reis-mobile 0.3.6 → 0.4.0

package/skills/android-wear-compose-m3/references/foundation/RotarySamples.kt.md.txt

@@ -0,0 +1,153 @@
+```
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.wear.compose.foundation.samples
+
+import androidx.annotation.Sampled
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.overscroll
+import androidx.compose.foundation.rememberOverscrollEffect
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.util.fastSumBy
+import androidx.wear.compose.foundation.requestFocusOnHierarchyActive
+import androidx.wear.compose.foundation.rotary.RotaryScrollableDefaults
+import androidx.wear.compose.foundation.rotary.RotarySnapLayoutInfoProvider
+import androidx.wear.compose.foundation.rotary.rotaryScrollable
+import androidx.wear.compose.material.Text
+
+@Sampled
+@Composable
+fun RotaryScrollSample() {
+    val scrollableState = rememberLazyListState()
+    val focusRequester = remember { FocusRequester() }
+    LazyColumn(
+        modifier =
+            Modifier.fillMaxSize()
+                .requestFocusOnHierarchyActive()
+                .rotaryScrollable(
+                    behavior = RotaryScrollableDefaults.behavior(scrollableState),
+                    focusRequester = focusRequester,
+                ),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        state = scrollableState,
+    ) {
+        items(300) {
+            BasicText(
+                text = "item $it",
+                modifier = Modifier.background(Color.Gray),
+                style = TextStyle.Default.copy(),
+            )
+        }
+    }
+}
+
+@Sampled
+@Composable
+fun RotaryScrollWithOverscrollSample() {
+    val scrollableState = rememberScrollState()
+    val focusRequester = remember { FocusRequester() }
+    val overscrollEffect = rememberOverscrollEffect()
+
+    val screenHeightDp = LocalConfiguration.current.screenHeightDp.dp
+
+    Column(
+        Modifier.fillMaxSize()
+            .requestFocusOnHierarchyActive()
+            .rotaryScrollable(
+                behavior = RotaryScrollableDefaults.behavior(scrollableState),
+                focusRequester = focusRequester,
+                overscrollEffect = overscrollEffect,
+            )
+            .verticalScroll(scrollableState, overscrollEffect)
+            .overscroll(overscrollEffect),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text("Top")
+        Spacer(modifier = Modifier.height(screenHeightDp / 2))
+        Text("Scroll this list up and down with rotary input", textAlign = TextAlign.Center)
+        Spacer(modifier = Modifier.height(screenHeightDp / 2))
+        Text("Bottom")
+    }
+}
+
+@Sampled
+@Composable
+fun RotarySnapSample() {
+    val scrollableState = rememberLazyListState()
+    val focusRequester = remember { FocusRequester() }
+    LazyColumn(
+        modifier =
+            Modifier.fillMaxSize()
+                .requestFocusOnHierarchyActive()
+                .rotaryScrollable(
+                    behavior =
+                        RotaryScrollableDefaults.snapBehavior(
+                            scrollableState,
+                            // This sample has a custom implementation of
+                            // RotarySnapLayoutInfoProvider which is required for snapping behavior.
+                            // ScalingLazyColumn has it built-in, so it's not required there.
+                            remember(scrollableState) {
+                                object : RotarySnapLayoutInfoProvider {
+
+                                    override val averageItemSize: Float
+                                        get() {
+                                            val items = scrollableState.layoutInfo.visibleItemsInfo
+                                            return (items.fastSumBy { it.size } / items.size)
+                                                .toFloat()
+                                        }
+
+                                    override val currentItemIndex: Int
+                                        get() = scrollableState.firstVisibleItemIndex
+
+                                    override val currentItemOffset: Float
+                                        get() =
+                                            scrollableState.firstVisibleItemScrollOffset.toFloat()
+
+                                    override val totalItemCount: Int
+                                        get() = scrollableState.layoutInfo.totalItemsCount
+                                }
+                            },
+                        ),
+                    focusRequester = focusRequester,
+                ),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        state = scrollableState,
+    ) {
+        items(300) {
+            BasicText(text = "item $it", modifier = Modifier.background(Color.Gray).height(50.dp))
+        }
+    }
+}
+```

package/skills/android-wear-compose-m3/references/foundation/ScalingLazyColumnSample.kt.md

