ios - UIDevice अद्वितीय इडेंडिफायर बहिष्कृत-अब क्या करना है?




deprecated (20)

@ मूनलाइट द्वारा प्रस्तावित लिंक के आधार पर, मैंने कई परीक्षण किए और यह सबसे अच्छा समाधान प्रतीत होता है। जैसा कि @ डार्कडस्ट कहता है कि विधि en0 जांच करने के लिए en0 जो हमेशा उपलब्ध होती है।
2 विकल्प हैं:
uniqueDeviceIdentifier (एमएसी + uniqueDeviceIdentifier एमडी 5)
और uniqueGlobalDeviceIdentifier (मैक का MD5), ये हमेशा एक ही मान देता है।
मैंने किए गए परीक्षणों के नीचे (असली डिवाइस के साथ):

#import "UIDevice+IdentifierAddition.h"

NSLog(@"%@",[[UIDevice currentDevice] uniqueDeviceIdentifier]);
NSLog(@"%@",[[UIDevice currentDevice] uniqueGlobalDeviceIdentifier]);

XXXX21f1f19edff198e2a2356bf4XXXX - (वाईफ़ाई) UDID
XXXX7dc3c577446a2bcbd77935bdXXXX - (वाईफ़ाई) GlobalAppUDID

XXXX21f1f19edff198e2a2356bf4XXXX - (3 जी) यूडीआईडी
XXXX7dc3c577446a2bcbd77935bdXXXX - (3 जी) GlobalAppUDID

XXXX21f1f19edff198e2a2356bf4XXXX - (जीपीआरएस) यूडीआईडी
XXXX7dc3c577446a2bcbd77935bdXXXX - (जीपीआरएस) GlobalAppUDID

XXXX21f1f19edff198e2a2356bf4XXXX - (एयरप्लेन मोड) UDID
XXXX7dc3c577446a2bcbd77935bdXXXX - (एयरप्लेन मोड) GlobalAppUDID

XXXX21f1f19edff198e2a2356bf4XXXX - ऐप को हटाने और इंस्टॉल करने के बाद ऐप XXXX7dc3c577446a2bcbd77935bdXXXX (वाई-फ़ाई) को हटाने और पुनर्स्थापित करने के बाद (वाई-फ़ाई)

उम्मीद है कि यह उपयोगी है।

संपादित करें:
जैसा कि अन्य ने इंगित किया है, आईओएस 7 में यह समाधान अब उपयोगी नहीं है क्योंकि uniqueIdentifier अब उपलब्ध नहीं है और मैक पते के लिए पूछताछ अब हमेशा 02: 00: 00: 00: 00: 00

यह अभी प्रकाश में आया है कि यूआईडीवीस अद्वितीय इंडेंटिफायर संपत्ति आईओएस 5 और उससे ऊपर में बहिष्कृत है। कोई वैकल्पिक विधि या संपत्ति उपलब्ध या आने वाली प्रतीत नहीं होती है।

हमारे मौजूदा ऐप्स में से कई विशेष रूप से किसी विशेष डिवाइस की पहचान करने के लिए इस संपत्ति पर निर्भर हैं। क्या कोई भी इस विचार को सुझाव दे सकता है कि हम इस समस्या को आगे कैसे संभालेंगे?

दस्तावेज से सुझाव है ...

विशेष ध्यान

अद्वितीय इंडेंटिफायर संपत्ति का उपयोग न करें। अपने ऐप के लिए विशिष्ट अद्वितीय पहचानकर्ता बनाने के लिए, आप UUID बनाने के लिए CFUUIDCreate फ़ंक्शन को कॉल कर सकते हैं, और इसे NSUserDefaults क्लास का उपयोग करके डिफ़ॉल्ट डेटाबेस पर लिख सकते हैं।

हालांकि यदि कोई उपयोगकर्ता ऐप को अनइंस्टॉल और पुनः इंस्टॉल करता है तो यह मान समान नहीं होगा।


