Android – Service

10、探究Service

如今,Android和IOS几乎占据了智能手机全部的市场份额,在这两大移动操作系统中,IOS一开始是不支持后台的,后来意识到这个功能的重要性,才逐渐添入这部分功能。而Android正好相反,一开始支持丰富的后台功能,后来意识到后台太过开放的弊端,于是逐渐消减了后台功能,不管怎么说,Service属于四大组件之一,其重要程度不言而喻。

10.1 Service是什么?

Service是Android中实现程序后台支持的解决方案,它非常适合执行那些不需要和用户交互而且还要求长期支持的任务。Service的支持不这件事于任何用户界面,即使程序被切换到后台,或者用户打开了另外一个程序,Service仍然能保持正常运行。

不过需要注意的是,Service并不是支持在独立的进程当中的,而是依赖于创建Service时所在的应用程序进程,当某个应用程序进程被杀掉时,所有依赖于该进程的Service也会停止运行。

另外不要被Service的后台概念所迷惑,实际上Service并不会自动开启线程,所有的代码都是在主线程中执行的。也就是说,我们需要在Service内手动创建子线程,并在这里执行具体的任务。否则 就有可以出现主线程被阻塞的情况。

10.2 Android多线程编程

如果你熟悉java的话,对多线程编程一定不会陌生吧、当我们需要去执行比较耗时的操作,比如发起一条网络请求时,考虑到网络等其他原因,服务器未必能够立刻响应我们的请求,如果不将这类操作放到子线程去执行,就会导致主线程被阻塞,从而影响用户对软件的正常使用。

10.2.1 回顾线程的基本用法

Android多线程编程其实并不比Java多线程特殊,基本是使用相同的语法。比如,定义一个线程只需要一个类继承自Thread,然后重写父类的run()方法,并在里面编写耗时的逻辑即可

class MyThread extends Thread {
   @Override
   public void run() {
       super.run();
  }
}

那么如何调用该线程呢?其实很简单,只需要创建MyThread的实例,然后调用它的start()方法即可,这样run()方法中的代码就会在子线程当中运行了。

public static void main(String[] args) {
   MyThread myThread = new MyThread();
   myThread.start();
}

当然,使用继承的方式耦合性有点高,我们会更多地选择使用实现Runnable接口的方式来定义一个线程,如

class MyThread implements Runnable {

   @Override
   public void run() {
       // Code...
  }
}

如果使用这这种写法,启动线程的方法也需要进行相应的改变,如

public static void main(String[] args) {
   Thread thread = new Thread(new MyThread());
   thread.start();
}

可见,Thread的构造函数接收一个Runnable参数,而我们创建的MyThread实例正是一个实现了Runnable接口的对象,所以可以直接将它传入Thread的构造函数里,接着调用Thread的start()方法,run()方法中的代码就会在子线程中运行了。

当然,如果你不想专门定义一个类去实现Runnable接口,也可以使用匿名内部类的方式

public static void main(String[] args) {
   Thread thread = new Thread(new Runnable() {
       @Override
       public void run() {
           // Code...
      }
  });
   thread.start();
}

可以简写为Lambda的方式

public static void main(String[] args) {
  Thread thread = new Thread(() ->{
      // Code...
  });
  thread.start();
}

以上这几种方式你应该不会陌生,因为在Java中创建和启动线程也是如此。

10.2.2 在子线程中更新UI

和许多GUI库一样,Android的UI也是线程不安全的。也就是说,如果想要更新应用程序里的UI元素,必须在主线程中进行。否则就会出现异常。

我们来验证一下吧,新建一个AndroidThreadTest项目

activity_main.xml

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

   <Button
       android:id="@+id/changeTextBtn"
       android:text="在子线程修改TextView的内容"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"/>

   <TextView
       android:textColor="#ff0000"
       android:textSize="20sp"
       android:id="@+id/textView"
       android:text="无刹:?"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"/>

</LinearLayout>

布局文件定义了两个控件:TextView用于在屏幕上显示 “无刹:?”字符串;Button用于改变TestView中显示的内容,我们希望在点击 Button 后把TextView显示的字符串改成 “无刹特斯拉”。

ActivityMain.java

package com.ziyia.androidthreadtest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import org.w3c.dom.Text;

public class MainActivity extends AppCompatActivity {
   private Button changesTextBtn;
   private TextView textView;
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       init();

