My ionic app is targeted 24, min 16, no max in android manifest.
When I run in firebase on devices set to 24 or 25 I get fatal crashes.
Does my app need a max to avoid crashes? Or does that limit it being supported on newer API devices?
Also in Android studio when you first try to set a project and pick a target it tells you that __% of people in the play store use that target so 24 is less than 1%. So if my target is 24 does that mean only 1% of the store will be able to use my app?
Here is my API 23 app crash on a 25 device:
API 24 app crash on a 24 device:
I see you are a little bit confused, let's first clear what each of them means to Android.
android:targetSdkVersion
With this you are telling Android which SDK you are targeting. What is important about this is that it tells the system that SDK level matchs this attribute, the system doesn't need to enable any behaviour to maintain compatibility.
Your app is still able to run on older versions (down to minSdkVersion).
android:minSdkVersion
As the attribute name suggests this is the minium SDK version required in order to run the app, if the device which is trying to install the app has a lower sdk version the system will block the process.
What is important to note is that if you raise the minSdkVersion in an update, all the user which have already installed the app and no loger match this attribute will be able no longer to use the app
android:maxSdkVersion
Again, the attribute name says it all. This is the maxium Sdk version a device can have in order to run the app.
Notice this from the docs:
An application declaring maxSdkVersion="5" in its manifest is
published on Google Play. A user whose device is running Android 1.6
(API Level 4) downloads and installs the app. After a few weeks, the
user receives an over-the-air system update to Android 2.0 (API Level
5). After the update is installed, the system checks the application's
maxSdkVersion and successfully re-validates it. The application
functions as normal. However, some time later, the device receives
another system update, this time to Android 2.0.1 (API Level 6). After
the update, the system can no longer re-validate the application
because the system's own API Level (6) is now higher than the maximum
supported by the application (5). The system prevents the application
from being visible to the user, in effect removing it from the device.
That's it. Check also the DOCS here
Also in Android studio when you first try to set a project and pick a
target it tells you that __% of people in the play store use that
target so 24 is less than 1%. So if my target is 24 does that mean
only 1% of the store will be able to use my app?
Actually not, you have to consider the minium and max in order to find how many % of market will be able to use your app. That's just saying how many people (in %) have that SDK Version.
About the crashes
I am quite sure that the problem is not related to the SDKVersion, maybe you should post some log in order to give a more detailed answer to that.
Hope it helped you :)
Related
Something doesn't add up:
According to Google Play’s target API level requirements new apps for Android as of June 2019 cannot target Android versions below 8. Starting with August 2019, nothing below version 9.
Yet, according to Distribution dashboard the 9's version devices share is just a bit above 10% while 9 and 8 combined get you to about 30%.
Am I correct to deduce that anyone thinking of creating a new app today (June 2019)
can only reach 30% of his Android audience (via Play Store) and
if s/he doesn't make it before August, only 10% of the whole Android users can be reached?
Apple has a similarly sounding page here, but: 1. it mentions iOS 12 share being above 80% and 2. I don't think built using iOS 12.1 SDK or later really means targeting iOS 12.1 and above.
Current Xcode still lets you target iOS 8.0 (do they still accept it into the App Store?) which still happily runs on 2011 iPhone 4S despite its minuscule market share.
The targetSdkVersion restriction was introduced to prevent app developers from using old apis like permissions to bypass runtime permissions.
An app targeting older api version was always allowed all required permissions at installation time. With the introduction of run time permissions, user has a better understanding and control of permissions in app.
The minSdkVersion is the one which actually affects from which version of Android your app runs.
API Level 21 would do good as it has near to 85% coverage of devices.
The restrictions that the Play Store imposes is on targetSdkVersion. You are confusing that with minSdkVersion. minSdkVersion controls how old of an Android device can run the code, and this is not affected by the Play Store restrictions.
Reviewing the reports on the Google Play Console for my app, I can see that ~150 devices among the active installations are running Android versions 4.1, 4.2, and 4.3 while I explicitly configured my build.gradle file with minSdkVersion 19.
From what I know those versions have different API numbers 16-17-18 and all belong to the Jelly Bean family.
How can this happen? Am I missing something?
You may had set minSdkVersion to 16 at the time of your first few release to Play Store, thats why many users had been able to install your app on Android versions 4.1, 4.2, and 4.3 but they never updated your app (may be because their auto update of off or some other reason)
In our apps I see a some background radiation from crashes on rooted devices that have older unsupported API levels. The numbers are small and it's not anything we are supporting, so I don't really care about those.
If the device is rooted, one way to bypass min SDK restrictions is to edit the build.prop file to lie about the device's API level.
This is a beginner question, but what are the steps needed to get my app to run on more devices? I noticed that my new update (on beta) is running on fewer devices. Do I just need to update the targetminsdk version in build gradle or is there anything else I need to do? I think I should be aiming for minsdkversion 18?
My versions in gradle are here
compileSdkVersion 23
minSdkVersion 21
targetSdkVersion 22
Min sdk version : Is the earliest release of the Android SDK that your application can run on. So this is what you want to change if you want more devices supported for your app.
Target sdk version : The version your application was targeted to run on. Ideally this is because of some sort of optimal run conditions.
Android Developers forum says :
The dashboard for Platform Versions is updated regularly to show the distribution of active devices running each version of Android, based
on the number of devices that visit the Google Play Store. Generally,
it’s a good practice to support about 90% of the active devices, while
targeting your app to the latest version.
For more details, go through : Supporting Different Platform Versions
For API 18 : your app will run on approximately 76.9% of the devices that are active on Google Play Store.
For API 21 : your app will run on approximately 40.5% of the devices that are active on Google Play Store.
Now that is a huge difference, that you may not really want for your app. So you need to weigh your pros and cons of having Latest API support to getting more users. I would infact recommend you to go for API 18 instead of 21, unless you have some very important functionality that necessitates API 21 and above and can't be done without.
I've faced the problem uploading app to Play Store. The old "19" version was available for API versions 10 and above. New "20" version specified maxSDKVersion=22 (not higher Android 5.1).
An error message, when trying to upload "20", says:
"it is forbidden that a device upgrading from API levels in the range
10-22 to API levels in the range of 23+ should downgrade from version
20 to version 19, which could happen if...".
This situation clearly specified in documentation:
...future versions of Android (beyond Android 2.0.1) will no longer
check or enforce the maxSdkVersion attribute during installation or
re-validation. Google play will continue to use the attribute as a
filter, however, presenting users with applications available for
download.
Our application not working properly on Android 6, so we should somehow to prevent installs on those devices.
So, there is an answer from Google support:
...
The error message is stating that if a user updates the Android
version on their device, the configuration of your APKs would cause
them to become ineligible for the version they currently have.
To resolve this issue, always make sure the APK that supports the
higher API level always has a higher version code. For example, if an
APK with API levels 14 - 17 was version 3 then an APK with API level
18 would have to have version 4.
In other cases, you can simply remove the max SDK declaration from
your app’s manifest.
...
And there is no way to add maxSDKVersion limitation in existing app.
What happens to existing users with the app installed when minSdkVersion is raised and their SDK version is less than that?
Do they still get the update from Google Play with a subsequent crash? Or do they stop getting updates from Google Play?
Below happens on minSdkVersion change
On apk upload, Google plays warns you on minSdkVersion telling how many users will be affected.
Existing users lower than minSdkVersion won't get update and cannot
see app in PlayStore
Existing users lower than minSdkVersion, if they uninstall, cannot
reinstall the application.
I suggest you use multiple apk option in PlayStore and continue to update your newer apk. Just keep the old one as it is.
For example, you can publish your application with one APK that
supports API levels 4 - 7 (Android 1.6 - 2.1)—using only APIs
available since API level 4 or lower—and another APK that supports API
levels 8 and above (Android 2.2+)—using APIs available since API level
8 or lower.
For more, read the android documentation on multiple apk support.
They will not get an update and it won't show up on Google Play for them any more. The version they have installed will remain on their device.