Skip to content

view router & holder

Jump to bottom
muune edited this page Feb 27, 2019 · 3 revisions

ChRouter[목차]

CHHolder[목차]

ChHolderBase[목차]

ChRouter<T>(class)

Ch.router(private val base: ChHolderBase<T>):ChRouter<T>

Ch.router(private val base: ChHolderBase<T>
  • Hoder들의 router처리기
  • [생성자]
val framentBase = Ch.fragmentBase()
val routerf = Ch.router(framentBase)

var groupBase = Ch.groupBase()
val router = Ch.router(groupBase)

restore() : ChRouter

restore()
  • Holder 복원
router.restore()

unlockPush() : ChRouter

unlockPush()
  • pushLock을 false로
  • push 메소드를 사용할 때 isAutoUnlock를 false로 한 경우 unlockPush를 하지 않는 이상 push가 실행되지 않는다.
App.router.unlockPush()

unlockPop() : ChRouter

unlockPop()
  • popLock을 false로
  • pop 메소드를 사용할 때 isAutoUnlock를 false로 한 경우 unlockPop를 하지 않는 이상 pop가 실행되지 않는다.
App.router.unlockPop()

push() : ChRouter

push(holder: ChHolder<T>, isAutoUnlock:Boolean = true)
  • router에 타겟 holder를 push한다(보이게 한다)
  • 타겟 holder를 Resume 시키고, 원래 있던 holder는 pause시킴
  • isAutoUnlock이 false이면 unlockPush를 하지 않는 이상 push가 실행되지 않는다.
object Main : ChHolder<View>(){
    private val main = MainVM
    override fun create(base: ChHolderBase<View>): View{
        if(base !is ChGroupBase) throw Exception("invalid base:$base")
        return Ch.scanner.scan(this, base.inflate(R.layout.main)).render()
    }
}
App.router.push(Main, false)

pop() : ChRouter

pop(isAutoUnlock:Boolean = true):Int
  • router에 holder를 pop함(맨 위에 있는 holder를 사라지게 함)
  • 보여질 holder는 Resume 시킴
  • isAutoUnlock이 false이면 unlockPop를 하지 않는 이상 pop이 실행되지 않는다.
router.pop()

jump() : ChRouter

jump(holder: ChHolder<T>)
  • router에 holder를 jump함(타겟 holder이 보일 때까지 나머지 holder를 사라지게 함(pop함))
router.jump(holder)

ChHolder(abstract class)

  • 뷰를 물고 있는 대상
  • 추상 클래스 : ChHolder<ViewType>을 상속해서 구현한다.
  • 참고 코드 MainHD
object MainHD: ChHolder<View>(){
    private val main = MainVM

    override fun create(base: ChHolderBase<View>): View{
        if(base !is ChGroupBase) throw Exception("invalid base:$base")
        return Ch.scanner.scan(this, base.inflate(R.layout.main)).render()
    }
}
abstract class Scene: ChHolder<View>(){
    private var inflater: LayoutInflater? = null
    private var scan:ChScanned? = null
    override fun create(base: ChHolderBase<View>):View{
        if(base !is ChGroupBase) throw Exception("")
        vmInit()
        if(base.inflater != inflater) {
            inflater = base.inflater
            val view = base.inflate(layout())
            scan?.let{it.view = view} ?: run{scan = Ch.scanner.scan(this, view)}
        }
        return scan!!.render()
    }
    fun render() = scan?.render()
    fun renderSync() = scan?.renderSync()
    fun alert(msg:String) = AppVM.alert(msg, scan!!)
    abstract fun layout():Int
    abstract fun vmInit()
}

create() : ChHolder

abstract fun create(base: ChHolderBase<T>):T
  • ChHolder가 생성될 때 홀더가 해야 할 일을 오버라이드해서 구현[필수]
//MainHD
override fun create(base: ChHolderBase<View>): View{
    if(base !is ChGroupBase) throw Exception("invalid base:$base")
    return Ch.scanner.scan(this, base.inflate(R.layout.main)).render()
}

push() : ChHolder

push(base: ChHolderBase<T>, isRestore:Boolean)
  • 라우터가 push될때 호출된다.
  • push될때 Holder 해야 할 일이 있을 때 함수를 오버라이드해서 내부를 구현한다.
override fun push(base: ChHolderBase<View>, isRestore:Boolean){
   ...
}

resume() : ChHolder

resume(base: ChHolderBase<T>, isRestore:Boolean)
  • 라우터가 resume될때 호출된다.
  • resume될때 Holder 해야 할 일이 있을 때 함수를 오버라이드해서 내부를 구현한다.
override fun resume(base: ChHolderBase<View>, isRestore:Boolean){
   ...
}

pause() : ChHolder

pause(base: ChHolderBase<T>, isJump:Boolean)
  • 라우터가 pause될때 호출된다.
  • pause될때 Holder 해야 할 일이 있을 때 함수를 오버라이드해서 내부를 구현한다.
override fun pause(base: ChHolderBase<View>, isJump: Boolean) {
    ...
}

pop() : ChHolder

pop(base: ChHolderBase<T>, isJump:Boolean):Boolean = true
  • 라우터가 pop될때 호출된다.
  • pop될때 Holder 해야 할 일이 있을 때 함수를 오버라이드해서 내부를 구현한다.
//Step1HD
override fun pop(base: ChHolderBase<View>, isJump: Boolean):Boolean {
    val w = -groupBase.group.width.toDouble()
    looper{
        time = 350
        ended = {base.pop(this@Step1HD)}
        block = {Ch.prop.view.x(view, it.backIn(0.0, w))}
    }
    return false
}

ChHolderBase(abstract class)

  • ViewType에 따라 push와 pop에서 해야 할 일이 다르므로 그 부분을 ChHolderBase를 상속받은 각자의 HolderBase를 만든다.
  • 추상 클래스 : ChHolderBase<ViewType>을 상속해서 구현한다.
  • class ChGroupBase: ChHolderBase<View> : View 타입 HolderBase
  • class ChFragmentBase: ChHolderBase<ChFragmentInfo> : Fragment 타입 HolderBase

ChGroupBase(class)

class ChGroupBase: ChHolderBase<View>(){
    lateinit var inflater:LayoutInflater
    lateinit var group:ViewGroup
    fun group(it:ViewGroup){
        group = it
        inflater = (group.context as AppCompatActivity).layoutInflater
        group.removeAllViews()
        restore()
    }
    fun inflate(id:Int, isMerge:Boolean = false):View = inflater.inflate(id, group, isMerge)
    override fun push(holder: ChHolder<View>){
        group.addView(holder.create(this))
        group.visibility = View.VISIBLE
    }
    override fun pop(holder: ChHolder<View>){
        group.removeViewAt(group.childCount - 1)
        if(group.childCount == 0) group.visibility = View.GONE
    }
}

ChFragmentBase(class)

class ChFragmentBase: ChHolderBase<ChFragmentInfo>(){
    lateinit var manager:FragmentManager
    var container:Int = 0
    override fun push(holder: ChHolder<ChFragmentInfo>) = with(holder.create(this)) {
        val ft = manager.beginTransaction()
        if(transition != 0) ft.setTransition(transition)
        if(style != 0) ft.setTransitionStyle(style)
        when(animation.size){
            2->ft.setCustomAnimations(animation[0], animation[1])
            4->ft.setCustomAnimations(animation[0], animation[1], animation[2], animation[3])
        }
        ft.add(container, fragment, tag)
        ft.addToBackStack(backStack)
        ft.commitAllowingStateLoss()
        manager.executePendingTransactions()
        Unit
    }
    override fun pop(holder: ChHolder<ChFragmentInfo>){
        manager.popBackStackImmediate()
    }
}

restore() : ChHolderBase

restore()
  • 라우터의 restore(복원)함수를 호출한다.
//ChGroupBase
fun group(it:ViewGroup){
    group = it
    inflater = (group.context as AppCompatActivity).layoutInflater
    group.removeAllViews()
    restore()
}

push() : ChHolderBase

push(holder: ChHolder<T>)
  • 라우터가 push될때 호출된다.
  • push될때 HolderBase가 해야 할 일이 있을 때 함수를 오버라이드해서 내부를 구현한다.
//ChGroupBase
override fun push(holder: ChHolder<View>){
    group.addView(holder.create(this))
    group.visibility = View.VISIBLE
}

pop() : ChHolderBase

pop(holder: ChHolder<T>)
  • 라우터가 pop될때 호출된다.
  • pop될 때 HolderBase가 해야 할 일이 있을 때 함수를 오버라이드해서 내부를 구현한다.
//ChGroupBase
override fun pop(holder: ChHolder<View>){
    group.removeViewAt(group.childCount - 1)
    if(group.childCount == 0) group.visibility = View.GONE
}
//ChFragmentBase
override fun pop(holder: ChHolder<ChFragmentInfo>){
    manager.popBackStackImmediate()
}

pause() : ChHolderBase

pause(holder: ChHolder<T>)
  • 라우터가 pause될때 호출된다.
  • pause될때 HolderBase가 해야 할 일이 있을 때 함수를 오버라이드해서 내부를 구현한다.

resume() : ChHolderBase

resume(holder: ChHolder<T>)
  • 라우터가 resume될때 호출된다.
  • resume될때 HolderBase가 해야 할 일이 있을 때 함수를 오버라이드해서 내부를 구현한다.
Clone this wiki locally