Android常用设计模式速查一览表

class appdatabase private constructor() {
    companion object {
        @volatile
        private var instance: appdatabase? = null

        fun getinstance(): appdatabase {
            return instance ?: synchronized(this) {
                instance ?: appdatabase().also { instance = it }
            }
        }
    }
}

class dialog private constructor(
    val title: string?,
    val message: string?,
    val cancelable: boolean
) {
    class builder {
        private var title: string? = null
        private var message: string? = null
        private var cancelable: boolean = true

        fun settitle(value: string) = apply { title = value }
        fun setmessage(value: string) = apply { message = value }
        fun setcancelable(value: boolean) = apply { cancelable = value }

        fun build(): dialog {
            return dialog(title, message, cancelable)
        }
    }
}

interface viewmodelfactory {
    fun <t : viewmodel> create(modelclass: class<t>): t
}

class userviewmodelfactory(
    private val repository: userrepository
) : viewmodelfactory {
    override fun <t : viewmodel> create(modelclass: class<t>): t {
        if (modelclass == userviewmodel::class.java) {
            return userviewmodel(repository) as t
        }
        error("unknown viewmodel")
    }
}

class observabledata<t> {
    private val observers = mutablelistof<(t) -> unit>()
    private var value: t? = null

    fun observe(observer: (t) -> unit) {
        observers += observer
        value?.let(observer)
    }

    fun setvalue(newvalue: t) {
        value = newvalue
        observers.foreach { it(newvalue) }
    }
}

class useradapter(
    private val users: list<user>
) : recyclerview.adapter<userviewholder>() {

    override fun getitemcount(): int {
        return users.size
    }

    override fun oncreateviewholder(parent: viewgroup, viewtype: int): userviewholder {
        return userviewholder(parent.inflate("item_user"))
    }

    override fun onbindviewholder(holder: userviewholder, position: int) {
        holder.bind(users[position])
    }
}

interface iuserservice {
    fun getusername(id: long): string
}

class userserviceproxy(
    private val remotebinder: binder
) : iuserservice {
    override fun getusername(id: long): string {
        val data = parcel.obtain()
        val reply = parcel.obtain()
        data.writelong(id)
        remotebinder.transact(code_get_user, data, reply, 0)
        return reply.readstring()
    }
}

open class basecontext {
    open fun getthemename(): string = "default"
}

open class contextwrapper(
    private val base: basecontext
) : basecontext() {
    override fun getthemename(): string {
        return base.getthemename()
    }
}

class themecontextwrapper(
    base: basecontext,
    private val theme: string
) : contextwrapper(base) {
    override fun getthemename(): string {
        return theme
    }
}

class imageloaderfacade(
    private val cache: imagecache,
    private val network: imagenetwork,
    private val decoder: imagedecoder
) {
    fun load(url: string, imageview: imageview) {
        val bytes = cache.get(url) ?: network.download(url)
        val bitmap = decoder.decode(bytes)
        imageview.setimagebitmap(bitmap)
    }
}

abstract class baseactivity {
    fun performcreate() {
        attachbasecontext()
        oncreate()
        restorestate()
    }

    protected open fun attachbasecontext() {}
    protected abstract fun oncreate()
    protected open fun restorestate() {}
}

class mainactivity : baseactivity() {
    override fun oncreate() {
        setcontentview("activity_main")
    }
}

interface sortstrategy {
    fun sort(items: list<item>): list<item>
}

class timesortstrategy : sortstrategy {
    override fun sort(items: list<item>) = items.sortedby { it.time }
}

class namesortstrategy : sortstrategy {
    override fun sort(items: list<item>) = items.sortedby { it.name }
}

class itemcontroller(
    private var strategy: sortstrategy
) {
    fun render(items: list<item>) {
        show(strategy.sort(items))
    }
}

abstract class eventnode {
    var next: eventnode? = null

    fun dispatch(event: motionevent): boolean {
        if (handle(event)) {
            return true
        }
        return next?.dispatch(event) ?: false
    }

    protected abstract fun handle(event: motionevent): boolean
}

interface playerstate {
    fun play(player: player)
    fun pause(player: player)
}

class idlestate : playerstate {
    override fun play(player: player) {
        player.prepare()
        player.state = playingstate()
    }

    override fun pause(player: player) {
        // idle 状态下无需处理
    }
}

class playingstate : playerstate {
    override fun play(player: player) {}

    override fun pause(player: player) {
        player.pauseinternal()
        player.state = pausedstate()
    }
}

interface command {
    fun execute()
}

class saveusercommand(
    private val repository: userrepository,
    private val user: user
) : command {
    override fun execute() {
        repository.save(user)
    }
}

class commandqueue {
    private val commands = arraydeque<command>()

    fun enqueue(command: command) {
        commands.addlast(command)
    }

    fun runnext() {
        commands.removefirstornull()?.execute()
    }
}

class userviewmodel(
    private val repository: userrepository
) : viewmodel() {
    private val _uistate = mutablestateflow<useruistate>(useruistate.loading)
    val uistate: stateflow<useruistate> = _uistate

    fun loaduser(id: long) {
        viewmodelscope.launch {
            _uistate.value = useruistate.loading
            _uistate.value = runcatching {
                repository.getuser(id)
            }.fold(
                onsuccess = { useruistate.content(it) },
                onfailure = { useruistate.error(it.message.orempty()) }
            )
        }
    }
}

class userfragment : fragment() {
    private val viewmodel: userviewmodel by viewmodels()

    fun render() {
        collect(viewmodel.uistate) { state ->
            when (state) {
                is useruistate.loading -> showloading()
                is useruistate.content -> showuser(state.user)
                is useruistate.error -> showerror(state.message)
            }
        }
    }
}

abstract class uinode {
    abstract fun draw()
}

class textnode : uinode() {
    override fun draw() {
        drawtext()
    }
}

class containernode : uinode() {
    private val children = mutablelistof<uinode>()

    fun add(child: uinode) {
        children += child
    }

    override fun draw() {
        children.foreach { it.draw() }
    }
}

class bitmappool {
    private val cache = mutablemapof<string, bitmap>()

    fun get(key: string, loader: () -> bitmap): bitmap {
        return cache[key] ?: loader().also { bitmap ->
            cache[key] = bitmap
        }
    }
}