qohosstatusbarmenu.cpp

Go to the documentation of this file.

// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qohosstatusbarmenu.h"
#include "qohosjsutils.h"
#include "qohospixelmapconversions.h"
#include <QtCore/qobject.h>
#include <QtCore/qlist.h>
#include <QtGui/qicon.h>
#include <QtGui/qwindow.h>
#include <atomic>
#include <cstdint>
#include <optional>
#include <qohosjsscopedataowner.h>
#include <qpa/qplatformtheme.h>
#include <string>
 
QT_BEGIN_NAMESPACE
 
namespace {
 
constexpr QSize defaultStatusBarMenuItemIconSize(48, 48);
 
std::shared_ptr<void> registerOhosRightMenuClickListener(
    QOhosJsState &jsState, QOhosConsumer<std::string> clickedMenuCodeConsumer)
{
   return registerQOhosOnOffMethodsBasedEventHandler(
       jsState.eval<QNapi::Object>("@kit.StatusBarExtensionKit.statusBarManager"),
       "rightMenuClick",
       [clickedMenuCodeConsumer = std::move(clickedMenuCodeConsumer)](const QOhosCallbackInfo &info) {
            auto eventData = info.getFirstArg<QNapi::Object>(Q_FUNC_INFO);
            auto optMenuCode = QNapi::getOptionalPropOrEmpty<QNapi::String>(
                QNapi::getOptionalPropOrEmpty<QNapi::Object>(eventData, "data"),
                "menuCode");
            if (!optMenuCode.IsEmpty()) {
                clickedMenuCodeConsumer(optMenuCode);
            } else {
                qOhosPrintfDebug(
                    "%s: no 'menuCode' in the event (%s), ignoring it",
                    Q_FUNC_INFO, QNapi::toJsonString(eventData).c_str());
            }
       });
}
 
std::optional<QNapi::Object> makeJsStatusBarItemIcon(
    QOhosJsState &jsState, const QIcon &icon, const QSize &iconSize)
{
    if (icon.isNull())
        return std::nullopt;
 
    QImage iconImage = icon.pixmap(iconSize).toImage();
    if (iconImage.isNull())
        return std::nullopt;
 
    auto *env = jsState.env();
    auto menuIcon =
        makeDisplayDensityScaledJsPixelMapFromQImage(jsState, iconImage);
 
    auto imageSize = menuIcon.eval<QNapi::Object>("getImageInfoSync().size");
 
    int imageWidth = imageSize.get<QNapi::Number>("width");
    int imageHeight = imageSize.get<QNapi::Number>("height");
    qOhosPrintfDebug("%s: created PixelMap size: %dx%d", Q_FUNC_INFO, imageWidth, imageHeight);
 
    return QNapi::makeObject(
        env,
        {
            {"white", menuIcon},
            {"black", menuIcon},
        });
}
 
std::optional<QNapi::Object> makeJsStatusBarMenuItemOptions(
    QOhosJsState &jsState, const QIcon &icon, const QSize &iconSize)
{
    auto itemIcon = makeJsStatusBarItemIcon(jsState, icon, iconSize);
    if (!itemIcon)
        return std::nullopt;
 
    return QNapi::makeObject(
        jsState.env(),
        {
            {"icon", *itemIcon},
        });
}
 
QNapi::Object makeNotifyOnlyJsStatusBarMenuAction(
    QOhosJsState &jsState, const std::string &menuCode)
{
    return QNapi::makeObject(
        jsState.env(),
        {
            {"abilityName", "invalidAbility"},
            {"notifyOnly", true},
            {"menuCode", menuCode},
        });
}
 
QNapi::Object makeJsStatusBarMenuItemWithAction(
    QOhosJsState &jsState, const std::string &title, const std::string &menuCode,
    const QIcon &icon, const QSize &iconSize)
{
    auto statusBarMenuItem = QNapi::makeObject(
        jsState.env(),
        {
            {"title", title},
            {"menuAction", makeNotifyOnlyJsStatusBarMenuAction(jsState, menuCode)},
        });
 
    if (auto options = makeJsStatusBarMenuItemOptions(jsState, icon, iconSize))
        statusBarMenuItem.set("options", *options);
 
    return statusBarMenuItem;
}
 
QNapi::Object makeJsStatusBarMenuItemWithSubMenu(
    QOhosJsState &jsState, const std::string &title, QNapi::Array jsStatusBarSubMenuItems,
    const QIcon &icon, const QSize &iconSize)
{
    auto statusBarMenuItem = QNapi::makeObject(
        jsState.env(),
        {
            {"title", title},
            {"subMenu", jsStatusBarSubMenuItems},
        });
 
    if (auto options = makeJsStatusBarMenuItemOptions(jsState, icon, iconSize))
        statusBarMenuItem.set("options", *options);
 
    return statusBarMenuItem;
}
 
QNapi::Object makeJsStatusBarSubMenuItem(
    QOhosJsState &jsState, const std::string &subTitle, const std::string &menuCode,
    const QIcon &icon, const QSize &iconSize)
{
    auto statusBarSubMenuItem = QNapi::makeObject(
        jsState.env(),
        {
            {"subTitle", subTitle},
            {"menuAction", makeNotifyOnlyJsStatusBarMenuAction(jsState, menuCode)},
        });
 
    if (auto options = makeJsStatusBarMenuItemOptions(jsState, icon, iconSize))
        statusBarSubMenuItem.set("options", *options);
 
    return statusBarSubMenuItem;
}
 
class QOhosStatusBarMenuImpl;
 
class QOhosStatusBarMenuItem : public QPlatformMenuItem
{
    Q_OBJECT
 
public:
    QOhosStatusBarMenuItem();
 
