Android Bound And Unbound Services Complete Guide

1. Setting Up the Android Project

First, ensure you have Android Studio installed. Follow these steps to create a new project:

1. Open Android Studio.
2. Create a New Project:
   • Select “Empty Activity”.
   • Click “Next”.
   • Name your project, e.g., ServicesExample.
   • Choose “Java” or “Kotlin” as your language (we'll use Kotlin in this example).
   • Configure other settings as needed (minimum SDK, etc.).
   • Click “Finish”.

Once the project is set up, you will have an MainActivity and a res/layout/activity_main.xml file.

2. Unbound Services

An Unbound Service runs in the background independently of any user interface. It can perform long-running operations (like downloading files, playing music) without needing to interact with the UI.

Step 1: Create the Unbound Service

In your ServicesExample project, create a new Service class:

1. Right-click on your app directory → New → Service → Service.
2. Name it MyUnboundService.
3. Choose “Create Service”.

class MyUnboundService : Service() {

    // 1. Override onBind
    override fun onBind(intent: Intent?): IBinder? {
        // Since it's an unbound service, return null
        return null
    }

    // 2. Override onCreate
    override fun onCreate() {
        super.onCreate()
        // Service is created
        Log.d("MyUnboundService", "Service Created")
    }

    // 3. Override onStartCommand
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // Handle the intent here
        Log.d("MyUnboundService", "Service Started")

        // Perform some tasks (e.g., download a file)
        Thread {
            for (i in 1..5) {
                Thread.sleep(1000) // Simulate work
                Log.d("MyUnboundService", "Working $i")
            }
            // Stop the service once the task is done
            stopSelf(startId)
        }.start()

        // Return START_NOT_STICKY to stop the service after it's done
        return START_NOT_STICKY
    }

    // 4. Override onDestroy
    override fun onDestroy() {
        super.onDestroy()
        // Service is destroyed
        Log.d("MyUnboundService", "Service Destroyed")
    }
}

Step 2: Declare the Service in the Manifest

Open the AndroidManifest.xml file and add the service declaration:

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/Theme.ServicesExample">
    <activity android:name=".MainActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

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

    <!-- Declare the unbound service -->
    <service
        android:name=".MyUnboundService"
        android:exported="false" />
</application>

• android:exported="false" is used to prevent other apps from starting the service. If you don't want your service to be private to your app, set it to true.

Step 3: Start the Unbound Service from MainActivity

Modify your MainActivity.kt to start and stop the service:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Button to start the service
        val startServiceButton: Button = findViewById(R.id.start_service_button)
        startServiceButton.setOnClickListener {
            // Create an intent for MyUnboundService
            val myServiceIntent = Intent(this, MyUnboundService::class.java)
            // Start the service
            startService(myServiceIntent)
        }

        // Button to stop the service
        val stopServiceButton: Button = findViewById(R.id.stop_service_button)
        stopServiceButton.setOnClickListener {
            // Create an intent for MyUnboundService
            val myServiceIntent = Intent(this, MyUnboundService::class.java)
            // Stop the service
            stopService(myServiceIntent)
        }
    }
}

Step 4: Add Buttons to activity_main.xml

Modify the layout/activity_main.xml to include two buttons for starting and stopping the service:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <!-- Button to start the unbound service -->
    <Button
        android:id="@+id/start_service_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Start Service"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="50dp"/>

    <!-- Button to stop the unbound service -->
    <Button
        android:id="@+id/stop_service_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Stop Service"
        android:layout_below="@id/start_service_button"
        android:layout_alignStart="@id/start_service_button"
        android:layout_alignEnd="@id/start_service_button"
        android:layout_marginTop="20dp"/>

</RelativeLayout>

Step 5: Run the Application

1. Run the app on an emulator or a physical device.
2. Click the "Start Service" button to start the service.
3. Check the Logcat to see the service starting, working, and then stopping.
4. Click the "Stop Service" button to stop the service (though in this example, the service stops automatically after the task is completed).

3. Bound Services

A Bound Service processes inter-process communication (IPC) requests from other components (e.g., activities, other services). Clients can bind to a bound service by calling bindService(). Bound services typically perform operations on behalf of a client and do not automatically run in the background when there are no clients bound to them.

Step 1: Create the Bound Service

1. Right-click on your app directory → New → Service → Service.
2. Name it MyBoundService.
3. Choose “Create Service”.

class MyBoundService : Service() {

    // Binder given to clients
    private val binder = LocalBinder()

    // Class used for the client Binder
    inner class LocalBinder : Binder() {
        // Return this instance of MyBoundService so clients can call public methods
        fun getService(): MyBoundService = this@MyBoundService
    }

