Android Manifes File

Fayyaz Muhammad
Sources: developer.android.com, The Internet and various Books.
When developing an Android app, there is a critical component that plays a pivotal role in defining
your app’s identity, permissions, and behavior—the Android Manifest. The manifest file describes
essential information about your app to the Android build tools, the Android operating system,
and Google Play.
The Android Manifest file is a fundamental component of every Android application. It serves as
a blueprint that defines various aspects of the app's behavior, requirements, and interactions with
the Android operating system and other applications.
The Android Manifest is an XML file that serves as a blueprint for your Android app. It acts as a
declaration file, providing vital information to the Android operating system about your app’s
structure, components, permissions, and more.
The manifest file is the foundation for any Android application. Every application must have an
AndroidManifest.xml (exact like here given name) file in its root directory. The manifest presents
essential information about the application to the Android system, information the system must
have before it can run any of the application’s code. The manifest file organizes an Android
application into a well-defined structure that is shared by all applications and enables the Android
operating system to load and execute them in a managed environment.
Its hierarchical organization and defined elements give the Android system the necessary details
to properly install, manage, and interact with your app. Understanding the structure and content
of the Android Manifest empowers you to shape your app's behavior, permissions, and
interactions with other components and apps.

Purpose of the Android Manifest File

The Android Manifest file, typically named AndroidManifest.xml, is a critical file in Android app
development. Its primary purposes are:
App Identification—The manifest file identifies the app to the Android operating system,
providing essential information such as the app's package name and version code. This
information is crucial for the system to manage and update the app.
Permissions—It specifies the permissions required by the app to access device resources or
interact with other apps. Android enforces these permissions to protect user privacy and security.
Android apps must request permission to access sensitive user data, such as contacts and SMS,
or certain system features, such as the camera and internet access. Each permission is identified
by a unique label. For example, an app that needs to send SMS messages must have the following
line in the manifest:
<manifest ... >
<uses-permission android:name="android.permission.SEND_SMS"/>
...
</manifest>
App Components—The manifest defines the app's components, including activities, services,
broadcast receivers, and content providers. These components are the building blocks of an
Android app.
For each app component that you create in your app, declare a corresponding XML element in
the manifest file:
<activity> for each subclass of Activity
<service> for each subclass of Service
<receiver> for each subclass of BroadcastReceiver
<provider> for each subclass of ContentProvider
If you subclass any of these components without declaring it in the manifest file, the system can't
start it.
Specify the name of your subclass with the name attribute, using the full package designation.
For example, an Activity subclass is declared as follows:
<manifest ... >
<application ... >
<activity android:name="com.example.myapp.MainActivity" ... >
</activity>
</application>
</manifest>
However, if the first character in the name value is a period, the app's namespace, from the
module-level build.gradle file's namespace property, is prefixed to the name. For example, if the
namespace is "com.example.myapp", the following activity name resolves to
com.example.myapp.MainActivity:
<manifest ... >
 <application ... >
<activity android:name=".MainActivity" ... >
...
</activity>
</application>
</manifest>
If you have app components that reside in sub-packages, such as in
com.example.myapp.purchases, the name value must add the missing sub-package names, such
as ".purchases.PayActivity", or use the fully qualified package name.

Intent Filters—Intentions turn on services, broadcast receivers, and app actions. An intent is a
message specified by an intent object that specifies an action to be taken. It includes information
about the data to be acted upon, the type of component that should carry out the action, and
other directives. Based on intent filter declarations in each app's manifest file, the system
determines which app component may handle an intent when an app issues one to the system.
The matching component is launched by the system, and it is provided with the Intent object. The
user can choose which app to use if more than one app can handle the purpose.
App activities, services, and broadcast receivers are activated by intents. An intent is a message
defined by an Intent object that describes an action to perform, including the data to be acted
on, the category of component that is expected to perform the action, and other instructions.
When an app issues an intent to the system, the system locates an app component that can
handle the intent based on intent filter declarations in each app's manifest file. The system
launches an instance of the matching component and passes the Intent object to that component.
If more than one app can handle the intent, then the user can select which app to use.
An app component can have any number of intent filters (defined with the <intent-filter>
element), each one describing a different capability of that component.
It declares intent filters for components, which specify the types of intents they can respond to.
This allows other apps and the system to interact with the app's components.
Icons and labels
A number of manifest elements have icon and label attributes for displaying a small icon and a
text label, respectively, to users for the corresponding app component.
In every case, the icon and label that are set in a parent element become the default icon and
label value for all child elements. For example, the icon and label that are set in the <application>
element are the default icon and label for each of the app's components, such as all activities.
The icon and label that are set in a component's <intent-filter> are shown to the user whenever
that component is presented as an option to fulfill an intent. By default, this icon is inherited from
whichever icon is declared for the parent component, either the <activity> or <application>
element.

