1 Agenda

• Framework Components Part V - Service
  • Service Lifecycle
  • System Services
  • Custom Service
• Framework Components Part VI - BroadcastReceiver
  • System Broadcasts
  • Receiver Registration
  • Local Broadcasts

2 Service

• A Service provides two main features:
  • A facility for the application to tell the system about something it wants to be doing in the background
    • Calls to Context.startService()
• A facility for an application to expose some of its functionality to other applications
  • Calls to Context.bindService()
• A Service is not a separate process
• A Service is not a thread (unless you want it to be)

2.1 Service Lifecycle

2.2 System Services

• Android provides a number of predefined system services
• They are exposed via a specific Manager class
• Use getSystemService() to gain access to the service, e.g.
  • POWER_SERVICE to get a PowerManager and control power management actions.
  • ALARM_SERVICE to get an AlarmManager and create intents at the time of your choosing.
  • NOTIFICATION_SERVICE to get a NotificationManager and inform the user via device notifications
  • LOCATION_SERVICE to get a LocationManager and receive for example location (e.g. GPS) updates.
  • ...

_For more services read the documentation of Context

2.3 Custom Service

• A service needs to be declared in the AndroidManifest.xml

<service
  android:name="MyService"
  android:icon="@drawable/icon"
  android:label="@string/service_name">
</service> 

2.4 Custom Service

• The implementing class must extend the Service class or one of its subclasses

class MyService : Service() {
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        //TODO do something useful
        return Service.START_NOT_STICKY
    }

    override fun onBind(intent: Intent?): IBinder? {
        //TODO for communication return IBinder implementation
        return null
    }
} 

2.5 Service Restart Options

2.6 Starting a Service

• Use the startService() method to start the service from within your activity

// Create an explicit intent
val i = Intent(context, MyService::class.java)

// if needed, add data to the intent
i.putExtra("Param1", "Data for the service")
context.startService(i)

2.7 Custom Service Example

• Use IntentService for asynchronous single tasks in the background

public class ExampleService extends IntentService {

    public ExampleService() {
        super("ExampleService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        int waitTime = (int) intent.getExtras().get("wait_time");
        // do work here, e.g. download file
        try {
            Thread.sleep(waitTime * 1000);
            intent.setAction("MYSERVICE_FINISHED_ACTION");
            LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(intent);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // ...
}

3 Broadcast Receiver

• Specialized event Intent handlers (like a message mailbox)
• Subscription to specific action strings (possibly multiple)
  • Action strings are defined by the system or developer.
  • System broadcasts: e.g. timezone changed, low battery, picture has been taken, user changed language preferences
  • Application broadcasts: e.g. finished download, data is ready ...

4 Broadcast Receiver

• System Broadcast Examples

5 Broadcast Receiver

• To receive a Broadcast, extend the BroadcastReceiver class:

class MyPhoneReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        Toast.makeText(context, "Incoming phone call", Toast.LENGTH_LONG).show()
    }
}

6 Broadcast Receiver

• For System Broadcast, register your class via the AndroidManifest.xml
• Use intent-filters to specify the intents that your receiver will react on, e.g.:

<receiver android:name="MyPhoneReceiver" >
 <intent-filter>
  <action android:name="android.intent.action.PHONE_STATE" >
  </action>
 </intent-filter>
</receiver>

• Or register the class dynamically via registerReceiver(Broadcast receiver, IntentFilter filter)
  • This is usually done for local (app internal) broadcasts (see next slides)
• Always unregister your receiver using unregisterReceiver()

6.1 Local Broadcasts (Deprecated)

• Use the LocalBroadcastManager to send messages within your application
  • This is faster and has no security issues
• Register the receiver in your onResume() method, e.g.

Note: The usage of LocalBroadCastManager is not recommended. Modern ways suggest the usage of LiveData that follows the observable pattern.

public void onResume() {
  super.onResume();

  // Register mMessageReceiver to receive messages.
  LocalBroadcastManager.getInstance(this)
        .registerReceiver(mMessageReceiver, new IntentFilter("my-event"));
}

6.2 Local Broadcasts (Deprecated)

• Implement the BroadcastReceiver as usual, e.g.

private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() {
  @Override
  public void onReceive(Context context, Intent intent) {
    // Extract data included in the Intent
    String message = intent.getStringExtra("message");
    Log.d("receiver", "Got message: " + message);
  }
};

6.3 Local Broadcasts (Deprecated)

• Unregister the receiver in your onPause() method, e.g.

protected void onPause() {
  // Unregister since the activity is not visible
  LocalBroadcastManager.getInstance(this).unregisterReceiver(mMessageReceiver);
  super.onPause();
} 

6.4 Local Broadcasts (Deprecated)

• The LocalBroadCastManager class is part of AndroidX library
• You might need to link it to your project first, if it is not already included
  • This is done in Android Studio in your Project Structure-Dependencies or in the gradle.build file

6.5 Sending a Broadcast (Deprecated)

• Sending a custom broadcast is done by using the method sendBroadcast(Intent intent), e.g.

Intent intent = new Intent();
intent.setAction("my-event");
sendBroadcast(intent); 

• Sending a custom local broadcast is done by using the method sendBroadcast(Intent intent) of the LocalBroadcastManager, e.g.

Intent intent = new Intent();
intent.setAction("my-event");
LocalBroadcastManager.getInstance(this).sendBroadcast(intent); 

7 Summary

• Services can be used to do things in the background once (e.g. download a file) or to expose functionality to other apps (e.g. updating location information)
• Broadcast Receivers are used either to listen to system events, events of other apps or local events of your own apps
  • Security issues occur when sending system wide broadcasts, better use LocalBroadcastManager to send app specific broadcast events

8 Recap Questions

• When do you use a Service? Write down a few cases where you would use a Service.
• Can a Service block the UI-Thread?
• How would you communicate your Activity that your Service has finished executing a task?
• When would you use system broadcasts and when local broadcasts?
• Which software design pattern is used with the broadcasts on Android?