aigroup-workflow 2.1.2 → 2.2.0

package/skills/java/kotlin-specialist/references/android-compose.md

@@ -0,0 +1,419 @@
+# Android & Jetpack Compose
+
+## Compose Basics
+
+```kotlin
+import androidx.compose.runtime.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun UserProfile(user: User, onEdit: () -> Unit) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(16.dp)
+    ) {
+        Column(modifier = Modifier.padding(16.dp)) {
+            Text(
+                text = user.name,
+                style = MaterialTheme.typography.headlineMedium
+            )
+            Text(
+                text = user.email,
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+            Spacer(modifier = Modifier.height(8.dp))
+            Button(onClick = onEdit) {
+                Text("Edit Profile")
+            }
+        }
+    }
+}
+```
+
+## State Management
+
+```kotlin
+// ViewModel with StateFlow
+class UserViewModel(
+    private val repository: UserRepository
+) : ViewModel() {
+    private val _uiState = MutableStateFlow(UserUiState())
+    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
+
+    fun loadUser(userId: String) {
+        viewModelScope.launch {
+            _uiState.update { it.copy(isLoading = true) }
+            try {
+                val user = repository.getUser(userId)
+                _uiState.update { it.copy(user = user, isLoading = false) }
+            } catch (e: Exception) {
+                _uiState.update { it.copy(error = e.message, isLoading = false) }
+            }
+        }
+    }
+}
+
+data class UserUiState(
+    val user: User? = null,
+    val isLoading: Boolean = false,
+    val error: String? = null
+)
+
+// Composable using ViewModel
+@Composable
+fun UserScreen(
+    viewModel: UserViewModel = hiltViewModel(),
+    userId: String
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    LaunchedEffect(userId) {
+        viewModel.loadUser(userId)
+    }
+
+    when {
+        uiState.isLoading -> LoadingIndicator()
+        uiState.error != null -> ErrorMessage(uiState.error!!)
+        uiState.user != null -> UserProfile(uiState.user!!)
+    }
+}
+```
+
+## Material 3 Theme
+
+```kotlin
+@Composable
+fun AppTheme(
+    darkTheme: Boolean = isSystemInDarkTheme(),
+    content: @Composable () -> Unit
+) {
+    val colorScheme = if (darkTheme) {
+        darkColorScheme(
+            primary = Purple80,
+            secondary = PurpleGrey80,
+            tertiary = Pink80
+        )
+    } else {
+        lightColorScheme(
+            primary = Purple40,
+            secondary = PurpleGrey40,
+            tertiary = Pink40
+        )
+    }
+
+    MaterialTheme(
+        colorScheme = colorScheme,
+        typography = Typography,
+        content = content
+    )
+}
+```
+
+## Navigation
+
+```kotlin
+import androidx.navigation.compose.*
+
+@Composable
+fun AppNavigation() {
+    val navController = rememberNavController()
+
+    NavHost(
+        navController = navController,
+        startDestination = "home"
+    ) {
+        composable("home") {
+            HomeScreen(
+                onNavigateToProfile = { userId ->
+                    navController.navigate("profile/$userId")
+                }
+            )
+        }
+
+        composable(
+            route = "profile/{userId}",
+            arguments = listOf(navArgument("userId") { type = NavType.StringType })
+        ) { backStackEntry ->
+            val userId = backStackEntry.arguments?.getString("userId")
+            ProfileScreen(
+                userId = userId ?: "",
+                onBack = { navController.popBackStack() }
+            )
+        }
+
+        composable("settings") {
+            SettingsScreen()
+        }
+    }
+}
+```
+
+## LazyColumn (Lists)
+
+```kotlin
+@Composable
+fun UserList(
+    users: List<User>,
+    onUserClick: (User) -> Unit
+) {
+    LazyColumn(
+        modifier = Modifier.fillMaxSize(),
+        contentPadding = PaddingValues(16.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp)
+    ) {
+        items(users, key = { it.id }) { user ->
+            UserCard(
+                user = user,
+                onClick = { onUserClick(user) }
+            )
+        }
+    }
+}
+
+// Pagination with LazyColumn
+@Composable
+fun PaginatedList(viewModel: ListViewModel = hiltViewModel()) {
+    val items by viewModel.items.collectAsStateWithLifecycle()
+    val isLoading by viewModel.isLoading.collectAsStateWithLifecycle()
+
+    LazyColumn {
+        items(items, key = { it.id }) { item ->
+            ItemCard(item)
+        }
+
+        if (isLoading) {
+            item {
+                CircularProgressIndicator(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(16.dp)
+                )
+            }
+        }
+
+        // Load more trigger
+        item {
+            LaunchedEffect(Unit) {
+                viewModel.loadMore()
+            }
+        }
+    }
+}
+```
+
+## Side Effects
+
+```kotlin
+@Composable
+fun UserScreen(userId: String) {
+    // Run once when userId changes
+    LaunchedEffect(userId) {
+        loadUser(userId)
+    }
+
+    // Run on every recomposition
+    SideEffect {
+        analyticsService.trackScreen("UserScreen")
+    }
+
+    // Cleanup when leaving composition
+    DisposableEffect(Unit) {
+        val listener = setupListener()
+        onDispose {
+            listener.cleanup()
+        }
+    }
+
+    // Remember value across recompositions
+    val scrollState = rememberScrollState()
+
+    // Derived state
+    val isScrolled by remember {
+        derivedStateOf { scrollState.value > 0 }
+    }
+}
+```
+
+## Dependency Injection (Hilt)
+
+```kotlin
+// Application class
+@HiltAndroidApp
+class MyApplication : Application()
+
+// Module
+@Module
+@InstallIn(SingletonComponent::class)
+object AppModule {
+    @Provides
+    @Singleton
+    fun provideApiService(): ApiService = ApiServiceImpl()
+
+    @Provides
+    @Singleton
+    fun provideUserRepository(api: ApiService): UserRepository =
+        UserRepositoryImpl(api)
+}
+
+// ViewModel with injection
+@HiltViewModel
+class UserViewModel @Inject constructor(
+    private val repository: UserRepository,
+    private val savedStateHandle: SavedStateHandle
+) : ViewModel() {
+    private val userId: String = savedStateHandle["userId"] ?: ""
+
+    val user: StateFlow<User?> = repository
+        .getUserFlow(userId)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5000),
+            initialValue = null
+        )
+}
+
+// Activity
+@AndroidEntryPoint
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            AppTheme {
+                AppNavigation()
+            }
+        }
+    }
+}
+```
+
+## Remember & State
+
+```kotlin
+@Composable
+fun SearchScreen() {
+    // State hoisting
+    var query by remember { mutableStateOf("") }
+    var results by remember { mutableStateOf<List<Result>>(emptyList()) }
+
+    Column {
+        SearchBar(
+            query = query,
+            onQueryChange = { query = it },
+            onSearch = {
+                // Trigger search
+            }
+        )
+
+        ResultsList(results)
+    }
+}
+
+// Remember with keys
+@Composable
+fun UserDetail(userId: String) {
+    val user = remember(userId) {
+        loadUser(userId)
+    }
+
+    // rememberSaveable survives process death
+    var expanded by rememberSaveable { mutableStateOf(false) }
+}
+```
+
+## Animation
+
+```kotlin
+import androidx.compose.animation.*
+import androidx.compose.animation.core.*
+
+@Composable
+fun AnimatedContent() {
+    var visible by remember { mutableStateOf(false) }
+
+    // Simple fade
+    AnimatedVisibility(visible) {
+        Text("Hello World")
+    }
+
+    // Custom animation
+    val alpha by animateFloatAsState(
+        targetValue = if (visible) 1f else 0f,
+        animationSpec = tween(durationMillis = 300)
+    )
+
+    // Animated content
+    AnimatedContent(
+        targetState = selectedTab,
+        transitionSpec = {
+            fadeIn() + slideInVertically() togetherWith
+                    fadeOut() + slideOutVertically()
+        }
+    ) { tab ->
+        when (tab) {
+            0 -> HomeContent()
+            1 -> ProfileContent()
+        }
+    }
+}
+```
+
+## Performance Optimization
+
+```kotlin
+// Stability annotations
+@Immutable
+data class User(val id: String, val name: String)
+
+@Stable
+class UserState(private val repository: UserRepository) {
+    val users: StateFlow<List<User>> = repository.users
+}
+
+// Key for recomposition optimization
+@Composable
+fun ItemList(items: List<Item>) {
+    LazyColumn {
+        items(items, key = { it.id }) { item ->
+            ItemCard(item)
+        }
+    }
+}
+
+// derivedStateOf for expensive calculations
+@Composable
+fun FilteredList(items: List<Item>, filter: String) {
+    val filtered by remember(items, filter) {
+        derivedStateOf {
+            items.filter { it.name.contains(filter, ignoreCase = true) }
+        }
+    }
+
+    LazyColumn {
+        items(filtered) { item ->
+            ItemCard(item)
+        }
+    }
+}
+```
+
+## Quick Reference
+
+| Composable | Purpose |
+|------------|---------|
+| `remember` | Retain value across recompositions |
+| `rememberSaveable` | Survive process death |
+| `LaunchedEffect` | Run suspend functions |
+| `DisposableEffect` | Cleanup when leaving |
+| `SideEffect` | Non-suspend effects |
+| `derivedStateOf` | Computed state |
+| `collectAsStateWithLifecycle` | Flow to State (lifecycle-aware) |
+| `animateFloatAsState` | Animate value changes |
+| `LazyColumn` | Scrollable list |
+| `Scaffold` | Material 3 layout structure |
+| `viewModelScope` | ViewModel coroutine scope |
+| `@HiltViewModel` | Hilt dependency injection |