अपना यूयूआईडी बनाएं और फिर इसे कीचेन में स्टोर करें। इस प्रकार यह तब भी बनी रहती है जब आपका ऐप अनइंस्टॉल हो जाता है। कई मामलों में यह तब भी जारी रहता है जब उपयोगकर्ता डिवाइसों के बीच माइग्रेट करता है (जैसे पूर्ण बैकअप और किसी अन्य डिवाइस पर पुनर्स्थापित)।

जहां तक ​​आप चिंतित हैं, प्रभावी रूप से यह एक अद्वितीय उपयोगकर्ता पहचानकर्ता बन जाता है। ( डिवाइस पहचानकर्ता से भी बेहतर)।

उदाहरण:

मैं UUID बनाने के लिए एक कस्टम विधि परिभाषित कर रहा हूं:

- (NSString *)createNewUUID 
{
    CFUUIDRef theUUID = CFUUIDCreate(NULL);
    CFStringRef string = CFUUIDCreateString(NULL, theUUID);
    CFRelease(theUUID);
    return [(NSString *)string autorelease];
}

फिर आप इसे अपने ऐप के पहले लॉन्च पर KEYCHAIN में स्टोर कर सकते हैं। इसलिए कि पहले लॉन्च के बाद, हम इसे केवल चाबी से उपयोग कर सकते हैं, इसे पुन: उत्पन्न करने की आवश्यकता नहीं है। स्टोर करने के लिए कीचेन का उपयोग करने का मुख्य कारण यह है: जब आप UUID को कीचेन पर सेट करते हैं, तो यह तब भी जारी रहेगा जब उपयोगकर्ता पूरी तरह से ऐप को अनइंस्टॉल करता है और फिर इसे फिर से इंस्टॉल करता है। । तो, यह इसे संग्रहीत करने का स्थायी तरीका है, जिसका अर्थ है कि कुंजी सभी तरह से अद्वितीय होगी।

     #import "SSKeychain.h"
     #import <Security/Security.h>

Applictaion लॉन्च पर निम्नलिखित कोड शामिल हैं:

 // getting the unique key (if present ) from keychain , assuming "your app identifier" as a key
       NSString *retrieveuuid = [SSKeychain passwordForService:@"your app identifier" account:@"user"];
      if (retrieveuuid == nil) { // if this is the first time app lunching , create key for device
        NSString *uuid  = [self createNewUUID];
// save newly created key to Keychain
        [SSKeychain setPassword:uuid forService:@"your app identifier" account:@"user"];
// this is the one time process
}

Sskeychain से SSKeychain.m और .h फ़ाइल डाउनलोड करें और अपनी परियोजना में SSKeychain.m और .h फ़ाइल खींचें और अपनी प्रोजेक्ट में "Security.framework" जोड़ें। बाद में यूयूआईडी का उपयोग करने के लिए:

NSString *retrieveuuid = [SSKeychain passwordForService:@"your app identifier" account:@"user"];


आप OpenUDID का उपयोग करने पर विचार करना चाह सकते हैं जो OpenUDID ड्रॉप-इन प्रतिस्थापन है।

असल में, UDID से मिलान करने के लिए, निम्नलिखित विशेषताओं की आवश्यकता है:

  1. अद्वितीय या पर्याप्त अद्वितीय (कम संभावना टक्कर शायद बहुत स्वीकार्य है)
  2. रीबूट, बहाल, अनइंस्टॉल में दृढ़ता
  3. विभिन्न विक्रेताओं के ऐप्स में उपलब्ध (सीपीआई नेटवर्क के माध्यम से उपयोगकर्ताओं को प्राप्त करने के लिए उपयोगी) -

OpenUDID उपरोक्त को पूरा करता है और यहां तक ​​कि बाद में विचार के लिए एक अंतर्निहित ऑप्ट-आउट तंत्र भी है।

Http://OpenUDID.org देखें यह संबंधित गिटहब को इंगित करता है। उम्मीद है की यह मदद करेगा!

