Ticket #2598: mtd-darwin.cpp

#include "mtd-darwin.h"

#include <mythtv/mythcontext.h>
#include <mythtv/mythmedia.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/storage/IOMedia.h>
#include <IOKit/storage/IOCDMedia.h>
#include <IOKit/storage/IODVDMedia.h>
#include <DiskArbitration/DiskArbitration.h>

static mach_port_t sMasterPort;

DarwinDiscCheckingThread::DarwinDiscCheckingThread(MTD *owner,
                    DVDProbe *probe, 
                    QMutex *drive_access_mutex,
                    QMutex *mutex_for_titles) : DiscCheckingThread(owner, probe, drive_access_mutex, mutex_for_titles)
{
}


/**
 * Guess the media that a volume/partition is on
 */
MediaType FindMediaType(io_service_t service)
{
    kern_return_t  kernResult;
    io_iterator_t  iter;
    MediaType      mediaType = MEDIATYPE_UNKNOWN;
    QString        msg = QString("FindMediaType() - ");
    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, (msg + "IORegistryEntryCreateIterator"
                                   + " returned %1").arg(kernResult));
    else if (!iter)
        VERBOSE(VB_IMPORTANT, msg + "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,
                            msg + "Could not retrieve Whole property");
                else
                {
                    isWholeMedia = CFBooleanGetValue((CFBooleanRef)wholeMedia);
                    CFRelease(wholeMedia);
                }
            }

            if (isWholeMedia)
            {
                if (IOObjectConformsTo(service, kIODVDMediaClass))
                    mediaType = MEDIATYPE_DVD;
                else if (IOObjectConformsTo(service, kIOCDMediaClass))
                    mediaType = MEDIATYPE_AUDIO;
            }

            IOObjectRelease(service);

        } while ((service = IOIteratorNext(iter))
                 && (mediaType == MEDIATYPE_UNKNOWN));

        IOObjectRelease(iter);
    }
    return mediaType;
}

/**
 * Given a BSD device node name, guess its media type
 */
MediaType MediaTypeForBSDName(const char *bsdName)
{
    CFMutableDictionaryRef  matchingDict;
    kern_return_t           kernResult;
    io_iterator_t           iter;
    io_service_t            service;
    QString                 msg = QString("MediaTypeForBSDName(%1)")
                                  .arg(bsdName);
    MediaType               mediaType;


    if (!bsdName || !*bsdName)
    {
        VERBOSE(VB_IMPORTANT, msg + " - Error. No name supplied?");
        return MEDIATYPE_UNKNOWN;
    }

    matchingDict = IOBSDNameMatching(sMasterPort, 0, bsdName);
    if (NULL == matchingDict)
    {
        VERBOSE(VB_IMPORTANT, msg + " - Error. IOBSDNameMatching()"
                                  + " returned a NULL dictionary.");
        return MEDIATYPE_UNKNOWN;
    }

    // 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, (msg + " - Error. IOServiceGetMatchingServices()"
                                   + " returned %2").arg(kernResult));
        return MEDIATYPE_UNKNOWN;
    }
    if (!iter)
    {
        VERBOSE(VB_IMPORTANT, msg + " - Error. IOServiceGetMatchingServices()"
                                  + " returned a NULL iterator");
        return MEDIATYPE_UNKNOWN;
    }

    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, msg + " - Error. IOIteratorNext()"
                                  + " returned a NULL iterator");
        return MEDIATYPE_UNKNOWN;
    }
    mediaType = FindMediaType(service);
    IOObjectRelease(service);
    return mediaType;
}

/*
 * Callbacks which the Disk Arbitration session invokes
 * whenever a disk comes or goes, or is renamed
 */

