In android gradle build file I have the following closure:
android {
compileSdkVersion 21
buildToolsVersion "23.0.1"
defaultConfig {
applicationId "com.mycoolapp"
minSdkVersion 16
targetSdkVersion 21
versionCode 41
versionName "3.0"
}
}
I do not want my app to run on Marshmallow. My targetSdkVersion is 21 and Marmallow would be 23. So imagine I have a phone that is Marshmallow, if I go to the play store will my app appear in the listing?
My second question is how would I stop my app from appearing in google play store for marshmallow devices?
So imagine i have a phone that is Marshmallow, if i go to the play store will my app appear in the listing ?
Yes.
how would i stop my app from appearing in google play store for marshmallow devices?
You are welcome to try android:maxSdkVersion in the <uses-sdk> element of your manifest, as the current documentation suggests that the Play Store uses it as a filter, though this comes at a cost to users who get upgrades of their app to Android 6.0.
Answering not to original question, but to reasons of it.
I'm not sure you have to do it.
api 23 is asking for runtime permissions. so if i have a device running 23 and since android is backward compatible, what will happen for example if im using apache httpClient which is depreacated in marshmallow
You still can use HTTP client. From the docs:
To continue using the Apache HTTP APIs, you must first declare the following compile-time dependency in your build.gradle file:
android {
useLibrary 'org.apache.http.legacy'
}
I tried to install my old applications which use HTTP Client on Android 6.0. They still work, without the dependency in build.gradle and even without recompiling.
or if im not prepared to handle runtime permissions ? wont my app break in this case ?
App wouldn't break. If you don't compile your app under Marshmallow (targetSdkVersion 23 or higher) then it will work in "legacy" mode: permissions will be requested before installation. With one exception: users still can switch off permissions in settings; I don't think that many users do it.
Try your app in emulator or real device. I'm almost sure it will work under Marshmallow.
may be i think it is described in app runtime permission model will work if we target api to 23
Note: This lesson describes how you implement permissions requests on apps that target API level 23 or higher, and are running on a device that's running Android 6.0 (API level 23) or higher. If the device or the app's targetSdkVersion is 22 or lower, the system prompts the user to grant all dangerous permissions when they install or update the app.
link: https://developer.android.com/intl/es/training/permissions/requesting.html
may be if i have some misunderstanding then please notify me
Related
Is it possible to target API30 while at the same time disallowing access to my app from Android 11+ devices. The Google Console forced an API30 targeting standard on updates and I do not want Android 11+ devices to have access to my app yet.
Thanks.
You can use maxSdkVersion.
The element is ignored by the android OS itself but apparently the Google Play Store still uses it to filter devices for apps:
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, when presenting users with applications available for download.
Source: https://developer.android.com/guide/topics/manifest/uses-sdk-element
You can add it in your app module's build.gradle file:
android {
compileSdkVersion 30
defaultConfig {
...
maxSdkVersion 29
targetSdkVersion 30
...
}
}
I am trying to port my app from API 22 to API 26. Several API calls are failing (e.g. WRITE_EXTERNAL_STORAGE, etc.). I believe it is due to the new runtime permission model wherein permissions are not granted EVEN if they are in the manifest.
So I tried to do the right thing, namely using checkSelfPermission() and requesting the permission if denied.
My problem is that checkSelfPermission is not available before API 23 and my minSdkVersion is lower than that so Android Studio flags it as an error.
I'm now stuck between rock & hard place: If I raise my minSdkVersion to 23, I'll break the app for many existing customers. If I lower my targetSdkVersion below API 23 to avoid the problem, Google Play won't accept it.
Help!
You should check permissions only for API >= 23.For API < 21 will use install-time requests
Call ContextCompat.checkSelfPermission() in the v4 support library (see this question). This is a "compatibility layer", so that single function will work on all versions of Android.
When I try to upload the apk to store I get these warnings
Partially upgradable APK
WARNING
Some users of this APK may not be able to upgrade to any of the new APKs added in this release.
CAUTION
Users that currently have APK with version code 53, which targets SDK 22 or lower, will be eligible to upgrade to this APK. However, once users upgrade to this APK, they will be unable to upgrade to APKs that target SDK 22 or lower.
Following datas are my current build details
compileSdkVersion 26
buildToolsVersion 26.0.2
minSdkVersion 15
targetSdkVersion 26
This is my previous update details
compileSdkVersion 25
buildToolsVersion "25.0.3"
minSdkVersion 15
targetSdkVersion 22
This warning is because yoy have upgraded your api higher than 22 that means you have to handle some runtime permisions. The warning says that this is a one way switch i.e there is no way of coming back to targeting API 22 or earlier once you make the switch to the runtime permission model.The developer console is just confirming that you have done all the thing need for runtime permissions so no need to worry.
It is normal but in your case - you need to be careful since you target several levels higher.
Warning: Users using previous build would not be able to install the
update simply because of difference in permission models and higher
compile - 26. So if you don't make sure that you handle new permission
models and other functionalities, you may tend to lose part of your
users.
Caution: Users once they update to the new build will not be
able to upgrade back to lesser build of the same App. This means once
you publish your App in higher build successfully, you can't go back
to lesser build targets in your next update. Make sure all your
functionalities work in the new build before deploying.
Thanks
Its simply ok.
Warning indicates that once you increase your target version higher than your previous target version then users get update to newer targeted version app. But then after they cant receive update for lower target version.
But make sure you have handled Runtime Permission Model Properly for all dangerous group permission.
Rather than it does not affect your user base or nor your app functionality.
Happy Coding..
I'm getting an error - INSTALL_FAILED_PERMISSION_LEVEL_DOWNGRADE while installing app from adb after targeting sdk 22, coming down from 23.
I have to do this, temporarily because of some other issues but it would not be the best experience for the users updating the app on Google play if they just couldn't. The only solution I know as of now is to uninstall the current version (targeting SDK 23) and then install the update (targeting SDK 22).
Even though there are only a handful of people on Marshmallow right now, it would be best if they don't face this issue.
Does anyone know anything about this?
Update: AFAIK nothing can be done in the app or on the console to avoid users uninstalling and installing the app. Luckily, I did it when the users on Marshmallow were few.
Perhaps this answer does not directly address the question, but may it helps others to achieve a faster solution.
I have created some versions with the following configuration (inside build.gradle) and made them available to alpha- and beta-tester via Google Play Console:
minSdkVersion 23
targetSdkVersion 23
When I noticed that users with a deeper system-version could not install the app, I changed the configuration as follows:
minSdkVersion 19
targetSdkVersion 19
However, this resulted in the downgrade error message in Google Play Console. So I adapted the configuration that the new version for both
user with a lower system version as well as for users who have installed the current app (with a higher system version).
minSdkVersion 19
targetSdkVersion 23
How set the android max sdk version on build.gradle at android studio.
I want do an app with two flavor, the first will run between version x~y and the second run at y+
Before on eclipse, in AndroidManifest.xml we have android:maxSdkVersion="y" but how it works on gradle?
You cannot set the maxSdkVersion in gradle. Actually, it is discourage by Google because of several issues. The main issue is that Google Play could decide to remove an app from a user device during an update if the system doesn't meet the maxSdkVersion specified in the app. For example, imagine you have a device with API Level 12 and you install an app with android:maxSdkVersion="12", then later you receive a system update that upgrades your android version to API Level 13...Google Play will uninstall your app.
Basically, you don't need this setting and you can easily ignore it, use the targetSDkVersion attribute and the minSdkVersion.
For your app "in flavour 1" with "version x~y" set the minSdkversion to x and the targetSdkVersion to y
now, for the app "in flavour 2", you will need to make sure that the sdk version don't get overlapped by the app "in flavour 1", set the min sdk version to "z". Otherwise, users with a device with api level "y" will never get to see this app in Google Play
Please note this.
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, when presenting users with applications available for download.
https://developer.android.com/guide/topics/manifest/uses-sdk-element.html
I think accepted answer is not correct. Accepted answer says it is not possible to set maxSdkVersion - it is not true. It is still possible to use maxSdkVersion in android studio app/build.gradle. As described here https://developer.android.com/guide/topics/manifest/uses-sdk-element developer must notice warning and should understand why wants to do it. Nobody here take care that in play store you can provide several bundles/packages at once (per update/release) and one bundle can be targeted for new devices and another for old devices so it is fine second one limit by maxSdkVersion. One app bundle have versionCode e.g. 2xyz and for older devices is versionCode 1xyz and google always installs higher code when minSdkVersion allows it. So developer can purposely set maxSdkVersion and he know why hi is doing it.
Each our app update have 2 packages with different app/build.gradle...
For old devices
(maxSdkVersion has sense here)
defaultConfig {
minSdkVersion 16
maxSdkVersion 23
targetSdkVersion 30
versionCode 1058
versionName "4.4.0"
}
For new devices
(without limiting maxSdkVersion as googole warns that should not be used)
defaultConfig {
minSdkVersion 24
targetSdkVersion 30
versionCode 2058
versionName "4.4.0"
}