### Mocking Dependencies in Android Tests (Kotlin)

Source: https://github.com/line/lich/blob/master/component/README.md

Provides an example of how to mock dependencies for testing a class using default arguments and Lich's `mockComponent` utility. This setup involves using `Mockito` for mocking and `AndroidJUnit4` for running the tests within an Android environment. Ensure mock components are created before the class under test is instantiated.

```kotlin
@RunWith(AndroidJUnit4::class)
class FooControllerTest {

    private lateinit var context: Context

    private lateinit var mockBarHelper: BarHelper

    private lateinit var mockBazComponent: BazComponent

    private lateinit var fooController: FooController

    @Before
    fun setUp() {
        context = ApplicationProvider.getApplicationContext()

        mockBarHelper = mock()
        mockBazComponent = mockComponent(BazComponent)

        fooController = FooController(context, mockBarHelper)
    }

    @Test
    fun testFoo() {
        // ...
    }
}
```

--------------------------------

### Mockito-Kotlin Unit Testing Setup - Groovy

Source: https://github.com/line/lich/blob/master/component/README.md

Sets up dependencies for unit testing with Mockito-Kotlin in an Android project, including Robolectric and AndroidX Test.

```Groovy
dependencies {
    testImplementation 'com.linecorp.lich:component-test-mockitokotlin:x.x.x'
    testImplementation 'androidx.test:runner:x.x.x'
    testImplementation 'androidx.test.ext:junit:x.x.x'
    testImplementation 'org.mockito:mockito-inline:x.x.x'
    testImplementation 'org.mockito.kotlin:mockito-kotlin:x.x.x'
    testImplementation 'org.robolectric:robolectric:x.x'

    androidTestImplementation 'com.linecorp.lich:component-test-mockitokotlin:x.x.x'
    androidTestImplementation 'androidx.test:runner:x.x.x'
    androidTestImplementation 'androidx.test.ext:junit:x.x.x'
    androidTestImplementation 'org.mockito:mockito-android:x.x.x'
    androidTestImplementation 'org.mockito.kotlin:mockito-kotlin:x.x.x'
}
```

--------------------------------

### MockK Unit Testing Setup - Groovy

Source: https://github.com/line/lich/blob/master/component/README.md

Configures dependencies for unit testing with MockK in an Android project, including Robolectric and AndroidX Test support.

```Groovy
dependencies {
    testImplementation 'com.linecorp.lich:component-test-mockk:x.x.x'
    testImplementation 'androidx.test:runner:x.x.x'
    testImplementation 'androidx.test.ext:junit:x.x.x'
    testImplementation 'io.mockk:mockk:x.x.x'
    testImplementation 'org.robolectric:robolectric:x.x'

    androidTestImplementation 'com.linecorp.lich:component-test-mockk:x.x.x'
    androidTestImplementation 'androidx.test:runner:x.x.x'
    androidTestImplementation 'androidx.test.ext:junit:x.x.x'
    androidTestImplementation 'io.mockk:mockk-android:x.x.x'
}
```

--------------------------------

### Testing with MockK and Lich Components (Kotlin)

Source: https://github.com/line/lich/blob/master/component/README.md

Provides an example of testing a use case (`SaveFooUseCase`) by mocking its dependencies (`FooRepository`) using MockK and the `mockComponent` function from Lich. This allows for controlled testing of business logic.

```kotlin
@RunWith(AndroidJUnit4::class)
class SaveFooUseCaseTest {

    private lateinit var context: Context

    @Before
    fun setUp() {
        context = ApplicationProvider.getApplicationContext()
    }

    @Test
    fun testGetFooFromStorage() {
        val expected = Foo()
        val mockFooRepository = mockComponent(FooRepository) {
            coEvery { findFoo(any()) } returns expected
        }
        val saveFooUseCase = SaveFooUseCase(context)

        val actual = runBlocking { saveFooUseCase.getFooFromStorage("key") }

        assertEquals(expected, actual)
        coVerify { mockFooRepository.findFoo(eq("key")) }
    }
}
```

--------------------------------

### Define a Facade interface for multi-module support

Source: https://github.com/line/lich/blob/master/component/README.md

Example of defining a Facade interface (`FooModuleFacade`) in the 'base' module to expose functionality from the 'foo' module. This adheres to the Facade pattern for inter-module communication.

```kotlin
// "base" module
package module.base.facades

/**
 * The Facade of the "foo" module.
 * https://en.wikipedia.org/wiki/Facade_pattern
 *
 * This component defines the API of the "foo" module.
 */
interface FooModuleFacade {

    fun launchFooActivity()

    companion object : ComponentFactory<FooModuleFacade>() {
        override fun createComponent(context: Context): FooModuleFacade = 
            TODO()
    }
}
```

--------------------------------

### Lazy Lich Component initialization in Activity

Source: https://github.com/line/lich/blob/master/component/README.md

Example of using lazy Lich component initialization within an Android Activity. The `component` delegate simplifies accessing component instances tied to the Activity's lifecycle.

```kotlin
class FooActivity : Activity() {

    private val fooComponent by component(FooComponent)

    // snip...
}
```

--------------------------------

### Gradle Dependencies for Lich ViewModel with Mockito-Kotlin

Source: https://github.com/line/lich/blob/master/viewmodel/README.md

This snippet outlines the Gradle dependencies for integrating Lich ViewModel with a testing setup that utilizes Mockito-Kotlin. It covers the core library, Compose support, and the necessary testing libraries for Mockito-Kotlin.

