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.
Related
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.
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 :)
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.
I have recently included android wear support in my app but when I went to publish it today I was made aware my earlier version would be archived. My earlier version was targeting api 16 to include as many devices as possible.
I was hoping if a user doesn't have the latest devices capable of running my updated android wear version then they would get the earlier version I have published.
What is the correct procedure to enable this to happen please?
Regards
It is possible to keep your app supporting API 16 while adding Android Wear support. The Google Play Services library runs on many older devices, and it will do the right thing to ensure that your code will not crash. Since an old Gingerbread phone cannot support Android Wear, you will just get an error code when you try to make use of Wear functionality, and you can just handle it gracefully with whatever way is appropriate for your application.
I published an app to Google Play, but some of my users are unable to find it using their device.
The min apk for the app is 11 (Android 3.0).
When someone uses for example a Samsung Galaxy SII with Android 4.0, the app can't be found because the initial release of the SII was with Android 2.3. With a SIII it's no problem.
In the developer console, the console automatically checks to see which devices are compatible when uploading the apk. As developer, I can disable devices for download, but not enable devices.
Does Google Play check the current version on the device or does it uses the versio, of initial release?
How can I reach as many as possible devices? When I lower my min APK in the manifest, I get compilation errors.
Thanks in advance
That's a really good question. Lowering your minSdkVersion or publishing multiple APKs is the best solution to reach many devices, your problem with this approach is that probably you are using some API features that aren't present in older APIs so that's why you're having compilation problems.
http://developer.android.com/google/play/filters.html#manifest-filters says:
Example:
The manifest includes uses-sdk android:minSdkVersion="3", and the
app uses APIs that were introduced in API Level 3. A user is searching
for apps on a device that has API Level 2. Result: Google Play will
not show the app to the user.
So I assume google will filter based on the current API version.
Can you post your app link?