MacOS X पर C प्रोग्राम में USB उपकरणों के साथ कार्य करना

प्रिय पाठकों को नमस्कार।
इस संक्षिप्त लेख में, मैं MacOS X ऑपरेटिंग सिस्टम में उपकरण (इस मामले में, USB डिवाइस) के साथ बातचीत के मुद्दे पर विचार करना चाहूंगा।
एक बहुत ही रोचक और उपयोगी IOKit फ्रेमवर्क पर विचार किया जाएगा, जो उपकरणों को जोड़ने / हटाने के बारे में सूचनाएं प्राप्त करने का एक तरीका है, साथ ही उपकरणों के बारे में पूरी जानकारी प्राप्त करना है। बेशक, यह सामग्री किसी भी विशिष्टता का दावा नहीं करती है, क्योंकि हर कोई अपने दम पर इन मुद्दों से निपट सकता है, Apple के प्रलेखन का अध्ययन किया है, साथ ही साथ कई स्रोतों को खोला है।
मेरा लेख इस तरह की रूसी-भाषा की सामग्री में अंतर को भरने का प्रयास है और कुछ रेक का वर्णन करता है जो नए लोगों का सामना कर सकते हैं।
हर कोई जो रुचि रखता है - बिल्ली का स्वागत करता है।


IOKit।
मैकओएस एक्स कर्नेल में एक अद्भुत चीज है - आईओकिट रूपरेखा। यह एक ऑब्जेक्ट-ओरिएंटेड C ++ फ्रेमवर्क है जिसे विशेष रूप से हार्डवेयर ड्राइवर इंफ्रास्ट्रक्चर का समर्थन करने के लिए डिज़ाइन किया गया है। सच है, C ++ वहां कुछ हद तक छोटा है, उदाहरण के लिए, कोई अपवाद नहीं हैं, RTTI, टेम्पलेट। शेष कर्नेल मुख्यतः C में लिखा जाता है।
IOKit को स्वयं दो भागों में विभाजित किया जा सकता है: कर्नेल फ्रेमवर्क, जिस पर ड्राइवर लिखे जाते हैं, और उपयोगकर्ता-विशिष्ट IOKit.framework, उपयोगकर्ता अनुप्रयोगों से कर्नेल मॉड्यूल (और, तदनुसार, हार्डवेयर) तक आसान पहुंच के लिए डिज़ाइन किया गया है।
IOKit की ऑब्जेक्ट-ओरिएंटेड प्रकृति आपको उपकरण के वास्तविक भौतिक मॉडल को आसानी से प्रदर्शित करने की अनुमति देती है: एक यूएसबी डिवाइस जुड़ा हुआ है, एक यूएसबी पोर्ट के माध्यम से यह हब से जुड़ा है, हब कंप्यूटर में संबंधित नियंत्रक से जुड़ा हुआ है, यह नियंत्रक पीसीआई बस के माध्यम से मदरबोर्ड चिपसेट के बाकी हिस्सों से जुड़ा है। इस मॉडल में प्रत्येक IOKit ड्राइवर या तो एक एंड नोड (उदाहरण के लिए, एक यूएसबी मॉडेम) या एक कनेक्टिंग मॉड्यूल (उदाहरण के लिए, एक यूएसबी पोर्ट कंट्रोलर) है, जो कि ऐप्पल की शब्दावली में उत्तरार्द्ध को नूब कहा जाता है।
Xcode डिलीवरी किट में ग्राफिकल यूटिलिटी IORegExplorer शामिल है, जो आपको IOKit मॉड्यूल की पूरी संरचना को देखने की अनुमति देता है, विभिन्न मापदंडों और तकनीकी जानकारी को पढ़ता है।

उपयोगिता का एक कंसोल एनालॉग भी है - आईओआरजी।

यह लेख केवल उपयोगकर्ता-विशिष्ट IOKit.framework के साथ काम करेगा। यदि पाठकों में से कोई भी कर्नेल फ्रेमवर्क में रुचि रखता है, तो आप लेख habrahabr.ru/post/36875 , साथ ही साथ अद्भुत पुस्तक OS X और iOS कर्नेल प्रोग्रामिंग पढ़ सकते हैं।

USB सूचनाएं प्राप्त करें
जैसा कि ऊपर उल्लेख किया गया है, हम यूएसबी के साथ काम करेंगे, इसलिए हमें केवल एक हेडर फ़ाइल की आवश्यकता है