    void setText(const QString &text) override;
    QString text() const;
    void setIcon(const QIcon &icon) override;
 
    void setMenu(QPlatformMenu *menu) override;
 
    void setVisible(bool isVisible) override;
    void setIsSeparator(bool isSeparator) override;
    void setFont(const QFont &font) override;
    void setRole(MenuRole role) override;
    void setCheckable(bool checkable) override;
    void setChecked(bool isChecked) override;
    void setShortcut(const QKeySequence &shortcut) override;
    void setEnabled(bool enabled) override;
    void setIconSize(int size) override;
 
    std::string menuCode() const;
 
    std::function<std::optional<QNapi::Object>(QOhosJsState &)> makeJsStatusBarMenuItemFactory() const;
    std::function<std::optional<QNapi::Object>(QOhosJsState &)> makeJsStatusBarSubMenuItemFactory() const;
 
private:
    QString m_text;
    std::string m_menuCode;
    QIcon m_icon;
    bool m_isSeparator = false;
    QOhosStatusBarMenuImpl *m_menu = nullptr;
 
    static std::string generateNextMenuCode();
};
 
class QOhosStatusBarMenuImpl : public QOhosStatusBarMenu
{
    Q_OBJECT
 
public:
    QOhosStatusBarMenuImpl();
 
    void insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *before) override;
    void removeMenuItem(QPlatformMenuItem *menuItem) override;
    void syncMenuItem(QPlatformMenuItem *menuItem) override;
    void syncSeparatorsCollapsible(bool enable) override;
 
    void setText(const QString &text) override;
    void setIcon(const QIcon &icon) override;
    void setEnabled(bool enabled) override;
    void setVisible(bool visible) override;
 
    void showPopup(const QWindow *parentWindow, const QRect &targetRect, const QPlatformMenuItem *item) override;
    void dismiss() override;
 
    QPlatformMenuItem *menuItemAt(int position) const override;
    QPlatformMenuItem *menuItemForTag(quintptr tag) const override;
 
    QPlatformMenuItem *createMenuItem() const override;
    QPlatformMenu *createSubMenu() const override;
 
    std::function<QNapi::Array(QOhosJsState &)> makeJsStatusBarGroupMenusFactory() const override;
 
    std::function<QNapi::Array(QOhosJsState &)> makeJsStatusBarSubMenuItemsFactory() const;
 
private:
    QPlatformMenuItem *findItemByMenuCode(const std::string &menuCode) const;
    void handleRightClickEvent(const std::string &menuCode);
 
