Ticket #1753: mythmediamonitor-darwin.3.cpp

#include "mythmediamonitor.h"
#include "mythmediamonitor-darwin.h"
#include "mythcdrom.h"
#include "mythmedia.h"

#include <mythtv/mythcontext.h>

#include <IOKit/IOKitLib.h>
#include <IOKit/storage/IOMedia.h>
#include <IOKit/storage/IOCDMedia.h>
#include <IOKit/storage/IODVDMedia.h>

static mach_port_t            sMasterPort;

MediaType FindDVDOrCDMedia(io_service_t service)
{
    kern_return_t    kernResult;
    io_iterator_t    iter;
    MediaType mediaType = MEDIATYPE_UNKNOWN;
    bool isWholeMedia = false;
    
    // Create an iterator across all parents of the service object passed in.
    kernResult = IORegistryEntryCreateIterator(service,
                                               kIOServicePlane,
                                               kIORegistryIterateRecursively | kIORegistryIterateParents,
                                               &iter);
    
    if (KERN_SUCCESS != kernResult)
    {
        VERBOSE(VB_IMPORTANT, QString("FindDVDMedia - IORegistryEntryCreateIterator returned %1").arg(kernResult));
    }
    else if (!iter)
    {
        VERBOSE(VB_IMPORTANT, "FindDVDMedia - IORegistryEntryCreateIterator returned a NULL iterator");
    }
    else
    {
        // A reference on the initial service object is released in the do-while loop below,
        // so add a reference to balance 
        IOObjectRetain(service);    
        
        do
        {
            isWholeMedia = false;
            if (IOObjectConformsTo(service, kIOMediaClass))
            {
                
                CFTypeRef wholeMedia;
                
                wholeMedia = IORegistryEntryCreateCFProperty(service, 
                                                             CFSTR(kIOMediaWholeKey), 
                                                             kCFAllocatorDefault, 
                                                             0);
                                                            
                if (NULL == wholeMedia)
                {
                    VERBOSE(VB_IMPORTANT, "IsDVDMedia - Could not retrieve Whole property");
                }
                else
                {                                        
                    isWholeMedia = CFBooleanGetValue((CFBooleanRef)wholeMedia);
                    CFRelease(wholeMedia);
                }
            }
        
            if (isWholeMedia && (IOObjectConformsTo(service, kIODVDMediaClass)))
            {
                mediaType = MEDIATYPE_DVD;
            }
            else if (isWholeMedia && (IOObjectConformsTo(service, kIOCDMediaClass)))
            {
                mediaType = MEDIATYPE_AUDIO;
            }
            IOObjectRelease(service);
        } while ((service = IOIteratorNext(iter)) && (mediaType == MEDIATYPE_UNKNOWN));

        IOObjectRelease(iter);
    }
    return mediaType;
}

MediaType MediaTypeForBSDName(const char *bsdName)
{
    CFMutableDictionaryRef    matchingDict;
    kern_return_t        kernResult;
    io_iterator_t         iter;
    io_service_t        service;
    MediaType mediaType = MEDIATYPE_UNKNOWN;
    
    matchingDict = IOBSDNameMatching(sMasterPort, 0, bsdName);
    if (NULL == matchingDict)
    {
        VERBOSE(VB_IMPORTANT, QString("IsDVDMediaForName(%1) - IOBSDNameMatching returned a NULL dictionary.").arg(bsdName));
    }
    else
    {
        // Return an iterator across all objects with the matching BSD node name. Note that there
        // should only be one match!
        kernResult = IOServiceGetMatchingServices(sMasterPort, matchingDict, &iter);    
    
        if (KERN_SUCCESS != kernResult)
        {
            VERBOSE(VB_IMPORTANT, QString("IIsDVDMediaForName - IOServiceGetMatchingServices returned %1").arg(kernResult));
        }
        else if (!iter)
        {
            VERBOSE(VB_IMPORTANT, "IIsDVDMediaForName - IOServiceGetMatchingServices returned a NULL iterator");
        }
        else
        {
            service = IOIteratorNext(iter);
            
            // Release this now because we only expect the iterator to contain
            // a single io_service_t.
            IOObjectRelease(iter);
            
            if (!service)
            {
                VERBOSE(VB_IMPORTANT, "IIsDVDMediaForName - IOIteratorNext returned a NULL iterator");
            }
            else
            {
                mediaType = FindDVDOrCDMedia(service);
                IOObjectRelease(service);
            }
        }
    }
    return mediaType;
}


