AndroidManifest

One of the most important components of your project. Stays in the root directory of the project source. This is used to describe essential information about the app to Android Build Tools, Android OS and Google Play.

Most important things for which AndroidManifest is used:
  • To declare app’s package name: Used by Android build tools to map code entities and to map it with applicationId defined in build.gradle
  • To declare different app components: Include all activities, services, broadcast receivers, and content providers
  • To declare app permissions: Helps in accessing specific restricted by System or other apps.
  • To declare hardware and software features: Used to decide which device can app be installed into
  • Package name and application ID
Example
<?xml version="1.0" encoding="utf-8"?> 
     <manifest 
        xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.example.myapplication" 
        android:versionCode="1" android:versionName="1.0"> 
     ... 
    </manifest>

How is package attribute used by Android build tools?

  • Used as a namespace for the generated R class of the project. E.g com.example.myapplication.R
  • Resolve relative names of components declared in the file. E.g <activity android:name=“.FirstActivity"> is resolved as com.example.myapplication.FirstActivity
  • When building the final APK, the build tool replaces packageName with applicationId declared build.gradle file. This is then used to uniquely identify the app at system and google play level.
  • Avoid changing the package attribute once the project is packaged

App components

Tags to declare different app comments:

  • <activity> for each subclass of Activity
  • <service> for each subclass of Service
  • <receiver> for each subclass of BroadcastReceiver
  • <provider> for each subclass of ContentProvider

Things to note:

  • Declaring an app component is a must unless it cannot be started by the system (i.e your app will crash while trying to open the non declared component.
  • android: name is a must. The value should be a full package destination.
  • If the component is part of same package full package name can skipped ie. <activity android:name=“.FirstActivity”> format can be followed
  • If the component is part of sub-package (com.example.myapplication.training) then the name attribute must add missing path i.e <activity android:name=“training.TrainingActivity”>

Intent filters

Read https://www.linkedin.com/pulse/android-intent-filters-tech-shift for details

Icons and Labels

Displays a small icon and the text for the corresponding app component. Set using android:icon and android:label attributes.

Things to note:

  • The value set for icon and label in parent tag becomes default for child tag. For e.g these attributes set in <application> tag are default values for <activity> tag.
  • The icon and label set in <intent-filter> is displayed in the chooser dialog shown to the user. This help in providing better visual display of functionality of that choose option.

Permissions

A way to let application access user sensitive data (contacts, SMS) and some restricted features of Android System (Camera, Bluetooth).

Defined using <user-permission> tag and using android:name attribute which can be uniquely identified.

<manifest ... > 
    <uses-permission android:name="android.permission.SEND_SMS"/> 
     ... 
 </manifest>

Things to note:

  • Starting Android 6.0 (API level 23) permissions will have be requested at runtime. This means user can accept or cancel as per their wish. So app should be able to handle both these scenarios.
  • Apps can use the permissions defined in Android framework or permissions from another app or can defines its own permissions.
  • A new permission is declared using <permission> tag.

Device compatibility

With a lot of Android devices in market with different hardware and software support this feature of Android Framework plays a very important role allowing developers to select only those devices which have those features which very much required for the application.

<user-feature> - Specifies the hardware and software feature required by the application.

<manifest ... >
    <uses-feature android:name="android.hardware.sensor.compass" android:required="true" />      ... 
 </manifest>

<user-sdk> - Specifies the minimum sdk version with which app is compatible. Those this is not the ideal place to add this info as these information should be mentioned in build.gradle file.

<manifest ... >
    <uses-sdk 
        android:minSdkVersion="integer" 
        android:targetSdkVersion="integer"
        android:maxSdkVersion="integer" />
     ... 
 </manifest>

Note if user’s device does not have satisfy these conditions system will not allow it.


Example of AndroidManifest file


Resources

https://developer.android.com/guide/topics/manifest/

Location: India

Comments

Post a Comment

Popular posts from this blog

Fragment Lifecycle

Image
Just like Activities, Fragments also manages its own lifecycle. Though these lifecycle callbacks are a bit different than activity’s callbacks they exist for the similar reason as that of activity’s callback. Fragment manages two different lifecycles. One for the fragment instance and other for the view shown in the fragment. Having different lifecycle for fragment’s view is useful in the situations where the work should be performed only when view exists. Points to note: Fragment lifecycle call-backs are similar to Activity’s lifecycle. More important they are dependent on Activity’ state. Fragment manages 2 different lifecycles - Instance and View. Fragment callbacks are: onAttach, onCreate, onCreateView, onViewCreated, onViewStateRestored, onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach Fragment state is saved before onStop for API level less than 28 while in API level 28 and above its saved after onStop method. i.e In API level 28 or above devices its safe to...
Read more

Activity Lifecycle

Image
To let Android System interact with Application different methods are defined by the system which communicate different states of the activity to the application. Those methods/states are called as Lifecycle Callbacks. Activity can go into different combination of these states. In the code each callback is used to understand the state in which the activity is in and accordingly perform different operations. Let’s discuss different activity callbacks and what each of them represent in real life scenarios. You will find each section explained with the 3 labels. Let us see what each label represents: Called: It will tell you when is this method called. Implement: What should be implemented in this method. State: What is the state of activity from user's perspective.                         onCreate() Called: This is the first callback received in Activity which is called as soon as the system creates the Activity. Implement: Used ...
Read more