Scaffold(
    topBar = {
        Surface(shadowElevation = 4.dp) {
            CenterAlignedTopAppBar(
                title = { Text("hoge") },
            )
        }
    },
)

CenterAlignedTopAppBar(
    title = { Text("hoge") },
    Modifier.shadow(4.dp)
)

Scaffold(
    Modifier.fillMaxSize(),
    bottomBar = {
        Row(Modifier.fillMaxWidth().height(80.dp).background(Color.Cyan)) {}
    },
    containerColor = Color.Red
) { innerPadding ->
    val title = "test"
    val layoutDirection = LocalLayoutDirection.current
    Scaffold(
        Modifier.padding(
            start = innerPadding.calculateLeftPadding(layoutDirection),
            end = innerPadding.calculateRightPadding(layoutDirection),
            bottom = innerPadding.calculateBottomPadding()
        ),
        topBar = {
            CenterAlignedTopAppBar(
                title = { Text(title) },
                colors = TopAppBarDefaults.topAppBarColors().copy(containerColor = Color.Magenta)
            )
        },
        containerColor = Color.Green
    ) { innerPadding ->
        val topPadding = innerPadding.calculateTopPadding()
        Column(
            Modifier.fillMaxSize().padding(top = topPadding),
        ) {
            Text(title)
            Column(
                Modifier.fillMaxSize(),
                verticalArrangement = Arrangement.Bottom
            ) {
                Text(title)
            }
        }
    }
}

Scaffold(
    Modifier.fillMaxSize(),
    bottomBar = {
        Row(Modifier.fillMaxWidth().height(80.dp).background(Color.Cyan)) {}
    },
    containerColor = Color.Red
) { innerPadding ->
    val title = "test"
    Scaffold(
        Modifier.padding(innerPadding),
        topBar = {
            CenterAlignedTopAppBar(
                title = { Text(title) },
                colors = TopAppBarDefaults.topAppBarColors().copy(containerColor = Color.Magenta)
            )
        },
        containerColor = Color.Green
    ) { innerPadding ->
        Column(
            Modifier.fillMaxSize().padding(innerPadding),
        ) {
            Text(title)
            Column(
                Modifier.fillMaxSize(),
                verticalArrangement = Arrangement.Bottom
            ) {
                Text(title)
            }
        }
    }
}

Scaffold(
    Modifier.fillMaxSize(),
    bottomBar = {
        Row(Modifier.fillMaxWidth().height(80.dp).background(Color.Cyan)) {}
    },
    containerColor = Color.Red
) { innerPadding ->
    val title = "test"
    Scaffold(
        Modifier.padding(innerPadding),
        topBar = {
            CenterAlignedTopAppBar(
                title = { Text(title) },
                colors = TopAppBarDefaults.topAppBarColors().copy(containerColor = Color.Magenta)
            )
        },
        containerColor = Color.Green
    ) { innerPadding ->
        val topPadding = innerPadding.calculateTopPadding()
        Column(
            Modifier.fillMaxSize().padding(top = topPadding),
        ) {
            Text(title)
            Column(
                Modifier.fillMaxSize(),
                verticalArrangement = Arrangement.Bottom
            ) {
                Text(title)
            }
        }
    }
}

@DevicePreviews
@Composable
fun ForYouScreenPopulatedAndLoading(...)

/**
 * Multipreview annotation that represents various device sizes. Add this annotation to a composable
 * to render various devices.
 */
@Preview(name = "phone", device = "spec:shape=Normal,width=360,height=640,unit=dp,dpi=480")
@Preview(name = "landscape", device = "spec:shape=Normal,width=640,height=360,unit=dp,dpi=480")
@Preview(name = "foldable", device = "spec:shape=Normal,width=673,height=841,unit=dp,dpi=480")
@Preview(name = "tablet", device = "spec:shape=Normal,width=1280,height=800,unit=dp,dpi=480")
annotation class DevicePreviews

class HogeViewModel {
    private val _uiState = MutableStateFlow(UiState())
    val uiState = _uiState.asStateFlow()
    
    data class UiState(
        val isLoading: Boolean = false,
        val text: String = "huga"
    )

    init {
        _uiState.update(...)
    }
}

fun HogeView(vm: ViewModel) {
    val uiState by viewModel.uiState.collectAsState()
    ...
}

