qiosfileengineassetslibrary.mm

Go to the documentation of this file.

// Copyright (C) 2016 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:significant reason:default
 
#include "qiosfileengineassetslibrary.h"
 
#import <UIKit/UIKit.h>
#import <AssetsLibrary/AssetsLibrary.h>
 
#include <QtCore/QTimer>
#include <QtCore/private/qcoreapplication_p.h>
#include <QtCore/qurl.h>
#include <QtCore/qset.h>
#include <QtCore/qthreadstorage.h>
#include <QtCore/qfileselector.h>
#include <QtCore/qpointer.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
static QThreadStorage<QString> g_iteratorCurrentUrl;
static QThreadStorage<QPointer<QIOSAssetData> > g_assetDataCache;
 
static const int kBufferSize = 10;
static ALAsset *kNoAsset = nullptr;
 
static bool ensureAuthorizationDialogNotBlocked()
{
    if ([ALAssetsLibrary authorizationStatus] != ALAuthorizationStatusNotDetermined)
        return true;
 
    if (static_cast<QCoreApplicationPrivate *>(QObjectPrivate::get(qApp))->in_exec)
        return true;
 
    if ([NSThread isMainThread]) {
        // The dialog is about to show, but since main has not finished, the dialog will be held
        // back until the launch completes. This is problematic since we cannot successfully return
        // back to the caller before the asset is ready, which also includes showing the dialog. To
        // work around this, we create an event loop to that will complete the launch (return from the
        // applicationDidFinishLaunching callback). But this will only work if we're on the main thread.
        QEventLoop loop;
        QTimer::singleShot(1, &loop, &QEventLoop::quit);
        loop.exec();
    } else {
        NSLog(@"QIOSFileEngine: unable to show assets authorization dialog from non-gui thread before QApplication is executing.");
        return false;
    }
 
    return true;
}
 
// -------------------------------------------------------------------------
 
class QIOSAssetEnumerator
{
public:
    QIOSAssetEnumerator(ALAssetsLibrary *assetsLibrary, ALAssetsGroupType type)
        : m_semWriteAsset(dispatch_semaphore_create(kBufferSize))
        , m_semReadAsset(dispatch_semaphore_create(0))
        , m_stop(false)
        , m_assetsLibrary([assetsLibrary retain])
        , m_type(type)
        , m_buffer(QVector<ALAsset *>(kBufferSize))
        , m_readIndex(0)
        , m_writeIndex(0)
        , m_nextAssetReady(false)
    {
        if (!ensureAuthorizationDialogNotBlocked())
            writeAsset(kNoAsset);
        else
            startEnumerate();
    }
 
    ~QIOSAssetEnumerator()
    {
        m_stop = true;
 
        // Flush and autorelease remaining assets in the buffer
        while (hasNext())
            next();
 
        // Documentation states that we need to balance out calls to 'wait'
        // and 'signal'. Since the enumeration function always will be one 'wait'
        // ahead, we need to signal m_semProceedToNextAsset one last time.
        dispatch_semaphore_signal(m_semWriteAsset);
        dispatch_release(m_semReadAsset);
        dispatch_release(m_semWriteAsset);
 
        [m_assetsLibrary autorelease];
    }
 
    bool hasNext()
    {
        if (!m_nextAssetReady) {
            dispatch_semaphore_wait(m_semReadAsset, DISPATCH_TIME_FOREVER);
            m_nextAssetReady = true;
        }
        return m_buffer[m_readIndex] != kNoAsset;
    }
 
    ALAsset *next()
    {
        Q_ASSERT(m_nextAssetReady);
        Q_ASSERT(m_buffer[m_readIndex]);
 
        ALAsset *asset = [m_buffer[m_readIndex] autorelease];
        dispatch_semaphore_signal(m_semWriteAsset);
 
        m_readIndex = (m_readIndex + 1) % kBufferSize;
        m_nextAssetReady = false;
        return asset;
    }
 
private:
    dispatch_semaphore_t m_semWriteAsset;
    dispatch_semaphore_t m_semReadAsset;
    std::atomic_bool m_stop;
 
    ALAssetsLibrary *m_assetsLibrary;
    ALAssetsGroupType m_type;
    QVector<ALAsset *> m_buffer;
    int m_readIndex;
    int m_writeIndex;
    bool m_nextAssetReady;
 
    void writeAsset(ALAsset *asset)
    {
        dispatch_semaphore_wait(m_semWriteAsset, DISPATCH_TIME_FOREVER);
        m_buffer[m_writeIndex] = [asset retain];
        dispatch_semaphore_signal(m_semReadAsset);
        m_writeIndex = (m_writeIndex + 1) % kBufferSize;
    }
 
