Android's four major components Service

Recently, I haven't found a job yet, so I'm taking advantage of the time I have to sort out the previous things, otherwise it's easy to forget. Today I'm going to explain the usage of Service. As one of the four major components of Android, its importance can be imagined. In the application, we mainly use it to perform some background operations, without interacting with the application UI, and perform time-consuming tasks.

The official documentation says:

A Service is an application component that can perform long-running operations in the background without providing a user interface. Services can be started by other application components, and they continue to run in the background even if the user switches to another application.

Additionally, components can bind to services to interact with them and even perform inter-process communication (IPC). For example, services can handle network transactions, play music, perform file I/O, and so on.

or interact with content providers, all in the background.

Service Purpose:

1. Perform time-consuming operations in the background, but do not require user interaction. 2. Some functions exposed by an application for use by other applications.

One thing that needs to be stated here is that the Service runs in the main thread, so if you need to perform time-consuming operations or access the network, you need to start another thread in the Service to execute it (if you use IntentService, you don’t need to manually start the thread yourself).

Start Service

There are two ways to start a Service:

 Context.startService()

 Context.bindService()

(Picture taken from the official document: https://developer.android.com...)

When we start a service with the startService() method, we cannot control the service after it is started, and the service will always run in the background. Even if some of the code in it is executed, if we want to terminate the service, we need to call the stopSelf() method in its code or directly call the stopService() method. When the service is started with the bindService() method, the client will obtain a persistent connection to the service, and the client will obtain an IBinder object returned by the onBind(Intent) method of the service, which is used for the client to call back the callback method in the service.

No matter which method we use, we need to define a class, let it inherit the Service class, and rewrite several methods. If we use the startService() method to start, we only need to rewrite the onCreate(), onStartCommand(Intent intent, int flags, int startId), and onDestroy() methods (in fact, we can also rewrite them). If we use the bindService() method to start, we need to rewrite the onCreate(), onBind(Intent intent), and onUnbind(Intent intent) methods. Note that as one of the four major components, Service must be configured in the manifest file before use.

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

Context.startService()

Code of MyService.java:

 public class MyService extends Service {
 public MyService() {
 } 
 
 @Override
 public void onCreate() {
 super.onCreate(); 
 
        Log.i( "test" , "onCrete executed !" );
 } 
 
 @Override
 public   int onStartCommand(Intent intent, int flags, int startId) { 
 
        Log.i( "test" , "onStartComand executed !" );
 return super.onStartCommand(intent, flags, startId);
 } 
 
 @Override
 public void onDestroy() {
 super.onDestroy();
        Log.i( "test" , "onDestroy executed !" );
 }
 }

The code of MainActivity.java is as follows:

 public class MainActivity extends AppCompatActivity implements View .OnClickListener{ 
 
 Button btnStart,btnStop;
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main); 
 
        btnStart = (Button) findViewById(R.id.btn_start);
        btnStop = (Button) findViewById(R.id.btn_stop);
        btnStart.setOnClickListener(this);
        btnStop.setOnClickListener(this);
 } 
 
 
 @Override
 public void onClick( View   view ) { 
 
        Intent mIntent = new Intent(MainActivity.this,MyService.class); 
 
        switch ( view .getId()){
 case R.id.btn_start:
                startService(mIntent);
 break;
 case R.id.btn_stop:
                stopService(mIntent);
 break;
 }
 }
 }

The main interface has two buttons, one for starting the Service and one for stopping the Service:

Next, we click the START button, and the Log information is as follows:

It can be seen that the onCreate() method is executed first, and then the onStartCommand() method is executed immediately. What if we click the start button again? The result is as follows:

We can see that this time the onCreate() method is not executed again, but the onStartCommand() method is executed directly. This is because the onCreate() method is only executed when the Service is created for the first time. If it has already been created, then when startService() is called again to start the Service, only the onStartCommand() method will be executed, and the onCreate() method will not be executed again.

Next we click the stop button and you can see that the onDestroy() method is executed:

Note that if we do not click the stop button to manually stop the Service, the Service will continue to run in the background, even if the code in its onStartCommand() method has been executed, as we can see in the figure below:

At this time, our Service is always executed in the background, even if the code in its onStartCommand() method has been executed. If we want it to stop automatically, we can modify the code in the onStartCommand() method as follows:

 @Override
 public   int onStartCommand(Intent intent, int flags, int startId) { 
 
       Log.i( "test" , "onStartComand() executed !" );
 stopSelf();
 return super.onStartCommand(intent, flags, startId);
 }

Context.bindService()