```groovy
dependencies {
    implementation 'com.linecorp.lich:viewmodel:x.x.x'
    // For Jetpack Compose
    implementation 'com.linecorp.lich:viewmodel-compose:x.x.x'

    testImplementation 'com.linecorp.lich:viewmodel-test-mockitokotlin:x.x.x'
    testImplementation 'androidx.test:runner:x.x.x'
    testImplementation 'androidx.test.ext:junit:x.x.x'
    testImplementation 'org.mockito:mockito-inline:x.x.x'
    testImplementation 'org.mockito.kotlin:mockito-kotlin:x.x.x'
    testImplementation 'org.robolectric:robolectric:x.x'

    androidTestImplementation 'com.linecorp.lich:viewmodel-test-mockitokotlin:x.x.x'
    androidTestImplementation 'androidx.test:runner:x.x.x'
    androidTestImplementation 'androidx.test.ext:junit:x.x.x'
    androidTestImplementation 'org.mockito:mockito-android:x.x.x'
    androidTestImplementation 'org.mockito.kotlin:mockito-kotlin:x.x.x'
}
```

--------------------------------

### Execute GET request with OkHttp coroutine extension in Kotlin

Source: https://context7.com/line/lich/llms.txt

Provides a suspending function fetchContent that performs a simple GET request using OkHttp. It automatically checks for successful responses and returns the response body as a string. Throws IOException on HTTP errors.

```Kotlin
suspend fun fetchContent(url: String): String {\n    val request = Request.Builder().url(url).build()\n\n    return okHttpClient.call(request) { response ->\n        if (!response.isSuccessful) {\n            throw IOException("HTTP ${response.code}: ${response.message}")\n        }\n        checkNotNull(response.body).string()\n    }\n}
```

--------------------------------

### Declare a Room Database as a Lich Component

Source: https://github.com/line/lich/blob/master/component/README.md

Example of declaring a Room database as a Lich component. It uses `Room.databaseBuilder` within the `createComponent` method of the companion object.

```kotlin
@Database(entities = [Foo::class], version = 1)
abstract class FooDatabase : RoomDatabase() {

    abstract val fooDao: FooDao

    companion object : ComponentFactory<FooDatabase>() {
        override fun createComponent(context: Context): FooDatabase = 
            Room.databaseBuilder(context, FooDatabase::class.java, "foo_db").build()
    }
}
```

--------------------------------

### Implement GlobalContext for Global Component Access in Kotlin

Source: https://github.com/line/lich/blob/master/component/README.md

Provides a solution to access components globally without explicitly passing a Context every time. It requires initial setup with the Application context and offers methods for both eager and lazy component retrieval.

```kotlin
object GlobalContext {
    private lateinit var application: Application

    fun setup(application: Application) {
        this.application = application
    }

    fun <T : Any> getComponent(factory: ComponentFactory<T>): T = 
        application.getComponent(factory)

    fun <T : Any> component(factory: ComponentFactory<T>): Lazy<T> = 
        componentLazy(factory) { application }
}

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate() 
        GlobalContext.setup(this)
    }
}
```

--------------------------------

### Initialize Fragment ViewModel with SavedState using setViewModelArgs

Source: https://github.com/line/lich/blob/master/viewmodel/README.md

Provides an example of initializing a Fragment's ViewModel using Lich SavedState arguments. This method directly uses `setViewModelArgs` on the Fragment instance to configure the `SavedStateHandle` for the ViewModel before it's accessed.

```kotlin
class FooFragment : Fragment() {

    private val fooViewModel by viewModel(FooViewModel)

    // snip...
}

val fooFragment = FooFragment().also {
    // This `FooViewModelArgs` is used to initialize the `savedStateHandle` of `FooFragment.fooViewModel`.
    it.setViewModelArgs(FooViewModelArgs(userName = "John", attachment = null, message = "Hello."))
}
```

--------------------------------

### Fetch Content as String using OkHttp

Source: https://github.com/line/lich/blob/master/okhttp/README.md

A suspending function to fetch the content of a given URL as a String. It uses OkHttp's call extension to send a GET request and handles successful responses by returning the body as a string. It throws a ResponseStatusException for non-successful HTTP codes.

```kotlin
suspend fun fetchContentAsString(url: String): String {
    val request = Request.Builder().url(url).build()
    return okHttpClient.call(request) { response ->
        if (!response.isSuccessful) {
            throw ResponseStatusException(response.code)
        }
        checkNotNull(response.body).string()
    }
}
```

--------------------------------

### Get Fragment ViewModel instance with Kotlin

Source: https://github.com/line/lich/blob/master/viewmodel/README.md

Gets a ViewModel instance associated with a Fragment using the viewModel delegate. The ViewModel lifecycle is tied to the Fragment's lifecycle. Works with AndroidX Fragment class.

```kotlin
class FooFragment : Fragment() {

    // An instance of FooViewModel associated with FooFragment.
    private val fooViewModel by viewModel(FooViewModel)

    // snip...
}
```

--------------------------------

### Set up Lich SavedState with kapt

Source: https://github.com/line/lich/blob/master/savedstate/README.md

Alternative configuration using kapt instead of KSP. Includes necessary plugin and dependency declarations for Kotlin annotation processing.

```groovy
plugins {
    id 'org.jetbrains.kotlin.kapt'
}

dependencies {
    implementation 'com.linecorp.lich:savedstate:x.x.x'
    kapt 'com.linecorp.lich:savedstate-compiler:x.x.x'
}
```

--------------------------------

### Create Multi-Module Component with delegateCreation (Kotlin)

Source: https://context7.com/line/lich/llms.txt

Demonstrates how to create a component that spans multiple modules using named factory classes and delegateCreation. It includes the repository interface, the factory implementation, and usage within a ViewModel. This approach facilitates cross-module component resolution.

```kotlin
// In base module
interface CounterRepository {
    suspend fun getCounter(counterName: String): Int
    suspend fun storeCounter(counterName: String, value: Int)

    companion object : ComponentFactory<CounterRepository>() {
        override fun createComponent(context: Context): CounterRepository = 
            delegateCreation(context, "com.example.impl.CounterRepositoryFactory")
    }
}

// In implementation module
class CounterRepositoryFactory : DelegatedComponentFactory<CounterRepository>() {
    override fun createComponent(context: Context): CounterRepository = 
        CounterRepositoryImpl(context)
}

private class CounterRepositoryImpl(
    private val context: Context
) : CounterRepository {
    private val preferences = context.getSharedPreferences("counters", Context.MODE_PRIVATE)

    override suspend fun getCounter(counterName: String): Int = 
        withContext(Dispatchers.IO) {
            preferences.getInt(counterName, 0)
        }

    override suspend fun storeCounter(counterName: String, value: Int) {
        withContext(Dispatchers.IO) {
            preferences.edit().putInt(counterName, value).apply()
        }
    }
}

// Usage
class CounterViewModel(context: Context) : ViewModel() {
    private val counterRepository by context.component(CounterRepository)

    suspend fun incrementCounter(name: String) {
        val current = counterRepository.getCounter(name)
        counterRepository.storeCounter(name, current + 1)
    }
}
```

