Github Repos Search - Kotlin Multiplatform Mobile using Jetpack Compose, SwiftUI, FlowRedux, Coroutines Flow, Dagger Hilt, Koin Dependency Injection, shared KMP ViewModel, Clean Architecture

Minimal Kotlin Multiplatform project with SwiftUI, Jetpack Compose.

• Android (Jetpack compose)
• iOS (SwiftUI)

Liked some of my work? Buy me a coffee (or more likely a beer)

• Kotlin Multiplatform
• Jetpack Compose
• Kotlin Coroutines & Flows
• Dagger Hilt
• SwiftUI
• Koin Dependency Injection
• FlowRedux State Management
• Shared KMP ViewModel
• Clean Architecture

• Functional & Reactive programming with Kotlin Coroutines with Flow
• Clean Architecture with MVI (Uni-directional data flow)
• Multiplatform ViewModel
• Multiplatform FlowRedux State Management
• Λrrow - Functional companion to Kotlin's Standard Library
  • Either
  • Monad Comprehensions
  • Option
  • parZip
• Dependency injection
  • iOS: Koin
  • Android: Dagger Hilt
• Declarative UI
  • iOS: SwiftUI
  • Android: Jetpack Compose
• Ktor client library for networking
• Kotlinx Serialization for JSON serialization/deserialization.
• Napier for Multiplatform Logging.
• FlowExt.
• MOKO KSwift is a gradle plugin for generation Swift-friendly API for Kotlin/Native framework.
• kotlinx.collections.immutable: immutable collection interfaces and implementation prototypes for Kotlin..

• domain: Domain models, UseCases, Repositories.
• presentation: ViewModels, ViewState, ViewSingleEvent, ViewAction.
• data: Repository Implementations, Remote Data Source, Local Data Source.
• utils: Utilities, Logging Library

• My implementation. Credits: freeletics/FlowRedux
• See more docs and concepts at freeletics/RxRedux

public sealed interface FlowReduxStore<Action, State> {
  public val coroutineScope: CoroutineScope

  public val stateFlow: StateFlow<State>

  /** Get streams of actions.
   *
   * This [Flow] includes dispatched [Action]s (via [dispatch] function)
   * and [Action]s returned from [SideEffect]s.
   */
  public val actionSharedFlow: SharedFlow<Action>

  /**
   * @return false if cannot dispatch action ([coroutineScope] was cancelled).
   */
  public fun dispatch(action: Action): Boolean
}

open class GithubSearchViewModel(
  searchRepoItemsUseCase: SearchRepoItemsUseCase,
) : ViewModel() {
  private val store = viewModelScope.createFlowReduxStore(
    initialState = GithubSearchState.initial(),
    sideEffects = GithubSearchSideEffects(
      searchRepoItemsUseCase = searchRepoItemsUseCase,
    ).sideEffects,
    reducer = { state, action -> action.reduce(state) }
  )
  private val eventChannel = store.actionSharedFlow
    .mapNotNull { it.toGithubSearchSingleEventOrNull() }
    .buffer(Channel.UNLIMITED)
    .produceIn(viewModelScope)

  fun dispatch(action: GithubSearchAction) = store.dispatch(action)
  val stateFlow: StateFlow<GithubSearchState> by store::stateFlow
  val eventFlow: Flow<GithubSearchSingleEvent> get() = eventChannel.receiveAsFlow()
}

Extends GithubSearchViewModel to use Dagger Constructor Injection.

@HiltViewModel
class DaggerGithubSearchViewModel @Inject constructor(searchRepoItemsUseCase: SearchRepoItemsUseCase) :
  GithubSearchViewModel(searchRepoItemsUseCase)

Conform to ObservableObject and use @Published property wrapper.

import Foundation
import Combine
import shared
import sharedSwift

@MainActor
class IOSGithubSearchViewModel: ObservableObject {
  private let vm: GithubSearchViewModel

  @Published private(set) var state: GithubSearchState
  let eventPublisher: AnyPublisher<GithubSearchSingleEventKs, Never>

  init(vm: GithubSearchViewModel) {
    self.vm = vm

    self.eventPublisher = vm.eventFlow.asNonNullPublisher()
      .assertNoFailure()
      .map(GithubSearchSingleEventKs.init)
      .eraseToAnyPublisher()

    self.state = vm.stateFlow.typedValue()
    vm.stateFlow.subscribeNonNullFlow(
      scope: vm.viewModelScope,
      onValue: { [weak self] in self?.state = $0 }
    )
  }

  @discardableResult
  func dispatch(action: GithubSearchAction) -> Bool {
    self.vm.dispatch(action: action)
  }

  deinit {
    Napier.d("\(self)::deinit")
    vm.clear()
  }
}

• Download latest debug APK here

• Android Studio Chipmunk | 2021.2.1 (note: Java 11 is now the minimum version required).

• XCode 13.2 or later (due to use of new Swift 5.5 concurrency APIs).

• Clone project: git clone https://github.com/hoc081098/GithubSearchKMM.git

• Android: open project by Android Studio and run as usual.

• iOS

  cd GithubSearchKMM
  
  # generate podspec files for cocopods intergration. with integration will be generated swift files for cocoapod
  ./gradlew kSwiftsharedPodspec
  
  # go to ios dir
  cd iosApp
  
  # install pods
  pod install
  
  # now we can open xcworkspace and build ios project
  # or open via XCode GUI
  open iosApp.xcworkspace

  There's a Build Phase script that will do the magic. 🧞
  Cmd + B to build
  Cmd + R to run.

--------------------------------------------------------------------------------
 Language             Files        Lines        Blank      Comment         Code
--------------------------------------------------------------------------------
 Kotlin                  78         4422          496          373         3553
 Swift                   16          861          110           98          653
 Markdown                 1          219           43            0          176
 JSON                     5          133            0            0          133
 Bourne Shell             1          240           28          110          102
 Batch                    1           91           21            0           70
 XML                      7           73            6            0           67
--------------------------------------------------------------------------------
 Total                  109         6039          704          581         4754
--------------------------------------------------------------------------------