void diskAppearedCallback(DADiskRef disk, void *context)
{
    // Find out if the new disk is a DVD (or CD)
    MediaType mediaType = MediaTypeForBSDName(DADiskGetBSDName(disk));
    if (context && ((mediaType == MEDIATYPE_DVD) || (mediaType == MEDIATYPE_AUDIO)))
    {
        // Add new device
        reinterpret_cast<MonitorThreadDarwin*>(context)->diskAppeared(DADiskGetBSDName(disk));
    }
}

void diskDisappearedCallback(DADiskRef disk, void *context)
{
    if (context)
        reinterpret_cast<MonitorThreadDarwin *>(context)->diskDisappeared(DADiskGetBSDName(disk));
}

MonitorThreadDarwin::MonitorThreadDarwin( MediaMonitor* pMon,  unsigned long interval) : 
    MonitorThread(pMon, interval)
{
}

// Nice and simple, as long as our monitor is valid and active, 
// loop and check it's devices.
void MonitorThreadDarwin::run(void)
{
    registerDiskArbitrationCallbacks();

    while (m_Monitor && m_Monitor->IsActive())        
    {
        m_Monitor->CheckDevices();
        // Run the run loop for interval (milliseconds) - this will handle any disk arbitration
        // appeared/dissappeared events
        CFRunLoopRunInMode(kCFRunLoopDefaultMode, (float) m_Interval / 1000.0f, false );
    }

    unregisterDiskArbitrationCallbacks();
}

void MonitorThreadDarwin::diskAppeared(QString devName)
{
        MythMediaDevice *media = MythCDROM::get(m_Monitor, devName, true, m_Monitor->m_AllowEject);
        m_Monitor->AddDevice(media);
}

void MonitorThreadDarwin::diskDisappeared(QString devName)
{
        m_Monitor->RemoveDevice(devName);
}

void MonitorThreadDarwin::registerDiskArbitrationCallbacks()
{
    m_DiskArbitrationSession = (void *) DASessionCreate(kCFAllocatorDefault);
    DARegisterDiskAppearedCallback( (DASessionRef) m_DiskArbitrationSession, kDADiskDescriptionMatchVolumeMountable, diskAppearedCallback, this);
    DARegisterDiskDisappearedCallback( (DASessionRef) m_DiskArbitrationSession, kDADiskDescriptionMatchVolumeMountable, diskDisappearedCallback, this);

    DASessionScheduleWithRunLoop((DASessionRef) m_DiskArbitrationSession, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
}

void MonitorThreadDarwin::unregisterDiskArbitrationCallbacks()
{
    CFRelease((DASessionRef) m_DiskArbitrationSession);
}

/** \fn MediaMonitor::StartMonitoring(void)
 *  \brief Start the monitoring thread if needed.
 */
void MediaMonitorDarwin::StartMonitoring(void)
{
    // Sanity check
    if (m_Active)
        return;

    if (!m_Thread)
    {
        m_Thread = new MonitorThreadDarwin(this, m_MonitorPollingInterval);
    }
    m_Active = true;
    m_Thread->start();
}

// Given a media device add it to our collection.
bool MediaMonitorDarwin::AddDevice(MythMediaDevice* pDevice)
{
    if ( ! pDevice )
    {
        VERBOSE(VB_IMPORTANT, "Error - MediaMonitor::AddDevice(null)");
        return false;
    }

    QMutexLocker locker(&m_DevicesLock);

    connect(pDevice, SIGNAL(statusChanged(MediaStatus, MythMediaDevice*)), 
            this, SLOT(mediaStatusChanged(MediaStatus, MythMediaDevice*)));
    m_Devices.push_back( pDevice );
    m_UseCount[pDevice] = 0;

    return true;
}