--------------------------------

### Test Components with MockK (Kotlin)

Source: https://context7.com/line/lich/llms.txt

Shows how to unit test components using MockK with the Lich component-test-mockk module. It covers mocking and spying on components to isolate dependencies and verify interactions. This enables testing component logic without relying on actual implementations.

```kotlin
import com.linecorp.lich.component.test.mockk.mockComponent
import com.linecorp.lich.component.test.mockk.spyComponent
import io.mockk.coEvery
import io.mockk.coVerify

@RunWith(AndroidJUnit4::class)
class FooViewModelTest {
    @Test
    fun testLoadData() = runTest {
        // Mock a component
        val mockRepository = mockComponent(FooRepository) {
            coEvery { fetchData(any()) } returns FooData("test", 123)
        }

        val viewModel = FooViewModel(ApplicationProvider.getApplicationContext())
        viewModel.loadData("foo")

        coVerify { mockRepository.fetchData("foo") }
        assertEquals("test", viewModel.data.value?.name)
    }

    @Test
    fun testWithSpy() = runTest {
        // Spy on real component with partial mocking
        val spyRepository = spyComponent(FooRepository) {
            coEvery { fetchData("error") } throws IOException("Network error")
        }

        val viewModel = FooViewModel(ApplicationProvider.getApplicationContext())

        // Normal call goes to real implementation
        viewModel.loadData("normal")
        assertNotNull(viewModel.data.value)

        // Mocked call throws exception
        assertFailsWith<IOException> {
            viewModel.loadData("error")
        }
    }
}
```

--------------------------------

### Delegate Component Creation using ServiceLoader and AutoService (Kotlin)

Source: https://github.com/line/lich/blob/master/component/README.md

Delegates component creation to ServiceLoader, recommended with the AutoService library. Requires adding AutoService dependencies to build.gradle and annotating the implementation class with @AutoService. The implementation class must have a public empty constructor and optionally implement ServiceLoaderComponent for context initialization.

```groovy
apply plugin: 'kotlin-kapt'

dependencies {
    compileOnly 'com.google.auto.service:auto-service-annotations:x.x'
    kapt 'com.google.auto.service:auto-service:x.x'
}
```

```kotlin
// "base" module
package module.base.facades

interface FooModuleFacade {

    fun launchFooActivity()

    companion object : ComponentFactory<FooModuleFacade>() {
        override fun createComponent(context: Context): FooModuleFacade = 
            delegateToServiceLoader(context)
    }
}
```

```kotlin
// "foo" module
package module.foo

// Declare this class as an implementation of `FooModuleFacade`.
@AutoService(FooModuleFacade::class)
class FooModuleFacadeImpl : FooModuleFacade, ServiceLoaderComponent {

    private lateinit var context: Context

    // The class instantiated by `delegateToServiceLoader` must have a public empty constructor.
    // If the class requires a `context`, implement the `ServiceLoaderComponent` interface and
    // override the `init(context)` function.
    override fun init(context: Context) {
        this.context = context
    }

    override fun launchFooActivity() {
        // snip...
    }
}
```

--------------------------------

### Get Activity ViewModel instance with Kotlin

Source: https://github.com/line/lich/blob/master/viewmodel/README.md

Obtains a ViewModel instance associated with an Activity using the viewModel delegate. This creates a scoped ViewModel that lives as long as the Activity. Requires AppCompatActivity from AndroidX.

```kotlin
class FooActivity : AppCompatActivity() {

    // An instance of FooViewModel associated with FooActivity.
    private val fooViewModel by viewModel(FooViewModel)

    // snip...
}
```

--------------------------------

### Set up Lich SavedState with KSP

Source: https://github.com/line/lich/blob/master/savedstate/README.md

Configure your project to use Lich SavedState with KSP. Requires adding KSP plugin and dependencies for implementation and compilation.

```groovy
plugins {
    id 'com.google.devtools.ksp' version 'x.x.x-x.x.x'
}

dependencies {
    implementation 'com.linecorp.lich:savedstate:x.x.x'
    ksp 'com.linecorp.lich:savedstate-compiler:x.x.x'
}
```

--------------------------------

### Access Components using GlobalContext in Kotlin

Source: https://github.com/line/lich/blob/master/component/README.md

Shows how to retrieve components using the previously defined GlobalContext object. It illustrates both eager instantiation and lazy initialization of components, simplifying access patterns.

```kotlin
val eagerFooComponent: FooComponent = GlobalContext.getComponent(FooComponent)

val lazyFooComponent: FooComponent by GlobalContext.component(FooComponent)
```

--------------------------------

### Lazy Lich Component initialization in Fragment

Source: https://github.com/line/lich/blob/master/component/README.md

Demonstrates lazy Lich component initialization within an Android Fragment using the `component` delegate. This pattern is consistent with its usage in Activities.

```kotlin
class FooFragment : Fragment() {

    private val fooComponent by component(FooComponent)

    // snip...
}
```

--------------------------------

### Implement FooServiceClient using AbstractThriftServiceClient

Source: https://github.com/line/lich/blob/master/thrift/README.md

This Kotlin code demonstrates how to implement a Thrift service client by extending AbstractThriftServiceClient. It configures the client with OkHttp and an endpoint URL, and defines methods for making RPC calls like `ping` and `callFoo`.

