Jetpack之自定义Navigation

@FragmentDestination(pageUrl = WanRouterKey.FRAGMENT_MAIN_TABLES_HOME, asStarter = true)
class HomeFragment : BaseFragment(){}

@FragmentDestination(pageUrl = WanRouterKey.FRAGMENT_MAIN_TABLES_APPLY)
class ApplyFragment : BaseFragment() {}

@FragmentDestination(pageUrl = WanRouterKey.FRAGMENT_MAIN_TABLES_FIND)
class FindFragment : BaseFragment() {}

@FragmentDestination(pageUrl = WanRouterKey.FRAGMENT_MAIN_TABLES_MINE)
class MineFragment : BaseFragment() {}

val navController = Navigation.findNavController(this, R.id.nav_host_fragment)
NavGraphBuilder.build(navController,this,R.id.nav_host_fragment)
nav_view.setNavController(navController)

fun build(navController: NavController, activity: FragmentActivity, containerId: Int) {
            val navigatorProvider = navController.navigatorProvider
            val fragmentNavigator = CustomFragmentNavigator(
                activity, activity.supportFragmentManager,
                containerId
            )
            navigatorProvider.addNavigator(fragmentNavigator)
            val activityNavigator = navigatorProvider.getNavigator(ActivityNavigator::class.java)

            val destinationMap = NavConfig.getDestinationMap()
            val navGraph = NavGraph(NavGraphNavigator(navigatorProvider))

            for ((key, destination) in destinationMap) {
                if (destination.isFragment) {
                    val fragmentDestination = fragmentNavigator.createDestination()
                    fragmentDestination.className = destination.className!!
                    fragmentDestination.id = destination.id
                    fragmentDestination.addDeepLink(destination.pageUrl!!)
                    navGraph.addDestination(fragmentDestination)
                } else {
                    if(destination.isBelongTab){
                        val activityDestination = activityNavigator.createDestination()
                        activityDestination.id = destination.id
                        activityDestination.setComponentName(
                            ComponentName(
                                Utils.getApp().packageName,
                                destination.className!!
                            )
                        )
                        activityDestination.addDeepLink(destination.pageUrl!!)
                        navGraph.addDestination(activityDestination)
                    }
                }
                if (destination.asStarter) {
                    navGraph.startDestination = destination.id
                }
            }
            navController.graph = navGraph
        }

class NavConfig {

    companion object {
        private var sDestinationMap: HashMap<String, Destination> = HashMap()
        private var sBottomBar: BottomBar? = null

        fun getDestinationMap(): HashMap<String, Destination> {
            if (sDestinationMap.size == 0) {
                val jsons = parseNavFile()
                for (json in jsons){
                    val destination: HashMap<String, Destination> = GsonUtils.fromJson(json,
                        object : TypeToken<HashMap<String, Destination>>(){}.type)
                    sDestinationMap.putAll(destination)
                }
            }
            return sDestinationMap
        }

        fun getBottomBar(): BottomBar {
            if (sBottomBar == null) {
                val jsonContent = parseFile("main_tabs_config.json")
                sBottomBar = GsonUtils.fromJson(jsonContent, BottomBar::class.java)
            }
            return sBottomBar!!
        }

        /**
         * 解析assets中特定文件
         */
        private fun parseFile(s: String): String {
            val assets = Utils.getApp().resources.assets
            val open = assets.open(s)
            val stringBuilder = StringBuilder()
            val bufferedReader = BufferedReader(InputStreamReader(open))
            bufferedReader.use {
                var line: String?
                while (true) {
                    line = it.readLine() ?: break
                    stringBuilder.append(line)
                }
            }
            return stringBuilder.toString()
        }

        /**
         * 解析assets下的所有的导航相关的文件
         */
        private fun parseNavFile():List<String>{
            val jsons = mutableListOf<String>()
            val assets = Utils.getApp().resources.assets
            val list = assets.list("");
            if (list != null) {
                for (item in list){
                    if(item.contains("_nav")){
                        jsons.add(parseFile(item))
                    }
                }
            }
            return jsons
        }
    }
}

