Note: There is a question with a similar title however this is not a duplicate. If you wonder what question that is: question link The option is already enabled in my IDE.
Recently we have updated an app with some bug fixes but one of the changes caused a critical crash, depending on a method that has been added in API 29, and Android Studio didn't warn me about it which led to an unavoidable crash at user base.
If you wonder, I also have API 29 documentation downloaded in IDE, so I can see the sources, javadocs in it.
The method I've used is Parcel.writeBoolean(val) method. According to the documentation, this was added in API level 29 (I don't know why it's added this late but it was), however this is how it looks when I use it in the IDE. (Minimum API version is 21)
There are no warnings about the API usage. Hence I casually used it and it lead to a huge crash rate in our app.
Is there a way to check every method based on its API level? On normal cases (such as using Context.getSystemService(Class clazz) the IDE gives a warning that it is added in API level 23) it seems to be working, but on really newly added methods, it sometimes skips the warning.
Do I need to check every Android framework based method before using it? Or is there something that do this task properly? Any help is appreciated, thanks.
Well, apparently I had an old version of Android Studio (3.5.1), updating it to 3.6.1 solved the issue.
Related
I am dealing with an app that has android:sharedUserId value in Manifest,
and there was an issue regarding permission triggered by this android:sharedUserId value.
While trying to solve the problem, I checked out that anderoid:sharedUserId was deprecated in API level 29 (Android 10).
So now I would really like to remove this sharedUserId from the application. (permission problem in API 29 + deprecated in API 29)
As I tested in debug mode, it seems that complete uninstall and reinstall is required after removal of sharedUserId... and It "seems" that there is not much problem else than that.
But I cannot assure that it is really safe to delete this property and release an update on market.
This IssueTracker Thread created in June, 2019 is about this issue, but does not give detailed instruction on how to remove sharedUserId safely from an application.
Would deleting android:sharedUserId without any other modification end up with a critical problem?
If so, does anyone know an appropriate way to remove sharedUserId from Manifest file and safely release an update version?
OK, I just checked out the documentation again in original English version... and found out this sentence was omitted in Korean translation.
Note that existing apps cannot remove this value, as migrating off a
shared user ID is not supported.
So sharedUserId drives out problems in Android 10 (obviously in my case), and there is no way to remove it. Did I get it right?
If so... well... I find this very surprising... and disappointing...
This wasn't possible, but Android introduced a solution for this in sdk 33. It's called the android:sharedUserMaxSdkVersion attribute. It's only available in android 13. The documentation says:
The maximum device SDK version for which the application will remain in the user ID defined in sharedUserId. Used when the application wants to migrate out of using shared user ID, but has to maintain backwards compatibility with the API level specified and before.
So I think you should define: android:sharedUserMaxSdkVersion="29". But I'm not completely sure yet how this option should be interpreted.
I've noticed after the update to Android Studio 3 (but it could be happened also before and I didn't noticed) that some deprecated methods are not marked any more with a line-through. For example:
I'm on Ubuntu, Android Studio 3.0.1 just updated. I checked inspections in the settings, and it's all enabled. I also checked that the code style/formatting is correctly set-up for deprecations (but it had to be, given the last line of the example is correctly marked). It's not something project-related, since I tried on a freshly created project.
What can cause this?
I finally discovered that this is (strangely) the intended behaviour: https://issuetracker.google.com/65793314
What's your minSdkVersion? It's a feature that we now only show deprecated method calls as deprecated if they're deprecated for all the versions you're trying to target
So, getColor() and isAnimationCacheEnabled() are not marked in my example because I'm targeting API 15+, and instead they're deprecated as of API 23. I confirmed this raising my app's minSdkVersion to 23, and they are all marked now.
Anyway I find this behaviour confusing and unnecessary, like I said in the bug report. If someone read this and agrees, please leave a comment there.
I'm just wondering, if the latest Android SDK installed on a device contains code of all the previous versions as well?
So if I target API level 10 in my app and install it on a device with Lollipop, will it just take and use Gingerbread SDK exactly as it was 3 years ago?
Or is there just one codebase for all versions with a lot of checks and switches which is then run by some kind of compatibility mode picking the correct code and enabling methods of the version of SDK I target?
I read the article about android:targetSdkVersion specified in Manifest but still would like to know how this works internally.
Ok, I just surfed a bit around on the source code (which you can find here: https://github.com/android/platform_frameworks_base). I'm not an engineer of the Android framework, I was just curious about your question and here is what I found.
It does not contain all the different versions of source code. You can imagine that this would result in a nightmare if more and more versions become available. Foremost, you would have different (buggy) versions of the same method without fixing them just to keep them the same.
In the source code, you can find places like these: (see https://github.com/android/platform_frameworks_base/blob/59701b9ba5c453e327bc0e6873a9f6ff87a10391/core/java/com/android/internal/view/ActionBarPolicy.java#L55)
public boolean hasEmbeddedTabs() {
final int targetSdk = mContext.getApplicationInfo().targetSdkVersion;
if (targetSdk >= Build.VERSION_CODES.JELLY_BEAN) {
return mContext.getResources().getBoolean(R.bool.action_bar_embed_tabs);
}
// ...
return mContext.getResources().getBoolean(R.bool.action_bar_embed_tabs_pre_jb);
}
So the Android developers do the version check in the code where necessary. But these checks are not as necessary as you think (I guess). What's the reason for changing a method?
method is buggy: All they need to do is fix the bug. Tests will make sure that the general behavior of the method keeps the same
method is deprecated: The guys can not remove the method, all they can do is mark it as deprecated and hope for the best. Compilers will do the rest.
method behavior has to change: Well, I guess that is something they can not do easily. They can work around with version codes (which is pretty ugly and becomes a maintenance nightmare), or they just introduce a new API. That's the reason why you'll find a lot of APIs just doing the same
If you have write down a code with latest android sdk and install it in your device. It means actually you are using latest android.jar(you can see android.jar in your project) file while compiling/Executing code.
Now If you install your application in ginger bread device then android.jar(latest) has a backward compatibility(if required) to run code in Gingerbread device.and if you define target sdk version 10 and running app on Higher API level ,then it will run smooth except your compatibility behavior disable in respective device other than targeted devices.
I want to call the Method setLayerType of the View Class in a Mono for Android application. Unfortunatley I cannot access (or even see) the method. According to Mono Documentation everything should be there.
Can somebody help me with this?
Thanks,
faiko
I had the same problem. You can fix this under your project settings choose "Minimum Framework Version to Target" of Android 3.1 or higher. This has nothing to do with your minimum/target API level in your manifest.
After changing that, you will have to restart Visual Studio (or reload the project in question) and you'll notice it now references the v3.1 assembly of Mono which has some new APIs exposed.
You'll still want to wrap the call to this API around a version check like:
if (Build.VERSION.SdkInt >= BuildVersionCodes.Honeycomb) if your minApiLevel is less than 11.
I have an app to release which works on all android screen-sizes (except smaller) and densities above SDK version 2.0.
It will also run on extra large screens.
Currently I have added this:
<supports-screens
android:largeScreens="true"
android:normalScreens="true"
android:smallScreens="false"
android:anyDensity="true"
/>
But I also need to add android:xlargeScreens="true" , to allow it visible in android market on extra large screen devices, since by default it is false.
But to add android:xlargeScreens I need to change my eclipse targetsettings to 2.3 as this attribute was added from API level 9.
So what should I do with my target compilation settings for this scenario ? Should it be 2.3 while compiling ? If yes, then will the app not give any problems while running on devices with 2.0 version ?
Yes you need to change the uses sdk to 2.3 but make sure that you are not using any newer apis which are not in 2.0 or whatever your minimum supported sdk version is. Or in case you want to use them you have to use reflection.
But more about how to use the sdk versions is here and more about uses-sdk is here.
I do the same in my application and make sure you test your application in both[all] the versions before you release.
Best,
Achie.
I'm moving this from the comments to make it more clear for others looking at this question in the future.
When supporting both old and new versions of Android it can be confusing how applications manage to run despite many things change with in the frameworks during each new release, I'm going to try and clarify this here.
An application written for the 1.5 sdk can only call functions that exist for that API level, so for instance the multi touch api's didn't exist in 1.5 and never will. Now you say "Ok but I don't need to call any newer APIs, I just want my app to work in 2.3 and have a2sd support" And I say "Ok, just change your targetApi in the manifest, set the minSDK and compile against 2.3 and you're good to go."
Now why does that work? What if the onMeasure() method for ListView was changed in 2.2 and now calls betterCalculateFunction() within onMeasure()? Why does my app still work?
This is the advantage of late binding in Java. You see, Java is never compiled until it reaches a device and is running, what you are doing in Eclipse is converting it to byte code which contains a bunch of byte code instructions that are later interpreted by the device. The byte code will NEVER contain a reference to betterCalculateFunction() though (unless you directly call it. Calling onMeasure() is indirect). This can happen because when your code is running on the device it gets linked against the Android framework on the device and your code calls onMeasure() directly because it is a public outward facing API. The path of execution will then enter the framework and call whatever it needs to, then once its done return to your code.
So on 1.5 you might see
doStuff (your code) -> onMeasure
(public API) -> done
and 2.2
doStuff (your code) -> onMeasure
(public API) ->
betterCalculateFunction (private
function) ->done
Now if you need to call functions that may or may not exist depending on API level then I suggest you look at a related answer of mine here stackoverflow: gracefully downgrade your app
Hope that clears some things up.
I haven't tried 2.3, but that's what I do with 2.2.
I compile for 2.2 and test on 1.6 to make sure everything works how I'm expecting. I haven't run in to any issues with it.
To double check, set your target for 2.3 and then setup an emulator for a lower rev version to make sure it all works.
The default value for android:xlargeScreens is true, so you don't have to change anything - it's on by default, as long as your minSdkVersion or targetSdkVersion is higher than 4.
http://developer.android.com/guide/topics/manifest/supports-screens-element.html
Here is an official Android developer blog explanation of how this works:
http://android-developers.blogspot.com/2010/07/how-to-have-your-cupcake-and-eat-it-too.html
In summary: you can use the newest XML whilst still supporting the older OS versions in a back compatible way.
While reading this blog post I guess I have an answer on my old question. An extract below (which is for another manifest attribute "requiresSmallestWidthDp" introduced from 3.2):
"The catch is that you must compile your application against Android 3.2 or higher in order to use the requiresSmallestWidthDp attribute. Older versions don’t understand this attribute and will raise a compile-time error. The safest thing to do is develop your app against the platform that matches the API level you’ve set for minSdkVersion. When you’re making final preparations to build your release candidate, change the build target to Android 3.2 and add the requiresSmallestWidthDp attribute. Android versions older than 3.2 simply ignore that XML attribute, so there’s no risk of a runtime failure."
For different screens you have to create multiple apk then it reduces size of your application.In each application's manifest you have to define according to following link.
http://developer.android.com/guide/practices/screens-distribution.html