The code for this method is slightly longer than before, because we need to control the Service on the client side, so we create an anonymous inner class ServiceConnection in MainActivity, and then pass it in the bindService() method and unbindService() method. The code in MyService.java is as follows:

 public class MyService extends Service {
    private MyBinder myBinder = new MyBinder(); 
 
 public MyService() {
 } 
 
 @Override
 public void onCreate() {
 super.onCreate();
        Log.i( "test" , "onCreate() executed !" );
 } 
 
 @Override
 public void onDestroy() {
 super.onDestroy();
        Log.i( "test" , "onDestroy() executed !" );
 } 
 
 @Override
 public boolean onUnbind(Intent intent) { 
 
        Log.i( "test" , "onUnbind executed !" );
 return super.onUnbind(intent);
 } 
 
 @Override
 public IBinder onBind(Intent intent) {
        Log.i( "test" , "onBind() executed !" );
 return myBinder;
 } 
 
    class MyBinder extends Binder{
 public void startDownload(){ 
 
            Log.i( "test" , "startDownload() in MyBinder executed!" );
 // To execute a specific download task, you need to start a child thread and execute specific code in it
 }
 }
 }

The code of MainActivity.java is as follows:

 public class MainActivity extends AppCompatActivity implements View .OnClickListener{ 
 
 Button btnBind,btnUnBind;
    MyService.MyBinder myBinder;
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main); 
 
        btnBind = (Button) findViewById(R.id.bind);
        btnUnBind = (Button) findViewById(R.id.btn_unBind);
        btnBind.setOnClickListener(this);
        btnUnBind.setOnClickListener(this); 
 
 } 
 
    ServiceConnection mServiceConnection = new ServiceConnection() {
 @Override
 public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
 // Transform IBinder down to our internal class MyBinder
            myBinder = (MyService.MyBinder) iBinder;
 // Execute the download task
            myBinder.startDownload();
 } 
 
 @Override
 public void onServiceDisconnected(ComponentName componentName) { 
 
 }
 }; 
 
 @Override
 public void onClick( View   view ) { 
 
        Intent mIntent = new Intent(MainActivity.this,MyService.class); 
 
        switch ( view .getId()){
 case R.id.bind:
 // Bind Service
                bindService(mIntent,mServiceConnection,BIND_AUTO_CREATE);
 break;
 case R.id.btn_unBind:
 // Unbind Service
                unbindService(mServiceConnection);
 break;
 }
 }
 }

Click the Bind button;

Click the Unbind button:

Note that if we click Cancel Bind directly without clicking Bind first, the program will crash directly with the following error:

 java.lang.IllegalArgumentException: Service not registered: com.qc.admin.myserializableparceabledemo.MainActivity$1@8860e28
 at android.app.LoadedApk.forgetServiceDispatcher(LoadedApk.java:1120)
 at android.app.ContextImpl.unbindService(ContextImpl.java:1494)
 at android.content.ContextWrapper.unbindService(ContextWrapper.java:616)
 at com.qc.admin.myserializableparceabledemo.MainActivity.onClick(MainActivity.java:71)

Careful people may have already discovered that the sentence "onServiceDisconnected executed!" is not printed in the Log, which means that the onServiceDisconnected() method is not called? From a literal understanding, the onServiceConnected() method is called when the Service establishes a connection. Shouldn't onServiceDisconnected() be called when the Service disconnects? In fact, it is not. We can see it by looking at the documentation of the method:

Called when a connection to the Service has been lost. This typically happens when the process hosting the service has crashed or been killed. This does not remove the ServiceConnection itself -- this binding to the service will remain active, and you will receive a call to onServiceConnected(ComponentName, IBinder) when the Service is next running.

This means: this method will be called when the connection bound to the Service is lost, typically when the process holding the Service crashes or is killed. But this does not remove the ServiceConnection itself - it remains active, and the onServiceConnected(ComponentName, IBinder) method will still be called when the Service is executed next time.

But please note that if we follow what we just said and do not click the bindService() method first, but directly click the unbindService() method, the program will crash, but the onServiceDisconnected() method will not be called. This is easy to understand. After all, there is no connection, so how can we disconnect it? But what if we have bound the Service and then terminate the Service directly in the background? What will be the result? The answer is that the onServiceDisconnected() method will still not be called. Here I think it should be that the process ends only in unexpected circumstances, and it is called automatically by the system, rather than being stopped manually by us. We can check the comments inside this method:

This is called when the connection with the service has been

unexpectedly disconnected -- that is, its process crashed.Because it

is running in our same process, we should never see this happen.

This text clearly explains the scenario in which this method is executed: the connection is disconnected due to an exception. That is, the process crashes. Because it runs in the process where our application is located, we will never want to see this happen.

Using Context.startService() and Context.bindService() at the same time

These two methods can be used at the same time, but please note that the startService() and stopService() methods are corresponding, and the bindService() and unBind() methods are corresponding, that is, if we call startService() first and then bindService(), or vice versa, then if we only call stopService() or only call bindService(), we cannot stop the Service. We can only call them at the same time.