@Navigator.Name("customfragment")
class CustomFragmentNavigator(context: Context, manager: FragmentManager, containerId: Int) :
    Navigator<FragmentNavigator.Destination>() {

    private val TAG = "CustomFragmentNavigator"
    private val KEY_BACK_STACK_IDS = "androidx-nav-fragment:navigator:backStackIds"

    private var mContext: Context = context
    private var mFragmentManager: FragmentManager = manager
    private var mContainerId = containerId
    private val mBackStack = ArrayDeque<Int>()

    override fun navigate(
        destination: FragmentNavigator.Destination,
        args: Bundle?,
        navOptions: NavOptions?,
        navigatorExtras: Extras?
    ): NavDestination? {
        if (mFragmentManager!!.isStateSaved) {
            Log.i(
                TAG,
                "Ignoring navigate() call: FragmentManager has already"
                        + " saved its state"
            )
            return null
        }
        var className = destination.className
        if (className[0] == '.') {
            className = mContext!!.packageName + className
        }
        val ft = mFragmentManager!!.beginTransaction()

        var enterAnim = navOptions?.enterAnim ?: -1
        var exitAnim = navOptions?.exitAnim ?: -1
        var popEnterAnim = navOptions?.popEnterAnim ?: -1
        var popExitAnim = navOptions?.popExitAnim ?: -1
        if (enterAnim != -1 || exitAnim != -1 || popEnterAnim != -1 || popExitAnim != -1) {
            enterAnim = if (enterAnim != -1) enterAnim else 0
            exitAnim = if (exitAnim != -1) exitAnim else 0
            popEnterAnim = if (popEnterAnim != -1) popEnterAnim else 0
            popExitAnim = if (popExitAnim != -1) popExitAnim else 0
            ft.setCustomAnimations(enterAnim, exitAnim, popEnterAnim, popExitAnim)
        }

        val frg = mFragmentManager!!.primaryNavigationFragment
        if (frg != null) {
            ft.hide(frg)
        }

        val tag = destination.id.toString()
        var fragment = mFragmentManager!!.findFragmentByTag(tag)
        if (fragment == null) {
            fragment = mFragmentManager.getFragmentFactory().instantiate(mContext.classLoader, className)
            fragment!!.arguments = args
            ft.add(mContainerId, fragment, tag)
        } else {
            ft.show(fragment)
        }
        ft.setPrimaryNavigationFragment(fragment)

        @IdRes val destId = destination.id
        val initialNavigation = mBackStack.isEmpty()

        var np = navOptions
        np = NavOptions.Builder().setLaunchSingleTop(true).build()
        val isSingleTopReplacement = (!initialNavigation
                && np.shouldLaunchSingleTop())

        val isAdded: Boolean
        isAdded = if (initialNavigation) {
            true
        } else if (isSingleTopReplacement) { // Single Top means we only want one instance on the back stack
            if (mBackStack.size > 1) { // If the Fragment to be replaced is on the FragmentManager's
                // back stack, a simple replace() isn't enough so we
                // remove it from the back stack and put our replacement
                // on the back stack in its place
                mFragmentManager!!.popBackStack(
                    generateBackStackName(mBackStack.size, mBackStack.peekLast()),
                    FragmentManager.POP_BACK_STACK_INCLUSIVE
                )
                ft.addToBackStack(generateBackStackName(mBackStack.size, destId))
            }
            false
        } else {
            ft.addToBackStack(generateBackStackName(mBackStack.size + 1, destId))
            true
        }
        if (navigatorExtras is FragmentNavigator.Extras) {
            for ((key, value) in navigatorExtras.sharedElements) {
                ft.addSharedElement(key!!, value!!)
            }
        }
        ft.setReorderingAllowed(true)
        ft.commit()
        (return if (isAdded) {
            mBackStack.add(destId)
            destination
        } else {
            null
        })
    }

    override fun createDestination(): FragmentNavigator.Destination {
        return FragmentNavigator.Destination(this)//To change body of created functions use File | Settings | File Templates.
    }

    override fun popBackStack(): Boolean {
        if (mBackStack.isEmpty()) {
            return false
        }
        if (mFragmentManager!!.isStateSaved) {
            Log.i(
                TAG,
                "Ignoring popBackStack() call: FragmentManager has already"
                        + " saved its state"
            )
            return false
        }
        mFragmentManager?.popBackStack(
            generateBackStackName(mBackStack.size, mBackStack.peekLast()),
            FragmentManager.POP_BACK_STACK_INCLUSIVE
        )
        mBackStack.removeLast()
        return true
    }

    override fun onSaveState(): Bundle? {
        val b = Bundle()
        val backStack = IntArray(mBackStack.size)
        var index = 0
        for (id in mBackStack) {
            backStack[index++] = id
        }
        b.putIntArray(
            KEY_BACK_STACK_IDS,
            backStack
        )
        return b
    }

    override fun onRestoreState(savedState: Bundle) {
        if (savedState != null) {
            val backStack =
                savedState.getIntArray(KEY_BACK_STACK_IDS)
            if (backStack != null) {
                mBackStack.clear()
                for (destId in backStack) {
                    mBackStack.add(destId)
                }
            }
        }
    }

    private fun generateBackStackName(backStackIndex: Int, destId: Int): String {
        return "$backStackIndex-$destId"
    }
}

