Butterfly 重磅更新，一个支持Activity、Fragment、DialogFragment以及Compose UI的全功能路由组件化框架

GitHub: github.com/ssseasonnn/…

经过绵长的等待，Butterfly 总算发布了新版本，本次更新为我们带来全功用的路由框架，不只支撑Activity、Fragment和DialogFragment，同时增加了Compose UI的路由支撑，至此，一个大一统的路由框架诞生了。不只细巧灵敏，并且功用强壮，Butterfly供给了一致的API，你无需关怀目的地是什么，在哪里，只需求供给一个scheme，Butterfly便会导航至正确的当地。

话不多说，先看下Butterfly支撑的功用列表。

功用列表

✅ 支撑导航Activity
✅ 支撑导航Fragment
✅ 支撑导航DialogFragment
✅ 支撑导航Compose UI
✅ 支撑导航Action
✅ 支撑导航参数传递和解析
✅ 支撑获取导航回来结果
✅ 支撑导航阻拦器
✅ 支撑Fragment和Compose UI回退栈
✅ 支撑Fragment和Compose UI组办理
✅ 支撑Fragment和Compose UI发动方式，如SingleTop、ClearTop
✅ 支撑组件化通讯

导航和参数传递

耳听为虚，眼见为实，如此强壮的功用，没有几个示例怎样能行，来看一眼基本的导航功用：

@Agile("test/activity")
class AgileTestActivity : AppCompatActivity()
@Agile("test/fragment")
class TestFragment : Fragment()
@Agile("test/dialog")
class TestDialogFragment : DialogFragment()
//导航
Butterfly.agile("test/xxx").carry()
//或许导航并获取回来数据
Butterfly.agile("test/xxx")
    .carry {
        val result = it.getStringExtra("result")
        binding.tvResult.text = result
    }

如上所示，导航就是这么简略，无论目的地是什么、在何方，只需求一个scheme即可完成路由跳转。 scheme没有任何限制，能够是任意字符串，也能够是规范scheme，如butterfly://home/path等。

在导航的过程中，参数传递也是必不可少的一环，Butterfly供给两种方式供你挑选，一是经过拼接scheme的方式，如test/activity?paramA=123&paramB=abc，即可将paramA和paramB传递至目的地，二是经过调用params办法，传递需求的数据，如：

//拼接scheme
Butterfly.agile("test/scheme?a=1&b=2").carry()
//调用params
Butterfly.agile("test/scheme?a=1&b=2")
    .params("intValue" to 1)
    .params("booleanValue" to true)
    .params("stringValue" to "test value")
    .carry()

如上所示，拼接scheme和调用params办法能够同时进行，在导航目的地能够获取到传递的一切的参数，params办法能够传递Bundle支撑的任意类型的参数。

在目的地承受参数：

//在导航目的地页面，可经过参数的key字段来获取传递的参数值
@Agile("test/scheme")
class AgileTestActivity : AppCompatActivity() {
    val a by lazy { intent?.getStringExtra("a") ?: "" }
    val b by lazy { intent?.getStringExtra("b") ?: "" }
    val intValue by lazy { intent?.getIntExtra("intValue", 0) ?: 0 }
}

//除了手动解析参数以外，还能够装备Bracer来完成全主动进行参数解析
@Agile("test/scheme")
class AgileTestActivity : AppCompatActivity() {
    val a by params<String>()
    val b by params<String>()
    val intValue by params<Int>()
}

Bracer 运用方式概况见: Github 地址 Bracer

Compose 导航

Compose 作为Android全新的UI框架异军突起，越来越多的项目正在大量运用Compose，因此支撑Compose导航现已刻不容缓。

@Agile("test/compose")
@Composable
fun HomeScreen() {
    Box {
        ...
    }
}
//导航到HomeScreen页面
Butterfly.agile("test/compose").carry()

如上所示，Compose的导航和Activity或Fragment的导航完全一致，一致的API使得简略易用程度得到更进一步的进步。

