Use of Android basic IntentService

A brief description of the service

1. Foreground service and IntentService:

The foreground service can keep running all the time without being recycled due to insufficient system memory.

Service service test preparation code

We use a specific case to illustrate the introduction of the service life cycle of the start and bind methods. The project results are as follows:

1. Do some initialization work in MainActivity.java , as follows:

 private   final   static String TAG = "MyIntentService" ;
 private MyIntentService.MyBinder binder; 
 
 private ServiceConnection connection = new ServiceConnection() {
 @Override 
     public   void onServiceConnected(ComponentName name, IBinder service) {
        binder = (MyIntentService.MyBinder) service;
        binder.sayHello(name.getClassName());
 } 
 
 @Override 
     public   void onServiceDisconnected(ComponentName name) {
        Log.i(TAG, "service disconnect: " + name.getClassName());
 }
 }; 
 
 @Override
 protected   void onCreate(Bundle savedInstanceState) { 
     super .onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
 }

2. Create a simple IntentService service class : MyIntentService

 package com.example.linux.intentservicetest; 
 
 import android.app.IntentService;
 import android.content.Intent;
 import android.os.Binder;
 import android.os.IBinder;
 import android.util.Log; 
 
 public   class MyIntentService extends IntentService { 
     private   final   static String TAG = "MyIntentService" ; 
     private MyBinder myBinder = new MyBinder(); 
 
     class MyBinder extends Binder { 
         public   void sayHello(String name) {
            Log.i(TAG, "say hello method: " + name);
 } 
 
         public   void sayWorld(String name) {
            Log.i(TAG, "say world method: " + name);
 }
 } 
 
 @Override 
     public IBinder onBind(Intent intent) { 
         return myBinder;
 } 
 
     public MyIntentService() { 
         super ( "MyIntentService" );
        Log.i(TAG, "myintent service constructor." );
 } 
 
 @Override 
     public   void onCreate() {
        Log.i(TAG, "on create." ); 
         super .onCreate();
 } 
 
 @Override 
     protected   void onHandleIntent(Intent intent) {
        Log.i(TAG, "handle intent: " + intent.getStringExtra( "username" ) + ", thread: " + Thread.currentThread());
 } 
 
 @Override 
     public   void onDestroy() { 
         super .onDestroy();
        Log.i(TAG, "on destroy." );
 } 
 
 @Override 
     public   int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG, "on start command." ); 
         return   super .onStartCommand(intent, flags, startId);
 } 
 
 @Override 
     public   boolean onUnbind(Intent intent) { 
         //Default return false  
        String username = intent.getStringExtra( "username" );
        Log.i(TAG, "on unbind: " + super .onUnbind(intent) + ", username: " + username); 
         return   true ;
 } 
 
 @Override 
     public   void onRebind(Intent intent) {
        Log.i(TAG, "on rebind" ); 
         super .onRebind(intent);
 }
 }

3. Create a simple front desk service class : FrontService

 package com.example.linux.intentservicetest; 
 
 import android.app.Notification;
 import android.app.PendingIntent;
 import android.app.Service;
 import android.content.Intent;
 import android.os.IBinder;
 import android.util.Log; 
 
 public   class FrontService extends Service { 
     private   final   static String TAG = "MyIntentService" ; 
     public FrontService() {
        Log.i(TAG, "front service constructor" );
 } 
 
 @Override 
     public IBinder onBind(Intent intent) { 
         return   null ;
 } 
 
 @Override 
     public   void onCreate() { 
         super .onCreate();
        Notification.Builder builder = new Notification.Builder( this );
        Intent intent = new Intent( this , MainActivity. class );
        PendingIntent pendingIntent = PendingIntent.getActivity( this , 0, intent,
                PendingIntent.FLAG_CANCEL_CURRENT); 
 
        builder.setSmallIcon(R.mipmap.ic_launcher).setTicker( "ticker" );
        builder.setWhen(System.currentTimeMillis()).setAutoCancel( true );
        builder.setContentTitle( "content title" ).setContentText( "content text" );
        builder.setContentIntent(pendingIntent); 
 
        Notification notify = builder.getNotification(); 
 
        notify.defaults = Notification.DEFAULT_ALL;
        startForeground(10, notify);
 }
 }

4. Register services and activities in AndroidManifest.xml :

 <activity android:name= ".MainActivity" >
 <intent-filter>
        <action android:name= "android.intent.action.MAIN" />
        <category android:name= "android.intent.category.LAUNCHER" />
 </intent-filter>
 </activity> 
 
 <service
    android:name= ".MyIntentService"  
    android:exported= "false" >
 </service>
 <service
    android:name= ".FrontService"  
 android:enabled= "true"  
    android:exported= "true" >
 </service>

Use of Intent Service

