qstandardpaths_android.cpp

Go to the documentation of this file.

// Copyright (C) 2023 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
// Qt-Security score:critical reason:provides-trusted-directory-paths
 
#include "qstandardpaths.h"
 
#ifndef QT_NO_STANDARDPATHS
 
#include <QtCore/qjniobject.h>
#include <QtCore/qmap.h>
#include <QtCore/qcoreapplication.h>
#include <QDir>
 
QT_BEGIN_NAMESPACE
 
Q_DECLARE_JNI_CLASS(Environment, "android/os/Environment");
 
using namespace QNativeInterface;
using namespace Qt::StringLiterals;
 
typedef QMap<QString, QString> AndroidDirCache;
Q_GLOBAL_STATIC(AndroidDirCache, androidDirCache)
 
static QString testDir()
{
    return QStandardPaths::isTestModeEnabled() ? "/qttest"_L1 : ""_L1;
}
 
static inline QString getAbsolutePath(const QJniObject &file)
{
    QJniObject path = file.callMethod<jstring>("getAbsolutePath");
 
    if (!path.isValid())
        return QString();
 
    return path.toString();
}
 
/*
 * The root of the external storage
 *
 */
static QString getExternalStorageDirectory()
{
    QString &path = (*androidDirCache)[QStringLiteral("EXT_ROOT")];
    if (!path.isEmpty())
        return path;
 
    QJniObject file = QJniObject::callStaticMethod<QtJniTypes::File>("android/os/Environment",
                                                                     "getExternalStorageDirectory");
    if (!file.isValid())
        return QString();
 
    return (path = getAbsolutePath(file));
}
 
/*
 * Locations where applications can place user files shared by all apps (public).
 * E.g., /storage/Music
 */
static QString getExternalStoragePublicDirectory(const char *directoryField)
{
    QString &path = (*androidDirCache)[QLatin1String(directoryField)];
    if (!path.isEmpty())
        return path;
 
    QJniObject dirField = QJniObject::getStaticField<jstring>("android/os/Environment",
                                                              directoryField);
    if (!dirField.isValid())
        return QString();
 
    QJniObject file = QJniObject::callStaticMethod<QtJniTypes::File>("android/os/Environment",
                                                            "getExternalStoragePublicDirectory",
                                                            dirField.object<jstring>());
    if (!file.isValid())
        return QString();
 
    return (path = getAbsolutePath(file));
}
 
/*
 * Locations where applications can place persistent files it owns.
 * E.g., /storage/org.app/Music
 */
static QString getExternalFilesDir(const char *directoryField = nullptr)
{
    QString &path = (*androidDirCache)["APPNAME_%1"_L1.arg(QLatin1StringView(directoryField))];
    if (!path.isEmpty())
        return path;
 
    QJniObject appCtx = QAndroidApplication::context();
    if (!appCtx.isValid())
        return QString();
 
    QJniObject dirField = QJniObject::fromString(""_L1);
    if (directoryField && strlen(directoryField) > 0) {
        dirField = QJniObject::getStaticField<QtJniTypes::Environment, jstring>(directoryField);
        if (!dirField.isValid())
            return QString();
    }
 
    QJniObject file = appCtx.callMethod<QtJniTypes::File>("getExternalFilesDir",
                                                          dirField.object<jstring>());
 
    if (!file.isValid())
        return QString();
 
    return (path = getAbsolutePath(file));
}
 
/*
 * Directory where applications can store cache files it owns (public).
 * E.g., /storage/org.app/
 */
static QString getExternalCacheDir()
{
    QString &path = (*androidDirCache)[QStringLiteral("APPNAME_CACHE")];
    if (!path.isEmpty())
        return path;
 
    QJniObject appCtx = QAndroidApplication::context();
    if (!appCtx.isValid())
        return QString();
 
    QJniObject file = appCtx.callMethod<QtJniTypes::File>("getExternalCacheDir");
 
    if (!file.isValid())
        return QString();
 
    return (path = getAbsolutePath(file));
}
 
/*
 * Directory where applications can store cache files it owns (private).
 */
static QString getCacheDir()
{
    QString &path = (*androidDirCache)[QStringLiteral("APPROOT_CACHE")];
    if (!path.isEmpty())
        return path;
 
    QJniObject appCtx = QAndroidApplication::context();
    if (!appCtx.isValid())
        return QString();
 
    QJniObject file = appCtx.callMethod<QtJniTypes::File>("getCacheDir");
    if (!file.isValid())
        return QString();
 
    return (path = getAbsolutePath(file));
}
 
/*
 * Directory where applications can store files it owns (private).
 * (Same location as $HOME)
 */
static QString getFilesDir()
{
    QString &path = (*androidDirCache)[QStringLiteral("APPROOT_FILES")];
    if (!path.isEmpty())
        return path;
 
    QJniObject appCtx = QAndroidApplication::context();
    if (!appCtx.isValid())
        return QString();
 
    QJniObject file = appCtx.callMethod<QtJniTypes::File>("getFilesDir");
    if (!file.isValid())
        return QString();
 
    return (path = getAbsolutePath(file));
}
 
