/*

* 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

*

* https://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 com.example.compose.snippets.sideeffects

import android.media.Image

import androidx.compose.animation.AnimatedVisibility

import androidx.compose.animation.core.Animatable

import androidx.compose.foundation.layout.Box

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.lazy.LazyColumn

import androidx.compose.foundation.lazy.rememberLazyListState

import androidx.compose.material3.Button

import androidx.compose.material3.Scaffold

import androidx.compose.material3.SnackbarHost

import androidx.compose.material3.SnackbarHostState

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.runtime.DisposableEffect

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.SideEffect

import androidx.compose.runtime.State

import androidx.compose.runtime.derivedStateOf

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableLongStateOf

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.produceState

import androidx.compose.runtime.remember

import androidx.compose.runtime.rememberCoroutineScope

import androidx.compose.runtime.rememberUpdatedState

import androidx.compose.runtime.setValue

import androidx.compose.runtime.snapshotFlow

import androidx.compose.ui.Modifier

import androidx.lifecycle.Lifecycle

import androidx.lifecycle.LifecycleEventObserver

import androidx.lifecycle.LifecycleOwner

import androidx.lifecycle.compose.LocalLifecycleOwner

import com.example.compose.snippets.interop.FirebaseAnalytics

import com.example.compose.snippets.interop.User

import com.example.compose.snippets.kotlin.Message

import kotlinx.coroutines.delay

import kotlinx.coroutines.flow.distinctUntilChanged

import kotlinx.coroutines.flow.filter

import kotlinx.coroutines.flow.map

import kotlinx.coroutines.isActive

import kotlinx.coroutines.launch

@Composable

fun MyScreen() {

// [START android_compose_side_effects_launchedeffect]

// Allow the pulse rate to be configured, so it can be sped up if the user is running

// out of time

var pulseRateMs by remember { mutableLongStateOf(3000L) }

val alpha = remember { Animatable(1f) }

LaunchedEffect(pulseRateMs) { // Restart the effect when the pulse rate changes

while (isActive) {

delay(pulseRateMs) // Pulse the alpha every pulseRateMs to alert the user

alpha.animateTo(0f)

alpha.animateTo(1f)

}

}

// [END android_compose_side_effects_launchedeffect]

}

// [START_EXCLUDE silent]

class Movie {

val url = ""

val id = ""

}

// [END_EXCLUDE]

// [START android_compose_side_effects_remembercoroutinescope]

@Composable

fun MoviesScreen(snackbarHostState: SnackbarHostState) {

// Creates a CoroutineScope bound to the MoviesScreen's lifecycle

val scope = rememberCoroutineScope()

Scaffold(

snackbarHost = {

SnackbarHost(hostState = snackbarHostState)

}

) { contentPadding ->

Column(Modifier.padding(contentPadding)) {

Button(

onClick = {

// Create a new coroutine in the event handler to show a snackbar

scope.launch {

snackbarHostState.showSnackbar("Something happened!")

}

}

) {

Text("Press me")

}

}

}

}

// [END android_compose_side_effects_remembercoroutinescope]

// [START android_compose_side_effects_rememberupdatedstate]

@Composable

fun LandingScreen(onTimeout: () -> Unit) {

// This will always refer to the latest onTimeout function that

// LandingScreen was recomposed with

val currentOnTimeout by rememberUpdatedState(onTimeout)

// Create an effect that matches the lifecycle of LandingScreen.

// If LandingScreen recomposes, the delay shouldn't start again.

LaunchedEffect(true) {

delay(SplashWaitTimeMillis)

currentOnTimeout()

}

/* Landing screen content */

}

// [START_EXCLUDE silent]

private const val SplashWaitTimeMillis = 1000L

// [END_EXCLUDE]

// [END android_compose_side_effects_rememberupdatedstate]

// [START android_compose_side_effects_disposableeffect]

@Composable

fun HomeScreen(

lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,

onStart: () -> Unit, // Send the 'started' analytics event

onStop: () -> Unit // Send the 'stopped' analytics event

) {

// Safely update the current lambdas when a new one is provided

val currentOnStart by rememberUpdatedState(onStart)

val currentOnStop by rememberUpdatedState(onStop)

// If `lifecycleOwner` changes, dispose and reset the effect

DisposableEffect(lifecycleOwner) {

// Create an observer that triggers our remembered callbacks

// for sending analytics events

val observer = LifecycleEventObserver { _, event ->

if (event == Lifecycle.Event.ON_START) {

currentOnStart()

} else if (event == Lifecycle.Event.ON_STOP) {

currentOnStop()

}

}

// Add the observer to the lifecycle

lifecycleOwner.lifecycle.addObserver(observer)

// When the effect leaves the Composition, remove the observer

onDispose {

lifecycleOwner.lifecycle.removeObserver(observer)

}

}

/* Home screen content */

}

