Android - Unit 3

1. Write a short note on the Drawable class in Android with a suitable example.
2. State and explain the MediaPlayer class along with predefined methods.
3. What is a Gesture class in Android? Explain multiple touches, swipe, drag,
recording, zoom, etc., in detail.
4. Difference between Background Service and Foreground Service in Android
applications.
5. What is a Service? Explain the service lifecycle with a suitable example.
6. Difference between Thread and Process in Android.
7. Write a short note on JobScheduler and Asynchronous tasks.
8. What is an APK? How to build and execute an APK? Explain the process steps
in detail.
9. State and explain the steps for deploying an Android application on Google
Play Publishing an Application
10.What is the Android Animation class? Explain categories of animations in
Android.
11. Write a short note on GPS tracker in Android.

1) Write a short note on the Drawable class in Android with a suitable

example.
A drawable resource is a common concept for a graphic that can be drawn to
the screen and which one can retrieve with APIs such as getDrawable(int) or
apply to another XML resource with attributes such
as android:drawable and android:icon. There are several different types of
drawable resources files and let’s discuss all the types in a tabular manner.

Drawable
Resources
Files Description

A bitmap graphic file. Android supports bitmap files in three

Bitmap File
formats: .png, .jpg, .gif.

Nine-Patch A PNG file with stretchable regions to allow image resizing based on
File content (.9.png)
Drawable
Resources
Files Description

A Drawable that manages an array of other Drawables. These are

Layer List drawn in array order, so the element with the largest index is be
drawn on top.

An XML file that defines a drawable that manages a number of

Level List
alternate Drawables, each assigned a maximum numerical value.

Transition An XML file that defines a drawable that can cross-fade between two
Drawable drawable resources.

Clip An XML file that defines a drawable that clips another Drawable based
Drawable on this Drawable’s current level value.

Scale An XML file that defines a drawable that changes the size of another
Drawable Drawable based on its current level value.

Shape An XML file that defines a geometric shape, including colors and
Drawable gradients.

Step by Step Process to Create a New Drawable Resource XML in

Android Studio
Step 1: Go to the app > res > drawable and right-click on it. Please refer to
the screenshot below to get a clear cut view of the steps.
Step 2: After right-clicking on the drawable file go to New > Drawable
resource file as shown in the figure below.

Step 3: When you click on the Drawable resource file a dialog box will open
on your compute screen. Enter the file name in the text box and then click
on OK.
Step 4: After that the drawable resource XML file will be created and one can
find the file in app > res > drawable as shown in the figure below. In this case,
we have named the file as round_button as shown in the above image.

Step 5: Now click on the file name and one can customize the views by writing
the necessary codes inside this file.
.
2) State and explain the MediaPlayer class along with predefined methods.
MediaPlayer Class in Android is used to play media files. Those are Audio and
Video files. It can also be used to play audio or video streams over the network.
So in this article, the things discussed are:
 MediaPlayer State diagram
 Creating a simple audio player using MediaPlayer API. Have a look at the
following image. Note that we are going to implement this project using
the Kotlin language.
State Diagram of the MediaPlayer Class
 The playing of the audio or video file using MediaPlayer is done using a
state machine.
 The following image is the MediaPlayer state diagram.
  In the above MediaPlayer state diagram, the oval shape represents the
state of the MediaPlayer instance resides in.
There are two types of arcs showing in the state diagram. One with the single
arrowhead represents the synchronous method calls of the MediaPlayer instance
and one with the double arrowhead represents the asynchronous calls.
  The release method which is one of the important element in the
MediaPlayer API. This helps in releasing the Memory resources allocated
for the Mediaplayer instance when it is not needed anymore.
 If the stop() method is called using Mediaplayer instance, then it needs to
prepared for the next playback.
 The MediaPlayer can be moved to the specific time position
using seekTo() method so that the MediaPlayer instance can continue
playing the Audio or Video playback from that specified position.
 The following image is the summarised version of the MediaPlayer state
diagram.

