I'm about to build a new app. I'm just making an alarm and I'm aiming to help old people mainly (I assume they don't follow technology as geeks and they can use old phones like 5-6 years old) and max user count not shiny new features. So I can ignore API 8's 0.1% according to Android Dev but I don't want to ignore API 10-15's ~5%.
So I decided to use API 10 as min SDK level. While downloading API 10 inside Android Studio I encountered with Obsolete warning as shown in the image:
Okay maybe it's shown here wrong and better to do this directly from Android SDK Manager. It was same and I had an extra warning for SDK platform is not compatible with Windows:
If I remember right it was not obsolete in late of 2015. Google confused me with API levels since they are refusing to be backwards compatible. Anyway here is my pile of questions inside my head:
Does this mean Google doesn't care that ~5% (API 10-15 users and developers) anymore?
What does obsolete mean? Just not supported by Google anymore?
Is it a bad idea to use this API for new projects? What are the problems I can face if I use it now and future?
If I choose a newer API like level 18+, what I'm gonna do after 5 years until API become obsolete? If I won't add any new functionality except basic things and fixes, do I have to upgrade API that time?
It says the "Google APIs" is obsolete, not the platform.
Yes, it is not supported anymore. (Once again, not the platform)
Yes, do not use anything that is deprecated or obsolete.
Most likely you Android application will still work but it is important that you update is periodically in order to keep/retain and grow your users.
Related
I can't lower the target sdk to 29 because it's the new requirement from google play(Target API level 30 (Android 11) or above)
Has anyone had the same issue?
No issue with target 29 and play-service 12
implementation 'com.google.android.gms:play-services-ads:12.0.1'
Play-services-ads version 12 is a bit old(released 3 years ago), it's possible that API-29 to 30 update deprecated & removed some stuff that makes version 12 work, you will probably need to update to a later version of ads(19-20 are the most recent ones as of this moment).
I suggest you if, you convert version low then some methods you 'll get deprecated.
So, When you upload an APK, it needs to meet Google Play’s target API level requirements. New apps and app updates must target Android 10 (API level 29) or higher; except for Wear OS apps, which must target API level 28 or higher.
As you update the target API level for your apps, consider adopting recent platform features to modernize your apps and delight your users.
Consider using CameraX, which is in Beta, to make the most of using the camera.
Use Jetpack components to help you follow best practices, free you from writing boilerplate code, and simplify complex tasks so that you can focus on the code you care about.
Use Kotlin to write better apps faster, and with less code.
Ensure you are following privacy requirements and best practices.
Add dark theme support to your apps.
Add gesture navigation support to your apps.
Migrate your app from Google Cloud Messaging (GCM) to the latest version of Firebase Cloud Messaging.
Take advantage of advanced window management.
I've downloaded the latest version of libGDX framework, which is meant for API level 20. Now, I'd like to target API level 19, since it's market share is HUGE, but the framework's developers "strongly discourage" using older versions. I could create the project using API level 20 SDK, then change the SDK when I import it to Android Studio, but I have no idea how it'll work out. Is it going to work, or I must use an older version to reach API level 20? (Maybe alternatives?)
The documentation wasn't too helpful, and I haven't seen anyone else having a problem like this, so I might have missed something.
Typically, you always want to target the most recent API version available, and set your minSdkVersion as low as you are willing to put the effort into supporting.
However, LibGDX is only officially tested up to level 20, so this is the safe target to use. You only need to go higher than 20 if there are some new API features you want to use. If you do that, make sure you test on a device with that API or later, since LibGDX hasn't officially started supporting it.
If you target 20, it will still work fine on later versions.
When Android gets API or behavior changes that have the potential to break old apps, the change only takes effect on apps that target the new API or higher. So all the old apps sitting in the store that haven't been updated will not be affected by the new API, because they don't target the new API.
I release LibGDX apps that target 20 and go to min version 9. These apps are installable and run fine on any device running Gingerbread or higher. I always compile with the latest SDK because I don't want to bother with keeping multiple SDK versions installed.
I am trying to decide what target API should I choose to build my next android app. I know that Gingerbread was a major upgrade over Froyo and thus I want to use API 10(2.3.3). Also the report from Google tells me that Gingerbread 2.3.3 now has 61.5% of market share(http://developer.android.com/resources/dashboard/platform-versions.html).
The thing is at this point of my project I am not very sure if the LocationManager and other API enchancement in Gingerbread will if of use, though my app will definitely use them. If I use 2.2 for development then I can target a greater audience.
My question is, will it be possible for 2.2(Froyo) users to install and run my 2.3.3(gingerbread) app if I dont use any new API's introduced in 2.3 SDK?
Edit : If the answer is no, what would you guys suggest me to do, being it March 2012 now and the pace with which updates are coming? Should developers start with minimum 2.3.3 now, seeing the bugfixes and enhancements been introduced in it, not to mention the top market shareholder.
You could target 10 as API level, but define a minSdkVersion of 8 or so in your manifest. This will enable users of Froyo devices to install your app. But you have to ensure, that you don't use any API calls which are exclusive to API level 10. If you need to use functions introduced in API level 10 you should use them via reflection and either reimplement the missing functionality for pre API level 10 or notify the user of the missing functionaltiy.
If you target your application at API 10, 2.2 users won't be able to install it, even if you don't use any new API methods.
If you keep your application at Android 2.2, 2.3 users will still be able to install and use it. See the documentation for more.
We are planning to create an android application for our web application. I have noticed that the latest android sdk is 4.0 but many mobiles on market just run on lower versions. If creating an app in lower version is supported in higher versions, which would be the most advisable version of android to start working with?
I advice you to target your application for Android 2.1.
This statistics can give you answer why.
Yes apps created for lower versions run on newer ones.
Which one to pick as the lowest version depends on your needs.
I like to start with 1.6. as a basic version¹ and increase it depending on what features I need. You can get an idea of the version distribution here. For a list of changes between each android version check out the API levels site and click on a level.
Keep in mind that 1% or 2% of a certain android version still represent a lot of customers when you consider how many devices are out there (wikipedia claims 190 million in october 2011). But on the other hand, many of these device owners may not expect that new apps support their version and don't look into the market at all. So it's a bit of a personal decision in the end.
¹ support for 1.5. and lower is a lot of work for a minority of users, it doesn't support different screen sizes for example
Indeed, almost all apps for older version will work with newer a android as well.
In the android developer guid it says:
Updates to the framework API are designed so that the new API remains compatible with earlier versions of the API. That is, most changes in the API are additive and introduce new or replacement functionality. As parts of the API are upgraded, the older replaced parts are deprecated but are not removed, so that existing applications can still use them
When creating your app, try setting the "minSDKlevel" to the lowest value where it still works. Like that you can make sure many people can use your app.
Here you can find two useful articles on different API levels and compatibility:
http://developer.android.com/guide/appendix/api-levels.html
http://developer.android.com/resources/articles/backward-compatibility.html
Yes, it will work on future versions.
How should I make the choice ? What are the parameters I should take into account ?
First of all you should take into account relative number of devices running a given version of the Android platform
Have a look at Android versions market share. I would develop for 1.6+. If you will realize in the middle of development that you want some API feature from newer version, you will have 3 choices:
Don't use that feature
Detect Android version from the app and then decide what to do
Change required Android version in your manifest file and project settings
If possible, you should support the oldest Android version still in widespread use. That would be 1.5. If you need features from later versions, you might consider requiring newer versions, but if you can do your work on the oldest version still available, you should to increase the number of people who are able to use your app.
The Oldest version that supports all the functionality your application requires.
For example: Your app needs multitouch? Target version 2.1
My application doesn't need any functionality introduced in newer versions, so I target 1.5
I agree with the answers posted above, and I would add that on the android API reference site, most of the time the minimum API level is specified (http://developer.android.com/reference/android/package-summary.html).
You can have a look at this page to identify the Android version associated with a given API level: http://developer.android.com/guide/appendix/api-levels.html
Personally, I develop everything for 2.1. There are only a handful of devices that still run <2.0 and most of those people have already put custom roms on them already. I know it kind of screws people with older phones, but I don't like the idea of crippling my app just to make it backwards compatible.
Also I feel like developing for >2.0 encourages people to upgrade their phones =P
#Falmarri: I see some flaws in your logic. Usually I'd tend to follow the same path as you if I'd be developing on another Plattform, like Windows. I do my C# applications always against the latest (non-beta) version available, as the .NET Framework is freely available for everyone (take out the new releases not being available for Win2k, which is almost 10 years old now).
With Android this attempt don't work. A majority of the devices which run 1.5 and 1.6 do it because there is no update for this device, as the manufacturer stopped developing new versions for this phone (either to motivate users to get a new upgraded one) or because it's to time intensive to make backports to this "old" devices.
So this uses don't have the "free choice" of upgrading their phones. Technically it's possible of course with rooted/custom ROMs, however most users do not have the technical knowledge to root/flash their devices with custom ROMs or don't want to lose their warranty.
So if you want to offer your App to as much people as possible, you have to develop it in mind with a much older OS version. In Android case, against 1.5.
And this is basically what I do. I've done my Apps with 1.5 in mind.
If you are developing using Android Studio:
1. Go to Tools --> Android --> AVD Manager
2. Click the Create Virtual Device... button of the AVD Manager dialog.
3. Select a Device on the "Select Hardware" wizard page of the dialog and click Next.
4. In the bottom right of the "System Image" wizard page you will see the following:
If you click the "API level distribution chart" link, it will provide you a summary of cumulative distribution by API level. I assume the information is kept up-to-date with each release. From there you can click on an API level to get specific information about that API level. Based on the information presented there, you need to use API level 18 or lower in order for about 75% of the current Android Market to be able to use you application.
Perhaps this is the type of information you are looking for. Hope it helps!
This is a direct quote from the Android Docs:
Generally, it’s a good practice to support about 90% of the active devices, while targeting your app to the latest version.
In a practical sense, this is impossible unless you had an unlimited budget.
Even Android themselves are only releasing security updates from version 8 onward.
As of right now, I recommend supporting Android 7 onward. This should cover 57.9% of market share.
If you scroll to the bottom of this page, there is a table that shows Android support information.
It will be updated monthly as the figures I quote above will change with time.