1. Activity 基础相关

Activity 基础相关

1. Activity 的四种状态

active： Activity 处于栈顶（可见状态，获取焦点能够和用户交互）；
paused：可见但不可交互（失去焦点，无法和用户交互），正常情况下不会被系统回收，但是在内存不足的情况下会被系统回收；
stopped：不可见，Activity 被完全覆盖，即不是被透明的 Activity 覆盖，与 paused 状态一样，在内存足够的情况下，他的状态、数据成员变量都会被保存，只有在内存不足的情况下才会被系统回收；
killed：当 Activity 被系统回收掉之后的状态；

要点：Activity 是与用户交互的接口；Android 系统是通过 Activity 栈的形式来管理 Activity 的；Activity 包含 active、paused、stopped 和 killed 四种状态；

2. Activity 生命周期回调方法

正常情况下生命周期

Activity 正常情况下生命周期

异常情况下生命周期的变化

异常情况：系统配置发生变化；内存等其他原因造成的改变；

主要体现在两个方法上 onSaveInstanceState(@NonNull Bundle outState, @NonNull PersistableBundle outPersistentState) 和 onRestoreInstanceState(@NonNull Bundle savedInstanceState) ；
在系统发生异常时，系统自动调用 onSaveInstanceState() 方法，将数据保存在 Bundle 中，当 Activity 重新被创建之后，系统会调用 onRestoreInstanceState() 方法，并将 Bundle 对象传入，同时也将 Bundle 传递给 onCreate() 方法；
一旦 Activity 异常退出，即可在 onRestoreInstanceState() 和 onCreate() 方法中恢复数据，但是在 onCreate() 方法中，Bundle 可能为空，但是在 onRestoreInstanceState() 方法中 Bundle 不可能为空；

3. Activity 与其他组件之间数据通信

1. 3种方式：

Intent / Bundle
类静态变量
全局变量

2. Activity --> Activity（Bundle 方式）

创建 Bundle 对象；

val bundle = Bundle()

将要传递的数据以 key-value 的形式封装到 Bundle 对象中；

bundle.putString("name", "张三")

将 Bundle 对象放入到 Intent 对象中；

val intent = Intent(this, TargetActivity::class.java)
intent.putExtras(bundle)

在 TargetActivity 中接收参数；

val intent = getIntent()
val name = intent.getStringExtra("name")
// val name = intent.getExtras()?.getString("name")

3. Activity --> Fragment

通过 Bundle 方式
- 步骤和 Activity --> Activity 传递数据一样；
- 在传递时使用 Fragment 的 setArguments() 方法封装参数；
```
val fragment = TargetFragment()
fragment.arguments = bundle
```
- 在 Fragment 中用 getArguments() 方法获取到 Bundle 对象，利用该对象接收；
```
getArguments()?.getString("name")
```
直接在 Activity 中定义方法，然后在 Fragment 中获取到 Activity 的实例 isntance，然后利用该 instance 调用定义好的方法去获取相对应的数据；

4. Fragment --> Activity

①可以使用广播的方式；②可以通过三方框架例如 EventBus 等方式传递；③还可以利用最基本的接口回调的方式；

使用接口回调的传递数据的基本步骤：
1. 在 Fragment 中定义一个内部回调接口，让 Activity 实现该接口，让后 Fragment 调用该接口中的方法，将数据以参数的形式传递给 Activity；
2. 在 Fragment 的 onAttach() 方法中，将 Activity 实例转换成该接口并赋值；
3. 在 Fragment 的 onDetach() 方法中，将第二步中的 Activity 对象释放掉，避免引起内存泄漏；

Fragment 代码部分

class TargetFragment : Fragment() {

    private var mFragmentCallback: FragmentCallback? = null

    override fun onAttach(context: Context) {
        super.onAttach(context)

        // 回调传值：③将 Activity 实例转换成该接口并赋值
        if (context is FragmentCallback) {
            mFragmentCallback = context
        }
    }

    override fun onDetach() {
        super.onDetach()

        // 回调传值：④将第③步中的 Activity 对象释放掉，避免引起内存泄漏
        mFragmentCallback = null
    }

    private fun doSomething() {
        mFragmentCallback?.process("要传递的数据")
    }

    // 回调传值：①创建回调接口
    interface FragmentCallback {
        fun process(arg: String)
    }
}

