XCode iOS Base SDK setting question - ios

I have an app that I build using XCode 3.2.6, Base SDK 4.3, Deployment target iOS 4.0.
I decided that I should test it with the latest iOS5 beta, to make sure that my app doesn't break, and submit any bug reports to Apple if I find something.
What I found is that if I build the app using XCode 4.2, Base SDK 5.0, Deployment target iOS 4.0, the size of the text in my UILabels and UITextViews renders smaller (by maybe 3 points or so). But that's not really what's important.
I have two test devices, one has iOS 4.3 installed on it and the other has iOS5b3 installed on it. What confuses me is that the shrunken text behavior occurs on BOTH devices.
If I build the app (like I normally do) using XCode 3.2.6, Base SDK 4.3, Deployment target iOS 4.0 the shrunken text behavior goes away on BOTH devices.
My understanding was that the UIKit libraries were linked at runtime on the actual device, and as long as I use APIs that are supported by both Base SDK versions it shouldn't matter which Base SDK I choose.
It wouldn't be so surprising to me if I observed different behaviors on devices running different versions of the OS. But as far as my understanding goes, choosing a different Base SDK shouldn't change any behaviors on a given OS as long as (of course) the Deployment Target setting is low enough to include the OS version and I'm using APIs that are supported.
So what gives? I'm obviously missing something.
I really appreciate you taking the time to help me understand this.
Thanks!

Related

What does deployment target mean?

this is a very simple question I'm assuming. Can someone tell me what deployment target means. If I choose IOS 10, does that mean only users with iOS 10 can download the app. Is it bad to choose a lower deployment target? ALSO, continuing on deployment target, is it not recommended to run on a lower deployment target.
Lets say you have set minimum deployment target to iOS 9.
This means your application is compatible for iOS 9 and above devices.
The application won't run on below 9.0 devices but can run on any iOS version greater than iOS 9.0.
The deployment target determines your app's ability to run on older iOS versions.
App with deployment target set to 10 will work on iOS version 10+ (10, 11, 12, 13 ...) but won't work on 9.x.
When a new version of iOS is released, some people do not bother to update their devices to the latest iOS version and thus they can't download your app from the App Store.
Example
If you choose higher deployment target (e.g 12.1), your app won't be able to download for the people who even have latest devices but have older iOS version (iPhone X with 11.0). In Contrast If you choose lowest possible deployment target (e.g 6.0), you try to make your app maximum backward compatible (so even if someone hasn't updated their iOS in ages will be able to download your app).
CAUTION
Many (almost all) newer frameworks and features won't be able to run properly (Behave as expected) on lower iOS versions which increases the chances of app crashes.
What Affects Deployment Target
Following are few factors that demands higher deployment target.
1) Using latest iOS SDK (alone)
2) Using latest iOS SDK specific features (Constraints, newer XIB files etc).
3) Using fast adapting external libraries / Frameworks (e.g Facebook SDK, Firebase etc).
4) Higher Swift Version (5.0) requires higher deployment target vs writing your app in legacy Objective C) !Needs citation.
SOLUTION
We have been using Deploymate for maximum backward support. It mainly assists us about warning the following:
1) Newer APIs that won't work on lower iOS versions
2) Using deprecated methods that won't work on newer iOS versions.
This is when you start fixing your code to make it available for lower iOS versions for maximum compatibility.
Note: Xcode also informs about several pitfalls. Deploymate is neither associates with us or pay us in any form. You can look for other alternates.
iOS Deployment Target(IPHONEOS_DEPLOYMENT_TARGET)
Deployment Target is a minimum version of iOS which is supported by your target.
It means that:
as a developer you support this version and you are able to support all next compatibility
as a user you should have at least this version of iOS
To change it in Xcode 11.5
Build Settings -> iOS Deployment Target
//.pbxproj
IPHONEOS_DEPLOYMENT_TARGET
If you are new to Xcode, I suggest accepting the default, and thinking of it as a constraint on your project.
As newer of Xcode versions come along, support for older target values will be removed. Companies that have extensive customer bases have to deal with this problem in their own way.
In most projects I have worked on, the iOS version matters because it dictates which devices can run your application.
For example, iOS 10 essentially left behind all iPod-style connectors.

Lowering Deployment Target for my app