class BottomBarView : BottomNavigationView, BottomNavigationView.OnNavigationItemSelectedListener {

    private var navController: NavController? = null

    companion object {
        val sIcons = arrayOf(
            R.drawable.icon_tab_home, R.drawable.icon_tab_apply,
            R.drawable.icon_tab_find, R.drawable.icon_tab_mine
        )
    }

    constructor(context: Context) : this(context, null)
    constructor(context: Context, attrs: AttributeSet?) : this(context, attrs, 0)

    @SuppressLint("RestrictedApi")
    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(
        context,
        attrs,
        defStyleAttr
    ) {
        setOnNavigationItemSelectedListener(this)
        val bottomBar = NavConfig.getBottomBar()
        val states = arrayOfNulls<IntArray>(2)
        states[0] = intArrayOf(android.R.attr.state_selected)
        states[1] = intArrayOf()
        val colors = intArrayOf(
            Color.parseColor(bottomBar.activeColor),
            Color.parseColor(bottomBar.inActiveColor)
        )
        itemIconTintList = ColorStateList(states, colors)
        itemTextColor = ColorStateList(states, colors)
        //设置文本和字体一直都显示
        labelVisibilityMode = LabelVisibilityMode.LABEL_VISIBILITY_LABELED
        val tabs = bottomBar.tabs
        //添加menu
        for (tab in tabs) {
            if (!tab.enable) {
                continue
            }
            val itemId: Int = getItemId(tab.pageUrl)
            if (itemId < 0) {
                continue
            }
            val menu = menu
            val menuItem = menu.add(0, itemId, tab.index, tab.title)
            menuItem.setIcon(sIcons[tab.index])
        }
        //设置menu的大小 添加完所有的itemMenu之后才改变大小，因为每次添加都会先移除所有的item，排序之后再放入到容器中
        var index = 0
        for (tab in tabs) {
            if (!tab.enable) {
                continue
            }
            val itemId: Int = getItemId(tab.pageUrl)
            if (itemId < 0) {
                continue
            }
            val size = SizeUtils.dp2px(tab.size.toFloat())
            val menuView: BottomNavigationMenuView = getChildAt(0) as BottomNavigationMenuView
            val itemView: BottomNavigationItemView = menuView.getChildAt(index) as BottomNavigationItemView
            itemView.setIconSize(size)
            if (TextUtils.isEmpty(tab.title)) { //title为空的一般是中间的按钮 有那种中间变大的按钮
                val tintColor =
                    if (TextUtils.isEmpty(tab.tintColor)) Color.parseColor("#ff678f") else Color.parseColor(
                        tab.tintColor
                    )
                itemView.setIconTintList(ColorStateList.valueOf(tintColor))
                //禁止上下浮动的效果
                itemView.setShifting(false)
            }
            index++
        }
        //底部导航栏默认选中项
        if (0 != bottomBar.selectTab) {
            val selectTab = tabs[bottomBar.selectTab]
            if (selectTab.enable) {
                val itemId = getItemId(selectTab.pageUrl)
                //延迟一下在切换，等待NavGraphBuilder解析完成
                post { selectedItemId = itemId }
            }
        }
    }