       changesTextBtn.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               Thread thread = new Thread(() -> {
                   textView.setText("无刹特斯拉");
              });
          }
      });

  }

   private void init() {
       changesTextBtn = findViewById(R.id.changeTextBtn);
       textView = findViewById(R.id.textView);
  }
}

可见,我们在 Button 按钮的点击事件里面开启了一个子线程,然后在子线程中调用TextView的setText()方法 将显示的字符串修改成“无刹特斯拉”代码逻辑非常简单,只不过我们是在子线程是更新UI,现在运行程序,点击按钮,人会发现程序崩溃了,查看日志如下

由此证实了Android确实是不允许在子线程中进行UI操作的,但有些时候,我们必须在子线程里执行一些耗时任务,然后根据任务的执行结果来更新相应的UI控件,这该如何是好呢?

对于这种情况,Android提供了一套异步消息处理机制,完善地解决了在子线程中进行UI操作的问题。

package com.ziyia.androidthreadtest;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import org.w3c.dom.Text;

public class MainActivity extends AppCompatActivity {
   private Button changesTextBtn;
   private TextView textView;
   private final int updateText = 1;

   private class Obj extends Handler{
       @Override
       public void handleMessage(@NonNull Message msg) {
           switch (msg.what) {
               case updateText:
                   textView.setText("无刹特斯拉");
                   break;
          }
      }
  }
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       init();



       changesTextBtn.setOnClickListener(new View.OnClickListener() {
           Obj obj = new Obj();
           @Override
           public void onClick(View v) {
               Thread thread = new Thread(() -> {
                   Message message = new Message();
                   message.what = updateText;
                   obj.sendMessage(message);
              });
               thread.start();
          }
      });

  }

   private void init() {
       changesTextBtn = findViewById(R.id.changeTextBtn);
       textView = findViewById(R.id.textView);
  }
}

我们先是定义了一个整型变量updateText,用于表示更新TextVitw这个动作。然后新增一个内部类去继承Handler对象,并重写父类的handleMessage()方法,在这里对具体的Message进行处理,如果发现Message的what字段的值等于updateText,就将TextView显示的内容进行修改。

再来看一下 Button 按钮的点击事件,可见,这次我们并没有在子线程里直接进行UI操作,而是创建了一个Message(android.os.Message)对象,并将它的what字段的值指定为updateText,然后调用Handler的sendMessage()方法 将这条Message发送出去,很快,Handler就会接到这条Message,并在handleMessage()方法 中对它进行处理,注意此时,handleMessage()方法中的代码就是要主线程当中运行的了。所以我们可以放心地在这里进行UI操作。接下来对Message携带的what字段的值进行判断,如果等于updateText就将TextView显示的内容修改。

10.2.3 解析异步的处理机制

Android中的异步消息处理主要由4个部分组成:Message Handler MessageQueue和Looper。其中Message和Handler在上方例子已经说过了,而MessageQueue和Looper对于你来说还是全新的概念。

  1. MessageMessage是在线程之间传递的消息,它可以在内部携带少量消息,用于在不同线程之间传递数据,上方例子我们使用到了其中的what字段,除此之外还可以使用arg1 arg2字段来携带一些整型数据,使用obj字段携带一个Object对象
  2. HandlerHandler顾名思义也就是处理者的意思,它主要是用于改善和处理消息的,改善消息一般是使用Hander的sendMessage()方法,post()方法等,而发出的消息经过一系列的辗转处理之后,最终会传递到Handler的handleMessage()方法中
  3. MessageQueueMessageQueue是消息队列的意思,它主要是用于存放所有通过Handler发送的消息,这部分消息会一直存在消息队列中,等待被处理,每个线程只会有一个MessageQueue对象。
  4. LooperLooper是每个线程中的MessageQueue管家,调用Looper的loop()方法后, 就会进入一个无限循环当中,然后每当发现MessageQueue中存在一条消息时,就会将它取出,并传递到Handler的handleMessage()方法中,每个线程中只有一片Looper对象。我们来把上方的过程梳理一遍。首先需要在主线程当中创建一个Handler对象,并重写handlMessage()方法,然后当子纯种中需要进行UI操作时,就创建一个Message对象,并通过Handler将这条消息发送出去,之后这条消息会被添加到MessageQueue的队列中等待处理,而Looper则会一直尝试从MessageQueue中取出待处理消息,最后颁发回Handler的handleMessage()方法中,由于Handler是要主线程中创建的,所以此时handlerMessage()方法中的代码也会在主线程中运行,于是我们在这里就可以安心地进行UI操作了。整个异步消息机制过程如图所示