static QString getSdkBasedExternalDir(const char *directoryField = nullptr)
{
    return (QNativeInterface::QAndroidApplication::sdkVersion() >= 30)
            ? getExternalFilesDir(directoryField)
            : getExternalStoragePublicDirectory(directoryField);
}
 
QString QStandardPaths::writableLocation(StandardLocation type)
{
    switch (type) {
    case QStandardPaths::MusicLocation:
        return getSdkBasedExternalDir("DIRECTORY_MUSIC");
    case QStandardPaths::MoviesLocation:
        return getSdkBasedExternalDir("DIRECTORY_MOVIES");
    case QStandardPaths::PicturesLocation:
        return getSdkBasedExternalDir("DIRECTORY_PICTURES");
    case QStandardPaths::DocumentsLocation:
        return getSdkBasedExternalDir("DIRECTORY_DOCUMENTS");
    case QStandardPaths::DownloadLocation:
        return getSdkBasedExternalDir("DIRECTORY_DOWNLOADS");
    case QStandardPaths::GenericConfigLocation:
    case QStandardPaths::ConfigLocation:
    case QStandardPaths::AppConfigLocation:
        return getFilesDir() + testDir() + "/settings"_L1;
    case QStandardPaths::StateLocation:
    case QStandardPaths::GenericStateLocation:
        return getFilesDir() + testDir() + "/state"_L1;
    case QStandardPaths::GenericDataLocation:
    {
        return QAndroidApplication::sdkVersion() >= 30 ?
                getExternalFilesDir() + testDir() : getExternalStorageDirectory() + testDir();
    }
    case QStandardPaths::AppDataLocation:
    case QStandardPaths::AppLocalDataLocation:
        return getFilesDir() + testDir();
    case QStandardPaths::GenericCacheLocation:
    case QStandardPaths::RuntimeLocation:
    case QStandardPaths::TempLocation:
    case QStandardPaths::CacheLocation:
        return getCacheDir() + testDir();
    case QStandardPaths::DesktopLocation:
    case QStandardPaths::HomeLocation:
        return getFilesDir();
    case QStandardPaths::ApplicationsLocation:
    case QStandardPaths::FontsLocation:
    case QStandardPaths::PublicShareLocation:
    case QStandardPaths::TemplatesLocation:
    default:
        break;
    }
 
    return QString();
}
 
QStringList QStandardPaths::standardLocations(StandardLocation type)
{
    QStringList locations;
 
    if (type == MusicLocation) {
        locations << getExternalFilesDir("DIRECTORY_MUSIC");
        // Place the public dirs before the app own dirs
        if (QNativeInterface::QAndroidApplication::sdkVersion() < 30) {
            locations << getExternalStoragePublicDirectory("DIRECTORY_PODCASTS")
                      << getExternalStoragePublicDirectory("DIRECTORY_NOTIFICATIONS")
                      << getExternalStoragePublicDirectory("DIRECTORY_ALARMS");
        }
        locations << getExternalFilesDir("DIRECTORY_PODCASTS")
                  << getExternalFilesDir("DIRECTORY_NOTIFICATIONS")
                  << getExternalFilesDir("DIRECTORY_ALARMS");
    } else if (type == MoviesLocation) {
        locations << getExternalFilesDir("DIRECTORY_MOVIES");
    } else if (type == PicturesLocation) {
        locations << getExternalFilesDir("DIRECTORY_PICTURES");
    } else if (type == DocumentsLocation) {
        locations << getExternalFilesDir("DIRECTORY_DOCUMENTS");
    } else if (type == DownloadLocation) {
        locations << getExternalFilesDir("DIRECTORY_DOWNLOADS");
    } else if (type == AppDataLocation || type == AppLocalDataLocation) {
        locations << getExternalFilesDir();
    } else if (type == CacheLocation) {
        locations << getExternalCacheDir();
    } else if (type == FontsLocation) {
        QString &fontLocation = (*androidDirCache)[QStringLiteral("FONT_LOCATION")];
        if (!fontLocation.isEmpty()) {
            locations << fontLocation;
        } else {
            const QByteArray ba = qgetenv("QT_ANDROID_FONT_LOCATION");
            if (!ba.isEmpty()) {
                locations << (fontLocation = QDir::cleanPath(QString::fromLocal8Bit(ba)));
            } else {
                // Don't cache the fallback, as we might just have been called before
                // QT_ANDROID_FONT_LOCATION has been set.
                locations << "/system/fonts"_L1;
            }
        }
    }
 
    const QString writable = writableLocation(type);
    if (!writable.isEmpty())
        locations.prepend(writable);
 
    locations.removeDuplicates();
    return locations;
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_STANDARDPATHS