Filepermissions/main.cpp

< Qt for HarmonyOS/qtohosextras doc/Qt Ohos Extras C++ Classes

main.cpp Example File

filepermissions/main.cpp

Source Code

/****************************************************************************
**
** Copyright (C) 2025 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** $QT_BEGIN_LICENSE:LGPL$
... (License Header) ...
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QApplication>
#include <QButtonGroup>
#include <QFileDialog>
#include <QHBoxLayout>
#include <QLabel>
#include <QLatin1String>
#include <QRadioButton>
#include <QString>
#include <QVBoxLayout>
#include <QVector>
#include <QWidget>
#include <QtOhosExtras>

namespace {

struct ActionOption
{
    QSharedPointer<QtOhosExtras::FileShare::ActionResult> (*actionFunction)(
        const QList<QtOhosExtras::FileShare::PathPolicy> &);
    QString label;
};

struct OperationModeOption
{
    QtOhosExtras::FileShare::OperationModes mode;
    QString label;
};

const QVector<ActionOption> actionOptions = {
    {QtOhosExtras::FileShare::persistPermission, QLatin1String("Persist")},
    {QtOhosExtras::FileShare::revokePermission, QLatin1String("Revoke")},
    {QtOhosExtras::FileShare::activatePermission, QLatin1String("Activate")},
    {QtOhosExtras::FileShare::deactivatePermission, QLatin1String("Deactivate")},
};

const QVector<OperationModeOption> operationModesOptions = {
    {
        .mode = QtOhosExtras::FileShare::OperationMode::Read,
        .label = QLatin1String("read"),
    },
    {
        .mode = QtOhosExtras::FileShare::OperationMode::Write,
        .label = QLatin1String("write"),
    },
    {
        .mode = QtOhosExtras::FileShare::OperationMode::Read | QtOhosExtras::FileShare::OperationMode::Write,
        .label = QLatin1String("read | write"),
    },
};

constexpr auto initialOperationMode = QtOhosExtras::FileShare::OperationMode::Read;

void logMessage(QTextEdit *logContext, const QString &message)
{
    if (logContext != nullptr) {
        logContext->append(message);
    }
}

QString buildOperationStatusText(
    const QString operationName, QSharedPointer<QtOhosExtras::QOhosOperationStatus> operationStatus)
{
    auto statusString =
        operationStatus->success()
            ? QLatin1String("successful")
            : QLatin1String("unsuccessful");

    return QStringLiteral("%1 permission operation %2")
        .arg(operationName)
        .arg(statusString);
}

QString buildPolicyModeText(QtOhosExtras::FileShare::OperationModes mode)
{
    QStringList parts;

    if (mode.testFlag(QtOhosExtras::FileShare::OperationMode::Read)) {
        parts << QLatin1String("read");
    }
    if (mode.testFlag(QtOhosExtras::FileShare::OperationMode::Write)) {
        parts << QLatin1String("write");
    }

    return parts.join(QLatin1Char('|')) + QLatin1String(" mode");
}

void logActionResult(
    QTextEdit *logContext, const QString &actionName,
    QSharedPointer<QtOhosExtras::FileShare::ActionResult> actionResult,
    QSharedPointer<QtOhosExtras::FileShare::PathPolicy> pathPolicy)
{
    logMessage(
        logContext,
        QStringLiteral("%1 on file: %2")
            .arg(buildOperationStatusText(actionName, actionResult->operationStatus()))
            .arg(pathPolicy->path));

    const auto &errorInfoList = actionResult->errorInfoList();
    if (!errorInfoList.empty()) {
        logMessage(logContext, QLatin1String("Error info list:"));
    }
    for (const auto &errorInfo : errorInfoList) {
        logMessage(logContext, QStringLiteral("Path: %1").arg(errorInfo.path));
        logMessage(
            logContext, QStringLiteral("Error code: %1").arg(static_cast<int>(errorInfo.error)));
        logMessage(logContext, QStringLiteral("Error message: %1").arg(errorInfo.errorMessage));
    }
}

void logCheckResult(
    QTextEdit *logContext, QSharedPointer<QtOhosExtras::FileShare::CheckResult> checkResult)
{
    logMessage(
        logContext,
        buildOperationStatusText(QLatin1String("Check"), checkResult->operationStatus()));

    for (const auto &result : checkResult->checkResultList()) {
        logMessage(
            logContext,
            QStringLiteral("Persistent permission %1 %2 on file: %3")
                .arg(buildPolicyModeText(result.policy.operationModes))
                .arg((result.result ? QLatin1String("is granted") : QLatin1String("is not granted")))
                .arg(result.policy.path));
    }
}

QString selectPathWithFileDialog(QTextEdit *logContext)
{
    const auto path = QFileDialog::getOpenFileName();
    logMessage(logContext, QLatin1String("New path selected: ") + path);
    return path;
}

QButtonGroup *createActionButtons(
    QWidget *parent, QTextEdit *logContext,
    QSharedPointer<QtOhosExtras::FileShare::PathPolicy> pathPolicy)
{
    auto *actionsGroup = new QButtonGroup(parent);

    for (int i = 0; i < actionOptions.size(); ++i) {
        auto *actionButton = new QPushButton(actionOptions[i].label, parent);
        actionsGroup->addButton(actionButton, i);
    }

    QObject::connect(
        actionsGroup, QOverload<int>::of(&QButtonGroup::buttonClicked),
        logContext,
        [logContext, pathPolicy](int id) {
            QList<QtOhosExtras::FileShare::PathPolicy> input = {{*pathPolicy}};

            const auto result = actionOptions[id].actionFunction(input);
            logActionResult(logContext, actionOptions[id].label, result, pathPolicy);
        });

    return actionsGroup;
}

QPushButton *createCheckButton(
    QWidget *parent, QTextEdit *logContext,
    QSharedPointer<QtOhosExtras::FileShare::PathPolicy> pathPolicy)
{
    auto *checkButton = new QPushButton(QLatin1String("Check"), parent);

    QObject::connect(
        checkButton, &QPushButton::clicked, logContext,
        [logContext, pathPolicy]() {
            QList<QtOhosExtras::FileShare::PathPolicy> input = {{*pathPolicy}};

            const auto result = QtOhosExtras::FileShare::checkPersistent(input);
            logCheckResult(logContext, result);
        });

    return checkButton;
}

QPushButton *createSelectFileButton(
    QWidget *parent, QTextEdit *logContext,
    QSharedPointer<QtOhosExtras::FileShare::PathPolicy> pathPolicy)
{
    auto *selectButton = new QPushButton(QLatin1String("Select File"), parent);
    QObject::connect(
        selectButton, &QPushButton::clicked, logContext,
        [logContext, pathPolicy]() {
            pathPolicy->path = selectPathWithFileDialog(logContext);
        });
    return selectButton;
}

QButtonGroup *createOperationModeButtons(
    QWidget *parent, QSharedPointer<QtOhosExtras::FileShare::PathPolicy> pathPolicy)
{
    auto *operationModeButtonGroup = new QButtonGroup(parent);

    for (int i = 0; i < operationModesOptions.size(); ++i) {
        auto *radioButton = new QRadioButton(operationModesOptions[i].label, parent);
        operationModeButtonGroup->addButton(radioButton, i);

        if (operationModesOptions[i].mode == QtOhosExtras::FileShare::OperationModes(initialOperationMode)) {
            radioButton->setChecked(true);
        }
    }

    QObject::connect(
        operationModeButtonGroup, QOverload<int>::of(&QButtonGroup::buttonClicked),
        [pathPolicy](int id) {
            pathPolicy->operationModes = operationModesOptions[id].mode;
        });

    return operationModeButtonGroup;
}

}

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QWidget window;
    window.setWindowTitle(QLatin1String("File permissions example"));
    window.setMinimumWidth(800);

    auto *logOutput = new QTextEdit(&window);
    logOutput->setReadOnly(true);

    auto pathPolicy = QSharedPointer<QtOhosExtras::FileShare::PathPolicy>::create(
        QtOhosExtras::FileShare::PathPolicy{
            .path = QLatin1String(),
            .operationModes = initialOperationMode,
        });

    auto *actionButtonsGroup = createActionButtons(&window, logOutput, pathPolicy);
    auto *checkButton = createCheckButton(&window, logOutput, pathPolicy);

    auto *actionButtonslayout = new QVBoxLayout;
    for (auto *button : actionButtonsGroup->buttons()) {
        actionButtonslayout->addWidget(button);
    }
    actionButtonslayout->addWidget(checkButton);
    actionButtonslayout->addStretch();

    auto *selectButton = createSelectFileButton(&window, logOutput, pathPolicy);
    auto *operationModeLabel = new QLabel(QLatin1String("Operation mode:"), &window);
    auto *operationModeButtons = createOperationModeButtons(&window, pathPolicy);

    auto *setupButtonslayout = new QVBoxLayout;
    setupButtonslayout->addWidget(selectButton);
    setupButtonslayout->addStretch();
    setupButtonslayout->addWidget(operationModeLabel);
    for (auto *button : operationModeButtons->buttons()) {
        setupButtonslayout->addWidget(button);
    }

    auto *buttonsLayout = new QHBoxLayout;
    buttonsLayout->addLayout(actionButtonslayout);
    buttonsLayout->addLayout(setupButtonslayout);

    auto *mainLayout = new QVBoxLayout(&window);
    mainLayout->addLayout(buttonsLayout);
    mainLayout->addWidget(logOutput);

    logMessage(logOutput, QLatin1String("Select a file to check or update its permissions"));

    window.show();

    return app.exec();
}

Summary of Implementation

• **Permission Management**: Utilizes

  PathPolicy

  to define file access rules.
• **Asynchronous Integration**: Uses Qt's signal and slot mechanism to bridge UI events with HarmonyOS security calls.
• **Error Handling**: Processes

  ActionResult

  to provide granular feedback on permission state changes.

See also: Return to C++ Classes List.