10.2.4 使用AsyncTask

为了更加方便我们在子线程中对UI进行操作,Android还提供了另外一些好用的工具。比如:AsyncTask。借助AsyncTask。即使你对异步消息处理机制完全不了解,也可以十分简单地从子线程切换到主线程。当然,AsyncTask背后的实现原理也是基于异步消息处理机制的。只是AsyncTask帮我们做好很好的封装。

AsyncTask是一个抽象类,所以如果我们想使用它,就必须创建一个子类去继承它,在继承时我们可以为AsyncTask类指定3个泛型参数,参数用途如下

  • Parms在执行AsyncTask时需要传入的参数,可用于在后台任务中使用
  • Progress在后台任务执行时,如果需要对结果进行返回,则使用这里指定的泛型作为返回类型返回。
  • Result当任务执行完毕后,如果需要对结果进行返回,则使用这里指定的泛型作为返回值类型。

因此,一个自定义的AsyncTask可以写成:

class DownLoadTask extends AsyncTask<Object, Integer, Boolean> {

}

这里我们把AsyncTask的第一个泛型参数指定为Object。第二个泛型参数指定为Integer,表示使用整型数据来作为进度显示单位。第三个泛型参数指定为Boolean,则表示使用布尔型数据来反馈执行结果。

当然,我们定义的AsyncTask还是一个空任务,我们还需要重写AsyncTask中的几个方法才能完成对任务的定制,需要重写的方法有以下4个

  1. onPreExcute()该方法会在后台任务开始执行之前调用,用于进行一些界面上的初始化操作,比如显示一个进度条对话框等
  2. doInBackground(Parms…)该方法中的所有代码博览会在子纯种中运行,我们应该在这里去处理所有的耗时任务,任务一旦完成,就可以通过return语句将任务的执行结果返回。注意,在这个方法中是不可以UI操作的,如果需要重新UI元素。比如说反馈当前任务的执行进度,可以调用publisProgress()方法来完成
  3. onPreogressUpdate(Progress…)当在后台任务中调用了publishProgress(Progress…)方法后,onProgressUpdate(Progress…)方法就会调用,该方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作,利用参数中的数值就可以对界面元素进行相应的更新。
  4. onPostExcute(Result)当后台任务执行完毕并通过return语句进行返回时,这个方法就很快会被调用,返回的数据会作为参数传递到此方法中,可以利用返回的数据进行一些UI操作,比如说提醒任务执行结果,以及关闭进度条对话框等

具体使用看下方例子:

我们在上一小节的例子上添加一个Activity,并添加一个按钮,点击按钮后跳转到AsyncTaskTest

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

   <Button
       android:id="@+id/toAsyncTaskTest"
       android:text="AsyncTask工具的使用"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"/>
   <Button
       android:id="@+id/changeTextBtn"
       android:text="在子线程修改TextView的内容"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"/>

   <TextView
       android:textColor="#ff0000"
       android:textSize="20sp"
       android:id="@+id/textView"
       android:text="无刹:?"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"/>

</LinearLayout>

MainActivity.java

package com.ziyia.androidthreadtest;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import org.w3c.dom.Text;

public class MainActivity extends AppCompatActivity {
   private Button changesTextBtn, toAsyncTask;
   private TextView textView;
   private final int updateText = 1;

   private class Obj extends Handler{
       @Override
       public void handleMessage(@NonNull Message msg) {
           switch (msg.what) {
               case updateText:
                   textView.setText("无刹特斯拉");
                   break;
          }
      }
  }
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       init();



       changesTextBtn.setOnClickListener(new View.OnClickListener() {
           Obj obj = new Obj();
           @Override
           public void onClick(View v) {
               Thread thread = new Thread(() -> {
                   Message message = new Message();
                   message.what = updateText;

                   obj.sendMessage(message);
              });
               thread.start();
          }
      });

       toAsyncTask.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               Intent intent = new Intent(MainActivity.this, AsyncTaskTest.class);
               startActivity(intent);
          }
      });

  }

   private void init() {
       changesTextBtn = findViewById(R.id.changeTextBtn);
       textView = findViewById(R.id.textView);
       toAsyncTask = findViewById(R.id.toAsyncTaskTest);
  }
}

activity_asynctask.xml

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

   <Button
       android:text="下载"
       android:onClick="down"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       tools:ignore="OnClick" />

   <TextView
       android:id="@+id/progress_text"
       android:textSize="15sp"
       android:text="0/100%"
       android:gravity="center"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"/>
   <ProgressBar
       android:max="100"
       android:id="@+id/progress"
       style="?android:attr/progressBarStyleHorizontal"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"/>
