12.

DEVELOPING ANDROID SERVICES

11.1 INTRODUCTION
Developing Android services in Android Studio involves creating components that can perform long-
running operations in the background, even when the user switches to another application. Services
can be used for various tasks such as playing music, fetching data from the internet, or monitoring
sensor inputs.

11.2 CREATING YOUR OWN SERVICES

1.Create a new Service class: In Android Studio, create a new Java class that extends the Service
class. This will be your custom service. For example:

public class MyService extends Service {

@Override

public IBinder onBind(Intent intent) {

return null;

@Override

public int onStartCommand(Intent intent, int flags, int startId) {

// Your code to perform background tasks goes here

return START_STICKY; // Or other appropriate return value

@Override

public void onDestroy() {

super.onDestroy();

// Clean up resources or perform any necessary tasks before the service is destroyed

2.Define service functionality: Inside your service class, define the functionality you want to run in
the background within the onStartCommand() method. This method is called when the service is
started.

3.Declare service in manifest: Open your AndroidManifest.xml file and declare your service. Add a
<service> element inside the <application> element:

<service

android:name=".MyService"

android:enabled="true"
 android:exported="false" />

4.Start and stop the service: You can start your service from any component (like an Activity) using
an Intent. For example:

Intent serviceIntent = new Intent(this, MyService.class);

startService(serviceIntent);

To stop the service, call stopService():

Intent serviceIntent = new Intent(this, MyService.class);

stopService(serviceIntent);

11.2.1 Performing Long-Running Tasks in a Service

Performing long-running tasks in a Service in Android is a common use case, especially for
operations that should continue even when the app is not in the foreground.

1.Use a separate thread or AsyncTask:

 Inside your Service's onStartCommand() method, create a new thread or AsyncTask to

perform the long-running task. This ensures that the task runs asynchronously and doesn't
block the main thread, which could lead to an "Application Not Responding" (ANR) error.

@Override

public int onStartCommand(Intent intent, int flags, int startId) {

new Thread(new Runnable() {

@Override

public void run() {

// Perform your long-running task here

}).start();

return START_STICKY;

 Alternatively, you can use an AsyncTask for simpler threading. AsyncTask provides
convenient methods like onPreExecute(), doInBackground(), and onPostExecute() that run
on the UI thread for setup, background execution, and post-execution respectively.

2.Handle task completion:

 Once the long-running task is completed, you may need to notify the user or update the UI if
necessary. You can use various methods for this purpose, such as broadcasting an intent,
updating a notification (if your service is running as a foreground service), or using a callback
interface.
3.Considerations for long-running tasks:

 Ensure that your long-running task doesn't consume excessive resources (CPU, memory,
battery) and doesn't negatively impact the performance of the device or other apps.
 If your task involves network operations, ensure that it's handled properly, such as using
background threading for network requests and handling network connectivity changes
gracefully.
 Be aware of Android's component lifecycle. Services can be stopped by the system under
certain conditions, such as low memory situations. Save the state of your task if necessary,
so it can be resumed when the service is restarted.

4. Foreground Service for long-running tasks:

 If your long-running task is something the user should be aware of, consider running your
service as a foreground service. This requires showing a persistent notification to the user,
indicating that the service is running.
 To convert your service to a foreground service, use startForeground() method in your
service's onStartCommand() method and provide a notification with an ongoing status.

11.2.2 Performing Repeated Tasks in a Service

Performing repeated tasks in a Service is a common requirement for many applications, such as
updating data from a server at regular intervals or performing periodic cleanup tasks. You can
achieve this using various techniques in Android.

1. Create a Service:

First, create a Service class that will perform the repeated tasks. This class should extend the Service
class and override the onStartCommand() method.

public class MyService extends Service {

private Handler handler = new Handler();

private Runnable taskRunnable = new Runnable() {

@Override

public void run() {

// Your repeated task goes here

// This will be executed periodically

Log.d("MyService", "Executing repeated task");

// Schedule the task to run again after a delay

handler.postDelayed(this, 5000); // 5000 milliseconds = 5 seconds

};
 @Override

public int onStartCommand(Intent intent, int flags, int startId) {

// Start the repeated task when the service starts

handler.post(taskRunnable);

return START_STICKY;

@Nullable

@Override

public IBinder onBind(Intent intent) {

return null;

2. Start the Service:

To start the service, you need to create an Intent and call startService() from your Activity or any
other component.

Intent serviceIntent = new Intent(this, MyService.class);

startService(serviceIntent);

3. Stop the Service (optional):

You might want to stop the service when it's no longer needed. You can do this by calling
stopService()

Intent serviceIntent = new Intent(this, MyService.class);

stopService(serviceIntent);

4. Cleanup:

Remember to handle cleanup tasks properly, such as removing callbacks from the Handler when the
service is stopped

@Override

public void onDestroy() {

super.onDestroy();

// Remove the callback to stop the repeated task

handler.removeCallbacks(taskRunnable);

}
This implementation will execute the taskRunnable periodically every 5 seconds. You can adjust the
delay (in milliseconds) according to your requirements. Additionally, ensure that you handle any
exceptions within the run() method to prevent the service from crashing.

11.2.3 Executing Asynchronous Tasks on Separate

When developing Android services to execute asynchronous tasks on a separate thread, it's essential
to ensure that these tasks don't block the main UI thread to maintain a responsive user experience.
One common approach to achieve this is by using the IntentService class, which automatically
creates a worker thread for handling asynchronous tasks.

1.Create a Service class that extends IntentService:

First, create a new Java class that extends IntentService. Override the onHandleIntent() method
where you'll place your asynchronous task logic.

public class MyIntentService extends IntentService {

public MyIntentService() {

super("MyIntentService");

@Override

protected void onHandleIntent(@Nullable Intent intent) {

// Perform your asynchronous task here

Log.d("MyIntentService", "Executing asynchronous task");

// You can perform network operations, database access, or any other long-running task here

2.Start the Service:

Start your IntentService from any component, such as an Activity or another Service, by creating an
Intent and calling startService().

Intent serviceIntent = new Intent(context, MyIntentService.class);

startService(serviceIntent);

3.Handle the Result (if needed)

If your asynchronous task produces a result that you need to handle, you can use various
mechanisms such as broadcasting an Intent, updating a database, or sending a message to a handler.

4.Cleanup (if needed):

If your service requires cleanup after execution, you can override the onDestroy() method to
perform any necessary cleanup tasks.
@Override

public void onDestroy() {

super.onDestroy();

// Perform any cleanup tasks here

5.Declare the Service in the Manifest:

Ensure that you declare your IntentService in the AndroidManifest.xml file.

<service

android:name=".MyIntentService"

android:exported="false" />

By using IntentService, you get a simple and efficient way to handle asynchronous tasks on a
separate thread without the need to manually manage threads. The IntentService class
automatically handles the creation of a worker thread, processing each Intent that is delivered to it
sequentially, and stopping itself when the queue of work is empty. This makes it a suitable choice for
executing background tasks in Android services.

11.2.4 Threads Using IntentService

Threads using IntentService refers to the utilization of concurrent execution mechanisms within an
IntentService in Android.

An IntentService is a subclass of Service in Android that provides a straightforward way to handle

asynchronous work off the main thread. It operates on a worker thread, handling incoming Intents
sequentially in the order they are sent.

When we talk about "threads using IntentService," it typically means leveraging additional threads or
concurrency mechanisms within the context of an IntentService. Despite IntentService already
providing a single worker thread for executing tasks sequentially, there may be scenarios where
parallel processing or more complex threading models are required within the service.

This can involve:

1.Manual Thread Creation:

Creating and managing additional threads manually within the onHandleIntent() method of the
IntentService to perform parallel tasks.

2.ExecutorService:

Utilizing ExecutorService to manage a pool of threads for executing tasks concurrently. This allows
for more controlled thread management and can help avoid the overhead of creating and destroying
threads repeatedly.
By incorporating additional threads or concurrency mechanisms within an IntentService, developers
can achieve more complex processing scenarios while still benefiting from the simplicity and
background execution capabilities provided by the IntentService class.

11.3 Binding Activities to Services

Binding activities to services is a crucial part of Android development, enabling communication
between user interface components like activities or fragments and background services. Here's how
to do it when developing Android services:

1.Create your Service:

Begin by creating your service class by extending the `Service` class. This class will contain the
background logic you want to execute.

public class MyService extends Service {

// Your service code here

2.Define a Service Connection:

Inside your activity, define a `ServiceConnection` object to handle the connection between the
activity and the service.

private ServiceConnection mServiceConnection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

// This method is called when the connection with the service has been established

// You can now interact with the service

@Override

public void onServiceDisconnected(ComponentName name) {

// This method is called when the connection with the service has been unexpectedly
disconnected

// This typically happens when the service crashes

};

3.Bind to the Service:

In your activity's lifecycle method, such as `onCreate()`, bind to the service using the `bindService()`
method, passing in an intent representing the service to bind to and the `ServiceConnection` object.
Intent serviceIntent = new Intent(this, MyService.class);

bindService(serviceIntent, mServiceConnection, Context.BIND_AUTO_CREATE);

4.Interact with the Service:

Once the connection with the service is established (`onServiceConnected()` is called), you can
interact with the service through the bound service instance.

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

// This method is called when the connection with the service has been established

// You can now interact with the service

MyService.MyBinder binder = (MyService.MyBinder) service;

MyService myService = binder.getService();

myService.doSomething();

5.Unbind from the Service:

When you're done using the service, unbind from it to release the connection. This is typically done
in the `onDestroy()` method of your activity.

@Override

protected void onDestroy() {

super.onDestroy();

unbindService(mServiceConnection);

6.Handle Errors and Exceptions:

Ensure you handle errors and exceptions that may occur during the binding process or while
interacting with the service, such as when the service is not available or crashes unexpectedly.

Binding activities to services allows for communication between the UI and background tasks,
enabling tasks to be performed outside of the main UI thread while keeping the UI responsive. This
pattern is commonly used for tasks such as downloading files, playing music, or performing long-
running computations in the background.

11.4 Understanding Threads

In Android development, threading in the context of services involves managing concurrent
execution of tasks in the background to perform operations such as network requests, database
transactions, or other long-running tasks without blocking the main UI thread. Here's a deeper dive
into threading in developing Android services:
1.Main UI Thread:

The main UI thread is where all UI interactions, such as user input processing, layout inflation, and
view updates, occur. Any lengthy operations performed on this thread can lead to UI freezes and
Application Not Responding (ANR) errors, degrading the user experience.

2.Background Threads:

Android services are often used to perform tasks that require background processing to avoid UI
thread blocking. Background threads are created explicitly within services to execute these tasks
asynchronously. By offloading work to background threads, the UI thread remains responsive.

3.Service Lifecycle and Threading:

Services in Android can run in the same process as the application's UI or in a separate process.
When a service is started, its `onStartCommand()` method is called on the main thread. It's essential
to delegate any long-running operations to background threads to prevent blocking the main thread.

4.IntentService:

IntentService is a specialized service class that provides a simplified way to perform background
tasks on a separate worker thread. It automatically handles thread management, including creating
a worker thread for each incoming intent, executing the task, and stopping the service when the task
is complete.

5.Thread Pool Management:

In scenarios where multiple tasks need to be executed concurrently or when tasks are executed
frequently, using a thread pool can be beneficial. Android provides classes like `ThreadPoolExecutor`
and `Executors` to manage a pool of worker threads efficiently. This helps control the number of
threads and reuse threads for subsequent tasks, reducing thread creation overhead.

6.Thread Safety and Communication:

When working with multiple threads in services, it's crucial to ensure thread safety, especially when
accessing shared resources or modifying state across threads. Techniques like synchronization,
locking, or using thread-safe data structures help prevent race conditions and ensure data integrity.
Additionally, communication between the UI thread and background threads can be facilitated using
mechanisms like handlers, message passing, or LiveData for real-time updates.

7.Foreground Services:

For long-running tasks that require ongoing user interaction or notification, foreground services are
used. Foreground services display a persistent notification to the user, indicating that the service is
running, and are less likely to be killed by the system, even under memory pressure.

Understanding threading in developing Android services is crucial for building responsive and
efficient applications. By utilizing background threads, thread pools, and appropriate threading
techniques, developers can ensure smooth user experiences while handling complex background
tasks in services.