```kotlin
class FooServiceClient(
    override val okHttpClient: OkHttpClient,
    override val endpointUrl: HttpUrl
) : AbstractThriftServiceClient<FooService.Client>() {

    override val thriftClientFactory: ThriftClientFactory<FooService.Client> = 
        ThriftClientFactory(FooService.Client.Factory())

    suspend fun ping() = 
        call({ send_ping() }, { recv_ping() })

    suspend fun callFoo(id: Long, name: String, param: FooParam): FooResponse = 
        call({ send_callFoo(id, name, param) }, { recv_callFoo() })
}

val fooServiceClient = FooServiceClient(OkHttpClient(), "https://api.example.com/foo".toHttpUrl())

try {
    val response = fooServiceClient.callFoo(123, "foobar", FooParam(4))
    println("response = $response")
} catch (e: TException) {
    println("fooService.callFoo() failed: $e")
}
```

--------------------------------

### Get Activity-shared ViewModel in Fragment with Kotlin

Source: https://github.com/line/lich/blob/master/viewmodel/README.md

Retrieves a ViewModel associated with the hosting Activity using activityViewModel delegate. Enables data sharing between Fragments and their parent Activity. The ViewModel persists across Fragment recreations but is scoped to the Activity.

```kotlin
class FooFragment : Fragment() {

    // A shared instance of FooViewModel associated with the Activity hosting this FooFragment.
    private val fooActivityViewModel by activityViewModel(FooViewModel)

    // snip...
}
```

--------------------------------

### Gradle Dependencies for Lich ViewModel with MockK

Source: https://github.com/line/lich/blob/master/viewmodel/README.md

This snippet shows the Gradle dependencies required to set up the Lich ViewModel library and its associated testing tools using MockK for mocking. It includes dependencies for the core library, Jetpack Compose integration, and various testing utilities.

```groovy
dependencies {
    implementation 'com.linecorp.lich:viewmodel:x.x.x'
    // For Jetpack Compose
    implementation 'com.linecorp.lich:viewmodel-compose:x.x.x'

    testImplementation 'com.linecorp.lich:viewmodel-test-mockk:x.x.x'
    testImplementation 'androidx.test:runner:x.x.x'
    testImplementation 'androidx.test.ext:junit:x.x.x'
    testImplementation 'io.mockk:mockk:x.x.x'
    testImplementation 'org.robolectric:robolectric:x.x'

    androidTestImplementation 'com.linecorp.lich:viewmodel-test-mockk:x.x.x'
    androidTestImplementation 'androidx.test:runner:x.x.x'
    androidTestImplementation 'androidx.test.ext:junit:x.x.x'
    androidTestImplementation 'io.mockk:mockk-android:x.x.x'
}
```

--------------------------------

### Accessing a multi-module Facade component

Source: https://github.com/line/lich/blob/master/component/README.md

Demonstrates how to obtain and use a Lich component that acts as a Facade to another module. This involves using `context.getComponent` with the Facade interface.

```kotlin
// Call some feature of the "foo" module.
val fooModuleFacade = context.getComponent(FooModuleFacade)
fooModuleFacade.launchFooActivity()
```

--------------------------------

### Initialize ViewModel using SavedStateViewModelFactory (Kotlin)

Source: https://github.com/line/lich/blob/master/savedstate/README.md

This snippet shows an alternative way to initialize a ViewModel using the `SavedStateViewModelFactory`. It passes the generated ViewModelArgs as a Bundle to the factory, which then sets up the SavedStateHandle.

```kotlin
class FooFragment : Fragment() {

    private val fooViewModel: FooViewModel by viewModels {
        SavedStateViewModelFactory(
            requireActivity().application,
            this,
            FooViewModelArgs(userName = "John", attachment = null, message = "Hello.").toBundle()
        )
    }

    // snip...
}
```

--------------------------------

### Get Navigation Graph ViewModel in Fragment with Kotlin

Source: https://github.com/line/lich/blob/master/viewmodel/README.md

Obtains a ViewModel scoped to a specific navigation graph using navGraphViewModel delegate. Requires AndroidX Navigation library. The ViewModel is shared among all destinations in the specified navigation graph and survives configuration changes.

```kotlin
class FooFragment : Fragment() {

    // A shared instance of FooViewModel scoped to the `foo_nav_graph` navigation graph.
    private val fooNavGraphViewModel by navGraphViewModel(FooViewModel, R.id.foo_nav_graph)

    // snip...
}
```

--------------------------------

### Multi-Module Component with ServiceLoader in Kotlin

Source: https://context7.com/line/lich/llms.txt

Shows how to implement multi-module components using ServiceLoader and AutoService annotation. Defines a facade interface in the base module and implements it in a feature module. Enables components to work across Dynamic Feature Modules with proper initialization and service loading.

```kotlin
interface FooModuleFacade {
    fun launchFooActivity(context: Context)
    fun getFooData(): String

    companion object : ComponentFactory<FooModuleFacade>() {
        override fun createComponent(context: Context): FooModuleFacade =
            delegateToServiceLoader(context)
    }
}

@AutoService(FooModuleFacade::class)
class FooModuleFacadeImpl : FooModuleFacade, ServiceLoaderComponent {
    private lateinit var context: Context

    override fun init(context: Context) {
        this.context = context
    }

    override fun launchFooActivity(context: Context) {
        context.startActivity(Intent(context, FooActivity::class.java))
    }

    override fun getFooData(): String = "Foo Data"
}

class MainActivity : AppCompatActivity() {
    private val fooModuleFacade by component(FooModuleFacade)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        findViewById<Button>(R.id.launchButton).setOnClickListener {
            fooModuleFacade.launchFooActivity(this)
        }

        val data = fooModuleFacade.getFooData()
        Toast.makeText(this, data, Toast.LENGTH_SHORT).show()
    }
}
```

--------------------------------

### Mocking Components with Lich (Kotlin)

Source: https://github.com/line/lich/blob/master/component/README.md

Demonstrates how to mock Lich components using the `setMockComponent` function, which is useful for testing individual components in isolation. This approach ensures that dependencies are controlled during tests.