sealed interface OnboardingUiState {
    /**
     * The onboarding state is loading.
     */
    data object Loading : OnboardingUiState
    /**
     * The onboarding state was unable to load.
     */
    data object LoadFailed : OnboardingUiState

    /**
     * There is no onboarding state.
     */
    data object NotShown : OnboardingUiState

    /**
     * There is a onboarding state, with the given lists of topics.
     */
    data class Shown(
        val topics: List<FollowableTopic>,
    ) : OnboardingUiState {
        /**
         * True if the onboarding can be dismissed.
         */
        val isDismissable: Boolean get() = topics.any { it.isFollowed }
    }
}

class ForYouViewModel(...) {
    val onboardingUiState: StateFlow<OnboardingUiState> =
        combine(
            shouldShowOnboarding,
            getFollowableTopics(),
        ) { shouldShowOnboarding, topics ->
            if (shouldShowOnboarding) {
                OnboardingUiState.Shown(topics = topics)
            } else {
                OnboardingUiState.NotShown
            }
        }
            .stateIn(
                scope = viewModelScope,
                started = SharingStarted.WhileSubscribed(5_000),
                initialValue = OnboardingUiState.Loading,
            )

}

internal fun ForYouScreen(...) {
    val onboardingUiState by viewModel.onboardingUiState.collectAsStateWithLifecycle()
    ForYouScreen(onboardingUiState)
}

internal fun ForYouScreen(
    onboardingUiState: OnboardingUiState
) {
    val isOnboardingLoading = onboardingUiState is OnboardingUiState.Loading

    LazyVerticalStaggeredGrid(...) {
        onboarding(
            onboardingUiState = onboardingUiState,
            ...
    }
}

private fun LazyStaggeredGridScope.onboarding(
    onboardingUiState: OnboardingUiState
) {
    when (onboardingUiState) {
        OnboardingUiState.Loading,
        OnboardingUiState.LoadFailed,
        OnboardingUiState.NotShown,
        -> Unit

        is OnboardingUiState.Shown -> {
        ...
}

<uses-permission android:name="android.permission.VIBRATE"/>

// ボタンやキーのフィードバックの場合はperformHapticFeedbackで実装がよい
val view = LocalView.current
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
    view.performHapticFeedback(HapticFeedbackConstants.CONFIRM)
}

// ワンショット
val context = LocalContext.current
//val vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
val vibrator = context.getSystemService(Vibrator::class.java)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    val vibrationEffect = VibrationEffect.createOneShot(100, DEFAULT_AMPLITUDE)
    vibrator.vibrate(vibrationEffect)
} else {
     vibrator.vibrate(100)
}

// VibratorManager
@SuppressLint("ServiceCast")
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
    val vibratorManager = context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
    // 100ms振動 / 100ms止める, 振動強度 0 - 255, 繰り返さない/繰り返す -1 / 0 配列の長さまで指定可能
    val vibrationEffect = VibrationEffect.createWaveform(longArrayOf(100L, 100L), intArrayOf(200, 0), -1)
    val combinedVibration = CombinedVibration.createParallel(vibrationEffect)
    vibratorManager.vibrate(combinedVibration)
}

@Composable
fun Screen(modifier: Modifier = Modifier) {
    Column(
        modifier.fillMaxSize().padding(44.dp),
        verticalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        Content1("1234567890")
        // TextがfillWidthになってbuttonが画面外に...
        Content1("1234567890".repeat(10))

        // 違う、そうじゃない
        Content2("1234567890")
        Content2("1234567890".repeat(10))

        // Good!
        Content3("1234567890")
        Content3("1234567890".repeat(10))
    }
}

@Composable
fun Content1(text: String) {
    Row(
        horizontalArrangement = Arrangement.spacedBy(8.dp),
        verticalAlignment = Alignment.CenterVertically,
    ) {
        Text(
            text,
            maxLines = 1,
            overflow = TextOverflow.Ellipsis
        )
        Button(onClick = {}) {
            Text("ok")
        }
    }
}

@Composable
fun Content2(text: String) {
    Row(
        horizontalArrangement = Arrangement.spacedBy(8.dp),
        verticalAlignment = Alignment.CenterVertically,
    ) {
        Text(
            text,
            Modifier.weight(1f),
            maxLines = 1,
            overflow = TextOverflow.Ellipsis
        )
        Button(onClick = {}) {
            Text("ok")
        }
    }
}