Compose 导航中的参数传递和获取与Activity或Fragment几乎相同，传递参数相同支撑拼接scheme和调用params参数。获取参数只需求给Compose组件增加一个Bundle参数，随后即可经过该bundle参数获取导航中传递的参数。

@Agile("test/compose")
@Composable
fun HomeScreen(bundle: Bundle) {
    val a by bundle.params<Int>()
    val b by bundle.params<Int>()
    val booleanValue by bundle.params<Boolean>()
    Box {
        Text(text = a)
    }
}
//拼接scheme
Butterfly.agile("test/compose?a=1&b=2").carry()
//或许调用params
Butterfly.agile("test/compose?a=1&b=2")
    .params("intValue" to 1)
    .params("booleanValue" to true)
    .params("stringValue" to "test value")
    .carry()

路由阻拦器

阻拦器是一个很实用的功用，能够供给强壮的路由操控功用，如登录检测、AB测试等功用。Butterfly供给两种效果域的阻拦器：大局阻拦器和一次性阻拦器，可针对不同运用场景灵敏挑选。

首先界说好阻拦器功用：

//自界说阻拦器
class TestInterceptor : ButterflyInterceptor {
    override fun shouldIntercept(agileRequest: AgileRequest): Boolean {
        //检测是否需求阻拦
        return true
    }
    override suspend fun intercept(agileRequest: AgileRequest) {
        //处理阻拦逻辑
        println("intercepting")
        delay(5000)
        println("intercept finish")
    }
}

装备大局阻拦器：

//增加大局阻拦器
ButterflyCore.addInterceptor(TestInterceptor())
//越过一切大局阻拦器
Butterfly.agile("test/scheme").skipGlobalInterceptor().carry()

装备一次性阻拦器：

//仅当前导航运用该阻拦器
Butterfly.agile("test/scheme")
    .addInterceptor(TestInterceptor())
    .carry()

阻拦器供给了suspend的intercept办法，聪明的你应该一眼就能明白它的强壮之处。

SingleTop和ClearTop发动方式以及回退栈

众所周知，Activity支撑多种发动方式，其间SingleTop和ClearTop尤为常用， Butterfly将这两种发动方式带给了Fragment和Compose，并且供给了一致的API，只需求调用singleTop或许clearTop即可。

//for Activity
@Agile("test/activity")
class AgileTestActivity : AppCompatActivity()
Butterfly.agile("test/activity")
    .clearTop()              
    // or .singleTop() 
    .carry()
//for Fragment
@Agile("test/fragment")
class TestFragment : Fragment()
Butterfly.agile("test/fragment")
    .clearTop()                 
    // or .singleTop()   
    .carry()
//for Compose
@Agile("test/compose")
@Composable
fun HomeScreen() {}
Butterfly.agile("test/compose")
    .clearTop()                 
     // or .singleTop()  
    .carry()

有了发动方式，回退栈自然必不可少，默认情况下，Butterfly运用回退栈对Activity、Fragment、DialogFragment以及Compose进行办理，每逢导航到一个目的地时，该目的地将会增加到回退栈中，经过运用retreat办法即可回退至上一个页面。

//封闭栈顶页面，回退至上一个页面
Butterfly.retreat()
//封闭栈顶页面, 回退至上一个页面并回来数据
Butterfly.retreat("result" to "123")

因为Compose的特性，不支撑回退并回来数据，Compose可直接经过再次导航传递新数据的方式改写页面

Fragment和Compose的组办理

除了运用栈的方式对Fragment和Compose进行办理以外， Butterfly还支撑运用group的方式对它们进行办理，例如APP首页多个TAB对应多个Fragment、Compose Screen的景象，运用组办理能够很好的应对这种场景。

// group fragments
Butterfly.agile("test/fragment1")
    .group("groupName")          
    .carry()
Butterfly.agile("test/fragment2")
    .group("groupName")          
    .carry()