```kotlin
setMockComponent(FooComponent, createMockFoo())
```

--------------------------------

### Scoped ViewModels for Fragment, Activity, and Navigation Sharing in Kotlin

Source: https://context7.com/line/lich/llms.txt

Demonstrates ViewModel scoping options: fragment-specific, activity-shared for cross-fragment data, and navigation graph-scoped for flow management. Uses delegates like viewModel(), activityViewModel(), and navGraphViewModel() for lifecycle-aware access. Depends on Context and SavedStateHandle; inputs trigger data updates via observables. Outputs share state across components. Limitations: Scoping requires proper navigation setup.

```kotlin
// Fragment-scoped ViewModel
class FooFragment : Fragment() {
    // Scoped to this fragment only
    private val fragmentViewModel by viewModel(FooViewModel)

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        fragmentViewModel.loadData()
    }
}

// Activity-scoped ViewModel shared between fragments
class SharedViewModel(
    context: Context,
    savedStateHandle: SavedStateHandle
) : AbstractViewModel() {
    val selectedItem: MutableLiveData<String?> = MutableLiveData(null)

    companion object : ViewModelFactory<SharedViewModel>() {
        override fun createViewModel(
            context: Context,
            savedStateHandle: SavedStateHandle
        ): SharedViewModel = SharedViewModel(context, savedStateHandle)
    }
}

class ListFragment : Fragment() {
    // Shared with host activity
    private val sharedViewModel by activityViewModel(SharedViewModel)

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        recyclerView.adapter = ItemAdapter { item ->
            sharedViewModel.selectedItem.value = item
            findNavController().navigate(R.id.action_list_to_detail)
        }
    }
}

class DetailFragment : Fragment() {
    // Same shared instance
    private val sharedViewModel by activityViewModel(SharedViewModel)

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        sharedViewModel.selectedItem.observe(viewLifecycleOwner) { item ->
            textView.text = "Selected: $item"
        }
    }
}

// Navigation graph scoped ViewModel
class NestedFlowFragment : Fragment() {
    // Scoped to specific navigation graph
    private val navGraphViewModel by navGraphViewModel(
        FlowViewModel,
        R.id.nested_nav_graph
    )

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        navGraphViewModel.loadFlowData()
    }
}
```

--------------------------------

### Download with Progress Monitoring in Kotlin

Source: https://github.com/line/lich/blob/master/okhttp/README.md

Downloads content from a given URL to a specified file while monitoring the download progress. It handles different download states (Downloading, Success, Failure) and prints relevant information to the console. Requires OkHttpClient and associated extensions.

```kotlin
suspend fun performDownloadWithProgress(url: HttpUrl, fileToSave: File) {
    val request = Request.Builder().url(url).build()
    okHttpClient.callWithCounting(request) { response ->
        if (response.code != StatusCode.OK) {
            throw ResponseStatusException(response.code)
        }
        response.saveBodyToFileAtomically(fileToSave)
    }.collect { state ->
        when (state) {
            is Uploading -> Unit
            is Downloading ->
                println("Downloading: ${state.bytesTransferred} bytes received." +
                    state.progressPercentage?.let { " ($it%)" }.orEmpty())
            is Success ->
                println("The download is complete. TotalLength=${state.bytesDownloaded}")
            is Failure ->
                println("Failure: ${state.exception}")
        }
    }
}
```

--------------------------------

### Mock ViewModel with Mockito-Kotlin for Android Tests

Source: https://github.com/line/lich/blob/master/viewmodel/README.md

Illustrates how to mock a ViewModel using Mockito-Kotlin in Android instrumented tests. It covers setting up mock data and verifying method calls on the mocked ViewModel. This method is an alternative to MockK and relies on the mockito-kotlin library.

```kotlin
@RunWith(AndroidJUnit4::class)
class BarActivityTest {

    @After
    fun tearDown() {
        // You can omit this in Robolectric tests.
        // All ViewModel mocks are automatically cleared for every Robolectric test.
        clearAllMockViewModels()
    }

    @Test
    fun testViewBinding() {
        val mockBarText = MutableLiveData("Mocked.")
        // Set mock ViewModel for `BarViewModel`.
        val mockViewModelHandle = mockViewModel(BarViewModel) {
            on { barText } doReturn mockBarText
        }

        ActivityScenario.launch(BarActivity::class.java).use { scenario ->

            scenario.onActivity {
                assertTrue(mockViewModelHandle.isCreated)
            }

            onView(withId(R.id.bar_text)).check(matches(withText("Mocked.")))

            onView(withId(R.id.load_bar_button)).perform(click())

            scenario.onActivity {
                verify(mockViewModelHandle.mock, times(1)).loadBarText()
            }
        }
    }
}
```

--------------------------------

### Configure and Enable Thrift Logging

Source: https://github.com/line/lich/blob/master/thrift/README.md

This Kotlin code illustrates how to set up and enable transparent logging for Thrift clients using `thrift-logging`. It defines a custom `ThriftLogger` implementation to log send and receive events and integrates it into the `FooServiceClient`.

```kotlin
val thriftLogger = object : ThriftLogger {
    override fun logSend(namespace: String, service: String, function: String, args: TBase<*, *>)
        Log.d("ThriftLogger", "$service.send_$function: $args")
    }

    override fun logReceive(namespace: String, service: String, function: String, result: TBase<*, *>)
        Log.d("ThriftLogger", "$service.recv_$function: $result")
    }
}
val thriftLogEnabler = ThriftLogEnabler(context, thriftLogger)

class FooServiceClient : AbstractThriftServiceClient<FooService.Client>() {

    override val thriftClientFactory: ThriftClientFactory<FooService.Client> = 
        thriftLogEnabler.enableLogging(ThriftClientFactory(FooService.Client.Factory()))

    // snip...
}
```

--------------------------------

### OkHttp Download with Progress Tracking in Kotlin

Source: https://context7.com/line/lich/llms.txt