@@ -0,0 +1,131 @@
+```
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.wear.compose.foundation.samples
+
+import androidx.annotation.Sampled
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.dp
+import androidx.wear.compose.foundation.lazy.AutoCenteringParams
+import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
+import androidx.wear.compose.foundation.lazy.ScalingLazyColumnDefaults
+import androidx.wear.compose.foundation.lazy.ScalingLazyListAnchorType
+import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
+import androidx.wear.compose.foundation.rotary.RotaryScrollableDefaults
+import androidx.wear.compose.material.Chip
+import androidx.wear.compose.material.ChipDefaults
+import androidx.wear.compose.material.ListHeader
+import androidx.wear.compose.material.Text
+import kotlinx.coroutines.launch
+
+@Sampled
+@Composable
+fun SimpleScalingLazyColumn() {
+    ScalingLazyColumn(modifier = Modifier.fillMaxWidth()) {
+        item { ListHeader { Text(text = "List Header") } }
+        items(20) {
+            Chip(
+                onClick = {},
+                label = { Text("List item $it") },
+                colors = ChipDefaults.secondaryChipColors(),
+            )
+        }
+    }
+}
+
+@Sampled
+@Composable
+fun SimpleScalingLazyColumnWithSnap() {
+    val state = rememberScalingLazyListState()
+    ScalingLazyColumn(
+        rotaryScrollableBehavior = RotaryScrollableDefaults.snapBehavior(scrollableState = state),
+        flingBehavior = ScalingLazyColumnDefaults.snapFlingBehavior(state = state),
+        modifier = Modifier.fillMaxWidth(),
+        state = state,
+    ) {
+        item { ListHeader { Text(text = "List Header") } }
+        items(20) {
+            Chip(
+                onClick = {},
+                label = { Text("List item $it") },
+                colors = ChipDefaults.secondaryChipColors(),
+            )
+        }
+    }
+}
+
+@Sampled
+@Composable
+fun ScalingLazyColumnEdgeAnchoredAndAnimatedScrollTo() {
+    val coroutineScope = rememberCoroutineScope()
+    val itemSpacing = 6.dp
+    // Line up the gap between the items on the center-line
+    val scrollOffset = with(LocalDensity.current) { -(itemSpacing / 2).roundToPx() }
+    val state =
+        rememberScalingLazyListState(
+            initialCenterItemIndex = 1,
+            initialCenterItemScrollOffset = scrollOffset,
+        )
+
+    ScalingLazyColumn(
+        modifier = Modifier.fillMaxWidth(),
+        anchorType = ScalingLazyListAnchorType.ItemStart,
+        verticalArrangement = Arrangement.spacedBy(itemSpacing),
+        state = state,
+        autoCentering = AutoCenteringParams(itemOffset = scrollOffset),
+    ) {
+        item { ListHeader { Text(text = "List Header") } }
+        items(20) {
+            Chip(
+                onClick = {
+                    coroutineScope.launch {
+                        // Add +1 to allow for the ListHeader
+                        state.animateScrollToItem(it + 1, scrollOffset)
+                    }
+                },
+                label = { Text("List item $it") },
+                colors = ChipDefaults.secondaryChipColors(),
+            )
+        }
+    }
+}
+
+@Sampled
+@Composable
+fun SimpleScalingLazyColumnWithContentPadding() {
+    ScalingLazyColumn(
+        modifier = Modifier.fillMaxWidth(),
+        contentPadding = PaddingValues(top = 20.dp, bottom = 20.dp),
+        autoCentering = null,
+    ) {
+        item { ListHeader { Text(text = "List Header") } }
+        items(20) {
+            Chip(
+                onClick = {},
+                label = { Text("List item $it") },
+                colors = ChipDefaults.secondaryChipColors(),
+            )
+        }
+    }
+}
+```

package/skills/android-wear-compose-m3/references/foundation/ScalingLazyColumnSample.kt.md.txt

