qohosqabilityinstancesmanager.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 "qohosqabilityinstancesmanager.h"
#include <QtCore/private/qnapi_p.h>
#include <QtCore/private/qohoslogger_p.h>
#include <QtCore/qcryptographichash.h>
#include <QtGui/qwindow.h>
#include <algorithm>
#include <chrono>
#include <cstdint>
#include <cstring>
#include <map>
#include <qohosdeviceinfo_p.h>
#include <qohosjsutils.h>
#include <qohosplatformwindow.h>
#include <render/qohosview.h>
#include <typeindex>
#include <unistd.h>
 
#include "qohoscloseeventcontext_p.h"
 
QT_BEGIN_NAMESPACE
 
using namespace std::chrono_literals;
 
namespace QtOhos {
 
namespace {
 
const auto qtInternalRequestIdWantParamKey = "io.qt.private.internalRequestId";
const auto qAbilityInstanceIdWantParamKey = "io.qt.private.abilityInstanceId";
const auto callerAbilityNameWantParamKey = "ohos.aafwk.param.callerAbilityName";
const auto callerBundleNameWantParamKey = "ohos.aafwk.param.callerBundleName";
const auto callerPidWantParamKey = "ohos.aafwk.param.callerPid";
 
std::string getUtf8QtInternalRequestIdForThisProcess()
{
    static const auto internalRequestIdCommonData =
        QByteArray::fromHex("eba08604c86e45ae3690621757b3f4e9");
 
    std::int32_t thisProcessPid = ::getpid();
 
    QCryptographicHash hash{QCryptographicHash::Sha1};
    hash.addData(internalRequestIdCommonData);
    hash.addData(QByteArray::number(thisProcessPid));
 
    return hash.result().toHex().toStdString();
}
 
QNapi::Symbol getAbilityLaunchParamPropSymbol(JsState &jsState)
{
    struct SymbolTag
    {
    };
 
    return jsState.getJsSymbolForType<SymbolTag>();
}
 
void sendWantToSelfQAbility(
    QNapi::Object baseQAbility, QNapi::Object optStartOptions, const std::string &instanceId,
    std::function<void(JsState &)> continueFunc)
{
    auto qAbilityInfo = QAbilityInstancesManager::readAbilityInfo(baseQAbility);
 
    std::vector<QNapi::ValueWrapper> startAbilityArgs = {
        QNapi::makeObject(
            baseQAbility.Env(),
            {
                {"bundleName", qAbilityInfo.bundleName},
                {"moduleName", qAbilityInfo.moduleName},
                {"abilityName", qAbilityInfo.name},
                {
                    "parameters",
                    QNapi::makeObject(
                        baseQAbility.Env(),
                        {
                            {qtInternalRequestIdWantParamKey, getUtf8QtInternalRequestIdForThisProcess()},
                            {qAbilityInstanceIdWantParamKey, instanceId},
                        })
                },
            }),
    };
 
    if (!optStartOptions.IsEmpty())
        startAbilityArgs.push_back(optStartOptions);
 
    baseQAbility.evalToPromiseOrRejectOnThrow("context.startAbility(*)", startAbilityArgs)
    .onCatch(
        [instanceId](const CallbackInfo &cbInfo) {
            logJsCallbackError(cbInfo, "context.startAbility()");
            qOhosReportFatalErrorAndAbort("Failed to start the Ability with instance id: %s", instanceId.c_str());
        })
    .onFinally(
        [continueFunc = std::move(continueFunc)](const CallbackInfo &cbInfo) {
            continueFunc(cbInfo.jsState());
        });
}
 
QOhosSupplier<std::string> makeAbilityInstanceIdsGenerator()
{
    return [idsCounter = std::uint64_t(0)]() mutable {
        auto instanceId = std::to_string(idsCounter);
        ++idsCounter;
        return instanceId;
    };
}
 
class DummyQAbilityPeer : public QAbilityPeer
{
public:
    DummyQAbilityPeer() = default;
 
    std::string instanceId() override;
    QNapi::Object uiContext() override;
    QNapi::Object qAbility() override;
    QNapi::Object launchWant() override;
    QObjectThreadSafeRef qWindowRef() override;
    std::optional<QNapi::Promise> qWindowDestroyPromise() override;
    void forceResolveQWindowDestroyPromiseIfPresent(Napi::Env env) override;
    std::shared_ptr<std::atomic_bool> destroyAllowedFlag() override;
 
    void setQWindow(Napi::Env env, QObjectThreadSafeRef) override;
 
    void *tryCastWithTypeIdObject(const void *matchTypeIdObject) override;
};
 
std::string DummyQAbilityPeer::instanceId()
{
    return {};
}
 
QNapi::Object DummyQAbilityPeer::uiContext()
{
    return QNapi::Object();
}
 
QNapi::Object DummyQAbilityPeer::qAbility()
{
    return QNapi::Object();
}
 
QNapi::Object DummyQAbilityPeer::launchWant()
{
    return QNapi::Object();
}
 
QObjectThreadSafeRef DummyQAbilityPeer::qWindowRef()
{
    return {};
}
 
std::optional<QNapi::Promise> DummyQAbilityPeer::qWindowDestroyPromise()
{
    return std::nullopt;
}
 
void DummyQAbilityPeer::forceResolveQWindowDestroyPromiseIfPresent(Napi::Env)
{
}
 
std::shared_ptr<std::atomic_bool> DummyQAbilityPeer::destroyAllowedFlag()
{
    return std::make_shared<std::atomic_bool>(false);
}
 
void DummyQAbilityPeer::setQWindow(Napi::Env, QObjectThreadSafeRef)
{
}
 
void *DummyQAbilityPeer::tryCastWithTypeIdObject(const void *)
{
    return nullptr;
}
 
class QAbilityPeerImpl : public virtual QAbilityPeer
{
public:
    QAbilityPeerImpl(
        JsState &jsState, std::string instanceId, QObjectThreadSafeRef qwindow,
        QNapi::Object uiAbility);
 