एक साइड नोट के रूप में, मैं किसी भी मैक पता विकल्प से दूर शर्मिंदा होगा। जबकि मैक पता एक आकर्षक और सार्वभौमिक समाधान की तरह प्रतीत होता है, यह सुनिश्चित करें कि यह कम लटकता फल जहर हो गया है। मैक पता बहुत संवेदनशील है, और इससे पहले कि आप "इस एप को सबमिट करें" कह सकें, ऐप्पल इस तक पहुंच को बहुत कम कर सकता है ... मैक नेटवर्क एड्रेस का उपयोग निजी लेंस (डब्लूएलएएन) या अन्य वर्चुअल प्राइवेट पर कुछ उपकरणों को प्रमाणित करने के लिए किया जाता है। नेटवर्क (वीपीएन)। .. यह पूर्व यूडीआईडी ​​से भी ज्यादा संवेदनशील है!


आप उपयोग कर सकते हैं

NSString *sID = [[[ASIdentifierManager sharedManager] advertisingIdentifier] UUIDString];

जो सभी अनुप्रयोगों में डिवाइस के लिए अद्वितीय है।


आप पहले से ही ऐप्पल UDID लिए अपने विकल्प का उपयोग कर सकते हैं। दयालु लड़के गीकिट्ज़ ने यूआईडीवीस पर श्रेणी लिखी जो डिवाइस मैक-एड्रेस और बंडल पहचानकर्ता के आधार पर किसी प्रकार का UIDevice उत्पन्न करेगी।

आप github पर कोड पा सकते हैं


इसकी जांच करें,

हम CFUUIDCreate द्वारा बनाए गए UUID को स्टोर करने के लिए NSUserDefaults क्लास के बजाय कीचेन का उपयोग कर सकते हैं।

इस तरह से हम UUID मनोरंजन के लिए पुनर्स्थापन के साथ बच सकते हैं, और उसी एप्लिकेशन के लिए हमेशा एक ही UUID प्राप्त कर सकते हैं, यहां तक ​​कि उपयोगकर्ता भी अनइंस्टॉल करें और फिर से इंस्टॉल करें।

उपयोगकर्ता द्वारा डिवाइस रीसेट होने पर UUID फिर से बनाया जाएगा।

मैंने इस विधि को SFHFKeychainUtils साथ करने की कोशिश की और यह एक आकर्षण की तरह काम करता है।


ऊपर वर्णित एसएसकेकेन और कोड का उपयोग करना। कॉपी / पेस्ट करने के लिए कोड यहां है (एसएसकेकेचैन मॉड्यूल जोड़ें):

+(NSString *) getUUID {

//Use the bundle name as the App identifier. No need to get the localized version.

NSString *Appname = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleName"];    

//Check if we have UUID already

NSString *retrieveuuid = [SSKeychain passwordForService:Appname account:@"user"];

if (retrieveuuid == NULL)
{

    //Create new key for this app/device

    CFUUIDRef newUniqueId = CFUUIDCreate(kCFAllocatorDefault);

    retrieveuuid = (__bridge_transfer NSString*)CFUUIDCreateString(kCFAllocatorDefault, newUniqueId);

    CFRelease(newUniqueId);

    //Save key to Keychain
    [SSKeychain setPassword:retrieveuuid forService:Appname account:@"user"];
}

return retrieveuuid;

}


निम्नलिखित कोड यूडीआईडी ​​प्राप्त करने में मदद करता है:

        udid = [[[UIDevice currentDevice] identifierForVendor] UUIDString];
        NSLog(@"UDID : %@", udid);

मदद कर सकते हैं: नीचे दिए गए कोड का उपयोग करें, यह आपके डिवाइस को मिटाने (प्रारूप) को छोड़कर हमेशा अनोखा रहेगा।

UIDevice *myDevice=[UIDevice currentDevice];
NSString *UUID = [[myDevice identifierForVendor] UUIDString];

मैं uniqueIdentifier से github (वास्तव में 2 सरल श्रेणियों) में बदलने का सुझाव देता हूं जो आपके अनुप्रयोगों में एक अद्वितीय आईडी उत्पन्न करने के लिए ऐप बंडल आइडेंटिफ़ायर के साथ डिवाइस के मैक पते का उपयोग करता है जिसे यूडीआईडी ​​प्रतिस्थापन के रूप में उपयोग किया जा सकता है।