    // 1. Override onBind
    override fun onBind(intent: Intent): IBinder {
        return binder
    }

    // 2. Override onCreate
    override fun onCreate() {
        super.onCreate()
        Log.d("MyBoundService", "Service Created")
    }

    // 3. Override onDestroy
    override fun onDestroy() {
        super.onDestroy()
        Log.d("MyBoundService", "Service Destroyed")
    }

    // Example method that clients can call
    fun getRandomNumber(): Int {
        return Random.nextInt(0, 100)
    }
}

Step 2: Declare the Bound Service in the Manifest

Ensure the service is declared in your AndroidManifest.xml (if it's not already declared):

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/Theme.ServicesExample">
    <activity android:name=".MainActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

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

    <!-- Declare the unbound service -->
    <service
        android:name=".MyUnboundService"
        android:exported="false" />

    <!-- Declare the bound service -->
    <service
        android:name=".MyBoundService"
        android:exported="false" />
</application>

Step 3: Bind and Unbind the Service from MainActivity

Modify MainActivity.kt to bind and unbind the service:

class MainActivity : AppCompatActivity() {

    private var myBoundService: MyBoundService? = null
    private var isBound = false

    // Connection to the bound service
    private val connection = object : ServiceConnection {

        override fun onServiceConnected(componentName: ComponentName, binder: IBinder) {
            // We've bound to MyBoundService, cast the IBinder and get MyBoundService instance
            val localBinder = binder as MyBoundService.LocalBinder
            myBoundService = localBinder.getService()
            isBound = true
            Log.d("MainActivity", "Service Connected")
        }

        override fun onServiceDisconnected(componentName: ComponentName) {
            // Service has unexpectedly disconnected; unbind from it and nullify it
            myBoundService = null
            isBound = false
            Log.d("MainActivity", "Service Disconnected")
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val startServiceButton: Button = findViewById(R.id.start_service_button)
        val stopServiceButton: Button = findViewById(R.id.stop_service_button)
        val getRandomNumberButton: Button = findViewById(R.id.get_random_number_button)

        startServiceButton.setOnClickListener {
            val myServiceIntent = Intent(this, MyUnboundService::class.java)
            startService(myServiceIntent)
        }

        stopServiceButton.setOnClickListener {
            val myServiceIntent = Intent(this, MyUnboundService::class.java)
            stopService(myServiceIntent)
        }

        getRandomNumberButton.setOnClickListener {
            if (isBound) {
                val randomNumber = myBoundService?.getRandomNumber()
                Toast.makeText(this, "Random Number: $randomNumber", Toast.LENGTH_SHORT).show()
            } else {
                Toast.makeText(this, "Service not bound", Toast.LENGTH_SHORT).show()
            }
        }

        // Bind the service
        val bindServiceIntent = Intent(this, MyBoundService::class.java)
        bindService(bindServiceIntent, connection, Context.BIND_AUTO_CREATE)
    }

    override fun onDestroy() {
        super.onDestroy()
        // Unbind the service when the activity is destroyed
        if (isBound) {
            unbindService(connection)
            isBound = false
            Log.d("MainActivity", "Service Unbound")
        }
    }
}

Step 4: Add a Button for Bound Service Operation

Modify activity_main.xml to include a button for getting a random number:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/start_service_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Start Service"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="50dp"/>

    <Button
        android:id="@+id/stop_service_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Stop Service"
        android:layout_below="@id/start_service_button"
        android:layout_alignStart="@id/start_service_button"
        android:layout_alignEnd="@id/start_service_button"
        android:layout_marginTop="20dp"/>

    <Button
        android:id="@+id/get_random_number_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Get Random Number"
        android:layout_below="@id/stop_service_button"
        android:layout_alignStart="@id/stop_service_button"
        android:layout_alignEnd="@id/stop_service_button"
        android:layout_marginTop="20dp"/>

</RelativeLayout>

Step 5: Run the Application

1. Run the app on an emulator or a physical device.
2. Click the "Get Random Number" button to get a random number from the bound service.
3. Check the Logcat to see the service connecting and disconnecting (when the activity is destroyed).

4. Summary

• Unbound Services:

  • Purpose: Run independently in the background.
  • Lifecycle: onCreate() → onStartCommand() → onDestroy().
  • Start/Stop: Use startService() and stopService().

• Bound Services:

  • Purpose: Perform IPC with other components (activities, other services).
  • Lifecycle: onCreate() → onBind() → onUnbind() → onDestroy().
  • Bind/Unbind: Use bindService() and unbindService().