</LinearLayout>

我们添加了三个控件,Button用于编写下载逻辑,TextView用于显示下载的具体进度值,ProgressBar用于显示进度条。

package com.ziyia.androidthreadtest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

public class AsyncTaskTest extends AppCompatActivity {
   private ProgressBar progressBar;
   private Button down;
   private TextView text;
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_asynctasktest);
       progressBar = findViewById(R.id.progress);
       text = findViewById(R.id.progress_text);
  }

   public void down(View view) {
       DownLoadTask downLoadTask = new DownLoadTask();
       // 我们可以往execute()方法中传递参数,这些参数将会传递到DownLoadTask的doInBackground()方法当中
       downLoadTask.execute();
  }

   private class DownLoadTask extends AsyncTask<Object, Integer, Boolean> {
       private Integer p = 0;
       @Override
       protected void onPreExecute() {
           super.onPreExecute();
           progressBar.setProgress(0);
      }

       @Override
       protected Boolean doInBackground(Object... objects) {
           while (true) {
               Integer downloadPercent = doDownload();
               publishProgress(downloadPercent);
               if (downloadPercent >= 100) {
                   break;
              }
          }
           return true;
      }

       private Integer doDownload() {
           try {
               Thread.sleep(100);
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
           return ++p;
      }

       @Override
       protected void onProgressUpdate(Integer... values) {
           super.onProgressUpdate(values);
           // 在这里更新下载进度
           text.setText(values[0].toString() + "/100%");
           progressBar.setProgress(values[0]);
      }

       @Override
       protected void onPostExecute(Boolean aBoolean) {
           super.onPostExecute(aBoolean);
           // 在这里显示下载结果。比如:下载成功 或 下载失败
           if (aBoolean) {
               Toast.makeText(AsyncTaskTest.this, "下载成功", Toast.LENGTH_SHORT).show();
          } else {
               Toast.makeText(AsyncTaskTest.this, "下载失败", Toast.LENGTH_SHORT).show();
          }
           return;
      }
  }
}

在这个DownLoadTask中,我们在doInBackground()方法执行具体的下载任务。这个方法里代码都是在子线程中执行的,因而不会影响主线程的运行。注意,我们这里虚构了一个doDownload()方法用于计算当前的下载进度并返回。在得到下载进度后,下面就该考虑如何把它显示到界面上了,由于doInBackground()方法是在子线程中执行的,在这里肯定不能UI操作,所以我们可以调用publishProgress()方法并传入当前下载进度,这样onProgressUpdate()方法就会很快被调用,在这里就可以进行UI操作了。

当下载完成后,doInBackground()方法会返回一个布尔型变量,这样onPostExcute()方就会很快被调用,这个方法也是在主线程中运行的,然后,在这个我们会根据下载的结果弹出相应的Toast提示。从而完成整个DownLoadTask任务。

简单来说就是,使用AsyncTask的决窍就是,在doInBackground()方法中执行具体的耗时任务。在onProgressUpdate()方法中进行UI操作,在onPostExecute()方法中执行一些任务的收尾工作。

如何想要启动这个任务,只需要获得DownLoadTask的实例,并调用其execute()方法即可。

当然你也可以往这个方法中传递参数,这些参数将会传递到DownLoadTask的doInBackground()方法当中。

效果图

10.3 Service的基本用法

作为Android四大组件之一,Service也少不了有很多非常重要的知识点

10.3.1 定义一个Service

首先看一下如何在项目中定义一个Service,我们新建一个ServiceTest项目,然后在包名上右键创建Service,

我们类名定义成MyService,Exported属性表示是否将这个Service暴露给外部其他程序访问,Enabled属性表示是否启用这个Service,将两个属性都勾中,点击 “Finish”

MyService.java

package com.ziyia.servicetest;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

import androidx.annotation.Nullable;

public class MyService extends Service {


   @Nullable
   @Override
   public IBinder onBind(Intent intent) {
       return null;
  }
}

可见,MyService是继承自系统的Service类的,目前MyService中可以算是空空如也,但有一个onBind()方法特别醒目,这个方法是Service中唯一的抽象方法,所以必须在子类里实现。

定义Service,自然是要处理一些事情了,这时就可以重写Service中的另外一些方法了,如下

package com.ziyia.servicetest;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

import androidx.annotation.Nullable;

