Services in Android - Srinivas Narasegouda

What is a Service in Android?

A Service in Android is a component that runs in the background without a user interface. It is useful for long-running tasks such as:
✅ Playing music
✅ Downloading files
✅ Fetching data from the internet
✅ Running a background task (e.g., location tracking)

Types of Services in Android

Service Type	Description	Example
Started Service	Runs in the background until stopped manually	Music Player, File Download
Bound Service	Allows communication between an Activity and the Service	Fetching Data from API
Foreground Service	Runs with higher priority and shows a notification	GPS Tracking, Music Player

Example: Creating a Service in Android

We will create an app where:
✅ A Service runs in the background
✅ The Activity binds to the Service and retrieves data
✅ The Service runs in a separate thread

Add Service in AndroidManifest.xml

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

Create a Service (MyService.java)

public class MyService extends Service {

    private final IBinder binder = new MyBinder();
    private int counter = 0;
    private boolean isRunning = true;


    public class MyBinder extends Binder {
        public MyService getService() {
            return MyService.this;
        }
    }

    public IBinder onBind(Intent intent) {
        return binder;
    }

    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(() -> {
            while (isRunning) {
                counter++;
                Log.d("MyService", "Counter: " + counter);
                try {
                    Thread.sleep(1000); // Sleep for 1 second
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        return START_STICKY;
    }

    public int getCounter() {
        return counter;
    }

    public void onDestroy() {
        super.onDestroy();  //  Ensure you call the superclass method
        isRunning = false;
        Log.d("MyService", "Service is stopped.");
    }
}

✅ This Service runs in the background
✅ It increments a counter every second
✅ It runs in a separate thread using new Thread(() -> {...}).start();

XML Layout (activity_main.xml)

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="20dp">

    <Button
        android:id="@+id/btnStart"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Start Service" />

    <Button
        android:id="@+id/btnBind"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Bind to Service" />

    <TextView
        android:id="@+id/textViewCounter"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="20sp"
        android:paddingTop="20dp"/>
</LinearLayout>

✅ Button 1 → Starts the Service
✅ Button 2 → Binds to the Service and gets the counter value
✅ TextView → Displays the counter value

Java Code (MainActivity.java)

public class MainActivity extends AppCompatActivity {

    private MyService myService;
    private boolean isBound = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button btnStart = findViewById(R.id.btnStart);
        Button btnBind = findViewById(R.id.btnBind);
        TextView textViewCounter = findViewById(R.id.textViewCounter);

        btnStart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, MyService.class);
                startService(intent);
            }
        });

        btnBind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (isBound) {
                    int count = myService.getCounter();
                    textViewCounter.setText("Counter: " + count);
                }
            }
        });
    }

    // Service connection to bind the activity with the service
    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            MyService.MyBinder binder = (MyService.MyBinder) service;
            myService = binder.getService();
            isBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            isBound = false;
        }
    };

    @Override
    protected void onStart() {
        super.onStart();
        Intent intent = new Intent(this, MyService.class);
        bindService(intent, serviceConnection, BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        if (isBound) {
            unbindService(serviceConnection);
            isBound = false;
        }
    }
}

✅ Click “Start Service” → Starts the service in the background
✅ Click “Bind to Service” → Fetches the counter value from the service

MyService class

This is an Android Service class, MyService, that runs in the background and counts from 0 upwards, logging the counter value every second. Here’s a breakdown of the code and what it does:

Key components:

MyService class:
- It extends the Service class, which is designed for performing long-running operations in the background. Services can run independently of the UI.
IBinder binder and MyBinder class:
- The binder is used for clients (like an Activity) to communicate with the service.
- The MyBinder class extends Binder and provides a getService() method, which allows clients to get a reference to the MyService instance.
onBind(Intent intent) method:
- This is the method that returns the binder object when a client binds to the service. The client can then use the MyBinder class to interact with the service.
onStartCommand(Intent intent, int flags, int startId) method:
- This is called when the service is started (via startService()).
- A new thread is created within this method, which starts the counter (counter++) and logs its value every second (Thread.sleep(1000)).
- The isRunning flag is checked in the loop, which ensures the thread continues running as long as the service is active.
- The method returns START_STICKY, meaning the service will try to restart if it gets terminated by the system.
getCounter() method:
- This is a public method that returns the current value of the counter. This method can be called by clients that have bound to the service.
onDestroy() method:
- This method is called when the service is destroyed. It sets the isRunning flag to false to stop the thread in the background, preventing the infinite loop from continuing.
- A log is also added to indicate that the service is stopped.

What happens at runtime:

When the service starts:
- The onStartCommand() method is called, creating a new background thread that increments the counter every second.
- The counter value is logged in Logcat, making it visible in the log.
When the service is destroyed:
- The onDestroy() method is called, and the isRunning flag is set to false to stop the counting thread.
Binding:
- A client can bind to the service using the bindService() method, and it will be able to interact with the service using the getCounter() method.

Potential improvements or issues:

Thread management: The code creates a new thread each time the service is started. This might lead to thread leaks or overconsumption of resources if the service is started multiple times. You might want to handle thread creation more carefully.
Logging: If this service is run for a long time, logging a counter every second can fill up Logcat with messages. It’s worth considering if you need this level of logging.
Thread interruption: In case the service gets interrupted or stops, the thread might not exit cleanly. You should handle the interruption properly in the try-catch block.