    QString m_text;
    QList<QPlatformMenuItem *> m_menuItems;
 
    struct JsScopeData
    {
        std::shared_ptr<void> m_rightMenuClickListenerHandle;
    };
 
    QtOhos::JsScopeDataOwner<JsScopeData> m_jsScopeData;
};
 
QOhosStatusBarMenuItem::QOhosStatusBarMenuItem()
    : QPlatformMenuItem()
    , m_menuCode(generateNextMenuCode())
{
}
 
void QOhosStatusBarMenuItem::setText(const QString &text)
{
    m_text = text;
}
 
QString QOhosStatusBarMenuItem::text() const
{
    return m_text;
}
 
void QOhosStatusBarMenuItem::setIcon(const QIcon &icon)
{
    m_icon = icon;
}
 
void QOhosStatusBarMenuItem::setMenu(QPlatformMenu *menu)
{
    auto *ohosMenu = qobject_cast<QOhosStatusBarMenuImpl *>(menu);
    if (menu != nullptr && ohosMenu == nullptr)
        qOhosPrintfWarning("%s: got menu object of incompatible type", Q_FUNC_INFO);
 
    m_menu = ohosMenu;
}
 
void QOhosStatusBarMenuItem::setVisible(bool isVisible)
{
    Q_UNUSED(isVisible);
}
 
void QOhosStatusBarMenuItem::setIsSeparator(bool isSeparator)
{
    m_isSeparator = isSeparator;
}
 
void QOhosStatusBarMenuItem::setFont(const QFont &font)
{
    Q_UNUSED(font);
}
 
void QOhosStatusBarMenuItem::setRole(MenuRole role)
{
    Q_UNUSED(role);
}
 
void QOhosStatusBarMenuItem::setCheckable(bool checkable)
{
    Q_UNUSED(checkable);
}
 
void QOhosStatusBarMenuItem::setChecked(bool isChecked)
{
    Q_UNUSED(isChecked);
}
 
void QOhosStatusBarMenuItem::setShortcut(const QKeySequence &shortcut)
{
    Q_UNUSED(shortcut);
}
 
void QOhosStatusBarMenuItem::setEnabled(bool enabled)
{
    Q_UNUSED(enabled);
}
 
void QOhosStatusBarMenuItem::setIconSize(int size)
{
    Q_UNUSED(size);
}
 
std::string QOhosStatusBarMenuItem::menuCode() const
{
    return m_menuCode;
}
 
std::function<std::optional<QNapi::Object>(QOhosJsState &)> QOhosStatusBarMenuItem::makeJsStatusBarMenuItemFactory() const
{
    if (m_isSeparator) {
        return [](QOhosJsState &) {
            return std::optional<QNapi::Object>();
        };
    }
 
    auto title = QPlatformTheme::removeMnemonics(m_text).toStdString();
 
    if (m_menu == nullptr) {
        return [title, menuCode = m_menuCode, icon = m_icon](QOhosJsState &jsState) {
            return std::optional(
                makeJsStatusBarMenuItemWithAction(
                    jsState, title, menuCode, icon, defaultStatusBarMenuItemIconSize));
        };
    } else {
        return [title, jsSubMenuItemsFactory = m_menu->makeJsStatusBarSubMenuItemsFactory(),
                icon = m_icon](QOhosJsState &jsState) {
            return std::optional(
                makeJsStatusBarMenuItemWithSubMenu(
                    jsState, title, jsSubMenuItemsFactory(jsState), icon, defaultStatusBarMenuItemIconSize));
        };
    }
}
 
std::function<std::optional<QNapi::Object>(QOhosJsState &)> QOhosStatusBarMenuItem::makeJsStatusBarSubMenuItemFactory() const
{
    if (m_isSeparator) {
        qOhosPrintfWarning(
            "%s: separator item %p used in sub-menu, which is unsupported on OHOS, ignoring",
            Q_FUNC_INFO, this);
        return [](QOhosJsState &) {
            return std::optional<QNapi::Object>();
        };
    }
 
    if (m_menu != nullptr) {
        qOhosPrintfWarning(
            "%s: nested-menu item %p used in sub-menu, which is unsupported on OHOS, ignoring",
            Q_FUNC_INFO, this);
        return [](QOhosJsState &) {
            return std::optional<QNapi::Object>();
        };
    }
 
    auto subTitle = QPlatformTheme::removeMnemonics(m_text).toStdString();
 
    return [subTitle, menuCode = m_menuCode, icon = m_icon](QOhosJsState &jsState) {
        return std::optional(
            makeJsStatusBarSubMenuItem(
                jsState, subTitle, menuCode, icon, defaultStatusBarMenuItemIconSize));
    };
}
 
