qohoswindowmanager.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 "qohoswindowmanager.h"
#include <QtCore/private/qcore_ohos_p.h>
#include <QtCore/qcoreapplication.h>
#include <QtCore/private/qnapi_p.h>
#include <QtCore/private/qohoscommon_p.h>
#include <QtCore/private/qohoslogger_p.h>
#include <QtCore/private/qohospathutils_p.h>
#include <QtCore/qurl.h>
#include <algorithm>
#include <iterator>
#include <vector>
#include "qohosplatformwindow.h"
 
QT_BEGIN_NAMESPACE
 
namespace {
 
struct FilePickerResult
{
    std::vector<std::string> resultPaths;
    int selectedIndex;
};
 
std::optional<QNapi::Object> tryGetQAbilityForQWindow(
    QOhosJsState &jsState, QtOhos::QObjectThreadSafeRef qWindowRef)
{
    auto optQAbility = jsState.tryGetQAbilityByQWindow(qWindowRef);
    return optQAbility ? optQAbility : jsState.defaultQAbility();
}
 
QNapi::Object makeDocumentViewPicker(
    QOhosJsState &jsState, QNapi::Object qAbility,
    QtOhos::QObjectThreadSafeRef contextWindowRef)
{
    auto optContextJsWindow = jsState.tryGetJsWindowByQWindow(contextWindowRef);
 
    std::vector<QNapi::ValueWrapper> constructorParams = {qAbility.get("context")};
    if (optContextJsWindow)
        constructorParams.push_back(optContextJsWindow.value());
 
    return jsState.eval<QNapi::Object>(
        "@ohos.file.picker.DocumentViewPicker<new>(*)", constructorParams);
}
 
void startOhosFilePicker(
    QOhosJsState &jsState, QtOhos::QObjectThreadSafeRef contextWindowRef,
    const std::string &pickerActionName, QNapi::Object pickerActionOptions,
    QOhosConsumer<std::optional<FilePickerResult>> resultConsumer)
{
    auto sharedResultConsumer = QtOhos::moveToSharedPtr(std::move(resultConsumer));
 
    auto optQAbility = tryGetQAbilityForQWindow(jsState, contextWindowRef);
    if (!optQAbility) {
        qOhosPrintfError(
            "Cannot call DocumentViewPicker.%s(): no UIAbility to use", pickerActionName.c_str());
        (*sharedResultConsumer)(std::nullopt);
        return;
    }
 
    qOhosPrintfDebug(
        "Calling DocumentViewPicker.%s() with options: %s",
        pickerActionName.c_str(), QNapi::toJsonString(pickerActionOptions).c_str());
    auto documentViewPicker = QtOhos::moveToSharedPtr(
        QNapi::Reference<>::makePersistentFrom(
            makeDocumentViewPicker(jsState, optQAbility.value(), contextWindowRef)));
    documentViewPicker->evalToPromiseOrRejectOnThrow(pickerActionName + "(*)", {pickerActionOptions}).onThen(
        [documentViewPicker, pickerActionName, sharedResultConsumer](const QOhosCallbackInfo &cbInfo) {
            auto actionResult = cbInfo.getFirstArg<QNapi::Array>(Q_FUNC_INFO);
            auto resultOhosUris = QNapi::getArrayElements<std::vector<std::string>, QNapi::String>(actionResult);
 
            qOhosPrintfDebug(
                "Called DocumentViewPicker.%s() callback with result: %s",
                pickerActionName.c_str(), QNapi::toJsonString(actionResult).c_str());
 
            std::vector<std::string> resultPaths;
            std::transform(
                resultOhosUris.cbegin(), resultOhosUris.cend(), std::back_inserter(resultPaths),
                [&](const auto &uri) {
                    return tryMapOhosFileUriToPath(uri).value_or("");
                });
 
            (*sharedResultConsumer)(
                std::optional<FilePickerResult>(
                    {
                        .resultPaths = std::move(resultPaths),
                        .selectedIndex = documentViewPicker->eval<QNapi::Number>("getSelectedIndex()"),
                    }));
        },
        [pickerActionName, sharedResultConsumer]() {
            qOhosPrintfError("DocumentViewPicker.%s() call failed", pickerActionName.c_str());
            (*sharedResultConsumer)({});
        });
}
 
QStringList mapFilePathsToQtUrls(const std::vector<std::string> &filePaths)
{
    QStringList qtUrls;
    std::transform(
        filePaths.cbegin(), filePaths.cend(), std::back_inserter(qtUrls),
        [&](const auto &path) {
            return QUrl::fromLocalFile(QString::fromStdString(path)).toString();
        });
    return qtUrls;
}
 
}
 
