I want unique identifier string which detect iPhone device (just like UDID)? - iphone

I want unique identifier string for iPhone devices instead of UDID and MAC.
1. Get UDID and MAC are deprecated by apple.
2. We can use UUID but it will get change after reinstalling app or delete app.
I want any unique value of device which is remain same after app reinstall OR delete OR upgrade iOS version.

What you can do is get a unique identifier using [[UIDevice currentDevice] identifierForVendor]or any other unique identifier generator. After that, you should store that value on keychain using KeychainItemWrapper and use. Once you store a value on the keychain it'll not remove even after you delete and reinstall the app.
Here is a guide for keychain access - Link

Try
[[UIDevice currentDevice] identifierForVendor];
It is from iOS 6.

As #danypata said, use the identifierForVendor as described in this answer.
Or alternatively you might be able to use the advertising NSUDID as described here.
However these can come back as nil or be changed over time. The user can opt out of advertiser tracking, so I don't recommend using it to track users for your own purposes.
I guess it depends on why you are tracking their device in the first place. My attitude is that I don't need to track users habits FOREVER. I only need to track general user trends and some DAU info. So I make up my own UDID - which will change on each install of the app. In my next version I will use the identifierForVendor and if it's NIL I will make up my own.
This is how I make my own:
// this makes a device id like: UUID = 89CD872F-C9AF-4518-9E6C-A01D35AF091C
// except that I'm going to attach some other attributes to it like the OS version, model type, etc.
// the UUID that is stored in user defaults will be like the one above.. but the device id that gets returned
// from this function and sent to [my online system] will have the extra info at the end of the string.
- (void) createUUID {
// for collecting some data.. let's add some info about the device to the uuid
NSString *thisDeviceID;
NSString *systemVersion = [[UIDevice currentDevice]systemVersion];
NSString *model = [[UIDevice currentDevice]model];
NSString *retinaTag;
if (retina) {
retinaTag = #"Retina";
}
else {
retinaTag = #"";
}
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
id uuid = [defaults objectForKey:#"uniqueID"];
if (uuid)
thisDeviceID = (NSString *)uuid;
else {
CFStringRef cfUuid = CFUUIDCreateString(NULL, CFUUIDCreate(NULL));
thisDeviceID = (__bridge NSString *)cfUuid;
CFRelease(cfUuid);
[defaults setObject:thisDeviceID forKey:#"uniqueID"];
}
//NSLog(#"UUID = %#", thisDeviceID);
MYthisDeviceID = [NSString stringWithFormat:#"%#-%#-%#-%#",thisDeviceID,systemVersion,retinaTag,model];
//NSLog(#"UUID with info = %#", MYthisDeviceID);
}
Then the single string that gets sent to my server has both a UDID in it and specs about the device and os. Until the user completely deletes and reloads the app the stats show usage on that device. To not get double udids if they update to a new os you can crop to just the udid portion.
I don't use the mac address at all because it was my understanding that apple didn't want us to. Although I can't find any documentation that says it at the moment.
UPDATE for iOS7:
I now use this code which works under io6 and io7:
NSString *globalDeviceID;
- (void) createUUID
{
NSString *thisDeviceID;
NSString *systemVersion = [[UIDevice currentDevice]systemVersion];
NSString *model = [[UIDevice currentDevice]model];
NSString *retinaTag;
if (retina) {
retinaTag = #"Retina";
}
else {
retinaTag = #"";
}
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
id uuid = [defaults objectForKey:#"deviceID"];
if (uuid)
thisDeviceID = (NSString *)uuid;
else {
if ([[UIDevice currentDevice] respondsToSelector:#selector(identifierForVendor)]) {
thisDeviceID = [[[UIDevice currentDevice] identifierForVendor] UUIDString];
}
else
{
CFStringRef cfUuid = CFUUIDCreateString(NULL, CFUUIDCreate(NULL));
thisDeviceID = (__bridge NSString *)cfUuid;
CFRelease(cfUuid);
}
[defaults setObject:thisDeviceID forKey:#"deviceID"];
}
NSLog(#"UUID = %#", thisDeviceID);
globalDeviceID = [NSString stringWithFormat:#"%#-%#-%#-%#",thisDeviceID,systemVersion,retinaTag,model];
NSLog(#"UUID with info = %#", globalDeviceID);
}

Or simply use the following and store to NSUserDefaults
[NSProcessInfo processInfo].globallyUniqueString
Global ID for the process. The ID includes the host name, process ID, and a time stamp, which ensures that the ID is unique for the network.

I'd suggest having a look at OpenUDID.
I believe underneath it uses the MAC address, so if you are correct in saying that accessing the MAC address is deprecated, then it probably won't be of much use, however, I think it would be unreasonable of Apple to remove access; the MAC address has other applications that just identifying the device for the purposes of UDID

Related

Retrieve iOS device identifier

Is there any way to get the iOS device identifier in iOS SDK?
I would like to access the identifier which is presented by the Xcode in Organizer - Devices section, something like: 21xb1fxef5x2052xec31x3xd3x48ex5e437xe593
It looks like you still can access UDID under iOS 6, but it is deprecated since iOS 5.0 and you shouldn't use it (anyway you'll get warning about that)
[UIDevice currentDevice].uniqueIdentifier
If you need unique identifier you should rather use :
[UIDevice currentDevice].identifierForVendor
or if it is connected with some kind of advertisement then:
// from AdSupport.framework
[ASIdentifierManager sharedManager].advertisingIdentifier
However those two new properties are available only under iOS >= 6.0, also advertisingIdentifier is not really unique (I'm getting many duplicates from that).
I suppose that you can do something like that if you wan't to support also iOS < 6:
UIDevice *device = [UIDevice currentDevice];
NSString *ident = nil;
if ([device respondsToSelector:SEL(identifierForVendor)]) {
ident = [device.identifierForVendor UUIDString];
} else {
ident = device.uniqueIdentifier;
}
but I'm not sure how apple will respond to that during review.
You can also use some 3rd party solution like openUDID or secureUDID. Open and secure UDIDs are deprecated - use identifier for vendor/advertising.
Update
One more possibility is to use MAC address as a base for unique hash, for example you can use code from ODIN1 - source is here
As of iOS7 MAC address is no longer available. (one can read it but it'll be always same dummy address 02:00:00:00:00:00).
From the Apple Documentation:
An alphanumeric string unique to each device based on various hardware
details. (read-only) (Deprecated in iOS 5.0. Use the
identifierForVendor property of this class or the
advertisingIdentifier property of the ASIdentifierManager class
instead, as appropriate, or use the UUID method of the NSUUID class to
create a UUID and write it to the user defaults database.)
NSString* identifier = nil;
if( [UIDevice instancesRespondToSelector:#selector(identifierForVendor)] ) {
// iOS 6+
identifier = [[[UIDevice currentDevice] identifierForVendor] UUIDString];
} else {
// before iOS 6, so just generate an identifier and store it
identifier = [[NSUserDefaults standardUserDefaults] objectForKey:#"identiferForVendor"];
if( !identifier ) {
CFUUIDRef uuid = CFUUIDCreate(NULL);
identifier = (__bridge_transfer NSString*)CFUUIDCreateString(NULL, uuid);
CFRelease(uuid);
[[NSUserDefaults standardUserDefaults] setObject:identifier forKey:#"identifierForVendor"];
}
}
you can find unique device identifier as
[[UIDevice currentDevice] uniqueIdentifier]
+ (NSString *)uuid
{
NSString *uuidString = nil;
CFUUIDRef uuid = CFUUIDCreate(NULL);
if (uuid) {
uuidString = (NSString *)CFUUIDCreateString(NULL, uuid);
CFRelease(uuid);
}
return [uuidString autorelease];
}
It works 100%, even on simulators too...
Yes there is.
[[UIDevice currentDevice] uniqueIdentifier]
EDIT:
However this is deprecated in iOS 5. This identifier should no longer be used in iOS 5. Read this SO post for more details.

using a unique identifier of iPhone or iOS device

I am making an order booking app. I need to send a unique key from the iPhone/iOS device to the server.
Can I use GUID of iPhone? i.e [UIDevice uniqueIdentifier] Is it legal? Legal means will apple accept that?
What is the best property to use to uniquely identify an iPhone or iOS device?
If not then what would be the other way to uniquely identifying device.
Actually i need booking reference no. generated by app. must be unique.
Apple has announced that in May 2013 will start to reject application that use the UDID to track the user behavior
this is an alternative to the UDID:
You can create a category of UIApplication , UIDevice or as you prefere like this (ARC example)
#interface UIApplication (utilities)
- (NSString*)getUUID;
#end
#implementation UIApplication (utilities)
- (NSString*)getUUID {
NSUserDefaults *standardUserDefault = [NSUserDefaults standardUserDefaults];
static NSString *uuid = nil;
// try to get the NSUserDefault identifier if exist
if (uuid == nil) {
uuid = [standardUserDefault objectForKey:#"UniversalUniqueIdentifier"];
}
// if there is not NSUserDefault identifier generate one and store it
if (uuid == nil) {
uuid = UUID ();
[standardUserDefault setObject:uuid forKey:#"UniversalUniqueIdentifier"];
[standardUserDefault synchronize];
}
return uuid;
}
#end
UUID () is this function
NSString* UUID () {
CFUUIDRef uuidRef = CFUUIDCreate(NULL);
CFStringRef uuidStringRef = CFUUIDCreateString(NULL, uuidRef);
CFRelease(uuidRef);
return (__bridge NSString *)uuidStringRef;
}
this generate an unique identifier stored into the NSUserDefault to be reused whenever the application need it - This identifier will unique related to the application installs not to the device, but can be used for example to take trace about the number devices subscribed the APN service etc...
After that you can use it in this way:
NSString *uuid = [[UIApplication sharedApplication] getUUID];
There is no GUID that I am aware of, do you mean [UIDevice uniqueIdentifier]? You may use that, but it’s getting deprecated in iOS 5, so that you’d better come up with some other means of identificating your devices.
Create a UUID: A string containing a UUID. The standard format for UUIDs represented in ASCII is a string punctuated by hyphens, for example 68753A44-4D6F-1226-9C60-0050E4C00067.
+ (NSString *)newUUID
{
CFUUIDRef theUUID = CFUUIDCreate(NULL);
CFStringRef string = CFUUIDCreateString(NULL, theUUID);
CFRelease(theUUID);
return (NSString *)string;
}
I won't refer to what is under NDA, but give a try to this solution, as the author advertises "It generates a unique identifier based on the mac address of the device in combination with the bundle identifier." However be warned that jailbroken devices can change their mac address AFAIK.
With iOS 6 came identifierForVendor, it can be used across multiple apps from the same vendor and although it identifies a device you can use it in combination with iCloud's key-value store for example to identify the user across devices.
Ole Begemann explains it all nicely on his blog: http://oleb.net/blog/2012/09/udid-apis-in-ios-6/

iOS unique user identifier [duplicate]

This question already has answers here:
UIDevice uniqueIdentifier deprecated - What to do now?
(32 answers)
Closed 8 years ago.
I'm writting an application for iphone, which communicates with my server using REST. The main problem is, I need to identify user somehow. Not so long ago, we were allowed to use UDID, but now its not allowed anymore. So what should I use instead? I need some kind of identifier on iphone, so user will delete application, install it again, and he will get same id.
I used CFUUIDCreate() to create a UUID:
+ (NSString *)GetUUID {
CFUUIDRef theUUID = CFUUIDCreate(NULL);
CFStringRef string = CFUUIDCreateString(NULL, theUUID);
CFRelease(theUUID);
return [(NSString *)string autorelease];
}
Then set the above UUID to my NSString:
NSString *UUID = [nameofclasswhereGetUUIDclassmethodresides UUID];
I then stored that UUID to the Keychain using SSKeyChain
To set the UUID with SSKeyChain:
[SSKeychain setPassword:UUID forService:#"com.yourapp.yourcompany" account:#"user"];
To Retrieve it:
NSString *retrieveuuid = [SSKeychain passwordForService:#"com.yourapp.yourcompany" account:#"user"];
When you set the UUID to the Keychain, it will persist even if the user completely uninstalls the App and then installs it again.
To make sure ALL devices have the same UUID in the Keychain.
Setup your app to use iCloud.
Save the UUID that is in the Keychain to NSUserDefaults as well.
Pass the UUID in NSUserDefaults to the Cloud with Key-Value Data Store.
On App first run, Check if the Cloud Data is available and set the UUID in the Keychain on the New Device.
You now have a Unique Identifier that is persistent and shared/synced with all devices.
Firstly, the UDID is only deprecated in iOS 5. That doesn't mean it's gone (yet).
Secondly, you should ask yourself if you really need such a thing. What if the user gets a new device and installs your app on that? Same user, but the UDID has changed. Meanwhile, the original user might have sold his old device so now a completely new user installs your app and you think it's a different person based on the UDID.
If you don't need the UDID, use CFUUIDCreate() to create a unique ID and save it to the user defaults on the first launch (use CFUUIDCreateString() to convert the UUID to a string first). It will survive backups and restores and even come along with the original user when they switch to a new device. It's in many ways a better option that the UDID.
If you really need a unique device identifier (it doesn't sound like you do), go for the MAC address as pointed out in Suhail's answer.
I was updating my application that was working based only on Unique Identifier which supported iOS 4.3 and above. So,
1) I was unable to use [UIDevice currentDevice].uniqueIdentifier; as it was no longer available
2) I could not use [UIDevice currentDevice].identifierForVendor.UUIDString because it was Available in iOS 6.0 and later only and was unable to use for lower iOS versions.
3) The mac address was not an option as it wasn't allowed in iOS-7
4) OpenUDID was deprecated some time ago and also had issues with iOS-6.
5) Advertisement identifiers were also not available for iOS-5 and below
Finally this was what i did
a) Added SFHFKeychainUtils to the project
b) Generated CFUUID key String
CFUUIDRef cfuuid = CFUUIDCreate(kCFAllocatorDefault);
udidString = (NSString*)CFBridgingRelease(CFUUIDCreateString(kCFAllocatorDefault, cfuuid));
c) Saved it to Key Chain Utils or else it will generate a new Unique Each Time
Final Code
+ (NSString *)GetDeviceID {
NSString *udidString;
udidString = [self objectForKey:#"deviceID"];
if(!udidString)
{
CFUUIDRef cfuuid = CFUUIDCreate(kCFAllocatorDefault);
udidString = (NSString*)CFBridgingRelease(CFUUIDCreateString(kCFAllocatorDefault, cfuuid));
CFRelease(cfuuid);
[self setObject:udidString forKey:#"deviceID"];
}
return udidString;
}
+(void) setObject:(NSString*) object forKey:(NSString*) key
{
NSString *objectString = object;
NSError *error = nil;
[SFHFKeychainUtils storeUsername:key
andPassword:objectString
forServiceName:#"LIB"
updateExisting:YES
error:&error];
if(error)
NSLog(#"%#", [error localizedDescription]);
}
+(NSString*) objectForKey:(NSString*) key
{
NSError *error = nil;
NSString *object = [SFHFKeychainUtils getPasswordForUsername:key
andServiceName:#"LIB"
error:&error];
if(error)
NSLog(#"%#", [error localizedDescription]);
return object;
}
For further Details
Some people want to know more about the different options available, and if you do, take a look at the answer from #NSQuamber.java. If you want to know how to use the NSUUID and sync with iCloud, keep reading. This post ended up being more long-winded than I originally wanted, but I hope that it makes it clear for anyone taking these steps!
Using NSUUID
I use the NSUUID class to create the UUID:
NSUUID *uuid = [NSUUID UUID];
Then to create the string, you only need to call the UUIDString method:
NSString *uuidString = [uuid UUIDString];
or do it in one line:
NSString *uuidString = [[NSUUID UUID] UUIDString];
IMHO, this is much easier than trying to use CFUUIDCreate and have a method you have to maintain.
EDIT: I now use UICKeyChainStore
To set the UUID with UICKeyChainStore:
UICKeyChainStore *keychain = [UICKeyChainStore keyChainStoreWithService:#"com.sample.MyApp"];
keychain[#"com.sample.MyApp.user"] = userID;
To retrieve it:
UICKeyChainStore *keychain = [UICKeyChainStore keyChainStoreWithService:#"com.sample.MyApp"];
NSString *userID = keychain[#"com.sample.MyApp.user"];
I then stored that UUID to the Keychain using SSKeyChain
To set the UUID with SSKeyChain:
[SSKeychain setPassword:userID forService:#"com.sample.MyApp.user" account:#"com.sample.MyApp"];
To retrieve it:
NSString *userID = [SSKeychain passwordForService:#"com.sample.MyApp.user" account:#"com.sample.MyApp"];
When you set the UUID to the Keychain, it will persist even if the user completely uninstalls the App and then installs it again.
Syncing with iCloud
So it's useful to make sure that all the user's devices use the same UUID. This is to ensure that data is synchronized across all the devices, rather than each device thinking it is a unique user.
There were several questions in the comments for my answer on how synchronization would work, so now that I've got it all working, I'll provide more details.
Configuring iCloud/NSUbiquitousKeyValueStore Use
Click on your project at the top of the Project Navigator in Xcode.
Select Capabilities.
Turn on iCloud.
It should now look something like this:
Using NSUbiquitousKeyValueStore
Using iCloud is fairly simple. To write:
// create the UUID
NSUUID *userUUID = [[NSUUID UUID];
// convert to string
NSString *userID = [userUUID UUIDString];
// create the key to store the ID
NSString *userKey = #"com.sample.MyApp.user";
// Save to iCloud
[[NSUbiquitousKeyValueStore defaultStore] setString:userID forKey:userKey];
To read:
// create the key to store the ID
NSString *userKey = #"com.sample.MyApp.user";
// read from iCloud
NSString *userID = [[NSUbiquitousKeyValueStore defaultStore] stringForKey:userKey];
Before you can write the NSUbiquitousKeyValueStore documentation states that you are required to read from iCloud first. To force a read, call the following method:
[[NSUbiquitousKeyValueStore defaultStore] synchronize];
To have your app receive notifications of changes in iCloud, add the following notification:
[[NSNotificationCenter defaultCenter] addObserver:self selector:#selector(iCloudStoreDidChange:)
name:NSUbiquitousKeyValueStoreDidChangeExternallyNotification
object:[NSUbiquitousKeyValueStore defaultStore]];
Creating the UUID with iCloud
Combining NSUUID, SSKeychain and NSUbiquityKeyValueStore, here's my method for generating a user ID:
- (NSUUID *)createUserID {
NSString *userKey = #"com.sample.MyApp.user";
NSString *KEYCHAIN_ACCOUNT_IDENTIFIER = #"com.sample.MyApp";
NSString *userID = [SSKeychain passwordForService:userKey account:KEYCHAIN_ACCOUNT_IDENTIFIER];
if (userID) {
return [[NSUUID UUID] initWithUUIDString:userID];
}
// check iCloud
userID = [[NSUbiquitousKeyValueStore defaultStore] stringForKey:userKey];
if (!userID) {
// none in iCloud, create one
NSUUID *newUUID = [NSUUID UUID];
userID = [newUUID UUIDString];
// save to iCloud
[[NSUbiquitousKeyValueStore defaultStore] setString:userID forKey:userKey];
}
// store the user ID locally
[SSKeychain setPassword:userID forService:userKey account:KEYCHAIN_ACCOUNT_IDENTIFIER];
return [[NSUUID UUID] initWithUUIDString:userID];
}
How to ensure that your User ID is in sync
Because writing to iCloud requires a download of any data in iCloud first, I put the synchronize call at the top of the (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions method. I also added the notification registration there as well. That allows me to detect any changes from iCloud and handle them appropriately.
Here's a sample:
NSString *const USER_KEY = #"com.sample.MyApp.user";
NSString *const KEYCHAIN_ACCOUNT_IDENTIFIER = #"com.sample.MyApp";
- (void)iCloudStoreDidChange:(NSNotification *)notification {
NSDictionary *userInfo = notification.userInfo;
NSNumber *changeReason = userInfo[NSUbiquitousKeyValueStoreChangeReasonKey];
NSArray *keysChanged = userInfo[NSUbiquitousKeyValueStoreChangedKeysKey];
if (changeReason) {
switch ([changeReason intValue]) {
default:
case NSUbiquitousKeyValueStoreServerChange:
case NSUbiquitousKeyValueStoreInitialSyncChange:
// check changed keys
for (NSString *keyChanged in keysChanged) {
NSString *iCloudID = [[NSUbiquitousKeyValueStore defaultStore] stringForKey:keyChanged];
if (![keyChanged isEqualToString:USER_KEY]) {
NSLog(#"Unknown key changed [%#:%#]", keyChanged, iCloudID);
continue;
}
// get the local key
NSString *localID = [SSKeychain passwordForService:keyChanged account:KEYCHAIN_ACCOUNT_IDENTIFIER];
if (!iCloudID) {
// no value from iCloud
continue;
}
// local ID not created yet
if (!localID) {
// save the iCloud value locally
[SSKeychain setPassword:iCloudID forService:keyChanged account:KEYCHAIN_ACCOUNT_IDENTIFIER];
continue; // continue because there is no user information on the server, so no migration
}
if ([iCloudID isEqualToString:localID]) {
// IDs match, so continue
continue;
}
[self handleMigration:keyChanged from:localID to:iCloudID];
}
break;
case NSUbiquitousKeyValueStoreAccountChange:
// need to delete all data and download new data from server
break;
}
}
}
When the application is launched or when it comes back to the foreground, I force a synchronization with iCloud and verify the integrity of the UUIDs.
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
[self configureSecKeyWrapper];
// synchronize data from iCloud first. If the User ID already exists, then we can initialize with it
[[NSUbiquitousKeyValueStore defaultStore] synchronize];
[self checkUseriCloudSync];
}
- (void)applicationWillEnterForeground:(UIApplication *)application {
// synchronize changes from iCloud
[[NSUbiquitousKeyValueStore defaultStore] synchronize];
[self checkUseriCloudSync];
}
- (BOOL)checkUseriCloudSync {
NSString *userKey = #"com.sample.MyApp.user";
NSString *KEYCHAIN_ACCOUNT_IDENTIFIER = #"com.sample.MyApp";
NSString *localID = [SSKeychain passwordForService:userKey account:KEYCHAIN_ACCOUNT_IDENTIFIER];
NSString *iCloudID = [[NSUbiquitousKeyValueStore defaultStore] stringForKey:userKey];
if (!iCloudID) {
// iCloud does not have the key saved, so we write the key to iCloud
[[NSUbiquitousKeyValueStore defaultStore] setString:localID forKey:userKey];
return YES;
}
if (!localID || [iCloudID isEqualToString:localID]) {
return YES;
}
// both IDs exist, so we keep the one from iCloud since the functionality requires synchronization
// before setting, so that means that it was the earliest one
[self handleMigration:userKey from:localID to:iCloudID];
return NO;
}
If which UUID came first matters
In my use case of my UserID, I assumed that the value in iCloud is the one to keep, since it would be the first UUID pushed to iCloud, regardless of which device generated the UUID first. Most of you would probably take the same path, since you won't really care which UUID it resolves to, as long as it resolves to a single one. For those of you who actually care about which came first, I suggest you store both the UUID and the timestamp generation ([[NSDate date] timeIntervalSince1970]) so that you can check to see which one is older:
// using dates
NSDate *uuid1Timestamp = [NSDate dateWithTimeIntervalSince1970:timestamp1];
NSDate *uuid2Timestamp = [NSDate dateWithTimeIntervalSince1970:timestamp2];
NSTimeInterval timeDifference = [uuid1 timeIntervalSinceDate:uuid2Timestamp];
// or just subtract
double timeDifference = timestamp1 - timestamp2;
There is a nice alternative on Github which generates a Unique Identifier based on a combination of Mac Address and the Bundle Identifier which works pretty well: UIDevice-with-UniqueIdentifier-for-iOS-5
In iOS7 Apple has introduced a read only property called "identifierForVendor" in the UIDevice class. If you decide to use it you should make note of the following,
This value could be nil if it is accessed before the user unlocks the device
The value changes when the user deletes all of that vendor’s apps from the device and subsequently reinstalls one or more of them.
The value can also change when installing test builds using Xcode or when installing an app on a device using ad-hoc distribution.
If you need an identifier for advertising purposes, use the advertisingIdentifier property of ASIdentifierManager. However make note that point one discussed above is still true for this as well.
Source: https://developer.apple.com/library/ios/documentation/uikit/reference/UIDevice_Class/Reference/UIDevice.html#//apple_ref/occ/instp/UIDevice/identifierForVendor
This is a hot topic indeed. I have an app that I have to migrate because it used the UDID to name an XML file to be stored on a server. Then the device with the app would connect to the server and download its specific udid.xml and parse it to work.
Ive been thinking that indeed if the user moves to a new device, the app will break. So I really should use something else. The thing is, I don't use a database for the data. The data is simply stored in an xml format, one xml file per device stored on the cloud.
Im thinking the best thing would be to have the user fill out the data on the web, have php create a token on the fly which will not be stored in a database but rather sent to the user. The user can then input the token on the target device and retrieve the xml in question.
That would be my solution to the problem. Not sure how to implement the whole 'creating unique tokens' thing though.

Unique Device Identifier

Does each Apple device (iPad/iPhone/iPod) have just one unique identifier for the span of it's use? Will the following code always return that identifier?
[[UIDevice currentDevice] uniqueIdentifier];
Will Apple allow to use this method in a deployed application?
the UDID (uniqueidentifier) is for life, however, not sure if apple are happy you to call that method to retrieve it.
Apple has announced that in May 2013 will start to reject application that use the UDID to track the user behavior
this is an alternative to the UDID:
You can create a category of UIApplication , UIDevice or as you prefere like this (ARC example)
#interface UIApplication (utilities)
- (NSString*)getUUID;
#end
#implementation UIApplication (utilities)
- (NSString*)getUUID {
NSUserDefaults *standardUserDefault = [NSUserDefaults standardUserDefaults];
static NSString *uuid = nil;
// try to get the NSUserDefault identifier if exist
if (uuid == nil) {
uuid = [standardUserDefault objectForKey:#"UniversalUniqueIdentifier"];
}
// if there is not NSUserDefault identifier generate one and store it
if (uuid == nil) {
uuid = UUID ();
[standardUserDefault setObject:uuid forKey:#"UniversalUniqueIdentifier"];
[standardUserDefault synchronize];
}
return uuid;
}
#end
UUID () is this function
NSString* UUID () {
CFUUIDRef uuidRef = CFUUIDCreate(NULL);
CFStringRef uuidStringRef = CFUUIDCreateString(NULL, uuidRef);
CFRelease(uuidRef);
return (__bridge NSString *)uuidStringRef;
}
this generate an unique identifier stored into the NSUserDefault to be reused whenever the application need it - This identifier will unique related to the application installs not to the device, but can be used for example to take trace about the number devices subscribed the APN service etc...
After that you can use it in this way:
NSString *uuid = [[UIApplication sharedApplication] getUUID];

How to change/reset iPhone simulator device ID?

How to change or reset an iPhone simulator device ID?
Solved.
#implementation UIDevice (ChangeUID)
- (NSString*)uniqueIdentifier
{
return #"test";
}
#end
If you just want to generate an UUID, say to tag an upload or communication to your server as being from a specific device you can use the CFUUID class to generate a UUID the first time your application is run,
NSString *uuid = nil;
CFUUID theUUID = CFUUIDCreate(kCFAllocatorDefault);
if (theUUID) {
uuid = NSMakeCollectable(CFUUIDCreateString(kCFAllocatorDefault, theUUID);
CFRelease(theUUID);
}
and then save this in your application preferences. This will then uniquely identify the users device, and it'll also work in the iPhone simulator.