I created my Universal device game app in iOS 7.1 and there for have my deployment target set to 7.1.
I currently use both iPhone/iPad simulators with 7.1 and 8.1 iOS versions.
Would there be an impact, in game performance, if I set my deployment target to iOS 6.1 or 7.0?
Would it be a negative impact if I set it lower than 7.1?
Chances are you could be using code not compatible with older versions. The only way to know is to have the app compile to that iOS version. But, in my honest opinion, you should stick with 7.0 onwards since they are the officially supported versions. You could change your deployment target to 7.0 and try to compile to see the effects.
If you set the deployment target to 7.0, Xcode will tell you which parts of your code are non compatible.
Regarding performance, that depends on what type of code you did and which device you are going to deploy. For that response you need to provide a little bit of more info about your app and code. But like I said before, change the deployment target in 7.0 to at least be sure your code will run on that version.
There would be some performance hits in your code if you are using any functionality that is new to iOS 7.1 because you would need to check at runtime whether or not that functionality is present, and symbols for such functionality would be weakly bound. However, that is extremely negligible and almost not worth mentioning beyond being overly specific.
On the whole, you should not see any performance impact simply by changing the deployment target version.

How does an app with lower base sdk work?

In XCode I can specify Base SDK. I am wondering how does that work behind the scenes? If I am running an app, for example, on a device that has iOS 7 and my base SDK is iOS 6, then how come the app has the old 'look and feel'? Does XCode compile the older SDK and include it within my app or does new version of iOS comes with older libraries/SDKs?
In other words, does the run time know this app is compiled with lower base SDK and somewhere in UIKit's code it does:
if (lower SDK) {
//show old look/feel
} else {
//show new look/feel
}
or does the app itself include the old library and load it ?
Thanks
iOS applications are forward compatible with new versions of iOS. The reason is :
Almost all changes to the iOS versions are additive and hence an
application build using lower version still runs on the higher iOS
version.
Though, we need to take care of this point:
As frameworks evolve through various releases, APIs are introduced or
deprecated and behaviors of existing APIs may occasionally change.
Apple makes every effort to minimize changes that may cause
incompatibilities, in some cases providing alternate behaviors based
on the framework version. In rare cases, your code needs to determine
the framework version and adjust accordingly
To understand more, read this
Apple never changes / deletes / renames classes or methods. They only add new ones.
If they don't want you to use it anymore, they mark it as deprecated.
This is a very important point.
At compile-time, the compiler checks if all classes and method signatures are available in the SDK your building your app with.
If that's the case, you can build and deploy your app. Because those classes and methods will never be deleted from newer versions of the framework, your app will run just fine.
On the other hand, you can build apps and deploy them to systems, which do not actually support the current SDK. For example, you can use Autolayout (NSLayoutConstraint class is available since 10.7) and deploy it for Mac OS X 10.6. The compiler will not say a word.
The app will crash though on systems prior to 10.7.
You should set your target to ios 5.0 (via your project target settings) for making sure that none of the ios6 methods are used (or else a compilation error will prevent you from building it).
In order to support new features and check if ios6 is available on the device you have two ways :
During compilation (so you can still build your app with lower targets and newer together) use the following macro
#if __IPHONE_OS_VERSION_MIN_REQUIRED > __IPHONE_6_0
// Your ios6 code goes here
#endif
2: During runtime : [[[UIDevice currentDevice] systemVersion] floatValue] > 6.0
Your project is built against the Current SDK. If you have an older Deployment Target, then your code base is compiled against that. So if you are building against 7.0, but have a 6.0 deployment target, iOS 7 specific deprecations will not be triggered. Everything will be compiled against the oldest specified deployment target.
This will however put the pressure on you as a developer to make sure you are not using iOS 7 specific code. The compiler will still assume you mean to allow newer users to run your application as well and that all the newest methods are available to you and your latest version users. You can either test your code base against the older SDK with older devices or Simulators to make sure it runs well, or use an application like Deploymate that will test for methods you are using that could potentially cause problems.
If you plan to use any of the latest methods, you will need to wrap them up in the compiler if statement (like Peter Fidemraizer answered) or in normal if statements checking the version in the Foundation framework.
if (floor(NSFoundationVersionNumber) <= NSFoundationVersionNumber_iOS_6_1) {
// Load resources for iOS 6.1 or earlier
} else {
// Load resources for iOS 7 or later
}
Base SDK means, the SDK that your app is going to be built on. SDK's have some frameworks etc. that are differantiated as the version of the SDK changes. For example;
Let's say your current Base SDK in your XCode is iOS 6:
You can have the frameworks and feautres that iOS 6 SDK provided you to.
Your app will be usable in any iOS SDK that you specify as "Minimum iOS SDK". Minimum iOS device gives you some restrictions on components to use. be aware of that.
Your app will be usable in iOS 7 too, just like it works in iOS 5 or iOS 6. Because iOS versions have backward compatibility. That means, iOS 7 will run the apps that are running in iOS 6 too.
Let's say your current Base SDK is iOS 6 and you want to make it iOS 7
Your app will be built with a brand new SDK, so, if the new SDK has
some big changes in it, you will see the differences immediately when
you run the app. For example, in iOS 7 SDK, you can use status bar
(20 px) as a view component too. That may ruin your view hierarchy.
You need to test your app again to check that your code is compatible with iOS 7
If you want to use new iOS 7 frameworks or features, you are in the correct way, you can use them now :)
In short, Base iOS SDK is on what iOS version your app is compiled & built on. running it on a iOS X? device is a different concept.
Hope this helps
Base SDK is the SDK that you want to use to build the app. Use "Deployment target" to specify the minimum OS you want your app to run on.
If you want to know the iOS version, check out this question.
While updating the Apple frameworks itself,Apple takes care of support for multiple iOS versions;However you need to follow some basics checks, which are explained here

targeting iOS5 - will it work on iOS6 also?

Hello I am beginner with these things and would appreciate nice explanations
that would dismiss my doubts.
If I target my app for iOS 5 -- does it mean users who have iOS 6 and iOS 7 can
also use it? Anything I should watch out for?
There are two primary settings used for your targeting your builds:
Base SDK & Deployment Target.
The Base SDK = What are the latest features I want available in this app?
The Deployment Target = What is the earliest OS I want to be able to run this app?
So, if you have both of these set to iOS 6, the user must have iOS 6 to install or run the app.
If you have a Deployment Target of iOS 5.0 and a Base SDK of 6.0 that means it'll install and run in iOS 5.0, but you need to be careful to branch your code and not use any iOS 6.0 features if the user is running on an iOS 5.0 device.
Yes, the target is the minimum version version that the app can run on. That doesn't mean that the app will work properly on newer versions and you really need to test to be sure. If you're creating a new app think carefully about which older versions to support.
If you target your Application for a lower iOS version, anyone with the version number you target AND HIGHER and access the application. Anyone LOWER than the one you target will not be able to download and use the application.
Everything will work fine, however there are certain features that are only available in iOS6 and iOS7 such as UICollectionView is only available in iOS6 and above. Fortunately you can test the different OS's in the simulator, it will make you life easier and you will be able to see if your application breaks running a different OS.

Updating apps to iOS6

Haven't been able to find an accurate response to this question on Apple Developer forums.
As with other Apple Developers, I will upgrading our apps to support iOS6 devices.
I've downloaded XCode 4.5 which supports iOS6 SDK.
I understand I cannot submit versions of my app to the app store using this XCode build, however:
if I re-compile and build an app using the deployment target of 6.0 and fix all the known issues e.g. deprecated methods etc. when Apple releases GM for iOS6, will any build compile and work with iOS5 devices as well?
Should I just be submitting apps with a deployment target of 5.0 or will those fail to run in iOS6?
Should my deployment target only be iOS6 if I am using new iOS6 features?
(confused).
Since this is a pretty generic question about supporting multiple versions of iOS and does not cover any iOS6 specific things (covered by NDA), here goes my answer:
if I re-compile and build an app using the deployment target of 6.0 and fix all the known issues e.g. deprecated methods etc. when Apple releases GM for iOS6, will any build compile and work with iOS5 devices as well?
In principle, yes, it will, provided you have not used any iOS6-only feature or you did it properly (see the answer to your third question). However, testing against an actual device running iOS5/4 (or the simulator) is almost mandatory if you want to be sure that things work correctly.
There is also a chance that something that is currently working under an older iOS version will just break on iOS6 (this can happen in case some bugs were added, but also in case some bugs were fixed and it happens that your code had a bug of its own that countered the effect of the former). So, testing is the king. (Thanks to rsswtmr's comment about this).
Should I just be submitting apps with a deployment target of 5.0 or will those fail to run in iOS6?
You can specify a deployment target of 5.0 if your app does no use any iOS6-only feature (or you do it properly, read later); in other words, this setting will not break compatibility with iOS6;
Should my deployment target only be iOS6 if I am using new iOS6 features?
It can, but it is not the only way.
If you specify your deployment target as iOS6, then you can freely use any iOS6-only feature in your app without concern. The app store mechanics will prevent your app from being installed on any older device and you will be safe.
On the other hand, if you specify your deployment target as iOS5 or older, then you can still use any iOS6-only feature in your app, but you should properly support older versions of iOS by "guarding" any usage of iOS6-only features and providing a fallback for iOS5.
This means the following: say that you are going to use featureA only available on iOS6; what you can do is:
check to see if the feature is available at runtime (e.g. class respondsToSelector, etc);
guard your code within an #ifdef so that it will be compiled only on when possible;
if the check at 1. will fail, define a way out for older iOS versions.
Have a look at this post on supporting multiple iOS versions.
Set "Base SDK" to Latest iOS and "iOS Deployment Target" to the older version you plan to support (iOS 5.0 for instance).
Add conditional code to use feature available in latest iOS without crashing in the old one supported.
The section "Conditional Coding" in this Apple guide can be helpful. Also check other questions on the subject in SO.

Resources