I am a bit new to mobile development. I have been using my GS7 to debug the app I am creating and I have an add-on that requires API level 25. My phone is currently running version 24. Is it possible to change the API level of the device?
You can do it by updating the operative system on your phone. The problem is most of the phone manufacturers cook the OS to highlight flagship features and to create a unique user experience (in my opinion, is a bad strategy which causes more problems than the added value). Since the OS is coocked there might not be an upgrade for your phone.
Here is a table with the API level and the name of the OS.
The most common solution for this is to use an emulator. If you are working in Mac there would be no trouble on using the default emulator, but in Windows or Linux Genymotion is recommended.
To be clear, there is no such a thing as changing the API level on your Android phone by code from an app. You have to update the OS.
Sometimes using target API code can be solved by other means, making your app compatible with older devices. Sometimes is simply using another class, other times there is a compatibility class, and worst case scenario is using an if statement where you check the OS version.
If you need to test a feature that requires api 25, then you should probably do it on the emulator.
It's gotten really good. I do most of my work on it.
https://developer.android.com/studio/run/emulator.html
Related
So, I'm current trying to learn and become a programmer. I've recently worked with C# but I really want to get into mobile apps, since most small projects really tend to fit better as mobile apps, rather than desktop apps.
The easiest, for me, seems to be the Android platform, but I'm having a problem... I don't own an android phone, but I could possibly purchase an old model. Naturally these will have an older version of Android, so here is my question...
How compatible are these different versions? Like, are there major differences when moving from Icecream Sandwich to Jelly Bean, or from KitKat to Lollipop?
How do app developers deal with this array of Android versions?
When you develop an app for an old version of Android, it will run without errors on all newer version of Android, unless you do something involving low-level stuff like direct kernel calls, but you will never encounter such issues if you only use Java.
Worst issue you'll see is your app visual style looking outdated on newer devices.
If you target API level 23 / Android 6.0 Marshmallow, you will still need to run your app on Android 6.0 emulator, to be sure that it won't crash when using new Android permission dialogs to ask for SD card access etc.
I have an Android device, apparently with API Level 10.
I'm developping an Android Application and I need to test it on API level 12.
I don't know much about Android and API levels, so my question is: Can I update my device to a higer API level ? (it says no New version available, aren't hier APIs considered new version?)
(I can't use the Emulators, as they really need a huge amount of ressources to start.)
Alternatively, is it possible to test the following code, on my API Level 10 device ?
UsbManager manager = (UsbManager) this.context.getSystemService(Context.USB_SERVICE);
I have the following warning:
Yes higher API levels = latest releases.
http://en.wikipedia.org/wiki/Android_version_history#Version_history_by_API_level makes the correlation between API and version number (2.3.4).
You should work with a device supporting latest api and high resolution because many of your users might have that and you NEED as a developer to see and test your work on these platforms.
Get yourself a nexus phone, you can upgrade these to the latest Android version.
Android version release : Google releases it --> manufacturers and Telecom Carriers checks and adjust the release before making it available to you. Hence, for old phone, the manufacturers and carriers don't make the effort and you are stuck to old versions.
If you do no want to or if you cannot find a more recent handset, you can install a custom ROM to try to reach API 12. But in any case, if you start developing, you ll need good handset soon.
good luck
You can try to see if there is a custom rom for your device that is of a higher api version. But this won't accurately test your app because there is probably a very good reason that a newer operating system was not made available for your device. As such, your app and the SDKs in the new API will probably not be able to make use of the hardware resources available, and you won't get an accurate representation of your app's performance.
You mentioned you can't use emulators but have you considered Genymotion's emulators? Although it is resource intensive it is better than Google's emulators and is faster than actual devices.
Assuming your using Eclipse ADT. You DONT have to update your device to level or API 12. All you have to do is specify the minimum required SDK, which is API 8 in most Eclipse ADT setups. and set your target SDK to API 12. That way your app will run on devices from API 8 through to API 12 Including you device. FYI the latest API is now 19 (Android 4.4) Hope this helps.
I am trying to test my app and I have lots of problems with Android emulators. Finally, I got one emulator running using Android 2.2 . So I used this one and my app works fine.
I also tested my app using real device, Nexus 7 , Android OS 4.2. App works fine in both versions.
It is safe to consider my app will run fine for OS versions within 4.2 - and 2.2 band? The reason I am asking is because using emulator makes my computer very slow and it takes forever.
In the best case: yes. In worst case: no. It completely depends on the parts of the Android API you're using in your app. For example, private APIs might very well break or change. You should be fine with public APIs, but there's always the chance of a bug in one of the OS versions...
If you want to test your app on various devices and Android versions, you should give apkudo.com and testdroid.com a try.
You can also try https://www.elusivestars.com it allows you to select devices based on specs like OS version, brand... and offering 5 free reviews
I have heard good things about testflightapp, they used to be iOS only and now doing Android.
Something like http://www.perfectomobile.com/ might also be a good way to go.
Here is a list of tools, including test tools
http://www.apptamin.com/blog/app-developer-tools/
Cloud based real device testing is typically either devices you can access and manipulate/automate or users with devices. Personally I think starting with automated testing then finishing off with real user (usability testing) may give you good coverage.
I am the Founder of elusivestars
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 have an application developed using Android 2.2 SDK. Can i port it on HTC Hero running Android 1.5?
Thanks
Dheepak
In theory yes, but you haven't given us enough information. Most of the API is largely the same so it may work simply by changing the "target" to whatever the 1.5 API level is. But it also may require hours upon hours of work if it relies heavily on API calls that are new to any version of Android after 1.5. It depends entirely on what the application does and how it does it.
We simply don't have enough information to give you an answer that is worth anything.
My suggestion would be to just change the compile target to Android 1.5 (I think the API level is 3...but I'm not sure) and see what happens. You can then go about fixing the errors that are reported. I would suggest looking through the errors though to make sure it isn't some fundamental problem with the calls you're using.