I have experience in java and I was thinking in starting developing for Android now. Trouble is I have an Android Phone with 2.1-update1 and an Eee Pad Transfomer with 3.1 and I would like to build applications that could work on both devices.
When creating a project in eclipse, I need to choose the Build target, but I can only choose one, so do I choose one that is compatible with both devices or I need to separate projects for different build targets?
If you set up Eclipse to compile with Android 2.1, then it will run on 3.1 too. Most Android API's are backward compatible.
<uses-sdk android:targetSdkVersion="7" android:minSdkVersion="3"/>
In Manifest file, set the "uses-sdk" version to API number matching your Version 2.1 (it's 7, Honeycomb 3.1 is 12)
Set minSdkVersin to whatever you desire (API level 3 is OLD Android 1.5)
Do not set maximum if you want to support future updates of Honeycomb, ignore Warning related to this at build time.
http://developer.android.com/guide/appendix/api-levels.html
Just Use the lower version as target.
Related
I'm downloading Android SDK , and want to know if Android's APIs has compatibility with its
Previous versions ? i.e. if i installed Android API 16 can I use the application on
Android 4.0 (API 14) ?
You can run older API versions on newer systems, but not vice-versa. For example Android 4.0 can run programs made for Android 2.3.3, but Android 2.3.3 can't run Android 4.0 programs.
You have to define a minimum sdk level in your android manifest. Every version from this upwards supports the app. You can only use classes and language elements that are supported by this specified version.
This is controlled by the following in your manifest file:
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="15" />
This means:
1) your app won't run on any Android whose version < 8.
Android OS whose version < 8 will not let your app be installed.
2) Your app is using Android API as of Android version 15.
In your code you can, however, check the Android version (using Build.VERSION.SDK_INT) and if it is < 15 then do not run certain code.
This is often done so the app can use newer features if run on newer Android versions yet it can run on older versions as well.
Not all components are backwards compatible, but for backwards stuff, look at the following
I found the most useful library out there for making an android app backwards compatible.
Its called Actionbarsherlock, it gives you all android 4.1+ functionality all the way back to 2.1 (what i am developing as a min version)
Its fairly simple to use, very well explained on their website:
http://actionbarsherlock.com/
Enjoy
I set up my project to use Android 3.2 (API Level 12), but it seems like a lot of phones are still using Android 2.2 (API Level 8).
Is there a way to change my project from only supporting Android 3.2+ to supporting back to Android 2.2?
yes...just change the minsdk number in the manifest. You have to be sure that you don't use any feature that is not supported though...
in your AndroidManifest.xml add this line:
<uses-sdk android:minSdkVersion="8" android:targetSdkVersion="16" />
android:minSdkVersion tells the Store what the minimum version you are targeting is. In this case 2.2. Devices less than 2.2 won't be able to download your app.
android:targetSdkVersion tells the store what the best version you are developing for is. In this case 4.1. Devices over 4.1 can still download your app but certain features may run in compatibility mode.
NOTE: When you setup your project to use 3.2, all you did was select the Android SDK you wanted your IDE to use when checking and compiling your code. Without the uses-sdk line in your manifest you've targeted nothing.
Right Click Project -> Properties -> Android -> Select SDK version
Update Manifest, min/target api. (as others have described by others).
Go to your Manifest.xml file and edit the minSdkVersion to 4. That will set it way back to 1.5 or something like that :). You can make that number higher if you want to suit a higher API, but I like compatibility.
I've been writing my first android app and so far have just been building against the highest android SDK available - 4.1. Up until this point I have only been testing on a physical device running 4.03 and everything seems to work fine.
I would like my min SDK level to be level 8 (2.2) and as far as I know I have not used anything from the APIs higher than this.
However if I build against 4.1 and run on a 2.2 emulator it just shows a white screen and no crash (OpenGL based so something going wrong with this). The same build runs fine on a 4.1 emu and my 4.03 device.
If I build against 2.2 with the exact same code it runs on the 2.2 emu fine.
I don't really know what could be causing this so any tips would be great. Do some classes get replaced in the newer APIs? If they were removed entirely I would assume it just wouldn't build at all against the new version.
Should I be setting my build target equal to my minimum? I am not using anything from the APIs higher than 2.2 currently but I was under the impression I should be building against the newest SDK available. Are there any negative effects of building for the lowest version for instance does it affect the look of the menus/dialogs?
Any help is appreciated, thanks.
You should build against the lowest SDK version you intend to be supported by your app (e.g., if you want to support users don't having the newest smart phones or tablets, building against the newest SDK version wouldn't be a good idea).
Generally, newer SDK versions only include additional classes and functions, but I am not 100% sure about any removed classes.
add this to your AndroidManifest.xml
<uses-sdk
android:minSdkVersion="7"
android:targetSdkVersion="15" />
I've built an Android application in eclipse. Before starting the project I selected the 2.3.3 api. The code is very basic.
A friend of mine asked to have a copy, but he's using 2.2, do I have to rebuild the project in 2.2 or will it work just fine if I send him the APK build with the 2.3.3 api?
change
<uses-sdk android:minSdkVersion=.... />
in the android manifest to
<uses-sdk android:minSdkVersion="8" />
Change the Project Build Target to 2.2, in the Properties Menu of your project in the Android drill down.
You should only get errors if you used methods that were introduced with the level 10 API (Android 2.3.3). Since you pointed out that your application is very basic, I highly doubt you'll run into major problems.
From the docs
Selecting a platform version and API Level
When you are developing your application, you will need to choose the platform version against which you will compile the application. In general, you should compile your application against the lowest possible version of the platform that your application can support.
You can determine the lowest possible platform version by compiling the application against successively lower build targets. After you determine the lowest version, you should create an AVD using the corresponding platform version (and API Level) and fully test your application. Make sure to declare a android:minSdkVersion attribute in the application's manifest and set its value to the API Level of the platform version.
So in short, you'll have to recompile it
If you go to the properties for your project and then select the Android dialog, you can change the API which your project is using. Provided you have have it installed.
In the AndroidManifest file set android:minSdkVersion to 7. In this way you force it to run in compatibility mode on devices that have lower version than the target mode(which is 8 in your case).
I'm building an application, and need to support both 1.5 (Magic and Hero) and 1.6 (Tattoo) devices.
As Android SDK is forward compatible, it seemed logical to build against Android 1.5 SDK, and expect application to work on Tattoo.
While that's true, (I tested app, it works ok), I'm now having problems on Android Market.
On Tattoo, Market search by default filters android apps that doesn't have explicit support for small screens defined in AndroidManifest.
Problem is that attribute exists only on Android 1.6 SDK, so Building against Android 1.5 SDK is no an option anymore.
How safe is to build App agains A1.6 (with minSdkVersion="3") and run it on 1.5 devices?
Is there anything else I should take care of except just change target SDK?
Make sure you don't mix up minimum SDK version and target SDK version as these are different options.
For example, I use the following setting in the application for my manifest:
<uses-sdk android:minSdkVersion="3" android:targetSdkVersion="4"/>
The documentation says the following about targetSdkVersion:
In some cases, this allows the application to use manifest elements or behaviors defined in the target API Level, rather than being restricted to using only those defined for the minimum API Level.
So by specifying targetSdkVersion of 4 but having a minimumSdkVersion of 3 you'll have an application which should work on 1.5 devices and 1.6 small screen devices.