As the title says, are there any sources (web pages etc) of summarised changes at each API level?
I have an app which I've put out to a small group of beta testers and I already fell foul of Context.getExternalFilesDir(), which I hadn't noticed was introduced in API Level 8, when a couple of the guys tried it on Android v2.1 devices.
The majority of my code should be pretty generic but it would be useful if I could find a condensed/summarised list/table or similar that I can quickly glance over.
The Android docs provide a diff between each major API revision. For example, here is the diff between API 10 and 11. Unfortunately, it looks like it's only sequentially available between revisions (not from 8 to 11). I can't find the landing page for the diffs, but you can change the API revision in the URL to see other reports.
You should be running the app yourself on the lowest version of the platform you are supporting. Always. Run it in the emulator. There is no replacement for doing this.
At a glance quick overview: https://developer.android.com/reference/android/os/Build.VERSION_CODES.html (quite well hidden, Google!). Clicking on a particular version will show a more detailed, but still quick overview on what's changed.
Not sure if this is exactly what you're looking for, but I have a look at the the API Overviews when a new version is out. It's a good start to see whats important and new. For example:
Android 2.3:
API Overview
Android 2.2:
API Overview
I also like to take a glance on the Platform Highlights when available.
Here is the analysis of changes performed with the help of the JAPI-CC tool: http://abi-laboratory.pro/java/tracker/timeline/android/
Related
First off, I know very little about android development, I am just getting started.
What is the Minimum SDK choice that you get when creating a project in android studio? Is there a downside to using an older one? And if I follow a tutorial is it essential that I use the same one so I can follow along?
Thanks.
What is the Minimum SDK choice that you get when creating a project in android studio?
That is the oldest version of Android that you are willing to support. It is expressed in terms of an API level. You can see common API levels in the Android dashboards, and the documentation will point out in many places where things need such-and-so an API level to work.
Is there a downside to using an older one?
Less stuff in Android will be supported. In your case, since you are following a tutorial, choosing a lower minSdkVersion may cause some more complaints from your IDE, saying that such-and-so is not available on your chosen minSdkVersion.
And if I follow a tutorial is it essential that I use the same one so I can follow along?
IMHO, that depends on your overall programming experience. If you are a veteran developer, and you want to play around with a lower minSdkVersion, go ahead, bearing in mind that the tutorial code might not run on that API level. If you are fairly new to programming overall, stick with what the tutorial tells you to do. If your concern is that your test device is not new enough for the tutorial, find a different tutorial, find a different device, or use the emulator instead of a device for testing this tutorial.
android:minSdkVersion
An integer designating the minimum API Level required for the application to run. The Android system will prevent the user from installing the application if the system's API Level is lower than the value specified in this attribute. You should always declare this attribute.
You can use your own min SDK but be careful about features you use. infact, minSDK with great number have more features.
For some reason the original Aviary framework has stopped working and this has forced me to migrate our code to use the new CreativeSDK instead.
Unfortunately this new SDK has a minSdkVersion of 14 = Android 4.0, but a lot of our customers still use older versions (a little over 20 % according to Googles statistics for our app).
We cannot release an app update that cuts away that many users, but is there a way to compile the app with a lower api level and then just disable the image editing for the "old api" users?
is there a way to compile the app with a lower api level and then just disable the image editing for the "old api" users?
Tricky question. You can try build the app with api lv < 14 but then the creativeSDK will not be able to compile, resulting in a build error, so no.
Android 4.0 is already ~4 years old. It happens more and more that libraries drop support for older android versions (for good reason I think. Just update already!), as is the case with the creativeSDK. The minSDK requirement went from 2.3 in the aviary framework to 4.0 in the creativeSDK.
Adobe has to have done this for a reason. It is too much of a hassle to provide compatibility for 'old' versions of android, especially for complex functionality.
It is mentioned here, here and here that the creativeSDK now really requires api 14, and compatibility for older versions is not mentioned anywhere, meaning it very much likely doesn't exist.
To come back to your question, I think what would be a solution for you is to create multiple APKs for different API levels. There is some work to be done, but it is officially supported by Android, and the steps on how to achieve it are described clearly in the documentation I linked to.
Other than that, you have two options:
Drop the SDK and use another library.
Contact support and ask if they had forseen this issue and how they suggest you go about solving it.
As noted by Tim, the Adobe Creative SDK supports Android API 14 and up. It won't work for anything lower than that.
If you're using the Image Editor UI component, it's also worth noting that for APIs 14 and 15, the AviaryIntent.Builder will not work.
There is a workaround for that issue documented here.
Update: Note that starting in version 0.9.7 of the Creative SDK, the Image Editor supports Android API 16 and up only. This is noted in the Getting Started guide.
what is the version of android from which further on there is no concept of incompatibility(no need of support libs). I am a newbie and this supporting and non supporting thing is making it so boring. I just want to know of a stable version from which I should take start and do not use support libraries (like appcompat, sherlock, etc). Also tell me if I am doing a wrong thing doing this I mean anything that will help me. Thanks
Any relevant help is appreciated.
As an app developer, you'd like your app to run on as many devices as possible. Generally, developers give support from API level 8 (Android 2.2) and upwards.
Most of the compatibility libraries are for pre-API 11 (HoneyComb).
So basically, it depends upon what you want to aim for.
Edit
You might be interested in checking out Choosing the right API Level for my android application.
I want to start programming for android devices and I have 1 question for you. I heard that Android is forward compatible. So, if I use 2.1, can I, at a later stage, update the app so it works with 4.0.3? What do you suggest me to do? Thank you for taking the time to answer these questions.
Ofcourse always start with lower version 2.1
2.1 is great for starters, but I would strongly advise to use Android Support Package for learning and implementing Fragments since Fragment based apps are the general direction in which Android is heading.
If you want to start Android Development i would Advice you to learn some Java Basics First if you are not familiar with the java envirnment.
Concerning The Android Api that you should start with, I will advice you to start with the 2.2 Froyo it's one of the most stable Api.
The choice of the android platform depends also on the fact that developer want to target the Larger Number of devices that's why google provide a chart's, that show wich platform are the most used. you can find this chart in this link.
Also in this link you can find the difference ore improvement on each platform, you can refer to the android developer site to see differences
I'm developing an Android app which will target 2.1/2.2 devices, so I have my project set up to use the 2.2 SDK (API level 8), but allow for installation on devices with at least API level 7.
The problem is that during my daily development, I'm not always paying close attention to which API level of the methods/classes/constants that I'm using, which makes it very easy to break code on older devices. I have got dynamic classloading working, and as much as I dislike having a ton of extra factory classes and interfaces in my project, I'm willing to deal with that solution. Currently, the only way I have to check an older API level is to set my project's settings to the given level, rebuild, see what breaks, and then refactor. It's quite a pain.
What I would really like is the ability to scan my code and check compatibility for a given API level without changing my global project build settings. Is there some easy way to do this?
Android API Analysis Plug-In for Eclipse:
http://adt-addons.googlecode.com/svn/trunk/apianalysis/
Ok, so based on my research and the comment by #CommonsWare, there's no static analysis tool or some other easy way to do this. Shucks.