Steps to create a simple MediaPlayer in Android

Step 1: Create an empty activity project
 Create an empty activity Android Studio project. And select Kotlin as a
programming language.
Step 2: Create a raw resource folder
Looking to become an expert in Android App Development? Whether you're a
student or a professional aiming to advance your career in mobile app
development, our course, "Android App Development with Kotlin," available
exclusively on GeeksforGeeks, is the perfect fit for you.
 Create a raw resource folder under the res folder and copy one of
the .mp3 file extension.
Step 3: Working with the activity_main.xml file
 The layout of the application consists of three buttons PLAY, PAUSE, and
STOP mainly, which is used to control the state of the MediaPlayer
instance.
 Invoke the following code inside the activity_main.xml file to implement
the UI.
 3) What is a Gesture class in Android? Explain multiple touches, swipe, drag,
recording, zoom, etc., in detail.
Gesture Class in Android
The Gesture class in Android is part of the android.view package and is used to
capture and interpret various user gestures, such as taps, swipes, pinches, and
other touch-based events. It provides a convenient way to detect and handle
user interactions on touchscreen devices, enabling developers to build more
interactive and intuitive user interfaces.
In Android, the handling of gestures is usually done through GestureDetector
or ScaleGestureDetector classes, which make it easier to detect common
gestures, like swiping, zooming, and long-pressing. These detectors work by
interpreting the user's touch events and mapping them to high-level gestures.
Multiple Touches (Multi-touch)
Multi-touch refers to the ability to recognize more than one touch point on the
screen at a time. Android supports multi-touch gestures, allowing the user to
interact with multiple points simultaneously. This is especially useful for
operations like pinch-to-zoom and rotating images.
Android provides the onTouchEvent() method to detect multiple touch events.
When there are multiple touches on the screen, the MotionEvent object passed
to the onTouchEvent() method will contain information about the current state of
each touch point, including their X and Y coordinates, touch action (e.g., down,
move, up), and ID.
1. Swipe Gesture
A swipe gesture is a common gesture where the user moves their finger across
the screen in a single, continuous motion. Swipes are typically used for
navigation or triggering actions, like moving between pages, switching tabs, or
dismissing notifications.
Android uses the GestureDetector class to detect swipe gestures. The
GestureDetector.SimpleOnGestureListener provides callbacks for common
gestures such as onFling() and onScroll().
 onFling(): Called when a swipe gesture (flick) is detected.
 onScroll(): Detects a continuous swipe or scroll action.
return gestureDetector.onTouchEvent(event);
}
2. Drag Gesture
A drag gesture refers to dragging a touch point across the screen. This gesture
is commonly used to move UI elements, like dragging a view or item within a list.
It is typically a combination of the ACTION_DOWN, ACTION_MOVE, and
ACTION_UP touch events.
  ACTION_DOWN: Detects the initial touch.
 ACTION_MOVE: Tracks the movement of the touch point as the user
drags.
 ACTION_UP: Handles the release of the touch.
3. Zoom Gesture (Pinch-to-Zoom)
Zoom gestures (commonly pinch-to-zoom) are used to zoom in or out of content,
like images, maps, or web pages. This gesture is usually performed by placing
two fingers on the screen and moving them apart (zoom in) or bringing them
closer (zoom out).
Android provides the ScaleGestureDetector class, which simplifies the detection
of zoom gestures by calculating the scale factor based on the distance between
two touch points.
4. Recording Gestures
Recording gestures refers to tracking the user's input over time to capture
specific gestures. For example, you can record the sequence of touch events
(e.g., position, action) to detect patterns such as a signature, drawing shapes, or
custom gestures.
In Android, this can be achieved by manually tracking touch events and storing
them for later analysis. This is commonly done in custom onTouchEvent()
methods or by using a GestureDetector in combination with custom logic.

4) Difference between Background Service and Foreground Service in Android

applications.
1. Definition
 Background Service:
o A Background Service runs in the background without any direct
interaction with the user. It is typically used for long-running tasks
that do not require immediate attention or visibility, such as
downloading data, syncing information, or performing background
computation.
 Foreground Service:
o A Foreground Service is one that is actively running and must
show a persistent notification in the system's notification area. It is
typically used for tasks that are user-initiated and must continue
running, even when the app is in the background (e.g., media
playback, ongoing navigation, or file downloads).
2. User Visibility
 Background Service:
 o Not visible to the user. It does not require any notification to
indicate that it is running.
 Foreground Service:
o Visible to the user through a persistent notification. This notification
is typically used to provide information about the ongoing task and
notify the user that the service is still running.
3. System Resource Management
 Background Service:
o Low priority: Background services have a lower priority. They can
be killed by the Android system when resources are low (e.g.,
memory, battery). Android’s battery optimizations, especially in
Android 8.0 (Oreo) and later, place strict restrictions on background
services.
 Foreground Service:
o High priority: Foreground services run with a higher priority. They
are less likely to be killed by the system compared to
background services. This is because the user is notified that the
service is running, and the system treats it as an ongoing task that
the user cares about (e.g., music playback or navigation).
4. Use Cases
 Background Service:
o Suitable for tasks that do not need user interaction or immediate
visibility, such as:
 Syncing data with the cloud
 Performing background computations
 Periodic data fetching
 Foreground Service:
o Suitable for tasks that need continuous operation or user
interaction, such as:
 Music or audio playback
 Active navigation (GPS)
 Ongoing file download/upload
 Tracking location in real-time
5. Notification Requirement
 Background Service:
o No notification required: Background services do not require a
persistent notification, but they may show a notification if needed.
  Foreground Service:
o Persistent notification required: Foreground services must
display a persistent notification in the system's status bar, which
lets users know that the service is active and ongoing.
6. Handling in Recent Android Versions
 Background Service:
o Strict limitations: In Android 8.0 (Oreo) and later, background
services are subject to strict limitations. These services can be
interrupted, delayed, or killed by the system to save battery life and
improve performance. Background tasks need to be scheduled
using tools like JobScheduler, WorkManager, or AlarmManager.
 Foreground Service:
o Less restrictive: Foreground services are not restricted by
Android's background limitations. As long as a notification is
displayed, the service will continue running without being
interrupted by the system, even if the app is not in the foreground.
7. Examples of Use
 Background Service:
o Syncing app data in the background without user intervention.

o Fetching news or updates periodically.

o Running a background task that needs to continue even if the app is

not actively being used.
 Foreground Service:
o Playing music while the user is using another app.

o Navigating with a map and showing real-time location on the

notification.
o Downloading or uploading large files where the progress is shown to
the user in the notification.

Feature Background Service Foreground Service

Runs in the background but

Runs in the background
Definition requires a persistent
without user interaction.
notification.

Visible to the user via a

User Visibility Not visible to the user.
persistent notification.

Low priority, can be killed by High priority, unlikely to be

Priority
the system. killed by the system.
Feature Background Service Foreground Service

System Can be terminated if Protected from termination, as

Resource resources are needed long as the notification is
Handling elsewhere. visible.

Background tasks like data Tasks that need to run

Use Cases sync, fetching updates, continuously, e.g., media
computation. playback, navigation.

Must show a persistent

Notification
No notification required. notification to keep the service
Requirement
running.

Subject to restrictions in Allowed to run with fewer

Handling in
Android 8.0 and above (e.g., restrictions, as long as
Recent Android
doze mode). notification is present.

5) What is a Service? Explain the service lifecycle with a suitable example.