ध्यान रखें कि यूडीआईडी ​​के विपरीत यह संख्या प्रत्येक ऐप के लिए अलग होगी।

आपको बस शामिल UIDevice और UIDevice श्रेणियों को आयात करने की आवश्यकता है और [[UIDevice currentDevice] uniqueDeviceIdentifier] कॉल करें:

#import "UIDevice+IdentifierAddition.h"
#import "NSString+MD5Addition.h"
NSString *iosFiveUDID = [[UIDevice currentDevice] uniqueDeviceIdentifier]

आप इसे यहां गिथब पर पा सकते हैं:

github

यहां श्रेणियां हैं (केवल। एम फाइलें - हेडर के लिए जिथब प्रोजेक्ट की जांच करें):

UIDevice + IdentifierAddition.m

#import "UIDevice+IdentifierAddition.h"
#import "NSString+MD5Addition.h"

#include <sys/socket.h> // Per msqr
#include <sys/sysctl.h>
#include <net/if.h>
#include <net/if_dl.h>

@interface UIDevice(Private)

- (NSString *) macaddress;

@end

@implementation UIDevice (IdentifierAddition)

////////////////////////////////////////////////////////////////////////////////
#pragma mark -
#pragma mark Private Methods

// Return the local MAC addy
// Courtesy of FreeBSD hackers email list
// Accidentally munged during previous update. Fixed thanks to erica sadun & mlamb.
- (NSString *) macaddress{
    
    int                 mib[6];
    size_t              len;
    char                *buf;
    unsigned char       *ptr;
    struct if_msghdr    *ifm;
    struct sockaddr_dl  *sdl;
    
    mib[0] = CTL_NET;
    mib[1] = AF_ROUTE;
    mib[2] = 0;
    mib[3] = AF_LINK;
    mib[4] = NET_RT_IFLIST;
    
    if ((mib[5] = if_nametoindex("en0")) == 0) {
        printf("Error: if_nametoindex error\n");
        return NULL;
    }
    
    if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) {
        printf("Error: sysctl, take 1\n");
        return NULL;
    }
    
    if ((buf = malloc(len)) == NULL) {
        printf("Could not allocate memory. error!\n");
        return NULL;
    }
    
    if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
        printf("Error: sysctl, take 2");
        return NULL;
    }
    
    ifm = (struct if_msghdr *)buf;
    sdl = (struct sockaddr_dl *)(ifm + 1);
    ptr = (unsigned char *)LLADDR(sdl);
    NSString *outstring = [NSString stringWithFormat:@"%02X:%02X:%02X:%02X:%02X:%02X", 
                           *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4), *(ptr+5)];
    free(buf);
    
    return outstring;
}

////////////////////////////////////////////////////////////////////////////////
#pragma mark -
#pragma mark Public Methods

- (NSString *) uniqueDeviceIdentifier{
    NSString *macaddress = [[UIDevice currentDevice] macaddress];
    NSString *bundleIdentifier = [[NSBundle mainBundle] bundleIdentifier];  
    NSString *stringToHash = [NSString stringWithFormat:@"%@%@",macaddress,bundleIdentifier];
    NSString *uniqueIdentifier = [stringToHash stringFromMD5];  
    return uniqueIdentifier;
}

- (NSString *) uniqueGlobalDeviceIdentifier{
    NSString *macaddress = [[UIDevice currentDevice] macaddress];
    NSString *uniqueIdentifier = [macaddress stringFromMD5];    
    return uniqueIdentifier;
}

@end

NSString + MD5Addition.m:

#import "NSString+MD5Addition.h"
#import <CommonCrypto/CommonDigest.h>

@implementation NSString(MD5Addition)