void diskAppearedCallback(DADiskRef disk, void *context)
{
    const char          *BSDname = DADiskGetBSDName(disk);
    CFDictionaryRef      details;
    bool                 isCDorDVD;
    DarwinDiscCheckingThread *ddct;
    QString              msg = "diskAppearedCallback() - ";
    MediaType           mediaType;

    if (!BSDname)
    {
        VERBOSE(VB_UPNP, msg + "Skipping non-local device");
        return;
    }

    if (!context)
    {
        VERBOSE(VB_IMPORTANT, msg + "Error. Invoked with a NULL context.");
        return;
    }

    ddct = reinterpret_cast<DarwinDiscCheckingThread*>(context);


    // We want to monitor CDs/DVDs and USB cameras or flash drives,
    // but probably not hard disk or network drives. For now, ignore
    // any disk or partitions that are not on removable media.
    // Seems OK for hot-plug USB/FireWire disks (i.e. they are removable)

    details = DADiskCopyDescription(disk);
    if (kCFBooleanFalse ==
        CFDictionaryGetValue(details, kDADiskDescriptionMediaRemovableKey))
    {
        VERBOSE(VB_UPNP, msg + "Skipping non-removable " + BSDname);
        CFRelease(details);
        return;
    }

    // Get the volume name for more user-friendly interaction
    //volName = getVolName(details);

    mediaType = MediaTypeForBSDName(BSDname);
    isCDorDVD = (mediaType == MEDIATYPE_DVD) || (mediaType == MEDIATYPE_AUDIO);


    // We know it is removable, and have guessed the type.
    // Call a helper function to create appropriate objects and insert 

    if (mediaType == MEDIATYPE_DVD)
    {
        VERBOSE(VB_IMPORTANT, QString("Found disk %1 ").arg(BSDname));
        ddct->DoProbe(BSDname);
    }
    
//    ddct->diskInsert(BSDname, volName, isCDorDVD);

    CFRelease(details);
//    free(volName);
}

void diskDisappearedCallback(DADiskRef disk, void *context)
{
    const char  *BSDname = DADiskGetBSDName(disk);

    if (context)
    {
        VERBOSE(VB_IMPORTANT, QString("diskDisappearedCallback - bsdname = %1").arg(BSDname));
        reinterpret_cast<DarwinDiscCheckingThread*>(context)->DiskRemoved(BSDname);
//        reinterpret_cast<DarwinDiscCheckingThread *>(context)->diskRemove(BSDname);
    }
}

void diskChangedCallback(DADiskRef disk, CFArrayRef keys, void *context)
{
    (void)context;
    if (CFArrayContainsValue(keys, CFRangeMake(0, CFArrayGetCount(keys)),
                             kDADiskDescriptionVolumeNameKey))
    {
        const char     *BSDname = DADiskGetBSDName(disk);
        CFDictionaryRef details = DADiskCopyDescription(disk);
//        char           *volName = getVolName(details);

        VERBOSE(VB_IMPORTANT, QString("diskChangedCallback - bsdname = %1").arg(BSDname));
//        reinterpret_cast<DarwinDiscCheckingThread *>(context)->diskRename(BSDname, volName);
        CFRelease(details);
//        free(volName);
    }
}

void DarwinDiscCheckingThread::run()
{
    CFDictionaryRef match     = kDADiskDescriptionMatchVolumeMountable;
    DASessionRef    daSession = DASessionCreate(kCFAllocatorDefault);

    DARegisterDiskAppearedCallback(daSession, match,
                                   diskAppearedCallback, this);
    DARegisterDiskDisappearedCallback(daSession, match,
                                      diskDisappearedCallback, this);
    DARegisterDiskDescriptionChangedCallback(daSession, match,
                                             kDADiskDescriptionWatchVolumeName,
                                             diskChangedCallback, this);

    DASessionScheduleWithRunLoop(daSession,
                                 CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);


    // Nice and simple, as long as our monitor is valid and active, 
    // loop and let daSession check the devices.
    while (keepGoing())        
    {
        // Run the run loop for 3 seconds - this will
        // handle any disk arbitration appeared/dissappeared events
        CFRunLoopRunInMode(kCFRunLoopDefaultMode,
                           (float) 3.0f, false );
        sleep(1);
    }

    DAUnregisterCallback(daSession, (void(*))diskChangedCallback,     this);
    DAUnregisterCallback(daSession, (void(*))diskDisappearedCallback, this);
    DAUnregisterCallback(daSession, (void(*))diskAppearedCallback,    this);
    CFRelease(daSession);
    
    
}

void DarwinDiscCheckingThread::DoProbe(const char *inDeviceName)
{
    dvd_probe->setDevice(QString("/dev/r%1").arg(inDeviceName));

    while(!dvd_drive_access->tryLock())
    {
        sleep(3);
    }
    while(!titles_mutex->tryLock())
    {
        sleep(3);
    }

    if (dvd_probe->probe())
        have_disc = true;
        
    titles_mutex->unlock();
    dvd_drive_access->unlock();
}

void DarwinDiscCheckingThread::DiskRemoved(const char *inDeviceName)
{
    (void)inDeviceName;
    dvd_probe->setDevice("");

    while(!dvd_drive_access->tryLock())
    {
        sleep(3);
    }
    while(!titles_mutex->tryLock())
    {
        sleep(3);
    }

    have_disc = false;

    titles_mutex->unlock();
    dvd_drive_access->unlock();
}