public class MyService extends Service {


   @Nullable
   @Override
   public IBinder onBind(Intent intent) {
       return null;
  }

   @Override
   public void onCreate() {
       super.onCreate();
  }

   @Override
   public int onStartCommand(Intent intent, int flags, int startId) {
       return super.onStartCommand(intent, flags, startId);
  }

   @Override
   public void onDestroy() {
       super.onDestroy();
  }
}

可见,这里我们又重写了onCreate()、onStartCommand()和onDestroy()这3个方法,它们是每个Service中最常用的3个方法了,其中onCreate()方法会在Service()创建的时候调用,onStartCommand()方法会在每次Service启动的时候调用,onDestroy()方法会在Service()销毁前调用。

另外需要注意,每个Service都需要在AndroidManfest.xml文件中进行注册才能生效,不知道你有没有发现,这是Android四大组件共有特点。

10.3.2 启动和停止Service

定义好了Service之后,接下来就应该考虑如何启动以及停止这个Service,启动和停止的方法当然你也不会陌生,主要是借助Intent来实现的。

activity_main.xml

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

   <Button
       android:text="启动Service"
       android:onClick="start"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       tools:ignore="OnClick" />

   <Button
       android:text="停止Service"
       android:onClick="stop"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       tools:ignore="OnClick" />
</LinearLayout>

这里我们在布局文件中加入了两个按钮,分别用于启动和停止Service

MainActivity.java

package com.ziyia.servicetest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.os.Bundle;
import android.view.View;

public class MainActivity extends AppCompatActivity {

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
  }

   public void start(View view) {
       Intent intent = new Intent(this, MyService.class);
       startService(intent);
  }

   public void stop(View view) {
       Intent intent = new Intent(this, MyService.class);
       stopService(intent);
  }
}

在 “启动” 按钮的点击事件里,我们构建了一个Intent对象,并调用startService()方法来启动MyService。在“停止 “ 按钮的点击事件里,我们同样构建了一个Intent对象,并调用stopService()访求来停止MyService。startService和stopService()方法教师定义在Context类中的,所以我们在Activity里可以直接调用这两个方法。

另外,Service()也可以自我停止运行,只需要在Service内部调用stopSelf()方法即可。

我们在重写的方法中加入一些日志来调试

MyService.java

package com.ziyia.servicetest;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

public class MyService extends Service {
   private static final String T = MyService.class.getName();

   public MyService() {
  }

   @Override
   public IBinder onBind(Intent intent) {
       // TODO: Return the communication channel to the service.
       throw new UnsupportedOperationException("Not yet implemented");
  }

   @Override
   public void onCreate() {
       super.onCreate();
       Log.d(T, "onCreate executed");
  }

   @Override
   public int onStartCommand(Intent intent, int flags, int startId) {
       super.onStartCommand(intent, flags, startId);
       Log.d(T, "onStartCommand executed");
       return 1;
  }

   @Override
   public void onDestroy() {
       super.onDestroy();
       Log.d(T, "onDestroy executed");
  }
}

点击启动

点击停止

MyService成功停止下来了。

但是从Android8.0系统开始,应用的后台功能被大副削减,现在只有当应用在前台可见状态的情况下,Service才能保证稳定运行,一旦进入后台后。Service陫都有可以被系统回收。之所以做这样的发动,是为了防止许多恶意的应用程序长期在后台战胜手机资源,从而导致手机变得越来越卡。当你,如果你真的非常需要长期在后台执行一些任务,可以使用前台Service或者WorkManager。

其实onCreate()方法是在Service第一次创建的时候调用的,onStartCommand()方法则在每次Service的时候都会调用。如果我们重复点击 “启动Service” 就会看到效果了。

10.3.3 Activity和Service进行通信

虽然Service是在Activity里启动的,但是启动Service之后,Activity与Service基本没有什么关系了,确实如此。我们在Activity里调用了startService()方法来启动MyService,然后MyService的onCreate()方法和onStartCommand()方法就会得到执行,之后Service会一直处于运行状态,但具体运行的是什么逻辑,Activity就控制不了,这就类似于Activity通知了Service一下:“干活了” 然后Service就去忙自己的事情了,但Activity并不知道Service到底做了什么,以及完成情况如何。

那么可不可以拿Service当工具人使呢?指挥Service去干什么,它就去干什么。当然是可以的,这时onBind()方法的作用来了。

package com.ziyia.servicetest;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

public class MyService extends Service {