#include <IOKit/usb/IOUSBLib.h> 

आरंभ करने के लिए, हम USB उपकरणों को जोड़ने / हटाने के बारे में सूचनाएँ प्राप्त करने के लिए सदस्यता लेते हैं। IONotificationPortRef जैसी एक विशेष वस्तु हमें इसमें मदद करेगी।
IONotificationPortRef का एक उदाहरण बनाएँ और आरंभ करें

 IONotificationPortRef notificationPort = IONotificationPortCreate(kIOMasterPortDefault); 

हमने IOKit से घटनाओं को सुनने के लिए एक प्रकार का वर्चुअल पोर्ट बनाया (यह अभी तक निर्धारित नहीं किया गया है कि कौन से हैं)। kIOMasterPortDefault एक स्थिर है जो IOKit से संदेश प्राप्त करने के लिए एक निश्चित डिफ़ॉल्ट पोर्ट को परिभाषित करता है, हमेशा इस मान का उपयोग करें।

अब हम यह निर्धारित करेंगे कि हम कौन से संदेश प्राप्त करना चाहते हैं। ऐसा करने के लिए, MacOS X बेस फ्रेमवर्क के उपयुक्त कंटेनर का उपयोग करके तथाकथित शब्दकोश बनाएं।

 CFMutableDictionaryRef matchDict = (CFMutableDictionaryRef) CFRetain(IOServiceMatching(kIOUSBDeviceClassName)); 

यहाँ मुख्य विधि IOServiceMatching है, जो USB क्लास उपकरणों का एक शब्दकोश बनाता है, मुझे लगता है कि यह स्पष्ट है (उदाहरण के लिए, फायरफॉक्स और इस तरह के अन्य स्थिरांक हैं, जो सूचनाएं प्राप्त करने की अनुमति देते हैं)। अगला, हम CFRetain का उपयोग करके इस ऑब्जेक्ट के स्वामित्व को "लेते हैं"। यह आवश्यक है ताकि IOKit फ्रेमवर्क विधियों में ऑब्जेक्ट के संभावित डबल रिलीज के साथ कोई समस्या न हो। वास्तव में, हमें इस ऑब्जेक्ट को खुद को मुक्त करने की आवश्यकता नहीं है, अन्य मामलों में, कभी भी ढेर में आवंटित वस्तुओं (किसी भी प्राप्त * विधि द्वारा प्राप्त नहीं) के लिए CFRelease को कॉल करना न भूलें। इसके अलावा, हमेशा जाँचें, हौसले से बनाए गए / हौसले से प्राप्त किए गए * NULL के लिए, अंतर्निहित ढांचे की वस्तुओं को देखें ये वास्तव में, साधारण संकेत हैं और आपको उनके अनुसार काम करने की आवश्यकता है।

अगला, इस वाक्यांश को "पहले से तैयार किए गए पोर्ट पर" मेल करें, मिलान अधिसूचना के रूप में। यह IOServiceAddMatchingNotification विधि द्वारा किया जाता है।
गौर से देखिए

 kern_return_t IOServiceAddMatchingNotification( IONotificationPortRef notifyPort, const io_name_t notificationType, CFDictionaryRef matching, IOServiceMatchingCallback callback, void *refCon, io_iterator_t *notification ); 

नोटिफिकेशन के लिए पहला पैरामीटर वास्तविक पोर्ट है जिसे हमने पहले बनाया था।
दूसरा नोटिफिकेशन पैरामीटर इस शब्दकोश के लिए सूचनाओं का प्रकार है, जैसे kIOTerminatedNotification , kIOMatchedNotification , kIOFirstMatchNotification । मुझे लगता है कि इन स्थिरांक के नामों से यह स्पष्ट है कि उनका क्या मतलब है।
तीसरा पैरामीटर मिलान शब्दकोष ही है। ऑब्जेक्ट का प्रकार, जैसा कि आप देख सकते हैं, सीएफआरडियर रीफ है। यह एक समस्या नहीं है क्योंकि CFMutableDictionaryRef आसानी से CF ढं ग की ओर डाली जाती है।
चौथा कॉलबैक विधि सबसे दिलचस्प है। यह कॉलबैक पद्धति का एक संकेतक है जिसे संबंधित घटना आने पर कॉल किया जाता है। उसके बारे में थोड़ा कम।
पांचवां पैरामीटर refCon कॉलबैक विधि का संदर्भ है, यहां आप अपने डेटा को इस फ़ंक्शन में स्थानांतरित कर सकते हैं।
अंतिम अधिसूचना पैरामीटर एक संग्रहकर्ता है जिसे डिवाइस संग्रह पर पुनरावृति करने के लिए डिज़ाइन किया गया है, इस तर्क को IOServiceAddMatchingNotification से आरंभ किया गया है और कॉलबैक विधि में भी इसे पारित किया गया है, जो संग्रह में बहुत पहले डिवाइस को दर्शाता है।