namespace QOhosWindowManager {
 
void showFileDialogOpen(
    QtOhos::QObjectThreadSafeRef contextWindowRef, QStringList filters, QString defaultPath,
    DocumentSelectMode documentSelectMode, ResultMultiplicity resultMultiplicity,
    QOhosConsumer<std::optional<OpenResult>> resultCallback)
{
    auto sharedResultCallback = QtOhos::moveToSharedPtr(std::move(resultCallback));
 
    QOhosJsThreadGateway::invoke(
        [contextWindowRef, filters, defaultPath, documentSelectMode, resultMultiplicity, sharedResultCallback](QOhosJsState &jsState) {
            constexpr auto ohosMaxValueForMaxSelectNumber = 500;
 
            auto *env = jsState.env();
 
            auto documentSelectOptions = QNapi::makeObject(
                env,
                {
                    {"maxSelectNumber", resultMultiplicity == ResultMultiplicity::SINGLE ? 1 : ohosMaxValueForMaxSelectNumber},
                    {"fileSuffixFilters", QNapi::makeArray(env, filters, std::mem_fn(&QString::toStdString))},
                    {"defaultFilePathUri", tryMapPathToOhosFileUri(defaultPath.toStdString()).value_or("")},
                    {"selectMode", jsState.mapOhosEnumToJs(documentSelectMode)},
                });
 
            startOhosFilePicker(
                jsState, contextWindowRef, "select", documentSelectOptions,
                [sharedResultCallback](auto optResult) {
                    auto optQtOpenResult = qTransform(
                        optResult,
                        [](const auto &result) {
                            return OpenResult{
                                .selectedUrls = mapFilePathsToQtUrls(result.resultPaths),
                            };
                        });
                    QtOhos::invokeInQtThread(
                        [sharedResultCallback, optQtOpenResult]() {
                            (*sharedResultCallback)(optQtOpenResult);
                        });
                });
        });
}
 
void showFileDialogSave(
    QtOhos::QObjectThreadSafeRef contextWindowRef, QStringList newFileNames,
    QString defaultFilePath, QStringList fileSuffixChoices,
    QOhosConsumer<std::optional<SaveResult>> resultCallback)
{
    auto sharedResultCallback = QtOhos::moveToSharedPtr(std::move(resultCallback));
 
    QOhosJsThreadGateway::invoke(
        [contextWindowRef, newFileNames, defaultFilePath, fileSuffixChoices, sharedResultCallback](QOhosJsState &jsState) {
            auto *env = jsState.env();
            auto documentSaveOptions = QNapi::Object::New(env);
            if (!newFileNames.isEmpty())
                documentSaveOptions.Set("newFileNames", QNapi::makeArray(env, newFileNames, std::mem_fn(&QString::toStdString)));
            if (!defaultFilePath.isEmpty())
                documentSaveOptions.Set("defaultFilePathUri", tryMapPathToOhosFileUri(defaultFilePath.toStdString()).value_or(""));
            if (!fileSuffixChoices.isEmpty())
                documentSaveOptions.Set("fileSuffixChoices", QNapi::makeArray(env, fileSuffixChoices, std::mem_fn(&QString::toStdString)));
            documentSaveOptions.Set("autoCreateEmptyFile", false);
 
            startOhosFilePicker(
                jsState, contextWindowRef, "save", documentSaveOptions,
                [sharedResultCallback](auto optResult) {
                    auto optQtSaveResult = qTransform(
                        optResult,
                        [](const auto &result) {
                            return SaveResult{
                                .savedUrls = mapFilePathsToQtUrls(result.resultPaths),
                                .selectedFileSuffixChoiceIndex = result.selectedIndex,
                            };
                        });
                    QtOhos::invokeInQtThread(
                        [sharedResultCallback, optQtSaveResult]() {
                            (*sharedResultCallback)(optQtSaveResult);
                        });
                });
        });
}
 
}
 
QT_END_NAMESPACE