- (NSString *) stringFromMD5{
    
    if(self == nil || [self length] == 0)
        return nil;
    
    const char *value = [self UTF8String];
    
    unsigned char outputBuffer[CC_MD5_DIGEST_LENGTH];
    CC_MD5(value, strlen(value), outputBuffer);
    
    NSMutableString *outputString = [[NSMutableString alloc] initWithCapacity:CC_MD5_DIGEST_LENGTH * 2];
    for(NSInteger count = 0; count < CC_MD5_DIGEST_LENGTH; count++){
        [outputString appendFormat:@"%02x",outputBuffer[count]];
    }
    return [outputString autorelease];
}

@end

मैक पते को धोखा दिया जा सकता है जो विशिष्ट उपयोगकर्ताओं को सामग्री लिखने या ब्लैकलिस्ट जैसी सुरक्षा सुविधाओं को लागू करने के लिए इस तरह के दृष्टिकोण को बेकार बनाता है।

कुछ और शोध के बाद मुझे लगता है कि हमें अभी तक उचित विकल्प के बिना छोड़ दिया गया है। मुझे गंभीरता से उम्मीद है कि ऐप्पल अपने फैसले पर पुनर्विचार करेगा।

शायद इस विषय के बारे में ऐप्पल को ईमेल करना और / या इस पर एक बग / फीचर अनुरोध दर्ज करना एक अच्छा विचार होगा क्योंकि शायद वे डेवलपर्स के पूर्ण परिणामों के बारे में भी अवगत नहीं हैं।


यह आईओएस 6 की तरह दिखता है, ऐप्पल आपको एनएसयूयूआईडी कक्षा का उपयोग करने की सिफारिश कर रहा है।

UIDevice uniqueIdentifier गुण के लिए अब UIDevice दस्तावेज़ों में संदेश से:

आईओएस 5.0 में बहिष्कृत इस श्रेणी की पहचानकर्ता फॉरवेंडर संपत्ति या विज्ञापन के लिए एएसआईडेंटिफायर प्रबंधक वर्ग की विज्ञापन पहचानकर्ता संपत्ति का उपयोग करें, या यूयूआईडी बनाने के लिए एनएसयूयूआईडी कक्षा की यूयूआईडी विधि का उपयोग करें और इसे उपयोगकर्ता डिफ़ॉल्ट डेटाबेस पर लिखें।


यह वह कोड है जिसका उपयोग मैं आईओएस 5 और आईओएस 6, 7 दोनों के लिए आईडी प्राप्त करने के लिए कर रहा हूं:

- (NSString *) advertisingIdentifier
{
    if (!NSClassFromString(@"ASIdentifierManager")) {
        SEL selector = NSSelectorFromString(@"uniqueIdentifier");
        if ([[UIDevice currentDevice] respondsToSelector:selector]) {
            return [[UIDevice currentDevice] performSelector:selector];
        }
    }
    return [[[ASIdentifierManager sharedManager] advertisingIdentifier] UUIDString];
}

CFUUIDCreate द्वारा बनाई गई एक CFUUIDCreate अद्वितीय है यदि कोई उपयोगकर्ता ऐप को अनइंस्टॉल और पुनः इंस्टॉल करता है: आपको हर बार एक नया प्राप्त होगा।

लेकिन हो सकता है कि आप इसे अद्वितीय न हों , यानी यह तब भी रहना चाहिए जब उपयोगकर्ता ऐप को अनइंस्टॉल और पुनः इंस्टॉल कर लेता है। इसके लिए थोड़ा सा प्रयास करना आवश्यक है, क्योंकि सबसे विश्वसनीय प्रति डिवाइस-पहचानकर्ता मैक पता प्रतीत होता है। आप मैक से पूछ सकते हैं और यूयूआईडी के रूप में इसका इस्तेमाल कर सकते हैं।

संपादित करें: निश्चित रूप से एक ही इंटरफ़ेस के मैक से हमेशा पूछताछ की आवश्यकता है। मुझे लगता है कि सबसे अच्छा शर्त en0 साथ है। मैक हमेशा मौजूद होता है, भले ही इंटरफ़ेस में कोई आईपी / डाउन न हो।

