/**
* Use the DiskArbitration Daemon to inform us of media changes
*/
void MonitorThreadDarwin::run(void)
{
CFDictionaryRef match = kDADiskDescriptionMatchVolumeMountable;
DASessionRef daSession = DASessionCreate(kCFAllocatorDefault);
IOMasterPort(MACH_PORT_NULL, &sMasterPort);
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 (m_Monitor && m_Monitor->IsActive())
{
// Run the run loop for interval (milliseconds) - this will
// handle any disk arbitration appeared/dissappeared events
CFRunLoopRunInMode(kCFRunLoopDefaultMode,
(float) m_Interval / 1000.0f, false );
}
DAUnregisterCallback(daSession, (void(*))diskChangedCallback, this);
DAUnregisterCallback(daSession, (void(*))diskDisappearedCallback, this);
DAUnregisterCallback(daSession, (void(*))diskAppearedCallback, this);
CFRelease(daSession);
}
DiskArbitrationDispatcher::DiskArbitrationDispatcher() :
m_impl(new Impl)
{
m_impl->session = DASessionCreate(kCFAllocatorDefault);
DARegisterDiskAppearedCallback(m_impl->session, nullptr, [](DADiskRef disk, void * ctx)
{ static_cast<DiskArbitrationDispatcher*>(ctx)->diskAppeared(disk); }, this);
DARegisterDiskDisappearedCallback(m_impl->session, nullptr, [](DADiskRef disk, void * ctx)
{ static_cast<DiskArbitrationDispatcher*>(ctx)->diskDisappeared(disk); }, this);
}
bool QDeviceWatcherPrivate::init()
{
//get sDevices
//FSGetVolumeInfo()
mSession = DASessionCreate(kCFAllocatorDefault);
DARegisterDiskAppearedCallback(mSession, NULL, onDiskAppear, this);
DARegisterDiskDisappearedCallback(mSession, NULL, onDiskDisappear, this);
}
__private_extern__ void ExternalMedia_prime(void)
{
gExternalMediaSet = CFSetCreateMutable(0, 0, &kCFTypeSetCallBacks);
if (!gExternalMediaSet)
return;
gDASession = DASessionCreate(0);
DARegisterDiskAppearedCallback(gDASession, kDADiskDescriptionMatchVolumeMountable, _DiskAppeared, NULL);
DARegisterDiskDisappearedCallback(gDASession, kDADiskDescriptionMatchVolumeMountable, _DiskDisappeared, NULL);
DASessionScheduleWithRunLoop(gDASession, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
}
/*
* Check if there are any mountable partitions on the disk. If there are any
* mountable partitions, then we don't want to display the dialog. CoreStorage
* and Apple_Boot partitions don't count as mountable for our purposes.
*/
static bool
check_all_partitions(char *devname)
{
bool found_mountable_fs = false;
SInt32 rc;
CFNumberRef num = NULL;
CFDictionaryRef description = NULL, matchDict = NULL;
DASessionRef session = (DASessionRef)0;
DADiskRef disk = (DADiskRef)0;
session = DASessionCreate(kCFAllocatorDefault);
if (session == (DASessionRef)0)
goto exit;
disk = DADiskCreateFromBSDName(kCFAllocatorDefault, session, devname);
if (disk == (DADiskRef)0)
goto exit;
description = DADiskCopyDescription(disk);
num = CFDictionaryGetValue(description, kDADiskDescriptionMediaBSDUnitKey);
matchDict = CFDictionaryCreate(kCFAllocatorDefault,
(const void **)&kDADiskDescriptionMediaBSDUnitKey,
(const void **)&num, 1, &kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
DASessionScheduleWithRunLoop(session, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
DARegisterIdleCallback(session, idle_cb, &found_mountable_fs);
DARegisterDiskAppearedCallback(session, matchDict, disk_appeared_cb, &found_mountable_fs);
rc = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 10, false);
DAUnregisterCallback(session, idle_cb, &found_mountable_fs);
DAUnregisterCallback(session, disk_appeared_cb, &found_mountable_fs);
DASessionUnscheduleFromRunLoop(session, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
exit:
if (disk)
CFRelease(disk);
if (session)
CFRelease(session);
if (description)
CFRelease(description);
if (matchDict)
CFRelease(matchDict);
return (!found_mountable_fs);
}
int mmc_scan_for_devices(struct mmc_device *devices, int max_devices)
{
// Only look for removable media
CFMutableDictionaryRef toMatch =
CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionaryAddValue(toMatch, kDADiskDescriptionMediaWholeKey, kCFBooleanTrue);
CFDictionaryAddValue(toMatch, kDADiskDescriptionMediaRemovableKey, kCFBooleanTrue);
struct scan_context context;
context.devices = devices;
context.max_devices = max_devices;
context.count = 0;
DARegisterDiskAppearedCallback(da_session, toMatch, scan_disk_appeared_cb, &context);
// Scan for removable media for 100 ms
// NOTE: It's not clear how long the event loop has to run. Ideally, it would
// terminate after all devices have been found, but I don't know how to do that.
run_loop_for_time(0.1);
return context.count;
}
void DiskArbitrationEventPublisher::restart() {
if (run_loop_ == nullptr) {
return;
}
stop();
WriteLock lock(mutex_);
session_ = DASessionCreate(kCFAllocatorDefault);
DARegisterDiskAppearedCallback(
session_,
nullptr,
DiskArbitrationEventPublisher::DiskAppearedCallback,
nullptr);
DARegisterDiskDisappearedCallback(
session_,
nullptr,
DiskArbitrationEventPublisher::DiskDisappearedCallback,
nullptr);
DASessionScheduleWithRunLoop(session_, run_loop_, kCFRunLoopDefaultMode);
}