   private static final String T = MyService.class.getName();
   private DownLoadBinder downLoadBinder = new DownLoadBinder();

   public static class DownLoadBinder extends Binder {
       public void startDownLoad() {
           Log.d(T, "开始下载.......");
      }

       public int getProgress() {
           Log.d(T, "获取进度.......");
           return 0;
      }
  }

   public MyService() {
  }

   @Override
   public IBinder onBind(Intent intent) {
       return downLoadBinder;
  }
  ...........................
}

可见,这里我们新建了一个DownLoadBinder类,并让它继承自Binder,然后它的内部提供了开始下载以及查看下载进度的方法。当然这只是两个模拟方法,并没有实现真正的功能,我们只在其中打印了一行日志。

接着,在MyService中创建了DownLoadBinder的实例,然后在onBind()方法里返回了这个实例,这样MyService的工作就完成了。

接下来就是如何在Activity中如何去调用Service里的这些方法了,首先在布局中添加两个按钮

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

  ...........................

   <Button
       android:onClick="bindService"
       android:text="开"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       tools:ignore="OnClick" />

   <Button
       android:onClick="unbindService"
       android:text="关"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       tools:ignore="OnClick" />
</LinearLayout>

这两个按钮的作用是绑定和取消绑定Service的,那谁要和Service绑定呢?当然是我们的Activity了,当一个Activity和Service绑定了之后,就可以调用该Service里的Binder提供的方法了。

MainActivity.java

package com.ziyia.servicetest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;

public class MainActivity extends AppCompatActivity {
   private MyService.DownLoadBinder downLoadBinder = new MyService.DownLoadBinder();
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
  }
  .......................................
   ServiceConnection serviceConnection = new ServiceConnection(){
       @Override
       public void onServiceConnected(ComponentName name, IBinder service) {
           downLoadBinder.startDownLoad();
           int progress = downLoadBinder.getProgress();
           Log.d("获取到的进度", String.valueOf(progress));
      }

       @Override
       public void onServiceDisconnected(ComponentName name) {

      }
  };

   public void bindService(View view) {
       Intent intent = new Intent(this, MyService.class);
       bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
  }

   public void unbindService(View view) {
       unbindService(serviceConnection);
  }
}

这里我们首先创建了一个ServiceConnection的匿名内部类的实现,并在里面重写了onService.Connected()方法和onServiceDisconnected()方法。onServiceConnected()方法会在Activity与Service成功绑定的时候调用。而onServiceDisconnected()方法只有在Service的创建进程崩溃或者被杀掉的时候才会调用,这个方法不太常用。那么在onServiceConnected()方法中,我们又通过IBinder向下转型得到了DownLoadBinder的实例,有了这个实例,Activity和Service之间的关系就变得非常紧密了,现在我们可以在Activity根据具体的场景来调用DownLoadBinder中的任何public修饰的方法,即实现了指挥Service干什么Service就去干什么,这里人是做了个简单的测试,在onServiceConnected()方法中调用了DownLoadBinder的startDownLoad()和getProgress()方法。

当然,现在Activity和Service其实还没有进行绑定呢。这个功能是在 “开” 这个按钮的点击事件里完成的,可见,我们仍然构建了一个Intent对象,然后调用bindService()方法将MainActivity和MyService进行绑定,bindSerivce()方法接收3个参数:第一个参数是刚刚构建出来的Intent;第二个参数是前面创建出的ServiceConnection的实例;第三个参数则是一个标志位,这里传入BIND_AUTO_CREATE表示在Activity和Service进行绑定后自动创建Service,这会使得MyService中的onCreate()方法得到执行,而onStartCommand()方法不会执行。

如何想解除Activity和Service的绑定,调用unbindService传入ServiceConnection实例即可。

点击 “开”

点击 “关”

10.4 Service的生命周期

Service同样也有自己的生命周期,前面我们使用到的onCreate()、onStartCommand()、onBind()和onDestroy()等方法都是Service的生命周期内可能回调的方法。

一旦在项目的任何位置调用了Context的startService()方法,相应的Service就会启动,并回调onStartCommand()方法

,如果这个Service之前还没有创建过 onCreate()方法会先于onStartCommand()方法执行。Service启动了之后会一直保持运行状态,直到stopService()或stopSelf()方法被调用,或者被系统回收。注意,虽然每调用一次startService()方法onStartCommand()方法都会执行一次,但实际上每个Service只会存在一个实例,所以不管你调用了多少次startService()方法,只需要调用一次stopService()方法或者stopSelf()方法,Service就会停止。