2 संपादित करें: जैसा कि दूसरों द्वारा इंगित किया गया था, आईओएस 6 के बाद से पसंदीदा समाधान है - [यूआईडीवीस पहचानकर्ता फॉरवेंडर] । ज्यादातर मामलों में, आपको इसे पुराने -[UIDevice uniqueIdentifier] ड्रॉप-इन प्रतिस्थापन के रूप में उपयोग करने में सक्षम होना चाहिए (लेकिन एक -[UIDevice uniqueIdentifier] जो तब बनाया जाता है जब ऐप पहली बार शुरू होता है, ऐप्पल आपको लगता है कि आप क्या चाहते हैं)।

संपादित करें 3: तो इस प्रमुख बिंदु टिप्पणी शोर में खो नहीं जाता है: मैक का उपयोग यूयूआईडी के रूप में नहीं करें, मैक का उपयोग करके हैश बनाएं। वह हैश हमेशा हर बार एक ही परिणाम बनायेगा, यहां तक ​​कि पुनर्स्थापना और ऐप्स (यदि हैशिंग एक ही तरीके से किया जाता है) में भी। वैसे भी, आजकल (2013) यह आवश्यक नहीं है कि आपको आईओएस <6.0 पर "स्थिर" डिवाइस पहचानकर्ता की आवश्यकता हो।

4 संपादित करें: आईओएस 7 में, मैक को विशेष रूप से एक आईडी योजना के आधार के रूप में मैक को विफल करने के लिए मैक से पूछताछ करते समय ऐप्पल हमेशा एक निश्चित मूल्य देता है। तो अब आपको वास्तव में उपयोग करना चाहिए - [UIDevice IdentifierForVendor] या एक प्रति-स्थापित यूयूआईडी बनाएं।


UIDevice identifierForVendor आईओएस 6 में पेश किया गया आपके उद्देश्यों के लिए काम करेगा।

identifierForVendor एक अल्फान्यूमेरिक स्ट्रिंग है जो विशिष्ट रूप से ऐप के विक्रेता को डिवाइस की पहचान करता है। (सिफ़ पढ़िये)

@property(nonatomic, readonly, retain) NSUUID *identifierForVendor

इस संपत्ति का मूल्य उन ऐप्स के लिए समान है जो एक ही डिवाइस पर चल रहे एक ही विक्रेता से आते हैं। अलग-अलग विक्रेताओं से आने वाले एक ही डिवाइस पर ऐप्स के लिए एक अलग मूल्य लौटाया जाता है, और विभिन्न उपकरणों पर ऐप्स के लिए विक्रेता के संबंध में।

आईओएस 6.0 और बाद में उपलब्ध है और UIDevice.h में घोषित किया UIDevice.h

आईओएस 5 के लिए इस लिंक github संदर्भ लें


A working way to get UDID:

  1. Launch a web server inside the app with two pages: one should return specially crafted MobileConfiguration profile and another should collect UDID. More info here , here and here .
  2. You open the first page in Mobile Safari from inside the app and it redirects you to Settings.app asking to install configuration profile. After you install the profile, UDID is sent to the second web page and you can access it from inside the app. (Settings.app has all necessary entitlements and different sandbox rules).

An example using RoutingHTTPServer :

import UIKit
import RoutingHTTPServer

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    var bgTask = UIBackgroundTaskInvalid
    let server = HTTPServer()

    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
        application.openURL(NSURL(string: "http://localhost:55555")!)
        return true
    }

    func applicationDidEnterBackground(application: UIApplication) {
        bgTask = application.beginBackgroundTaskWithExpirationHandler() {
            dispatch_async(dispatch_get_main_queue()) {[unowned self] in
                application.endBackgroundTask(self.bgTask)
                self.bgTask = UIBackgroundTaskInvalid
            }
        }
    }
}