    ~QAbilityPeerImpl() = default;
 
    std::string instanceId() final;
    QNapi::Object qAbility() final;
    QObjectThreadSafeRef qWindowRef() final;
    std::optional<QNapi::Promise> qWindowDestroyPromise() final;
    void forceResolveQWindowDestroyPromiseIfPresent(Napi::Env env) final;
    std::shared_ptr<std::atomic_bool> destroyAllowedFlag() final;
 
    void setQWindow(Napi::Env env, QObjectThreadSafeRef qwindow) final;
 
private:
    struct QWindowDestroyPromiseData
    {
        std::optional<QNapi::Promise::Deferred> deferred;
        QNapi::Reference<QNapi::Promise> promise;
    };
 
    std::string m_instanceId;
    QObjectThreadSafeRef m_qwindow;
    std::shared_ptr<QWindowDestroyPromiseData> m_optQWindowDestroyPromiseData;
    std::shared_ptr<std::atomic_bool> m_destroyAllowedFlag;
    QNapi::Reference<QNapi::Object> m_uiAbility;
};
 
QAbilityPeerImpl::QAbilityPeerImpl(
    JsState &, std::string instanceId, QObjectThreadSafeRef qwindow,
    QNapi::Object uiAbility)
    : m_instanceId(std::move(instanceId))
    , m_destroyAllowedFlag(std::make_shared<std::atomic_bool>(false))
    , m_uiAbility(Napi::Persistent(uiAbility))
{
    setQWindow(uiAbility.Env(), qwindow);
}
 
std::string QAbilityPeerImpl::instanceId()
{
    return m_instanceId;
}
 
QNapi::Object QAbilityPeerImpl::qAbility()
{
    return m_uiAbility.Value();
}
 
QObjectThreadSafeRef QAbilityPeerImpl::qWindowRef()
{
    return m_qwindow;
}
 
std::optional<QNapi::Promise> QAbilityPeerImpl::qWindowDestroyPromise()
{
    if (!m_optQWindowDestroyPromiseData || m_optQWindowDestroyPromiseData->promise.IsEmpty())
        return std::nullopt;
 
    auto promiseValue = m_optQWindowDestroyPromiseData->promise.Value();
    m_optQWindowDestroyPromiseData->promise.Reset();
 
    return promiseValue;
}
 
void QAbilityPeerImpl::forceResolveQWindowDestroyPromiseIfPresent(Napi::Env env)
{
    if (!m_optQWindowDestroyPromiseData || !m_optQWindowDestroyPromiseData->deferred)
        return;
 
    qOhosPrintfInfo(
        "%s: force-resolving QWindow destroy Promise for id='%s'",
        Q_FUNC_INFO, m_instanceId.c_str());
    std::exchange(m_optQWindowDestroyPromiseData->deferred, std::nullopt)->Resolve(env.Undefined());
}
 
std::shared_ptr<std::atomic_bool> QAbilityPeerImpl::destroyAllowedFlag()
{
    return m_destroyAllowedFlag;
}
 
void QAbilityPeerImpl::setQWindow(Napi::Env env, QObjectThreadSafeRef qwindow)
{
    if (qwindow == m_qwindow)
        return;
 
    qOhosPrintfInfo(
        "%s: setting QAbilityPeer's QWindow: %s / %s",
        Q_FUNC_INFO, m_instanceId.c_str(), m_qwindow.refName().c_str());
 
    if (m_qwindow != QObjectThreadSafeRef()) {
        qOhosReportFatalErrorAndAbort(
            "QAbilityPeerImpl: overwriting previously set qwindow: %s => %s",
            m_qwindow.refName().c_str(), qwindow.refName().c_str());
    }
 
    m_qwindow = qwindow;
 
    auto qWindowDestroyPromiseDeferred = QNapi::Promise::Deferred::New(env);
    m_optQWindowDestroyPromiseData = std::make_shared<QWindowDestroyPromiseData>(
        QWindowDestroyPromiseData{
            .deferred = qWindowDestroyPromiseDeferred,
            .promise = QNapi::Reference<QNapi::Promise>::makePersistentFrom(
                qWindowDestroyPromiseDeferred.Promise()),
        });
 
    auto resolveQWindowDestroyPromiseFunc =
        [qWindowRef = qwindow, weakPromiseData = QtOhos::makeWeakPtr(m_optQWindowDestroyPromiseData)]() {
            qOhosPrintfDebug(
                "%s: sending request to resolve QWindow destroy notify Promise if needed: %s",
                Q_FUNC_INFO, qWindowRef.refName().c_str());
            QOhosJsThreadGateway::invoke(
                [qWindowRef, weakPromiseData](QOhosJsState &jsState) {
                    auto promiseData = weakPromiseData.lock();
                    if (promiseData && promiseData->deferred) {
                        qOhosPrintfDebug(
                            "%s: resolving QWindow destroy notify Promise: %s",
                            Q_FUNC_INFO, qWindowRef.refName().c_str());
                        auto napiUndefined = Napi::Env(jsState.env()).Undefined();
                        std::exchange(promiseData->deferred, std::nullopt)->Resolve(napiUndefined);
                    } else {
                        qOhosPrintfDebug(
                            "%s: QAbilityPeer already removed on QWindow's destroy notification: %s",
                            Q_FUNC_INFO, qWindowRef.refName().c_str());
                    }
                });
        };
 
    QtOhos::invokeInQtThread(
        [qWindowRef = qwindow, resolveQWindowDestroyPromiseFunc]() {
            auto *qWindow = static_cast<QWindow *>(qWindowRef.data().data());
            auto *platformWindow = qWindow != nullptr ? QOhosPlatformWindow::fromQWindowOrNull(qWindow) : nullptr;
            auto *view = platformWindow != nullptr ? platformWindow->ownedViewOrNull() : nullptr;
 
            if (view != nullptr) {
                qCDebug(
                    QtForOhos, "%s: connecting to QOhosView's 'destroyed', win: %s",
                    Q_FUNC_INFO, qWindowRef.refName().c_str());
                QObject::connect(
                    view, &QObject::destroyed,
                    [qWindowRef, resolveQWindowDestroyPromiseFunc](QObject *) {
                        qCDebug(
                            QtForOhos, "%s: got QOhosView's 'destroyed' signal, win: %s",
                            Q_FUNC_INFO, qWindowRef.refName().c_str());
                        resolveQWindowDestroyPromiseFunc();
                    });
            } else {
                qCDebug(
                    QtForOhos, "%s: QOhosView already destroyed, win: %s",
                    Q_FUNC_INFO, qWindowRef.refName().c_str());
                resolveQWindowDestroyPromiseFunc();
            }
        });
}
 
class QUiAbilityPeerImpl final : public virtual QUiAbilityPeer, public QAbilityPeerImpl, public QUiAbilityPeerBackend
{
public:
    QUiAbilityPeerImpl(
        JsState &jsState, std::string instanceId, QObjectThreadSafeRef qwindow,
        QNapi::Object uiAbility, QNapi::Object windowStage);
 