std::string QOhosStatusBarMenuItem::generateNextMenuCode()
{
    static std::atomic<std::uint64_t> menuCodeCounter(0);
 
    auto counterValue = ++menuCodeCounter;
    return std::to_string(counterValue);
}
 
QOhosStatusBarMenuImpl::QOhosStatusBarMenuImpl()
    : QOhosStatusBarMenu()
{
    auto selfRef = QtOhos::makeQThreadSafeRef(this);
    QOhosJsThreadGateway::runAndWait(
        [&](QOhosJsState &jsState) {
            *m_jsScopeData = JsScopeData {
                .m_rightMenuClickListenerHandle = registerOhosRightMenuClickListener(
                    jsState,
                    [selfRef](std::string menuCode) {
                        selfRef.visitInQtThreadIfAlive(
                            [menuCode](auto &self) {
                                self.handleRightClickEvent(menuCode);
                            });
                    }),
            };
        },
        Q_FUNC_INFO);
}
 
void QOhosStatusBarMenuImpl::insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *before)
{
    if (menuItem == nullptr)
        return;
 
    if (before == nullptr) {
        m_menuItems.append(menuItem);
        return;
    }
 
    const int idx = m_menuItems.indexOf(before);
    if (idx >= 0)
        m_menuItems.insert(idx, menuItem);
    else
        m_menuItems.append(menuItem);
}
 
void QOhosStatusBarMenuImpl::removeMenuItem(QPlatformMenuItem *menuItem)
{
    if (menuItem == nullptr)
        return;
    m_menuItems.removeAll(menuItem);
}
 
void QOhosStatusBarMenuImpl::syncMenuItem(QPlatformMenuItem *menuItem)
{
    Q_UNUSED(menuItem);
}
 
void QOhosStatusBarMenuImpl::syncSeparatorsCollapsible(bool enable)
{
    Q_UNUSED(enable);
}
 
void QOhosStatusBarMenuImpl::setText(const QString &text)
{
    m_text = text;
}
 
void QOhosStatusBarMenuImpl::setIcon(const QIcon &icon)
{
    Q_UNUSED(icon);
}
 
void QOhosStatusBarMenuImpl::setEnabled(bool enabled)
{
    Q_UNUSED(enabled);
}
 
void QOhosStatusBarMenuImpl::setVisible(bool visible)
{
    Q_UNUSED(visible);
}
 
void QOhosStatusBarMenuImpl::showPopup(const QWindow *parentWindow, const QRect &targetRect, const QPlatformMenuItem *item)
{
    Q_UNUSED(parentWindow);
    Q_UNUSED(targetRect);
    Q_UNUSED(item);
}
 
void QOhosStatusBarMenuImpl::dismiss()
{
}
 
QPlatformMenuItem *QOhosStatusBarMenuImpl::menuItemAt(int position) const
{
    if (position < 0 || position >= m_menuItems.size())
        return nullptr;
    return m_menuItems.at(position);
}
 
QPlatformMenuItem *QOhosStatusBarMenuImpl::menuItemForTag(quintptr tag) const
{
    for (auto *item : m_menuItems) {
        if (item && item->tag() == tag)
            return item;
    }
    return nullptr;
}
 
QPlatformMenuItem *QOhosStatusBarMenuImpl::createMenuItem() const
{
    return new QOhosStatusBarMenuItem();
}
 
QPlatformMenu *QOhosStatusBarMenuImpl::createSubMenu() const
{
    return new QOhosStatusBarMenuImpl();
}
 