另外,还可以调用Context的bindService()来获取一个Service的持久连接,这时候就会回调Service中的onBind()方法,类似地,如果这个Service之前还没有创建过.,onCreate()会等于onBind()方法执行。之后,调用方可以获取到onBind()方法里IBinder对象的实例,这样就能自由地和Service进行通信了,只要调用方和Service之间的连接没有断开,Service就会一直保持运行状态,直到被系统回收。

当调用了startService()方法后,再去调用stopService()方法。这时Service中onDestroy()方法就会得到执行,表示Service已经销毁。当调用了bindService()方法后,再去调用unbindService()方法,onDestroy()方法也会执行。

这两种情况都很好理解。但是要注意,我们是完全有可能对一个Service即调用了startService()方法,又调用了bindService()方法,在这种情况下该如何让Service销毁呢?根据Android系统的机制,一个Service只要被启动或者被绑定后,就会处理运行状态,必须让以上两种条件不满足,Service才能被销毁,所以,这种情况下要同时调用stopService()和unbindService()方法,onDestroy()方法才会执行。

10.5 实用技巧

前面只是Service最基本的一些用法和概念。当然也是最常用的,不过仅满足于仅显然是不够的,一起来看一下高级应用技巧吧。

10.5.1 使用前台Service

从Android8.0系统开始,只有当应用保持在前台可见状态的情况下,Service才能保证稳定运行,一旦应用进入后台之后,Service随时都有可以被系统回收,而如果你希望Service能够一直保持运行状态,就可以考虑使用前台Service,前台Service和普通Serivce最大的就在于,它会一直有一个正在运行的的图标在系统的状态栏中显示,下拉状态栏后可以看到更加详细的信息,非常类似于通知的效果。

由于状态中一直有一个正在运行的图标,相当于我们的应用以另外一种形式保持在前台可见状态,所以系统不会倾于回收前台Serivce。另外,用户也可以通过下拉状态栏清楚地知道当前什么应在运行,因此也不存在某些恶意的应用长期在后台偷偷战胜资源的情况。

MyService.java

package com.ziyia.servicetest;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.Binder;
import android.os.Build;
import android.os.IBinder;
import android.util.Log;
import android.widget.Button;

import androidx.core.app.NotificationCompat;

public class MyService extends Service {

   private static final String T = MyService.class.getName();
  ........

   @Override
   public void onCreate() {
       super.onCreate();
       Log.d(T, "onCreate executed");
       NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
           NotificationChannel channel = new NotificationChannel("MyService", "前台Service通知", NotificationManager.IMPORTANCE_DEFAULT);
           manager.createNotificationChannel(channel);
      }
       Intent intent = new Intent(this, MainActivity.class);
       PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
       Notification builder = new NotificationCompat.Builder(this, "MyService")
              .setContentTitle("标题在此")
              .setContentText("通知内容")
              .setContentIntent(pendingIntent)
              .build();

       startForeground(1, builder);

  }
  .........
}

可见,这里只是修改了onCreate()方法中的代码,相信这部分代码你会非常眼熟,没错!这就是我们创建通知的方法,只不过这次构建Notification对象后并没有使用NotificatioManager将通知显示出来,而是调用了startForeground()方法。这个方法接收2个参数:第一参数是通知的id,第二个参数是我们构建的Notification对象。调用startForeground()方法后就会让MyService变成一个前台Service,并存系统通知栏中显示出来。

另外,从Android9.0开始,使用前台Service必须在AndroidManfest.xml文件中进行权限声明才行,如

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   package="com.ziyia.servicetest">

   <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

 
  ........

</manifest>

MyService也会一直牌运行状态,而且不用担心会被系统回收,当然,MyService所对应的通知会一直显示在状态栏上面,如果用户不然废物分道扬镳程序一直运行,也可以选择手动杀掉应用,这样MyService就会跟着一起停止运行了。

10.5.2使用IntentService

前面的例子,Service中的代码都是默认运行在主线程中的,如果直接在Service处理一些耗时的逻辑。很很容易出现 ANR(Application Not Reponding)应用程序长时间不影响的情况。

所以这个时候就需要用到Android多线程编程技术了,我们应该在Service的每个具体的方法里开启一个子线程,然后在这里处理那些耗时的逻辑,因此,一个比较标准的Service就可以写成

MyService.java

package com.ziyia.servicetest;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.Binder;
import android.os.Build;
import android.os.IBinder;
import android.util.Log;
import android.widget.Button;