    void startEnumerate()
    {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            [m_assetsLibrary enumerateGroupsWithTypes:m_type usingBlock:^(ALAssetsGroup *group, BOOL *stopEnumerate) {
 
                if (!group) {
                    writeAsset(kNoAsset);
                    return;
                }
 
                if (m_stop) {
                    *stopEnumerate = true;
                    return;
                }
 
                [group enumerateAssetsUsingBlock:^(ALAsset *asset, NSUInteger index, BOOL *stopEnumerate) {
                    Q_UNUSED(index);
                    if (!asset || ![[asset valueForProperty:ALAssetPropertyType] isEqual:ALAssetTypePhoto])
                       return;
 
                    writeAsset(asset);
                    *stopEnumerate = m_stop;
                }];
            } failureBlock:^(NSError *error) {
                NSLog(@"QIOSFileEngine: %@", error);
                writeAsset(kNoAsset);
            }];
        });
    }
 
};
 
// -------------------------------------------------------------------------
 
class QIOSAssetData : public QObject
{
public:
    QIOSAssetData(const QString &assetUrl, QIOSFileEngineAssetsLibrary *engine)
        : m_asset(0)
        , m_assetUrl(assetUrl)
        , m_assetLibrary(0)
    {
        if (!ensureAuthorizationDialogNotBlocked())
            return;
 
        if (QIOSAssetData *assetData = g_assetDataCache.localData()) {
            // It's a common pattern that QFiles pointing to the same path are created and destroyed
            // several times during a single event loop cycle. To avoid loading the same asset
            // over and over, we check if the last loaded asset has not been destroyed yet, and try to
            // reuse its data.
            if (assetData->m_assetUrl == assetUrl) {
                m_assetLibrary = [assetData->m_assetLibrary retain];
                m_asset = [assetData->m_asset retain];
                return;
            }
        }
 
        // We can only load images from the asset library async. And this might take time, since it
        // involves showing the authorization dialog. But the QFile API is synchronuous, so we need to
        // wait until we have access to the data. [ALAssetLibrary assetForUrl:] will schedule a block on
        // the current thread. But instead of spinning the event loop to force the block to execute, we
        // wrap the call inside a synchronuous dispatch queue so that it executes on another thread.
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
 
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSURL *url = [NSURL URLWithString:assetUrl.toNSString()];
            m_assetLibrary = [[ALAssetsLibrary alloc] init];
            [m_assetLibrary assetForURL:url resultBlock:^(ALAsset *asset) {
 
                if (!asset) {
                    // When an asset couldn't be loaded, chances are that it belongs to ALAssetsGroupPhotoStream.
                    // Such assets can be stored in the cloud and might need to be downloaded first. Unfortunately,
                    // forcing that to happen is hidden behind private APIs ([ALAsset requestDefaultRepresentation]).
                    // As a work-around, we search for it instead, since that will give us a pointer to the asset.
                    QIOSAssetEnumerator e(m_assetLibrary, ALAssetsGroupPhotoStream);
                    while (e.hasNext()) {
                        ALAsset *a = e.next();
                        QString url = QUrl::fromNSURL([a valueForProperty:ALAssetPropertyAssetURL]).toString();
                        if (url == assetUrl) {
                            asset = a;
                            break;
                        }
                    }
                }
 
                if (!asset)
                    engine->setError(QFile::OpenError, "could not open image"_L1);
 
                m_asset = [asset retain];
                dispatch_semaphore_signal(semaphore);
            } failureBlock:^(NSError *error) {
                engine->setError(QFile::OpenError, QString::fromNSString(error.localizedDescription));
                dispatch_semaphore_signal(semaphore);
            }];
        });
 
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        dispatch_release(semaphore);
 
        g_assetDataCache.setLocalData(this);
    }
 
    ~QIOSAssetData()
    {
        [m_assetLibrary release];
        [m_asset release];
        if (g_assetDataCache.localData() == this)
            g_assetDataCache.setLocalData(0);
    }
 
    ALAsset *m_asset;
 
private:
    QString m_assetUrl;
    ALAssetsLibrary *m_assetLibrary;
};
 
// -------------------------------------------------------------------------
 
#ifndef QT_NO_FILESYSTEMITERATOR
 
class QIOSFileEngineIteratorAssetsLibrary : public QAbstractFileEngineIterator
{
public:
    QIOSAssetEnumerator *m_enumerator;
 
    QIOSFileEngineIteratorAssetsLibrary(
            const QString &path, QDirListing::IteratorFlags filters, const QStringList &nameFilters)
        : QAbstractFileEngineIterator(path, filters, nameFilters)
        , m_enumerator(new QIOSAssetEnumerator([[[ALAssetsLibrary alloc] init] autorelease], ALAssetsGroupAll))
    {
    }
 
    ~QIOSFileEngineIteratorAssetsLibrary()
    {
        delete m_enumerator;
        g_iteratorCurrentUrl.setLocalData(QString());
    }
 
    bool advance() override
    {
        if (!m_enumerator->hasNext())
            return false;
 
        // Cache the URL that we are about to return, since QDir will immediately create a
        // new file engine on the file and ask if it exists. Unless we do this, we end up
        // creating a new ALAsset just to verify its existence, which will be especially
        // costly for assets belonging to ALAssetsGroupPhotoStream.
        ALAsset *asset = m_enumerator->next();
        QString url = QUrl::fromNSURL([asset valueForProperty:ALAssetPropertyAssetURL]).toString();
        g_iteratorCurrentUrl.setLocalData(url);
        return true;
    }
 
