I am using the Google SafetyNet API to detect device tampering in my application. Reference:: https://developers.google.com/android/reference/com/google/android/gms/safetynet/package-summary
But I cannot find any reference to the minimum support OS version. I thought I read somewhere that it was 7.0 but can't find that now.
It used to say "since" in the API docs, which was useful to tell the requirements but that seems to have disappeared.
What is the earliest version of Android that SafetyNet will work on, as supported by Android? Thanks.
All Play-enabled Android devices using Android 2.3 and above already use SafetyNet as long as the Play Services package is updated.
here
As mentioned in the prior response, Android 2.3. is the minimum supported version. However it should be noted that prior to Andoird 6.0, the SafetyNet could not read the device's bootstate, limiting the effectiveness of SafetyNet.
See Slide 50
Related
I'm working on an Andriod Studio project and I'm trying to use the Google Cloud Vision API. I've been trying to figure out if I can use it since my target sdk is level 15-25, but I can't find the minimum required sdk level anywhere in the documentation.
The only information relevant to this that I found was the only sample application on their website and it says under prerequisites "
An Android device running Android 5.0 or higher 1
That doesn't necessarily mean it doesn't work for lower API levels. Does anyone know what's the minimum requirement?
According to this link vision API depends on the Google Play Services which are curently available for Android 4.0 and above. So for now I think you can continue using the API for your min SDK version 15.
But on a long run there will be many more cool features that will added to lollipop and above only. So the question is, do you want support or quality? Either comprimise the quality for the devices which has 4.0 or focus on quality by building for 5.0 and above because soon devices below 5.0 are going to be obsolete.
I am thinking to make an application but at the time I don't have API 21 and API 22 installed on my SDK due to some network problems and I'm unable to download any thing at the moment. I was wondering if I can make an app effective enough to target many devices without using API 21 and API 22.
Bilal, judging from your comments to others, I'm getting the impression that you don't fully understand how the API levels work in Android. Let me try and explain.
The minimum API level is pretty self-explanatory, as it refers to the minimum Android OS version that can run your app. You want to set this as low as possible to target the most devices. To determine which level you set depends entirely on your application. For example, if your app requires access to the Calendar APIs, your minimum API level would be 7, because that is when those APIs were introduced.
You almost always want to set your maximum API level to the highest possible. Google encourages this, because it allows you to take advantage of all of the new APIs that have been released. But what about the devices that are outdated? You can still enable backwards compatibility with those devices using the Support Library.
Finally, it is not necessary to download each and every API level in the SDK manager. You only need to download the most recent.
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.
Should I use the latest 4.0 or 2.3? My phone has android 2.3.5 and it's a HTC Desire HD.
Does the runtime matter or will the applications work still?
First you should choose what device versions you'd like to target: http://developer.android.com/resources/dashboard/platform-versions.html
Based on those numbers it makes sense to currently support Android 2.1 and higher.
Also you should read about <uses-sdk> directive:
android:minSdkVersion and maxSdkVersion define the version range to which your app will be available. If device has Android version out of this range then app will not be visible for it.
targetSdkVersion is the vesrion that you are targeting and that you actually tested against. This attribute triggers Android's compatibility behavior: for instance targeting 2.3 will not show the new look on 4.0 devices.
I think this url will be helpful :
http://developer.android.com/resources/dashboard/platform-versions.html
All versions of android are backward compatible which means that an application designed to work with 2.0's api will work on 4.0 so it basically comes down to whats your target customers. there's still a vast majority that uses 2.x (unfortunately) so it is probably smart to develop for 2.1 and up..
but anyway this is a pretty common question and i'm sure google will produce a lot of useful information in the subject.
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.