@Composable
fun Content3(text: String) {
    ConstraintLayout {
        val (left, right) = createRefs()

        Text(
            text,
            Modifier.constrainAs(left) {
                start.linkTo(parent.start)
                end.linkTo(right.start, margin = 8.dp)
                width = Dimension.preferredWrapContent
                centerVerticallyTo(parent)
            },
            maxLines = 1,
            overflow = TextOverflow.Ellipsis
        )

        Button(
            onClick = {},
            Modifier.constrainAs(right) {
                end.linkTo(parent.end)
                centerVerticallyTo(parent)
            }
        ) {
            Text("ok")
        }
    }
}

[versions]
constraintlayoutCompose = "1.1.1"

[libraries]
androidx-constraintlayout-compose = { group = "androidx.constraintlayout", name = "constraintlayout-compose", version.ref = "constraintlayoutCompose" }

@Composable
fun Screen(modifier: Modifier = Modifier) {
    var expanded by remember { mutableStateOf(false) }

    Column(
        modifier.padding(44.dp),
    ) {
        ElevatedCard(
            onClick = { expanded = !expanded },
            elevation = CardDefaults.cardElevation(
                defaultElevation = 8.dp
            ),
        ) {
            Column(
                Modifier
                    .animateContentSize(
                        spring(
                            stiffness = Spring.StiffnessHigh,
                            visibilityThreshold = IntSize.VisibilityThreshold
                        )
                    )
                    .fillMaxWidth()
                    .padding(horizontal = 12.dp, vertical = 8.dp),
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                Row(verticalAlignment = Alignment.CenterVertically) {
                    Text("ElevatedCard")
                    Icon(
                        Icons.Default.ArrowDropDown,
                        "",
                        Modifier
                            .then(
                                if (expanded) Modifier.rotate(180f)
                                else Modifier
                            )
                    )
                }
                if (expanded) Text("あ".repeat(100))
            }
        }
    }
}

[versions]
firebaseBom = "33.2.0"

[libraries]
firebase-bom = { group = "com.google.firebase", name = "firebase-bom", version.ref = "firebaseBom" }
firebase-analytics = { group = "com.google.firebase", name = "firebase-analytics" }
firebase-inappmessaging-display = { group = "com.google.firebase", name = "firebase-inappmessaging-display" }

dependencies {
    implementation(platform(libs.firebase.bom))
    implementation(libs.firebase.analytics)
    implementation(libs.firebase.inappmessaging.display)
}

// 表示したいタイミングでtriggerEventを呼ぶだけ
Firebase.inAppMessaging.triggerEvent("xxx")

val fbInAppMessagingClickListener = object : FirebaseInAppMessagingClickListener {
        override fun messageClicked(
            inAppMessage: InAppMessage, action: Action
        ) {
            // hoge://url?https://hoge.com/
            val url = URI(action.actionUrl).query
            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url + "?id=xxx"))
            startActivity(intent)
        }
    }
}

override fun onStart() {
    super.onStart()
    FirebaseInAppMessaging.getInstance().addClickListener(fbInAppMessagingClickListener)
}

override fun onStop() {
    super.onStop()
    FirebaseInAppMessaging.getInstance().removeClickListener(fbInAppMessagingClickListener)
}

@OptIn(ExperimentalMaterial3Api::class)
@Preview(showBackground = true)
@Composable
fun Screen(modifier: Modifier = Modifier) {
    var isRefreshing by remember { mutableStateOf(false) }
    val state = rememberPullToRefreshState()
    val scope = rememberCoroutineScope()

    PullToRefreshBox(
        isRefreshing,
        onRefresh = {
            isRefreshing = true
            scope.launch {
                delay(2_000)
                isRefreshing = false
            }
        },
        modifier = modifier,
        state = state,
        indicator = {
            Indicator(
                modifier = Modifier.align(Alignment.TopCenter),
                isRefreshing = isRefreshing,
                state = state,
                threshold = 100.dp
            )
        }
    ) {
        Column(
            Modifier
                .fillMaxSize()
                .verticalScroll(rememberScrollState()),
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            Text("PullToRefreshBox")
        }
    }
}