This question already has answers here:
iOS app compatibility issue
(2 answers)
Closed 7 years ago.
After releasing an update to my app yesterday, I got a text from a friend saying iTunes wouldn't let him update because it said "The app is not compatible with this iPhone". He was on an iPhone 5c running latest iOS 9.1. I went and checked and it said this:
The app is not available to iPhones below iPhone 5S. I did not purposely change anything in the update for this to happen. Why is my app not available for all iPhones?
Looking at the list of devices, they all appear to have 64-bit CPUs – is it possible you accidentally disabled support for ARMv7? Did you modify Bitcode settings in the update, or change Xcode versions?
The app is compiled for 64-bit only. You need to make sure you compile for both 32-bit and 64-bit architectures (armv7, armv7s, arm64). The best option is to use the default architecture settings.
Related
This question already has answers here:
How to convert xcode 32 bit app into 64 bit xcode app
(2 answers)
Closed 5 years ago.
I want to update/convert my iOS App for 64-bit so it will still run on iOS 11. I am still on Yosemite and don't currently have the time to upgrade to El Capitan so I'm stuck with XCode 7.2.1. Is it even possible to convert my App to a 64-bit binary with that version of XCode?
If yes, does anyone know a good description of how to do this? I haven't coded in XCode for a while and don't know where to begin with this task.
From here:
In Xcode, set the following values:
Build settings > Architectures
Set to arm64 only. (click Other -> + and than enter arm64)
Build settings > Valid architectures
Set to arm64 only.
Really though I'd recommend you just update because you are missing out on a ton of features.
This question already has answers here:
How to support both armv6 and armv7s for release build in xcode 4.5
(7 answers)
Closed 9 years ago.
As you probably know, Apple announces two news:
Make Your Apps Look Great on the Retina Display and iPhone 5
And another one related to UDID
I've a question about the first one. So we have an application which is built with iOS3.2 as a minimum deployment target and with armv6 support. The reason for this because many user still has an iPhone 3G, so we need support for armv6.
But because of this announcement, we have to drop armv6 support and use iOS6 SDK (with iOS4.3 min deployment target) to properly build the app with the 4 cols launch image.
I was reading and searching a lot about this topic and I found these:
Currently we have armv6 support. You can't drop it, you can just set the minimum os version to 4.3. But with XCode 4.5 you can't built for armv6 architecture, so this slice will missing from the app. That's why Apple won't accept your app at next upload, because you limit the supported list of devices. But if you use older XCode, you can't add the big launch image for supporting iPhone5 full screen mode.
The main point is the missing armv6 slice.
Someone told that Apple can detect this, and if your app contains such slice, it will be rejected after May 1.
But you can't update your existing app with armv6 support, because you can't built for that.
I also read that you can combine apps built with XCode 4.x and 4.5 to support all architectures, but this is too risky for us if Apple will accept this after May 1.
So is it true that all developer whose app is still supporting armv6 must have to upload a new app to App Store with different app id? Or is there any other solution that updates after May 1 will arrive in the right manner to all current user?
Thanks
madik
There's nothing wrong with removing support for a previously-supported architecture once it's out of date, as is the case here. You will not be able to release any more updates for these users though, and that's just all there is to it.
What you can't do is remove support for a device group. That is, you can't have a universal app and later remove support for iPad, for example.
There is no point in supporting armv6 devices or OS < 5.0 any more. This market is extremely limited unless your product is targeted at countries where buying new devices is uncommon. In most major markets the effort to support ancient iOS devices is not worth it. We only support 5.x and armv7 devices for new app versions.
This question already has answers here:
How can I deploy an iPhone application from Xcode to a real iPhone device?
(12 answers)
Closed 10 years ago.
This has been answered many times before, but none of those answers are compatible with iOS 6. The only answers that mention iOS 6 use a tool called Jailcoder, which isn't working for me.
What I have tried:
Create a fake code-sign certificate
Modify SDKSettings.plist
Used Jailcoder to patch Xcode as well as my project
I am using Xcode 4.5.1 and iOS 6.0.1. Note that Xcode 4.5.1 doesn't have an SDK specific for 6.0.1, but I don't think that makes a difference.
Jailbreak your device (seems you have already done this step).
Build the app in Xcode. Take the binary which is compiled for iOS, not the one for the simulator.
Use the ldid utility to fake codesign the binary:
ldid -S ~/Projects/Foo/Foo.app/Foo
Copy the .app folder (the application bundle) to your device (for example, using SSH). Reload the list of apps (either restart SpringBoard or use the uicache utility on the device).
Profit.
there is a better and easier way to do this.
Download the Jailcoder.app App and press "guided patch" or "quick patch". Then the app will do all work for you and you can directly choose your iphone from the xcode organizer.
On the iPhone you need the cydia tweak AppSync for iOS 5.0+
The latest release notes indicates 4.2.1 and lower will not be supported, we now have to use 2 version of Xcode to develop when supporting older devices?? This is going to be difficult to support older devices if we want to develop iOS6 AND support 4.2 and lower.
I don't think Xcode 4.4 will support iOS6. So this is the issue. How would developers easily support these platform without so much hassle?
You can do this, but it requires some minor Xcode hacking, and some sacrifices. Depending on what you mean by "support iOS 6", this may or may not be sufficient for you. If you just want your app to run on iOS 6, then this should work. If you also need your app to incorporate new iOS 6 features, then it won't.
(Note for others who don't have a problem using multiple versions of Xcode: this similar question has answers that do allow you to also use new iOS 6 APIs and directly target armv7s)
See basic instructions on chpwn's blog here (but read the rest of this below, too!)
Basically, you can use Xcode 4.5 to build for iOS 4 and above, but then you can't take advantage of the new iOS 6 only features. So, you're really building for iOS 4 and 5, and assuming that the app will run fine on iOS 6 (which should be true, but you'll need to test this yourself).
You'll need to copy the iOS 5 SDK folder
/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS5.*.sdk
from an old Xcode installation (which you'll need to keep around briefly, or reinstall to a non-standard location). You'll then set the Deploy Target in your Build Settings to iOS 4.0 (or whatever minimum OS you want). You may need to open the project.pbxproj file in a text editor to set this manually:
IPHONEOS_DEPLOYMENT_TARGET = 4.0;
You'll also need to set the Architectures to armv6 and armv7. You cannot directly also target armv7s. But, that doesn't mean your app won't run on iPhone 5. armv7 executables should run on iPhone 5, simply without any optimizations added in armv7s. It's just that compatibility doesn't work in the other direction (e.g. armv7 executables don't run on an armv6 iPhone 3G).
There's also a step that might be necessary, that's not mentioned in chpwn's blog. You may get these warnings (which really are errors, because Xcode won't generate your executable properly):
warning: no rule to process file '$(PROJECT_DIR)/main.m' of type sourcecode.c.objc for architecture armv6
In order to fix this, you'll need to setup a custom Build Rule for your target that tells Xcode to use LLVM GCC 4.2 to generate armv6 code. Define the rule for files matching the pattern *.[mc]:
This will be a different compiler than the Xcode default, and you may need to adjust some of the syntax in your Objective-C code. Even though many people wanting to do this probably wrote their apps before ARC, it is important to note that LLVM gcc 4.2 does not support ARC.
Finally, you probably will still see warnings from Xcode about iOS deploy targets less than 4.3, and armv6 not being supported. Those, I found, were not problems, and could be ignored:
Running lipo -info on my app executable after this shows the desired result:
lipo -info MyAppName
Architectures in the fat file: MyAppName are: armv6 armv7
Xcode 4.5 makes iOS 4.3 the earliest supported operating system, which effectively orphans the original iPhone and the 3G.
If you want to support iOS versions earlier than 4.3, you will need to keep around a 4.4 version of Xcode.
To be a bit clearer : you cannot easily (meaning Xcode does not out-of-the-box) support pre-4.3 devices and use iOS 6 features in the same app. That's because iOS 6 features require XCode 4.5 which also sets iOS 4.3 as the minimum supported OS.
So, you have 3 choices :
Continue using XCode 4.4. You'll be able to target pre-4.3 iOS. You won't be able to take advantage of iOS 6 features, but your app should run fine on it assuming you perform adequate testing on actual iOS 6 devices.
Migrate to XCode 4.5. You won't be able to target pre-4.3 iOS, but you'll be able to take advantage of iOS 6 features.
Make two versions your app. Build one version with XCode 4.4 (as in option 1), and the other with 4.5 (as in option 2). From the point of view of distribution, these will be 2 separate apps, they'll each have their own bundle ID, etc. You will have two entries in the app store.
If you are comfortable going beyond what is supported directly by Xcode, see Nate's answer.
The original iPhone and iPhone 3G are the only devices that don't support iOS 5. The iPhone 3G is now 4 years old. You may want to consider dropping support for iOS 4. If you don't want to do that, I think you'll have to develop in two different versions of Xcode.
I assume that the dropped support for iOS 4.2.1 is not the core problem. In fact, I tried to work around this and do the following:
Build the app with iOS 6 SDK, setting deployment target to iOS 4.2.1 (which works).
Pack the app for ad hoc installation and install the app on an iOS 4.2.1 device (iPod touch 2G).
Test the app.
However, installation fails. The reason here is - afaik - not the iOS version. The reason is the architecture. XCode 4.5 no longer allows you to build for armv6. It only builds for armv7. On the other hand: all device which have armv7 or better can run iOS 5. The only devices which do not support armv7 are iPhone, iPhone 3G, iPod touch 1G and iPod touch 2G.
So for me the question is: can you build for armv6 with XCode 4.5 and iOS 6 as base SDK?
Edit: Which you cannot do, because the iOS 6 base SDK is not available for armv6. Right?
Try to set the project settings manually using IPHONEOS_DEPLOYMENT_TARGET=4.0. However, I don't know if there is any side effect.
I think that targeting to 4.3 is the best choice, according to ios version statistics
This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
iPhone app does not run on old device (3G, 3GS, …)
I've got a similar problem to this (iPhone app does not run on old device (3G, 3GS, ...)) but the workaround on that page doesn't do anything for me. I have been developing iOS apps on XCode3 and testing on an older second generation iPod Touch running iOS 4.2.1. Been trying the last couple of days to use XCode4 instead.
I'm able to build and run apps under XCode4 using the simulator, both ones that I initially developed under XCode3, as well as brand new XCode4 created "Hello World" type ones. However, when I try to put one on the actual hardware, it fails with little in the way of error messages. The debug window in XCode4 doesn't show anything amiss. The activity/status indicator in the top middle of XCode goes from "Building [AppName]" straight to "Finished Running [AppName]" but the app never is transferred or run on the device.
If I look at the iPod's console via Organizer I see a bunch of errors like:
Thu Jun 16 15:17:56 unknown lockdownd[16] <Error>: 2ff68000 handle_connection: Could not receive USB message #6 from Xcode. Killing connection
Thu Jun 16 15:17:56 unknown com.apple.mobile.lockdown[16] <Notice>: Could not receive size of message
and I'm guessing it's related to that. I've tried unplugging all other USB devices from my Mac but makes no difference. Tried rebooting both the device and the Mac, but again no difference.
I have adjusted the iOS deployment target to 4.2, so I don't think there's any problem there. The device shows up in Organizer with the green dot and a valid unexpired provisioning profile. Under code signing properties it looks like:
Code Signing Entity Don't Code Sign
Debug Don't Code Sign
Any iOS SDK iPhone Developer (currently matches...[profile I have installed])
Release Don't Code Sign
Any iOS SDK iPhone Developer (currently matches...[profile I have installed])
The device itself is showing up in the Schemes dropdown as:
[DeviceName] (4.2.1 overriding Base SDK to 5.0)
Anyone else running into a similar problem or have any suggestions?
Just to promote Thomas' comment to an answer, this can be caused by targeting a CPU architecture that your device doesn't support. The iPhone and iPhone 3G (along with iPod touches of the same generation) don't support armv7. Set the "Archiectures" build setting to include "armv6" to ensure the resulting fat binary contains armv6 code.
I had the same problem with XCode 4.1.1 and an Ipod Touch 2nd gen. I started with one of the templates and couldn't run it on my hardware. Found all the answers here on stackoverflow, but it's better to have all necessary steps in one spot:
You have to add armv6 to Architectures in your project settings (Build Settings tab). You can set it to "armv6 $(ARCHS_STANDARD_32_BIT)" or "armv6 armv7", it doesn't matter. $(ARCHS_STANDARD_32_BIT) is just a variable which equals "armv7" in the newest XCode.
Don't change the Base SDK, "Latest iOS (iOS5.0)" is fine. Under "Summary" change "Deployment Target" to 4.0 or whatever iOS version you want to have as a minimum version.
The newer templates in Xcode 4 have a standard setting in your Info.plist which you have to change. Search "Required device capabilities" and delete "armv7".
If you're doing steps 1+2 but forgot step 3, you get the "Could not receive USB message" errors in the device log and no error message otherwise in XCode. Why it does that, instead of showing you an error message that hints you to "Required device capabilities" is a different question.
In Short: Apple started to drop support for the armv6 platform with the update to iOS 4.3. Newer hardware runs with a different instruction set, armv7. If you want to support iOS 4 with XCode 4, you should really make sure that you also build your project for armv6 correctly with the steps above.
It looks like you have iOS 5.0 SDK installed. Am I reading that right? If so, that is governed by Apple Developer NDA and should not be discussed here. I would post in the developer forums.
Do you have other devices running 4.2.1 that DO work with your installation of Xcode? Do you have any other devices at all that DO work with your installation of Xcode?
Please be aware that apparently the architecture setting is case-sensitive.
I manually added 'Armv6' and nothing still worked.
Changing this to 'armv6' did the trick.