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
        }
    }
}