std::function<QNapi::Array(QOhosJsState &)> QOhosStatusBarMenuImpl::makeJsStatusBarGroupMenusFactory() const
{
    std::vector<std::function<std::optional<QNapi::Object>(QOhosJsState &)>> jsMenuItemsFactories;
    for (auto *item : m_menuItems) {
        auto *ohosItem = qobject_cast<QOhosStatusBarMenuItem *>(item);
        jsMenuItemsFactories.push_back(
            ohosItem != nullptr
                ? ohosItem->makeJsStatusBarMenuItemFactory()
                : [](QOhosJsState &) {
                    return std::optional<QNapi::Object>();
                });
    }
 
    return [jsMenuItemsFactories = std::move(jsMenuItemsFactories)](QOhosJsState &jsState) {
        std::vector<QNapi::ValueWrapper> jsGroupMenusArray;
 
        std::vector<QNapi::ValueWrapper> currentJsMenuItemsArray;
 
        for (const auto &jsMenuItemFactory : jsMenuItemsFactories) {
            std::optional<QNapi::Object> optJsMenuItem = jsMenuItemFactory(jsState);
            if (optJsMenuItem.has_value()) {
                currentJsMenuItemsArray.push_back(optJsMenuItem.value());
            } else {
                jsGroupMenusArray.push_back(QNapi::makeArray(jsState.env(), currentJsMenuItemsArray));
                currentJsMenuItemsArray.clear();
            }
        }
 
        jsGroupMenusArray.push_back(QNapi::makeArray(jsState.env(), currentJsMenuItemsArray));
        currentJsMenuItemsArray.clear();
 
        return QNapi::makeArray(jsState.env(), jsGroupMenusArray);
    };
}
 
std::function<QNapi::Array(QOhosJsState &)> QOhosStatusBarMenuImpl::makeJsStatusBarSubMenuItemsFactory() const
{
    std::vector<std::function<std::optional<QNapi::Object>(QOhosJsState &)>> jsSubMenuItemsFactories;
    for (auto *item : m_menuItems) {
        auto *ohosItem = qobject_cast<QOhosStatusBarMenuItem *>(item);
        if (ohosItem != nullptr)
            jsSubMenuItemsFactories.push_back(ohosItem->makeJsStatusBarSubMenuItemFactory());
    }
 
    return [jsSubMenuItemsFactories = std::move(jsSubMenuItemsFactories)](QOhosJsState &jsState) {
        std::vector<QNapi::ValueWrapper> jsSubMenuItems;
        for (const auto &jsSubMenuItemsFactory : jsSubMenuItemsFactories) {
            std::optional<QNapi::Object> optJsSubMenuItem = jsSubMenuItemsFactory(jsState);
            if (optJsSubMenuItem.has_value())
                jsSubMenuItems.push_back(optJsSubMenuItem.value());
        }
        return QNapi::makeArray(jsState.env(), jsSubMenuItems);
    };
}
 
QPlatformMenuItem *QOhosStatusBarMenuImpl::findItemByMenuCode(const std::string &menuCode) const
{
    for (auto *item : m_menuItems) {
        auto *ohosItem = qobject_cast<QOhosStatusBarMenuItem *>(item);
        if (ohosItem != nullptr && ohosItem->menuCode() == menuCode)
            return item;
    }
    return nullptr;
}
 
void QOhosStatusBarMenuImpl::handleRightClickEvent(const std::string &menuCode)
{
    QPlatformMenuItem *item = findItemByMenuCode(menuCode);
    if (item == nullptr) {
        qOhosPrintfWarning("%s: Menu item with code '%s' not found", Q_FUNC_INFO, menuCode.c_str());
        return;
    }
 
    QOhosStatusBarMenuItem *ohosItem = qobject_cast<QOhosStatusBarMenuItem *>(item);
    if (ohosItem != nullptr)
        Q_EMIT ohosItem->activated();
}
 
}
 
QOhosStatusBarMenu::QOhosStatusBarMenu() = default;
 
std::unique_ptr<QOhosStatusBarMenu> makeQOhosStatusBarMenu()
{
    return std::make_unique<QOhosStatusBarMenuImpl>();
}
 
QT_END_NAMESPACE
 
#include "qohosstatusbarmenu.moc"