Downloads a file from a URL and provides progress updates via a callback. It uses OkHttp's `callWithCounting` for tracking transferred bytes and supports atomic saving. It returns a `Result` indicating success with the downloaded file or failure with an exception.

```kotlin
class DownloadManager(private val okHttpClient: OkHttpClient) {

    // ... other methods

    // Download with progress tracking
    suspend fun downloadWithProgress(
        url: String,
        targetFile: File,
        onProgress: (bytesDownloaded: Long, totalBytes: Long?) -> Unit
    ): Result<File> {
        val request = Request.Builder().url(url).build()

        return try {
            okHttpClient.callWithCounting(request, countUpload = false) { response ->
                if (!response.isSuccessful) {
                    throw IOException("HTTP ${response.code}")
                }
                response.saveBodyToFileAtomically(targetFile)
            }.collect { state ->
                when (state) {
                    is Downloading -> {
                        onProgress(state.bytesTransferred, state.contentLength)
                    }
                    is Success -> {
                        Log.i("Download", "Downloaded ${state.bytesDownloaded} bytes")
                    }
                    is Failure -> throw state.exception
                }
            }
            Result.success(targetFile)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
    // ... other methods
}
```

--------------------------------

### Test Lich ViewModel with Mockk in Android

Source: https://context7.com/line/lich/llms.txt

Shows how to mock a Lich ViewModel for instrumented tests using the `viewmodel-test-mockk` library. This enables verification of ViewModel interactions and UI updates without actual ViewModel logic. Dependencies include `viewmodel-test-mockk`, `androidx.test.ext`, and `mockk`.

```kotlin
import com.linecorp.lich.viewmodel.test.mockk.mockViewModel
import androidx.test.ext.junit.rules.ActivityScenarioRule
import io.mockk.every
import io.mockk.verify

@RunWith(AndroidJUnit4::class)
class FooActivityTest {

    @Test
    fun testActivityWithMockedViewModel() {
        // Mock ViewModel before launching Activity
        val mockViewModel = mockViewModel(FooViewModel) { 
            every { data.value } returns FooData("test", 42)
            every { isLoading.value } returns false
            every { loadData(any()) } answers { 
                data.value = FooData("loaded", 100)
            }
        }

        ActivityScenario.launch(FooActivity::class.java).use { scenario ->
            // Verify UI displays mocked data
            onView(withId(R.id.dataText)).check(matches(withText("test: 42")))

            // Click button to trigger loadData
            onView(withId(R.id.loadButton)).perform(click())

            // Verify ViewModel method was called
            verify { mockViewModel.loadData(any()) }

            // Verify UI updated with new data
            onView(withId(R.id.dataText)).check(matches(withText("loaded: 100")))
        }
    }
}
```

--------------------------------

### Delegate Component Creation using DelegatedComponentFactory (Kotlin)

Source: https://github.com/line/lich/blob/master/component/README.md

Delegates component creation to a specified DelegatedComponentFactory. Requires implementing a subclass of DelegatedComponentFactory with a public empty constructor in a separate module. The factory class name is passed as a string to delegateCreation.

```kotlin
// "base" module
package module.base.facades

interface FooModuleFacade {

    fun launchFooActivity()

    companion object : ComponentFactory<FooModuleFacade>() {
        override fun createComponent(context: Context): FooModuleFacade = 
            delegateCreation(context, "module.foo.FooModuleFacadeFactory")
    }
}
```

```kotlin
// "foo" module
package module.foo

// The class inheriting DelegatedComponentFactory must have a public empty constructor.
class FooModuleFacadeFactory: DelegatedComponentFactory<FooModuleFacade>() {
    override fun createComponent(context: Context): FooModuleFacade = 
        FooModuleFacadeImpl(context)
}

internal class FooModuleFacadeImpl(private val context: Context) : FooModuleFacade {

    override fun launchFooActivity() {
        // snip...
    }
}
```

--------------------------------

### Define and Use Component with ComponentFactory in Kotlin

Source: https://context7.com/line/lich/llms.txt

Demonstrates how to define a component using ComponentFactory and use it in Activity, Service, and Fragment. Components are lazily created and cached per Context. The approach enables simplified dependency management using delegated properties and direct acquisition methods.

```kotlin
class FooComponent(private val context: Context) {
    fun doSomething() { /* implementation */ }

    companion object : ComponentFactory<FooComponent>() {
        override fun createComponent(context: Context): FooComponent =
            FooComponent(context)
    }
}

class FooActivity : Activity() {
    private val fooComponent by component(FooComponent)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        fooComponent.doSomething()
    }
}

class BarService : Service() {
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val fooComponent = getComponent(FooComponent)
        fooComponent.doSomething()
        return START_NOT_STICKY
    }
}

class FooFragment : Fragment() {
    private val fooComponent by component(FooComponent)

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        fooComponent.doSomething()
    }
}
```

--------------------------------

### Mock ViewModel with MockK for Android Tests

Source: https://github.com/line/lich/blob/master/viewmodel/README.md

Demonstrates how to mock a ViewModel using MockK in Android instrumented tests. It shows setting up mock data for ViewModel properties and verifying interactions with the mocked ViewModel. This approach requires the MockK library.

```kotlin
@RunWith(AndroidJUnit4::class)
class BarActivityTest {

    @After
    fun tearDown() {
        // You can omit this in Robolectric tests.
        // All ViewModel mocks are automatically cleared for every Robolectric test.
        clearAllMockViewModels()
    }

    @Test
    fun testViewBinding() {
        val mockBarText = MutableLiveData("Mocked.")
        // Set mock ViewModel for `BarViewModel`.
        val mockViewModelHandle = mockViewModel(BarViewModel) {
            every { barText } returns mockBarText
        }

        ActivityScenario.launch(BarActivity::class.java).use { scenario ->

            scenario.onActivity {
                assertTrue(mockViewModelHandle.isCreated)
            }

            onView(withId(R.id.bar_text)).check(matches(withText("Mocked.")))

            onView(withId(R.id.load_bar_button)).perform(click())

            scenario.onActivity {
                verify(exactly = 1) { mockViewModelHandle.mock.loadBarText() }
            }
        }
    }
}
```