    QNapi::Object uiContext() override;
    QNapi::Object launchWant() override;
    QNapi::Object launchParam() override;
    QNapi::Object windowStage() override;
    QNapi::Object window() override;
 
    QNapi::Promise handleCloseRequestFromSystem(
        QOhosJsState &jsState, const std::string &logContextStr, CloseAbilityRequestSource requestSource,
        std::function<QNapi::Value(QOhosJsState &, CloseAbilityRequestResolution)> promiseValueFactory) override;
 
    void handleOnContinueRequestFromSystem(
        JsState &jsState, QNapi::Object wantParamsObj,
        QOhosConsumer<JsState &, QOhosAbilityOnContinueResult> resultConsumer) override;
 
    void setOnContinueRequestsHandler(
        std::function<void(JsState &, QNapi::Object, QOhosConsumer<JsState &, QOhosAbilityOnContinueResult>)> requestsHandler) override;
 
private:
    QNapi::Reference<QNapi::Object> m_windowStage;
    QNapi::Reference<QNapi::Object> m_window;
    QNapi::Reference<QNapi::Object> m_launchParam;
    std::shared_ptr<void> m_windowWillCloseCallbackHandle;
    std::function<void(JsState &, QNapi::Object, QOhosConsumer<JsState &, QOhosAbilityOnContinueResult>)> m_onContinueRequestsHandler;
};
 
QUiAbilityPeerImpl::QUiAbilityPeerImpl(
    JsState &jsState, std::string instanceId, QObjectThreadSafeRef qwindow,
    QNapi::Object uiAbility, QNapi::Object windowStage)
    : QAbilityPeerImpl(jsState, instanceId, qwindow, uiAbility)
    , m_windowStage(Napi::Persistent(windowStage))
    , m_window(Napi::Persistent(windowStage.eval<QNapi::Object>("getMainWindowSync()")))
{
    auto optLaunchParam = QNapi::getOptionalPropOrEmpty<QNapi::Object>(
        uiAbility, getAbilityLaunchParamPropSymbol(jsState));
    if (optLaunchParam.IsEmpty()) {
        qOhosReportFatalErrorAndAbort(
            "Ability with instanceId='%s' doesn't have 'launchParam' set. It shouldn't happen!",
            instanceId.c_str());
    }
    m_launchParam = QNapi::Reference<>::makePersistentFrom(optLaunchParam);
 
    m_windowWillCloseCallbackHandle = registerQOhosOnOffMethodsBasedEventHandler(
        window(), "windowWillClose",
        [this](const CallbackInfo &cbInfo) {
            JsState &jsState = cbInfo.jsState();
            return handleCloseRequestFromSystem(
                jsState, "Window.windowWillClose",
                CloseAbilityRequestSource::WindowWillClose,
                [](QOhosJsState &jsState, CloseAbilityRequestResolution ohosRequestResolution) {
                    return QNapi::Boolean::New(
                        jsState.env(),
                        ohosRequestResolution == CloseAbilityRequestResolution::DontClose);
                });
        },
        {
            .optEventSourceAliveCheckFunc =
                [qAbilityWeakRef = moveToSharedPtr(Napi::Weak(uiAbility))](QNapi::Object window) {
                    bool isWindowClosing = QOhosJsThreadGateway::eval(
                        [&](QOhosJsState &) {
                            return JsWindowsTracker::isWindowClosing(window);
                        },
                        Q_FUNC_INFO);
                    auto qAbilityValue = qAbilityWeakRef->Value();
                    return
                        !isWindowClosing
                        && qAbilityValue.IsObject()
                        && !QNapi::checkedCast<QNapi::Object>(qAbilityValue).eval<QNapi::Boolean>("context.isTerminating()");
                },
            .extraOnArg = {},
            .extraOffArg = {},
            .optOnCallExceptionHandler = [](const Napi::Error &error) {
                constexpr auto capabilityNotSupportedErrorCode = 801;
                QtOhos::rethrowUnlessJsBusinessErrorIs(
                    error, capabilityNotSupportedErrorCode, "on('windowWillClose')");
            },
        });
}
 
QNapi::Object QUiAbilityPeerImpl::uiContext()
{
    return window().eval<QNapi::Object>("getUIContext()");
}
 
QNapi::Object QUiAbilityPeerImpl::launchWant()
{
    return qAbility().get<QNapi::Object>("launchWant");
}
 
QNapi::Object QUiAbilityPeerImpl::launchParam()
{
    return m_launchParam.Value();
}
 
QNapi::Object QUiAbilityPeerImpl::windowStage()
{
    return m_windowStage.Value();
}
 
QNapi::Object QUiAbilityPeerImpl::window()
{
    return m_window.Value();
}
 
QOhosCloseEventContext::CloseRootCause mapCloseAbilityRequestSourceToRootCause(
    QUiAbilityPeerBackend::CloseAbilityRequestSource requestSource)
{
    using CloseAbilityRequestSource = QUiAbilityPeerBackend::CloseAbilityRequestSource;
    using CloseRootCause = QOhosCloseEventContext::CloseRootCause;
 
    switch (requestSource) {
    case CloseAbilityRequestSource::OnPrepareToTerminate:
        return CloseRootCause::OnPrepareToTerminate;
    case CloseAbilityRequestSource::WindowWillClose:
        return CloseRootCause::WindowStageClose;
    }
 
    qOhosReportFatalErrorAndAbort("Unsupported CloseAbilityRequestSource: %d", static_cast<int>(requestSource));
}
 
QNapi::Promise QUiAbilityPeerImpl::handleCloseRequestFromSystem(
    QOhosJsState &jsState, const std::string &logContextStr, CloseAbilityRequestSource requestSource,
    std::function<QNapi::Value(QOhosJsState &, CloseAbilityRequestResolution)> promiseValueFactory)
{
    auto instanceId = this->instanceId();
 
    qOhosPrintfInfo(
        "%s: got close request from source %d, id: '%s'",
        logContextStr.c_str(), static_cast<int>(requestSource), instanceId.c_str());
 
    if (destroyAllowedFlag()->load()) {
        qOhosPrintfDebug(
            "%s: resolving immediately with 'false', id: '%s'",
            Q_FUNC_INFO, instanceId.c_str());
        JsWindowsTracker::tagWindowAsClosing(
            window(), printfToString("%s => false", logContextStr.c_str()).c_str());
        return makeResolvedPromise(
            promiseValueFactory(jsState, CloseAbilityRequestResolution::Close));
    }
 
    struct PromiseResolveFuncContext
    {
        std::string logContextStr;
        std::weak_ptr<QUiAbilityPeer> weakQAbilityPeer;
        std::shared_ptr<QNapi::Promise::Deferred> promiseDeferred;
        std::string instanceId;
        std::function<QNapi::Value(QOhosJsState &, CloseAbilityRequestResolution)> promiseValueFactory;
    };
 
    auto promiseResolveFuncContext = moveToSharedPtr(
        PromiseResolveFuncContext{
            .logContextStr = logContextStr,
            .weakQAbilityPeer = makeWeakPtr(shared_from_this()),
            .promiseDeferred = std::make_shared<QNapi::Promise::Deferred>(jsState.env()),
            .instanceId = instanceId,
            .promiseValueFactory = std::move(promiseValueFactory),
        });
 
    auto promiseResolveFunc = moveToSharedPtr(
        makeCallOnceConsumerWrapper<QOhosJsState &, CloseAbilityRequestResolution>(
            [context = promiseResolveFuncContext](QOhosJsState &jsState, CloseAbilityRequestResolution ohosRequestResolution) {
                auto qAbilityPeer = context->weakQAbilityPeer.lock();
                if (qAbilityPeer && ohosRequestResolution == CloseAbilityRequestResolution::Close) {
                    JsWindowsTracker::tagWindowAsClosing(
                        qAbilityPeer->window(), printfToString("%s => false", context->logContextStr.c_str()).c_str());
                }
                context->promiseDeferred->Resolve(
                    context->promiseValueFactory(jsState, ohosRequestResolution));
                qOhosPrintfInfo(
                    "%s: promise resolved as %d, id: '%s'",
                    context->logContextStr.c_str(), static_cast<int>(ohosRequestResolution), context->instanceId.c_str());
            }));
 
    constexpr auto promiseAutoresolveTimeout = 9s;
    setJsTimeout(
        jsState,
        [logContextStr, promiseResolveFunc, instanceId](const QOhosCallbackInfo &cbInfo) {
            if ((*promiseResolveFunc)(cbInfo.jsState(), CloseAbilityRequestResolution::DontClose)) {
                qOhosPrintfInfo(
                    "%s: promise resolved by timeout, id: '%s'",
                    logContextStr.c_str(), instanceId.c_str());
            }
        },
        promiseAutoresolveTimeout);
 
    qWindowRef().visitInQtThreadIfAlive(
        [logContextStr, requestSource, promiseResolveFunc, instanceId](auto &qWindowObj) {
            qOhosPrintfInfo(
                "%s: calling close(), id: '%s'",
                logContextStr.c_str(), instanceId.c_str());
            QOhosCloseEventContext::runWithCloseRootCauseAndCloseResolutionConsumerSet(
                mapCloseAbilityRequestSourceToRootCause(requestSource),
                [logContextStr, promiseResolveFunc, instanceId](QOhosCloseEventContext::CloseResolution closeResolution) {
                    auto ohosRequestResolution =
                        closeResolution == QOhosCloseEventContext::CloseResolution::Close
                            ? CloseAbilityRequestResolution::Close
                            : CloseAbilityRequestResolution::DontClose;
                    qOhosPrintfInfo(
                        "%s: requesting promise resolve to %d from Qt thread, id: '%s'",
                        logContextStr.c_str(), static_cast<int>(ohosRequestResolution), instanceId.c_str());
                    QOhosJsThreadGateway::invoke(
                        [logContextStr, promiseResolveFunc, ohosRequestResolution, instanceId](QOhosJsState &jsState) {
                            bool resolveCalled = (*promiseResolveFunc)(jsState, ohosRequestResolution);
                            qOhosPrintfInfo(
                                "%s: promise resolve to %d, called: %s, id: '%s'",
                                logContextStr.c_str(), static_cast<int>(ohosRequestResolution),
                                mapBoolToTrueFalseStr(resolveCalled), instanceId.c_str());
                        });
                },
                [&]() {
                    static_cast<QWindow &>(qWindowObj).close();
                });
        });
 
    qOhosPrintfInfo("%s: returning Promise, id: '%s'", logContextStr.c_str(), instanceId.c_str());
 
    return promiseResolveFuncContext->promiseDeferred->Promise();
}
 
void QUiAbilityPeerImpl::handleOnContinueRequestFromSystem(
    JsState &jsState, QNapi::Object wantParamsObj, QOhosConsumer<JsState &, QOhosAbilityOnContinueResult> resultConsumer)
{
    if (m_onContinueRequestsHandler) {
        m_onContinueRequestsHandler(jsState, wantParamsObj, std::move(resultConsumer));
    } else {
        qOhosPrintfDebug("%s: no handler set, rejecting", Q_FUNC_INFO);
        QOhosJsThreadGateway::invoke(
            [resultConsumer = std::move(resultConsumer)](QOhosJsState &jsState) {
                resultConsumer(JsState::castFrom(jsState), QOhosAbilityOnContinueResult::REJECT);
            });
    }
}
 
void QUiAbilityPeerImpl::setOnContinueRequestsHandler(
    std::function<void(JsState &, QNapi::Object, QOhosConsumer<JsState &, QOhosAbilityOnContinueResult>)> requestsHandler)
{
    if (m_onContinueRequestsHandler) {
        qOhosReportFatalErrorAndAbort(
            "%s: overwriting previously set requests handler, id='%s'",
            Q_FUNC_INFO, instanceId().c_str());
    }
 
    m_onContinueRequestsHandler = std::move(requestsHandler);
}
 
bool isAbilityTerminating(QNapi::Object ability)
{
    try {
        return ability.eval<QNapi::Boolean>("context.isTerminating()");
    } catch (const Napi::Error &error) {
        qOhosPrintfWarning("context.isTerminating() failed (%s), assuming the Ability is terminating", error.what());
        return true;
    }
}
 
bool isAbilityPeerClosing(std::shared_ptr<QAbilityPeer> abilityPeer)
{
    auto optUiAbilityPeer = QUiAbilityPeer::tryCastFromQAbilityPeerOrNull(abilityPeer);
    return optUiAbilityPeer
        && (JsWindowsTracker::isWindowClosing(optUiAbilityPeer->window())
            || isAbilityTerminating(optUiAbilityPeer->qAbility()));
}
 
class QAbilityInstancesManagerImpl final : public QAbilityInstancesManager
{
public:
    QAbilityInstancesManagerImpl();
 
