Lecture Mobile Application Development (119310)

Android Framework Basics

Agenda

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

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)

Service Lifecycle

center

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 (“power”)
  - A PowerManager for controlling power management.
- ALARM_SERVICE (“alarm”)
  - A AlarmManager for receiving intents at the time of your choosing.
- NOTIFICATION_SERVICE (“notification”)
  - A NotificationManager for informing the user of background events
- LOCATION_SERVICE (“location”)
  - A LocationManager for controlling location (e.g., GPS) updates.
- …

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>

Custom Service

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

public class MyService extends Service {

  @Override
public int onStartCommand(Intent intent, int flags, int startId) {
    //TODO do something useful
    return Service.START_NOT_STICKY;
 }
  @Override
public IBinder onBind(Intent intent) {
  //TODO for communication return IBinder implementation
    return null;
 }
}

Service Restart Options

Option	Description
Service.START_STICKY	Service is restarted, if it gets terminated. Intent data passed to the onStartCommand method is null. Used for services which manages their own state and do not depend on the Intent data.Service is not restarted. Used for services which are periodically triggered anyway. The service is only restarted, if the runtime has pending startService() calls since the service termination.
Service.START_NOT_STICKY	Service is not restarted. Used for services which are periodically triggered anyway. The service is only restarted, if the runtime has pending startService() calls since the service termination.
Service.START_REDELIVER_INTENT	Similar to Service.START_STICKY but the original Intent is re-delivered to the onStartCommand method.

Starting a Service

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

// Create an explicit intent
Intent i= new Intent(context, MyService.class);
// if needed, add data to the intent
i.putExtra("Param1", "Data for the service");
context.startService(i);

Custom Service

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();}
}

Android Assignment - Service

Open Android Assignment on Service
- Create a Service in your application that executes long background task running in its own thread in order not to block the UI
- Simulate the background task by using wait()

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 …

Broadcast Receiver

System Broadcast Examples

Event	Description
Intent.ACTION_BOOT_COMPLETED	Boot completed. Requires the android.permission.RECEIVE_BOOT_COMPLETED permission
Intent.ACTION_POWER_CONNECTED	Power got connected to the device
Intent.ACTION_POWER_DISCONNECTED	Power got disconnected from the device
Intent.ACTION_BATTERY_LOW	Battery gets low, typically used to reduce activities in your app which consume power
Intent.ACTION_BATTERY_OKAY	Battery status good again

Broadcast Receiver

To receive a Broadcast, extend the BroadcastReceiver class:

public class MyPhoneReceiver extends BroadcastReceiver {

 @Override
 public void onReceive(Context context, Intent intent) {
	Toast.makeText(context,"Incoming phone call", Toast.LENGTH_LONG).show();
 }
}

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()

Local Broadcasts

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

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

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

Local Broadcasts

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);
  }
};

Local Broadcasts

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();
}

Local Broadcasts

The LocalBroadCastManager Class is part of the Android Support Library package android.support.v4.content
You might need to link it to your project first, if is not already included
- This is done in Android Studio in your Project Structure-Dependencies or in the gradle.build file

Sending a Broadcast

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);

Android Assignment - Broadcast Receiver

Open Android Assignment on BroadcastReceiver
- Use an BroadcastReceiver and a local broadcast to notify the activity when the task executed by the service is finished

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

Recab 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?