Activity-onActivityForResult业务解耦

接https://www.jianshu.com/p/2aec07816bbd

之前方案存在的问题

1.无法处理多个requestCode对应一个ResultHandler，例如A业务包含增加、删除、修改三个子业务 ；
2.ResultHandler 功能不内聚，理应由自己决定是否处理该requestCode业务，而不是是由ResultDispatcher 分发器决定；
3.dispatch的参数没有封装，一旦入参过多，阅读性就比较差。

先从简单的开始解决。

针对问题3，面向对象封装dispatch的参数

密封类封装参数，这里只列举了常用的参数，可以根据业务情况进行调整。
传递对象，对业务变化是很有好处，因为不至于因为参数增减，而改变函数的定义。

//密封类
data class Result(val requestCode: Int, val data: Intent?)

//ResultHandler onResult函数变化
 abstract fun onResult(result：Result)

//ResultDispatcher dispatch函数的变化
fun dispatch(result：Result)

针对问题2，由ResultHandler 决定是否处理该requestCode；

interface ResultHandler {

   val requestCodes: MutableList<Int>//1

    fun isHandle(requestCode: Int): Boolean {//2
        return requestCodes.contains(requestCode)
    }

    fun onResult(result：Result)
}

注释1：集合维护该ResultHandler需要处理的requestCode，可以是多个；
注释2：isHandle判断是否处理该requestCode；

针对问题1，map代替list来处理多对一的关系；

interface ResultHandler {
    abstract val requestCodeMap: MutableMap<Int,XXX>
    ......
}

大家可能注意到了，requestCodeMap的value是XXX(待定)，因为value的类型是值得考虑。

业务场景：图片业务，可以划分增加图片、删除图片、修改图片三种，他们分别对应一个requestCode，那么第一反应XXX是类，分别是增加图片子类、删除图片子类、修改图片子类。这样的设计也没有太大的问题。
但这里我们可以用函数式编程，XXX是函数类型，增加、删除、修改，分别对应不同的函数。ResultHandler 负责图片业务处理，具有处理增加、删除、修改的能力，也很符合单一设计原则。
不适用类还有一个好处，减少接口、类的定义。

最后优化代码，大家可以看下注释，我就不一一解读了，因为也不是很复杂。

业务处理接口

/***
 * 业务处理接口，
 */
interface ResultHandler {

    /***
     * 子类必须实现，注册需要处理的requestCode 以及函数
     * requestCode 与 高阶函数对应关系
     */
    val map: MutableMap<Int, ((Result) -> Unit)>

    /**
     * 分发器判断requestCode是否由该处理器处理
     */
    fun isHandle(requestCode: Int) = map.contains(requestCode)

    /**
     * 调用对应的高阶函数进行处理
     */
    fun onResult(result: Result) {
        map[result.requestCode]?.invoke(result)
    }
}

Result的定义

data class Result(val requestCode: Int, val data: Intent?)

ResultHandler的实现

/***
 * 图片业务处理
 */
class PhotoResultHandler : ResultHandler {
    /***
     * 注册需要处理的requestCode以及高阶函数
     * 这里需要处理增加图片、删除图片、修改图片
     */
    override val map: MutableMap<Int, (Result) -> Unit> =
        mutableMapOf<Int, (Result) -> Unit>().apply {
            put(ResultDispatcher.CODE_ADD_PHOTO, ::addPhoto)
            put(ResultDispatcher.CODE_DEL_PHOTO, ::delPhoto)
            put(ResultDispatcher.CODE_MODIFY_PHOTO, ::modifyPhoto)
        }

    /***
     * 增加图片
     */
    private fun addPhoto(result: Result) {}

    /***
     * 删除图片
     */
    private fun delPhoto(result: Result) {}

    /***
     * 修改图片
     */
    private fun modifyPhoto(result: Result) {}
}

/***
 * 视频业务处理
 */
class VideoResultHandler : ResultHandler {

    override val map: MutableMap<Int, (Result) -> Unit> =
        mutableMapOf<Int, (Result) -> Unit>().apply {
            put(ResultDispatcher.CODE_VIDEO, ::handleVideo)
        }

    private fun handleVideo(result: Result) {}
}

ResultDispatcher的实现

object ResultDispatcher {

    const val CODE_ADD_PHOTO = 1//增加图片
    const val CODE_DEL_PHOTO = 2//删除图片
    const val CODE_MODIFY_PHOTO = 3//修改图片

    const val CODE_VIDEO = 4//视频

    /***
     * 维护ResultHandler
     */
    private val handlers = mutableListOf<ResultHandler>().apply {
        add(PhotoResultHandler())
        add(VideoResultHandler())
    }

    /***
     * 查找对应的处理器进行分发
     */
    fun dispatch(requestCode: Int, intentData: Intent?) {
        handlers.firstOrNull { it.isHandle(requestCode) }?.onResult(Result(requestCode, intentData))
    }
}

调用处

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        ResultDispatcher.dispatch(requestCode, data)
    }

以上分析有不对的地方，请指出，互相学习，谢谢哦！