// [END android_compose_side_effects_disposableeffect]

// [START android_compose_side_effects_sideeffect]

@Composable

fun rememberFirebaseAnalytics(user: User): FirebaseAnalytics {

val analytics: FirebaseAnalytics = remember {

FirebaseAnalytics()

}

// On every successful composition, update FirebaseAnalytics with

// the userType from the current User, ensuring that future analytics

// events have this metadata attached

SideEffect {

analytics.setUserProperty("userType", user.userType)

}

return analytics

}

// [END android_compose_side_effects_sideeffect]

// b/368420773

@Suppress("ProduceStateDoesNotAssignValue")

// [START android_compose_side_effects_producestate]

@Composable

fun loadNetworkImage(

url: String,

imageRepository: ImageRepository = ImageRepository()

): State<Result<Image>> {

// Creates a State<T> with Result.Loading as initial value

// If either `url` or `imageRepository` changes, the running producer

// will cancel and will be re-launched with the new inputs.

return produceState<Result<Image>>(initialValue = Result.Loading, url, imageRepository) {

// In a coroutine, can make suspend calls

val image = imageRepository.load(url)

// Update State with either an Error or Success result.

// This will trigger a recomposition where this State is read

value = if (image == null) {

Result.Error

} else {

Result.Success(image)

}

}

}

// [START_EXCLUDE silent]

class ImageRepository {

fun load(url: String): Image? { return null }

}

sealed class Result<out T> {

object Loading : Result<Nothing>()

object Error : Result<Nothing>()

class Success<T>(t: T?) : Result<T>()

}

// [END_EXCLUDE]

// [END android_compose_side_effects_producestate]

// [START android_compose_side_effects_derivedstateof]

@Composable

// When the messages parameter changes, the MessageList

// composable recomposes. derivedStateOf does not

// affect this recomposition.

fun MessageList(messages: List<Message>) {

Box {

val listState = rememberLazyListState()

LazyColumn(state = listState) {

// ...

}

// Show the button if the first visible item is past

// the first item. We use a remembered derived state to

// minimize unnecessary compositions

val showButton by remember {

derivedStateOf {

listState.firstVisibleItemIndex > 0

}

}

AnimatedVisibility(visible = showButton) {

ScrollToTopButton()

}

}

}

// [END android_compose_side_effects_derivedstateof]

@Composable

fun ScrollToTopButton() {

// Button to scroll to the top of list.

}

@Suppress("CanBeVal")

@Composable

fun DerivedStateOfWrongUsage() {

// [START android_compose_side_effects_derivedstateof_wrong]

// DO NOT USE. Incorrect usage of derivedStateOf.

var firstName by remember { mutableStateOf("") }

var lastName by remember { mutableStateOf("") }

val fullNameBad by remember { derivedStateOf { "$firstName $lastName" } } // This is bad!!!

val fullNameCorrect = "$firstName $lastName" // This is correct

// [END android_compose_side_effects_derivedstateof_wrong]

}

@Composable

private fun SnapshotFlowExample() {

// [START android_compose_side_effects_snapshotflow]

val listState = rememberLazyListState()

LazyColumn(state = listState) {

// ...

}

LaunchedEffect(listState) {

snapshotFlow { listState.firstVisibleItemIndex }

.map { index -> index > 0 }

.distinctUntilChanged()

.filter { it == true }

.collect {

MyAnalyticsService.sendScrolledPastFirstItemEvent()

}

}

// [END android_compose_side_effects_snapshotflow]

}

private object MyAnalyticsService {

fun sendScrolledPastFirstItemEvent() {}

}

private object RestartingEffectsSnippet {

// [START android_compose_side_effects_restarting_effects]

@Composable

fun HomeScreen(

lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,

onStart: () -> Unit, // Send the 'started' analytics event

onStop: () -> Unit // Send the 'stopped' analytics event

) {

// These values never change in Composition

val currentOnStart by rememberUpdatedState(onStart)

val currentOnStop by rememberUpdatedState(onStop)

DisposableEffect(lifecycleOwner) {

val observer = LifecycleEventObserver { _, event ->

/* ... */

}

lifecycleOwner.lifecycle.addObserver(observer)

onDispose {

lifecycleOwner.lifecycle.removeObserver(observer)

}

}

}

// [END android_compose_side_effects_restarting_effects]

}