Butterfly.agile("test/fragment3")
    .group("groupName")          
    .carry()
// group composes
Butterfly.agile("test/compose_screen1")
    .group("groupName")          
    .carry()
Butterfly.agile("test/compose_screen2")
    .group("groupName")          
    .carry()
Butterfly.agile("test/compose_screen3")
    .group("groupName")          
    .carry()

运用相同的groupName可将这些Fragments或Compose Screens办理在同一个group中，在同一个group中重复导航不会重复创立实例。

组件化通讯

作为一个组件化路由框架，组件之间的通讯也是必不可少的功用。Butterfly除了支撑常规的接口下沉的方式，还支撑组件之间直接通讯，无需互相依靠。

运用接口下沉的方式，首先会有一个公共的依靠组件，通常叫Base或许Common，而需求通讯的两个组件如Home和Cart，都依靠于Base或许Common，构成如下的依靠图：

Butterfly 重磅更新，一个支持Activity、Fragment、DialogFragment以及Compose UI的全功能路由组件化框架

如Home需求调用Cart中的addToCart办法，首先需求在Base中界说通讯接口：

Module Base:

@Evade
interface CartApi {
    fun addToCart(product: String)
}

随后在Cart中创立CartApi的完成：

Module Cart:

@EvadeImpl
class CartApiImpl : CartApi {
    override fun addToCart(product: String) {
        // do something
    }
}

然后便能够在Home中调用CartApi供给的办法：

Module Home:

val cartApi = Butterfly.evade<CartApi>()
cartApi.addToCart("test")

运用接口下沉的方式很好，但也有一些问题，如果需求通讯的组件越来越多，那么下沉的接口也会越来越多，最终会导致Base或许Common爆破。因此，除了运用接口下沉的方式以外，Butterfly还供给了组件之间直接通讯的功用，组件之间完全无需任何依靠。

和之前的结构相似，相同是Home和Cart需求通讯，Home需求调用Cart中的addToCart办法，但这次不需求下沉接口至Base或Common，只需求在Home中界说通讯接口：

Module Home:

@Evade
interface CartApi {
    fun addToCart(product: String)
}

随后在Cart中创立CartApi的完成，因为Home和Cart之间没有直接依靠，因此在Cart的完成类无需完成Home中的接口，只需求运用和Home中的接口相同的办法名和办法参数即可：

Module Cart:

// 不需求完成CartApi
@EvadeImpl
class CartApiImpl {
    fun addToCart(product: String) {
        // do something
    }
}

然后便能够在Home中调用CartApi的办法：

Module Home:

val cartApi = Butterfly.evade<CartApi>()
cartApi.addToCart("test")

更多具体代码请移步GitHub: github.com/ssseasonnn/…

路由表注册和Gradle插件

Butterfly会为每个运用了注解的Module生成一个路由表, 命名规则为: Butterfly[模块名称]Module

手动注册:

class DemoApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        //注册
        ButterflyCore.addModule(ButterflyHomeModule())
        ButterflyCore.addModule(ButterflyFooModule())
        ButterflyCore.addModule(ButterflyBarModule())
    }
}

运用插件主动注册:

  1. 增加插件依靠
//运用 plugins DSL:
plugins {
    id "io.github.ssseasonnn.butterfly" version "1.0.1"
}
//或许运用legacy plugin application:
buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "io.github.ssseasonnn:plugin:1.0.1"
    }
}
//增加plugin
apply plugin: "io.github.ssseasonnn.butterfly"
  1. 完成自己的Application类
class DemoApplication : Application() {
    override fun onCreate() {
        super.onCreate()
    }
}

经过插件，Butterfly会主动发现一切的路由模块，并主动注入增加路由表的代码到Application中，达到了解放双手的目的

End

更多关于Butterfly的具体情况，请移步GitHub: github.com/ssseasonnn/…

欢迎感兴趣的朋友供给反馈和建议。