    QNapi::Object appLaunchWant() override;
    std::optional<QNapi::Object> optAppLaunchParam() override;
 
    std::shared_ptr<QAbilityPeer> defaultQAbilityPeer() override;
    std::shared_ptr<QAbilityPeer> tryGetQAbilityPeerByInstanceId(const std::string &instanceId) override;
    std::shared_ptr<QAbilityPeer> tryGetQAbilityPeerByInstance(QNapi::Object qAbility) override;
    std::shared_ptr<QAbilityPeer> tryGetQAbilityPeerByQWindow(QObjectThreadSafeRef qwindow) override;
 
    void visitEachQAbilityPeer(const std::function<void(std::shared_ptr<QAbilityPeer>)> &visitor) override;
 
    void removeMatchingQAbilityPeer(QNapi::Object qAbility) override;
 
    bool isWantFromThisApp(QNapi::Object appQAbility, QNapi::Object want) const override;
 
    std::optional<std::string> tryGetQAbilityInstanceIdFromWant(QNapi::Object appQAbility, QNapi::Object want) const override;
    std::string getQAbilityInstanceIdOrPendingAutoStartedId(QNapi::Object qAbility) const override;
 
    std::optional<std::string> pendingAutoStartedInstanceId() const override;
 
    void registerPendingAutoStartedInstance(
        std::function<void(JsState &, std::shared_ptr<QAbilityPeer>)> startupNotifyFunc) override;
 
