imagemanager.h

Go to the documentation of this file.

 
/* Myth uses two Gallery instances;
 *
 * One runs on the BE to manage the 'Photographs' Storage Group. The (permanent)
 * database table is synchronised to SG files, thumbnails are generated and stored
 * in the Temp SG, and BE messages for these images are handled.
 *
 * A separate instance runs on each FE to manage local/removeable media. This uses
 * a temporary, memory Db table that is synchronised to images on USB/CDs etc,
 * as they are mounted. Thumbnails are generated/stored on the FE and operations on
 * these images are handled locally. The Db table and all thumbnails are removed
 * when the FE exits.
 *
 * The UI integrates images/functions from both instances seamlessly.
 *
 * Commonality is provided by using an adapter layer for database and filesystem access.
 * Functionality is segregated into local classes, which are layered on an
 * adapter to assemble singletons for a BE manager & FE manager - the only
 * elements intended for external use.
 *
 *                              Device manager
 *                                    |
 *                              Common Adapter
 *                              /             \
 *                  BE adapter                  FE adapter
 *                       |      Common Db API       |
 *                       |      /             \     |
 *                  BE Db functions             FE Db functions
 *                       |      Common Handler      |
 *                       |      /             \     |
 *                  BE manager                  UI Db API
 *                                                  |
 *                                              FE manager
 *
 * Implemented using templates rather than polymorphism for speed/efficiency.
 */
 
#ifndef IMAGEMANAGER_H
#define IMAGEMANAGER_H
 
#include <utility>
 
// Qt headers
#include <QTemporaryDir>
 
// MythTV headers
#include "libmythbase/mythcorecontext.h"
#include "libmythbase/mythdirs.h"
#include "libmythbase/storagegroup.h"
 
#include "imagescanner.h"
#include "imagemetadata.h"
 
 
// Builtin storage groups as per storagegroup.cpp
static constexpr const char* IMAGE_STORAGE_GROUP      { "Photographs" };
static constexpr const char* THUMBNAIL_STORAGE_GROUP  { "Temp" };
 
// Filesystem dir within config dir used by TEMP SG
static constexpr const char* TEMP_SUBDIR              { "tmp" };
// Filesystem dir within tmp config dir where thumbnails reside
static constexpr const char* THUMBNAIL_SUBDIR         { "Images" };
 
static constexpr int DEVICE_INVALID { -1 };
 
class MythMediaDevice;
class MythMediaEvent;
 
enum ImageDisplayType {
    kPicAndVideo = 0, 
    kPicOnly     = 1, 
    kVideoOnly   = 2  
};
 
class Device;
 
class META_PUBLIC DeviceManager
{
public:
    QStringList CloseDevices(int devId, const QString &action);
    QString DeviceMount(int devId) const;
    QString DeviceName(int devId) const;
    int     DeviceCount() const   { return m_devices.size(); }
    QString     ThumbDir(int fs) const;
 
protected:
    int     OpenDevice(const QString &name, const QString &mount,
                       MythMediaDevice *media = nullptr,
                       QTemporaryDir   *dir = nullptr);
 
    int         LocateMount(const QString &mount) const;
    StringMap   GetDeviceDirs() const;
    QList<int>  GetAbsentees();
 
    DeviceManager() = default;
    ~DeviceManager();
 
private:
    using DeviceMap = QMap<int, Device*>;
 
    DeviceMap m_devices;
};
 
 
class META_PUBLIC ImageAdapterBase : public DeviceManager
{
public:
    static QStringList SupportedImages();
 
    static QStringList SupportedVideos();
 
    static QString ConstructPath(const QString &path, const QString &name)
    {  return path.isEmpty() ? name : path + "/" + name; }
 
    static QString BaseNameOf(const QString &path)
    { QString result = path.section('/', -1); return result.isNull() ? "" : result; }
 
    static QString PathOf(const QString &path)
    { QString result = path.section('/', 0, -2); return result.isNull() ? "" : result; }
 