import androidx.core.app.NotificationCompat;

public class MyService extends Service {
  ...............

   @Override
   public int onStartCommand(Intent intent, int flags, int startId) {
       super.onStartCommand(intent, flags, startId);
       Thread onStartCommand_executed = new Thread(() -> {
           Log.d(T, "onStartCommand executed");
      });
       onStartCommand_executed.start();
       return 1;
  }

  ,,,,,,,,,,
}

但是,这样Service一旦启动,就会一直牌运行状态,必须调用stopService()方法或stopSelf()方法,或者被系统回收,Service才会停止,如果你想实现让一个Service在执行完毕后自动信息的功能,就应该在处理完逻辑之后在子线程内调用stopSelf()。

MyService.java

package com.ziyia.servicetest;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.Binder;
import android.os.Build;
import android.os.IBinder;
import android.util.Log;
import android.widget.Button;

import androidx.core.app.NotificationCompat;

public class MyService extends Service {

  ............
   @Override
   public int onStartCommand(Intent intent, int flags, int startId) {
       super.onStartCommand(intent, flags, startId);
       Thread onStartCommand_executed = new Thread(() -> {
               Log.d(T, "onStartCommand executed");
               
               stopSelf();
      });
       onStartCommand_executed.start();
       Log.d(T, "onStartCommand executed");
       return 1;
  }
  ........
}

虽说这与法并不复杂,但总会有一些程序员忘记开启纯种,或者忘记调用stopService()方法,为了可以简单地创建一个异步的。会自动停止的Service,Android专门提供了一个IntentService类,这个类就很好地解决了前面所提到的两种尴尬。

MyIntentService.java

package com.ziyia.servicetest;

import android.app.IntentService;
import android.content.Intent;
import android.content.Context;
import android.util.Log;

import androidx.annotation.Nullable;

/**
* An {@link IntentService} subclass for handling asynchronous task requests in
* a service on a separate handler thread.
* <p>
* <p>
* TODO: Customize class - update intent actions, extra parameters and static
* helper methods.
*/
public class MyIntentService extends IntentService {
   private final String T = getClass().getName();

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


   @Override
   protected void onHandleIntent(@Nullable Intent intent) {
       Log.d(T, Thread.currentThread().getName());
  }

   @Override
   public void onDestroy() {
       super.onDestroy();
       Log.d(T, "回收了");
  }
}

这里首先要求必须调用父类的构造函数,并传入一个字符串,这个字符串可以随意指定,只在调试的时候有用,然后要在子类中实现onHandlIntent()这个抽象方法,这个方法中可以处理一些耗时的逻辑,而不用担心ANR问题,因为这个方法已经是在子线程中运行的了,这里为了证实一下,我们在onHandleIntent()方法中打印了当前线程名,另外,根据IntentService的特性,这个Service在运行结束后应该是会自动停止的,所以我们又重写了onDestroy()方法,在这打印了一行日志,以证实Service是不是停止了。

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:orientation="vertical"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   tools:context=".MainActivity">
   
  ........
   
   <Button
       android:onClick="startMyIntentService"
       android:text="开启MyIntentService"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       tools:ignore="OnClick" />
</LinearLayout>

MainActivity.java

package com.ziyia.servicetest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;

public class MainActivity extends AppCompatActivity {
   private final String T = getClass().getName();

  ........
       
   public void startMyIntentService(View view) {
       Log.d(T, Thread.currentThread().getName());
       Intent intent = new Intent(this, MyIntentService.class);
       startService(intent);
  }
}

可见,我们在按钮的点击事件是启动了MyIntentService并在这里打印了一下主线程名,稍后用于和IntentService进行比对,你会发现,其实IntentService的启动方式和普通的Service没什么两样。最后不要忘记在AndroidManfest.xml里注册,如

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   package="com.ziyia.servicetest">

   <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

   <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.MyApplication">
       <service
           android:name=".MyIntentService"
           android:exported="true"
           android:enabled="true"
           tools:ignore="Instantiatable"/>
       <service
           android:name=".MyService"
           android:enabled="true"
           android:exported="true" />

       <activity android:name=".MainActivity">
           <intent-filter>
               <action android:name="android.intent.action.MAIN" />
               <category android:name="android.intent.category.LAUNCHER" />
           </intent-filter>
       </activity>
   </application>

</manifest>

点击按钮后,打印的日志如下

MyIntentService执行完成后就自动回收了。

发表回复

相关

浙ICP备2021031744号-3