यदि सफल, IOServiceAddMatchingNotification शून्य देता है, अन्यथा एक सकारात्मक संख्या, एक त्रुटि कोड।

कॉलबैक फ़ंक्शन को निम्नानुसार परिभाषित किया गया है:
typedef void (*IOServiceMatchingCallback)(void *refcon, io_iterator_t iterator);
जैसा कि आप देख सकते हैं, फ़ंक्शन IOServiceAddMatchingNotification से अंतिम दो तर्क स्वीकार करता है।

हमें उपकरणों को जोड़ने और हटाने के लिए दो ऐसे कार्यों की घोषणा करने की आवश्यकता है

 void usb_device_added(void* refcon, io_iterator_t iterator) { } void usb_device_removed(void* refcon, io_iterator_t iterator) { } 

और अब, अंत में, सूचनाओं को कॉन्फ़िगर करें।

 kern_return_t result; io_iterator_t deviceAddedIter; io_iterator_t deviceRemovedIter; result = IOServiceAddMatchingNotification(notificationPort, kIOMatchedNotification, matchDict, usb_device_added, NULL, &deviceAddedIter); ... result = IOServiceAddMatchingNotification(notificationPort, kIOTerminatedNotification, matchDict, usb_device_removed, NULL, &deviceRemovedIter); 

कोई अतिरिक्त विधि आरंभीकरण की आवश्यकता नहीं है और IOServiceAddMatchingNotification पर प्रत्येक कॉल के बाद परिणाम कोड की जांच करना सुनिश्चित करें।

अब हमें एक लूप के साथ स्ट्रीम को कॉन्फ़िगर करने की आवश्यकता है जिसमें हमारा श्रोता स्पिन करेगा। MacOS X इन उद्देश्यों के लिए एक संबंधित वस्तु प्रदान करता है - CFRunLoop। इस ऑब्जेक्ट के सामान्य संचालन के लिए, आपको तथाकथित स्रोत को निर्दिष्ट करना होगा और वर्तमान या किसी अन्य स्ट्रीम के संदर्भ में शुरू करना होगा, और काम पूरा होने के बाद इसे रोकना होगा।
आइए इसे ऐसे करें:

 CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notificationPort), kCFRunLoopDefaultMode); 

इस स्थिति में, हम विशेष IONotificationPortGetRunLoopSource विधि का उपयोग करके अधिसूचना स्रोत जोड़ते हैं, हमारे सूचना पोर्ट का उपयोग करते हैं, इसके अलावा, हम आवश्यक स्ट्रीम के पहचानकर्ता को निर्दिष्ट करते हैं - इस मामले में, वर्तमान स्ट्रीम CFRunPopGetCurrent ()

फिर आप इस स्ट्रीम को शुरू कर सकते हैं और सूचनाएं प्राप्त करना शुरू कर सकते हैं। लेकिन एक चेतावनी है कि सब कुछ काम करता है - कॉलबैक विधियों को मैन्युअल रूप से एक बार कॉल करने की आवश्यकता होती है, जैसे कि संग्रह "परीक्षण"। यदि ऐसा नहीं किया जाता है, तो सूचनाएं नहीं आएंगी।

धागे की शुरुआत CFRunLoopRun () विधि द्वारा की जाती है; सब कुछ, इस बिंदु पर, कोड निष्पादन आगे नहीं बढ़ेगा। इस चक्र को केवल CFRunLoopStop के उपयोग से रोका जा सकता है, तर्क से, यह विधि उस थ्रेड के पहचानकर्ता को पास करती है जहाँ CFRunLoopRun लॉन्च किया गया था, वास्तव में वह मान जो CFRunLoopGetCurrent के ऊपर लौटा है। बहु-थ्रेडेड वातावरण में, मैं अनुशंसा करता हूं कि आप इस मान को दूसरे थ्रेड के संदर्भ से रनऑलॉप को रोकने में सक्षम होने के लिए रखें, बस सही, सहेजे गए पहचानकर्ता को निर्दिष्ट करके।

प्रवाह को रोकने के बाद, आपको थोड़ा सा कसने की जरूरत है:

 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notificationPort), kCFRunLoopDefaultMode); IONotificationPortDestroy(notificationPort); 

USB उपकरणों के बारे में जानकारी प्राप्त करना
इसलिए, हमने सीखा कि USB उपकरणों को जोड़ने / हटाने के बारे में सूचनाएँ कैसे प्राप्त करें, अब देखते हैं कि आप सीधे कॉलबैक विधियों में डिवाइस के बारे में सभी जानकारी कैसे प्राप्त कर सकते हैं।
एक अच्छे तरीके से, दोनों तरीकों को कम करके एक विधि को iterate_usb_devices कहा जाना चाहिए

 void iterate_usb_devices(io_iterator_t iterator) { io_service_t usbDevice; while ((usbDevice = IOIteratorNext(iterator))) { .... IOObjectRelease(usbDevice); } } 

यहां हम पारित संग्रहकर्ता और IOIteratorNext का उपयोग करके डिवाइस संग्रह के माध्यम से जाते हैं, ऑब्जेक्ट का उपयोग करने के बाद, आपको IOObjectRelease में इसे मुक्त करने की आवश्यकता है।
प्रत्येक usbDevice प्राप्त वस्तु सभी आवश्यक जानकारी का स्रोत है। सबसे सरल उदाहरण:

 io_name_t devicename; if (IORegistryEntryGetName(usbDevice, devicename) != KERN_SUCCESS) == KERN_SUCCESS) { printf("Device name: %s\n", devicename); } 

यदि सफल हो, तो एक पठनीय डिवाइस नाम, जैसे कि "नोवटेल वायरलेस मॉडेम," प्रदर्शित किया जाएगा। io_name_t अनिवार्य रूप से एक नियमित चार सरणी है।

एक और उदाहरण, IOKit पदानुक्रम में डिवाइस को पूर्ण पथ प्राप्त करना:

 io_name_t entrypath; if (IORegistryEntryGetPath(usbDevice, kIOServicePlane, entrypath) == KERN_SUCCESS) { printf("\tDevice entry path: %s\n", entrypath); } 

ये सबसे सरल मामले हैं, क्योंकि usbDevice ऑब्जेक्ट एक मुख्य-मूल्य जोड़ी के रूप में विभिन्न मापदंडों के पूरे शब्दकोश के साथ जुड़ा हुआ है। संबंधित कुंजियों का उपयोग करके, आप संबंधित पैरामीटर मान प्राप्त कर सकते हैं, उदाहरण के लिए, डिवाइस का विक्रेता प्राप्त करें।

 CFNumberRef vendorId = (CFNumberRef) IORegistryEntrySearchCFProperty(usbDevice , kIOServicePlane , CFSTR("idVendor") , NULL , kIORegistryIterateRecursively | kIORegistryIterateParents); 

यह विधि स्ट्रिंग कुंजी द्वारा संबंधित पैरामीटर की तलाश करती है, इस मामले में "idVendor" (CFSTR एक MacOS X फ्रेमवर्क विधि है जो जल्दी से C-string को आंतरिक प्रकार के CFStringRef में परिवर्तित करता है)

IORegistryEntrySearchCFProperty यदि इस मामले में CFNumberRef की तलाश में असफल है, या आप जिस प्रकार की वस्तु की तलाश कर रहे हैं, उसके सूचक को रिटर्न देता है। CFNumberRef से एक सामान्य संख्यात्मक मान लाने के लिए, आपको निम्नलिखित का उपयोग करना चाहिए:

 int result; if (CFNumberGetValue(vendorId, kCFNumberSInt32Type, &result)) { printf("VendorID: %i\n", result); } 

"ProductID" प्राप्त करना ठीक उसी तरह से किया जाता है, केवल कुंजी "idProduct" का उपयोग किया जाना चाहिए

बेशक, मापदंडों और इसी कुंजी की सूची डिवाइस से डिवाइस तक बहुत भिन्न हो सकती है। पाठक के पास एक ही प्रश्न हो सकता है - कैसे पता लगाएं कि इस उपकरण में कौन से पैरामीटर और किस कुंजी को देखना है और एक बार में सभी मानों को कैसे प्रदर्शित करना है?
यह काफी सरलता से किया जाता है:

 CFMutableDictionaryRef properties; IORegistryEntryCreateCFProperties(usbDevice, &properties, kCFAllocatorDefault, 0); 

यदि यह विधि सफलतापूर्वक पूर्ण हो जाती है, तो हमें अपने निपटान में डिवाइस की सभी कुंजियों / मूल्यों से भरा एक शब्दकोश देना होगा।
इस डिक्शनरी को स्क्रीन पर प्रिंट करने का सबसे आसान तरीका है, CFShow फ्रेमवर्क। इसके बारे में शब्दों की एक जोड़ी, CFShow MacOS X में किसी भी CoreFoundation फ्रेमवर्क ऑब्जेक्ट्स का अनुकरण करने के लिए एक सार्वभौमिक विधि है - CFMutableDictionaryRef, CFStringRef, CFNumberRef, आदि। उत्पादन stderr में किया जाता है।
इसलिए, हम स्क्रीन पर शब्दकोश की सामग्री प्रदर्शित करते हैं:

 CFShow(properties); 

अब हमारे पास इस उपकरण के लिए सभी कुंजी और सभी मापदंडों की एक सूची है और हम इस ज्ञान का उपयोग विशिष्ट वस्तुओं के रूप में विशिष्ट मूल्यों को प्राप्त करने के लिए कर सकते हैं (या तो IORegistryEntrySearchCFProperty के माध्यम से, या सीधे शब्दकोश से, शब्दकोशों के साथ काम करने के तरीकों का उपयोग करके)