    static QString FormatSize(int sizeKib)
    {  return (sizeKib < 10000) ? QString("%L1 KiB").arg(sizeKib)
                                : QString("%L1 MiB").arg(sizeKib / 1024.0, 0, 'f', 1); }
 
    static QString GetAbsThumbPath(const QString &devPath, const QString &path)
    {
        QString dirFmt = QString("%1/") % TEMP_SUBDIR % "/%2/%3";
        return dirFmt.arg(GetConfDir(), devPath, path);
    }
 
    static QString ThumbPath(const ImageItem &im)
    { return im.m_type != kVideoFile ? im.m_filePath : im.m_filePath + ".jpg"; }
 
    QDir GetImageFilters() const { return m_dirFilter; }
 
    ImageNodeType GetImageType(const QString &ext) const
    { return m_imageFileExt.contains(ext)
                ? kImageFile
                : m_videoFileExt.contains(ext) ? kVideoFile : kUnknown; }
protected:
    ImageAdapterBase();
    virtual ~ImageAdapterBase() = default;
 
private:
    QDir        m_dirFilter;
    QStringList m_imageFileExt;
    QStringList m_videoFileExt;
};
 
 
class ImageAdapterLocal : public ImageAdapterBase
{
public:
    ImageAdapterLocal() = default;
 
    ImageItem *CreateItem(const QFileInfo &fi, int parentId, int devId,
                          const QString &base) const;
 
    StringMap GetScanDirs() const  { return GetDeviceDirs(); }
 
    static QString GetAbsFilePath(const ImagePtrK &im)
    { return im->m_filePath; }
 
    static QString MakeFileUrl(const QString &path) { return path; }
 
    static QString MakeThumbUrl(const QString &devPath, const QString &path = "")
    { return GetAbsThumbPath(devPath, path); }
 
    static void Notify(const QString &mesg, const QStringList &extra) ;
 
protected:
    // Adapter functions used by Database for local images. Negate ids in & out
    static int     ImageId(int id)            { return ImageItem::ToLocalId(id); }
    static QString ImageId(const QString &id) { return ImageItem::ToLocalId(id); }
    static int     DbId(int id)               { return ImageItem::ToDbId(id); }
    static QString DbIds(const QString &ids)  { return ImageItem::ToDbId(ids); }
};
 
 
class ImageAdapterSg : public ImageAdapterBase
{
public:
    ImageAdapterSg() :
        m_hostname(gCoreContext->GetMasterHostName()),
        m_hostport(MythCoreContext::GetMasterServerPort()),
        m_sg(StorageGroup(IMAGE_STORAGE_GROUP, m_hostname, false)) {}
 
    ImageItem *CreateItem(const QFileInfo &fi, int parentId, int devId,
                          const QString &base) const;
    StringMap  GetScanDirs() const;
    QString    GetAbsFilePath(const ImagePtrK &im) const;
 
    QString MakeFileUrl(const QString &path) const
    { return MythCoreContext::GenMythURL(m_hostname, m_hostport, path,
                                      IMAGE_STORAGE_GROUP); }
 
    QString MakeThumbUrl(const QString &devPath, const QString &path = "") const
    { return MythCoreContext::GenMythURL(m_hostname, m_hostport,
                                      devPath + "/" + path,
                                      THUMBNAIL_STORAGE_GROUP); }
 
    static void Notify(const QString &mesg, const QStringList &extra) ;
 
protected:
    // Adapter functions used by Database for remote images. Do nothing
    static int     ImageId(int id)            { return id; }
    static QString ImageId(const QString &id) { return id; }
    static int     DbId(int id)               { return id; }
    static QString DbIds(const QString &ids)  { return ids; }
 
private:
    QString m_hostname;
    int m_hostport;
    // Marked mutable as storagegroup.h does not enforce const-correctness
    mutable StorageGroup m_sg;
};
 
 
template <class FS>
class META_PUBLIC ImageDb : public FS
{
public:
    // Handler support
    int         GetImages(const QString &ids, ImageList &files, ImageList &dirs,
                          const QString &refine = "") const;
    bool        GetDescendants(const QString &ids,
                               ImageList &files, ImageList &dirs) const;
    int         InsertDbImage(ImageItemK &im, bool checkForDuplicate = false) const;
    bool        UpdateDbImage(ImageItemK &im) const;
    QStringList RemoveFromDB(const ImageList &imList) const;
 