    void startNewInstance(
        QNapi::Object baseQAbility, QObjectThreadSafeRef qwindow,
        QNapi::Object optStartOptions,
        std::function<void(JsState &, std::shared_ptr<QAbilityPeer>)> startupNotifyFunc) override;
 
    void handleStartedUiInstance(JsState &jsState, QNapi::Object qAbility, QNapi::Object windowStage) override;
 
    std::shared_ptr<QUiAbilityPeerBackend> getAbilityPeerBackend(std::shared_ptr<QUiAbilityPeer> uiAbilityPeer) override;
 
private:
    struct InstanceStartParams
    {
        QObjectThreadSafeRef qwindow;
        std::function<void(JsState &, std::shared_ptr<QAbilityPeer>)> startupNotifyFunc;
    };
 
    void handleStartedInstance(
        JsState &jsState, const std::string &abilityInstanceId,
        const std::function<std::shared_ptr<QAbilityPeer>(const std::string &, const InstanceStartParams &)> &qAbilityPeerFactory);
 
    void addQAbilityPeer(std::shared_ptr<QAbilityPeer> qAbilityPeer);
 
    template<typename PeerMatchFunc>
    std::shared_ptr<QAbilityPeer> tryFindMatchingQAbilityPeer(PeerMatchFunc &&matchFunc) const;
 