Let's look at the specific code:

MainActivity.java

 public class MainActivity extends AppCompatActivity implements View .OnClickListener{ 
 
    Button btnStart,btnStop,btnBind,btnUnBind;
    MyService.MyBinder myBinder;
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main); 
 
        btnStart = (Button) findViewById(R.id.btn_start);
        btnStop = (Button) findViewById(R.id.btn_stop);
        btnBind = (Button) findViewById(R.id.btn_bind);
        btnUnBind = (Button) findViewById(R.id.btn_unBind); 
 
        btnStart.setOnClickListener(this);
        btnStop.setOnClickListener(this);
        btnBind.setOnClickListener(this);
        btnUnBind.setOnClickListener(this); 
 
 } 
 
    ServiceConnection mServiceConnection = new ServiceConnection() {
 @Override
 public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
 // Transform IBinder down to our internal class MyBinder
            myBinder = (MyService.MyBinder) iBinder;
 // Execute the download task
            myBinder.startDownload(); 
 
 } 
 
 @Override
 public void onServiceDisconnected(ComponentName componentName) { 
 
            Log.i( "test" , "onServiceDisconnected executed !" );
 }
 }; 
 
 @Override
 public void onClick( View   view ) { 
 
        Intent mIntent = new Intent(MainActivity.this,MyService.class); 
 
        switch ( view .getId()){
 case R.id.btn_start:
 // Start the Service
                startService(mIntent);
 break;
 case R.id.btn_stop:
 //Terminate the Service
                stopService(mIntent);
 break;
 case R.id.btn_bind:
 // Bind Service
                bindService(mIntent,mServiceConnection,BIND_AUTO_CREATE);
 break;
 case R.id.btn_unBind:
 // Unbind Service
                unbindService(mServiceConnection);
 break;
 }
 }
 }

Code of MyService.java:

 public class MyService extends Service {
    private MyBinder myBinder = new MyBinder(); 
 
 public MyService() {
 } 
 
 @Override
 public void onCreate() {
 super.onCreate();
        Log.i( "test" , "onCreate() executed !" );
 } 
 
 @Override
 public   int onStartCommand(Intent intent, int flags, int startId) { 
 
        Log.i( "test" , "onStartComand() executed !" );
 return super.onStartCommand(intent, flags, startId);
 } 
 
 @Override
 public void onDestroy() {
 super.onDestroy();
        Log.i( "test" , "onDestroy() executed !" );
 } 
 
 @Override
 public boolean onUnbind(Intent intent) { 
 
        Log.i( "test" , "onUnbind executed !" );
 return super.onUnbind(intent);
 } 
 
 @Override
 public IBinder onBind(Intent intent) {
        Log.i( "test" , "onBind() executed !" );
 return myBinder;
 } 
 
    class MyBinder extends Binder{
 public void startDownload(){ 
 
            Log.i( "test" , "startDownload() in MyBinder executed!" );
 // Execute specific download tasks
 }
 }
 }

a. Below is the output of clicking the start, bind, stop, and unBind buttons in sequence:

b. Below is the output when clicking the start, bind, unbind, and stop buttons in sequence:

Running a service in the foreground

We have been saying above that Service is generally used to perform time-consuming operations in the background, but you should know that Service can also run in the foreground. Background Service has a lower priority and is likely to be killed by the system in situations such as insufficient memory. By setting it to the foreground, the chance of it being killed can be greatly reduced. The foreground Service will display an icon in the system notification bar, where we can perform some operations. Common scenarios for foreground Service include music players and weather forecasts:

Then let's go directly to the code:

 @Override
 public void onCreate() {
 super.onCreate();
        Log.i( "test" , "onCreate() executed !" ); 
 
        Intent mIntent = new Intent(this, SecondActivity.class);
        PendingIntent mPendingIntent = PendingIntent.getActivity(this, 0, mIntent, 0);
        Notification mNotification = new NotificationCompat.Builder(this)
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentTitle( "My Notification " )
                .setContentText( "Hello World! " )
                .setContentIntent(mPendingIntent)
 .build(); 
 
 // NOTE: The integer ID provided to startForeground() must not be 0.
 // To remove the service from the foreground, call stopForeground(). This method takes a boolean indicating whether to also remove the status bar notification.
 // However, stopForeground() does not stop the service. However, if you stop the service while it is running in the foreground, the notification will also be removed.
        startForeground(1, mNotification);
 }

In fact, the implementation here is very simple, that is, passing a Notification through startForeground(1, mNotification);, so as to establish an association between the Notification and the Service. When we click on this notification, it will jump to the second Activity (but the Notification will not disappear), as shown in the screenshot below: