前言

对Activity和Fragment之间的跳转封装处理，在Activity/Framgent中用法基本一样。每个函数基本上都对应着一个扩展函数，方便调用。实现方式有很多种，可以自由组合，实际使用时按需求使用。

Intent 扩展函数api列表

  1. //传值解析函数
  2. intentK                            :intent 获取传值扩展函数
  3. //创建 intent
  4. intentOf                        :生成Intent并添加参数(可选）
  5. createIntent        :生成Intent并添加参数(可选）
  6. createActivityIntent:生成跳转的Intent并添加参数,也可以不添加参数
  7. createBroadcastIntent:生成发送广播 intent,可以添加参数
  8. addPair                            :Intent 添加参数
  10. startActivityK            :跳转
  11. startActivityForResultK    :带回调的跳转
  12. browse                            :打开浏览器
  13. share                                :生调用分享，只能分享文本
  14. email                                :发送邮件
  15. makeCallPermission    :拨打电话，需要权限
  16. makeCall                        :拨打电话
  17. sendSMS                            :发送短信

常规跳转startActivity，没有回调

  1. 不带任何参数

    1. IntentKtx.startActivityK(this,TvActivity::class.java)
    2. IntentKtx.startActivityK<TvActivity>(this)
    3. startActivityK<TvActivity>()//扩展函数

    前两个是封装函数，第3个是扩展函数，可以直接在Activity好Fragment中调用，在其他地方只要有Context也可以调用扩展函数，方式如下：

    1. context.startActivityK<TvActivity>()

  2. 使用Intent传参

    1. val intent = Intent(this,TvActivity::class.java)
    2. intent.putExtra("tv","one")
    3. intent.putExtra("hai","hai---")
    4. IntentKtx.startActivityK(this,intent)

    对应的扩展函数：

    1. val intent = Intent(this,TvActivity::class.java)
    2.      intent.putExtra("tv","one")
    3.      intent.putExtra("hai","hai---")
    4. //        IntentKtx.startActivityK(this,intent)
    5.      startActivityK(intent)

    更简便的写法： ``` Intent(this,TvActivity::class.java) .addPair(“tv” to “one”, “hai” to “two”) ?.let { startActivityK(it) }

//或者 createIntent( “tv” to “one”, “hai” to “two” ).let { startActivityK(it) }

  2. 3. 使用Pair传参

//函数 IntentKtx.startActivityK(this,TvActivity::class.java,”tv” to “one”,”hai” to “hello”) //扩展函数 startActivityK(TvActivity::class.java,”tv” to “one”,”hai” to “hello”)

  1. ```
  2. //函数
  3. IntentKtx.startActivityK<TvActivity>(this,"tv" to "one","hai" to "hello")
  4. //扩展函数
  5. startActivityK<TvActivity>("tv" to "one","hai" to "hello")

startActivityForResult跳转

使用Fragment处理onActivityResult，网络上有很多开源库都是使用Fragment处理封装。回调result就是onActivityResult里的resultCode, intent就是回传的数据。

  1. 无参跳转

    1. ActivityHelper.init(this)
    2.  ?.startActivityForResult(TvActivity::class.java){reuslt,intent->
    3.      Log.e(TAG, "btnMainStartListener: $reuslt ---- ${intent?.getStringExtra("key")}");
    4.  }

    对应的扩展函数：

    1. startActivityForResultK(TvActivity::class.java){ reuslt ,intent->
    2.          Log.e(TAG, "btnMainStartListener: $reuslt ---- ${intent?.getStringExtra("key")}");
    3.      }

  2. 无参跳转，使用内联函数

    1. ActivityHelper.init(this)
    2.  ?.startActivityForResult<TvActivity>{reuslt,intent->
    3.      Log.e(TAG, "btnMainStartListener: $reuslt ---- ${intent?.getStringExtra("key")}");
    4.  }

    对应的扩展函：

    1. startActivityForResultK<TvActivity>{result ,intent->
    2.    Log.e(TAG, "btnMainStartListener: $result ---${intent?.getStringExtra("key")}")
    3. }

  3. 使用Intent携带参数跳转

    1. //带参数跳转,数据放在 intent 里面
    2. /*       val intent2 = Intent(this,TvActivity::class.java)
    3.     intent2.putExtra("tv","key one")
    4.     ActivityHelper.init(this)
    5.         ?.startActivityForResult(intent2){result ,intent->
    6.             Log.e(TAG, "btnMainStartListener: $result ---- ${intent?.getStringExtra("key")}")
    7.         }*/
    8. //扩展函数
    9.   /* val intent2 = Intent(this,TvActivity::class.java)
    10.    intent2.putExtra("tv","key one")
    11.    startActivityForResultK(intent2){result ,intent->
    12.        Log.e(TAG, "btnMainStartListener: $result ---- ${intent?.getStringExtra("key")}")
    13.    }*/

  4. 使用Pair带参跳转

    1. //pair 传值
    2.    /*ActivityHelper.init(this)
    3.        ?.startActivityForResult(TvActivity::class.java,
    4.        "tv" to "key one", "hai" to "key two"){result ,intent->
    5.            Log.e(TAG, "btnMainStartListener: $result ---- ${intent?.getStringExtra("key")}")
    6.        }*/
    7. //扩展函数
    8. /*      startActivityForResultK(TvActivity::class.java,
    9.        "key" to "key one", "key2" to "key two"){result ,intent->
    10.        Log.e(TAG, "btnMainStartListener: $result ---- ${intent?.getStringExtra("key")}")
    11.    }*/

  5. 使用Pair带参跳转，内联函数

    1. //方法一  
    2. ActivityHelper.init(this)
    3.    ?.startActivityForResult(TvActivity::class.java,{result ,intent->
    4.             Log.e(TAG, "btnMainStartListener: $result ---- ${intent?.getStringExtra("key")}")
    5.         },"key" to "key one", "key2" to "key two")
    6. //方法二          
    7. ActivityHelper.init(this)
    8.          ?.startActivityForResult<TvActivity>("key" to "key one", "key2" to "key two"){result ,intent->
    9.              Log.e(TAG, "btnMainStartListener: $result ---- ${intent?.getStringExtra("key")}")
    10.          }
    11. //扩展函数
    12. startActivityForResultK<TvActivity>("tv" to "key one", "hai" to "key two"){result ,intent->
    13.        Log.e(TAG, "btnMainStartListener: $result ---- ${intent?.getStringExtra("key")}")
    14.    }

在目标Activity/Fragment使用

在目标Activity/Fragment界面，创建函数实现跳转。这样方便其他人调用跳转，而且不用关心传值的key，也方便以后同意修改。这里面无法直接使用扩展函数，有些方法虽然可以使用，但是并不比扩展函数更方便，这里给出几个简单示例，实现方式有很多种，可以自由组合，实际使用时按需求使用。

  1. companion object{
  2.     //这里不能直接使用扩展函数,简单几个示例,不带回调跳转
  3.     //不传参数一般也没必要在这里写，直接使用扩展函数更方便
  4.     fun starter(context: Context){
  5.         IntentKtx.startActivityK(context,TvActivity::class.java)
  6.     }
  7.     fun starter2(context: Context){
  8.         IntentKtx.startActivityK<TvActivity>(context)
  9.     }
  10.     //一般这种没有必要写在这里，直接用扩展函数跳转就好了
  11.     fun starter(context: Context,vararg pair: Pair<String,Any?>){
  12.         IntentKtx.startActivityK<TvActivity>(context,*pair)
  13.     }
  14.     //这里比较实现这种情况，key值定好，调用的地方直接传对应的参数就行了
  15.     fun starter(context: Context,tv: String?,hai: String?){
  16.         val intent = Intent(context,TvActivity::class.java)
  17.         intent.addPair("tv" to tv, "hai" to hai)
  18.         IntentKtx.startActivityK(context,intent)
  19.     }
  20.     //带回调跳转
  21.     fun starter(context: Context?,callback: ((Int, Intent?) -> Unit)?){
  22.         ActivityHelper.init(context)
  23.             ?.startActivityForResult<TvActivity>(callback)
  24.     }
  25.     //回调也一样，这里比较适合这种情况
  26.     fun starter(context: Context?,tv: String?,hai: String?,callback: ((Int, Intent?) -> Unit)?){
  27.         val intent = Intent(context,TvActivity::class.java)
  28.         intent.addPair("tv" to tv, "hai" to hai)
  29.         ActivityHelper.init(context)
  30.             ?.startActivityForResult(intent,callback)
  31.     }
  32.     //写成下面这样更
  33.        fun starter(context: Context, tv: String?, hai: String?, callback: ((Int, Intent?) -> Unit)?){
  34.             val intent = context.createIntent<TextViewActivity>("tv" to tv, "hai" to hai)
  35.             ActivityHelper.init(context)
  36.                 ?.startActivityForResult(intent,callback)
  37.         }
  38.         //或者写成这样，实现方式有很多，可以自由组合
  39.         fun starter2(context: Context, tv: String?, hai: String?, callback: ((Int, Intent?) -> Unit)?){
  40.             val intent = context.createIntent<TextViewActivity>("tv" to tv, "hai" to hai)
  41.             context.startActivityForResultK(intent,callback)
  42.         }
  43. }

其他界面调用示例：

  1.         //调用跳转类的跳转方法
  2. //        TvActivity.starter(this)
  3. //        TvActivity.starter(this,"one","two")
  4.         //回调跳转
  5. //        TvActivity.starter(this,"one","two"){result,intent ->
  6. //            Log.e(TAG, "btnMainStartListener: $result ---- ${intent?.getStringExtra("key")}")
  7. //        }

源码

内容比较简单，只有三个类，约400行代码。复制到代码中即可使用。

  • RouterFragment ```kotlin class RouterFragment : Fragment() {

    private val mCallbacks: SparseArray<((Int, Intent?) -> Unit)?> = SparseArray()

    private val mCodeGenerator: Random = Random()

    companion object {

    1.   fun newInstance(): RouterFragment? {
    2.       return RouterFragment()
    3.   }

    }

    override fun onCreate(savedInstanceState: Bundle?) {

    1.   super.onCreate(savedInstanceState)
    2.   //防止重复创建
    3.   retainInstance = true

    }

    fun startActivityForResult(intent: Intent, callback: ((Int, Intent?) -> Unit)?) {

    1.   val requestCode = makeRequestCode()
    2.   mCallbacks.put(requestCode, callback)
    3.   startActivityForResult(intent, requestCode)

    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {

    1.   super.onActivityResult(requestCode, resultCode, data)
    2.   //处理返回的结果
    3.   val callback = mCallbacks[requestCode]
    4.   mCallbacks.remove(requestCode)
    5.   callback?.run {
    6.       invoke(resultCode, data)
    7.   }

    }

    /**

    • 随机生成唯一的requestCode，最多尝试10次
    • @return */ private fun makeRequestCode(): Int { var requestCode: Int var tryCount = 0 do {
      1.  requestCode = mCodeGenerator.nextInt(0x0000FFFF)
      2.  tryCount++
      } while (mCallbacks.indexOfKey(requestCode) >= 0 && tryCount < 10) return requestCode }

}

  2. - IntentKtx
  3. ```kotlin
  4. object IntentKtx {
  5.     fun addPair(intent: Intent, vararg params: Pair<String, Any?>) {
  6.         params.forEach {
  7.             when (val value = it.second) {
  8.                 null -> intent.putExtra(it.first, null as Serializable?)
  9.                 is Int -> intent.putExtra(it.first, value)
  10.                 is Long -> intent.putExtra(it.first, value)
  11.                 is CharSequence -> intent.putExtra(it.first, value)
  12.                 is String -> intent.putExtra(it.first, value)
  13.                 is Float -> intent.putExtra(it.first, value)
  14.                 is Double -> intent.putExtra(it.first, value)
  15.                 is Char -> intent.putExtra(it.first, value)
  16.                 is Short -> intent.putExtra(it.first, value)
  17.                 is Boolean -> intent.putExtra(it.first, value)
  18.                 is Serializable -> intent.putExtra(it.first, value)
  19.                 is Bundle -> intent.putExtra(it.first, value)
  20.                 is Parcelable -> intent.putExtra(it.first, value)
  21.                 is Array<*> -> when {
  22.                     value.isArrayOf<CharSequence>() -> intent.putExtra(it.first, value)
  23.                     value.isArrayOf<String>() -> intent.putExtra(it.first, value)
  24.                     value.isArrayOf<Parcelable>() -> intent.putExtra(it.first, value)
  25.                     else -> throw Exception("Intent extra ${it.first} has wrong type ${value.javaClass.name}")
  26.                 }
  27.                 is IntArray -> intent.putExtra(it.first, value)
  28.                 is LongArray -> intent.putExtra(it.first, value)
  29.                 is FloatArray -> intent.putExtra(it.first, value)
  30.                 is DoubleArray -> intent.putExtra(it.first, value)
  31.                 is CharArray -> intent.putExtra(it.first, value)
  32.                 is ShortArray -> intent.putExtra(it.first, value)
  33.                 is BooleanArray -> intent.putExtra(it.first, value)
  34.                 else -> throw Exception("Intent extra ${it.first} has wrong type ${value.javaClass.name}")
  35.             }
  36.         }
  37.     }
  39.     /**
  40.      * 不带回调跳转相关
  41.      */
  42.     fun startActivityK(context: Context?, clazz: Class<*>) {
  43.         context?.startActivity(Intent(context, clazz))
  44.     }
  46.     inline fun <reified T> startActivityK(context: Context?) {
  47.         context?.startActivity(Intent(context, T::class.java))
  48.     }
  50.     fun startActivityK(context: Context?, intent: Intent) {
  51.         context?.startActivity(intent)
  52.     }
  54.     fun startActivityK(context: Context?, clazz: Class<*>, vararg params: Pair<String, Any?>) {
  55.         context?.run {
  56.             val intent = Intent(this, clazz)
  57.             intent.addPair(*params)
  58.             startActivity(intent)
  59.         }
  60.     }
  62.     inline fun <reified T> startActivityK(context: Context?, vararg params: Pair<String, Any?>) {
  63.         context?.run {
  64.             val intent = Intent(this, T::class.java)
  65.             intent.addPair(*params)
  66.             startActivity(intent)
  67.         }
  68.     }
  69. }
  72. /**
  73.  *生成跳转的Intent并添加参数
  74.  * @param T
  75.  * @param pair
  76.  */
  77. inline fun <reified T> Context.createIntentStart(vararg pair: Pair<String, Any?>) =
  78.     Intent(this, T::class.java).apply {
  79.         addPair(*pair)
  80.     }
  82. /**
  83.  *生成Intent添加参数,也可以不添加
  84.  */
  85. fun Context.createIntent(vararg pair: Pair<String, Any?>) = Intent().addPair(*pair)
  87. /**
  88.  *给Intent添加参数
  89.  * @param params
  90.  * @return
  91.  */
  92. fun Intent?.addPair(vararg params: Pair<String, Any?>): Intent? {
  93.     return this?.also { IntentKtx.addPair(it, *params) }
  94. }
  96. /**
  97.  * 不带回调,无参跳转
  98.  */
  99. fun Context?.startActivityK(clazz: Class<*>) {
  100.     this?.startActivity(Intent(this, clazz))
  101. }
  103. inline fun <reified T> Context?.startActivityK() {
  104.     this?.startActivity(Intent(this, T::class.java))
  105. }
  107. /**
  108.  * 不带回调,带参跳转
  109.  */
  110. fun Context?.startActivityK(intent: Intent) {
  111.     this?.startActivity(intent)
  112. }
  114. fun Context?.startActivityK(clazz: Class<*>, vararg pair: Pair<String, Any?>) {
  115.     this?.run {
  116.         val intent = Intent(this, clazz)
  117.         startActivity(intent.addPair(*pair))
  118.     }
  119. }
  121. inline fun <reified T> Context?.startActivityK(vararg pair: Pair<String, Any?>) {
  122.     this?.run {
  123.         val intent = Intent(this, T::class.java)
  124.         startActivity(intent.addPair(*pair))
  125.     }
  126. }
  128. /**
  129.  * 不带回调,无参跳转
  130.  */
  131. fun Fragment?.startActivityK(clazz: Class<*>) {
  132.     this?.startActivity(Intent(activity, clazz))
  133. }
  135. inline fun <reified T> Fragment?.startActivityK() {
  136.     this?.startActivity(Intent(activity, T::class.java))
  137. }
  139. /**
  140.  * 不带回调,带参跳转
  141.  */
  142. fun Fragment?.startActivityK(intent: Intent) {
  143.     this?.startActivity(intent)
  144. }
  146. fun Fragment?.startActivityK(clazz: Class<*>, vararg pair: Pair<String, Any?>) {
  147.     this?.run {
  148.         val intent = Intent(activity, clazz)
  149.         startActivity(intent.addPair(*pair))
  150.     }
  151. }
  153. inline fun <reified T> Fragment?.startActivityK(vararg pair: Pair<String, Any?>) {
  154.     this?.run {
  155.         val intent = Intent(activity, T::class.java)
  156.         startActivity(intent.addPair(*pair))
  157.     }
  158. }
  161. /**
  162.  * Context扩展函数跳转
  163.  */
  164. fun Context?.startActivityForResultK(clazz: Class<*>, callback: ((Int, Intent?) -> Unit)?) {
  165.     ActivityHelper.init(this)?.startActivityForResult(clazz, callback)
  166. }
  168. fun Context?.startActivityForResultK(intent: Intent, callback: ((Int, Intent?) -> Unit)?) {
  169.     ActivityHelper.init(this)?.startActivityForResult(intent, callback)
  170. }
  172. inline fun <reified T> Context?.startActivityForResultK(noinline callback: ((Int, Intent?) -> Unit)?) {
  173.     ActivityHelper.init(this)?.startActivityForResult<T>(callback)
  175. }
  177. fun Context?.startActivityForResultK(
  178.     clazz: Class<*>,
  179.     vararg pair: Pair<String, Any?>,
  180.     callback: ((Int, Intent?) -> Unit)?
  181. ) {
  182.     ActivityHelper.init(this)
  183.         ?.startActivityForResult(clazz, callback, *pair)
  184. }
  186. inline fun <reified T> Context?.startActivityForResultK(
  187.     vararg pair: Pair<String, Any?>,
  188.     noinline callback: ((Int, Intent?) -> Unit)?
  189. ) {
  190.     ActivityHelper.init(this)
  191.         ?.startActivityForResult<T>(callback, *pair)
  192. }
  195. /**
  196.  * 上述方法在 fragment 中扩展
  197.  */
  198. fun Fragment?.startActivityForResultK(clazz: Class<*>, callback: ((Int, Intent?) -> Unit)?) {
  199.     ActivityHelper.init(this?.context)?.startActivityForResult(clazz, callback)
  200. }
  202. fun Fragment?.startActivityForResultK(intent: Intent, callback: ((Int, Intent?) -> Unit)?) {
  203.     ActivityHelper.init(this?.context)?.startActivityForResult(intent, callback)
  204. }
  206. inline fun <reified T> Fragment?.startActivityForResultK(noinline callback: ((Int, Intent?) -> Unit)?) {
  207.     ActivityHelper.init(this?.context)?.startActivityForResult<T>(callback)
  208. }
  210. fun Fragment?.startActivityForResultK(
  211.     clazz: Class<*>,
  212.     vararg pair: Pair<String, Any?>,
  213.     callback: ((Int, Intent?) -> Unit)?
  214. ) {
  215.     ActivityHelper.init(this?.context)
  216.         ?.startActivityForResult(clazz, callback, *pair)
  217. }
  219. inline fun <reified T> Fragment?.startActivityForResultK(
  220.     vararg pair: Pair<String, Any?>,
  221.     noinline callback: ((Int, Intent?) -> Unit)?
  222. ) {
  223.     ActivityHelper.init(this?.context)
  224.         ?.startActivityForResult<T>(callback, *pair)
  225. }
  227. /**
  228.  *跳转到浏览器
  229.  * @param url
  230.  * @param newTask
  231.  * @return
  232.  */
  233. fun Context.browse(url: String, newTask: Boolean = false): Boolean {
  234.     return try {
  235.         val intent = Intent(Intent.ACTION_VIEW)
  236.         intent.data = Uri.parse(url)
  237.         if (newTask) {
  238.             intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
  239.         }
  240.         startActivity(intent)
  241.         true
  242.     } catch (e: ActivityNotFoundException) {
  243.         e.printStackTrace()
  244.         false
  245.     }
  246. }
  248. /**
  249.  *跳转到浏览器
  250.  * @param url
  251.  * @param newTask
  252.  * @return
  253.  */
  254. fun Fragment.browse(url: String, newTask: Boolean = false) = activity?.browse(url, newTask)
  256. /**
  257.  *原生调用分享，只能分享文本
  258.  * @param text
  259.  * @param subject
  260.  * @param title
  261.  * @return
  262.  */
  263. fun Context.share(text: String, subject: String = "", title: String? = null): Boolean {
  264.     return try {
  265.         val intent = Intent(android.content.Intent.ACTION_SEND)
  266.         intent.type = "text/plain"
  267.         intent.putExtra(android.content.Intent.EXTRA_SUBJECT, subject)
  268.         intent.putExtra(android.content.Intent.EXTRA_TEXT, text)
  269.         startActivity(Intent.createChooser(intent, title))
  270.         true
  271.     } catch (e: ActivityNotFoundException) {
  272.         e.printStackTrace()
  273.         false
  274.     }
  275. }
  277. /**
  278.  *发送邮件
  279.  * @param email
  280.  * @param subject
  281.  * @param text
  282.  * @return
  283.  */
  284. @SuppressLint("QueryPermissionsNeeded")
  285. fun Context.email(email: String, subject: String = "", text: String = ""): Boolean {
  286.     val intent = Intent(Intent.ACTION_SENDTO)
  287.     intent.data = Uri.parse("mailto:")
  288.     intent.putExtra(Intent.EXTRA_EMAIL, arrayOf(email))
  289.     if (subject.isNotEmpty())
  290.         intent.putExtra(Intent.EXTRA_SUBJECT, subject)
  291.     if (text.isNotEmpty())
  292.         intent.putExtra(Intent.EXTRA_TEXT, text)
  293.     if (intent.resolveActivity(packageManager) != null) {
  294.         startActivity(intent)
  295.         return true
  296.     }
  297.     return false
  298. }
  300. /**
  301.  *拨打电话,需要权限permission.CALL_PHONE才能拨打
  302.  * @param number
  303.  * @return
  304.  */
  305. @SuppressLint("MissingPermission")
  306. fun Context.makeCallPermission(number: String): Boolean {
  307.     return try {
  308.         val intent = Intent(Intent.ACTION_CALL, Uri.parse("tel:$number"))
  309.         startActivity(intent)
  310.         true
  311.     } catch (e: Exception) {
  312.         e.printStackTrace()
  313.         false
  314.     }
  315. }
  317. fun Fragment.markCallPermission(number: String) = context?.makeCallPermission(number)
  319. /**
  320.  *拨打电话,不需要权限,跳转到拨打电话界面
  321.  * @param number
  322.  * @return
  323.  */
  324. fun Context.makeCall(number: String) {
  325.     val uri = Uri.parse("tel:$number")
  326.     val it = Intent(Intent.ACTION_DIAL, uri)
  327.     startActivity(it)
  328. }
  330. fun Fragment.markCall(number: String) = context?.makeCall(number)
  332. /**
  333.  *发送短信
  334.  * @param number
  335.  * @param text
  336.  * @return
  337.  */
  338. fun Context.sendSMS(number: String, text: String = ""): Boolean {
  339.     return try {
  340.         val intent = Intent(Intent.ACTION_VIEW, Uri.parse("sms:$number"))
  341.         intent.putExtra("sms_body", text)
  342.         startActivity(intent)
  343.         true
  344.     } catch (e: Exception) {
  345.         e.printStackTrace()
  346.         false
  347.     }
  348. }
  350. fun Fragment.sendSMS(number: String, text: String = "") = context

  • ActivityHelper ```kotlin class ActivityHelper private constructor(activity: FragmentActivity) { private val TAG = “MMMK” var mContext: Activity? = null private var mRouterFragment: RouterFragment? = null

    init {

    1.   mContext = activity
    2.   mRouterFragment = getRouterFragment(activity)

    }

    companion object { // fun init(activity: FragmentActivity?): ActivityHelper? { // if (activity != null) return ActivityHelper(activity) // return null // }

    1.   fun init(context: Context?): ActivityHelper? {
    2.       if (context is FragmentActivity) return ActivityHelper(context)
    3.       return null
    4.   }

    }

  1. private fun getRouterFragment(activity: FragmentActivity): RouterFragment? {
  2.     var routerFragment: RouterFragment? = findRouterFragment(activity)
  3.     if (routerFragment == null) {
  4.         //创建 fragment,加入当前 activity
  5.         routerFragment = RouterFragment.newInstance()
  6.         val sfm = activity.supportFragmentManager
  7.         sfm.beginTransaction().add(routerFragment!!, TAG).commitAllowingStateLoss()
  8.         sfm.executePendingTransactions()
  9.     }
  10.     return routerFragment
  11. }
  13. private fun findRouterFragment(activity: FragmentActivity): RouterFragment? {
  14.     //通过 tag 获取 fragment
  15.     return activity.supportFragmentManager.findFragmentByTag(TAG) as RouterFragment?
  16. }
  19. /**
  20.  * 对Intent跳转,不带参数
  21.  */
  22. fun startActivityForResult(
  23.     clazz: Class<*>,
  24.     callback: ((Int, Intent?) -> Unit)?
  25. ) {
  26.     mContext?.run {
  27.         val intent = Intent(this, clazz)
  28.         startActivityForResult(intent, callback)
  29.     }
  30. }
  32. inline fun <reified T> startActivityForResult(noinline callback: ((Int, Intent?) -> Unit)?) {
  33.     mContext?.run {
  34.         val intent = Intent(mContext, T::class.java)
  35.         startActivityForResult(intent, callback)
  36.     }
  37. }
  39. /**
  40.  *带参数跳转
  41.  * @param T
  42.  * @param pair
  43.  * @param callback
  44.  */
  45. inline fun <reified T> startActivityForResult(
  46.     vararg pair: Pair<String, Any?>,
  47.     noinline callback: ((Int, Intent?) -> Unit)?
  48. ) {
  49.     if (mContext == null) return
  50.     val intent = Intent(mContext, T::class.java)
  51.     IntentKtx.addPair(intent, *pair)
  52.     startActivityForResult(intent, callback)
  53. }
  55. inline fun <reified T> startActivityForResult(
  56.     noinline callback: ((Int, Intent?) -> Unit)?,
  57.     vararg pair: Pair<String, Any?>
  58. ) {
  59.     if (mContext == null) return
  60.     val intent = Intent(mContext, T::class.java)
  61.     IntentKtx.addPair(intent, *pair)
  62.     startActivityForResult(intent, callback)
  63. }
  65. fun startActivityForResult(
  66.     clazz: Class<*>,
  67.     vararg pair: Pair<String, Any?>,
  68.     callback: ((Int, Intent?) -> Unit)?
  69. ) {
  70.     mContext?.run {
  71.         val intent = Intent(this, clazz)
  72.         IntentKtx.addPair(intent, *pair)
  73.         startActivityForResult(intent, callback)
  74.     }
  75. }
  77. fun startActivityForResult(
  78.     clazz: Class<*>,
  79.     callback: ((Int, Intent?) -> Unit)?,
  80.     vararg pair: Pair<String, Any?>
  81. ) {
  82.     mContext?.run {
  83.         val intent = Intent(this, clazz)
  84.         IntentKtx.addPair(intent, *pair)
  85.         startActivityForResult(intent, callback)
  86.     }
  87. }
  89. /**
  90.  * 对Intent跳转,带参数
  91.  * @param intent  参数提取放入intent中
  92.  * @param callback
  93.  */
  94. fun startActivityForResult(intent: Intent, callback: ((Int, Intent?) -> Unit)?) {
  95.     mRouterFragment?.run {
  96.         startActivityForResult(intent, callback)
  97.     }
  98. }

}

  1. <a name="Sr423"></a>
  2. ## 导入依赖
  3. 不想复制更省事的方法，直接依赖即可。依赖如下：<br />[Github](https://github.com/KiWiLss/LUtils)上面有详细的文档。<br />[最新版](https://www.jitpack.io/v/KiWiLss/LUtils.svg)
  4. ```kotlin
  5.     allprojects {
  6.         repositories {
  7.             ...
  8.             maven { url 'https://www.jitpack.io' }
  9.         }
  10.     }
  12. dependencies {
  13.             implementation 'com.github.KiWiLss:LUtils:1.1.0'
  14.     }

使用前要调用，获取到 Context：

  1. object LUtilsConfig{
  3.     lateinit var mContext: Context
  4.     fun init(context: Context) {
  5.         mContext = context
  6.     }