App Configuration—Various app configurations, such as screen orientations, supported screen

sizes, and minimum Android API levels, are specified in the manifest.
App Icon and Label—The manifest defines the app's launcher icon and label, which appear on
the device's home screen and app drawer.

Structure of the Android Manifest File

The Android Manifest file is written in XML (eXtensible Markup Language) and follows a specific
structure. Here's a breakdown of its key elements:

XML Declaration—The Android Manifest starts with an XML declaration that specifies the version
of XML being used.
<?xml version="1.0" encoding="utf-8"?>
<manifest> Element—This is the root element of the manifest file. It contains essential attributes
like package (the app's unique identifier), versionCode (an integer representing the app's version),
and versionName (a human-readable version string).
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.myapp"
android:versionCode="1"
android:versionName="1.0">
The xmlns:android attribute defines the XML namespace for Android-specific attributes used
throughout the manifest.
The package attribute identifies your app’s unique package name.
Application Element—Inside the <manifest> element, you’ll find the <application> element. It
represents your app as a whole and contains various components and settings.
<application
android:icon="@drawable/app_icon"
android:label="@string/app_name">
The android:icon attribute specifies the app’s launcher icon.
The android:label attribute sets the app’s display name.
Activity Elements—Activities represent the individual screens or user interfaces in your app. Each
activity is declared within an <activity> element inside the <application> element.
<activity
android:name=".MainActivity"
android:label="@string/main_activity_title">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
The android:name attribute specifies the activity’s class name.
The android:label attribute sets the activity’s display name.
The <intent-filter> element defines the actions and categories associated with the activity,
including the "MAIN" action and "LAUNCHER" category for the app’s entry point.
Permissions—Permissions are declared within the <manifest> element to define the access rights
required by your app.
The <uses-permission> element declares a permission that your app needs, such as accessing the
device’s fine location. The <uses-permission> element is used to declare permissions required by
the app. For example, if your app needs access to the device's camera, you would include the
following: <uses-permission android:name="android.permission.CAMERA" />
App Components—Various components like activities, services, broadcast receivers, and content
providers are defined within the manifest. Each component has its own XML element. For
instance, an activity is defined as follows:
 <activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
In this example, the <activity> element declares the MainActivity class as an activity, and the
<intent-filter> specifies that it should be the launcher activity.

Intent Filters—As shown in the activity example above, intent filters are used to specify the types
of intents a component can respond to. In the case of activities, the MAIN action and LAUNCHER
category indicate that this activity is the app's main entry point.

App Configuration—The <application> element contains app-wide configuration settings, such as

the supported screen orientations and theme:
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme">

Android Manifest File Example

Here's a simplified example of an Android Manifest file for an imaginary "ToDoList" app:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.todolist"
android:versionCode="1"
android:versionName="1.0">
<!-- Required Permissions -->
<uses-permission android:name="android.permission.INTERNET" />

<!-- App Components -->

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme">

<!-- Main Activity -->

<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>

<!-- Settings Activity -->

<activity android:name=".SettingsActivity" />

<!-- Background Sync Service -->

<service android:name=".SyncService" />

<!-- Broadcast Receiver -->

<receiver android:name=".AlarmReceiver">
<intent-filter>
 <action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>

<!-- Content Provider -->

<provider
android:name=".TaskProvider"
android:authorities="com.example.todolist.provider"
android:exported="false" />
</application>
</manifest>

Elements Used in Android Manifest File

<manifest> Element—The root element of the manifest file. Contains metadata about the app,
such as its package name, version code, and version name.
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.myapp"
android:versionCode="1"
android:versionName="1.0">

<service> Element—Declares a service component. Specifies the service's name and attributes.
<service android:name=".MyService" />

<receiver> Element—Declares a broadcast receiver component. Specifies the receiver's name

and intent filters.
<receiver android:name=".MyReceiver">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
 </intent-filter>
</receiver>

<provider> Element—Declares a content provider component. Specifies the provider's name,

authorities, and other attributes.
<provider
android:name=".MyProvider"
android:authorities="com.example.myapp.provider"
android:exported="false" />

<intent-filter> Element—Used within <activity>, <receiver>, and <service> elements.

Specifies the types of intents that the component can respond to.
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

<meta-data> Element—Allows the app to include metadata that can be retrieved

programmatically.
<meta-data
android:name="com.example.myapp.api_key"
android:value="your_api_key_here" />

<uses-feature> Element—Declares required hardware features that the app depends on.
<uses-feature android:name="android.hardware.camera" />

<activity-alias> Element—Creates an alias for an existing activity.

Useful for creating multiple launch icons for the same activity.
 <activity-alias
