Service

Service 是什么

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

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

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

Android 多线程编程

当我们需要执行一些耗时操作，比如发起一条网络请求时，考虑到网速等其他原因，服务器未必能够立刻响应我们的请求，如果不将这类操作放在子线程里运行，就会导致主线程被阻塞，从而影响用户对软件的正常使用。

线程的基本用法

义一个线程只需要新建一个类继承自 Thread，然后重写父类的 run () 方法，并在里面编写耗时逻辑即可，如下所示：

class MyThread : Thread(){
    override fun run(){
        
    }
}

那么该如何启动这个线程呢？其实很简单，只需要创建 MyThread 的实例，然后调用它的 start () 方法即可，这样 run () 方法中的代码就会在子线程当中运行了，如下所示：

1	MyThread().start()

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

class MyThread : Runnable { 
     override fun run() { 
        // 编写具体的逻辑 
     } 
}

如果使用了这种写法，启动线程的方法也需要进行相应的改变，如下所示：

1 2	val myThread = MyThread() Thread(myThread).start()

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

当然，如果你不想专门再定义一个类去实现 Runnable 接口，也可以使用 Lambda 的方式，这种写法更为常见，如下所示：

1
2
3

Thread { 
 // 编写具体的逻辑 
}.start()

以上几种线程的使用方式你应该不会感到陌生，因为在 Java 中创建和启动线程也是使用同样的方式。而 Kotlin 还给我们提供了一种更加简单的开启线程的方式，写法如下：

1
2
3

thread { 
 // 编写具体的逻辑 
}

这里的 thread 是一个 Kotlin 内置的顶层函数，我们只需要在 Lambda 表达式中编写具体的逻辑就可以了，连 start () 方法都不用调用，thread 函数在内部帮我们全部都处理好了。

在子线程中更新 UI

class MainActivity : AppCompatActivity(){
    val updateText = 1
    lateinit var textView : TextView
    
    val handle = object : Handler(Looper.getMainLooper()){
        override fun handleMessage(msg:Message){
            when(msg.what){
                updateText -> textView.text = "Nice to meet you"
            }
        }
    }
    
    override fun onCreate(savedInstanceState : Bundle?){
        super.onCreate(savedInstanceState)
        val binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        textView = binding.textView
        val changeTextBtn = binding.changeTextBtn
        changeTextBtn.setOnClickListener{
            thread{
                val msg = Message()
                mag.what = updateText
                handle.sendMessage(msg)
            }
        }
    }
}

解析异步消息处理机制

Android 中的异步消息处理主要由 4 个部分组成：Message、Handler、MessageQueue 和 Looper。

Message

Message 是在线程之间传递的消息，它可以在内部携带少量的消息，用于在不同线程之间传递数据。
Handler

Handler 主要是用于发送和处理消息的，发出的消息经过一系列地辗转处理后，最终会传递到 Handler 的 handleMessage () 方法中
MessageQueue

MessageQueue 是消息队列的意思，它主要用于存放所有通过 Handler 发送的消息。这部分消息会一直存在于消息队列中，等待被处理。每个线程中只有一个 MessageQueue 对象。
Looper

Looper 是每个线程中的 MessageQueue 的管家，调用 Looper 的 loop () 方法后，就会进入一个无限循环当中，然后每当发现 MessageQueue 中存在一条消息时，就会将它取出，并传递到 Handler 的 handleMessage () 方法中。每个线程中只会有一个 Looper 对象

异步消息处理流程

首先需要在主线程当中创建一个 Handler 对象，并重写 handleMessage () 方法。然后当子线程中国需要进行 UI 操作时，就创建一个 Message 对象，并通过 Handler 将这条消息发送出去。之后这条消息就会被添加到 MessageQueue 的队列中等待被处理，而 Looper 则会一直尝试从 MessageQueue 中取出待处理消息，最后分发回 Handler 的 handleMessage () 方法中。由于 Handle 的构造函数中我们传入了 Looper.getMainLooper ()，所以此时 handleMessage () 方法中的代码也会在主线程中运行

使用 AsyncTask

首先来看一下 AsyncTask 的基本用法。由于 AsyncTask 是一个抽象类，所以如果我们想使用它，就必须创建一个子类去继承它。在继承时我们可以为 AsyncTask 类指定 3 个泛型参数，这 3 个参数的用途如下。

Params。在执行 AsyncTask 时需要传入的参数，可用于在后台任务中使用。
Progress。在后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为单位进度
Result。当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型

因此，一个最简单的自定义 AsyncTask 就可以写成如下形式：

1
2
3

class DownloadTask : AsyncTask<Unit, Int, Boolean>() { 
 	... 
}

