70 #include <CoreFoundation/CFNotificationCenter.h> |
71 #include <CoreFoundation/CFNotificationCenter.h> |
71 #include <IOKit/graphics/IOGraphicsLib.h> |
72 #include <IOKit/graphics/IOGraphicsLib.h> |
72 #include <CoreFoundation/CoreFoundation.h> |
73 #include <CoreFoundation/CoreFoundation.h> |
73 #include <CoreFoundation/CFLocale.h> |
74 #include <CoreFoundation/CFLocale.h> |
74 #include <ScreenSaver/ScreenSaverDefaults.h> |
75 #include <ScreenSaver/ScreenSaverDefaults.h> |
|
76 #include <dns_sd.h> |
75 |
77 |
76 #include <QTKit/QTKit.h> |
78 #include <QTKit/QTKit.h> |
77 |
79 |
78 #include <IOKit/usb/IOUSBLib.h> |
80 #include <IOKit/usb/IOUSBLib.h> |
79 #include <IOKit/pwr_mgt/IOPM.h> |
81 #include <IOKit/pwr_mgt/IOPM.h> |
118 #include <net/if_types.h> |
121 #include <net/if_types.h> |
119 #include <net/if_media.h> |
122 #include <net/if_media.h> |
120 #include <sys/ioctl.h> |
123 #include <sys/ioctl.h> |
121 #include <sys/socket.h> |
124 #include <sys/socket.h> |
122 |
125 |
123 // |
|
124 //////// |
|
125 static QString stringFromCFString(CFStringRef value) { |
126 static QString stringFromCFString(CFStringRef value) { |
126 QString retVal; |
127 QString retVal; |
127 if(CFStringGetLength(value) > 1) { |
128 if(CFStringGetLength(value) > 1) { |
128 CFIndex maxLength = 2 * CFStringGetLength(value) + 1/*zero term*/; // max UTF8 |
129 CFIndex maxLength = 2 * CFStringGetLength(value) + 1/*zero term*/; // max UTF8 |
129 char *cstring = new char[maxLength]; |
130 char *cstring = new char[maxLength]; |
170 |
171 |
171 |
172 |
172 |
173 |
173 #ifdef MAC_SDK_10_6 |
174 #ifdef MAC_SDK_10_6 |
174 |
175 |
175 @interface QNSListener : NSObject |
176 @interface QtMNSListener : NSObject |
176 { |
177 { |
177 NSNotificationCenter *center; |
178 NSNotificationCenter *center; |
178 CWInterface * currentInterface; |
179 CWInterface * currentInterface; |
179 } |
180 } |
180 - (void)notificationHandler:(NSNotification *)notification; |
181 - (void)notificationHandler:(NSNotification *)notification; |
181 - (void)remove; |
182 - (void)remove; |
182 @end |
183 @end |
183 |
184 |
184 @implementation QNSListener |
185 @implementation QtMNSListener |
185 - (id) init |
186 - (id) init |
186 { |
187 { |
187 [super init]; |
188 [super init]; |
188 center = [NSNotificationCenter defaultCenter]; |
189 center = [NSNotificationCenter defaultCenter]; |
189 currentInterface = [CWInterface interface]; |
190 currentInterface = [CWInterface interfaceWithName:nil]; |
190 |
191 |
191 [center addObserver:self selector:@selector(notificationHandler:) name:kCWModeDidChangeNotification object:nil]; |
192 [center addObserver:self selector:@selector(notificationHandler:) name:kCWModeDidChangeNotification object:nil]; |
192 [center addObserver:self selector:@selector(notificationHandler:) name:kCWSSIDDidChangeNotification object:nil]; |
193 [center addObserver:self selector:@selector(notificationHandler:) name:kCWSSIDDidChangeNotification object:nil]; |
193 [center addObserver:self selector:@selector(notificationHandler:) name:kCWBSSIDDidChangeNotification object:nil]; |
194 [center addObserver:self selector:@selector(notificationHandler:) name:kCWBSSIDDidChangeNotification object:nil]; |
194 [center addObserver:self selector:@selector(notificationHandler:) name:kCWCountryCodeDidChangeNotification object:nil]; |
195 [center addObserver:self selector:@selector(notificationHandler:) name:kCWCountryCodeDidChangeNotification object:nil]; |
200 } |
201 } |
201 |
202 |
202 -(void)dealloc |
203 -(void)dealloc |
203 { |
204 { |
204 [center release]; |
205 [center release]; |
205 [currentInterface release]; |
|
206 [super dealloc]; |
206 [super dealloc]; |
207 } |
207 } |
208 |
208 |
209 -(void)remove |
209 -(void)remove |
210 { |
210 { |
211 [center removeObserver:self]; |
211 [center removeObserver:self]; |
212 } |
212 } |
213 |
213 |
214 - (void)notificationHandler:(NSNotification *)notification |
214 - (void)notificationHandler:(NSNotification *)notification |
215 { |
215 { |
216 QTM_NAMESPACE::QSystemNetworkInfoPrivate::instance()->networkChanged( nsstringToQString([notification name]), nsstringToQString([[notification object]name])); |
216 QTM_NAMESPACE::QSystemNetworkInfoPrivate::instance()->wifiNetworkChanged( nsstringToQString([notification name]), nsstringToQString([[notification object]name])); |
217 } |
217 } |
218 @end |
218 @end |
219 |
219 |
220 |
220 |
221 @interface QLangListener : NSObject |
221 @interface QtMLangListener : NSObject |
222 { |
222 { |
223 NSNotificationCenter *center; |
223 NSNotificationCenter *center; |
224 QString currentLanguage; |
224 QString currentLanguage; |
225 } |
225 } |
226 - (void)languageHandler;//:(NSNotification *)notification; |
226 - (void)languageHandler;//:(NSNotification *)notification; |
270 [self getCurrentLanguage]; |
270 [self getCurrentLanguage]; |
271 } |
271 } |
272 @end |
272 @end |
273 |
273 |
274 |
274 |
275 #endif |
275 @interface RemoteDeviceRSSIHostControllerDelegate : NSObject |
|
276 { |
|
277 } |
|
278 // See IOBluetoothHostControllerDelegate |
|
279 - (void)readRSSIForDeviceComplete:(id)controller device:(IOBluetoothDevice*)device info:(BluetoothHCIRSSIInfo*)info error:(IOReturn)error; |
|
280 @end |
|
281 |
|
282 @implementation RemoteDeviceRSSIHostControllerDelegate |
|
283 - (id) init |
|
284 { |
|
285 [super init]; |
|
286 return self; |
|
287 } |
|
288 |
|
289 - (void)readRSSIForDeviceComplete:(id)controller device:(IOBluetoothDevice*)device info:(BluetoothHCIRSSIInfo*)info error:(IOReturn)error |
|
290 { |
|
291 Q_UNUSED(controller); |
|
292 Q_UNUSED(device); |
|
293 |
|
294 if ((error != kIOReturnSuccess) || (info == NULL)) { |
|
295 qWarning() << "ERROR: readRSSIForDeviceComplete return error"; |
|
296 |
|
297 } else if (info->handle == kBluetoothConnectionHandleNone) { |
|
298 qWarning() << "ERROR: readRSSIForDeviceComplete no connection"; |
|
299 } else { |
|
300 NSLog(@"Rssi value: %@", info->RSSIValue); |
|
301 } |
|
302 } |
|
303 @end |
|
304 #endif |
|
305 NSObject* delegate; |
276 |
306 |
277 QTM_BEGIN_NAMESPACE |
307 QTM_BEGIN_NAMESPACE |
278 |
308 |
279 QSystemInfoPrivate *QSystemInfoPrivate::self = 0; |
309 QSystemInfoPrivate *QSystemInfoPrivate::self = 0; |
280 |
310 |
281 QSystemInfoPrivate::QSystemInfoPrivate(QObject *parent) |
311 QSystemInfoPrivate::QSystemInfoPrivate(QObject *parent) |
282 : QObject(parent) |
312 : QObject(parent) |
283 { |
313 { |
284 langloopThread = new QLangLoopThread(this); |
|
285 langloopThread->start(); |
|
286 if(!self) |
314 if(!self) |
287 self = this; |
315 self = this; |
288 } |
316 } |
289 |
317 |
290 QSystemInfoPrivate::~QSystemInfoPrivate() |
318 QSystemInfoPrivate::~QSystemInfoPrivate() |
291 { |
319 { |
292 langloopThread->quit(); |
320 if(langloopThread->isRunning()) { |
293 langloopThread->wait(); |
321 langloopThread->quit(); |
|
322 langloopThread->wait(); |
|
323 } |
294 } |
324 } |
295 |
325 |
296 QString QSystemInfoPrivate::currentLanguage() const |
326 QString QSystemInfoPrivate::currentLanguage() const |
297 { |
327 { |
298 QString lang = QLocale::system().name().left(2); |
328 QString lang = QLocale::system().name().left(2); |
313 for(int i = 0; i < langList.count(); i++) { |
344 for(int i = 0; i < langList.count(); i++) { |
314 QString language = langList.at(i).left(2); |
345 QString language = langList.at(i).left(2); |
315 if(!returnList.contains(language)) |
346 if(!returnList.contains(language)) |
316 returnList << language; |
347 returnList << language; |
317 } |
348 } |
|
349 [pool drain]; |
318 return returnList; |
350 return returnList; |
319 } |
351 } |
320 |
352 |
321 void QSystemInfoPrivate::languageChanged(const QString &lang) |
353 void QSystemInfoPrivate::languageChanged(const QString &lang) |
322 { |
354 { |
323 Q_EMIT currentLanguageChanged(lang); |
355 Q_EMIT currentLanguageChanged(lang); |
324 } |
356 } |
325 |
357 |
|
358 void QSystemInfoPrivate::connectNotify(const char *signal) |
|
359 { |
|
360 if (QLatin1String(signal) == SIGNAL(currentLanguageChanged(QString))) { |
|
361 langloopThread = new QLangLoopThread(this); |
|
362 langloopThread->start(); |
|
363 } |
|
364 } |
|
365 |
|
366 void QSystemInfoPrivate::disconnectNotify(const char *signal) |
|
367 { |
|
368 if (QLatin1String(signal) == SIGNAL(currentLanguageChanged(QString))) { |
|
369 if(langloopThread->isRunning()) { |
|
370 langloopThread->quit(); |
|
371 langloopThread->wait(); |
|
372 } |
|
373 } |
|
374 } |
326 |
375 |
327 QString QSystemInfoPrivate::version(QSystemInfo::Version type, const QString ¶meter) |
376 QString QSystemInfoPrivate::version(QSystemInfo::Version type, const QString ¶meter) |
328 { |
377 { |
329 Q_UNUSED(parameter); |
378 Q_UNUSED(parameter); |
330 QString errorStr = "Not Available"; |
379 QString errorStr = "Not Available"; |
395 //kHIDPage_LEDs |
444 //kHIDPage_LEDs |
396 } |
445 } |
397 break; |
446 break; |
398 case QSystemInfo::MemcardFeature: |
447 case QSystemInfo::MemcardFeature: |
399 { |
448 { |
400 |
449 // IOSCSIPeripheralDeviceType0E |
|
450 if(hasIOServiceMatching("IOUSBMassStorageClass")) { |
|
451 featureSupported = true; |
|
452 } |
401 } |
453 } |
402 break; |
454 break; |
403 case QSystemInfo::UsbFeature: |
455 case QSystemInfo::UsbFeature: |
404 { |
456 { |
405 if(hasIOServiceMatching(kIOUSBDeviceClassName)) { |
457 if(hasIOServiceMatching("AppleUSBOHCI")) { |
406 featureSupported = true; |
458 featureSupported = true; |
407 } |
459 } |
|
460 if(hasIOServiceMatching("AppleUSBEHCI")) { |
|
461 featureSupported = true; |
|
462 } |
408 } |
463 } |
409 break; |
464 break; |
410 case QSystemInfo::VibFeature: |
465 case QSystemInfo::VibFeature: |
411 { |
466 { |
412 |
|
413 } |
467 } |
414 break; |
468 break; |
415 case QSystemInfo::WlanFeature: |
469 case QSystemInfo::WlanFeature: |
416 { |
470 { |
417 if(!QSystemNetworkInfoPrivate::instance()->interfaceForMode(QSystemNetworkInfo::WlanMode).name().isEmpty()) { |
471 if(!QSystemNetworkInfoPrivate::instance()->interfaceForMode(QSystemNetworkInfo::WlanMode).name().isEmpty()) { |
418 featureSupported = true; |
472 featureSupported = true; |
419 |
|
420 } |
473 } |
421 } |
474 } |
422 break; |
475 break; |
423 case QSystemInfo::SimFeature: |
476 case QSystemInfo::SimFeature: |
424 { |
477 { |
425 |
|
426 } |
478 } |
427 break; |
479 break; |
428 case QSystemInfo::LocationFeature: |
480 case QSystemInfo::LocationFeature: |
429 { |
481 { |
430 #ifdef MAC_SDK_10_6 |
482 #ifdef MAC_SDK_10_6 |
451 } |
506 } |
452 |
507 |
453 QSystemNetworkInfoPrivate *QSystemNetworkInfoPrivate::self = 0; |
508 QSystemNetworkInfoPrivate *QSystemNetworkInfoPrivate::self = 0; |
454 |
509 |
455 |
510 |
456 void networkChangeCallback(SCDynamicStoreRef/* store*/, CFArrayRef /*changedKeys*/, void */*info*/) |
511 void networkChangeCallback(SCDynamicStoreRef /*dynamicStore*/, CFArrayRef changedKeys, void */*networkConfigurationManagerPrivate*/) |
457 { |
512 { |
458 QTM_NAMESPACE::QSystemNetworkInfoPrivate::instance()->getDefaultInterface(); |
513 // NSLog(@"changed keys %@", changedKeys); |
|
514 QStringList keyList = nsarrayToQStringList((void*)changedKeys); |
|
515 if(keyList.contains("State:/Network/Global/DNS")) { |
|
516 } |
|
517 if(keyList.contains("State:/Network/Global/IPv4")) { |
|
518 QTM_NAMESPACE::QSystemNetworkInfoPrivate::instance()->ethernetChanged(); |
|
519 QTM_NAMESPACE::QSystemNetworkInfoPrivate::instance()->getDefaultInterface(); |
|
520 } |
|
521 |
459 return; |
522 return; |
460 } |
523 } |
461 |
524 |
462 #ifdef MAC_SDK_10_6 |
525 #ifdef MAC_SDK_10_6 |
463 #endif |
526 #endif |
483 mutex.lock(); |
546 mutex.lock(); |
484 keepRunning = true; |
547 keepRunning = true; |
485 mutex.unlock(); |
548 mutex.unlock(); |
486 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
549 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
487 |
550 |
488 QLangListener *listener; |
551 QtMLangListener *listener; |
489 listener = [[QLangListener alloc] init]; |
552 listener = [[QtMLangListener alloc] init]; |
490 |
553 |
491 NSDate *loopUntil = [NSDate dateWithTimeIntervalSinceNow:1.0]; |
554 NSDate *loopUntil = [NSDate dateWithTimeIntervalSinceNow:1.0]; |
492 while (keepRunning && |
555 while (keepRunning && |
493 [[NSRunLoop currentRunLoop] runMode: NSDefaultRunLoopMode beforeDate: loopUntil]) { |
556 [[NSRunLoop currentRunLoop] runMode: NSDefaultRunLoopMode beforeDate: loopUntil]) { |
494 loopUntil = [NSDate dateWithTimeIntervalSinceNow:1.0]; |
557 loopUntil = [NSDate dateWithTimeIntervalSinceNow:1.0]; |
495 } |
558 } |
496 // [listener release]; //crash |
|
497 [pool release]; |
559 [pool release]; |
498 #endif |
560 #endif |
499 } |
561 } |
500 |
562 |
|
563 #ifdef MAC_SDK_10_6 |
|
564 QtMNSListener *listener; |
|
565 #endif |
501 |
566 |
502 QRunLoopThread::QRunLoopThread(QObject *parent) |
567 QRunLoopThread::QRunLoopThread(QObject *parent) |
503 :QThread(parent) |
568 :QThread(parent) |
504 { |
569 { |
505 } |
570 } |
506 |
571 |
507 QRunLoopThread::~QRunLoopThread() |
572 QRunLoopThread::~QRunLoopThread() |
508 { |
573 { |
509 CFRelease(storeSession); |
574 #ifdef MAC_SDK_10_6 |
|
575 [listener dealloc]; |
|
576 #endif |
|
577 } |
|
578 |
|
579 void QRunLoopThread::quit() |
|
580 { |
510 CFRelease(runloopSource); |
581 CFRelease(runloopSource); |
511 } |
|
512 |
|
513 void QRunLoopThread::quit() |
|
514 { |
|
515 |
|
516 mutex.lock(); |
582 mutex.lock(); |
517 keepRunning = false; |
583 keepRunning = false; |
518 mutex.unlock(); |
584 mutex.unlock(); |
519 } |
585 CFRelease(storeSession); |
|
586 } |
|
587 |
520 |
588 |
521 void QRunLoopThread::run() |
589 void QRunLoopThread::run() |
522 { |
590 { |
523 #ifdef MAC_SDK_10_6 |
591 #ifdef MAC_SDK_10_6 |
524 |
592 |
|
593 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
525 startNetworkChangeLoop(); |
594 startNetworkChangeLoop(); |
|
595 delegate = [[RemoteDeviceRSSIHostControllerDelegate alloc] init]; |
526 |
596 |
527 mutex.lock(); |
597 mutex.lock(); |
528 keepRunning = true; |
598 keepRunning = true; |
529 mutex.unlock(); |
599 mutex.unlock(); |
530 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
600 |
531 |
601 listener = [[QtMNSListener alloc] init]; |
532 QNSListener *listener; |
|
533 listener = [[QNSListener alloc] init]; |
|
534 |
602 |
535 NSDate *loopUntil = [NSDate dateWithTimeIntervalSinceNow:1.0]; |
603 NSDate *loopUntil = [NSDate dateWithTimeIntervalSinceNow:1.0]; |
536 while (keepRunning && |
604 while (keepRunning && |
537 [[NSRunLoop currentRunLoop] runMode: NSDefaultRunLoopMode beforeDate: loopUntil]) { |
605 [[NSRunLoop currentRunLoop] runMode: NSDefaultRunLoopMode beforeDate: loopUntil]) { |
538 loopUntil = [NSDate dateWithTimeIntervalSinceNow:1.0]; |
606 loopUntil = [NSDate dateWithTimeIntervalSinceNow:1.0]; |
539 } |
607 } |
540 // [listener release]; //crash |
|
541 [pool release]; |
608 [pool release]; |
542 #endif |
609 #endif |
543 } |
610 } |
544 |
611 |
545 void QRunLoopThread::startNetworkChangeLoop() |
612 void QRunLoopThread::startNetworkChangeLoop() |
546 { |
613 { |
547 storeSession = NULL; |
614 storeSession = NULL; |
548 |
615 |
549 SCDynamicStoreContext dynStoreContext = { 0, (void *)storeSession, NULL, NULL, NULL }; |
616 SCDynamicStoreContext dynStoreContext = { 0, this /*(void *)storeSession*/, NULL, NULL, NULL }; |
550 storeSession = SCDynamicStoreCreate(NULL, |
617 storeSession = SCDynamicStoreCreate(NULL, |
551 CFSTR("networkChangeCallback"), |
618 CFSTR("networkChangeCallback"), |
552 networkChangeCallback, |
619 networkChangeCallback, |
553 &dynStoreContext); |
620 &dynStoreContext); |
554 if (!storeSession ) { |
621 if (!storeSession ) { |
555 qWarning() << "could not open dynamic store: error:" << SCErrorString(SCError()); |
622 qWarning() << "could not open dynamic store: error:" << SCErrorString(SCError()); |
560 notificationKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); |
627 notificationKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); |
561 CFMutableArrayRef patternsArray; |
628 CFMutableArrayRef patternsArray; |
562 patternsArray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); |
629 patternsArray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); |
563 |
630 |
564 CFStringRef storeKey; |
631 CFStringRef storeKey; |
|
632 |
|
633 storeKey = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, |
|
634 kSCDynamicStoreDomainState, |
|
635 kSCEntNetLink); |
|
636 CFArrayAppendValue(notificationKeys, storeKey); |
|
637 CFRelease(storeKey); |
|
638 |
|
639 storeKey = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL, |
|
640 kSCDynamicStoreDomainState, |
|
641 kSCCompAnyRegex, |
|
642 kSCEntNetLink); |
|
643 CFArrayAppendValue(patternsArray, storeKey); |
|
644 CFRelease(storeKey); |
|
645 |
|
646 storeKey = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, |
|
647 kSCDynamicStoreDomainState, |
|
648 kSCEntNetDNS); |
|
649 CFArrayAppendValue(notificationKeys, storeKey); |
|
650 CFRelease(storeKey); |
|
651 |
|
652 storeKey = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL, |
|
653 kSCDynamicStoreDomainState, |
|
654 kSCCompAnyRegex, |
|
655 kSCEntNetDNS); |
|
656 CFArrayAppendValue(patternsArray, storeKey); |
|
657 CFRelease(storeKey); |
|
658 |
565 storeKey = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, |
659 storeKey = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, |
566 kSCDynamicStoreDomainState, |
660 kSCDynamicStoreDomainState, |
567 kSCEntNetIPv4); |
661 kSCEntNetIPv4); |
568 CFArrayAppendValue(notificationKeys, storeKey); |
662 CFArrayAppendValue(notificationKeys, storeKey); |
569 CFRelease(storeKey); |
663 CFRelease(storeKey); |
586 CFRelease(patternsArray); |
680 CFRelease(patternsArray); |
587 |
681 |
588 runloopSource = SCDynamicStoreCreateRunLoopSource(NULL, storeSession , 0); |
682 runloopSource = SCDynamicStoreCreateRunLoopSource(NULL, storeSession , 0); |
589 if (!runloopSource) { |
683 if (!runloopSource) { |
590 qWarning() << "runloop source error:"<< SCErrorString(SCError()); |
684 qWarning() << "runloop source error:"<< SCErrorString(SCError()); |
591 CFRelease(storeSession ); |
685 CFRelease(storeSession); |
592 return; |
686 return; |
593 } |
687 } |
594 |
688 |
595 CFRunLoopAddSource(CFRunLoopGetCurrent(), runloopSource, kCFRunLoopDefaultMode); |
689 CFRunLoopAddSource(CFRunLoopGetCurrent(), runloopSource, kCFRunLoopDefaultMode); |
596 return; |
690 return; |
602 { |
696 { |
603 defaultInterface = ""; |
697 defaultInterface = ""; |
604 qRegisterMetaType<QSystemNetworkInfo::NetworkMode>("QSystemNetworkInfo::NetworkMode"); |
698 qRegisterMetaType<QSystemNetworkInfo::NetworkMode>("QSystemNetworkInfo::NetworkMode"); |
605 qRegisterMetaType<QSystemNetworkInfo::NetworkStatus>("QSystemNetworkInfo::NetworkStatus"); |
699 qRegisterMetaType<QSystemNetworkInfo::NetworkStatus>("QSystemNetworkInfo::NetworkStatus"); |
606 #ifdef MAC_SDK_10_6 |
700 #ifdef MAC_SDK_10_6 |
607 runloopThread = new QRunLoopThread(this); |
701 if([[CWInterface supportedInterfaces] count] > 0 ) { |
608 runloopThread->start(); |
702 hasWifi = true; |
|
703 } else { |
|
704 hasWifi = false; |
|
705 } |
609 #endif |
706 #endif |
610 rssiTimer = new QTimer(this); |
707 rssiTimer = new QTimer(this); |
611 |
708 |
612 connect(rssiTimer, SIGNAL(timeout()), this, SLOT(rssiTimeout())); |
|
613 if(!self) |
709 if(!self) |
614 self = this; |
710 self = this; |
615 QTimer::singleShot(200, this, SLOT(primaryInterface())); |
711 QTimer::singleShot(200, this, SLOT(primaryInterface())); |
616 } |
712 } |
617 |
713 |
618 QSystemNetworkInfoPrivate::~QSystemNetworkInfoPrivate() |
714 QSystemNetworkInfoPrivate::~QSystemNetworkInfoPrivate() |
619 { |
715 { |
620 #ifdef MAC_SDK_10_6 |
716 #ifdef MAC_SDK_10_6 |
621 runloopThread->quit(); |
717 if(hasWifi && runloopThread->isRunning()) { |
622 runloopThread->wait(); |
718 runloopThread->quit(); |
|
719 runloopThread->wait(); |
|
720 [delegate release]; |
|
721 } |
623 #endif |
722 #endif |
624 } |
723 } |
625 |
724 |
626 void QSystemNetworkInfoPrivate::primaryInterface() |
725 void QSystemNetworkInfoPrivate::primaryInterface() |
627 { |
726 { |
628 defaultInterface = getDefaultInterface(); |
727 defaultInterface = getDefaultInterface(); |
|
728 } |
|
729 |
|
730 void QSystemNetworkInfoPrivate::connectNotify(const char *signal) |
|
731 { |
|
732 if (QLatin1String(signal) == SIGNAL(networkSignalStrengthChanged(QSystemNetworkInfo::NetworkMode,int))) { |
|
733 connect(rssiTimer, SIGNAL(timeout()), this, SLOT(rssiTimeout())); |
|
734 rssiTimer->start(5000); |
|
735 } |
|
736 if (QLatin1String(signal) == SIGNAL(networkNameChanged(QSystemNetworkInfo::NetworkMode,QString)) |
|
737 || QLatin1String(signal) == SIGNAL(networkStatusChanged(QSystemNetworkInfo::NetworkMode, QSystemNetworkInfo::NetworkStatus))) { |
|
738 #ifdef MAC_SDK_10_6 |
|
739 if(hasWifi) { |
|
740 runloopThread = new QRunLoopThread(this); |
|
741 runloopThread->start(); |
|
742 } |
|
743 #endif |
|
744 } |
|
745 } |
|
746 |
|
747 void QSystemNetworkInfoPrivate::disconnectNotify(const char *signal) |
|
748 { |
|
749 if (QLatin1String(signal) == SIGNAL(networkSignalStrengthChanged(QSystemNetworkInfo::NetworkMode,int))) { |
|
750 rssiTimer->stop(); |
|
751 disconnect(rssiTimer, SIGNAL(timeout()), this, SLOT(rssiTimeout())); |
|
752 } |
|
753 if (QLatin1String(signal) == SIGNAL(networkNameChanged(QSystemNetworkInfo::NetworkMode,QString)) |
|
754 || QLatin1String(signal) == SIGNAL(networkStatusChanged(QSystemNetworkInfo::NetworkMode, QSystemNetworkInfo::NetworkStatus))) { |
|
755 #ifdef MAC_SDK_10_6 |
|
756 if(hasWifi && runloopThread->isRunning()) { |
|
757 runloopThread->quit(); |
|
758 runloopThread->wait(); |
|
759 [delegate release]; |
|
760 } |
|
761 #endif |
|
762 } |
629 } |
763 } |
630 |
764 |
631 QSystemNetworkInfo::NetworkMode QSystemNetworkInfoPrivate::modeForInterface(QString interfaceName) |
765 QSystemNetworkInfo::NetworkMode QSystemNetworkInfoPrivate::modeForInterface(QString interfaceName) |
632 { |
766 { |
633 QSystemNetworkInfo::NetworkMode mode = QSystemNetworkInfo::UnknownMode; |
767 QSystemNetworkInfo::NetworkMode mode = QSystemNetworkInfo::UnknownMode; |
688 if(interfaceName != defaultInterface) { |
822 if(interfaceName != defaultInterface) { |
689 Q_EMIT networkModeChanged(modeForInterface(interfaceName)); |
823 Q_EMIT networkModeChanged(modeForInterface(interfaceName)); |
690 defaultInterface = interfaceName; |
824 defaultInterface = interfaceName; |
691 } |
825 } |
692 } |
826 } |
693 // qWarning() << __FUNCTION__ << interfaceName; |
827 |
694 return interfaceName; |
828 return interfaceName; |
695 } |
829 } |
696 |
830 |
697 void QSystemNetworkInfoPrivate::rssiTimeout() |
831 void QSystemNetworkInfoPrivate::rssiTimeout() |
698 { |
832 { |
699 networkStatus(QSystemNetworkInfo::WlanMode); |
|
700 networkSignalStrength(QSystemNetworkInfo::WlanMode); |
833 networkSignalStrength(QSystemNetworkInfo::WlanMode); |
701 } |
834 } |
702 |
|
703 |
835 |
704 bool QSystemNetworkInfoPrivate::isInterfaceActive(const char* netInterface) |
836 bool QSystemNetworkInfoPrivate::isInterfaceActive(const char* netInterface) |
705 { |
837 { |
706 struct ifmediareq ifm; |
838 struct ifmediareq ifm; |
707 |
839 |
713 return true; |
845 return true; |
714 } |
846 } |
715 return false; |
847 return false; |
716 } |
848 } |
717 |
849 |
|
850 void QSystemNetworkInfoPrivate::ethernetChanged() |
|
851 { |
|
852 QSystemNetworkInfo::NetworkStatus status = QSystemNetworkInfo::NoNetworkAvailable; |
|
853 int carrier = 0; |
|
854 |
|
855 if(isInterfaceActive(interfaceForMode(QSystemNetworkInfo::EthernetMode).name().toLocal8Bit())) { |
|
856 status = QSystemNetworkInfo::Connected; |
|
857 carrier = 100; |
|
858 } |
|
859 Q_EMIT networkStatusChanged(QSystemNetworkInfo::EthernetMode,status); |
|
860 Q_EMIT networkSignalStrengthChanged(QSystemNetworkInfo::EthernetMode,carrier); |
|
861 Q_EMIT networkNameChanged(QSystemNetworkInfo::EthernetMode, networkName(QSystemNetworkInfo::EthernetMode)); |
|
862 Q_EMIT networkModeChanged(modeForInterface(getDefaultInterface())); |
|
863 } |
|
864 |
718 QSystemNetworkInfo::NetworkStatus QSystemNetworkInfoPrivate::networkStatus(QSystemNetworkInfo::NetworkMode mode) |
865 QSystemNetworkInfo::NetworkStatus QSystemNetworkInfoPrivate::networkStatus(QSystemNetworkInfo::NetworkMode mode) |
719 { |
866 { |
720 QSystemNetworkInfo::NetworkStatus status = QSystemNetworkInfo::NoNetworkAvailable; |
867 QSystemNetworkInfo::NetworkStatus status = QSystemNetworkInfo::NoNetworkAvailable; |
721 switch(mode) { |
868 switch(mode) { |
722 case QSystemNetworkInfo::GsmMode: |
869 case QSystemNetworkInfo::GsmMode: |
726 case QSystemNetworkInfo::WcdmaMode: |
873 case QSystemNetworkInfo::WcdmaMode: |
727 break; |
874 break; |
728 case QSystemNetworkInfo::WlanMode: |
875 case QSystemNetworkInfo::WlanMode: |
729 { |
876 { |
730 #ifdef MAC_SDK_10_6 |
877 #ifdef MAC_SDK_10_6 |
731 NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init]; |
878 if(hasWifi) { |
732 CWInterface *wifiInterface = [CWInterface interfaceWithName: qstringToNSString(interfaceForMode(mode).name())]; |
879 NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init]; |
733 |
880 CWInterface *wifiInterface = [CWInterface interfaceWithName: qstringToNSString(interfaceForMode(mode).name())]; |
734 if([wifiInterface power]) { |
881 |
735 if(!rssiTimer->isActive()) |
882 if([wifiInterface power]) { |
736 rssiTimer->start(1000); |
883 if(!rssiTimer->isActive()) |
737 } else { |
884 rssiTimer->start(5000); |
738 if(rssiTimer->isActive()) |
885 } else { |
739 rssiTimer->stop(); |
886 if(rssiTimer->isActive()) |
740 } |
887 rssiTimer->stop(); |
741 |
888 } |
742 switch([[wifiInterface interfaceState]intValue]) { |
889 |
743 case kCWInterfaceStateInactive: |
890 switch([[wifiInterface interfaceState]intValue]) { |
744 status = QSystemNetworkInfo::NoNetworkAvailable; |
891 case kCWInterfaceStateInactive: |
745 break; |
892 status = QSystemNetworkInfo::NoNetworkAvailable; |
746 case kCWInterfaceStateScanning: |
893 break; |
747 case kCWInterfaceStateAuthenticating: |
894 case kCWInterfaceStateScanning: |
748 case kCWInterfaceStateAssociating: |
895 case kCWInterfaceStateAuthenticating: |
749 status = QSystemNetworkInfo::Searching; |
896 case kCWInterfaceStateAssociating: |
750 break; |
897 status = QSystemNetworkInfo::Searching; |
751 case kCWInterfaceStateRunning: |
898 break; |
752 status = QSystemNetworkInfo::Connected; |
899 case kCWInterfaceStateRunning: |
753 break; |
900 status = QSystemNetworkInfo::Connected; |
754 }; |
901 break; |
755 [autoreleasepool release]; |
902 }; |
|
903 [autoreleasepool release]; |
|
904 } |
|
905 |
756 #else |
906 #else |
757 if(isInterfaceActive(interfaceForMode(mode).name().toLatin1())) { |
907 if(isInterfaceActive(interfaceForMode(mode).name().toLatin1())) { |
758 status = QSystemNetworkInfo::Connected; |
908 status = QSystemNetworkInfo::Connected; |
759 } |
909 } |
760 #endif |
910 #endif |
761 } |
911 } |
762 break; |
912 break; |
763 case QSystemNetworkInfo::EthernetMode: |
913 case QSystemNetworkInfo::EthernetMode: |
764 { |
914 { |
765 if(networkSignalStrength(mode) == 100) { |
915 if(isInterfaceActive(interfaceForMode(mode).name().toLatin1())) { |
766 return QSystemNetworkInfo::Connected; |
916 return QSystemNetworkInfo::Connected; |
767 } else { |
917 } else { |
768 return QSystemNetworkInfo::NoNetworkAvailable; |
918 return QSystemNetworkInfo::NoNetworkAvailable; |
769 } |
919 } |
770 } |
920 } |
792 case QSystemNetworkInfo::WcdmaMode: |
942 case QSystemNetworkInfo::WcdmaMode: |
793 break; |
943 break; |
794 case QSystemNetworkInfo::WlanMode: |
944 case QSystemNetworkInfo::WlanMode: |
795 { |
945 { |
796 int signalQuality = 0; |
946 int signalQuality = 0; |
|
947 if(hasWifi) { |
797 #ifdef MAC_SDK_10_6 |
948 #ifdef MAC_SDK_10_6 |
798 NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init]; |
949 NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init]; |
799 QString name = interfaceForMode(mode).name(); |
950 QString name = interfaceForMode(mode).name(); |
800 CWInterface *wifiInterface = [CWInterface interfaceWithName:qstringToNSString(name)]; |
951 CWInterface *wifiInterface = [CWInterface interfaceWithName:qstringToNSString(name)]; |
801 |
952 |
802 if([wifiInterface power]) { |
953 if([wifiInterface power]) { |
803 if(!rssiTimer->isActive()) |
954 if(!rssiTimer->isActive()) |
804 rssiTimer->start(1000); |
955 rssiTimer->start(5000); |
805 } else { |
956 } else { |
806 if(rssiTimer->isActive()) |
957 if(rssiTimer->isActive()) |
807 rssiTimer->stop(); |
958 rssiTimer->stop(); |
808 } |
|
809 |
|
810 int rssiSignal = [[wifiInterface rssi] intValue]; |
|
811 |
|
812 if(rssiSignal !=0 ) { |
|
813 int maxRssi = -40; |
|
814 int minRssi = [[wifiInterface noise] intValue]; |
|
815 signalQuality = ( 100 * (maxRssi - minRssi) * (maxRssi - minRssi) - (maxRssi - rssiSignal) * |
|
816 (15 * (maxRssi - minRssi) + 62 * (maxRssi - rssiSignal)) ) / |
|
817 ((maxRssi - minRssi) * (maxRssi - minRssi)); |
|
818 |
|
819 } else { |
|
820 signalQuality = 0; |
|
821 } |
|
822 |
|
823 if(signalStrengthCache != signalQuality) { |
|
824 if(signalStrengthCache == 0) { |
|
825 networkStatus(QSystemNetworkInfo::WlanMode); |
|
826 } |
959 } |
827 signalStrengthCache = signalQuality; |
960 |
828 Q_EMIT networkSignalStrengthChanged(mode, signalQuality); |
961 int rssiSignal = [[wifiInterface rssi] intValue]; |
829 } |
962 |
830 [autoreleasepool release]; |
963 if(rssiSignal !=0 ) { |
831 #endif |
964 int maxRssi = -40; |
|
965 int minRssi = [[wifiInterface noise] intValue]; |
|
966 signalQuality = ( 100 * (maxRssi - minRssi) * (maxRssi - minRssi) - (maxRssi - rssiSignal) * |
|
967 (15 * (maxRssi - minRssi) + 62 * (maxRssi - rssiSignal)) ) / |
|
968 ((maxRssi - minRssi) * (maxRssi - minRssi)); |
|
969 |
|
970 } else { |
|
971 signalQuality = 0; |
|
972 } |
|
973 |
|
974 if(signalStrengthCache != signalQuality) { |
|
975 if(signalStrengthCache == 0) { |
|
976 networkStatus(QSystemNetworkInfo::WlanMode); |
|
977 } |
|
978 signalStrengthCache = signalQuality; |
|
979 Q_EMIT networkSignalStrengthChanged(mode, signalQuality); |
|
980 } |
|
981 [autoreleasepool release]; |
|
982 #endif |
|
983 } |
832 return signalQuality; |
984 return signalQuality; |
833 } |
985 } |
834 break; |
986 break; |
835 case QSystemNetworkInfo::EthernetMode: |
987 case QSystemNetworkInfo::EthernetMode: |
836 { |
988 { |
837 int percent = (isInterfaceActive(interfaceForMode(mode).name().toLatin1())) ? 100 : 0; |
989 int percent = (isInterfaceActive(interfaceForMode(mode).name().toLatin1())) ? 100 : 0; |
838 return percent; |
990 return percent; |
839 } |
991 } |
840 break; |
992 break; |
841 case QSystemNetworkInfo::BluetoothMode: |
993 case QSystemNetworkInfo::BluetoothMode: |
842 // link quality for which device? |
994 { |
843 // [controller readRSSIForDevice: blah?]; |
995 #ifdef MAC_SDK_10_6 |
844 break; |
996 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
|
997 IOBluetoothHostController* controller = IOBluetoothHostController.defaultController; |
|
998 if (controller != NULL) { |
|
999 |
|
1000 NSArray *devices = [IOBluetoothDevice recentDevices:0]; |
|
1001 for ( IOBluetoothDevice *btDevice in devices ) { |
|
1002 if([btDevice isConnected]) { |
|
1003 qWarning() <<"IOBluetoothDevice connected"<< nsstringToQString([btDevice getName]); |
|
1004 // delegate = [[RemoteDeviceRSSIHostControllerDelegate alloc] init]; |
|
1005 [delegate retain]; |
|
1006 [controller setDelegate:delegate]; |
|
1007 IOReturn rc = [controller readRSSIForDevice:btDevice]; |
|
1008 if (rc != noErr) { |
|
1009 qWarning() << "ERROR: call readRSSIForDevice failed"; |
|
1010 } |
|
1011 //[delegate release]; |
|
1012 } |
|
1013 } |
|
1014 // [devices release]; |
|
1015 // [controller release]; |
|
1016 } |
|
1017 [pool release]; |
|
1018 #endif |
|
1019 } |
845 case QSystemNetworkInfo::WimaxMode: |
1020 case QSystemNetworkInfo::WimaxMode: |
846 break; |
1021 break; |
847 default: |
1022 default: |
848 break; |
1023 break; |
849 }; |
1024 }; |
860 return -1; |
1035 return -1; |
861 } |
1036 } |
862 |
1037 |
863 QString QSystemNetworkInfoPrivate::currentMobileCountryCode() |
1038 QString QSystemNetworkInfoPrivate::currentMobileCountryCode() |
864 { |
1039 { |
|
1040 QString cmcc; |
|
1041 #if defined(MAC_SDK_10_6) |
|
1042 if(hasWifi) { |
|
1043 CWInterface *primary = [CWInterface interfaceWithName:nil]; |
|
1044 if([primary power]) { |
|
1045 cmcc = nsstringToQString([primary countryCode]); |
|
1046 } |
|
1047 } |
|
1048 #endif |
|
1049 return cmcc; |
|
1050 } |
|
1051 |
|
1052 QString QSystemNetworkInfoPrivate::currentMobileNetworkCode() |
|
1053 { |
865 return ""; |
1054 return ""; |
866 } |
1055 } |
867 |
1056 |
868 QString QSystemNetworkInfoPrivate::currentMobileNetworkCode() |
1057 QString QSystemNetworkInfoPrivate::homeMobileCountryCode() |
869 { |
1058 { |
870 return ""; |
1059 return ""; |
871 } |
1060 } |
872 |
1061 |
873 QString QSystemNetworkInfoPrivate::homeMobileCountryCode() |
1062 QString QSystemNetworkInfoPrivate::homeMobileNetworkCode() |
874 { |
1063 { |
875 return ""; |
1064 return ""; |
876 } |
1065 } |
877 |
1066 |
878 QString QSystemNetworkInfoPrivate::homeMobileNetworkCode() |
|
879 { |
|
880 return ""; |
|
881 } |
|
882 |
|
883 QString QSystemNetworkInfoPrivate::networkName(QSystemNetworkInfo::NetworkMode mode) |
1067 QString QSystemNetworkInfoPrivate::networkName(QSystemNetworkInfo::NetworkMode mode) |
884 { |
1068 { |
|
1069 if(networkStatus(mode) == QSystemNetworkInfo::NoNetworkAvailable) { |
|
1070 return ""; |
|
1071 } |
885 switch(mode) { |
1072 switch(mode) { |
886 case QSystemNetworkInfo::GsmMode: |
1073 case QSystemNetworkInfo::GsmMode: |
887 break; |
1074 break; |
888 case QSystemNetworkInfo::CdmaMode: |
1075 case QSystemNetworkInfo::CdmaMode: |
889 break; |
1076 break; |
890 case QSystemNetworkInfo::WcdmaMode: |
1077 case QSystemNetworkInfo::WcdmaMode: |
891 break; |
1078 break; |
892 case QSystemNetworkInfo::WlanMode: |
1079 case QSystemNetworkInfo::WlanMode: |
893 { |
1080 { |
|
1081 QString name = interfaceForMode(mode).name(); |
894 #ifdef MAC_SDK_10_6 |
1082 #ifdef MAC_SDK_10_6 |
895 QString name = interfaceForMode(mode).name(); |
1083 if(hasWifi) { |
896 CWInterface *wifiInterface = [CWInterface interfaceWithName:qstringToNSString(name)]; |
1084 CWInterface *wifiInterface = [CWInterface interfaceWithName:qstringToNSString(name)]; |
897 return nsstringToQString([wifiInterface ssid]); |
1085 return nsstringToQString([wifiInterface ssid]); |
|
1086 } |
898 #else |
1087 #else |
|
1088 SCDynamicStoreRef theDynamicStore; |
|
1089 theDynamicStore = SCDynamicStoreCreate(nil, CFSTR("FindCurrentInterfaceAndIP"), nil, nil); |
|
1090 |
|
1091 NSMutableString *interfaceName = [NSMutableString string]; |
|
1092 NSString *airportPath = [NSString stringWithFormat:@"State:/Network/Interface/%@/AirPort", qstringToNSString(name)]; |
|
1093 |
|
1094 CFDictionaryRef airportPlist = (const __CFDictionary*)SCDynamicStoreCopyValue(theDynamicStore, (CFStringRef)airportPath); |
|
1095 |
|
1096 CFRelease(theDynamicStore); |
|
1097 |
|
1098 return nsstringToQString([(NSDictionary *)airportPlist valueForKey:@"SSID_STR"]); |
899 #endif |
1099 #endif |
900 } |
1100 } |
901 break; |
1101 break; |
902 case QSystemNetworkInfo::EthernetMode: |
1102 case QSystemNetworkInfo::EthernetMode: |
903 { |
1103 { |
|
1104 if(isInterfaceActive(interfaceForMode(mode).name().toLocal8Bit())) { |
|
1105 return QHostInfo::localDomainName(); |
|
1106 } |
904 } |
1107 } |
905 break; |
1108 break; |
906 case QSystemNetworkInfo::BluetoothMode: |
1109 case QSystemNetworkInfo::BluetoothMode: |
907 break; |
1110 break; |
908 case QSystemNetworkInfo::WimaxMode: |
1111 case QSystemNetworkInfo::WimaxMode: |
913 return ""; |
1116 return ""; |
914 } |
1117 } |
915 |
1118 |
916 QString QSystemNetworkInfoPrivate::macAddress(QSystemNetworkInfo::NetworkMode mode) |
1119 QString QSystemNetworkInfoPrivate::macAddress(QSystemNetworkInfo::NetworkMode mode) |
917 { |
1120 { |
918 QString mac; |
1121 return interfaceForMode(mode).hardwareAddress(); |
919 #ifdef MAC_SDK_10_6 |
|
920 if(mode == QSystemNetworkInfo::BluetoothMode) { |
|
921 NSString *addy; |
|
922 IOBluetoothHostController* controller = [IOBluetoothHostController defaultController]; |
|
923 if (controller != NULL) { |
|
924 addy = [controller addressAsString]; |
|
925 mac = QLatin1String([addy UTF8String]); |
|
926 mac.replace("-",":"); |
|
927 } |
|
928 return mac; |
|
929 } |
|
930 #endif |
|
931 mac = interfaceForMode(mode).hardwareAddress(); |
|
932 return mac; |
|
933 } |
1122 } |
934 |
1123 |
935 QNetworkInterface QSystemNetworkInfoPrivate::interfaceForMode(QSystemNetworkInfo::NetworkMode mode) |
1124 QNetworkInterface QSystemNetworkInfoPrivate::interfaceForMode(QSystemNetworkInfo::NetworkMode mode) |
936 { |
1125 { |
937 QNetworkInterface netInterface; |
1126 QNetworkInterface netInterface; |
938 |
|
939 CFArrayRef interfaceArray = SCNetworkInterfaceCopyAll(); //10.4 |
1127 CFArrayRef interfaceArray = SCNetworkInterfaceCopyAll(); //10.4 |
940 CFStringRef iName; |
1128 CFStringRef iName; |
941 CFStringRef type; |
1129 CFStringRef type; |
942 |
|
943 for ( long i = 0; i < CFArrayGetCount(interfaceArray); i++) { |
1130 for ( long i = 0; i < CFArrayGetCount(interfaceArray); i++) { |
944 SCNetworkInterfaceRef thisInterface = (SCNetworkInterfaceRef ) CFArrayGetValueAtIndex(interfaceArray, i); |
1131 SCNetworkInterfaceRef thisInterface = (SCNetworkInterfaceRef ) CFArrayGetValueAtIndex(interfaceArray, i); |
945 type = SCNetworkInterfaceGetInterfaceType(thisInterface); |
1132 type = SCNetworkInterfaceGetInterfaceType(thisInterface); |
946 iName = SCNetworkInterfaceGetBSDName(thisInterface); |
1133 iName = SCNetworkInterfaceGetBSDName(thisInterface); |
|
1134 |
947 if (type != NULL) { |
1135 if (type != NULL) { |
948 if (CFEqual(type, kSCNetworkInterfaceTypeBluetooth) && mode == QSystemNetworkInfo::BluetoothMode) { |
1136 if (CFEqual(type, kSCNetworkInterfaceTypeBluetooth) && mode == QSystemNetworkInfo::BluetoothMode) { |
949 netInterface = QNetworkInterface::interfaceFromName(stringFromCFString(iName)); |
1137 netInterface = QNetworkInterface::interfaceFromName(stringFromCFString(iName)); |
950 break; |
1138 // workaround for null MAC from SCNetworkInterfaceGetHardwareAddressString and bogus BSD name here |
|
1139 #ifdef MAC_SDK_10_6 |
|
1140 IOBluetoothHostController* controller = IOBluetoothHostController.defaultController; |
|
1141 QString macbtMac = nsstringToQString([controller addressAsString]).replace("-",":").toUpper(); |
|
1142 if(!macbtMac.isEmpty()) { |
|
1143 QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces(); |
|
1144 foreach(const QNetworkInterface thisNetInterface, interfaces) { |
|
1145 if( thisNetInterface.hardwareAddress() == macbtMac) { |
|
1146 netInterface = thisNetInterface; |
|
1147 break; |
|
1148 } |
|
1149 } |
|
1150 } |
|
1151 #endif |
951 } else if (CFEqual(type, kSCNetworkInterfaceTypeEthernet) && mode == QSystemNetworkInfo::EthernetMode) { |
1152 } else if (CFEqual(type, kSCNetworkInterfaceTypeEthernet) && mode == QSystemNetworkInfo::EthernetMode) { |
952 netInterface = QNetworkInterface::interfaceFromName(stringFromCFString(iName)); |
1153 netInterface = QNetworkInterface::interfaceFromName(stringFromCFString(iName)); |
953 break; |
1154 break; |
954 } else if (CFEqual(type, kSCNetworkInterfaceTypeIEEE80211) && mode == QSystemNetworkInfo::WlanMode) { |
1155 } else if (CFEqual(type, kSCNetworkInterfaceTypeIEEE80211) && mode == QSystemNetworkInfo::WlanMode) { |
955 netInterface = QNetworkInterface::interfaceFromName(stringFromCFString(iName)); |
1156 netInterface = QNetworkInterface::interfaceFromName(stringFromCFString(iName)); |
959 } |
1160 } |
960 CFRelease(interfaceArray); |
1161 CFRelease(interfaceArray); |
961 return netInterface; |
1162 return netInterface; |
962 } |
1163 } |
963 |
1164 |
964 void QSystemNetworkInfoPrivate::networkChanged(const QString ¬ification, const QString interfaceName) |
1165 void QSystemNetworkInfoPrivate::wifiNetworkChanged(const QString ¬ification, const QString interfaceName) |
965 { |
1166 { |
966 qWarning() << __FUNCTION__ << notification; |
1167 getDefaultInterface(); |
967 // runloopThread->stopLoop(); |
|
968 |
1168 |
969 if(notification == QLatin1String("SSID_CHANGED_NOTIFICATION")) { |
1169 if(notification == QLatin1String("SSID_CHANGED_NOTIFICATION")) { |
970 Q_EMIT networkNameChanged(QSystemNetworkInfo::WlanMode, networkName(QSystemNetworkInfo::WlanMode)); |
1170 Q_EMIT networkNameChanged(QSystemNetworkInfo::WlanMode, networkName(QSystemNetworkInfo::WlanMode)); |
971 } |
1171 } |
972 |
1172 |
977 if(notification == QLatin1String("POWER_CHANGED_NOTIFICATION")) { |
1177 if(notification == QLatin1String("POWER_CHANGED_NOTIFICATION")) { |
978 #ifdef MAC_SDK_10_6 |
1178 #ifdef MAC_SDK_10_6 |
979 CWInterface *wifiInterface = [CWInterface interfaceWithName: qstringToNSString(interfaceName)]; |
1179 CWInterface *wifiInterface = [CWInterface interfaceWithName: qstringToNSString(interfaceName)]; |
980 if([wifiInterface power]) { |
1180 if([wifiInterface power]) { |
981 if(!rssiTimer->isActive()) { |
1181 if(!rssiTimer->isActive()) { |
982 qWarning() << __FUNCTION__ << "start timer"; |
1182 rssiTimer->start(5000); |
983 rssiTimer->start(1000); |
1183 |
984 } |
1184 } |
985 } else { |
1185 } else { |
986 if(rssiTimer->isActive()) { |
1186 if(rssiTimer->isActive()) { |
987 qWarning() << __FUNCTION__ << "stop timer"; |
1187 rssiTimer->stop(); |
988 rssiTimer->stop(); |
1188 } |
989 } |
1189 Q_EMIT networkSignalStrengthChanged(QSystemNetworkInfo::WlanMode, 0); |
990 } |
1190 } |
991 #endif |
1191 #endif |
992 } |
1192 } |
993 // runloopThread->start(); |
1193 } |
994 } |
1194 |
|
1195 QSystemNetworkInfo::NetworkMode QSystemNetworkInfoPrivate::currentMode() |
|
1196 { |
|
1197 return modeForInterface(getDefaultInterface()); |
|
1198 } |
|
1199 |
995 |
1200 |
996 QSystemDisplayInfoPrivate::QSystemDisplayInfoPrivate(QObject *parent) |
1201 QSystemDisplayInfoPrivate::QSystemDisplayInfoPrivate(QObject *parent) |
997 : QObject(parent) |
1202 : QObject(parent) |
998 { |
1203 { |
999 } |
1204 } |
1120 devId = devId.prepend(QLatin1String("/dev/")); |
1325 devId = devId.prepend(QLatin1String("/dev/")); |
1121 if(mountEntriesHash.value(devId) == driveVolume) { |
1326 if(mountEntriesHash.value(devId) == driveVolume) { |
1122 if (volumeParmeters.vMServerAdr == 0) { //local drive |
1327 if (volumeParmeters.vMServerAdr == 0) { //local drive |
1123 io_service_t ioService; |
1328 io_service_t ioService; |
1124 ioService = IOServiceGetMatchingService(kIOMasterPortDefault, |
1329 ioService = IOServiceGetMatchingService(kIOMasterPortDefault, |
1125 IOBSDNameMatching(kIOMasterPortDefault, 0, |
1330 IOBSDNameMatching(kIOMasterPortDefault, |
1126 (char *)volumeParmeters.vMDeviceID)); |
1331 0, |
|
1332 (char *)volumeParmeters.vMDeviceID)); |
1127 |
1333 |
1128 if (IOObjectConformsTo(ioService, kIOMediaClass)) { |
1334 if (IOObjectConformsTo(ioService, kIOMediaClass)) { |
1129 CFTypeRef wholeMedia; |
1335 CFTypeRef wholeMedia; |
1130 |
1336 |
1131 wholeMedia = IORegistryEntryCreateCFProperty(ioService, |
1337 wholeMedia = IORegistryEntryCreateCFProperty(ioService, |
1132 CFSTR(kIOMediaContentKey), |
1338 CFSTR(kIOMediaContentKey), |
1133 kCFAllocatorDefault, |
1339 kCFAllocatorDefault, |
1134 0); |
1340 0); |
1135 |
1341 |
1136 if((volumeParmeters.vMExtendedAttributes & (1L << bIsRemovable))) { |
1342 if((volumeParmeters.vMExtendedAttributes & (1L << bIsRemovable))) { |
|
1343 IOObjectRelease(ioService); |
1137 CFRelease(wholeMedia); |
1344 CFRelease(wholeMedia); |
1138 return QSystemStorageInfo::RemovableDrive; |
1345 return QSystemStorageInfo::RemovableDrive; |
1139 } else { |
1346 } else { |
|
1347 IOObjectRelease(ioService); |
|
1348 CFRelease(wholeMedia); |
1140 return QSystemStorageInfo::InternalDrive; |
1349 return QSystemStorageInfo::InternalDrive; |
1141 } |
1350 } |
1142 } |
1351 } |
|
1352 IOObjectRelease(ioService); |
1143 } else { |
1353 } else { |
1144 return QSystemStorageInfo::RemoteDrive; |
1354 return QSystemStorageInfo::RemoteDrive; |
1145 } |
1355 } |
1146 } |
1356 } |
1147 } |
1357 } |
1320 CFNumberGetValue((CFNumberRef)powerStateValue, kCFNumberSInt32Type, &maxLevel); |
1530 CFNumberGetValue((CFNumberRef)powerStateValue, kCFNumberSInt32Type, &maxLevel); |
1321 level = (currentLevel/maxLevel) * 100; |
1531 level = (currentLevel/maxLevel) * 100; |
1322 } |
1532 } |
1323 |
1533 |
1324 CFRelease(powerSourcesInfoBlob); |
1534 CFRelease(powerSourcesInfoBlob); |
1325 CFRelease(powerSourcesList); |
1535 CFRelease(powerSourcesList); |
1326 |
1536 |
1327 if(batteryLevelCache != level) { |
1537 if(batteryLevelCache != level) { |
1328 batteryLevelCache = level; |
1538 batteryLevelCache = level; |
1329 Q_EMIT batteryLevelChanged(level); |
1539 Q_EMIT batteryLevelChanged(level); |
1330 } |
1540 } |