class HTTPServer: RoutingHTTPServer {
    override init() {
        super.init()
        setPort(55555)
        handleMethod("GET", withPath: "/") {
            $1.setHeader("Content-Type", value: "application/x-apple-aspen-config")
            $1.respondWithData(NSData(contentsOfFile: NSBundle.mainBundle().pathForResource("udid", ofType: "mobileconfig")!)!)
        }
        handleMethod("POST", withPath: "/") {
            let raw = NSString(data:$0.body(), encoding:NSISOLatin1StringEncoding) as! String
            let plistString = raw.substringWithRange(Range(start: raw.rangeOfString("<?xml")!.startIndex,end: raw.rangeOfString("</plist>")!.endIndex))
            let plist = NSPropertyListSerialization.propertyListWithData(plistString.dataUsingEncoding(NSISOLatin1StringEncoding)!, options: .allZeros, format: nil, error: nil) as! [String:String]

            let udid = plist["UDID"]! 
            println(udid) // Here is your UDID!

            $1.statusCode = 200
            $1.respondWithString("see https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/iPhoneOTAConfiguration/ConfigurationProfileExamples/ConfigurationProfileExamples.html")
        }
        start(nil)
    }
}

Here are the contents of udid.mobileconfig :

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
    <dict>
        <key>PayloadContent</key>
        <dict>
            <key>URL</key>
            <string>http://localhost:55555</string>
            <key>DeviceAttributes</key>
            <array>
                <string>IMEI</string>
                <string>UDID</string>
                <string>PRODUCT</string>
                <string>VERSION</string>
                <string>SERIAL</string>
            </array>
        </dict>
        <key>PayloadOrganization</key>
        <string>udid</string>
        <key>PayloadDisplayName</key>
        <string>Get Your UDID</string>
        <key>PayloadVersion</key>
        <integer>1</integer>
        <key>PayloadUUID</key>
        <string>9CF421B3-9853-9999-BC8A-982CBD3C907C</string>
        <key>PayloadIdentifier</key>
        <string>udid</string>
        <key>PayloadDescription</key>
        <string>Install this temporary profile to find and display your current device's UDID. It is automatically removed from device right after you get your UDID.</string>
        <key>PayloadType</key>
        <string>Profile Service</string>
    </dict>
</plist>

प्रोफाइल स्थापना विफल हो जाएगी (मैंने अपेक्षित प्रतिक्रिया को लागू करने के लिए परेशान नहीं किया था, documentation देखें ), लेकिन ऐप को एक सही यूडीआईडी ​​मिलेगा। और आपको मोबाइल कॉन्फिग पर भी हस्ताक्षर करना चाहिए ।


Apple has hidden the UDID from all public APIs, starting with iOS 7. Any UDID that begins with FFFF is a fake ID. The "Send UDID" apps that previously worked can no longer be used to gather UDID for test devices. (sigh!)

The UDID is shown when a device is connected to XCode (in the organizer), and when the device is connected to iTunes (although you have to click on 'Serial Number' to get the Identifier to display.

If you need to get the UDID for a device to add to a provisioning profile, and can't do it yourself in XCode, you will have to walk them through the steps to copy/paste it from iTunes.

Is there a way since (iOS 7's release) to get the UDID without using iTunes on a PC/Mac?



We can use identifierForVendor for ios7,

-(NSString*)uniqueIDForDevice
{
    NSString* uniqueIdentifier = nil;
    if( [UIDevice instancesRespondToSelector:@selector(identifierForVendor)] ) { // >=iOS 7
        uniqueIdentifier = [[[UIDevice currentDevice] identifierForVendor] UUIDString];
    } else { //<=iOS6, Use UDID of Device       
            CFUUIDRef uuid = CFUUIDCreate(NULL);
            //uniqueIdentifier = ( NSString*)CFUUIDCreateString(NULL, uuid);- for non- ARC
            uniqueIdentifier = ( NSString*)CFBridgingRelease(CFUUIDCreateString(NULL, uuid));// for ARC
            CFRelease(uuid);
         }
    }
return uniqueIdentifier;
}

--Important Note ---

UDID and identifierForVendor are different:---

1.) On uninstalling  and reinstalling the app identifierForVendor will change.

2.) The value of identifierForVendor remains the same for all the apps installed from the same vendor on the device.

3.) The value of identifierForVendor also changes for all the apps if any of the app (from same vendor) is reinstalled.




deprecated