Activity 代码部分

class SourceActivity : AppCompatActivity(), TargetFragment.FragmentCallback { // 回调传值：②实现回调接口
    override fun process(arg: String) {
        // 回调传值：⑤拿到 Fragment 传递过来的数据
        TODO("Not yet implemented")
    }
}

5. Activity 与 Service 数据通信

绑定服务，利用 ServiceConnection 类；

与 Service 绑定的 Activity 实现 ServiceConnection 类，并重写它的两个抽象方法 onServiceConnected() 和 onServiceDisconnected()；
在 Service 创建一个内部类 MyBinder 继承自 Binder，在 MyBinder 中创建一个方法，用于向 Service 传递数据；
在 Activity 中重写 onServiceConnected() 方法，获取到 Service 的 MyBinder 对象；
利用第三步拿到的 MyBinder 对象调用第二步创建的方法向 Service 传递数据；

Service 源码

class TargetService : Service() {

    var data: String = "服务正在执行"

    override fun onBind(intent: Intent): IBinder {
        loge(data,"---CME--- TargetService.onBind()")
        return MyBinder()
    }

    override fun onUnbind(intent: Intent?): Boolean {
        loge("解绑了！","---CME--- TargetService.onUnbind()")
        return super.onUnbind(intent)
    }

    override fun onDestroy() {
        loge("Service 销毁了！","---CME--- TargetService.onDestroy()")
        super.onDestroy()
    }


    inner class MyBinder : Binder() {
        fun setData(data: String) {
            this@TargetService.data = data
        }

        fun printData() {
            loge(this@TargetService.data,"---CME--- MyBinder.printData()")
        }
    }

}

Activity 源码

class ServiceActivity : AppCompatActivity(), ServiceConnection {

    private var mBinder: TargetService.MyBinder? = null
    private lateinit var mIntent: Intent
    private var click = 0

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.act_service)

        mIntent = Intent(this, TargetService::class.java)

        srb_startService.onClick {
            bindService(mIntent, this, Context.BIND_AUTO_CREATE)
        }

        srb_changeServiceData.onClick {
            mBinder?.let {
                it.setData("此时Service 的数据是 ${click++}")
                it.printData()
            }
        }

        srb_unbindService.onClick {
            unbindService(this)
        }

        srb_stopService.onClick {
            stopService(mIntent)
        }
    }

    override fun onServiceDisconnected(name: ComponentName) { // 进程崩溃
        loge("Service 断开了", "---CME--- ServiceActivity.onServiceDisconnected()")
    }

    override fun onServiceConnected(name: ComponentName, service: IBinder) { // 绑定成功
        mBinder = service as TargetService.MyBinder
        loge("service 绑定了", "---CME--- ServiceActivity.onServiceConnected()")
    }
}

简单通信，利用 Intent 进行传值

在 Activity 中，利用 startService() 中的 Intent 对象，将数据封装到该对象中；
在 Service 的 onStartCommand() 方法中来获取所对应的数据；

Activty

class ServiceActivity : AppCompatActivity() {

    private lateinit var mIntent: Intent

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.act_service)

        mIntent = Intent(this, TargetService::class.java)

        srb_startService.onClick {
            mIntent.putExtra("data","从 Activity 中传入的数据")
            startService(mIntent)
        }

        srb_stopService.onClick {
            stopService(mIntent)
        }
    }
}

Service

class TargetService : Service() {

    var data: String = "服务正在执行"

    override fun onBind(intent: Intent): IBinder {
        loge(data, "---CME--- TargetService.onBind()")
        return Binder()
    }

    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
        data = intent.getStringExtra("data") ?: ""
        loge(data, "---CME---TargetService.onStartCommand()")
        return super.onStartCommand(intent, flags, startId)
    }

    override fun onDestroy() {
        loge("Service 销毁了！", "---CME--- TargetService.onDestroy()")
        super.onDestroy()
    }
}

定义一个 callback 接口，来监听服务中的进程变化

在 Service 中定义一个回调接口 Callback，并提供一个 setCallback() 方法供 Activity 实现回调函数；然后定义一个继承于 Binder 的 MyBinder 类，在该类中提供一个获取该 Service 实例的方法；
让 Activity 继承 ServiceConnection，然后复写 onServiceConnected() 方法，在该方法中获取到 Service 对象，并实现回调函数；

Service

class TargetService : Service() {

    private var mCallback: Callback? = null

    override fun onBind(intent: Intent): IBinder {
        loge("绑定", "---CME---TargetService.onBind()")

        object : CountDownTimer(10_000L, 1_000) {
            override fun onFinish() {
                mCallback?.onDataChange("倒计时结束了！")
            }

            override fun onTick(millisUntilFinished: Long) {
                mCallback?.onDataChange("当前剩余时间：$millisUntilFinished")
            }

        }.start()
        
        return MyBinder()
    }

    override fun unbindService(conn: ServiceConnection) {
        loge("解绑 Service", "---CME---TargetService.unbindService()")
        super.unbindService(conn)
    }

    fun setCallback(callback: Callback) {
        this.mCallback = callback
    }
    
    inner class MyBinder : Binder() {
        fun getMyService(): TargetService {
            return this@TargetService
        }
    }

    interface Callback {
        fun onDataChange(data: String)
    }
}

Activity

class ServiceActivity : AppCompatActivity(), ServiceConnection {

    private lateinit var mIntent: Intent

    private val mHandler = object : Handler() {
        override fun handleMessage(msg: Message) {
            super.handleMessage(msg)
            tv_result.text = "${tv_result.text}\n${msg.data.getString("data")}"
        }
    }


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.act_service)

        mIntent = Intent(this, TargetService::class.java)

        srb_startService.onClick {
            bindService(mIntent, this, Context.BIND_AUTO_CREATE)
        }

        srb_stopService.onClick {
            unbindService(this)
        }
    }

    override fun onServiceDisconnected(name: ComponentName?) {}

    override fun onServiceConnected(name: ComponentName?, service: IBinder) {
        val myBinder = service as TargetService.MyBinder
        myBinder.getMyService().setCallback(object : TargetService.Callback {
            override fun onDataChange(data: String) {
                val msg = Message()
                val bundle = Bundle()
                bundle.putString("data", data)
                msg.data = bundle
                mHandler.sendMessage(msg)
            }
        })
    }
}

4. Activity 启动模式

1. 4种启动模式

standard：标准模式，不会开启新的任务栈，系统默认。
- 在这种模式下，每次启动一个 Activity，都会创建一个新的 Activity 实例压入到任务栈的顶部。
- 所有的生命周期函数都会被调用。
- 该实例处于启动该 Activity 的 Activity 任务栈中。

singleTop：栈顶复用，不会开启新的任务栈。
- 如果被开启的 Activity 处在任务栈的栈顶，那么该 Activity 不会被重新创建，而是直接复用存在在栈顶的那个 Activity 实例。此时会将 Intent 对象传入，并回调 onNewIntent() 方法。
- 这里如果被开启的 Activity 没有处于任务栈的顶部，那么依旧会重新创建一个新的 Activity 实例。此时无论该任务栈是否有 Activity 实例存在，都会和标准模式一样。
- 应用场景：IM 消息推送，新闻推送。

singleTask：栈内复用，可以看成是一种单例模式。
- 与 singleTop 的区别在与：singleTop 检测的是栈顶的实例，而 singleTask 则会遍历整个任务栈。
- 如果占内存在要开启的 Activity 实例，则会关闭该实例上面的所有 Activity，将该实例放到栈顶。同时将 Intent 对象传入，并回调 onNewIntent() 方法。
- 常用于主界面。
步骤：
1. 首先会根据 taskAffinity 属性去寻找是否存在一个对应名字的任务栈；
2. 如果不存在，则会创建一个新的任务栈，并创建一个新的实例加入到该任务栈中；
3. 如果存在，则会得到该任务栈，查找该任务栈中是否存在 Activity 的实例。如果存在，就会将实例以上的 Activity 都出栈，并回调 onNewIntent() 方法；如果不存在，就会创建一个新的 Activity 实例入栈。

singleInstance：单一实例，整个系统中只存在一个 Activity 实例，并且独享一个任务栈。
- 以该模式启动的 Activity 具有全局唯一性，即整个系统只存在一个实例；
- 启动时，如果存在该实例，会把该实例所在的任务调度到前台，复用该实例；
- 由于独占性，被他启动的任何 Activity 都只能运行在其他任务战中；
- 应用场景：呼叫来电