    bool SetHidden(bool hide, const QString &ids) const;
    bool SetCover(int dir, int id) const;
    bool SetOrientation(int id, int orientation) const;
 
    // Scanner support
    bool ReadAllImages(ImageHash &files, ImageHash &dirs) const;
    void ClearDb(int devId, const QString &action);
 
    // ImageReader support
    int  GetChildren(const QString &ids, ImageList &files, ImageList &dirs,
                     const QString &refine = "") const;
    bool GetImageTree(int id, ImageList &files, const QString &refine) const;
    int  GetDirectory(int id, ImagePtr &parent, ImageList &files, ImageList &dirs,
                      const QString &refine) const;
    void GetDescendantCount(int id, bool all, int &dirs, int &pics,
                            int &videos, int &sizeKb) const;
 
protected:
    explicit ImageDb(QString table) : FS(), m_table(std::move(table)) {}
 
    ImageItem *CreateImage(const MSqlQuery &query) const;
    int        ReadImages(ImageList &dirs, ImageList &files,
                          const QString &selector) const;
    QString m_table;
};
 
 
class META_PUBLIC ImageDbSg : public ImageDb<ImageAdapterSg>
{
public:
    ImageDbSg();
};
 
 
class META_PUBLIC ImageDbLocal : public ImageDb<ImageAdapterLocal>
{
protected:
    ImageDbLocal();
    ~ImageDbLocal() override          { DropTable(); }
    bool CreateTable();
    bool m_dbExists { false };
 
private:
    void DropTable();
};
 
 
template <class DBFS>
class META_PUBLIC ImageHandler : protected DBFS
{
public:
    QStringList HandleRename(const QString &id, const QString &newBase) const;
    QStringList HandleDelete(const QString &ids) const;
    QStringList HandleDbCreate(QStringList defs) const;
    QStringList HandleDbMove(const QString &ids, const QString &srcPath, QString destPath) const;
    QStringList HandleHide(bool hide, const QString &ids) const;
    QStringList HandleTransform(int transform, const QString &ids) const;
    QStringList HandleDirs(const QString &destId, bool rescan,
                           const QStringList &relPaths) const;
    QStringList HandleCover(int dir, int cover) const;
    QStringList HandleIgnore(const QString &exclusions) const;
    QStringList HandleScanRequest(const QString &command, int devId = DEVICE_INVALID) const;
    QStringList HandleCreateThumbnails(const QStringList &message) const;
    QStringList HandleGetMetadata(const QString &id) const;
 
protected:
    ImageHandler() : DBFS(),
        m_thumbGen(new ImageThumb<DBFS>(this)),
        m_scanner(new ImageScanThread<DBFS>(this, m_thumbGen)) {}
 
    ~ImageHandler() override
    {
        delete m_scanner;
        delete m_thumbGen;
    }
 
    void RemoveFiles(ImageList &images) const;
 
    ImageThumb<DBFS>      *m_thumbGen {nullptr}; 
    ImageScanThread<DBFS> *m_scanner  {nullptr}; 
};
 
 
class META_PUBLIC ImageManagerBe : protected QObject, public ImageHandler<ImageDbSg>
{
public:
    static ImageManagerBe* getInstance();
 
protected:
    ImageManagerBe()
    {
        // Cleanup & terminate child threads before application exits
        connect(qApp, &QCoreApplication::aboutToQuit, this, &QObject::deleteLater);
    }
 
    static ImageManagerBe *s_instance;
};
 
 
class META_PUBLIC ImageDbReader : protected ImageHandler<ImageDbLocal>
{
public:
    ~ImageDbReader() override { delete m_remote; }
 
    int  GetType() const        { return m_showType; }
    bool GetVisibility() const  { return m_showHidden; }
 
    void SetType(int showType)
    { m_showType = showType; SetRefinementClause(); }
 