काम कर रहे आवेदन।
अब मैं एक छोटे से आवेदन का उदाहरण देना चाहूंगा जिसमें ऊपर वर्णित सब कुछ है। अन्य बातों के अलावा, मैंने Ctrl-C का उपयोग करके एप्लिकेशन को सही ढंग से पूरा करने में सक्षम होने के लिए इस उदाहरण में सिग्नल प्रोसेसिंग को जोड़ने का निर्णय लिया।
नोट: वास्तविक परियोजनाओं में, सिग्नल हैंडलर में कभी भी इस तरह की कार्रवाई नहीं की जाती है, क्यों, आप उदाहरण के लिए, इस संदेश में पढ़ सकते हैं

 #include <IOKit/usb/IOUSBLib.h> #include <signal.h> #include <stdio.h> #include <stdlib.h> static IONotificationPortRef notificationPort; void usb_device_added(void* refcon, io_iterator_t iterator); void usb_device_removed(void* refcon, io_iterator_t iterator); void init_notifier() { notificationPort = IONotificationPortCreate(kIOMasterPortDefault); CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notificationPort), kCFRunLoopDefaultMode); printf("init_notifier ---> Ok\n"); } void configure_and_start_notifier() { printf("Starting notifier...\n\n"); CFMutableDictionaryRef matchDict = (CFMutableDictionaryRef) CFRetain(IOServiceMatching(kIOUSBDeviceClassName)); if (!matchDict) { fprintf(stderr, "Failed to create matching dictionary for kIOUSBDeviceClassName\n"); return; } kern_return_t addResult; io_iterator_t deviceAddedIter; addResult = IOServiceAddMatchingNotification(notificationPort, kIOMatchedNotification, matchDict, usb_device_added, NULL, &deviceAddedIter); if (addResult != KERN_SUCCESS) { fprintf(stderr, "IOServiceAddMatchingNotification failed for kIOMatchedNotification\n"); return; } usb_device_added(NULL, deviceAddedIter); io_iterator_t deviceRemovedIter; addResult = IOServiceAddMatchingNotification(notificationPort, kIOTerminatedNotification, matchDict, usb_device_removed, NULL, &deviceRemovedIter); if (addResult != KERN_SUCCESS) { fprintf(stderr, "IOServiceAddMatchingNotification failed for kIOTerminatedNotification\n"); return; } usb_device_removed(NULL, deviceRemovedIter); CFRunLoopRun(); } void deinit_notifier() { CFRunLoopRemoveSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notificationPort), kCFRunLoopDefaultMode); IONotificationPortDestroy(notificationPort); printf("deinit_notifier ---> Ok\n"); } void signal_handler(int signum) { printf("\ngot signal, signnum=%i stopping current RunLoop\n", signum); CFRunLoopStop(CFRunLoopGetCurrent()); } void init_signal_handler() { signal(SIGINT, signal_handler); signal(SIGQUIT, signal_handler); signal(SIGTERM, signal_handler); } int main() { init_signal_handler(); init_notifier(); configure_and_start_notifier(); deinit_notifier(); return 0; } void print_cfstringref(const char* prefix, CFStringRef cfVal) { char* cVal = malloc(CFStringGetLength(cfVal) * sizeof(char)); if (!cVal) { return; } if (CFStringGetCString(cfVal, cVal, CFStringGetLength(cfVal) + 1, kCFStringEncodingASCII)) { printf("%s %s\n", prefix, cVal); } free(cVal); } void print_cfnumberref(const char* prefix, CFNumberRef cfVal) { int result; if (CFNumberGetValue(cfVal, kCFNumberSInt32Type, &result)) { printf("%s %i\n", prefix, result); } } void get_usb_device_info(io_service_t device, int newdev) { io_name_t devicename; io_name_t entrypath; io_name_t classname; if (IORegistryEntryGetName(device, devicename) != KERN_SUCCESS) { fprintf(stderr, "%s unknown device (unable to get device name)\n", newdev ? "Added " : " Removed"); return; } printf("USB device %s: %s\n", newdev ? "FOUND" : "REMOVED", devicename); if (IORegistryEntryGetPath(device, kIOServicePlane, entrypath) == KERN_SUCCESS) { printf("\tDevice entry path: %s\n", entrypath); } if (IOObjectGetClass(device, classname) == KERN_SUCCESS) { printf("\tDevice class name: %s\n", classname); } CFStringRef vendorname = (CFStringRef) IORegistryEntrySearchCFProperty(device , kIOServicePlane , CFSTR("USB Vendor Name") , NULL , kIORegistryIterateRecursively | kIORegistryIterateParents); if (vendorname) { print_cfstringref("\tDevice vendor name:", vendorname); } CFNumberRef vendorId = (CFNumberRef) IORegistryEntrySearchCFProperty(device , kIOServicePlane , CFSTR("idVendor") , NULL , kIORegistryIterateRecursively | kIORegistryIterateParents); if (vendorId) { print_cfnumberref("\tVendor id:", vendorId); } CFNumberRef productId = (CFNumberRef) IORegistryEntrySearchCFProperty(device , kIOServicePlane , CFSTR("idProduct") , NULL , kIORegistryIterateRecursively | kIORegistryIterateParents); if (productId) { print_cfnumberref("\tProduct id:", productId); } printf("\n"); } void iterate_usb_devices(io_iterator_t iterator, int newdev) { io_service_t usbDevice; while ((usbDevice = IOIteratorNext(iterator))) { get_usb_device_info(usbDevice, newdev); IOObjectRelease(usbDevice); } } void usb_device_added(void* refcon, io_iterator_t iterator) { iterate_usb_devices(iterator, 1); } void usb_device_removed(void* refcon, io_iterator_t iterator) { iterate_usb_devices(iterator, 0); } 

एप्लिकेशन का संकलन कमांड द्वारा किया जाता है
gcc usbnotify.c -framework IOKit -framework Foundation -o notifier
या
clang usbnotify.c -framework IOKit -framework Foundation -o notifier
दोनों आदेशों को निष्पादित करने का परिणाम समान होगा।

नीचे आप कनेक्ट और डिस्कनेक्ट किए गए उपकरणों के बारे में जानकारी के साथ चल रहे एप्लिकेशन के स्क्रीनशॉट देख सकते हैं











संदर्भ:
goo.gl/LRyIr
goo.gl/O1Oyk
goo.gl/NQUtL
goo.gl/daEiS
goo.gl/7jkUs
goo.gl/yeJre
www.amazon.com/OS-X-iOS-Kernel-Programming/dp/1430235365
habrahabr.ru/post/36875

आपका ध्यान देने के लिए धन्यवाद।