@@ -0,0 +1,131 @@
+```
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.wear.compose.foundation.samples
+
+import androidx.annotation.Sampled
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.dp
+import androidx.wear.compose.foundation.lazy.AutoCenteringParams
+import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
+import androidx.wear.compose.foundation.lazy.ScalingLazyColumnDefaults
+import androidx.wear.compose.foundation.lazy.ScalingLazyListAnchorType
+import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
+import androidx.wear.compose.foundation.rotary.RotaryScrollableDefaults
+import androidx.wear.compose.material.Chip
+import androidx.wear.compose.material.ChipDefaults
+import androidx.wear.compose.material.ListHeader
+import androidx.wear.compose.material.Text
+import kotlinx.coroutines.launch
+
+@Sampled
+@Composable
+fun SimpleScalingLazyColumn() {
+    ScalingLazyColumn(modifier = Modifier.fillMaxWidth()) {
+        item { ListHeader { Text(text = "List Header") } }
+        items(20) {
+            Chip(
+                onClick = {},
+                label = { Text("List item $it") },
+                colors = ChipDefaults.secondaryChipColors(),
+            )
+        }
+    }
+}
+
+@Sampled
+@Composable
+fun SimpleScalingLazyColumnWithSnap() {
+    val state = rememberScalingLazyListState()
+    ScalingLazyColumn(
+        rotaryScrollableBehavior = RotaryScrollableDefaults.snapBehavior(scrollableState = state),
+        flingBehavior = ScalingLazyColumnDefaults.snapFlingBehavior(state = state),
+        modifier = Modifier.fillMaxWidth(),
+        state = state,
+    ) {
+        item { ListHeader { Text(text = "List Header") } }
+        items(20) {
+            Chip(
+                onClick = {},
+                label = { Text("List item $it") },
+                colors = ChipDefaults.secondaryChipColors(),
+            )
+        }
+    }
+}
+
+@Sampled
+@Composable
+fun ScalingLazyColumnEdgeAnchoredAndAnimatedScrollTo() {
+    val coroutineScope = rememberCoroutineScope()
+    val itemSpacing = 6.dp
+    // Line up the gap between the items on the center-line
+    val scrollOffset = with(LocalDensity.current) { -(itemSpacing / 2).roundToPx() }
+    val state =
+        rememberScalingLazyListState(
+            initialCenterItemIndex = 1,
+            initialCenterItemScrollOffset = scrollOffset,
+        )
+
+    ScalingLazyColumn(
+        modifier = Modifier.fillMaxWidth(),
+        anchorType = ScalingLazyListAnchorType.ItemStart,
+        verticalArrangement = Arrangement.spacedBy(itemSpacing),
+        state = state,
+        autoCentering = AutoCenteringParams(itemOffset = scrollOffset),
+    ) {
+        item { ListHeader { Text(text = "List Header") } }
+        items(20) {
+            Chip(
+                onClick = {
+                    coroutineScope.launch {
+                        // Add +1 to allow for the ListHeader
+                        state.animateScrollToItem(it + 1, scrollOffset)
+                    }
+                },
+                label = { Text("List item $it") },
+                colors = ChipDefaults.secondaryChipColors(),
+            )
+        }
+    }
+}
+
+@Sampled
+@Composable
+fun SimpleScalingLazyColumnWithContentPadding() {
+    ScalingLazyColumn(
+        modifier = Modifier.fillMaxWidth(),
+        contentPadding = PaddingValues(top = 20.dp, bottom = 20.dp),
+        autoCentering = null,
+    ) {
+        item { ListHeader { Text(text = "List Header") } }
+        items(20) {
+            Chip(
+                onClick = {},
+                label = { Text("List item $it") },
+                colors = ChipDefaults.secondaryChipColors(),
+            )
+        }
+    }
+}
+```

package/skills/android-wear-compose-m3/references/foundation/SwipeToDismissBoxSample.kt.md