这里我们把 AsyncTask 的第一个泛型参数指定为 Unit，表示在执行 AsyncTask 的时候不需要传入参数给后台任务。第二个泛型参数指定为 Int，表示使用整型数据来作为进度显示单位。第三个泛型参数指定为 Boolean，则表示使用布尔型数据来反馈执行结果。

当然，目前我们自定义的 DownloadTask 还是一个空任务，并不能进行任何实际的操作，我们还需要重写 AsyncTask 中的几个方法才能完成对任务的定制。经常需要重写的方法有以下 4 个。

onPreExecute()

这个方法回在后台任务开始执行之前调用，用于进行一些界面上的初始化操作，比如显示一个进度条对话框等
doInBackground(Params…)

这个方法中的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。任务一旦完成，就可以通过 return 语句将任务的执行结果返回，如果 AsyncTask 的第三个泛型参数指定的是 Unit，就可以不返回任务执行的结果注意，在这个方法中是不可以进行 UI 操作的，如果需要更新 UI 元素，比如说反馈当前任务的执行进度，可以调用 publishProgress (Progress…) 方法来完成。
onProgressUpdate(Progress…)

当在后台任务中调用了 publishProgress (Progress…) 方法后， onProgressUpdate (Progress…) 方法就会很快被调用，该方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对 UI 进行操作，利用参数中的数值就可以对界面元素进行相应的更新。
onPostExecute(Result)

当后台任务执行完毕并通过 return 语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据进行一些 UI 操作，比如说提醒任务执行的结果，以及关闭进度条对话框等。

Service 的基本用法

定义一个 Service

首先看一下如何在项目中定义一个 Service。新建一个 ServiceTest 项目，然后右击 com.example.servicetest→New→Service→Service，

可以看到，这里我们将类名定义成 MyService，Exported 属性表示是否将这个 Service 暴露给外部其他程序访问，Enabled 属性表示是否启用这个 Service。将两个属性都勾中，点击 “Finish” 完成创建。

现在观察 MyService 中的代码，如下所示：

class MyService : Service() { 
 
 override fun onBind(intent: Intent): IBinder { 
     TODO("Return the communication channel to the service.") 
     } 
 
}

可以看到，MyService 是继承自系统的 Service 类的。目前 MyService 中可以算是空空如也，但有一个 onBind () 方法特别醒目。这个方法是 Service 中唯一的抽象方法，所以必须在子类里实现。我们会在后面的小节中使用到 onBind () 方法，目前可以暂时将它忽略。既然是定义一个 Service，自然应该在 Service 中处理一些事情了，那处理事情的逻辑应该写在哪里呢？这时就可以重写 Service 中的另外一些方法了，如下所示：

class MyService : Service() { 
 ... 
 override fun onCreate() { 
 super.onCreate() 
 } 
 
 override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int { 
 return super.onStartCommand(intent, flags, startId) 
 } 
 
 override fun onDestroy() { 
 super.onDestroy() 
 } 
 
}

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

通常情况下，如果我们希望 Service 一旦启动就立刻去执行某个动作，就可以将逻辑写在 onStartCommand () 方法里。而当 Service 销毁时，我们又应该在 onDestroy () 方法中回收那些不再使用的资源。

启动和停止 Service

定义好了 Service 之后，接下来就应该考虑如何启动以及停止这个 Service。启动和停止的方法当然你也不会陌生，主要是借助 Intent 来实现的。下面就让我们在 ServiceTest 项目中尝试启动以及停止 MyService。

修改 MainActivity 中的代码，如下所示：

class MainActivity : AppCompatActivity(){
    override fun onCreate(savedInstanceState : Bundle?){
        super.onCreate(savedInstanceState)
        val binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        val startServiceBtn = binding.startServiceBtn
        val stopServiceBtn = binding.stopServiceBtn
        startServiceBtn.setOnClickListener{
            val intent = Intent(this,MyService::class.java)
            startService(intent)
        }
        stioServiceBtn.setOnCLickListener{
            val intent = Intent(this,Myservice::class.java)
            stopService(intent)
        }
    }
}

OnCreate () 方法和 onStartCommand () 方法区别

onCreate () 方法是在 Service 第一次创建的时候调用的，而 onStartCommand () 方法则在每次启动 Service 的时候都会调用。由于刚才我们是第一次点击 “Start Service” 按钮， Service 此时还未创建过，所以两个方法都会执行，之后如果你再连续多点击几次 “Start Service” 按钮，你就会发现只有 onStartCommand () 方法可以得到执行了。

Activity 和 Service 进行通信

使用 onBind () 方法

