Service

Service是什么

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

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

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

Android多线程编程

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

线程的基本用法

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

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

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

MyThread().start()

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

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

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

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

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

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

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

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

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就可以写成如下形式：

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" /> 
         ... 
</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关键字来表示该泛型要进行实化。示例代码如下：

inline fun <reified T> getGenericType() { 
}

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

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，只需要这样写就可以了：

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