--------------------------------

### Define Thrift Service Client with OkHttp

Source: https://context7.com/line/lich/llms.txt

Defines a Thrift service client that utilizes OkHttp for network communication. It extends an abstract Thrift service client and provides factories for Thrift client creation. This client supports basic calls, calls with parameters and return values, complex calls, and calls with custom headers.

```kotlin
class FooServiceClient(
    override val okHttpClient: OkHttpClient,
    override val endpointUrl: HttpUrl
) : AbstractThriftServiceClient<FooService.Client>() {

    override val thriftClientFactory: ThriftClientFactory<FooService.Client> =
        ThriftClientFactory(FooService.Client.Factory())

    // Simple void call
    suspend fun ping() =
        call({ send_ping() }, { recv_ping() })

    // Call with parameters and return value
    suspend fun getUserInfo(userId: Long): UserInfo =
        call(
            { send_getUserInfo(userId) },
            { recv_getUserInfo() }
        )

    // Complex call with multiple parameters
    suspend fun createOrder(
        userId: Long,
        items: List<OrderItem>,
        metadata: OrderMetadata
    ): OrderResult =
        call(
            { send_createOrder(userId, items, metadata) },
            { recv_createOrder() }
        )

    // Call with custom headers
    suspend fun authenticatedCall(token: String, request: FooRequest): FooResponse {
        return callWithCustomHeaders(
            headers = mapOf("Authorization" to "Bearer $token"),
            send = { send_callFoo(request) },
            recv = { recv_callFoo() }
        )
    }
}

// Register as Component
class FooServiceClient private constructor(
    override val okHttpClient: OkHttpClient,
    override val endpointUrl: HttpUrl
) : AbstractThriftServiceClient<FooService.Client>() {

    override val thriftClientFactory = ThriftClientFactory(FooService.Client.Factory())

    suspend fun fetchData(id: String): FooData =
        call({ send_fetchData(id) }, { recv_fetchData() })

    companion object : ComponentFactory<FooServiceClient>() {
        override fun createComponent(context: Context): FooServiceClient {
            val okHttpClient = context.getComponent(OkHttpClient)
            val endpointUrl = "https://api.example.com/thrift".toHttpUrl()
            return FooServiceClient(okHttpClient, endpointUrl)
        }
    }
}

// Usage in Repository
class FooRepository(private val context: Context) {
    private val fooServiceClient by context.component(FooServiceClient)

    suspend fun getFooData(id: String): Result<FooData> = withContext(Dispatchers.IO) {
        try {
            val data = fooServiceClient.fetchData(id)
            Result.success(data)
        } catch (e: TException) {
            Log.e("Repository", "Thrift call failed", e)
            Result.failure(e)
        } catch (e: IOException) {
            Log.e("Repository", "Network error", e)
            Result.failure(e)
        }
    }

    suspend fun batchGetUsers(userIds: List<Long>): List<UserInfo> {
        return userIds.mapNotNull { id ->
            try {
                fooServiceClient.getUserInfo(id)
            } catch (e: Exception) {
                Log.w("Repository", "Failed to fetch user $id", e)
                null
            }
        }
    }
}

```

--------------------------------

### Resumable Download with Progress Monitoring in Kotlin

Source: https://github.com/line/lich/blob/master/okhttp/README.md

Performs a resumable download from a URL to a file, allowing the download to continue from where it left off if interrupted. It utilizes the file's current length to set the range header for resuming. Handles download progress and provides messages for completion, partial completion, or failure, indicating how to resume.

```kotlin
suspend fun performResumableDownloadWithProgress(url: HttpUrl, fileToSave: File) {
    val resourceToSave = fileToSave.asWritableResource()
    val request = Request.Builder()
        .url(url)
        .setRangeHeader(resourceToSave.length)
        .build()
    okHttpClient.callWithCounting(request) { response ->
        response.saveToResourceWithSupportingResumption(resourceToSave)
    }.collect { state ->
        when (state) {
            is Uploading -> Unit
            is Downloading ->
                println("Downloading: ${state.bytesTransferred} bytes downloaded." +
                    state.progressPercentage?.let { " ($it%)" }.orEmpty())
            is Success ->
                if (state.data)
                    println("The download is complete. TotalLength=${state.bytesDownloaded}")
                else
                    println("The HTTP call was successful, but the content may have a remaining part.\n" +
                        "To complete the download, call this function again.")
            is Failure ->
                println("Failure: ${state.exception}\nTo resume the download, call this function again.")
        }
    }
}
```

--------------------------------

### OkHttp Upload Single File with Progress Tracking (Kotlin)

Source: https://context7.com/line/lich/llms.txt

Uploads a single file to a specified URL using OkHttp, providing real-time progress updates. It handles the request body, response checking, and collects upload progress states. Dependencies include OkHttp and Kotlin coroutines.