    QString currentFileName() const override
    {
        return g_iteratorCurrentUrl.localData();
    }
 
    QFileInfo currentFileInfo() const override
    {
        return QFileInfo(currentFileName());
    }
};
 
#endif
 
// -------------------------------------------------------------------------
 
QIOSFileEngineAssetsLibrary::QIOSFileEngineAssetsLibrary(const QString &fileName)
    : m_offset(0)
    , m_data(0)
{
    setFileName(fileName);
}
 
QIOSFileEngineAssetsLibrary::~QIOSFileEngineAssetsLibrary()
{
    close();
}
 
ALAsset *QIOSFileEngineAssetsLibrary::loadAsset() const
{
    if (!m_data)
        m_data = new QIOSAssetData(m_assetUrl, const_cast<QIOSFileEngineAssetsLibrary *>(this));
    return m_data->m_asset;
}
 
bool QIOSFileEngineAssetsLibrary::open(QIODevice::OpenMode openMode,
                                       std::optional<QFile::Permissions> permissions)
{
    Q_UNUSED(permissions);
 
    if (openMode & (QIODevice::WriteOnly | QIODevice::Text))
        return false;
    return loadAsset();
}
 
bool QIOSFileEngineAssetsLibrary::close()
{
    if (m_data) {
        // Delete later, so that we can reuse the asset if a QFile is
        // opened with the same path during the same event loop cycle.
        m_data->deleteLater();
        m_data = nullptr;
    }
    return true;
}
 
QAbstractFileEngine::FileFlags QIOSFileEngineAssetsLibrary::fileFlags(QAbstractFileEngine::FileFlags type) const
{
    QAbstractFileEngine::FileFlags flags;
    const bool isDir = (m_assetUrl == "assets-library://"_L1);
    if (!isDir) {
        static const QFileSelector fileSelector;
        static const auto selectors = fileSelector.allSelectors();
        if (m_assetUrl.startsWith("assets-library://"_L1)) {
            for (const auto &selector : selectors) {
                if (m_assetUrl.endsWith(selector))
                    return flags;
            }
        }
    }
 
    const bool exists = isDir || m_assetUrl == g_iteratorCurrentUrl.localData() || loadAsset();
 
    if (!exists)
        return flags;
 
    if (type & FlagsMask)
        flags |= ExistsFlag;
    if (type & PermsMask) {
        ALAuthorizationStatus status = [ALAssetsLibrary authorizationStatus];
        if (status != ALAuthorizationStatusRestricted && status != ALAuthorizationStatusDenied)
            flags |= ReadOwnerPerm | ReadUserPerm | ReadGroupPerm | ReadOtherPerm;
    }
    if (type & TypesMask)
        flags |= isDir ? DirectoryType : FileType;
 
    return flags;
}
 
qint64 QIOSFileEngineAssetsLibrary::size() const
{
    if (ALAsset *asset = loadAsset())
        return [[asset defaultRepresentation] size];
    return 0;
}
 
qint64 QIOSFileEngineAssetsLibrary::read(char *data, qint64 maxlen)
{
    ALAsset *asset = loadAsset();
    if (!asset)
        return -1;
 
    qint64 bytesRead = qMin(maxlen, size() - m_offset);
    if (!bytesRead)
        return 0;
 
    NSError *error = nullptr;
    [[asset defaultRepresentation] getBytes:(uint8_t *)data fromOffset:m_offset length:bytesRead error:&error];
 
    if (error) {
        setError(QFile::ReadError, QString::fromNSString(error.localizedDescription));
        return -1;
    }
 
    m_offset += bytesRead;
    return bytesRead;
}
 
qint64 QIOSFileEngineAssetsLibrary::pos() const
{
    return m_offset;
}
 
bool QIOSFileEngineAssetsLibrary::seek(qint64 pos)
{
    if (pos >= size())
        return false;
    m_offset = pos;
    return true;
}
 
QString QIOSFileEngineAssetsLibrary::fileName(FileName file) const
{
    Q_UNUSED(file);
    return m_fileName;
}
 
void QIOSFileEngineAssetsLibrary::setFileName(const QString &file)
{
    if (m_data)
        close();
    m_fileName = file;
    // QUrl::fromLocalFile() will remove double slashes. Since the asset url is
    // passed around as a file name in the app (and converted to/from a file url, e.g
    // in QFileDialog), we need to ensure that m_assetUrl ends up being valid.
    qsizetype index = file.indexOf("/asset"_L1);
    if (index == -1)
        m_assetUrl = "assets-library://"_L1;
    else
        m_assetUrl = "assets-library:/"_L1 + file.mid(index);
}
 
#ifndef QT_NO_FILESYSTEMITERATOR
 
QAbstractFileEngine::IteratorUniquePtr
QIOSFileEngineAssetsLibrary::beginEntryList(
    const QString &path, QDirListing::IteratorFlags filters, const QStringList &filterNames)
{
    return std::make_unique<QIOSFileEngineIteratorAssetsLibrary>(path, filters, filterNames);
}
 
QT_END_NAMESPACE
 
#endif