比如说，目前我们希望在 MyService 里提供一个下载功能，然后在 Activity 中可以决定何时开始下载，以及随时查看下载进度。实现这个功能的思路是创建一个专门的 Binder 对象来对下载功能进行管理。修改 MyService 中的代码，如下所示：

class MyService : Service() {
    private val mBinder = DownloadBinder()
    
    class DownloadBinder : Binder(){
        
        fun startDownload(){
            Log.d("MyService","startDownload executed")
        }
        
        fun getProgress() : Int {
            Log.d("MyService","getProgress executed")
            return 0
        }
    }
    
    override fun onBind(intent:Intent) : IBinder{
        return mBinder
    }
}

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

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

下面就要看一看在 Activity 中如何调用 Service 里的这些方法了。首先需要在布局文件里新增两个按钮，修改 activity_main.xml 中的代码，如下所示：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
     android:orientation="vertical" 
     android:layout_width="match_parent" 
     android:layout_height="match_parent"> 

         ... 

             <Button 
                 android:id="@+id/bindServiceBtn" 
                 android:layout_width="match_parent" 
                 android:layout_height="wrap_content" 
                 android:text="Bind Service" /> 

             <Button 
                 android:id="@+id/unbindServiceBtn" 
                 android:layout_width="match_parent" 
                 android:layout_height="wrap_content" 
                 android:text="Unbind Service" /> 

</LinearLayout>

这两个按钮分别是用于绑定和取消绑定 Service 的，那到底谁需要和 Service 绑定呢？当然就是 Activity 了。当一个 Activity 和 Service 绑定了之后，就可以调用该 Service 里的 Binder 提供的方法了。修改 MainActivity 中的代码，如下所示：

class MainActivity : AppCompatActivity(){
    lateinit var downloadBinder : MyService.DownloadBinder
    
    private val connection = object : ServiceConnection{
        override fun onServiceConnected(name:ComponentName,service:IBinder){
            downloadBinder = service as MyService.DownloadBinder
            downloadBinder.startDownload()
            downloadBinder.getProgress()
        }
        
        override fun onServiceDisconnected(name : ComponentName){
            
        }
    }
    override fun onCreate(savedInstanceState: Bundle?){
        、、、
        bindServiceBtn.setOnClickListener{
            val intent = Intent(this, MyService::class.java)
            bindService(intent,connection,Context.BIND_AUTO_CREATE)
        }
        unbindServiceBtn.setOnClickListener{
            unbindService(connection)
        }
    }
}

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 () 方法才会执行。这样你就把 Service 的生命周期完整地走了一遍。

Service 的更多技巧

使用前台 Service

修改 MyService 中的代码，如下所示：

class MyService : Service(){
    、、、
    override fun onCreate(){
        super.onCreate()
        Log.d("MyService","onCreate executed")
        val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        if(Build.VERSION.SDK_INT >= Build>VERSION_CODES.0){
            val channel = NotoficationManager("my_service","前台Service通知",NotificationManager.IMPORTANCE_DEFAULT)
            	manager.createNotificationChannel(channel)
        }
        val intent = Intent(this, MainActivity::class.java)
        val pi = PendingIntent.getActivity(this,0,intent,0)
        val notification = NotificationCompat.Builder(this,"my_service")
        	.setContextTitle("This is content text")
        	.setSmallIcon(R.drawable.small_icon)
        	.setLargeIcon(BitmapFactory.decodeResource(resoruces,R.drabable.large_icon))
        	.setContentIntent(pi)
        	.build()
        startForeground(1,notification)  	
    }
}

调用 startForeground () 方法后就会让 MyService 变成一个前台 Service，并在系统状态栏显示出来。

另外，从 Android 9.0 系统开始，使用前台 Service 必须在 AndroidManifest.xml 文件中进行权限声明才行，而且如下所示：

<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.servicetest"> 
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />添加这个
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC"/>/*添加这个，对应android:foregroundServiceType="dataSync"所需要的权限*/
         ... 
        <service
            android:name=".MyService"
            android:enabled="true"
            android:exported="false"
            android:foregroundServiceType="dataSync"/>/*添加这个属性，前台service一定要的，也可以是mediaPlayback等，但要添加相应的权限*/
            ...
</manifest>

现在即使你退出应用程序，MyService 也会一直处于运行状态，而且不用担心会被系统回收。当然，MyService 所对应的通知也会一直显示在状态栏上面。如果用户不希望我们的程序一直运行，也可以选择手动杀掉应用，这样 MyService 就会跟着一起停止运行了。

使用 IntentService

Android 专门提供了一个 IntentService 类，这个类就很好地解决了前面所提到的两种尴尬，下面我们就来看一下它的用法。

