为多个iOS版本开发应用程序

Question

I am testing an app on an iPhone 4 with iOS 5.1 and an iPad 4 with iOS 6.0. I looked around and surprisingly did not find similar questions:

1- My app has some methods that have been deprecated in iOS 6.0 so I believe I have to build some if/then conditions to test for system version using: [[UIDevice currentDevice] systemVersion], and then use the version appropriate methods. Is that the most efficient way?

2- My understanding is, with only one target, the "project" Deployment Target and the "Targets" deployment target serve the same purpose. And I need to have one of them or both as iOS 5.1 since that is the minimum iOS supported. What is confusing is that if the target is built based on iOS 5.1, how would it run on the iPad4 with iOS 6.0:

• Does the iPad OS checks for target versions before running or just tries to run the code and it happens that the iOS 5.1 target does not have any code that the 6.0 is incompatible with?

• Even if that is the case though, how could a 5.1 target support 6.0 methods that I built to conditionally replace deprecated methods?

Many thanks!

Answer 1

Deprecated methods

Deprecated methods can be used if you are targetting iOS versions that were released before those methods were deprecated. But assuming your deployment target is set correctly, you won't get any compiler errors unless those deprecated methods were always deprecated for the versions you are targetting. In other words, if you are seeing deprecation warnings in your code you need to fix them or check that your deployment target setting is correct. Do not ignore them!

Xcode setting levels

You mention the fact that you can define the deployment target setting at both the target and project level. Xcode build settings at the target level will override project settings. So define the deployment target at one of these levels only, then go to the other and hit delete so you don't have duplicate values. If you only have one target then it doesn't really matter if you define it at the target or project level.

Backwards and forwards compatibility

Finally, there are many factors that come into play for backwards and forwards compatibility. Sometimes there will be new iOS 6 methods like supportedInterfaceOrientations which will simply be ignored on older iOS versions. Other times you need to add explicit checks:

• If you are calling a method on an object and that method was only introducted with iOS 6, you will need to add a respondsToSelector: check like this:

   // only available on iOS 6 if ([locationManager respondsToSelector:@selector(pausesLocationUpdatesAutomatically)]) { locationManager.pausesLocationUpdatesAutomatically = YES; } 

• If you want to check if a particular class exists on the current iOS version, you can check the return value of the +class method like this:

   // Only available on iOS 6 if ([UICollectionView class]) { // ... } else { // class doesn't exist in this iOS version } 

• If you want to check if a particular function is available, do a simple if statement on it:

   // Only available in iOS 6 if (ABAddressBookCreateWithOptions) { ABAddressBookCreateWithOptions(...); } else { ABAddressBookCreate(...); } 

• Finally, if you want to check if a constant is available, check it's address:

   // Only available in iOS 4 if (&UIApplicationProtectedDataDidBecomeAvailable) { // subscribe to notification } 

Your Base SDK setting should always be set to "latest".

If you follow all these guidelines you will be able to solve most of your problems without having to add explicit version checks. Checking the iOS version or device ID is very brittle and is likely to cause your app to break in future versions. You really want to avoid it.

Answer 2

1. You can use [[UIDevice currentDevice] systemVersion] to detect the OS version, that would work. Rather than detecting the OS version, you could use respondsToSelector: to see what methods are present, NSClassFromString() != nil to see if classes are present, and fallback if that method is not available.

2. iOS is backward compatible, so iOS 6 will run iOS 5 apps just fine. However, if you want to use iOS 6 specific feature but still support iOS 5.1, you have to :

   • Compile using the 6.0 SDK so that the compilers knows new APIs
   • Set your target version to the lowest supported, aka. 5.1. Any system higher than that number will run the code. Any lower will not try.
   • Use one of the method described in 1. to make sure that each device execute codes the OS support.

I hope that's clear, don't hesitate if you have more questions

Answer 3

What you must do is detect functionality, not iOS version, please check out this thread:

Conditional support of iOS 6 features in an iOS 5 app

Answer 4

iOS is backwards compatible. If you compile your app for iOS 5.1 it will be perfectly run on iOS 6 as well. No need to re-implement deprecated classes.

But if you change your deployment version from 5.0 to 6.0, Xcode will show you warnings if you use deprecated methods

If you want to use methods, which are available only in iOS 6, you can use this check:

if ([self respondsToSelector:@selector(doSomething:)]) {
        [self doSomething];
    }

Answer 5

You shouldn't check against the system version but rather check against the functionality you are trying to use. On that note remember that deprecated does not mean removed so whatever you are trying to do may very well be there for iOS6. To check against a specific functionality you would do something like:

if([TheClassInQuestion class] != nil)
{
    //use it
}