android:name=".AlternateMainActivity"
android:targetActivity=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity-alias>
<uses-library> Element—Declares that the app depends on a system library.
<uses-library android:name="com.google.android.maps" />

File Features
File features refer to the characteristics and attributes associated with computer files, which are
units of digital data used to store, organize, and manage information on a computer or storage
device. Understanding these features is essential for effective data management, software
development, and general computer usage. Below, I'll discuss various file features in detail.
File Name—A file's name serves as its unique identifier within a file system. It should be
descriptive and follow naming conventions to make it easily recognizable and searchable. File
names often include an extension (e.g., ".txt" for text files) that indicates the file's format or type.
File Extension—The file extension is a suffix added to a file's name to indicate its format or type.
It helps both users and software applications recognize the file's content and how to handle it.
Common extensions include ".jpg" for images, ".docx" for Microsoft Word documents, and
".mp3" for audio files.
File Size—File size refers to the amount of storage space a file occupies on a storage device,
typically measured in bytes, kilobytes (KB), megabytes (MB), gigabytes (GB), or other larger units.
Understanding file sizes is crucial for managing storage capacity and data transfer.
File Format—File format defines the structure and encoding of the file's content. Different
formats are designed for specific types of data, such as text, images, audio, or video. Common
file formats include JPEG, PDF, MP3, and CSV.
File Date and Time—Files have timestamps indicating when they were created, last modified, and
last accessed. These timestamps provide valuable information for tracking changes, managing
versions, and auditing file usage.
File Attributes—File attributes are properties associated with a file, such as read-only, hidden,
system, or archive. These attributes control how a file is treated by the operating system and user
permissions.
File Ownership and Permissions—In multi-user environments, files have owners and permissions
that dictate who can access, modify, or delete them. These security features help protect sensitive
data and ensure proper file management.
File Content—The content of a file is the actual data it stores, whether it's text, binary data, code,
or multimedia. Different applications are used to create, edit, and view file content based on its
format and purpose.
File Encryption—For security and privacy, files can be encrypted to prevent unauthorized access.
Encryption transforms the file's content into an unreadable format that can only be decrypted
with the appropriate key.
File Metadata—Metadata is additional information about a file, such as author, keywords, or
description. It helps with file organization, searchability, and classification.
File Backup—Regularly backing up files ensures data recovery in case of accidental deletion,
hardware failure, or data corruption. Backup methods include local backups, cloud storage, and
external drives.
File Sharing—Files can be shared among users or devices using various methods, such as email
attachments, file-sharing services, or network protocols like FTP and SMB.

File Conventions
Descriptive File Name—The Android Manifest file should have a clear and descriptive name, such
as AndroidManifest.xml, to indicate its purpose and content at a glance.
Consistent Location—Place the Android Manifest file in the root directory of the app module.
This is the standard location for the manifest, making it easily accessible and recognizable.
Correct File Extension—Ensure that the file has the ".xml" extension, which is the standard file
format for XML files.
XML Formatting Conventions—Use proper XML formatting with consistent indentation, line
breaks, and comments to enhance readability.
Follow a consistent coding style, such as placing attributes on separate lines and using a standard
order for attributes (e.g., package, versionCode, versionName).
Descriptive Package Name—Choose a meaningful package name for your app, typically following
the reverse domain name convention (e.g., com.example.myapp). This should be reflected in the
package attribute of the <manifest> element.
Version Information—Include version information using the versionCode and versionName
attributes in the <manifest> element. These attributes help track and manage app versions.
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.myapp"
android:versionCode="1"
android:versionName="1.0">
Consistent Intent Filters—When defining intent filters for activities, services, and receivers,
maintain consistency in their structure and naming conventions. Use clear and meaningful action
and category names to convey the component's purpose.
Permission Declarations—Declare app permissions using the <uses-permission> element and
use clear and meaningful permission names. Avoid excessive or unnecessary permissions to
enhance security.
<uses-permission android:name="android.permission.CAMERA" />
Intent Filter Ordering—If your app has multiple activities with intent filters, order them
consistently to prioritize the main launcher activity by placing it first in the <activity> elements.

Summary
Identification—It uniquely identifies the app to the Android operating system through the
package name.
Permissions—Specifies the permissions required by the app for accessing device resources and
maintaining security.
Components—Defines the app's building blocks, including activities, services, broadcast
receivers, and content providers.
Intent Filters—Enables interaction with other apps and the system by specifying the types of
intents the components can respond to.
Configuration—Contains critical app configurations such as screen orientations, minimum API
levels, and theme settings.
Launch Configuration—Determines the app's entry point by specifying the main activity and its
intent filters.
Metadata—Allows for the inclusion of metadata for better organization and searchability.
Version Information—Provides version control through version code and version name
attributes.