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 "mythcorecontext.h"
#include "storagegroup.h"
#include "mythdirs.h"

#include "imagescanner.h"
#include "imagemetadata.h"


// Builtin storage groups as per storagegroup.cpp
#define IMAGE_STORAGE_GROUP         "Photographs"
#define THUMBNAIL_STORAGE_GROUP     "Temp"

// Filesystem dir within config dir used by TEMP SG
#define TEMP_SUBDIR                 "tmp"
// Filesystem dir within tmp config dir where thumbnails reside
#define THUMBNAIL_SUBDIR            "Images"

#define 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)
    { return QString("%1/" TEMP_SUBDIR "/%2/%3").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, 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(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, SIGNAL(aboutToQuit()), this, SLOT(deleteLater()));
    }

    static ImageManagerBe *s_instance;
};


class META_PUBLIC ImageDbReader : protected ImageHandler<ImageDbLocal>
{
public:
    ~ImageDbReader() override { delete m_remote; }

    int  GetType()        { return m_showType; }
    bool GetVisibility()  { 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, SIGNAL(aboutToQuit()), this, SLOT(deleteLater()));
    }

    static ImageManagerFe *s_instance;

    QString    m_dateFormat;
};


#endif // IMAGEMANAGER_H