    QNapi::Reference<QNapi::Object> m_appLaunchWant;
    QNapi::Reference<QNapi::Object> m_optAppLaunchParam;
    std::shared_ptr<QAbilityPeer> m_defaultQAbilityPeer;
    std::map<std::string, std::shared_ptr<QAbilityPeer>> m_qAbilityPeers;
    std::shared_ptr<std::map<QUiAbilityPeer *, std::weak_ptr<QUiAbilityPeerImpl>>> m_ownedUiAbilityPeers;
    QOhosSupplier<std::string> m_abilityInstanceIdsGenerator;
    std::map<std::string, InstanceStartParams> m_pendingInstancesStartParams;
    std::optional<std::string> m_pendingAutoStartedInstanceId;
};
 
QAbilityInstancesManagerImpl::QAbilityInstancesManagerImpl()
    : m_defaultQAbilityPeer(std::make_shared<DummyQAbilityPeer>())
    , m_ownedUiAbilityPeers(std::make_shared<std::map<QUiAbilityPeer *, std::weak_ptr<QUiAbilityPeerImpl>>>())
    , m_abilityInstanceIdsGenerator(makeAbilityInstanceIdsGenerator())
{
}
 
QNapi::Object QAbilityInstancesManagerImpl::appLaunchWant()
{
    return m_appLaunchWant.Value();
}
 
std::optional<QNapi::Object> QAbilityInstancesManagerImpl::optAppLaunchParam()
{
    return !m_optAppLaunchParam.IsEmpty()
        ? std::optional(m_optAppLaunchParam.Value())
        : std::nullopt;
}
 
std::shared_ptr<QAbilityPeer> QAbilityInstancesManagerImpl::defaultQAbilityPeer()
{
    if (isAbilityPeerClosing(m_defaultQAbilityPeer)) {
        auto optLivePeer = tryFindMatchingQAbilityPeer(
            [](const auto &peer) {
                return !isAbilityPeerClosing(peer);
            });
        if (optLivePeer) {
            qOhosPrintfInfo(
                "%s: default Ability with instanceId='%s' is closing, switching to instanceId='%s'",
                Q_FUNC_INFO, m_defaultQAbilityPeer->instanceId().c_str(), optLivePeer->instanceId().c_str());
            m_defaultQAbilityPeer = optLivePeer;
        }
    }
 
    return m_defaultQAbilityPeer;
}
 
std::shared_ptr<QAbilityPeer> QAbilityInstancesManagerImpl::tryGetQAbilityPeerByInstanceId(const std::string &instanceId)
{
    auto foundIter = m_qAbilityPeers.find(instanceId);
    return foundIter != m_qAbilityPeers.end() ? foundIter->second : nullptr;
}
 
std::shared_ptr<QAbilityPeer> QAbilityInstancesManagerImpl::tryGetQAbilityPeerByInstance(QNapi::Object qAbility)
{
    Napi::HandleScope findPeerScope(qAbility.Env());
    return tryFindMatchingQAbilityPeer(
        [&](const auto &peer) {
            return peer->qAbility() == qAbility;
        });
}
 
std::shared_ptr<QAbilityPeer> QAbilityInstancesManagerImpl::tryGetQAbilityPeerByQWindow(QObjectThreadSafeRef qwindow)
{
    return tryFindMatchingQAbilityPeer(
        [&](const auto &peer) {
            return peer->qWindowRef() == qwindow;
        });
}
 
void QAbilityInstancesManagerImpl::visitEachQAbilityPeer(const std::function<void(std::shared_ptr<QAbilityPeer>)> &visitor)
{
    auto qAbilityPeersSnapshot = m_qAbilityPeers;
    for (const auto &qAbilityPeerEntry : qAbilityPeersSnapshot)
        visitor(qAbilityPeerEntry.second);
}
 
void QAbilityInstancesManagerImpl::removeMatchingQAbilityPeer(QNapi::Object qAbility)
{
    Napi::HandleScope funcScope{qAbility.Env()};
 
    auto foundPeerIter = std::find_if(
        m_qAbilityPeers.begin(), m_qAbilityPeers.end(),
        [&](const auto &entry) {
            return entry.second->qAbility() == qAbility;
        });
 
    if (foundPeerIter != m_qAbilityPeers.end()) {
        auto removedPeer = foundPeerIter->second;
        m_qAbilityPeers.erase(foundPeerIter);
        if (m_defaultQAbilityPeer == removedPeer) {
            m_defaultQAbilityPeer =
                !m_qAbilityPeers.empty()
                    ? m_qAbilityPeers.begin()->second
                    : std::make_shared<DummyQAbilityPeer>();
        }
        qOhosPrintfDebug(
            "%s: removed QAbilityPeer, instanceId: %s, qwindow: %s",
            Q_FUNC_INFO, removedPeer->instanceId().c_str(), removedPeer->qWindowRef().refName().c_str());
    }
}
 
std::optional<std::string> QAbilityInstancesManagerImpl::tryGetQAbilityInstanceIdFromWant(
    QNapi::Object appQAbility, QNapi::Object want) const
{
    auto wantParameters = QNapi::getPropOrUndefined(want, "parameters");
    if (wantParameters.IsUndefined())
        return std::nullopt;
 
    auto instanceIdParam = QNapi::getPropOrUndefined(wantParameters, qAbilityInstanceIdWantParamKey);
 
    bool validInstanceId = isWantFromThisApp(appQAbility, want) && instanceIdParam.IsString();
 
    return validInstanceId
        ? std::optional(QNapi::checkedCast<QNapi::String>(instanceIdParam).Utf8Value())
        : std::nullopt;
}
 
std::string QAbilityInstancesManagerImpl::getQAbilityInstanceIdOrPendingAutoStartedId(QNapi::Object qAbility) const
{
    auto optInstanceId = tryGetQAbilityInstanceIdFromWant(
        qAbility, qAbility.get<QNapi::Object>("launchWant"));
 
    if (!optInstanceId.has_value() && !m_pendingAutoStartedInstanceId.has_value()) {
        qOhosReportFatalErrorAndAbort(
            "Got Ability without '%s' param and no pending auto-started instance",
            qAbilityInstanceIdWantParamKey);
    }
 
    return optInstanceId.has_value()
        ? optInstanceId.value()
        : m_pendingAutoStartedInstanceId.value();
}
 
bool QAbilityInstancesManagerImpl::isWantFromThisApp(QNapi::Object appQAbility, QNapi::Object want) const
{
    auto wantParameters = QNapi::getPropOrUndefined(want, "parameters");
    if (wantParameters.IsUndefined())
        return false;
 
    auto callerAbilityNameParam = QNapi::getPropOrUndefined(wantParameters, callerAbilityNameWantParamKey);
    auto callerBundleNameParam = QNapi::getPropOrUndefined(wantParameters, callerBundleNameWantParamKey);
 
    auto appAbilityInfo = readAbilityInfo(appQAbility);
 
    return
        callerAbilityNameParam.IsString()
        && QNapi::checkedCast<QNapi::String>(callerAbilityNameParam).Utf8Value() == appAbilityInfo.name
        && callerBundleNameParam.IsString()
        && QNapi::checkedCast<QNapi::String>(callerBundleNameParam).Utf8Value() == appAbilityInfo.bundleName;
}
 
std::optional<std::string> QAbilityInstancesManagerImpl::pendingAutoStartedInstanceId() const
{
    return m_pendingAutoStartedInstanceId;
}
 
void QAbilityInstancesManagerImpl::registerPendingAutoStartedInstance(
    std::function<void(JsState &, std::shared_ptr<QAbilityPeer>)> startupNotifyFunc)
{
    if (m_pendingAutoStartedInstanceId.has_value()) {
        qOhosReportFatalErrorAndAbort(
            "%s: pending auto-started instance already registered (id='%s')",
            Q_FUNC_INFO, m_pendingAutoStartedInstanceId.value().c_str());
    }
 
    m_pendingAutoStartedInstanceId = m_abilityInstanceIdsGenerator();
 
    m_pendingInstancesStartParams.emplace(
        m_pendingAutoStartedInstanceId.value(),
        InstanceStartParams{
            .qwindow = QObjectThreadSafeRef(),
            .startupNotifyFunc = std::move(startupNotifyFunc),
        });
 
    qOhosPrintfInfo(
        "Registered pending auto-started Ability instance, id='%s'",
        m_pendingAutoStartedInstanceId.value().c_str());
}
 
void QAbilityInstancesManagerImpl::startNewInstance(
    QNapi::Object baseQAbility, QObjectThreadSafeRef qwindow,
    QNapi::Object optStartOptions,
    std::function<void(JsState &, std::shared_ptr<QAbilityPeer>)> startupNotifyFunc)
{
    struct Context
    {
        std::function<void(JsState &, std::shared_ptr<QAbilityPeer>)> startupNotifyFunc;
        bool sendWantFinished = false;
        std::shared_ptr<QAbilityPeer> optAbilityPeer;
 
        void callNotifyIfReady(JsState &jsState)
        {
            qOhosPrintfDebug(
                "%s: sendWantFinished=%s, startedAbilityPeer=%s",
                Q_FUNC_INFO, mapBoolToTrueFalseStr(sendWantFinished), mapBoolToTrueFalseStr(!!optAbilityPeer));
            if (sendWantFinished && optAbilityPeer)
                startupNotifyFunc(jsState, optAbilityPeer);
        }
    };
 
    auto context = std::make_shared<Context>();
    context->startupNotifyFunc = std::move(startupNotifyFunc);
 
    auto instanceId = m_abilityInstanceIdsGenerator();
 
    InstanceStartParams startParams;
    startParams.qwindow = qwindow;
    startParams.startupNotifyFunc = [context](JsState &jsState, std::shared_ptr<QAbilityPeer> abilityPeer) {
        context->optAbilityPeer = abilityPeer;
        context->callNotifyIfReady(jsState);
    };
    m_pendingInstancesStartParams.emplace(instanceId, std::move(startParams));
 
    sendWantToSelfQAbility(
        baseQAbility, optStartOptions, instanceId,
        [context](JsState &jsState) {
            context->sendWantFinished = true;
            context->callNotifyIfReady(jsState);
        });
}
 
void QAbilityInstancesManagerImpl::handleStartedUiInstance(
    JsState &jsState, QNapi::Object qAbility, QNapi::Object windowStage)
{
    handleStartedInstance(
        jsState, getQAbilityInstanceIdOrPendingAutoStartedId(qAbility),
        [&](const std::string &instanceId, const InstanceStartParams &startParams) {
            auto uiAbilityPeer = std::make_shared<QUiAbilityPeerImpl>(
                jsState, instanceId, startParams.qwindow, qAbility, windowStage);
            QUiAbilityPeer *uiAbilityPeerKey = uiAbilityPeer.get();
            m_ownedUiAbilityPeers->emplace(uiAbilityPeerKey, uiAbilityPeer);
            return makeSharedPtrWithAttachedExtraData(
                uiAbilityPeer,
                makeDestroyNotifier(
                    [ownedUiAbilityPeers = m_ownedUiAbilityPeers, uiAbilityPeerKey]() {
                        ownedUiAbilityPeers->erase(uiAbilityPeerKey);
                    }));
        });
}
 
void QAbilityInstancesManagerImpl::addQAbilityPeer(std::shared_ptr<QAbilityPeer> qAbilityPeer)
{
    if (m_appLaunchWant.IsEmpty())
        m_appLaunchWant = Napi::Persistent(qAbilityPeer->launchWant());
 
    auto optQUiAbilityPeer = QUiAbilityPeer::tryCastFromQAbilityPeerOrNull(qAbilityPeer);
    if (m_optAppLaunchParam.IsEmpty() && optQUiAbilityPeer) {
        m_optAppLaunchParam = QNapi::Reference<>::makePersistentFrom(optQUiAbilityPeer->launchParam());
        qOhosPrintfInfo(
            "%s: appLaunchParam set from Ability with instanceId='%s'",
            Q_FUNC_INFO, qAbilityPeer->instanceId().c_str());
    }
 
    if (m_qAbilityPeers.empty())
        m_defaultQAbilityPeer = qAbilityPeer;
 
    m_qAbilityPeers.emplace(qAbilityPeer->instanceId(), qAbilityPeer);
 
    qOhosPrintfDebug(
        "%s: added QAbilityPeer, instanceId: %s, qwindow: %s",
        Q_FUNC_INFO, qAbilityPeer->instanceId().c_str(), qAbilityPeer->qWindowRef().refName().c_str());
}
 
template<typename PeerMatchFunc>
std::shared_ptr<QAbilityPeer> QAbilityInstancesManagerImpl::tryFindMatchingQAbilityPeer(PeerMatchFunc &&matchFunc) const
{
    auto foundIter = std::find_if(
        m_qAbilityPeers.begin(), m_qAbilityPeers.end(),
        [&](const auto &entry) {
            return matchFunc(entry.second);
        });
    return foundIter != m_qAbilityPeers.end() ? foundIter->second : nullptr;
}
 
std::shared_ptr<QUiAbilityPeerBackend> QAbilityInstancesManagerImpl::getAbilityPeerBackend(
    std::shared_ptr<QUiAbilityPeer> uiAbilityPeer)
{
    auto ownedPeerEntryIter = m_ownedUiAbilityPeers->find(uiAbilityPeer.get());
    auto ownedPeerImpl =
        ownedPeerEntryIter != m_ownedUiAbilityPeers->end()
            ? ownedPeerEntryIter->second.lock()
            : nullptr;
 
    if (!ownedPeerImpl) {
        qOhosReportFatalErrorAndAbort(
            "%s: got unknown QUiAbilityPeer %p with id='%s'",
            Q_FUNC_INFO, uiAbilityPeer.get(), uiAbilityPeer->instanceId().c_str());
    }
 
    return ownedPeerImpl;
}
 
void QAbilityInstancesManagerImpl::handleStartedInstance(
    JsState &jsState, const std::string &abilityInstanceId,
    const std::function<std::shared_ptr<QAbilityPeer>(const std::string &, const InstanceStartParams &)> &qAbilityPeerFactory)
{
    auto startParamsIter = m_pendingInstancesStartParams.find(abilityInstanceId);
    if (startParamsIter != m_pendingInstancesStartParams.end()) {
        auto startParams = std::move(startParamsIter->second);
        m_pendingInstancesStartParams.erase(startParamsIter);
        if (abilityInstanceId == m_pendingAutoStartedInstanceId)
            m_pendingAutoStartedInstanceId.reset();
 
        auto qAbilityPeer = qAbilityPeerFactory(abilityInstanceId, startParams);
        addQAbilityPeer(qAbilityPeer);
        startParams.startupNotifyFunc(jsState, qAbilityPeer);
    } else {
        qOhosPrintfError(
            "%s: got unexpected started instance notification with id='%s', ignoring",
            Q_FUNC_INFO, abilityInstanceId.c_str());
    }
}
 
}
 
QUiAbilityPeerBackend::QUiAbilityPeerBackend() = default;
 
QAbilityInstancesManager::QAbilityInstancesManager() = default;
 
QAbilityInstancesManager::~QAbilityInstancesManager() = default;
 
QAbilityInstancesManager &QAbilityInstancesManager::instance(QOhosJsState &jsState)
{
    return JsState::castFrom(jsState).getAttachedObjectWithLazyCreate<QAbilityInstancesManagerImpl>();
}
 
bool QAbilityInstancesManager::isQtInternalWantFromThisProcess(QNapi::Object want)
{
    auto optWantParameters = QNapi::getOptionalPropOrEmpty<QNapi::Object>(want, "parameters");
 
    auto optCallerPid = QNapi::getOptionalPropOrEmpty<QNapi::Number>(
        optWantParameters, callerPidWantParamKey);
    auto optQtInternalRequestId = QNapi::getOptionalPropOrEmpty<QNapi::String>(
        optWantParameters, qtInternalRequestIdWantParamKey);
 
    std::int32_t thisProcessPid = ::getpid();
 
    return
        !optCallerPid.IsEmpty() && optCallerPid.Int32Value() == thisProcessPid
        && !optQtInternalRequestId.IsEmpty()
        && optQtInternalRequestId.Utf8Value() == getUtf8QtInternalRequestIdForThisProcess();
}
 
void QAbilityInstancesManager::setLaunchParamOnAbilityObject(
    JsState &jsState, QNapi::Object ability, QNapi::Object launchParam)
{
    ability.set(getAbilityLaunchParamPropSymbol(jsState), launchParam);
}
 
QAbilityInfo QAbilityInstancesManager::readAbilityInfo(const QNapi::Object &ability)
{
    auto abilityInfo = ability.eval<QNapi::Object>("context.abilityInfo");
 
    return {
        .name = abilityInfo.get<QNapi::String>("name"),
        .bundleName = abilityInfo.get<QNapi::String>("bundleName"),
        .moduleName = abilityInfo.get<QNapi::String>("moduleName"),
    };
}
 
}
 
QT_END_NAMESPACE