    void SetSortOrder(int order, int dirOrder)
    { m_dirOrder = dirOrder; m_fileOrder = order; SetRefinementClause(); }
 
    void SetVisibility(bool showHidden)
    { m_showHidden = showHidden; SetRefinementClause(); }
 
    int  GetImages(const ImageIdList& ids, ImageList &files, ImageList &dirs) const;
    int  GetChildren(int id, ImageList &files, ImageList &dirs) const;
    int  GetDirectory(int id, ImagePtr &parent,
                      ImageList &files, ImageList &dirs) const;
    void GetDescendants(const ImageIdList &ids,
                        ImageList &files, ImageList &dirs) const;
    void GetImageTree(int id, ImageList &files) const;
    void GetDescendantCount(int id, int &dirs, int &pics, int &videos,
                            int &sizeKb) const;
protected:
    ImageDbReader(int order, int dirOrder, bool showAll, int showType)
        : m_remote(new ImageDbSg()),
          m_dirOrder(dirOrder),  m_fileOrder(order),
          m_showHidden(showAll), m_showType(showType)
    { SetRefinementClause(); }
 
    void SetRefinementClause();
 
    static QString TypeSelector(int type);
    static QString OrderSelector(int order);
 
    ImageDbSg* m_remote;    
 
    int     m_dirOrder;     
    int     m_fileOrder;    
    bool    m_showHidden;   
    int     m_showType;     
    QString m_refineClause; 
};
 
 
class META_PUBLIC ImageManagerFe : protected QObject, public ImageDbReader
{
    Q_DECLARE_TR_FUNCTIONS(ImageManagerFe);
public:
    static ImageManagerFe &getInstance();
 
    // UI actions on all images
    void        CreateThumbnails(const ImageIdList &ids, bool forFolder);
    QString     ScanImagesAction(bool start, bool local = false);
    static QStringList ScanQuery();
    QString     HideFiles(bool hidden, const ImageIdList &ids);
    QString     ChangeOrientation(ImageFileTransform transform, const ImageIdList &ids);
    QString     SetCover(int parent, int cover);
    void        RequestMetaData(int id);
    static QString     IgnoreDirs(const QString &excludes);
    QString     MakeDir(int parent, const QStringList &names, bool rescan = true);
    QString     RenameFile(const ImagePtrK& im, const QString &name);
    QString     CreateImages(int destId, const ImageListK &images);
    QString     MoveDbImages(const ImagePtrK& destDir, ImageListK &images, const QString &srcPath);
    QString     DeleteFiles(const ImageIdList &ids);
    static void ClearStorageGroup();
    void        CloseDevices(int devId = DEVICE_INVALID, bool eject = false);
 
    using ImageAdapterBase::ConstructPath;
 
    // Local Device management
    bool    DetectLocalDevices();
    void    DeviceEvent(MythMediaEvent *event);
    QString CreateImport();
    using  DeviceManager::DeviceCount;
    using  DeviceManager::OpenDevice;
 
    // UI helper functions
    void SetDateFormat(const QString &format)    { m_dateFormat = format; }
    static QString LongDateOf(const ImagePtrK &im) ;
    QString ShortDateOf(const ImagePtrK &im) const;
    QString DeviceCaption(ImageItemK &im) const;
    QString CrumbName(ImageItemK &im, bool getPath = false) const;
 
    QString BuildTransferUrl(const QString &path, bool local) const
    { return local ? ImageDbReader::MakeFileUrl(path)
                   : m_remote->MakeFileUrl(path); }
 
protected:
    ImageManagerFe(int order, int dirOrder, bool showAll, int showType,
                   QString dateFormat)
        : ImageDbReader(order, dirOrder, showAll, showType),
          m_dateFormat(std::move(dateFormat))
    {
        // Cleanup & terminate child threads before application exits
        connect(qApp, &QCoreApplication::aboutToQuit, this, &QObject::deleteLater);
    }
 
    static ImageManagerFe *s_instance;
 
    QString    m_dateFormat;
};
 
 
#endif // IMAGEMANAGER_H