package/skills/java/kotlin-specialist/references/coroutines-flow.md

@@ -0,0 +1,276 @@
+# Coroutines & Flow API
+
+## Structured Concurrency
+
+```kotlin
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+
+class UserRepository(
+    private val api: ApiService,
+    private val scope: CoroutineScope
+) {
+    // CORRECT: Structured concurrency with supervisor
+    suspend fun fetchUsers(): Result<List<User>> = coroutineScope {
+        supervisorScope {
+            try {
+                val users = async { api.getUsers() }
+                val profiles = async { api.getProfiles() }
+                Result.success(users.await() + profiles.await())
+            } catch (e: Exception) {
+                Result.failure(e)
+            }
+        }
+    }
+
+    // WRONG: GlobalScope bypasses structured concurrency
+    // fun fetchUsersWrong() = GlobalScope.launch { ... }
+}
+```
+
+## Coroutine Scopes & Dispatchers
+
+```kotlin
+class ViewModel : CoroutineScope {
+    override val coroutineContext = SupervisorJob() + Dispatchers.Main
+
+    fun loadData() {
+        launch {
+            val data = withContext(Dispatchers.IO) {
+                // I/O operations on IO dispatcher
+                repository.fetchData()
+            }
+            // Back to Main dispatcher automatically
+            updateUI(data)
+        }
+    }
+
+    fun cleanup() {
+        coroutineContext.cancelChildren()
+    }
+}
+
+// Android ViewModel - use viewModelScope
+class AndroidViewModel : ViewModel() {
+    fun loadUsers() {
+        viewModelScope.launch {
+            userRepository.getUsers().collect { users ->
+                _uiState.update { it.copy(users = users) }
+            }
+        }
+    }
+}
+```
+
+## Flow Basics
+
+```kotlin
+// Cold flow - starts on collection
+fun getUsers(): Flow<List<User>> = flow {
+    val users = api.fetchUsers()
+    emit(users)
+    delay(1000)
+    emit(users + api.fetchNewUsers())
+}.flowOn(Dispatchers.IO)
+
+// Hot flow - StateFlow (always has value)
+class UserStore {
+    private val _users = MutableStateFlow<List<User>>(emptyList())
+    val users: StateFlow<List<User>> = _users.asStateFlow()
+
+    suspend fun loadUsers() {
+        api.getUsers().collect { userList ->
+            _users.update { userList }
+        }
+    }
+}
+
+// Hot flow - SharedFlow (events, no initial value)
+class EventBus {
+    private val _events = MutableSharedFlow<Event>(
+        replay = 0,
+        extraBufferCapacity = 10,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST
+    )
+    val events: SharedFlow<Event> = _events.asSharedFlow()
+
+    suspend fun emit(event: Event) {
+        _events.emit(event)
+    }
+}
+```
+
+## Flow Operators
+
+```kotlin
+fun getUsersWithPosts(): Flow<UserWithPosts> = flow {
+    userRepository.getUsers()
+        .map { user -> UserWithPosts(user, getPosts(user.id)) }
+        .filter { it.posts.isNotEmpty() }
+        .catch { e -> emit(UserWithPosts.Error(e)) }
+        .onEach { delay(100) } // Throttle
+        .distinctUntilChanged()
+        .collect { emit(it) }
+}
+
+// Combining flows
+fun getCombinedData(): Flow<UiState> = combine(
+    userFlow,
+    settingsFlow,
+    notificationsFlow
+) { user, settings, notifications ->
+    UiState(user, settings, notifications)
+}
+
+// Flattening flows
+fun searchUsers(query: String): Flow<List<User>> =
+    queryFlow
+        .debounce(300)
+        .filter { it.length >= 3 }
+        .distinctUntilChanged()
+        .flatMapLatest { query ->
+            repository.search(query)
+        }
+```
+
+## Exception Handling
+
+```kotlin
+suspend fun loadDataSafely(): Result<Data> =
+    supervisorScope {
+        try {
+            val result = async {
+                api.getData()
+            }
+            Result.success(result.await())
+        } catch (e: CancellationException) {
+            // Don't catch cancellation - rethrow
+            throw e
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+
+// Flow error handling
+fun getDataFlow(): Flow<Data> = flow {
+    emit(api.getData())
+}.retry(3) { cause ->
+    cause is IOException
+}.catch { e ->
+    emit(Data.Error(e))
+}
+
+// Supervisor scope for independent children
+suspend fun loadMultiple() = supervisorScope {
+    val job1 = launch { task1() } // Failure won't affect job2
+    val job2 = launch { task2() }
+    joinAll(job1, job2)
+}
+```
+
+## Cancellation
+
+```kotlin
+suspend fun cancellableWork() {
+    withTimeout(5000) {
+        while (isActive) { // Check for cancellation
+            doWork()
+            yield() // Cooperation point
+        }
+    }
+}
+
+// Cleanup with finally
+suspend fun withCleanup() {
+    try {
+        longRunningTask()
+    } finally {
+        withContext(NonCancellable) {
+            cleanup() // Always runs even if cancelled
+        }
+    }
+}
+```
+
+## Testing Coroutines
+
+```kotlin
+import kotlinx.coroutines.test.*
+
+class UserViewModelTest {
+    @Test
+    fun testLoadUsers() = runTest {
+        val viewModel = UserViewModel(fakeRepository)
+
+        viewModel.loadUsers()
+        advanceUntilIdle() // Run all pending coroutines
+
+        assertEquals(expectedUsers, viewModel.users.value)
+    }
+
+    @Test
+    fun testFlow() = runTest {
+        val flow = repository.getUsersFlow()
+        val results = flow.take(3).toList()
+
+        assertEquals(3, results.size)
+    }
+
+    // Testing with Turbine
+    @Test
+    fun testFlowWithTurbine() = runTest {
+        repository.getUsersFlow().test {
+            assertEquals(Loading, awaitItem())
+            assertEquals(Success(users), awaitItem())
+            awaitComplete()
+        }
+    }
+}
+```
+
+## Performance Patterns
+
+```kotlin
+// Use sequence for lazy evaluation
+fun processLargeList(items: List<Item>): List<Result> =
+    items.asSequence()
+        .filter { it.isValid }
+        .map { transform(it) }
+        .take(100)
+        .toList() // Only processes first 100 valid items
+
+// Channel for producer-consumer
+fun produceNumbers() = produce {
+    repeat(10) {
+        send(it)
+        delay(100)
+    }
+}
+
+// Parallel processing with async
+suspend fun processInParallel(items: List<Item>): List<Result> =
+    coroutineScope {
+        items.map { item ->
+            async { process(item) }
+        }.awaitAll()
+    }
+```
+
+## Quick Reference
+
+| Pattern | Use Case |
+|---------|----------|
+| `launch` | Fire-and-forget coroutine |
+| `async/await` | Parallel computation with result |
+| `flow { }` | Cold stream of values |
+| `StateFlow` | Hot flow with current state |
+| `SharedFlow` | Hot flow for events |
+| `withContext` | Switch dispatcher |
+| `supervisorScope` | Independent child failures |
+| `coroutineScope` | All children must succeed |
+| `flowOn` | Change flow dispatcher |
+| `catch` | Handle flow errors |
+| `retry` | Retry on failure |
+| `debounce` | Rate limiting |
+| `distinctUntilChanged` | Skip duplicates |
+| `combine` | Merge multiple flows |