```kotlin
class UploadManager(private val okHttpClient: OkHttpClient) {

    suspend fun uploadFile(
        url: String,
        file: File,
        contentType: String = "application/octet-stream",
        onProgress: (bytesUploaded: Long, totalBytes: Long) -> Unit
    ): Result<String> {
        val requestBody = file.asRequestBody(contentType.toMediaType())
        val request = Request.Builder()
            .url(url)
            .post(requestBody)
            .build()

        return try {
            var responseBody = ""

            okHttpClient.callWithCounting(request, countDownload = false) { response ->
                if (!response.isSuccessful) {
                    throw IOException("Upload failed: HTTP ${response.code}")
                }
                responseBody = response.body?.string() ?: ""
            }.collect { state ->
                when (state) {
                    is Uploading -> {
                        onProgress(state.bytesTransferred, file.length())
                    }
                    is Success -> {
                        Log.i("Upload", "Uploaded ${state.bytesUploaded} bytes")
                    }
                    is Failure -> throw state.exception
                }
            }

            Result.success(responseBody)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    // Multipart form upload
    suspend fun uploadMultipart(
        url: String,
        fields: Map<String, String>,
        files: Map<String, File>,
        onProgress: (Long, Long) -> Unit
    ): Result<String> {
        val multipartBody = MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .apply {
                fields.forEach { (key, value) ->
                    addFormDataPart(key, value)
                }
                files.forEach { (key, file) ->
                    addFormDataPart(
                        key,
                        file.name,
                        file.asRequestBody("application/octet-stream".toMediaType())
                    )
                }
            }
            .build()

        val request = Request.Builder()
            .url(url)
            .post(multipartBody)
            .build()

        return try {
            var responseText = ""

            okHttpClient.callWithCounting(request, countDownload = false) { response ->
                if (!response.isSuccessful) {
                    throw IOException("HTTP ${response.code}")
                }
                responseText = response.body?.string() ?: ""
            }.collect { state ->
                when (state) {
                    is Uploading -> onProgress(state.bytesTransferred, multipartBody.contentLength())
                    is Success -> Log.i("Upload", "Complete")
                    is Failure -> throw state.exception
                }
            }

            Result.success(responseText)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

// Usage example
class PhotoUploader(private val uploadManager: UploadManager) {

    suspend fun uploadPhoto(photo: File, userId: String): String {
        val uploadProgress = MutableStateFlow(0)

        val result = uploadManager.uploadMultipart(
            url = "https://api.example.com/upload",
            fields = mapOf(
                "userId" to userId,
                "timestamp" to System.currentTimeMillis().toString()
            ),
            files = mapOf("photo" to photo),
            onProgress = {
                current, total ->
                uploadProgress.value = (current * 100 / total).toInt()
            }
        )

        return result.getOrThrow()
    }
}

```

--------------------------------

### Testing with Mockito-Kotlin and Lich Components (Kotlin)

Source: https://github.com/line/lich/blob/master/component/README.md

Illustrates how to test a use case (`SaveFooUseCase`) by mocking its dependencies (`FooRepository`) using Mockito-Kotlin and the `mockComponent` function from Lich. This is an alternative to MockK for dependency mocking in tests.

```kotlin
@RunWith(AndroidJUnit4::class)
class SaveFooUseCaseTest {

    private lateinit var context: Context

    @Before
    fun setUp() {
        context = ApplicationProvider.getApplicationContext()
    }

    @Test
    fun testGetFooFromStorage() {
        val expected = Foo()
        val mockFooRepository = mockComponent(FooRepository) {
            onBlocking { findFoo(any()) } doReturn expected
        }
        val saveFooUseCase = SaveFooUseCase(context)

        val actual = runBlocking { saveFooUseCase.getFooFromStorage("key") }

        assertEquals(expected, actual)
        verifyBlocking(mockFooRepository) { findFoo(eq("key")) }
    }
}
```

--------------------------------

### Obtain a Lich Component singleton instance

Source: https://github.com/line/lich/blob/master/component/README.md

Shows how to retrieve the singleton instance of a declared Lich component using the `getComponent` extension function on a Context. This is the standard way to access component instances.

```kotlin
val fooComponent = context.getComponent(FooComponent)
```

--------------------------------

### Default Arguments for Non-Singleton Objects (Kotlin)

Source: https://github.com/line/lich/blob/master/component/README.md

Demonstrates using default arguments in Kotlin constructors to provide default instances of dependencies, such as `BarHelper`. This pattern facilitates mocking dependencies in tests without explicit manual injection. Lazy acquisition via `context.component` can also be used for components.

```kotlin
class FooController(
    context: Context,
    private val barHelper: BarHelper = BarHelper(context)
) {
    private val bazComponent by context.component(BazComponent)

    // ...
}

class BarHelper(private val context: Context) {
    // ...
}
```

--------------------------------

### Add Lich Thrift Dependency to Gradle

Source: https://github.com/line/lich/blob/master/thrift/README.md

This snippet shows how to add the Lich Thrift library to your project's Gradle build file. It specifies the dependency needed for basic Thrift client functionality.

```groovy
// build.gradle
dependencies {
    implementation 'com.linecorp.lich:thrift:x.x.x'
}
```

--------------------------------

### Add Lich OkHttp Dependency

Source: https://github.com/line/lich/blob/master/okhttp/README.md

This snippet shows how to add the Lich OkHttp library to your project's Gradle build file. It ensures you have the necessary dependencies for using the coroutine-aware extensions.

```groovy
// build.gradle
dependencies {
    implementation 'com.linecorp.lich:okhttp:x.x.x'
}
```

--------------------------------

### OkHttp Resumable Download with Range Header in Kotlin

Source: https://context7.com/line/lich/llms.txt

Implements resumable file downloads using the `Range` header in OkHttp requests. It checks for existing bytes in the target file and appends new data, providing progress updates. It returns a `Result` indicating success or failure.

```kotlin
class DownloadManager(private val okHttpClient: OkHttpClient) {

    // ... other methods

    // Resumable download with Range header support
    suspend fun resumableDownload(
        url: String,
        targetFile: File,
        onProgress: (current: Long, total: Long?) -> Unit
    ): Result<File> {
        val resourceToSave = targetFile.asWritableResource()
        val existingBytes = resourceToSave.length

        val request = Request.Builder()
            .url(url)
            .setRangeHeader(existingBytes)  // Resume from existing bytes
            .build()

        return try {
            okHttpClient.callWithCounting(request) { response ->
                if (response.code !in 200..299) {
                    throw IOException("HTTP ${response.code}")
                }
                response.saveToResourceWithSupportingResumption(resourceToSave)
            }.collect { state ->
                when (state) {
                    is Downloading -> {
                        val totalDownloaded = existingBytes + state.bytesTransferred
                        val totalSize = state.contentLength?.let { it + existingBytes }
                        onProgress(totalDownloaded, totalSize)
                    }
                    is Success -> {
                        Log.i("Download", "Completed: ${resourceToSave.length} bytes")
                    }
                    is Failure -> throw state.exception
                }
            }
            Result.success(targetFile)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}
```