Services in Android are a special component that facilitates an application to run
in the background in order to perform long-running operation tasks. The prime
aim of a service is to ensure that the application remains active in the
background so that the user can operate multiple applications at the same time.
A user-interface is not desirable for android services as it is designed to operate
long-running processes without any user intervention. A service can run
continuously in the background even if the application is closed or the user
switches to another application. Further, application components can bind itself
to service to carry out inter-process communication(IPC) . There is a major
difference between android services and threads, one must not be confused
between the two.
Types of Android Services
1. Foreground Services:
Services that notify the user about its ongoing operations are termed as
Foreground Services. Users can interact with the service by the notifications
provided about the ongoing task. Such as in downloading a file, the user can
keep track of the progress in downloading and can also pause and resume the
process.
2. Background Services:
Background services do not require any user intervention. These services do not
notify the user about ongoing background tasks and users also cannot access
them. The process like schedule syncing of data or storing of data fall under this
service.
3. Bound Services:
This type of android service allows the components of the application like activity
to bound themselves with it. Bound services perform their task as long as any
application component is bound to it. More than one component is allowed to
bind themselves with a service at a time. In order to bind an application
component with a service bindService() method is used.
The Life Cycle of Android Services
1. Started Service (Unbounded Service):
By following this path, a service will initiate when an application component calls
the startService() method. Once initiated, the service can run continuously in
the background even if the component is destroyed which was responsible for
the start of the service. Two option are available to stop the execution of service:
 By calling stopService() method,
 The service can stop itself by using stopSelf() method.
2. Bounded Service:
It can be treated as a server in a client-server interface. By following this path,
android application components can send requests to the service and can fetch
results. A service is termed as bounded when an application component binds
itself with a service by calling bindService() method. To stop the execution of
this service, all the components must unbind themselves from the service by
using unbindService() method.

Fundamentals of Android Services

A user-defined service can be created through a normal class which is extending
the class Service . Further, to carry out the operations of service on
applications, there are certain callback methods which are needed to
be overridden . The following are some of the important methods of Android
Services:

6) Difference between Thread and Process in Android.

Difference Between Process and Thread

The table below represents the difference between process and
thread.
Process Thread

Process means a program

Thread means a segment of a process.
in execution.
 Process Thread

A process takes more

A thread takes less time to terminate.
time to terminate.

It takes more time for

It takes less time for creation.
creation.

It also takes more time for

It takes less time for context switching.
context switching.

A process is less efficient

Thread is more efficient in terms of
in terms of
communication.
communication.

We don’t need multi programs in

Multiprogramming holds
action for multiple threads because a
the concepts of multi-
single process consists of multiple
process.
threads.

Every process runs in its

Threads share memory.
own memory.

A Thread is lightweight as each thread

A process is heavyweight
in a process shares code, data, and
compared to a thread.
resources.

Process switching uses an Thread switching may not require

interface in an operating calling involvement of operating
system. system.

If one process is blocked,

If a user-level thread is blocked, then
then it will not affect the
all other user-level threads are
execution of other
blocked.
processes.

A process has its own Thread has Parents’ PCB, its own
Process Control Block, Thread Control Block, and Stack and
Stack, and Address Space. common Address space.

Changes to the parent Since all threads of the same process

 Process Thread

share address space and other

process do not affect child resources so any changes to the main
processes. thread may affect the behavior of the
other threads of the process.

A system call is involved No system call is involved, it is created

in it. using APIs.

A process does not share

Threads share data with each other.
data with each other.

7) Write a short note on JobScheduler and Asynchronous tasks.

1. JobScheduler in Android
JobScheduler is an Android API introduced in API level 21 (Lollipop),
which provides a way to schedule tasks to run in the background under
certain conditions (such as when the device is charging, connected to
Wi-Fi, or the device is idle). This helps improve battery life and system
performance by deferring tasks to appropriate times.
Key Features of JobScheduler:
 Job Constraints: You can specify conditions under which the job
should run, such as network availability, device charging, or a
specific time window.
 Efficiency: JobScheduler optimizes background tasks, especially
when running multiple tasks. It batches jobs together to run them
at the same time, reducing system load.
 Persistence: Jobs are persistent and will be retried if they fail due
to certain conditions (e.g., lack of network).
Example Usage of JobScheduler:
JobScheduler jobScheduler = (JobScheduler)
getSystemService(JOB_SCHEDULER_SERVICE);