@@ -0,0 +1,169 @@
+```
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.wear.compose.foundation.samples
+
+import androidx.annotation.Sampled
+import androidx.compose.foundation.background
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.saveable.rememberSaveableStateHolder
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.wear.compose.foundation.BasicSwipeToDismissBox
+import androidx.wear.compose.foundation.SwipeToDismissValue
+import androidx.wear.compose.foundation.edgeSwipeToDismiss
+import androidx.wear.compose.foundation.rememberSwipeToDismissBoxState
+import androidx.wear.compose.material.Icon
+import androidx.wear.compose.material.MaterialTheme
+import androidx.wear.compose.material.SplitToggleChip
+import androidx.wear.compose.material.Text
+import androidx.wear.compose.material.ToggleChipDefaults
+
+@Sampled
+@Composable
+fun SimpleSwipeToDismissBox(navigateBack: () -> Unit) {
+    val state = rememberSwipeToDismissBoxState()
+    BasicSwipeToDismissBox(state = state, onDismissed = navigateBack) { isBackground ->
+        if (isBackground) {
+            Box(modifier = Modifier.fillMaxSize().background(MaterialTheme.colors.secondaryVariant))
+        } else {
+            Column(
+                modifier = Modifier.fillMaxSize().background(MaterialTheme.colors.primary),
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.Center,
+            ) {
+                Text("Swipe right to dismiss", color = MaterialTheme.colors.onPrimary)
+            }
+        }
+    }
+}
+
+@Sampled
+@Composable
+fun StatefulSwipeToDismissBox() {
+    // State for managing a 2-level navigation hierarchy between
+    // MainScreen and ItemScreen composables.
+    // Alternatively, use SwipeDismissableNavHost from wear.compose.navigation.
+    var showMainScreen by remember { mutableStateOf(true) }
+    val saveableStateHolder = rememberSaveableStateHolder()
+
+    // Swipe gesture dismisses ItemScreen to return to MainScreen.
+    val state = rememberSwipeToDismissBoxState()
+    LaunchedEffect(state.currentValue) {
+        if (state.currentValue == SwipeToDismissValue.Dismissed) {
+            state.snapTo(SwipeToDismissValue.Default)
+            showMainScreen = !showMainScreen
+        }
+    }
+
+    // Hierarchy is ListScreen -> ItemScreen, so we show ListScreen as the background behind
+    // the ItemScreen, otherwise there's no background to show.
+    BasicSwipeToDismissBox(
+        state = state,
+        userSwipeEnabled = !showMainScreen,
+        backgroundKey = if (!showMainScreen) "MainKey" else "Background",
+        contentKey = if (showMainScreen) "MainKey" else "ItemKey",
+    ) { isBackground ->
+        if (isBackground || showMainScreen) {
+            // Best practice would be to use State Hoisting and leave this composable stateless.
+            // Here, we want to support MainScreen being shown from different destinations
+            // (either in the foreground or in the background during swiping) - that can be achieved
+            // using SaveableStateHolder and rememberSaveable as shown below.
+            saveableStateHolder.SaveableStateProvider(
+                key = "MainKey",
+                content = {
+                    // Composable that maintains its own state
+                    // and can be shown in foreground or background.
+                    val checked = rememberSaveable { mutableStateOf(true) }
+                    Column(
+                        modifier =
+                            Modifier.fillMaxSize().padding(horizontal = 8.dp, vertical = 8.dp),
+                        verticalArrangement =
+                            Arrangement.spacedBy(4.dp, Alignment.CenterVertically),
+                    ) {
+                        SplitToggleChip(
+                            checked = checked.value,
+                            label = { Text("Item details") },
+                            modifier = Modifier.height(40.dp),
+                            onCheckedChange = { v -> checked.value = v },
+                            onClick = { showMainScreen = false },
+                            toggleControl = {
+                                Icon(
+                                    imageVector =
+                                        ToggleChipDefaults.checkboxIcon(checked = checked.value),
+                                    contentDescription = null,
+                                )
+                            },
+                        )
+                    }
+                },
+            )
+        } else {
+            Column(
+                modifier = Modifier.fillMaxSize().background(MaterialTheme.colors.primary),
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.Center,
+            ) {
+                Text("Show details here...", color = MaterialTheme.colors.onPrimary)
+                Text("Swipe right to dismiss", color = MaterialTheme.colors.onPrimary)
+            }
+        }
+    }
+}
+
+@Sampled
+@Composable
+fun EdgeSwipeForSwipeToDismiss(navigateBack: () -> Unit) {
+    val state = rememberSwipeToDismissBoxState()
+
+    // When using Modifier.edgeSwipeToDismiss, it is required that the element on which the
+    // modifier applies exists within a SwipeToDismissBox which shares the same state.
+    BasicSwipeToDismissBox(state = state, onDismissed = navigateBack) { isBackground ->
+        val horizontalScrollState = rememberScrollState(0)
+        if (isBackground) {
+            Box(modifier = Modifier.fillMaxSize().background(MaterialTheme.colors.secondaryVariant))
+        } else {
+            Box(modifier = Modifier.fillMaxSize()) {
+                Text(
+                    modifier =
+                        Modifier.align(Alignment.Center)
+                            .edgeSwipeToDismiss(state)
+                            .horizontalScroll(horizontalScrollState),
+                    text =
+                        "This text can be scrolled horizontally - to dismiss, swipe " +
+                            "right from the left edge of the screen (called Edge Swiping)",
+                )
+            }
+        }
+    }
+}
+```