1. Create methods in MainActivity to start and stop services:

 // Start the service  
 public   void startService(View view) {
    Intent intent = new Intent();
    intent.putExtra( "username" , "linux" );
    intent.setClass(MainActivity. this , MyIntentService. class );
 startService(intent);
 } 
 
 // Stop the service  
 public   void stopService(View view) {
    Intent intent = new Intent();
    intent.setClass(MainActivity. this , MyIntentService. class );
 stopService(intent);
 }

2. Create a method in MainActivity to bind and unbind services:

 // Bind service  
 public   void bindService(View view) {
    Intent intent = new Intent();
    intent.setClass(MainActivity. this , MyIntentService. class );
    intent.putExtra( "username" , "linux" ); 
     boolean isBind = bindService(intent, connection, Context.BIND_AUTO_CREATE);
    Log.i(TAG, "bind service: " + isBind);
 } 
 
 // Unbind service  
 public   void unbindService(View view) {
    Intent intent = new Intent();
    intent.setClass(MainActivity. this , MyIntentService. class );
    unbindService(connection);
 }

3. Operation results :

Click start:

 03-25 08:01:53.460 8389-8389/? I/MyIntentService: myintent service constructor.
 03-25 08:01:53.460 8389-8389/? I/MyIntentService: on create.
 03-25 08:01:53.475 8389-8389/? I/MyIntentService: on start command.
 03-25 08:01:53.477 8389-8727/? I/MyIntentService: handle intent: linux, thread: Thread[IntentService[MyIntentService],5,main]
 03-25 08:01:53.478 8389-8389/? I/MyIntentService: on destroy.

Click stop: no output Click bind:

 03-25 08:02:25.421 8389-8389/? I/MyIntentService: bind service: true  
 03-25 08:02:25.422 8389-8389/? I/MyIntentService: myintent service constructor.
 03-25 08:02:25.422 8389-8389/? I/MyIntentService: on create.
 03-25 08:02:25.432 8389-8389/? I/MyIntentService: say hello method: com.example.linux.intentservicetest.MyIntentService

Click unbind:

 03-25 08:02:28.486 8389-8389/? I/MyIntentService: on unbind: false , username: linux
 03-25 08:02:28.490 8389-8389/? I/MyIntentService: on destroy.

Use of front desk services

1. Create a method in MainActivity to start the foreground service:

 //Use of foreground service  
 public   void frontService(View view) {
    Intent intent = new Intent();
    intent.setClass(MainActivity. this , FrontService. class );
 startService(intent);
 }

2. Operation results : In the notification bar of the mobile phone

Analysis of the principle of IntentService

1. intentService is an abstract method that inherits Service :

 public   abstract   class IntentService extends Service

2. Some fields contained in intentService are referenced as follows :

 private   volatile Looper mServiceLooper;
 private   volatile ServiceHandler mServiceHandler;
 private String mName;
 private   boolean mRedelivery; 
 
 private   final   class ServiceHandler extends Handler { 
     public ServiceHandler(Looper looper) { 
         super (looper);
 } 
 
 @Override 
     public   void handleMessage(Message msg) {
        onHandleIntent((Intent)msg.obj);
 stopSelf(msg.arg1);
 }
 }

2. When starting a service, the constructor is executed first, followed by the onCreate method, and then the onStartCommand method. The onStart method is executed in onStartCommand (the execution process is described in Android Basics ----> Service Lifecycle):

The onCreate method starts a thread, gets the Looper and initializes a Handler

 @Override
 public   void onCreate() { 
     // TODO: It would be nice to have an option to hold a partial wakelock  
     // during processing, and to have a static startService(Context, Intent)  
     // method that would launch the service & hand off a wakelock.  
 
     super .onCreate();
    HandlerThread thread = new HandlerThread( "IntentService[" + mName + "]" );
 thread.start(); 
 
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
 }

onStart method, using the above Handler to send information

 @Override
 public   void onStart(Intent intent, int startId) {
    Message msg = mServiceHandler.obtainMessage();
 msg.arg1 = startId;
 msg.obj = intent;
    mServiceHandler.sendMessage(msg);
 }

onStartCommand method, calls onStart method, sends information

 @Override
 public   int onStartCommand(Intent intent, int flags, int startId) {
 onStart(intent, startId); 
     return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
 } 
 

***The above Handler gets the information and calls the handleMessage method, which contains the stopSelf(msg.arg1) method to stop the service:

3. Here are two methods of the service class, the source code is android6.0

The onStart method in Service has been deprecated:

 /**
 * @deprecated Implement {@link #onStartCommand(Intent, int, int)} instead.
 */  
 @Deprecated
 public   void onStart(Intent intent, int startId) {
 }

In the onStartCommand method

 public   int onStartCommand(Intent intent, int flags, int startId) {
 onStart(intent, startId); 
     return mStartCompatibility ? START_STICKY_COMPATIBILITY : START_STICKY;
 }