JobInfo job = new JobInfo.Builder(1, new ComponentName(this,

MyJobService.class))
.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED) //
Require Wi-Fi
.setRequiresCharging(true) // Require charging
.build();
jobScheduler.schedule(job);
In this example, a job is scheduled to run only when the device is
charging and connected to an unmetered (Wi-Fi) network.

2. Asynchronous Tasks in Android

Asynchronous tasks in Android allow the execution of long-running
operations in the background without blocking the main (UI) thread.
These tasks are commonly used to perform operations like network
calls, file I/O, or heavy computations.
Key Concepts of Asynchronous Tasks:
 AsyncTask (Deprecated): Previously, Android used AsyncTask for
simple background tasks. However, AsyncTask is now deprecated
in favor of more modern solutions (like ExecutorService and
WorkManager), but understanding it is still useful.
 ExecutorService: A more modern approach to manage threads and
background tasks using the Executor framework. It provides more
flexibility than AsyncTask.
 Coroutine (Kotlin): In Kotlin, coroutines are a popular way to
handle asynchronous programming, providing a more readable
and scalable way to write async code.
Example of Asynchronous Task Using AsyncTask (Deprecated):
private class DownloadTask extends AsyncTask<String, Void, String> {
@Override
protected String doInBackground(String... urls) {
// Perform background work (e.g., download data)
return "Download Complete!";
}

@Override
protected void onPostExecute(String result) {
// Update UI after task is complete
textView.setText(result);
}
}
new DownloadTask().execute("https://example.com");
In the example above, AsyncTask executes a network operation
(doInBackground) and updates the UI (onPostExecute) once the task is
complete.

Difference Between JobScheduler and Asynchronous Tasks

Feature JobScheduler Asynchronous Tasks

Schedule background tasks Perform background tasks

Purpose with specific conditions asynchronously without
(e.g., charging, Wi-Fi). blocking the UI thread.

Used for tasks that need to

Suitable for short-lived tasks
be deferred and have
Task Type like network requests, file
specific execution
downloads, etc.
conditions.

Tasks that need to run in the

Battery-efficient background
Use Case background without UI
tasks with constraints.
blocking.

Jobs can be persisted and

Persistenc Tasks run once and are not
retried if conditions are met
e persistent across app restarts.
(e.g., network failure).

API Available through AsyncTask

Available from Android
Availabilit (deprecated), ExecutorService,
Lollipop (API 21).
y and Kotlin Coroutine.

Job Supports flexible job

Does not support specific job
Constraint constraints (e.g., network,
constraints directly.
s charging).

8) What is an APK? How to build and execute an APK? Explain the

process steps in detail.
An APK (Android Package Kit) is the file format used to distribute and
install applications on Android devices. It contains all the elements
required for an Android app, such as the code (in the form of .dex files),
resources, assets, and the manifest file. Essentially, it's a package of
everything that an Android app needs to function on a device.
Steps to Build and Execute an APK
1. Set Up Your Development Environment
Before building and executing an APK, you need to set up an
environment for Android development. The most commonly used IDE for
Android development is Android Studio.
 Install Android Studio:
 o Download the latest version of Android Studio from the
official website.
o Follow the installation instructions based on your operating
system (Windows, macOS, or Linux).
o Android Studio comes with the Android SDK (Software
Development Kit) and other necessary tools.
2. Create a New Android Project
Once Android Studio is set up:
1. Open Android Studio.
2. Create a New Project:
o Select Start a new Android Studio project.

o Choose a template (e.g., Empty Activity).

o Provide the project name, save location, language (Java or

Kotlin), and the minimum API level (i.e., which Android
version the app supports).
3. Configure the App:
o Android Studio will generate files for your project, such as
MainActivity.java (or MainActivity.kt for Kotlin), res/
(resources), and AndroidManifest.xml.
o The AndroidManifest.xml file contains app-level information
like app permissions and components.
3. Write Code for the Application
1. Develop your app by writing Java or Kotlin code. The main files
you'll interact with are:
o MainActivity.java or MainActivity.kt: This is the entry point
of your app.
o res/: This directory holds all your resources like layouts
(res/layout/), images (res/drawable/), strings
(res/values/strings.xml), and more.
2. Add UI elements in XML files (for instance, activity_main.xml in
res/layout/).
3. Test your app using the Android Emulator or a physical Android
device connected via USB (ensure you enable Developer Options
and USB Debugging on the device).
4. Build the APK
Once your app's code and resources are ready:
1. Configure Build Settings:
 o The build configuration can be set in the build.gradle files.

o The build.gradle (Project) file defines repositories, plugins,

and classpaths, while the build.gradle (Module: app) file
defines dependencies, build types (e.g., debug or release),
and other properties.
2. Build the APK:
o In Android Studio, go to Build > Build Bundle / APK > Build
APK.
o Android Studio will start building the APK. This process
compiles the code, merges resources, and packages
everything into an APK file.
3. Location of the APK:
o After the build process completes, you can locate the APK in
the output directory: app/build/outputs/apk/debug/ or
app/build/outputs/apk/release/, depending on the build type.
5. Sign the APK (For Release Version)
To distribute your APK on the Google Play Store or any other platform,
you must sign your APK with a private key. This step ensures that the
APK is authentic and can’t be tampered with after distribution.
1. Generate a Keystore:
o You can use the keytool utility (part of the Java
Development Kit) to generate a keystore file. Example
command:
o keytool -genkey -v -keystore my-release-key.jks -keyalg RSA
-keysize 2048 -validity 10000 -alias my-key-alias
2. Configure Gradle for Signing:
o Open the build.gradle file for the app module and add
signing configurations:
o android {

o signingConfigs {

o release {

o storeFile file("path/to/my-release-key.jks")

o storePassword "your_store_password"

o keyAlias "my-key-alias"

o keyPassword "your_key_password"

o }

o }
 o }

3. Build the Signed APK:

o In Android Studio, go to Build > Build Bundle / APK > Build
APK and select Release.
o Android Studio will ask for the keystore and password
details if you haven't already configured them in
build.gradle.
6. Install and Test the APK
Once you have the APK, you can install and run it on an Android device:
1. Install on a Device:
o Connect your Android device to your computer via USB (or
use an emulator).
o Ensure USB Debugging is enabled on your Android device.

o Use Android Studio's Run button or the command line to

install the APK:
o adb install path/to/your/app.apk

2. Test the APK:

o Once installed, you can launch the app on your device and
test its functionality.
7. Distribute the APK
Once the APK is ready and tested, you can distribute it in several ways:
 Google Play Store: For public distribution, you'll need to create a
developer account and upload the APK to the Play Store.
 Direct Distribution: You can share the APK directly with others,
but users must enable installation from unknown sources in their
device settings.
 Other App Stores: You can upload the APK to third-party Android
app stores.
9) State and explain the steps for deploying an Android application on Google
Play Publishing an Application
Deploying an Android application on Google Play involves several steps
that take your app from development to availability on the Play Store.
Here's a detailed explanation of the process:
1. Create a Google Play Developer Account
Before you can publish an app on the Google Play Store, you need a
Google Play Developer account. This account is required to manage and
publish apps to the Play Store.
  Create an account at the Google Play Console.
 Pay the registration fee of $25 (one-time payment).
 Provide your details, such as your business or developer name,
contact info, and tax information.
2. Prepare the App for Release
Before publishing your app, you must ensure that it is fully prepared for
release, including optimizations and signing.
a. Generate a Signed APK (or AAB)
To publish your app, it must be signed with a keystore file. This ensures
that the app is authentic and hasn’t been tampered with after
publishing.
1. Generate a Keystore: Use keytool to create a keystore (if you
don’t have one). Example command:
2. keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -
keysize 2048 -validity 10000 -alias my-key-alias
3. Configure Signing in Gradle:
o Open build.gradle and add the signing configuration for the
release build:
o android {

o signingConfigs {

o release {

o storeFile file("path/to/your/keystore/my-release-
key.jks")
o storePassword "your_store_password"

o keyAlias "my-key-alias"

o keyPassword "your_key_password"

o }

o }

o }

4. Build the Signed APK:

o In Android Studio, go to Build > Build Bundle / APK > Build
APK or Build AAB for Android App Bundle (Google
recommends AAB over APK for better app size
optimization).
o Select Release as the build variant.

o You will get a signed APK or AAB in app/build/outputs/.

3. Create a Store Listing on Google Play Console
To publish your app, you need to create a detailed store listing for it,
which will be displayed to users on the Play Store.
1. Go to the Google Play Console and log in.
2. Create a New Application:
o Click on Create Application.

o Select a default language (usually English).

o Enter a title for your app (this will be displayed on the Play
Store).
3. Provide App Details:
o Description: Write a short and long description that explains
what your app does.
o Screenshots: Upload high-quality screenshots that
demonstrate your app’s features. The Play Store typically
requires at least two screenshots.
o Feature Graphic: This is a promotional image that appears
at the top of your app’s listing on the Play Store.
o Category: Select the category that best fits your app (e.g.,
Education, Health, Entertainment).
o Content Rating: Complete the content rating questionnaire
so that your app is appropriately rated for different
audiences.
4. Prepare Pricing and Distribution:
o Pricing: Select whether your app will be free or paid. If it’s
paid, you’ll need to set a price.
o Countries: Select the countries where you want your app to
be available.
o Distribute to Specific Devices: If needed, you can restrict
your app’s availability to certain devices (e.g., only tablets
or specific screen sizes).
5. Privacy Policy:
o If your app collects any user data (including location,
contacts, or personal information), you must provide a
Privacy Policy. This policy should be accessible from within
your app and included in the store listing.
4. Upload the APK or AAB
Now that you have your app’s details filled in, you need to upload the
signed APK or AAB file to the Google Play Console.
 1. Navigate to the "App releases" section of the Play Console.
2. Create a new release:
o Select Production (for the main version of the app) or
Beta/Alpha (for testing).
o Click on Create Release.

3. Upload your APK or AAB:

o Drag and drop the signed APK or AAB file or click to browse
for it.
o Once uploaded, you may be prompted to review any
warnings or issues.
4. Release Notes:
o Provide release notes that describe the new features or
changes in this version of the app.
5. Review and Submit the App
After uploading the APK/AAB and providing all the required information:
1. Review all information: Check your app’s details, APK/AAB file,
screenshots, and descriptions for accuracy.
2. Submit your app for review: Once you are sure everything is in
order, click the Publish or Submit button to send your app for
review by Google.
6. App Review Process
After submitting your app, Google will review it to ensure it meets their
guidelines and policies. This process typically takes a few hours to a
few days.
 Automated Review: Google uses automated systems to scan the
APK for any malicious behavior or policy violations.
 Manual Review: In some cases, a human reviewer may need to
assess your app more carefully, especially if it has special
features or permissions.
7. Publish and Monitor Your App
Once your app is approved, it will be available on the Play Store!
 Monitor app performance: In the Play Console, you can view user
reviews, crash reports, installation statistics, and other insights.
 Respond to reviews: Engage with users by responding to their
feedback.
 Update your app: Whenever you release updates, repeat the same
process by uploading new APK/AAB files and providing release
notes.
8. Promote Your App
Once your app is live, you can use various marketing strategies to drive
installs and increase user engagement, such as:
 App Store Optimization (ASO): Improve your app’s visibility and
ranking in the Play Store.
 Social Media and Advertising: Promote your app through social
media, blogs, or paid ads.

10) What is the Android Animation class? Explain categories of

animations in Android.
Animation is the process of adding a motion effect to any view, image,
or text. With the help of an animation, you can add motion or can
change the shape of a specific view. Animation in Android is generally
used to give your UI a rich look and feel. The animations are basically of
three types as follows:
 Property Animation
 View Animation
 Drawable Animation
1. Property Animation
Property Animation is one of the robust frameworks which allows
animation almost everything. This is one of the powerful and flexible
animations which was introduced in Android 3.0. Property animation
can be used to add any animation in the CheckBox, RadioButtons, and
widgets other than any view.
2. View Animation
View Animation can be used to add animation to a specific view to
perform tweened animation on views. Tweened animation calculates
animation information such as size, rotation, start point, and endpoint.
These animations are slower and less flexible. An example of View
animation can be used if we want to expand a specific layout in that
place we can use View Animation. The example of View Animation can
be seen in Expandable RecyclerView.

3. Drawable Animation
Drawable Animation is used if you want to animate one image over
another. The simple way to understand is to animate drawable is to load
the series of drawable one after another to create an animation. A
simple example of drawable animation can be seen in many apps Splash
screen on apps logo animation.
Step 1: Create a New Project
To create a new project in Android Studio please refer to How to
Create/Start a New Project in Android Studio.
Select Java/Kotlin as the programming language.
Step 2: Working with the strings.xml file
Navigate to app > res > values > strings.xml and the below code into
the file. Follow the gate to the file.

Step 3: Working with the activity_main.xml file

Navigate to the app > res > layout > activity_main.xml. Create
ImageView in the activity_main.xml along with buttons that will add
animation to the view.
Step 4: Create 6 different types of animation for ImageView
To create new animations we have to create a new directory for storing
all our animations. Navigate to the app > res > Right-Click on res > New
> Directory > Name your directory and type as “anim”. Inside this
directory, we will create our animations. For creating a new anim right
click on the anim directory> Animation Resource file and give the name
to your file as below. Below is the code snippet for 6 different
animations.
Step 5: Working with the MainActivity file
Add animation to the ImageView by clicking a specific Button. Navigate
to the app > java > your apps package name >> MainActivity. Code is
provided in both Java and Kotlin.

11) Write a short note on GPS tracker in Android.

A GPS Tracker in Android refers to an application or feature that uses the
Global Positioning System (GPS) to determine the device's geographical
location. Android devices have built-in GPS receivers, which can track the
device's latitude, longitude, and altitude with high accuracy. GPS trackers are
commonly used for location-based services, navigation, and geofencing.
How GPS Tracker Works in Android:
Android provides access to GPS services through the LocationManager class,
which helps obtain the current location of the device. The key components
involved in GPS tracking on Android are:
1. LocationManager: This class allows you to access location services. It
provides methods to request location updates, such as
requestLocationUpdates().
2. LocationListener: This is used to listen for changes in the device's
location. When the location changes, the onLocationChanged() method
is triggered.
3. GPS Provider: The device's GPS chip acts as the GPS provider, giving
the most accurate location data when it's available.
 4. Other Providers: If GPS isn't available or accurate (e.g., indoors), Android
can fall back on other location providers, like Network (cell tower and Wi-
Fi based), which are less accurate but still useful for location tracking.
Basic Implementation of GPS Tracker:
To implement a GPS tracker, you need to request permissions and use the
LocationManager to get updates. Here's a brief code example:
1. Request Permissions: In the AndroidManifest.xml, add the following
permissions:
<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission
android:name="android.permission.ACCESS_COARSE_LOCATION" />
2. Stop Location Updates: When you're done with location tracking, it's
important to stop requesting updates to save battery:
Uses of GPS Tracker in Android:
 Navigation: GPS is used in apps like Google Maps, which provide real-
time navigation and route guidance.
 Location-Based Services: Apps that offer services like finding nearby
restaurants, hotels, or rideshare services (e.g., Uber, Lyft).
 Geofencing: Triggering actions when the device enters or leaves a
specific geographic area.
 Fitness Apps: Tracking running, walking, cycling routes, and other
fitness-related activities.
 Emergency Services: Sending location data to emergency services for
quick response.