I am making an android app, and am wondering what the industry's thoughts are on supporting older android versions like GingerBread and FroYo. Should a developer like me take the extra step to make my app compatible with those older versions, or are they obsolete? I am speaking in terms of the market in 2014.
Increasing my minimum SDK version opens up some more APIs, so which option should I pick, compatibility or APIs and features?
Most of the Android devices are above the Gingerbread level. But there are still a decent number of those devices out there. You, as a developer, must decide if the number of users who would potentially download your app for those versions of Android is worth the level of effort in developing the app for those versions. For the past year, both companies I've worked at have begun to work on 4.0 and above only and have forsaken the lower versions.
To get the current information on what the ecosystem looks like for Android, check out Google's dashboard
As I write this comment, Gingerbread and below is around 15% of the total population.
2019 UPDATE: Google's dashboard states that only 0.2% of Android users are running Gingerbread (Android 2.3). Around 3% are using Jelly Bean (Android 4.1/4.2/4.3), and 7.6% are running KitKat (Android 4.4).
Generally, companies target a minimum version of KitKat, or SDK 19, for new endeavors. For personal projects, we usually choose Lollipop, or SDK 21, as it brings a number of improvements to the table, such as improved build times.
[2020 UPDATE] You need to base on Android Pie Chart . It is always updated.
here's the link of the dash board:
https://developer.android.com/about/dashboards/index.html
For the record - 2020 April
If you look at the comments, they usually set the min level to 19 since years ago. Right now, it is nonsense (also, some comments are obsolete).
We are looked at the statistics of Google, and they say, "+10% of the devices are KitKat or lower. However, it's tough (if any) to find a company that sells phones for Kitkat.
So, why Kitkat 19 is still popular? Because old smartphones simply don't go away (and they aren't updated).
Then, technically 10% of the market uses Kitkat or lower but that information is mostly useless
From then 10%, how many of them will install your application? Or any new application?. I know a lot of people that are happy with their old-and-rusty phone, but they only use for making calls and watch youtube/browser internet. So, usually, the lower 10% is not part of our target market or the target market of anybody.
Twitter said about it:
minSdkVersion ยท Nov 7, 2016 19
minSdkVersion Apr 23, 2018 21
minSdkVersion Dec 9, 2019 23
When Twitter says API=23, then Twitter is ignoring 25% of the market. It is a huge number. But again, this number means nothing without analysis. Twitter decided that this number is moot because, of the 25% of the users that use an old phone, they are not really in its market share, i.e., people that don't use Twitter on their phones using an application.
So, for the record and as for April 2020.
API = 19 who are you pleasing? Remember, we are 4 years later in comparison with Twitter.
API = 21 is a moderated number.
API = 23 sounds like a rational number.
For example, I run a windows server, and the default browser is Internet Explorer. Do you know how Internet Explorer works in the real world? It doesn't!. It works with google and a few sites, but everything else is broken. And still, developers "support" internet explorer because of the non-existence 6.97% market share (the users exist, but they are not everybody users but intranet users).
Now, if your application is for a government/public interest, then we should stick with the standard or official procedure, and sometimes it could be around API 15 or 16.
For those who are looking for an opinion to refer to, #minSdkVersion updates their Twitter account when they deem it appropriate to start using a higher minimum SDK version. They claim
The minimum SDK version for the practical, rational developer.
As others have mentioned, it's also worth checking the Android distribution dashboard. The full platform version disribution can be found in Android Studio's Create New Project wizard.
UPDATE JULY 2022
This is what Android Studio shows before creating a new Project.
I'm a developer myself. I would look into this from multiple point of view and I would use several factors to begin a project with a particular sdk as minimum.
Beside the chart, that Google is kind enough to publish, which is really helpful and informative and i believe it represents devices around the world.
These are the factors I would take under consideration:
What's my app all about? What kind of people and what kind of age range would attract. Young people tend to keep their gadgets up-to-date.
In which country I'm going to release my app? Not all countries have the same mainstream when it comes to technology.
Does the minimum sdk affects the time or the resources that are going to be used in the app? If having a high sdk as minimum is inversely proportional with the time and the struggle my developers would face in order to make everything compatible, then I would choose a higher sdk, even if I have to exclude a small proportion of users. Let's face it, this is 2016. Technology is running faster than light. Releasing early really matters. In the other hand, if it really doesn't affect that much, then just choose a version that covers most devices.
Security matters as well. Everyday new issues are being patched. Newer version is more secure.
If the idea is powerful, than I would choose as higher as I could. People will follow. Is the truth.
Many functionalities are being deprecated. And usually in older versions. Upgrading from those can be hell.
Can't think of anything else. But if you want my opinion, I would choose API 19 as minimum.
Cheers.
There were only few (~10) percent of users with Gingerbread to download our application from Play Store, so we have decided not to support it anymore. It was about 7 months ago. Froyo and Honeycomb are dead for much longer time.
We would go with Android 4.0 (API 14) as minimum for new projects. There is no real benefit from supporting older version unless you are forced to do so (client requested it, etc.).
Note the new directive from Google around the dropping of support for ICS (sdk 14 and 15). Recommended course of action is to set your minimum to 16. See https://android-developers.googleblog.com/2018/12/google-play-services-discontinuing.html
Note that existing apps will continue to work ok.
Related
I found that Jelly Bean is still taking a fair amount of installed devices.
If I plan to make an application for Jelly Bean, do I have to set source code compatibility 1.6?
Jellybean is 4.1-4.3
If you are looking at that api 16 that's different than android version 1.6
At this point, it looks like anything under 2.2 (froyo) is on less than 0.2% of android devices.
In this graphic you can see a distribution of Android platform versions used by Android smartphone owners in October 2015. The figures are based on the number of Android devices that have accessed the Google Play Store within a 7-day period ending on October 5th, 2015.
http://www.statista.com/statistics/271774/share-of-android-platforms-on-mobile-devices-with-android-os/
This graph shows the most common SDK installed on Android phones and tablets used by AppBrain SDK users as of December 8, 2015.
http://www.appbrain.com/stats/top-android-sdk-versions
So I'd suggest anything 4.0.x and up will suffice for making most of the public happy with your apps.
No, you don't need to. Almost nobody uses 1.6 now.
I am a beginner on android programming. I am at the first at all. I wanna learn some important point.
Now, I am installing the programs and platforms which I need to develop Android Apps. On the SDK Manager there are few options to download Android API.
Which one should I prefer? I want to that, my app will run on all android roms and versions like ICS or JellyBean.
Thanks!
In order to support as many users as you can, you should opt for the lowest version API, since apps written for an older version of Android will work for future versions as well (although they may not be optimal). Once you need a feature in a later version, you can increment your minimum SDK version.
I would look through the different SDK versions (e.g. 2.1) and see which features (and/or permissions) you need for your app.
Keep in mind that older phones may not have certain capabilities, and you may not be able to support them. Therefore you should weigh if what you're adding is worth alienating the users you will no longer be able to support. Android provides a table of market share per version.
You mention that you want to support ICS (4.0) and Jellybean (4.1 and 4.2), which together control a little less than 50% of the Android market. It is worth looking into supporting Gingerbread (2.3) as well for another 45%.
Another option of course is to branch your code depending on the user's OS version, but this requires a little more maintenance work. However, if you are supporting pre- and post-Holo-themed versions (ie for the action bar), it may not add that much overhead.
It really depends on your target market, purpose, and familiarity with Android.
Android maintains forward-compatibility which means an app designed for 2.1 for example will work on later versions (in most cases). However there are some features added in later versions which are only supported starting with a certain SDK version.
This page may be helpful for you
I developed an application and I put it on Google Play, but the thing is that sometimes, some people fail to install it and i don't know the reason.
However, i'm not sure if the reason is because my minSdkVersion is set to "8".
I'm using Android 2.2 API.
Is it ok to set the minSdkVersion = "1" ? and what are the disadvantages of putting it as "1" instead of "8". How should I choose it? That makes me confused because in the same time I want everyone to install my app.
There is very little benefit from using API 1 as the minimum SDK. Check out Android's Dashboard of active devices. It shows that 3.1% of users still have API 7 or below, 0.4% for API 6 below.
You will also find great difficulty, if it is even possible, to recreate many of the modern features in API 1... even the Support Library only works on API 4+.
In short, it is unlikely that your minimum SDK version is the culprit.
Only set the minSdkVersion to the lowest you have tested on. If you use features that are specific to API level 8 (or higher), and don't specifically check for their existence, then your users on lower versions won't be able to run anyway.
Running lint can also smoke out bugs from lower versions.
This number will only filter out users on the market. They will get a message saying the app isn't compatibile with their version. It sounds to me like the problems you are having are that users are failing to install. I don't believe changing the minSdkVersion will help you there. This is most likely to do with bugs in the Android Market version they are using.
Android version 2.3 - 2.3.2 (API 9) are declared as obsolete, and according to Android Market statistics, are very rare (0.5% of market users).
The question is:
Why is API 9 declared obsolete and more importantly, is there any reason why should I not use it? I've been using API 9 and see no problems with it... am I missing something?
Better not fix it if it's not broken, right?
EDIT:
Clarification:
If I would update my applications' API from 9 to 10, what would be the benefits?
I can only see negative effects:
1% of users will suddenly find out that the app doesn't work on their phones any longer. This is even worse with paid apps. Or that I'd be forced to maintain two versions of each app.
Have a look at the description of API levels. Gingerbread API (9) has been replaced by Gingerbread MR1 (10). You should upgrade to this API.
The current version of the android OS is 4.0 (Ice Cream Sandwich). 2.3/2.3.2 is quite a few versions ago and was quickly replaced by 2.3.3. (api lvl 10), so it is very reasonable (as time progresses and changes / updates are introduced) to "shelve" a specific version so to speak.
However, the one strength in the android OS is backwards compatibility. While older devices (pre 2.3) will not be able to run your applications, all applications going forward will. There is technically no problem running the older OS's but bug fixes/changes...etc mean you may be inadvertently using buggy code that contains security flaws or other issues.
It's best to pick the API version that will reach the majority of your target market most effectively.
For example, if you wanted to take advantage of some screaming new OpenGL features on the newer higher powered phone you wouldn't want to run it an older API level and possibly create a storm of angry users because their phone doesn't have the HP to run it!
However a more simple application might be fine just running on an older OS (like the Chuck Norris random fact generator).
You should always go for the lowest possible API to use. Simply because the lower your API level is, the more users can you reach.
So looking at the current stats, you are able to reach 97.9% if you "dumb" yourself down to API level 7.
But why API level 9 is obsolete? One could not know for sure, but most likely because it had some major flaws.
The Lvl9 is obsolete because if you want to develop for Gingerbread you should use 2.3.3+ (Lvl 10). This is because the "old Gingerbread" (lvl 9) has some significant issues.
Well, I don't really think you should be worry about the OS itself. But many Droid programers, like myself, are not testing Gingerbread version on emulators. Mostly, because it's not showing on the SDK interface (appears only when you check the obsolete filter). So, I guess that other programers are ignoring this version also. That's the only problem I can think.
I'm starting to broad my developer skills also to the Android development.
I installed all the tools and configurations and every thing seem great, As a default settings I install the 3.2 SDK, but there is not too much docs on that one, mode of what is out there is on the 2.x SDKs.
Is it like IOS, does android have a good backward computability? Can I stay with the 3.x and count on it (with the features that are in the 2.x SDKs) to work on 2.x phones? What are the common version in the Android devices this days? I have lots of newbie develop questions like that, as i want to start from a good starting point and there are lots of materials and tutorials over the web that are not up to date.
Also, does any one know about a good site for this kind of Q&A?
Thank you,
Erez
As of July 5th the version with the largest market share (59.4%) is 2.2 (API Level 8) as shown here
http://developer.android.com/resources/dashboard/platform-versions.html so Consequently I would recommend using that as a starting point unless you are solely focusing on the new honeycomb tablets (<1% market share).
As for backward compatibility, android is completely backward compatible for the most part. Unless of course you use a new feature that is only available starting with a certain API level. Google's Android market is good about only allowing apps that will run on a certain API being visible to that phones user. This is enforced by the API level as recorded in the manifest file that is created with every Android app and set by the developer.
To help you with the API level, the SDK docs show what API a feature/object started with in the upper left hand corner. You can also view the specific changes in each platform and it's corresponding API level at http://developer.android.com/sdk/index.html.
As for a good website to get started I would recommend the developer site at developer.android.com and this website of course. Also the book Android Wireless Application Development by Shane Conder and Lauren Darcey (2 ed) Is very good. (I am not connected with the book just currently reading it). Make sure you get the latest edition.
Hope this helps,
George
Above is good info, but it would be advisable to develop for 2.1 and up at the moment, considering as of this answer's writing, 2.1 makes up 17.5% of the market and 2.2 makes up 59.4% of the market.
http://developer.android.com/resources/dashboard/platform-versions.html
OP should also be advised that version 3.x is specifically for tablets, so that may not be the best choice for a starting developer. My advice is to go with 2.1. Most of the documentation is up to date with that, and you won't have access to things you don't need yet (fragments, tablet-specific things)
Hope this helps!
You can read about application forward and backward compatibility in the docs.
Generally apps are forwards compatible but not backward compatible - new APIs introduced in one version are not available in an older version.
This pie chart shows distribution of devices accessing the Android Market and based on this I would try to target devices using 2.1 or newer to cover most of your users.
Your decision should be based on whether you need a feature introduced in a specific version. For example, if you want to add NFC to your app, you'll need Android 2.3.3 or newer, but otherwise there's no reason to exclude older devices.
I recommend learning about Fragments and using the compatibility package to use them on targets below 3.0. This will make it easier to reuse view elements on both tablet and phone devices. Note that if you only intend to develop for phones, 2.3.4 is the latest phone version of Android at the time of writing. Later this year, 3.0 for tablets will merge with the phone version to provide a unified OS version as with iOS.
Android 3.2 is just released publicly on friday, July 15th. You can start-off with Android 2.3.3 and 3.2 installation and development.
Android applications are mostly forward compatible. (But not always)
The best place to find all your answers is developer.android.com