新建一个 MyIntentService 类继承自 IntentService，代码如下所示：

class MyIntentService : IntentService("MyIntentService"){
    override fun onHandleIntent(intent:Intent?){
        //打印当前线程的id
        Log.d("MyIntentService", "Thread id is ${Thread.currentThread().name}")
    }
    
    override fun onDestroy(){
        super.onDestroy()
        Log.d("MyIntentService","onDestroy executed")
    }
}

接下来修改 activity_main.xml 中的代码，加入一个用于启动 MyIntentService 的按钮，如下所示：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 android:orientation="vertical" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent"> 
 
     ... 

     <Button 
         android:id="@+id/startIntentServiceBtn" 
         android:layout_width="match_parent" 
         android:layout_height="wrap_content" 
         android:text="Start IntentService" /> 

</LinearLayout>

然后修改 MainActivity 中的代码，如下所示：

class MainActivity : AppCompatActivity(){
    、、、
    override fun onCreate(savedInstanceState:Bundle?){
        、、、
        startIntentServiceBtn.setOnClickListener{
            //打印主线程的id
            Log.d("MainActivity","Thread id is ${Thread.currentThread().name}")
            val intent = Intent(this,MyIntentService::class.java)
            startService(intent)
        }
    }
}

可以看到，我们在 “Start IntentService” 按钮的点击事件里启动了 MyIntentService，并在这里打印了一下主线程名，稍后用于和 IntentService 进行比对。你会发现，其实 IntentService 的启动方式和普通的 Service 没什么两样

最后不要忘记，Service 都是需要在 AndroidManifest.xml 里注册的，如下所示：

、、、
<service
         android:name="MyIntentService"
         android:enabled="true"
         android:exported="true"
         />
、、、

Kotlin 课堂：泛型的高级特性

对泛型进行实化

那么具体该怎么写才能将泛型实化呢？首先，该函数必须是内联函数才行，也就是要用 inline 关键字来修饰该函数。其次，在声明泛型的地方必须加上 reified 关键字来表示该泛型要进行实化。示例代码如下：

1 2	inline fun <reified T> getGenericType() { }

上述函数中的泛型 T 就是一个被实化的泛型，因为它满足了内联函数和 reified 关键字这两个前提条件。那么借助泛型实化，到底可以实现什么样的效果呢？从函数名就可以看出来了，这里我们准备实现一个获取泛型实际类型的功能，代码如下所示：

1	inline fun <reified T> getGenericType() = T::class.java

虽然只有一行代码，但是这里却实现了一个 Java 中完全不可能实现的功能： getGenericType () 函数直接返回了当前指定泛型的实际类型。T.class 这样的语法在 Java 中是不合法的，而在 Kotlin 中，借助泛型实化功能就可以使用 T::class.java 这样的语法了

现在我们可以使用如下代码对 getGenericType () 函数进行测试：

fun main() { 
     val result1 = getGenericType<String>() 
     val result2 = getGenericType<Int>() 
     println("result1 is $result1") 
     println("result2 is $result2") 
}

泛型实化的应用

新建一个 reiﬁed.kt 文件，然后在里面编写如下代码：

inline fun <reified T> startActivity(context: Context) { 
     val intent = Intent(context, T::class.java) 
     context.startActivity(intent) 
}

这里我们定义了一个 startActivity () 函数，该函数接收一个 Context 参数，并同时使用 inline 和 reified 关键字让泛型 T 成为了一个被实化的泛型。接下来就是神奇的地方了， Intent 接收的第二个参数本来应该是一个具体 Activity 的 Class 类型，但由于现在 T 已经是一个被实化的泛型了，因此这里我们可以直接传入 T::class.java。最后调用 Context 的 startActivity () 方法来完成 Activity 的启动

现在，如果我们想要启动 TestActivity，只需要这样写就可以了：

1	startActivity<TestActivity>(context)

添加一个新的 startActivity () 函数重载，如下所示

inline fun <reified T> startActivity(context: Context, block: Intent.() -> Unit) { 
     val intent = Intent(context, T::class.java) 
     intent.block() 
     context.startActivity(intent) 
}

可以看到，这次的 startActivity () 函数中增加了一个函数类型参数，并且它的函数类型是定义在 Intent 类当中的。在创建完 Intent 的实例之后，随即调用该函数类型参数，并把 Intent 的实例传入，这样调用 startActivity () 函数的时候就可以在 Lambda 表达式中为 Intent 传递参数了，如下所示：

startActivity<TestActivity>(context) { 
     putExtra("param1", "data") 
     putExtra("param2", 123) 
}