    private fun getItemId(pageUrl: String): Int {
        val destination = NavConfig.getDestinationMap()[pageUrl]
        return destination?.id ?: -1
    }

    fun setNavController(navController: NavController) {
        this.navController = navController
    }

    override fun onNavigationItemSelected(item: MenuItem): Boolean {
        navController?.navigate(item.itemId)
        return true;
    }
}

val navController = Navigation.findNavController(this, R.id.nav_host_fragment)
NavGraphBuilder.build(navController,this,R.id.nav_host_fragment)
nav_view.setNavController(navController)

class NavManager {

    companion object{
        private var sNavController:NavController? = null
        private val sMavManager = NavManager()
        fun get():NavManager{
            setNavController()
            return sMavManager
        }
        private fun setNavController() {
            if(sNavController == null){
                val navController = NavController(Utils.getApp())
                val navigatorProvider = navController.navigatorProvider
                val navGraph = NavGraph(NavGraphNavigator(navigatorProvider))
                val activityNavigator = navigatorProvider.getNavigator(ActivityNavigator::class.java)
                val destinationMap = NavConfig.getDestinationMap()
                val activityDestinationStart:ActivityNavigator.Destination = getStartDestination(activityNavigator)
                navGraph.addDestination(activityDestinationStart)
                for ((key, destination) in destinationMap) {
                    if (!destination.isFragment&&!destination.isBelongTab){
                        val activityDestination = activityNavigator.createDestination()
                        activityDestination.id = destination.id
                        activityDestination.setComponentName(
                            ComponentName(Utils.getApp().packageName, destination.className!!)
                        )
                        activityDestination.addDeepLink(destination.pageUrl!!)
                        navGraph.addDestination(activityDestination)
                    }
                }
                navGraph.startDestination = activityDestinationStart.id
                navController.graph = navGraph
                sNavController = navController
            }
        }

        private fun getStartDestination(activityNavigator:ActivityNavigator): ActivityNavigator.Destination {
            val activityDestination = activityNavigator.createDestination()
            activityDestination.id = R.id.bottom_start_activity
            activityDestination.setComponentName(
                ComponentName(Utils.getApp().packageName, "com.chs.lib_core.navigation.EmptyActivity")
            )
            return activityDestination
        }
    }

    fun build(toWhere: String) : Builder{
        val bundle = Bundle()
        return Builder(toWhere,bundle)
    }

    class Builder(private val toWhere: String,private val bundle: Bundle){

        fun withString(key:String,value:String):Builder{
            bundle.putString(key, value)
            return this
        }

        fun withInt(key:String,value:Int):Builder{
            bundle.putInt(key, value)
            return this
        }

        fun withLong(key:String,value:Long):Builder{
            bundle.putLong(key, value)
            return this
        }

        fun withDouble(key:String,value:Double):Builder{
            bundle.putDouble(key, value)
            return this
        }

        fun withBoolean(key:String,value:Boolean):Builder{
            bundle.putBoolean(key, value)
            return this
        }

        fun withByte(key:String,value:Byte):Builder{
            bundle.putByte(key, value)
            return this
        }

        fun withSerializable(key:String,value: Serializable):Builder{
            bundle.putSerializable(key, value)
            return this
        }

        fun withParcelable(key:String,value: Parcelable):Builder{
            bundle.putParcelable(key, value)
            return this
        }

        private fun getItemId(pageUrl: String): Int {
            val destination = NavConfig.getDestinationMap()[pageUrl]
            return destination?.id ?: -1
        }

        fun navigate(){
            sNavController?.navigate(getItemId(toWhere),bundle)
        }
    }
}

class EmptyActivity:AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        finish()
    }
}

@ActivityDestination(pageUrl = WanRouterKey.ACTIVITY_MAIN_MINE_RANK)
class RankActivity : BaseActivity() {}

NavManager.get()
        .build(WanRouterKey.ACTIVITY_MAIN_MINE_RANK)
        .withString("stringparama","stringparama")
        .navigate()