qohosplugincore.h

Go to the documentation of this file.

// Copyright (C) 2026 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
 
#ifndef QOHOSPLUGINCORE_H
#define QOHOSPLUGINCORE_H
 
#include <QtCore/private/qcore_ohos_p.h>
#include <QtCore/private/qnapi_p.h>
#include <QtCore/private/qohoscommon_p.h>
#include <atomic>
#include <chrono>
#include <cstdlib>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <qohosqpaenums.h>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <vector>
 
QT_BEGIN_NAMESPACE
 
namespace QtOhos {
 
class JsWindowsTracker
{
public:
    static void tagWindowAsClosing(QNapi::Object jsWindow, const char *logContext);
    static bool isWindowClosing(QNapi::Object jsWindow);
 
    JsWindowsTracker() = delete;
};
 
class QAbilityPeer
{
public:
    virtual ~QAbilityPeer();
 
    virtual std::string instanceId() = 0;
    virtual QNapi::Object uiContext() = 0;
    virtual QNapi::Object qAbility() = 0;
    virtual QNapi::Object launchWant() = 0;
    virtual QObjectThreadSafeRef qWindowRef() = 0;
    virtual std::optional<QNapi::Promise> qWindowDestroyPromise() = 0;
    virtual void forceResolveQWindowDestroyPromiseIfPresent(Napi::Env env) = 0;
    virtual std::shared_ptr<std::atomic_bool> destroyAllowedFlag() = 0;
 
    virtual void setQWindow(Napi::Env env, QObjectThreadSafeRef qwindow) = 0;
 
    virtual void *tryCastWithTypeIdObject(const void *matchTypeIdObject) = 0;
 
protected:
    QAbilityPeer();
};
 
class JsState;
 
class AppFunctions
{
public:
    virtual ~AppFunctions();
 
    virtual void startAppProcess(
        QNapi::Object baseQAbility, const std::string &processId, QNapi::Object want,
        QNapi::Object optStartOptions, std::function<void(JsState &)> continueFunc) = 0;
 
    virtual void startNoUiChildProcess(JsState &jsState, const std::string &libraryName, const std::vector<std::string> &args) = 0;
};
 
enum class QtRunMode
{
    Normal,
    NoUiChildProcess,
};
 
class JsState : public QOhosJsState
{
public:
    static JsState &castFrom(QOhosJsState &jsState);
 
    JsState(const JsState &) = delete;
    JsState &operator=(const JsState &) = delete;
 
    ~JsState() override;
 
    virtual QtRunMode qtRunMode() = 0;
 
    template<typename T>
    QNapi::Symbol getJsSymbolForType();
 
protected:
    JsState();
 
private:
    virtual QNapi::Symbol getJsSymbolForType(const std::type_info &typeInfo) = 0;
};
 
using QOhosAbilityOnContinueResult = QtOhosQpa::enums::ohos::app::ability::AbilityConstant::OnContinueResult;
 
class QUiAbilityPeer : public virtual QAbilityPeer, public std::enable_shared_from_this<QUiAbilityPeer>
{
public:
    static std::shared_ptr<QUiAbilityPeer> tryCastFromQAbilityPeerOrNull(std::shared_ptr<QAbilityPeer> qAbilityPeer);
 
    ~QUiAbilityPeer() override;
 
    virtual QNapi::Object launchParam() = 0;
 
    virtual QNapi::Object windowStage() = 0;
    virtual QNapi::Object window() = 0;
 
    virtual void setOnContinueRequestsHandler(
        std::function<void(JsState &, QNapi::Object, QOhosConsumer<JsState &, QOhosAbilityOnContinueResult>)> requestsHandler) = 0;
 
protected:
    QUiAbilityPeer();
 
private:
    static const nullptr_t typeIdObject;
 
    void *tryCastWithTypeIdObject(const void *matchTypeIdObject) final;
};
 
class CallbackInfo : public ::QOhosCallbackInfo
{
public:
    using ::QOhosCallbackInfo::QOhosCallbackInfo;
 
    JsState &jsState() const;
};
 
std::vector<std::string> predefinedJsModuleNames();
 
// this function should be called once from JS thread at some point during startup
void initJsThreadState(
    napi_env env, std::map<std::string, QNapi::Reference<QNapi::Function>> &&jsModulesFactories,
    std::shared_ptr<AppFunctions> appFunctions, QtRunMode qtRunMode);
 
// returns true iff the calling thread is the JS thread
bool isJsThread();
 
// this function should be called from JS thread when new Want object is received
void dispatchNewWant(QNapi::Object qAbility, QNapi::Object want, QNapi::Object launchParam);
 
// Invokes the task inside the Qt thread and blocks the caller's thread until either:
//  - the "continue" function (std::function<void()>, passed as second argument to
//    the task) is called on the Qt side and returns,
//  - timeout occurs (we don't receive response from the finished task within the
//    specified time limit),
//  - deadlock is detected (both Qt and JS thread use synchronous calls at the same
//    time).
// It can be called from the JS thread. Calling it from the Qt thread is illegal.
//
// Returns true iff the caller receives confirmation about finishing the task within
// the time limit.
//
// Note:
// If the function returns false then:
//   - either the task wasn't started at all (timeout or deadlock)
//   - or the task was still running (and may be still running!) in the Qt thread
// after reaching the timeout.
Q_REQUIRED_RESULT bool tryInvokeInQtThreadAndTryWaitForContinue(
    std::function<void(std::function<void()>)> &&task,
    std::chrono::nanoseconds timeout);
 
template<typename T>
QNapi::Symbol JsState::getJsSymbolForType()
{
    return getJsSymbolForType(typeid(T));
}
 
}
 
QT_END_NAMESPACE
 
#endif