mythmedia.h

Go to the documentation of this file.

#ifndef MYTH_MEDIA_H
#define MYTH_MEDIA_H
 
#include <QObject>
#include <QMap>
#include <QString>
#include <QEvent>
#include <QPointer>
 
#include "mythbaseexp.h"
 
enum MythMediaStatus : std::uint8_t {
    MEDIASTAT_ERROR,        
    MEDIASTAT_UNKNOWN,
    MEDIASTAT_UNPLUGGED,
    MEDIASTAT_OPEN,         
    MEDIASTAT_NODISK,       
    MEDIASTAT_UNFORMATTED,  
    MEDIASTAT_USEABLE,
    MEDIASTAT_NOTMOUNTED,
    MEDIASTAT_MOUNTED
};
 
enum MythMediaType : std::uint16_t {
    MEDIATYPE_UNKNOWN  = 0x0001,
    MEDIATYPE_DATA     = 0x0002,
    MEDIATYPE_MIXED    = 0x0004,
    MEDIATYPE_AUDIO    = 0x0008,
    MEDIATYPE_DVD      = 0x0010,
    MEDIATYPE_VCD      = 0x0020,
    MEDIATYPE_MMUSIC   = 0x0040,
    MEDIATYPE_MVIDEO   = 0x0080,
    MEDIATYPE_MGALLERY = 0x0100,
    MEDIATYPE_BD       = 0x0200,
    MEDIATYPE_END      = 0x0400,
};
// MediaType conflicts with a definition within OSX Quicktime Libraries.
 
enum MythMediaError : std::uint8_t {
    MEDIAERR_OK,
    MEDIAERR_FAILED,
    MEDIAERR_UNSUPPORTED
};
 
using ext_cnt_t = QMap<QString,uint>;
using ext_to_media_t = QMap<QString,uint>;
 
class MBASE_PUBLIC MythMediaDevice : public QObject
{
    Q_OBJECT
    friend class MediaMonitorDarwin;   // So these can call setStatus(),
    friend class MonitorThreadDarwin;  // and trigger posting of MythMediaEvents
 
 public:
    MythMediaDevice(QObject* par, QString DevicePath, bool SuperMount,
                    bool AllowEject);
 
    const QString& getMountPath() const { return m_mountPath; }
    void setMountPath(const char *path) { m_mountPath = path; }
 
    const QString& getDevicePath() const { return m_devicePath; }
 
    const QString& getRealDevice() const
    { return !m_realDevice.isEmpty() ? m_realDevice : m_devicePath; }
 
 
    const QString& getDeviceModel() const  { return m_deviceModel;  }
    void setDeviceModel(const char *model) { m_deviceModel = model; }
 
    MythMediaStatus getStatus() const { return m_status; }
 
    const QString& getVolumeID() const { return m_volumeID; }
    void  setVolumeID(const char *vol)  { m_volumeID = vol; }
 
    const QString& getKeyID() const { return m_keyID; }
 
    bool getAllowEject() const { return m_allowEject; }
 
    bool getLocked() const { return m_locked; }
 
    bool isDeviceOpen() const;
 
    bool isUsable() const
    {
        return m_status == MEDIASTAT_USEABLE
            || m_status == MEDIASTAT_MOUNTED
            || m_status == MEDIASTAT_NOTMOUNTED;
    }
 
    MythMediaType getMediaType() const { return m_mediaType; }
 
    bool isSuperMount()      const { return m_superMount; }
 
    virtual MythMediaError  testMedia() { return MEDIAERR_UNSUPPORTED; }
    virtual bool openDevice();
    virtual bool closeDevice();
    virtual bool isSameDevice(const QString &path);
    virtual void setSpeed(int speed);
    virtual void setDeviceSpeed(const char * /*devicePath*/, int /*speed*/) { }
    virtual MythMediaStatus checkMedia() = 0;// Derived classes MUST implement this.
    virtual MythMediaError eject(bool open_close = true);
    virtual MythMediaError lock();
    virtual MythMediaError unlock();
    virtual bool performMountCmd( bool DoMount );
 
    bool mount()   { return performMountCmd(true);  }
    bool unmount() { return performMountCmd(false); }
 
    bool isMounted(bool bVerify = true);
    bool findMountPath();
 
    static void RegisterMediaExtensions(uint mediatype,
                                 const QString& extensions);
 
 
    static const std::array<const QString,9> kMediaStatusStrings;
    static const std::array<const QString,3> kMediaErrorStrings;
 
    void clearData();
 
    QString MediaTypeString();
 
    static QString MediaTypeString(uint type);
 
 signals:
    void statusChanged(MythMediaStatus oldStatus, MythMediaDevice* pMedia);
 
 protected:
    ~MythMediaDevice() override = default; // use deleteLater...
 
    virtual void onDeviceMounted(void)
    {
        MythMediaType type = DetectMediaType();
        if (type != MEDIATYPE_UNKNOWN)
            m_mediaType = type;
    }
 
    virtual void onDeviceUnmounted() {};
 
    MythMediaType DetectMediaType(void);
    bool ScanMediaType(const QString &directory, ext_cnt_t &cnt);
 
    MythMediaStatus setStatus(MythMediaStatus newStat, bool CloseIt=false);
 
    QString m_deviceModel;   
    QString m_devicePath;    
    QString m_keyID;         
    QString m_mountPath;     
    QString m_realDevice;    
    QString m_volumeID;      
 
    MythMediaStatus m_status {MEDIASTAT_UNKNOWN};
    MythMediaType   m_mediaType {MEDIATYPE_UNKNOWN};
 
    bool m_allowEject;       
    bool m_locked {false};   
 
    bool m_superMount;       
 
 
    int  m_deviceHandle {-1};
 private:
    static ext_to_media_t s_ext_to_media; 
};
 
class MBASE_PUBLIC MythMediaEvent : public QEvent
{
  public:
    MythMediaEvent(MythMediaStatus oldStatus, MythMediaDevice *pDevice) :
        QEvent(kEventType), m_oldStatus(oldStatus), m_device(pDevice) {}
    ~MythMediaEvent() override;
 
    MythMediaStatus getOldStatus(void) const { return m_oldStatus; }
    MythMediaDevice* getDevice(void) { return m_device.isNull() ? nullptr : m_device.data(); }
 
    static const Type kEventType;
 
  protected:
    MythMediaStatus m_oldStatus;
    QPointer<MythMediaDevice> m_device;
};
 
#endif