content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.kristianskokars.catnexus.core.domain.repository
interface ImageSharer {
fun shareImage(url: String)
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/domain/repository/ImageSharer.kt | 763682257 |
package com.kristianskokars.catnexus.core.domain.repository
import android.net.Uri
import com.kristianskokars.catnexus.lib.Result
interface ImageDownloader {
suspend fun downloadImage(url: String, fileName: String): Result<Unit, Uri>
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/domain/repository/ImageDownloader.kt | 3610334157 |
package com.kristianskokars.catnexus.core.domain
import androidx.datastore.core.DataStore
import com.kristianskokars.catnexus.R
import com.kristianskokars.catnexus.core.domain.model.UserSettings
import com.kristianskokars.catnexus.lib.ToastMessage
import com.kristianskokars.catnexus.lib.Toaster
import com.kristianskokars.catnexus.lib.UIText
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class CarModeHandler @Inject constructor(
private val store: DataStore<UserSettings>,
private val toaster: Toaster,
) {
private val scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
private var timeoutJob: Job? = null
private var clicks = 0
val isInCarMode = store.data.map { it.isInCarMode }.stateIn(scope, SharingStarted.WhileSubscribed(), false)
suspend fun onCatNexusLogoClick() {
if (store.data.first().isCarModeUnlocked) return
timeoutJob?.cancel()
timeoutJob = scope.launch {
clicks++
if (clicks == 5) {
unlockCarMode()
return@launch
}
delay(2000)
clicks = 0
}
}
private suspend fun unlockCarMode() {
store.updateData { data ->
data.copy(isCarModeUnlocked = true)
}
toaster.show(ToastMessage(UIText.StringResource(R.string.unlocked_car_mode)))
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/domain/CarModeHandler.kt | 1802416855 |
package com.kristianskokars.catnexus.core.domain.model
import kotlinx.serialization.Serializable
@Serializable
data class UserSettings(
val swipeDirection: CatSwipeDirection = CatSwipeDirection.HORIZONTAL,
val showDownloadNotifications: Boolean = true,
val isCarModeUnlocked: Boolean = false,
val isInCarMode: Boolean = false,
)
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/domain/model/UserSettings.kt | 2139922867 |
package com.kristianskokars.catnexus.core.domain.model
enum class CatSwipeDirection {
VERTICAL, HORIZONTAL;
fun flip(): CatSwipeDirection = when (this) {
VERTICAL -> HORIZONTAL
HORIZONTAL -> VERTICAL
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/domain/model/CatSwipeDirection.kt | 3745584836 |
package com.kristianskokars.catnexus.core.domain.model
data object ServerError
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/domain/model/ServerError.kt | 1784059721 |
package com.kristianskokars.catnexus.core.domain.model
import android.os.Parcelable
import kotlinx.parcelize.Parcelize
@Parcelize
data class Cat(
val id: String,
val url: String,
val name: String?,
val fetchedDateInMillis: Long,
val isFavourited: Boolean = false,
) : Parcelable
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/domain/model/Cat.kt | 3011863053 |
package com.kristianskokars.catnexus.core.presentation
import android.annotation.SuppressLint
import androidx.compose.foundation.lazy.grid.LazyGridState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.rememberCoroutineScope
import com.ramcosta.composedestinations.result.NavResult
import com.ramcosta.composedestinations.result.ResultRecipient
import com.ramcosta.composedestinations.spec.DestinationSpec
import kotlinx.coroutines.launch
@SuppressLint("ComposableNaming")
@Composable
fun <T : DestinationSpec<*>> ResultRecipient<T, Int>.scrollToReturnedItemIndex(
lazyGridState: LazyGridState,
scrollOffset: Int = -240,
) {
val scope = rememberCoroutineScope()
onNavResult { result ->
when (result) {
is NavResult.Canceled -> { /* Ignored */ }
is NavResult.Value -> {
// We put an offset to ensure the scrolled to item is not hidden behind the top bar
// TODO: make it take the same size as an item actually is
scope.launch {
if (isItemVisible(result.value, lazyGridState)) return@launch
lazyGridState.scrollToItem(result.value, scrollOffset = scrollOffset)
}
}
}
}
}
private fun isItemVisible(itemIndex: Int, lazyGridState: LazyGridState) =
itemIndex > lazyGridState.firstVisibleItemIndex && itemIndex < lazyGridState.layoutInfo.visibleItemsInfo.last().index
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/ScrollToReturnedItem.kt | 2991181506 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.safeContentPadding
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material3.SnackbarData
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.kristianskokars.catnexus.core.presentation.theme.Black
import com.kristianskokars.catnexus.core.presentation.theme.Gray
import com.kristianskokars.catnexus.core.presentation.theme.Inter
@Composable
fun BelowTopBarDownloadToast(
modifier: Modifier = Modifier,
hostState: SnackbarHostState
) {
ToastHost(hostState = hostState) { data ->
Box(
modifier = modifier
.fillMaxSize()
.safeContentPadding()
.padding(top = 36.dp)
) {
Toast(
modifier = Modifier.align(Alignment.TopCenter),
data = data,
)
}
}
}
@Composable
private fun Toast(
modifier: Modifier = Modifier,
data: SnackbarData,
) {
Row(
modifier = modifier
.padding(vertical = 24.dp, horizontal = 36.dp)
.background(Black, CircleShape)
.border(
Dp.Hairline,
Gray.copy(alpha = 0.7f),
CircleShape
)
.padding(8.dp),
horizontalArrangement = Arrangement.Center,
verticalAlignment = Alignment.CenterVertically,
) {
// TODO: add way to add custom icons
// Icon(
// modifier = Modifier.size(20.dp),
// painter = painterResource(id = R.drawable.ic_download),
// contentDescription = null,
// tint = Color.White,
// )
// Spacer(modifier = Modifier.size(6.dp))
Text(
fontFamily = Inter,
fontSize = 12.sp,
text = data.visuals.message
)
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/Toast.kt | 3960230929 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import com.kristianskokars.catnexus.core.presentation.theme.SimpleCatAppTheme
@Composable
fun BackgroundSurface(
block: @Composable () -> Unit
) {
SimpleCatAppTheme {
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background,
) {
block()
}
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/BackgroundSurface.kt | 4076471490 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.material3.HorizontalDivider
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import com.kristianskokars.catnexus.core.presentation.theme.Gray
@Composable
fun CatNexusDivider(modifier: Modifier = Modifier) {
HorizontalDivider(modifier = modifier, color = Gray.copy(0.2f))
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/CatNexusDivider.kt | 1754027606 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.GridItemSpan
import androidx.compose.foundation.lazy.grid.LazyGridState
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.itemsIndexed
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.kristianskokars.catnexus.core.domain.model.Cat
private fun LazyGridState.isScrolledToEnd() = layoutInfo.visibleItemsInfo.lastOrNull()?.index == layoutInfo.totalItemsCount - 1
@Composable
fun CatGrid(
modifier: Modifier = Modifier,
cats: List<Cat>,
onCatClick: (index: Int) -> Unit,
state: LazyGridState,
topContentPadding: PaddingValues,
bottomSlot: @Composable () -> Unit = {},
onScrolledToBottom: () -> Unit = {}
) {
val currentOnScrolledToBottom by rememberUpdatedState(onScrolledToBottom)
val endOfListReached by remember {
derivedStateOf {
state.isScrolledToEnd()
}
}
LaunchedEffect(endOfListReached) {
if (!endOfListReached) return@LaunchedEffect
currentOnScrolledToBottom()
}
LazyVerticalGrid(
modifier = modifier.fillMaxSize(),
state = state,
columns = GridCells.Fixed(3),
) {
item(span = { GridItemSpan(3)}) {
Box(modifier = Modifier.padding(topContentPadding))
}
itemsIndexed(cats, key = { _, cat -> cat.id }) { index, cat ->
CatCard(
modifier = Modifier
.size(124.dp)
.clickable { onCatClick(index) },
cat = cat,
)
}
item(span = { GridItemSpan(3) }) {
bottomSlot()
}
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/CatGrid.kt | 976216901 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.foundation.layout.Column
import androidx.compose.material.ripple.LocalRippleTheme
import androidx.compose.material.ripple.RippleAlpha
import androidx.compose.material.ripple.RippleTheme
import androidx.compose.material3.Icon
import androidx.compose.material3.NavigationBar
import androidx.compose.material3.NavigationBarItem
import androidx.compose.material3.NavigationBarItemDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import com.kristianskokars.catnexus.R
import com.kristianskokars.catnexus.core.presentation.theme.Black
import com.kristianskokars.catnexus.core.presentation.theme.Inter
import com.kristianskokars.catnexus.core.presentation.theme.Orange
import dev.chrisbanes.haze.HazeState
import dev.chrisbanes.haze.hazeChild
enum class BottomBarDestination {
HOME, FAVOURITES
}
@Composable
fun CatNexusBottomBar(
modifier: Modifier = Modifier,
hazeState: HazeState,
currentDestination: BottomBarDestination,
onHomeClick: () -> Unit,
onFavouritesClick: () -> Unit,
) {
Column(modifier = modifier) {
CatNexusDivider()
NavigationBar(
modifier = Modifier.hazeChild(hazeState),
containerColor = Black,
tonalElevation = 0.dp
) {
val bottomBarColors = NavigationBarItemDefaults.colors(
selectedIconColor = Orange,
selectedTextColor = Orange,
unselectedTextColor = Color.White,
indicatorColor = Color.Transparent
)
CompositionLocalProvider(LocalRippleTheme provides NoRippleTheme) {
NavigationBarItem(
colors = bottomBarColors,
selected = currentDestination == BottomBarDestination.HOME,
onClick = onHomeClick,
icon = {
Icon(
painter = painterResource(id = R.drawable.ic_home),
contentDescription = null
)
},
label = { Text(text = stringResource(R.string.home), fontFamily = Inter) }
)
NavigationBarItem(
colors = bottomBarColors,
selected = currentDestination == BottomBarDestination.FAVOURITES,
onClick = onFavouritesClick,
icon = {
Icon(
painter = painterResource(id = R.drawable.ic_favourite),
contentDescription = null
)
},
label = { Text(text = stringResource(R.string.favourites), fontFamily = Inter) }
)
}
}
}
}
private object NoRippleTheme : RippleTheme {
@Composable
override fun defaultColor() = Color.Unspecified
@Composable
override fun rippleAlpha(): RippleAlpha = RippleAlpha(0.0f, 0.0f, 0.0f, 0.0f)
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/CatNexusBottomBar.kt | 869964458 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
@Composable
fun MessageCard(content: @Composable () -> Unit) {
Row(
modifier = Modifier
.padding(vertical = 12.dp)
.fillMaxWidth(),
horizontalArrangement = Arrangement.Center,
verticalAlignment = Alignment.CenterVertically
) {
content()
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/MessageCard.kt | 1550498799 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.foundation.clickable
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.kristianskokars.catnexus.R
import com.kristianskokars.catnexus.core.presentation.theme.Orange
import com.kristianskokars.catnexus.feature.destinations.SettingsScreenDestination
import com.ramcosta.composedestinations.navigation.DestinationsNavigator
import dev.chrisbanes.haze.HazeState
import dev.chrisbanes.haze.hazeChild
@Composable
fun CatNexusDefaultTopBar(
hazeState: HazeState,
isBorderVisible: Boolean,
isInCarMode: Boolean,
onCatNexusLogoClick: () -> Unit,
navigator: DestinationsNavigator,
) {
CatNexusTopBarLayout(hazeState = hazeState, isBorderVisible = isBorderVisible) {
Row(
modifier = Modifier.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
modifier = Modifier.clickable(
interactionSource = remember { MutableInteractionSource() },
indication = null,
onClick = onCatNexusLogoClick,
),
painter = if (isInCarMode) painterResource(id = R.drawable.ic_car) else painterResource(id = R.drawable.ic_cat_large),
contentDescription = null,
tint = Orange,
)
Text(
modifier = Modifier.padding(8.dp),
text = if (isInCarMode) stringResource(R.string.car_nexus) else stringResource(R.string.cat_infinity),
fontSize = 24.sp,
)
Spacer(modifier = Modifier.weight(1f))
IconButton(
modifier = Modifier.padding(end = 8.dp),
onClick = { navigator.navigate(SettingsScreenDestination) }
) {
Icon(
painter = painterResource(id = R.drawable.ic_settings),
contentDescription = stringResource(R.string.open_settings),
tint = Color.White
)
}
}
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun CatNexusTopBarLayout(
hazeState: HazeState,
isBorderVisible: Boolean,
content: @Composable () -> Unit,
) {
Column(modifier = Modifier.fillMaxWidth()) {
TopAppBar(
modifier = Modifier
.hazeChild(state = hazeState)
.fillMaxWidth(),
colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Transparent),
title = { content() }
)
AnimatedVisibility(visible = isBorderVisible) {
CatNexusDivider()
}
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/CatNexusTopBar.kt | 2655936350 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.foundation.layout.size
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.kristianskokars.catnexus.core.presentation.theme.Orange
@Composable
fun LoadingSpinner(modifier: Modifier = Modifier) {
CircularProgressIndicator(
modifier = modifier.size(48.dp),
color = Orange,
)
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/LoadingSpinner.kt | 553189683 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import coil.compose.AsyncImage
import coil.request.ImageRequest
import com.kristianskokars.catnexus.core.domain.model.Cat
import com.kristianskokars.catnexus.core.presentation.theme.DarkGray
@Composable
fun CatCard(
modifier: Modifier = Modifier,
cat: Cat,
) {
Card(
modifier = modifier.padding(8.dp),
colors = CardDefaults.cardColors(containerColor = DarkGray)
) {
AsyncImage(
modifier = Modifier.fillMaxSize(),
model = ImageRequest.Builder(LocalContext.current)
.data(cat.url)
.crossfade(true)
.build(),
contentScale = ContentScale.Crop,
contentDescription = "Picture of Cat ${cat.name ?: "with ID of ${cat.id}"}",
)
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/CatCard.kt | 3309638291 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.AnimationSpec
import androidx.compose.animation.core.FastOutSlowInEasing
import androidx.compose.animation.core.LinearEasing
import androidx.compose.animation.core.tween
import androidx.compose.foundation.layout.Box
import androidx.compose.material3.SnackbarData
import androidx.compose.material3.SnackbarDuration
import androidx.compose.material3.SnackbarHostState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.RecomposeScope
import androidx.compose.runtime.State
import androidx.compose.runtime.currentRecomposeScope
import androidx.compose.runtime.key
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.platform.AccessibilityManager
import androidx.compose.ui.platform.LocalAccessibilityManager
import androidx.compose.ui.semantics.LiveRegionMode
import androidx.compose.ui.semantics.dismiss
import androidx.compose.ui.semantics.liveRegion
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.util.fastFilterNotNull
import androidx.compose.ui.util.fastForEach
import androidx.compose.ui.util.fastMap
import androidx.compose.ui.util.fastMapTo
import kotlinx.coroutines.delay
// this is a copy of the default Material3 SnackbarHost, with a change to have the animation start from the top, instead of the bottom
@Composable
fun ToastHost(
hostState: SnackbarHostState,
modifier: Modifier = Modifier,
toast: @Composable (SnackbarData) -> Unit
) {
val currentSnackbarData = hostState.currentSnackbarData
val accessibilityManager = LocalAccessibilityManager.current
LaunchedEffect(currentSnackbarData) {
if (currentSnackbarData != null) {
val duration = currentSnackbarData.visuals.duration.toMillis(
currentSnackbarData.visuals.actionLabel != null,
accessibilityManager
)
delay(duration)
currentSnackbarData.dismiss()
}
}
FadeInFadeOutWithScale(
current = hostState.currentSnackbarData,
modifier = modifier,
content = toast
)
}
private fun SnackbarDuration.toMillis(
hasAction: Boolean,
accessibilityManager: AccessibilityManager?
): Long {
val original = when (this) {
SnackbarDuration.Indefinite -> Long.MAX_VALUE
SnackbarDuration.Long -> 10000L
SnackbarDuration.Short -> 4000L
}
if (accessibilityManager == null) {
return original
}
return accessibilityManager.calculateRecommendedTimeoutMillis(
original,
containsIcons = true,
containsText = true,
containsControls = hasAction
)
}
@Composable
private fun FadeInFadeOutWithScale(
current: SnackbarData?,
modifier: Modifier = Modifier,
content: @Composable (SnackbarData) -> Unit
) {
val state = remember { FadeInFadeOutState<SnackbarData?>() }
if (current != state.current) {
state.current = current
val keys = state.items.fastMap { it.key }.toMutableList()
if (!keys.contains(current)) {
keys.add(current)
}
state.items.clear()
keys.fastFilterNotNull().fastMapTo(state.items) { key ->
FadeInFadeOutAnimationItem(key) { children ->
val isVisible = key == current
val duration = if (isVisible) SnackbarFadeInMillis else SnackbarFadeOutMillis
val delay = SnackbarFadeOutMillis + SnackbarInBetweenDelayMillis
val animationDelay = if (isVisible && keys.fastFilterNotNull().size != 1) {
delay
} else {
0
}
val opacity = animatedOpacity(
animation = tween(
easing = LinearEasing,
delayMillis = animationDelay,
durationMillis = duration
),
visible = isVisible,
onAnimationFinish = {
if (key != state.current) {
// leave only the current in the list
state.items.removeAll { it.key == key }
state.scope?.invalidate()
}
}
)
val scale = animatedScale(
animation = tween(
easing = FastOutSlowInEasing,
delayMillis = animationDelay,
durationMillis = duration
),
visible = isVisible
)
Box(
Modifier
.graphicsLayer(
scaleX = scale.value,
scaleY = scale.value,
alpha = opacity.value
)
.semantics {
liveRegion = LiveRegionMode.Polite
dismiss { key.dismiss(); true }
}
) {
children()
}
}
}
}
Box(modifier) {
state.scope = currentRecomposeScope
state.items.fastForEach { (item, opacity) ->
key(item) {
opacity {
content(item!!)
}
}
}
}
}
private class FadeInFadeOutState<T> {
// we use Any here as something which will not be equals to the real initial value
var current: Any? = Any()
var items = mutableListOf<FadeInFadeOutAnimationItem<T>>()
var scope: RecomposeScope? = null
}
private data class FadeInFadeOutAnimationItem<T>(
val key: T,
val transition: FadeInFadeOutTransition
)
private typealias FadeInFadeOutTransition = @Composable (content: @Composable () -> Unit) -> Unit
@Composable
private fun animatedOpacity(
animation: AnimationSpec<Float>,
visible: Boolean,
onAnimationFinish: () -> Unit = {}
): State<Float> {
val alpha = remember { Animatable(if (!visible) 1f else 0f) }
LaunchedEffect(visible) {
alpha.animateTo(
if (visible) 1f else 0f,
animationSpec = animation
)
onAnimationFinish()
}
return alpha.asState()
}
@Composable
private fun animatedScale(animation: AnimationSpec<Float>, visible: Boolean): State<Float> {
val scale = remember { Animatable(if (!visible) 1f else 1.2f) }
LaunchedEffect(visible) {
scale.animateTo(
if (visible) 1f else 1.2f,
animationSpec = animation
)
}
return scale.asState()
}
private const val SnackbarFadeInMillis = 150
private const val SnackbarFadeOutMillis = 75
private const val SnackbarInBetweenDelayMillis = 0
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/ToastHost.kt | 449492349 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@Composable
fun LoadingCats() {
Column(
modifier = Modifier.fillMaxSize(),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
) {
LoadingSpinner()
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/LoadingCats.kt | 1815916772 |
package com.kristianskokars.catnexus.core.presentation.components
import androidx.compose.foundation.layout.Arrangement
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.material3.ButtonDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.kristianskokars.catnexus.R
import com.kristianskokars.catnexus.core.presentation.theme.Orange
@Composable
fun ErrorGettingCats(onRetry: () -> Unit) {
Column(
modifier = Modifier.fillMaxSize(),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
) {
Icon(painter = painterResource(id = R.drawable.ic_error), contentDescription = null, tint = Color.Red)
Spacer(modifier = Modifier.height(8.dp))
Text(text = stringResource(R.string.failed_to_fetch_cats), fontSize = 14.sp)
TextButton(onClick = onRetry, colors = ButtonDefaults.textButtonColors(contentColor = Orange)) {
Text(text = stringResource(R.string.retry), fontSize = 12.sp)
}
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/components/ErrorGettingCats.kt | 2640416228 |
package com.kristianskokars.catnexus.core.presentation.theme
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Shapes
import androidx.compose.ui.unit.dp
val Shapes = Shapes(
small = RoundedCornerShape(4.dp),
medium = RoundedCornerShape(4.dp),
large = RoundedCornerShape(0.dp)
)
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/theme/Shape.kt | 3001914025 |
package com.kristianskokars.catnexus.core.presentation.theme
import androidx.compose.ui.graphics.Color
val Orange = Color(0xFFE5760F)
val Black = Color(0xFF100F0F)
val DarkGray = Color(0xFF221F1F)
val Red = Color(0xFFE5360F)
val Gray = Color(0xFF8B8584)
val Gray600 = Color(0xFF504C4C)
val Gray900 = Color(0xFF141313)
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/theme/Color.kt | 628366442 |
package com.kristianskokars.catnexus.core.presentation.theme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable
private val DarkColorPalette = darkColorScheme(
primary = Orange,
surface = Black,
background = Black,
error = Red
)
@Composable
fun SimpleCatAppTheme(content: @Composable () -> Unit) {
val colors = DarkColorPalette
MaterialTheme(
colorScheme = colors,
typography = Typography,
shapes = Shapes,
content = content,
)
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/theme/Theme.kt | 3193090270 |
package com.kristianskokars.catnexus.core.presentation.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.Font
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
import com.kristianskokars.catnexus.R
val Inter = FontFamily(
Font(R.font.inter_regular),
Font(R.font.inter_medium, weight = FontWeight.Medium),
)
val Typography = Typography(
bodyMedium = TextStyle(
fontFamily = Inter,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
),
labelLarge = TextStyle(
fontFamily = Inter,
fontWeight = FontWeight.Medium,
fontSize = 16.sp,
)
)
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/theme/Type.kt | 3211147422 |
package com.kristianskokars.catnexus.core.presentation
import androidx.compose.ui.unit.dp
import com.kristianskokars.catnexus.core.presentation.theme.Black
import com.kristianskokars.catnexus.core.presentation.theme.Gray900
import dev.chrisbanes.haze.HazeStyle
val DefaultHazeStyle = HazeStyle(tint = Black.copy(alpha = 0.72f), blurRadius = 24.dp)
val ElevatedHazeStyle = HazeStyle(tint = Gray900.copy(alpha = 0.72f), blurRadius = 24.dp)
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/presentation/DefaultHazeStyle.kt | 3494327199 |
package com.kristianskokars.catnexus.core
const val BASE_URL = "https://api.thecatapi.com/v1/"
const val CAT_DATABASE = "cat_database"
const val CAT_TABLE_NAME = "cats"
const val NETWORK_TIMEOUT = 25L
const val CHANNEL_NAME = "Cat Nexus"
const val CHANNEL_DESCRIPTION = "Cat Nexus Downloading Picture Notifications"
const val CHANNEL_ID = "CatsNexus"
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/core/Constants.kt | 2259153967 |
package com.kristianskokars.catnexus.lib
/**
* Type for representing a Success without returning data.
*/
typealias Success = Unit
/**
* Result class for encapsulating operation success or errors, allowing exceptions to be
* handled explicitly from the method signature.
*
* The [E] type represents the [Err] data, the [S] type represents the [Ok] data. One can use
* the [Success] typealias if there is no specific data to be returned.
*
* It is functionally similar to Arrow's Either class.
* @param E The error data type.
* @param S The success data type.
*/
sealed class Result<out E, out S> {
/**
* Gets the [Err] error value or null if there isn't an error.
*/
fun failure() = when (this) {
is Err -> value
else -> null
}
/**
* Handles the result from a Response type, allowing to handle both the Right and Left.
*/
inline fun <T> handle(onSuccess: (S) -> T, onError: (E) -> T): T = when (this) {
is Err -> onError(value)
is Ok -> onSuccess(value)
}
}
/**
* A [E] response, indicating an error.
*
* @param E Error type in a [Result].
* @property value Error data in a [Result].
*/
class Err<out E>(val value: E) : Result<E, Nothing>()
/**
* A [S] response, indicating success.
*
* @param S Success type in a [Result].
* @property value Success data in a [Result].
*/
class Ok<out S>(val value: S) : Result<Nothing, S>()
/**
* Default [Ok] response with a [Success] data type.
*/
fun Ok() = Ok(Success)
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/lib/Result.kt | 1423715499 |
package com.kristianskokars.catnexus.lib
import com.ramcosta.composedestinations.spec.Direction
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class Navigator @Inject constructor() {
private val _navigationActions = MutableSharedFlow<Action>(
replay = 0,
extraBufferCapacity = 1
)
val navigationActions = _navigationActions.asSharedFlow()
suspend fun navigateUp() {
_navigationActions.emit(Action.GoBack)
}
sealed class Action {
data object GoBack : Action()
data class Navigate(val direction: Direction) : Action()
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/lib/Navigator.kt | 3780842178 |
package com.kristianskokars.catnexus.lib
import kotlinx.serialization.json.Json
val json = Json {
ignoreUnknownKeys = true
isLenient = true
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/lib/Json.kt | 4135800280 |
package com.kristianskokars.catnexus.lib
import androidx.compose.animation.slideInHorizontally
import androidx.compose.animation.slideOutHorizontally
import com.kristianskokars.catnexus.feature.NavGraphs
import com.ramcosta.composedestinations.animations.defaults.RootNavGraphDefaultAnimations
import com.ramcosta.composedestinations.navigation.DestinationsNavigator
import com.ramcosta.composedestinations.navigation.popUpTo
import com.ramcosta.composedestinations.spec.Direction
val screenSlideTransitionAnimations get() = RootNavGraphDefaultAnimations(
enterTransition = { slideInHorizontally(initialOffsetX = { it }) },
exitTransition = { slideOutHorizontally(targetOffsetX = { -it }) },
popEnterTransition = { slideInHorizontally(initialOffsetX = { -it }) },
popExitTransition = { slideOutHorizontally(targetOffsetX = { it }) },
)
fun DestinationsNavigator.navigateToBottomBarDestination(destination: Direction) {
navigate(destination) {
popUpTo(NavGraphs.root) {
saveState = true
}
launchSingleTop = true
restoreState = true
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/lib/Navigation.kt | 1152065759 |
package com.kristianskokars.catnexus.lib
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.repeatOnLifecycle
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
suspend fun LifecycleOwner.launchImmediate(
block: suspend () -> Unit,
) = repeatOnLifecycle(Lifecycle.State.STARTED) {
withContext(Dispatchers.Main.immediate) {
block()
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/lib/Coroutines.kt | 3107005579 |
package com.kristianskokars.catnexus.lib
import android.content.Context
import androidx.annotation.StringRes
sealed class UIText {
class StringResource(@StringRes val id: Int, val argument: String = "") : UIText()
fun get(context: Context) = when (this) {
is StringResource -> context.getString(id, argument)
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/lib/UIText.kt | 1033595069 |
package com.kristianskokars.catnexus.lib
// we are assuming the given file will always be an image type
fun mimeTypeFromImageUrl(url: String): String {
val extension = url.split(".").last().lowercase()
return when (extension) {
"gif" -> "image/gif"
else -> "image/jpeg"
}
}
fun String.extensionFromImageUrl(): String = split(".").last().lowercase()
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/lib/Files.kt | 606120806 |
package com.kristianskokars.catnexus.lib
import androidx.annotation.DrawableRes
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class Toaster @Inject constructor() {
private val _messages = MutableSharedFlow<ToastMessage>(replay = 0, extraBufferCapacity = 1)
val messages = _messages.asSharedFlow()
suspend fun show(message: ToastMessage) {
_messages.emit(message)
}
}
data class ToastMessage(val text: UIText, val icon: ToastIcon? = null)
sealed interface ToastIcon {
data class Resource(@DrawableRes val id: Int) : ToastIcon
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/lib/Toaster.kt | 1318900504 |
package com.kristianskokars.catnexus.feature.cat_list.presentation
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.kristianskokars.catnexus.core.domain.CarModeHandler
import com.kristianskokars.catnexus.core.domain.model.ServerError
import com.kristianskokars.catnexus.core.domain.repository.CatRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class CatListViewModel @Inject constructor(
private val repository: CatRepository,
private val carModeHandler: CarModeHandler,
) : ViewModel() {
private val isLoading = MutableStateFlow(false)
private val hasServerError = MutableStateFlow<ServerError?>(null)
val isInCarMode = carModeHandler.isInCarMode
val state = combine(
repository.cats,
isLoading,
hasServerError,
) { cats, isLoading, hasServerError ->
when {
hasServerError != null -> when {
cats.isEmpty() -> CatListState.Error
else -> CatListState.Loaded(cats, hasServerError)
}
else -> when {
isLoading && cats.isEmpty() -> CatListState.Loading
!isLoading && cats.isEmpty() -> CatListState.NoCats
else -> CatListState.Loaded(cats)
}
}
}
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), CatListState.Loading)
init {
fetchCats(clearPreviousCats = true)
}
fun fetchCats(clearPreviousCats: Boolean = false) {
if (isLoading.value || hasServerError.value != null) return
viewModelScope.launch {
isLoading.update { true }
repository.refreshCats(clearPreviousCats).handle(
onSuccess = { hasServerError.update { null } },
onError = { hasServerError.update { ServerError } },
)
isLoading.update { false }
}
}
fun retryFetch() {
hasServerError.update { null }
fetchCats()
}
fun onCatNexusLogoClick() {
viewModelScope.launch {
carModeHandler.onCatNexusLogoClick()
}
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/cat_list/presentation/CatListViewModel.kt | 3167102799 |
package com.kristianskokars.catnexus.feature.cat_list.presentation
import com.kristianskokars.catnexus.core.domain.model.Cat
import com.kristianskokars.catnexus.core.domain.model.ServerError
sealed class CatListState {
data object Loading : CatListState()
data object Error : CatListState()
data object NoCats : CatListState()
data class Loaded(val cats: List<Cat>, val hasError: ServerError? = null) : CatListState()
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/cat_list/presentation/CatListState.kt | 3908340638 |
package com.kristianskokars.catnexus.feature.cat_list.presentation
import android.content.res.Configuration.UI_MODE_NIGHT_YES
import androidx.compose.animation.AnimatedContentTransitionScope
import androidx.compose.animation.EnterTransition
import androidx.compose.animation.ExitTransition
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.grid.LazyGridState
import androidx.compose.foundation.lazy.grid.rememberLazyGridState
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.NavBackStackEntry
import com.kristianskokars.catnexus.R
import com.kristianskokars.catnexus.core.presentation.components.BackgroundSurface
import com.kristianskokars.catnexus.core.presentation.components.BottomBarDestination
import com.kristianskokars.catnexus.core.presentation.components.CatGrid
import com.kristianskokars.catnexus.core.presentation.components.CatNexusBottomBar
import com.kristianskokars.catnexus.core.presentation.components.CatNexusDefaultTopBar
import com.kristianskokars.catnexus.core.presentation.components.ErrorGettingCats
import com.kristianskokars.catnexus.core.presentation.components.LoadingCats
import com.kristianskokars.catnexus.core.presentation.components.LoadingSpinner
import com.kristianskokars.catnexus.core.presentation.scrollToReturnedItemIndex
import com.kristianskokars.catnexus.core.presentation.theme.Black
import com.kristianskokars.catnexus.feature.appDestination
import com.kristianskokars.catnexus.feature.destinations.CatDetailsScreenDestination
import com.kristianskokars.catnexus.feature.destinations.FavouritesScreenDestination
import com.kristianskokars.catnexus.lib.navigateToBottomBarDestination
import com.ramcosta.composedestinations.annotation.Destination
import com.ramcosta.composedestinations.annotation.RootNavGraph
import com.ramcosta.composedestinations.navigation.DestinationsNavigator
import com.ramcosta.composedestinations.navigation.EmptyDestinationsNavigator
import com.ramcosta.composedestinations.result.ResultRecipient
import com.ramcosta.composedestinations.spec.DestinationStyle
import dev.chrisbanes.haze.HazeState
import dev.chrisbanes.haze.HazeStyle
import dev.chrisbanes.haze.haze
object HomeTransitions : DestinationStyle.Animated {
override fun AnimatedContentTransitionScope<NavBackStackEntry>.enterTransition(): EnterTransition? {
return when (initialState.appDestination()) {
FavouritesScreenDestination -> EnterTransition.None
else -> null
}
}
override fun AnimatedContentTransitionScope<NavBackStackEntry>.popEnterTransition(): EnterTransition? {
return when (initialState.appDestination()) {
FavouritesScreenDestination -> EnterTransition.None
else -> null
}
}
override fun AnimatedContentTransitionScope<NavBackStackEntry>.exitTransition(): ExitTransition? {
return when (targetState.appDestination()) {
FavouritesScreenDestination -> ExitTransition.None
else -> null
}
}
override fun AnimatedContentTransitionScope<NavBackStackEntry>.popExitTransition(): ExitTransition? {
return when (targetState.appDestination()) {
FavouritesScreenDestination -> ExitTransition.None
else -> null
}
}
}
@Destination(style = HomeTransitions::class)
@RootNavGraph(start = true)
@Composable
fun CatListScreen(
viewModel: CatListViewModel = hiltViewModel(),
navigator: DestinationsNavigator,
resultRecipient: ResultRecipient<CatDetailsScreenDestination, Int>
) {
val state by viewModel.state.collectAsStateWithLifecycle()
val isInCarMode by viewModel.isInCarMode.collectAsStateWithLifecycle()
val lazyGridState = rememberLazyGridState()
resultRecipient.scrollToReturnedItemIndex(lazyGridState = lazyGridState)
CatListContent(
state = state,
lazyGridState = lazyGridState,
navigator = navigator,
isInCarMode = isInCarMode,
onFetchMoreCats = viewModel::fetchCats,
onRetry = viewModel::retryFetch,
onCatNexusLogoClick = viewModel::onCatNexusLogoClick
)
}
@Composable
private fun CatListContent(
state: CatListState,
lazyGridState: LazyGridState,
navigator: DestinationsNavigator,
isInCarMode: Boolean,
onFetchMoreCats: () -> Unit,
onRetry: () -> Unit,
onCatNexusLogoClick: () -> Unit,
) {
val hazeState = remember { HazeState() }
Scaffold(
topBar = {
CatNexusDefaultTopBar(
hazeState = hazeState,
isInCarMode = isInCarMode,
isBorderVisible = lazyGridState.canScrollBackward,
onCatNexusLogoClick = onCatNexusLogoClick,
navigator = navigator
)
},
bottomBar = {
CatNexusBottomBar(
hazeState = hazeState,
currentDestination = BottomBarDestination.HOME,
onHomeClick = { /* Ignored */ },
onFavouritesClick = { navigator.navigateToBottomBarDestination(FavouritesScreenDestination) }
)
}
) { padding ->
Column(
modifier = Modifier
.padding(horizontal = 8.dp)
.padding(bottom = padding.calculateBottomPadding())
) {
when (state) {
is CatListState.Loaded -> CatGrid(
modifier = Modifier
.haze(
state = hazeState,
style = HazeStyle(tint = Black.copy(alpha = 0.72f), blurRadius = 24.dp)
),
topContentPadding = PaddingValues(top = padding.calculateTopPadding()),
state = lazyGridState,
cats = state.cats,
onCatClick = { navigator.navigate(CatDetailsScreenDestination(it)) },
bottomSlot = {
Row(
modifier = Modifier
.padding(vertical = 12.dp)
.fillMaxWidth(),
horizontalArrangement = Arrangement.Center,
verticalAlignment = Alignment.CenterVertically
) {
if (state.hasError != null) {
ErrorGettingCats(onRetry)
} else {
LoadingSpinner()
}
}
},
onScrolledToBottom = onFetchMoreCats,
)
is CatListState.Error -> ErrorGettingCats(onRetry)
CatListState.Loading -> LoadingCats()
CatListState.NoCats -> Text(text = stringResource(R.string.no_cats_found))
}
}
}
}
@Preview(uiMode = UI_MODE_NIGHT_YES)
@Composable
private fun CatListContentPreview() {
BackgroundSurface {
CatListContent(
state = CatListState.Loading,
isInCarMode = false,
lazyGridState = rememberLazyGridState(),
navigator = EmptyDestinationsNavigator,
onFetchMoreCats = {},
onRetry = {},
onCatNexusLogoClick = {}
)
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/cat_list/presentation/CatListScreen.kt | 4078796167 |
package com.kristianskokars.catnexus.feature.settings.presentation
sealed interface SettingsEvent {
data object ToggleSwipeDirection : SettingsEvent
data object ToggleDownloadNotificationsShowing : SettingsEvent
data object ToggleCarMode : SettingsEvent
data object ResetToDefaultSettings : SettingsEvent
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/settings/presentation/SettingsEvent.kt | 1306367200 |
package com.kristianskokars.catnexus.feature.settings.presentation
import com.kristianskokars.catnexus.core.domain.model.CatSwipeDirection
data class SettingsState(
val swipeDirection: CatSwipeDirection = CatSwipeDirection.HORIZONTAL,
val showDownloadNotifications: Boolean = true,
val isCarModeUnlocked: Boolean = false,
val isInCarMode: Boolean = false,
)
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/settings/presentation/SettingsState.kt | 3023586988 |
package com.kristianskokars.catnexus.feature.settings.presentation
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MediumTopAppBar
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.material3.rememberTopAppBarState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.nestedscroll.nestedScroll
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.Density
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.hilt.navigation.compose.hiltViewModel
import com.kristianskokars.catnexus.R
import com.kristianskokars.catnexus.core.presentation.theme.Gray
import com.kristianskokars.catnexus.core.presentation.theme.Red
import com.kristianskokars.catnexus.feature.settings.presentation.components.CatNexusSwitch
import com.kristianskokars.catnexus.feature.settings.presentation.components.OrientationSwitch
import com.ramcosta.composedestinations.annotation.Destination
import com.ramcosta.composedestinations.navigation.DestinationsNavigator
@Destination
@Composable
fun SettingsScreen(
viewModel: SettingsViewModel = hiltViewModel(),
navigator: DestinationsNavigator
) {
val state by viewModel.state.collectAsState()
Content(
state = state,
onEvent = viewModel::onEvent,
navigator = navigator
)
}
@Composable
@OptIn(ExperimentalMaterial3Api::class)
private fun Content(
state: SettingsState,
onEvent: (SettingsEvent) -> Unit,
navigator: DestinationsNavigator
) {
val scrollBehavior = TopAppBarDefaults.enterAlwaysScrollBehavior(rememberTopAppBarState())
Scaffold(
modifier = Modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
topBar = {
MediumTopAppBar(
scrollBehavior = scrollBehavior,
colors = TopAppBarDefaults.mediumTopAppBarColors(
containerColor = Color.Transparent,
scrolledContainerColor = Color.Transparent,
titleContentColor = Color.White,
navigationIconContentColor = Color.White
),
navigationIcon = {
IconButton(onClick = { navigator.navigateUp() }) {
Icon(
painter = painterResource(id = R.drawable.ic_arrow_back),
contentDescription = stringResource(R.string.go_back),
)
}
},
title = { Text(text = stringResource(R.string.settings), fontSize = 24.sp) }
)
}
) { padding ->
Column(
modifier = Modifier
.fillMaxSize()
.padding(padding)
.padding(horizontal = 16.dp)
) {
LazyColumn(
modifier = Modifier
.fillMaxWidth(),
verticalArrangement = remember {
object : Arrangement.Vertical {
override fun Density.arrange(
totalSize: Int,
sizes: IntArray,
outPositions: IntArray
) {
var currentOffset = 0
sizes.forEachIndexed { index, size ->
if (index == sizes.lastIndex) {
outPositions[index] = totalSize - size
} else {
outPositions[index] = currentOffset
currentOffset += size
}
}
}
}
}
) {
item("settings") {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Column(
modifier = Modifier.fillMaxWidth(0.7f)
) {
Text(text = stringResource(R.string.swipe_direction), fontWeight = FontWeight.Medium)
Text(
text = stringResource(R.string.swipe_direction_desc),
color = Gray,
lineHeight = 16.sp,
fontSize = 12.sp
)
}
Spacer(modifier = Modifier.weight(1f))
OrientationSwitch(
orientation = state.swipeDirection,
onCheckedChange = { onEvent(SettingsEvent.ToggleSwipeDirection) }
)
}
Spacer(modifier = Modifier.size(24.dp))
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically,
) {
Column(
modifier = Modifier.fillMaxWidth(0.7f)
) {
Text(text = stringResource(R.string.download_notifications), fontWeight = FontWeight.Medium)
Text(
text = stringResource(R.string.show_download_notifications_desc),
color = Gray,
lineHeight = 16.sp,
fontSize = 12.sp
)
}
Spacer(modifier = Modifier.weight(1f))
CatNexusSwitch(
modifier = Modifier.weight(1f, false),
checked = state.showDownloadNotifications,
onCheckedChange = { onEvent(SettingsEvent.ToggleDownloadNotificationsShowing) }
)
}
if (state.isCarModeUnlocked) {
Spacer(modifier = Modifier.size(24.dp))
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically,
) {
Column(
modifier = Modifier.fillMaxWidth(0.7f)
) {
Text(
text = stringResource(R.string.car_mode),
fontWeight = FontWeight.Medium
)
Text(
text = stringResource(R.string.car_mode_desc),
color = Gray,
lineHeight = 16.sp,
fontSize = 12.sp
)
}
Spacer(modifier = Modifier.weight(1f))
CatNexusSwitch(
modifier = Modifier.weight(1f, false),
checked = state.isInCarMode,
onCheckedChange = { onEvent(SettingsEvent.ToggleCarMode) }
)
}
}
}
item {
Spacer(modifier = Modifier.size(24.dp))
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically,
) {
Column(
modifier = Modifier.fillMaxWidth(0.7f)
) {
Text(text = stringResource(R.string.reset_to_default_settings), fontWeight = FontWeight.Medium)
}
Spacer(modifier = Modifier.weight(1f))
IconButton(
onClick = { onEvent(SettingsEvent.ResetToDefaultSettings) }
) {
Icon(painter = painterResource(id = R.drawable.ic_reset), tint = Red, contentDescription = null)
}
}
}
}
Spacer(modifier = Modifier.weight(1f))
Column(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 8.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
Text(text = stringResource(R.string.made_with_love), fontSize = 12.sp, lineHeight = 2.sp)
Text(text = stringResource(R.string.by_kristians), fontSize = 12.sp)
}
}
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/settings/presentation/SettingsScreen.kt | 1189507212 |
package com.kristianskokars.catnexus.feature.settings.presentation.components
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.size
import androidx.compose.material3.Icon
import androidx.compose.material3.Switch
import androidx.compose.material3.SwitchDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.rotate
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import com.kristianskokars.catnexus.R
import com.kristianskokars.catnexus.core.domain.model.CatSwipeDirection
import com.kristianskokars.catnexus.core.presentation.components.BackgroundSurface
import com.kristianskokars.catnexus.core.presentation.theme.Black
import com.kristianskokars.catnexus.core.presentation.theme.Gray
@Composable
fun OrientationSwitch(
orientation: CatSwipeDirection,
onCheckedChange: (CatSwipeDirection) -> Unit,
) {
val rotation by animateFloatAsState(
targetValue = if (orientation == CatSwipeDirection.HORIZONTAL) 1f else 0f,
label = "Orientation Rotation"
)
Switch(
checked = orientation == CatSwipeDirection.HORIZONTAL,
onCheckedChange = { if (it) onCheckedChange(CatSwipeDirection.HORIZONTAL) else onCheckedChange(CatSwipeDirection.VERTICAL) },
colors = SwitchDefaults.colors(
checkedThumbColor = Black,
checkedTrackColor = Gray,
uncheckedThumbColor = Black,
uncheckedTrackColor = Gray,
uncheckedBorderColor = Gray,
uncheckedIconColor = Color.White,
checkedIconColor = Color.White,
),
thumbContent = {
Icon(
modifier = Modifier.size(16.dp).rotate(90 * rotation),
painter = painterResource(id = R.drawable.ic_vertical_orientation),
contentDescription = stringResource(R.string.cat_swipe_direction)
)
}
)
}
@Preview
@Composable
private fun Preview() {
BackgroundSurface {
Column {
OrientationSwitch(
orientation = CatSwipeDirection.HORIZONTAL,
onCheckedChange = {}
)
Spacer(modifier = Modifier.size(8.dp))
OrientationSwitch(
orientation = CatSwipeDirection.VERTICAL,
onCheckedChange = {}
)
}
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/settings/presentation/components/OrientationSwitch.kt | 4087946061 |
package com.kristianskokars.catnexus.feature.settings.presentation.components
import androidx.compose.material3.Switch
import androidx.compose.material3.SwitchDefaults
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import com.kristianskokars.catnexus.core.presentation.theme.Black
import com.kristianskokars.catnexus.core.presentation.theme.Gray600
import com.kristianskokars.catnexus.core.presentation.theme.Orange
@Composable
fun CatNexusSwitch(
checked: Boolean,
onCheckedChange: (Boolean) -> Unit,
modifier: Modifier = Modifier,
) {
Switch(
modifier = modifier,
colors = SwitchDefaults.colors(
checkedThumbColor = Black,
checkedTrackColor = Orange,
uncheckedThumbColor = Black,
uncheckedTrackColor = Gray600,
uncheckedBorderColor = Gray600,
),
checked = checked,
onCheckedChange = onCheckedChange
)
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/settings/presentation/components/CatNexusSwitch.kt | 3234657934 |
package com.kristianskokars.catnexus.feature.settings.presentation
import androidx.datastore.core.DataStore
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.kristianskokars.catnexus.core.domain.model.UserSettings
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class SettingsViewModel @Inject constructor(
private val store: DataStore<UserSettings>
) : ViewModel() {
val state = store.data
.map { data ->
SettingsState(
swipeDirection = data.swipeDirection,
showDownloadNotifications = data.showDownloadNotifications,
isCarModeUnlocked = data.isCarModeUnlocked,
isInCarMode = data.isInCarMode
)
}
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), SettingsState())
fun onEvent(event: SettingsEvent) {
viewModelScope.launch {
when (event) {
SettingsEvent.ToggleDownloadNotificationsShowing -> {
store.updateData { data ->
data.copy(showDownloadNotifications = !data.showDownloadNotifications)
}
}
SettingsEvent.ToggleSwipeDirection -> {
store.updateData { data ->
data.copy(swipeDirection = data.swipeDirection.flip())
}
}
SettingsEvent.ToggleCarMode -> {
store.updateData { data ->
data.copy(isInCarMode = !data.isInCarMode)
}
}
SettingsEvent.ResetToDefaultSettings -> store.updateData { UserSettings() }
}
}
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/settings/presentation/SettingsViewModel.kt | 316803117 |
package com.kristianskokars.catnexus.feature.favourites.presentation
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.kristianskokars.catnexus.core.domain.CarModeHandler
import com.kristianskokars.catnexus.core.domain.repository.CatRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class FavouritesViewModel @Inject constructor(
private val carModeHandler: CarModeHandler,
repository: CatRepository,
) : ViewModel() {
val state = repository.getFavouritedCats()
.map { FavouritesState(cats = it) }
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), FavouritesState())
val isInCarMode = carModeHandler.isInCarMode
fun onCatNexusLogoClick() {
viewModelScope.launch {
carModeHandler.onCatNexusLogoClick()
}
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/favourites/presentation/FavouritesViewModel.kt | 798135272 |
package com.kristianskokars.catnexus.feature.favourites.presentation
import com.kristianskokars.catnexus.core.domain.model.Cat
data class FavouritesState(val cats: List<Cat>? = null)
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/favourites/presentation/FavouritesState.kt | 2786049835 |
package com.kristianskokars.catnexus.feature.favourites.presentation
import androidx.compose.animation.AnimatedContentTransitionScope
import androidx.compose.animation.EnterTransition
import androidx.compose.animation.ExitTransition
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.grid.LazyGridState
import androidx.compose.foundation.lazy.grid.rememberLazyGridState
import androidx.compose.foundation.text.ClickableText
import androidx.compose.material3.Scaffold
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color.Companion.White
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.NavBackStackEntry
import com.kristianskokars.catnexus.core.presentation.components.BackgroundSurface
import com.kristianskokars.catnexus.core.presentation.components.BottomBarDestination
import com.kristianskokars.catnexus.core.presentation.components.CatGrid
import com.kristianskokars.catnexus.core.presentation.components.CatNexusBottomBar
import com.kristianskokars.catnexus.core.presentation.components.CatNexusDefaultTopBar
import com.kristianskokars.catnexus.core.presentation.components.LoadingCats
import com.kristianskokars.catnexus.core.presentation.scrollToReturnedItemIndex
import com.kristianskokars.catnexus.core.presentation.theme.Black
import com.kristianskokars.catnexus.core.presentation.theme.Inter
import com.kristianskokars.catnexus.core.presentation.theme.Orange
import com.kristianskokars.catnexus.feature.appDestination
import com.kristianskokars.catnexus.feature.cat_detail.presentation.CatDetailsScreenNavArgs
import com.kristianskokars.catnexus.feature.destinations.CatDetailsScreenDestination
import com.kristianskokars.catnexus.feature.destinations.CatListScreenDestination
import com.kristianskokars.catnexus.lib.navigateToBottomBarDestination
import com.ramcosta.composedestinations.annotation.Destination
import com.ramcosta.composedestinations.navigation.DestinationsNavigator
import com.ramcosta.composedestinations.navigation.EmptyDestinationsNavigator
import com.ramcosta.composedestinations.result.ResultRecipient
import com.ramcosta.composedestinations.spec.DestinationStyle
import dev.chrisbanes.haze.HazeState
import dev.chrisbanes.haze.HazeStyle
import dev.chrisbanes.haze.haze
object FavouritesTransitions : DestinationStyle.Animated {
override fun AnimatedContentTransitionScope<NavBackStackEntry>.enterTransition(): EnterTransition? {
return when (initialState.appDestination()) {
CatListScreenDestination -> EnterTransition.None
else -> null
}
}
override fun AnimatedContentTransitionScope<NavBackStackEntry>.popEnterTransition(): EnterTransition? {
return when (initialState.appDestination()) {
CatListScreenDestination -> EnterTransition.None
else -> null
}
}
override fun AnimatedContentTransitionScope<NavBackStackEntry>.exitTransition(): ExitTransition? {
return when (targetState.appDestination()) {
CatListScreenDestination -> ExitTransition.None
else -> null
}
}
override fun AnimatedContentTransitionScope<NavBackStackEntry>.popExitTransition(): ExitTransition? {
return when (targetState.appDestination()) {
CatListScreenDestination -> ExitTransition.None
else -> null
}
}
}
@Destination(style = FavouritesTransitions::class)
@Composable
fun FavouritesScreen(
viewModel: FavouritesViewModel = hiltViewModel(),
navigator: DestinationsNavigator,
resultRecipient: ResultRecipient<CatDetailsScreenDestination, Int>
) {
val state by viewModel.state.collectAsStateWithLifecycle()
val isInCarMode by viewModel.isInCarMode.collectAsStateWithLifecycle()
val lazyGridState = rememberLazyGridState()
resultRecipient.scrollToReturnedItemIndex(lazyGridState = lazyGridState)
Content(
navigator = navigator,
lazyGridState = lazyGridState,
state = state,
isInCarMode = isInCarMode,
onCatNexusLogoClick = viewModel::onCatNexusLogoClick
)
}
@Composable
private fun Content(
navigator: DestinationsNavigator,
lazyGridState: LazyGridState,
state: FavouritesState,
isInCarMode: Boolean,
onCatNexusLogoClick: () -> Unit,
) {
val hazeState = remember { HazeState() }
val noFavouriteString = buildAnnotatedString {
var start = 0
var end = 0
withStyle(style = SpanStyle(color = White)) {
append("No favourites added yet. Head to")
}
withStyle(style = SpanStyle(color = Orange)) {
start = length
append(" home ")
end = length
}
withStyle(style = SpanStyle(color = White)) {
append("and add some!")
}
addStringAnnotation("navigate", "home", start, end)
}
Scaffold(
topBar = {
CatNexusDefaultTopBar(
hazeState = hazeState,
isBorderVisible = lazyGridState.canScrollBackward,
navigator = navigator,
isInCarMode = isInCarMode,
onCatNexusLogoClick = onCatNexusLogoClick,
)
},
bottomBar = {
CatNexusBottomBar(
hazeState = hazeState,
currentDestination = BottomBarDestination.FAVOURITES,
onHomeClick = { navigator.navigateToBottomBarDestination(CatListScreenDestination) },
onFavouritesClick = { /* IGNORED */ }
)
}
) { padding ->
Column(
modifier = Modifier
.padding(horizontal = 8.dp)
.padding(bottom = padding.calculateBottomPadding())
) {
if (state.cats == null) {
LoadingCats()
} else if (state.cats.isEmpty()) {
Column(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
ClickableText(
modifier = Modifier
.padding(top = padding.calculateTopPadding())
.padding(48.dp),
text = noFavouriteString,
style = TextStyle.Default.copy(textAlign = TextAlign.Center, fontFamily = Inter),
onClick = { offset ->
noFavouriteString
.getStringAnnotations("navigate", offset, offset)
.firstOrNull()?.item ?: return@ClickableText
navigator.navigateToBottomBarDestination(CatListScreenDestination)
}
)
}
} else {
CatGrid(
modifier = Modifier
.haze(
state = hazeState,
style = HazeStyle(tint = Black.copy(alpha = 0.72f), blurRadius = 24.dp)
),
topContentPadding = PaddingValues(top = padding.calculateTopPadding()),
state = lazyGridState,
cats = state.cats,
onCatClick = {
navigator.navigate(
CatDetailsScreenDestination(CatDetailsScreenNavArgs(it, showFavourites = true))
)
},
)
}
}
}
}
@Preview
@Composable
private fun Preview() {
BackgroundSurface {
Content(
navigator = EmptyDestinationsNavigator,
lazyGridState = rememberLazyGridState(),
state = FavouritesState(),
isInCarMode = false,
onCatNexusLogoClick = {}
)
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/favourites/presentation/FavouritesScreen.kt | 100868594 |
package com.kristianskokars.catnexus.feature.cat_detail.presentation
import androidx.datastore.core.DataStore
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.kristianskokars.catnexus.R
import com.kristianskokars.catnexus.core.domain.model.Cat
import com.kristianskokars.catnexus.core.domain.model.CatSwipeDirection
import com.kristianskokars.catnexus.core.domain.model.UserSettings
import com.kristianskokars.catnexus.core.domain.repository.CatRepository
import com.kristianskokars.catnexus.core.domain.repository.ImageSharer
import com.kristianskokars.catnexus.feature.navArgs
import com.kristianskokars.catnexus.lib.Navigator
import com.kristianskokars.catnexus.lib.ToastIcon
import com.kristianskokars.catnexus.lib.ToastMessage
import com.kristianskokars.catnexus.lib.Toaster
import com.kristianskokars.catnexus.lib.UIText
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class CatDetailsViewModel @Inject constructor(
private val repository: CatRepository,
private val imageSharer: ImageSharer,
private val navigator: Navigator,
private val userSettingsStore: DataStore<UserSettings>,
private val toaster: Toaster,
savedStateHandle: SavedStateHandle,
) : ViewModel() {
private val navArgs = savedStateHandle.navArgs<CatDetailsScreenNavArgs>()
private val showFavourites = navArgs.showFavourites
private val startingCatPageIndex = navArgs.catPageIndex
private val _page = MutableStateFlow(startingCatPageIndex)
private val _isUnfavouritingSavedCatConfirmation = MutableStateFlow(false)
val pageCount = if (showFavourites)
repository.getFavouritedCats().map { it.size }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), Int.MAX_VALUE)
else
repository.cats.map { it.size }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), Int.MAX_VALUE)
val cats =
if (showFavourites)
repository
.getFavouritedCats()
.onEach { cats -> if (cats.isEmpty()) navigator.navigateUp() }
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
else
repository.cats.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
@OptIn(ExperimentalCoroutinesApi::class)
val isCatDownloading = combine(
repository.cats,
_page
) { cats, page ->
cats[page].id
}
.flatMapLatest { repository.isCatDownloading(it) }
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
val swipeDirection = userSettingsStore.data
.map { it.swipeDirection }
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), CatSwipeDirection.HORIZONTAL)
val isUnfavouritingSavedCatConfirmation = _isUnfavouritingSavedCatConfirmation.asStateFlow()
fun saveCat() {
viewModelScope.launch {
repository.saveCatImage(currentCat())
}
}
fun toggleFavouriteCat() {
viewModelScope.launch {
if (showFavourites && currentCat().isFavourited) {
_isUnfavouritingSavedCatConfirmation.update { true }
} else {
repository.toggleFavouriteForCat(currentCat().id)
}
}
}
fun shareCat() {
imageSharer.shareImage(currentCat().url)
}
fun dismissDeleteConfirmation() {
_isUnfavouritingSavedCatConfirmation.update { false }
}
fun confirmUnfavourite() {
viewModelScope.launch {
_isUnfavouritingSavedCatConfirmation.update { false }
repository.toggleFavouriteForCat(currentCat().id)
}
}
fun onPageSelected(page: Int) {
if (page > cats.value.size - 1) return
// we add more cats one page before the final one to have it preload earlier for better UX
if (page == cats.value.size - 2 && !showFavourites) {
viewModelScope.launch {
repository.refreshCats()
}
}
_page.update { page }
}
fun onToggleSwipeDirection() {
viewModelScope.launch {
userSettingsStore.updateData {
val newDirection = it.swipeDirection.flip()
// TODO: make string resource out of this
val text = when (newDirection) {
CatSwipeDirection.VERTICAL -> "Vertical"
CatSwipeDirection.HORIZONTAL -> "Horizontal"
}
viewModelScope.launch {
toaster.show(
ToastMessage(
UIText.StringResource(
R.string.flipped_direction_notification,
text
),
ToastIcon.Resource(
R.drawable.ic_vertical_orientation
)
)
)
}
it.copy(swipeDirection = newDirection)
}
}
}
private fun currentCat(): Cat {
return cats.value[_page.value]
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/cat_detail/presentation/CatDetailsViewModel.kt | 517661955 |
package com.kristianskokars.catnexus.feature.cat_detail.presentation
import android.widget.Toast
import androidx.activity.compose.BackHandler
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxScope
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.pager.HorizontalPager
import androidx.compose.foundation.pager.PagerDefaults
import androidx.compose.foundation.pager.PagerState
import androidx.compose.foundation.pager.VerticalPager
import androidx.compose.foundation.pager.rememberPagerState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.ripple.rememberRipple
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.minimumInteractiveComponentSize
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshotFlow
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.rotate
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.window.Dialog
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import coil.ImageLoader
import coil.compose.AsyncImage
import coil.request.ImageRequest
import com.kristianskokars.catnexus.R
import com.kristianskokars.catnexus.core.domain.model.Cat
import com.kristianskokars.catnexus.core.domain.model.CatSwipeDirection
import com.kristianskokars.catnexus.core.presentation.DefaultHazeStyle
import com.kristianskokars.catnexus.core.presentation.ElevatedHazeStyle
import com.kristianskokars.catnexus.core.presentation.components.BackgroundSurface
import com.kristianskokars.catnexus.core.presentation.components.CatNexusTopBarLayout
import com.kristianskokars.catnexus.core.presentation.components.LoadingSpinner
import com.kristianskokars.catnexus.core.presentation.theme.Gray
import com.kristianskokars.catnexus.core.presentation.theme.Orange
import com.kristianskokars.catnexus.core.presentation.theme.Red
import com.ramcosta.composedestinations.annotation.Destination
import com.ramcosta.composedestinations.result.EmptyResultBackNavigator
import com.ramcosta.composedestinations.result.ResultBackNavigator
import dev.chrisbanes.haze.HazeState
import dev.chrisbanes.haze.haze
import dev.chrisbanes.haze.hazeChild
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
import net.engawapg.lib.zoomable.rememberZoomState
import net.engawapg.lib.zoomable.zoomable
data class CatDetailsScreenNavArgs(val catPageIndex: Int, val showFavourites: Boolean = false)
@OptIn(ExperimentalFoundationApi::class)
@Destination(navArgsDelegate = CatDetailsScreenNavArgs::class)
@Composable
fun CatDetailsScreen(
viewModel: CatDetailsViewModel = hiltViewModel(),
imageLoader: ImageLoader,
navArgsDelegate: CatDetailsScreenNavArgs,
resultNavigator: ResultBackNavigator<Int>
) {
val context = LocalContext.current
val cats by viewModel.cats.collectAsStateWithLifecycle()
val pageCount by viewModel.pageCount.collectAsStateWithLifecycle()
val isCatDownloading by viewModel.isCatDownloading.collectAsStateWithLifecycle(initialValue = false)
val isUnfavouritingSavedCatConfirmation by viewModel.isUnfavouritingSavedCatConfirmation.collectAsStateWithLifecycle()
var isDownloadPermissionGranted by remember { mutableStateOf(isPermissionToSavePicturesGranted(context)) }
val launcher = rememberLauncherForActivityResult(
ActivityResultContracts.RequestPermission()
) { isGranted ->
if (isGranted) {
viewModel.saveCat()
} else {
isDownloadPermissionGranted = false
}
}
val pagerState = rememberPagerState(initialPage = navArgsDelegate.catPageIndex, pageCount = { pageCount })
val swipeDirection by viewModel.swipeDirection.collectAsStateWithLifecycle()
val scope = rememberCoroutineScope()
LaunchedEffect(pagerState) {
snapshotFlow { pagerState.currentPage }.collectLatest { page ->
viewModel.onPageSelected(page)
}
}
BackHandler {
resultNavigator.navigateBack(pagerState.currentPage)
}
CatDetailsContent(
cats = cats,
swipeDirection = swipeDirection,
pagerState = pagerState,
isCatDownloading = isCatDownloading,
isUnfavouritingSavedCatConfirmation = isUnfavouritingSavedCatConfirmation,
resultNavigator = resultNavigator,
onDownloadClick = { askForStoragePermissionIfOnOlderAndroid(context, launcher, viewModel::saveCat) },
imageLoader = imageLoader,
isDownloadPermissionGranted = isDownloadPermissionGranted,
onFavouriteClick = viewModel::toggleFavouriteCat,
onShareCat = viewModel::shareCat,
onDismissDeleteConfirmation = viewModel::dismissDeleteConfirmation,
onConfirmUnfavourite = {
scope.launch {
viewModel.confirmUnfavourite()
pagerState.scrollToPage(pagerState.currentPage - 1)
}
},
onToggleSwipeDirection = viewModel::onToggleSwipeDirection
)
}
@OptIn(ExperimentalFoundationApi::class)
@Composable
fun CatDetailsContent(
cats: List<Cat>,
swipeDirection: CatSwipeDirection,
pagerState: PagerState,
isCatDownloading: Boolean,
resultNavigator: ResultBackNavigator<Int>,
imageLoader: ImageLoader,
isUnfavouritingSavedCatConfirmation: Boolean,
isDownloadPermissionGranted: Boolean?,
onDownloadClick: () -> Unit,
onFavouriteClick: () -> Unit,
onShareCat: () -> Unit,
onDismissDeleteConfirmation: () -> Unit,
onConfirmUnfavourite: () -> Unit,
onToggleSwipeDirection: () -> Unit,
) {
val hazeState = remember { HazeState() }
val pictureHazeState = remember { HazeState() }
val configuration = LocalConfiguration.current
val isInLandscape by remember {
derivedStateOf {
configuration.screenWidthDp > configuration.screenHeightDp
}
}
var zoomFactor by remember { mutableFloatStateOf(1f) }
if (cats.getOrNull(pagerState.currentPage) == null || cats.isEmpty()) {
return
}
if (isUnfavouritingSavedCatConfirmation) {
Dialog(
onDismissRequest = onDismissDeleteConfirmation
) {
Column(
modifier = Modifier
.padding(vertical = 24.dp, horizontal = 36.dp)
.border(
Dp.Hairline,
Gray.copy(alpha = 0.4f),
RoundedCornerShape(4.dp)
)
.hazeChild(
pictureHazeState,
shape = RoundedCornerShape(4.dp),
style = ElevatedHazeStyle
)
.padding(16.dp)
) {
Text(text = stringResource(R.string.confirm_unfavourite_cat), fontSize = 14.sp, textAlign = TextAlign.Center)
Spacer(modifier = Modifier.padding(12.dp))
Row(modifier = Modifier.fillMaxWidth()) {
TextButton(
modifier = Modifier.weight(1f),
onClick = onDismissDeleteConfirmation,
colors = ButtonDefaults.textButtonColors(
contentColor = Gray
)
) {
Text(text = stringResource(R.string.cancel))
}
Spacer(modifier = Modifier.padding(4.dp))
OutlinedButton(
modifier = Modifier.weight(1f),
border = BorderStroke(
width = Dp.Hairline,
color = Gray.copy(alpha = 0.4f),
),
onClick = {
onDismissDeleteConfirmation()
onConfirmUnfavourite()
}
) {
Text(text = stringResource(R.string.ok))
}
}
}
}
}
Scaffold(
topBar = {
CatNexusTopBarLayout(hazeState = hazeState, isBorderVisible = zoomFactor != 1f) {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically,
) {
IconButton(
onClick = { resultNavigator.navigateBack(pagerState.currentPage) },
rippleRadius = 24.dp,
) {
Icon(
painter = painterResource(id = R.drawable.ic_arrow_back),
contentDescription = stringResource(R.string.go_back),
)
}
Spacer(modifier = Modifier.weight(1f))
IconButton(
onClick = onToggleSwipeDirection,
rippleRadius = 24.dp,
) {
val rotation by animateFloatAsState(
targetValue = if (swipeDirection == CatSwipeDirection.HORIZONTAL) 1f else 0f,
label = "Orientation Rotation"
)
Icon(
modifier = Modifier
.rotate(90 * rotation),
painter = painterResource(id = R.drawable.ic_vertical_orientation),
contentDescription = stringResource(R.string.cat_swipe_direction)
)
}
Spacer(modifier = Modifier.padding(8.dp))
}
}
}
) { padding ->
Box(
modifier = Modifier
.haze(
state = hazeState,
style = DefaultHazeStyle
)
.then(if (isInLandscape) Modifier.padding(padding) else Modifier.padding(bottom = padding.calculateBottomPadding()))
.fillMaxSize(),
) {
when (swipeDirection) {
CatSwipeDirection.VERTICAL -> VerticalPager(
state = pagerState,
flingBehavior = PagerDefaults.flingBehavior(
state = pagerState,
)
) { index ->
ZoomableCatPicture(
cats = cats,
onZoomFactorChange = { zoomFactor = it },
index = index,
pictureHazeState = pictureHazeState,
imageLoader = imageLoader
)
}
CatSwipeDirection.HORIZONTAL -> HorizontalPager(
state = pagerState,
flingBehavior = PagerDefaults.flingBehavior(
state = pagerState,
)
) { index ->
ZoomableCatPicture(
cats = cats,
onZoomFactorChange = { zoomFactor = it },
index = index,
pictureHazeState = pictureHazeState,
imageLoader = imageLoader
)
}
}
ActionBar(
cat = cats[pagerState.currentPage],
isCatDownloading = isCatDownloading,
isDownloadPermissionGranted = isDownloadPermissionGranted,
pictureHazeState = pictureHazeState,
onFavouriteClick = onFavouriteClick,
onDownloadClick = onDownloadClick,
onShareCat = onShareCat
)
}
}
}
@Composable
private fun ZoomableCatPicture(
cats: List<Cat>,
onZoomFactorChange: (Float) -> Unit,
index: Int,
pictureHazeState: HazeState,
imageLoader: ImageLoader,
) {
val zoomState = rememberZoomState()
LaunchedEffect(key1 = zoomState.scale) {
onZoomFactorChange(zoomState.scale)
}
Box(
modifier = Modifier
.haze(state = pictureHazeState, style = DefaultHazeStyle)
.fillMaxWidth()
.fillMaxHeight()
.zoomable(zoomState)
) {
val cat = cats[index]
AsyncImage(
model = ImageRequest.Builder(LocalContext.current)
.data(cat.url)
.crossfade(true)
.build(),
modifier = Modifier
.align(Alignment.Center)
.fillMaxSize(),
contentScale = ContentScale.Fit,
contentDescription = null,
imageLoader = imageLoader,
)
}
}
@Composable
private fun BoxScope.ActionBar(
cat: Cat,
isCatDownloading: Boolean,
isDownloadPermissionGranted: Boolean?,
pictureHazeState: HazeState,
onFavouriteClick: () -> Unit,
onDownloadClick: () -> Unit,
onShareCat: () -> Unit
) {
val context = LocalContext.current
Row(
modifier = Modifier
.padding(vertical = 24.dp, horizontal = 36.dp)
.border(Dp.Hairline, Gray.copy(alpha = 0.4f), CircleShape)
.hazeChild(pictureHazeState, shape = CircleShape, style = ElevatedHazeStyle)
.padding(8.dp)
.align(Alignment.BottomCenter),
horizontalArrangement = Arrangement.Center,
verticalAlignment = Alignment.CenterVertically,
) {
IconButton(onClick = onFavouriteClick) {
if (cat.isFavourited) {
Icon(
painter = painterResource(id = R.drawable.ic_favourite_filled),
tint = Orange,
contentDescription = stringResource(R.string.unfavourite_cat),
)
} else {
Icon(
painter = painterResource(id = R.drawable.ic_favourite),
contentDescription = stringResource(R.string.favourite_cat)
)
}
}
Spacer(modifier = Modifier.size(16.dp))
if (isCatDownloading) {
LoadingSpinner(modifier = Modifier
.padding(12.dp)
.size(24.dp))
} else {
IconButton(
onClick = {
if (isDownloadPermissionGranted == false) {
Toast.makeText(context, R.string.ask_for_storage_permission, Toast.LENGTH_SHORT).show()
} else {
onDownloadClick()
}
},
) {
Icon(
painter = painterResource(id = R.drawable.ic_download),
contentDescription = stringResource(R.string.save_cat),
tint = if (isDownloadPermissionGranted == false) Red else Color.White,
)
}
}
Spacer(modifier = Modifier.size(16.dp))
IconButton(
onClick = onShareCat,
) {
Icon(
painter = painterResource(id = R.drawable.ic_share),
contentDescription = stringResource(R.string.share_cat),
tint = Color.White,
)
}
}
}
@Composable
private fun IconButton(
modifier: Modifier = Modifier,
onClick: () -> Unit,
enabled: Boolean = true,
interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
rippleRadius: Dp = 24.dp,
content: @Composable () -> Unit,
) {
Box(
modifier = modifier
.clickable(
onClick = onClick,
enabled = enabled,
role = Role.Button,
interactionSource = interactionSource,
indication = rememberRipple(bounded = false, radius = rippleRadius),
)
.minimumInteractiveComponentSize(),
contentAlignment = Alignment.Center,
) {
content()
}
}
@OptIn(ExperimentalFoundationApi::class)
@Preview
@Composable
private fun CatDetailsScreenPreview() {
val context = LocalContext.current
BackgroundSurface {
CatDetailsContent(
cats = emptyList(),
swipeDirection = CatSwipeDirection.HORIZONTAL,
isCatDownloading = true,
isUnfavouritingSavedCatConfirmation = false,
pagerState = rememberPagerState { 1 },
resultNavigator = EmptyResultBackNavigator(),
imageLoader = ImageLoader.Builder(context).build(),
isDownloadPermissionGranted = null,
onDownloadClick = {},
onFavouriteClick = {},
onShareCat = {},
onDismissDeleteConfirmation = {},
onConfirmUnfavourite = {},
onToggleSwipeDirection = {}
)
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/cat_detail/presentation/CatDetailsScreen.kt | 508170011 |
package com.kristianskokars.catnexus.feature.cat_detail.presentation
import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.os.Build
import androidx.activity.compose.ManagedActivityResultLauncher
import androidx.core.content.ContextCompat
fun isPermissionToSavePicturesGranted(context: Context): Boolean {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) return true
return ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
}
fun askForStoragePermissionIfOnOlderAndroid(
context: Context,
launcher: ManagedActivityResultLauncher<String, Boolean>,
block: () -> Unit
) {
// We are allowed to use Media Storage above and including Android 10 without needing a permission
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
block()
return
}
if (isPermissionToSavePicturesGranted(context)) {
block()
} else {
launcher.launch(Manifest.permission.WRITE_EXTERNAL_STORAGE)
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/feature/cat_detail/presentation/StoragePermissionHelpers.kt | 2107587485 |
package com.kristianskokars.catnexus
import android.app.Application
import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
import android.os.Build
import android.widget.Toast
import androidx.hilt.work.HiltWorkerFactory
import androidx.work.Configuration
import com.kristianskokars.catnexus.core.CHANNEL_DESCRIPTION
import com.kristianskokars.catnexus.core.CHANNEL_ID
import com.kristianskokars.catnexus.core.CHANNEL_NAME
import dagger.hilt.android.HiltAndroidApp
import io.sentry.Sentry
import timber.log.Timber
import javax.inject.Inject
@HiltAndroidApp
class CatApplication : Application(), Configuration.Provider {
@Inject lateinit var workerFactory: HiltWorkerFactory
private val exceptionHandler =
Thread.UncaughtExceptionHandler { _: Thread, e: Throwable ->
handleUncaughtException(e)
}
override fun onCreate() {
super.onCreate()
attachUnhandledExceptionHandler()
createNotificationChannel()
if (BuildConfig.DEBUG) {
Timber.plant(Timber.DebugTree())
}
}
override val workManagerConfiguration: Configuration by lazy {
Configuration.Builder().setWorkerFactory(workerFactory).build()
}
private fun createNotificationChannel() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
val name = CHANNEL_NAME
val descriptionText = CHANNEL_DESCRIPTION
val importance = NotificationManager.IMPORTANCE_LOW
val channel = NotificationChannel(CHANNEL_ID, name, importance).apply {
description = descriptionText
}
val notificationManager: NotificationManager =
getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
notificationManager.createNotificationChannel(channel)
}
}
private fun attachUnhandledExceptionHandler() {
if (BuildConfig.DEBUG.not()) {
Thread.setDefaultUncaughtExceptionHandler(exceptionHandler)
}
}
private fun handleUncaughtException(e: Throwable) {
Sentry.captureException(e)
Toast.makeText(this, getString(R.string.error_unexpected_error, e.localizedMessage), Toast.LENGTH_SHORT).show()
}
}
| CatNexus/app/src/main/java/com/kristianskokars/catnexus/CatApplication.kt | 1848761948 |
import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import kotlin.test.BeforeTest
import kotlin.test.Test
class BlindEncryptionMigrationTest {
private val fakeStoredHashes = HashSet<String>().apply {
add("234083y")
add("2340734")
}
private val storageManagerMock = mockk<IStorageManager>(relaxed = true)
private val statsAggregatorMock = mockk<IStatsAggregator>(relaxed = true)
private val tested: BlindEncryptionMigrator = BlindEncryptionMigrator(storageManagerMock, statsAggregatorMock)
@BeforeTest
fun setup() {
every { storageManagerMock.readHashSet() } returns fakeStoredHashes
}
@Test
fun `on instantiating BlindEncryptionMigration it should retrieve from storage`() {
tested.addEncryptedHash("tewfewatrew") // Need to perform some action since the first read is lazy
verify(exactly = 1) { storageManagerMock.readHashSet() }
}
@Test
fun `addEncryptedHash should add the hash to the store`() {
tested.addEncryptedHash("test hash")
verify(exactly = 1) { storageManagerMock.storeHashSet(fakeStoredHashes) }
}
@Test
fun `addEncryptedHash and then searchEncryptedHash should be be true`() {
val fakeHash = "test"
tested.addEncryptedHash(fakeHash)
verify(exactly = 1) { storageManagerMock.storeHashSet(fakeStoredHashes) }
assert(tested.searchEncryptedHash(fakeHash))
}
@Test
fun `searchEncryptedHash for a non existent hash should return false`() {
val nonExistentHash = "qewrty"
assert(!tested.searchEncryptedHash(nonExistentHash))
}
@Test
fun `StatsAggregator countNewHashAdded should be called when adding new hash`() {
`addEncryptedHash should add the hash to the store`()
verify(exactly = 1) { statsAggregatorMock.countNewHashAdded() }
}
@Test
fun `StatsAggregator countHashHit should be called with true for an existing stored hash`() {
`addEncryptedHash and then searchEncryptedHash should be be true`()
verify(exactly = 1) { statsAggregatorMock.countHashHit(true) }
}
@Test
fun `StatsAggregator countHashHit should be called with false for a non existent hash`() {
`searchEncryptedHash for a non existent hash should return false`()
verify(exactly = 1) { statsAggregatorMock.countHashHit(false) }
}
} | BEM/src/test/kotlin/BlindEncryptionMigrationTest.kt | 3518026542 |
interface IStatsAggregator {
fun countNewHashAdded()
fun countHashHit(hashHit: Boolean)
} | BEM/src/main/kotlin/IStatsAggregator.kt | 4033567000 |
import java.security.MessageDigest
import kotlin.collections.HashSet
class BlindEncryptionMigrator(
private val storageManager: IStorageManager,
private val statsBuilder: IStatsAggregator? = null
) {
private val hashingSet: HashSet<String> by lazy {
storageManager.readHashSet()
}
fun addEncryptedHash(hash: String) = hashingSet.add(hash).also {
statsBuilder?.countNewHashAdded()
persistData()
}
fun searchEncryptedHash(hash: String) = hashingSet.contains(hash).also {
statsBuilder?.countHashHit(it)
}
private fun persistData() = storageManager.storeHashSet(hashingSet)
companion object {
@JvmStatic
@JvmOverloads
fun calculateHash(text: String, numberOfChars: Int? = 7): String {
val digest = MessageDigest.getInstance("SHA-1")
val hash = digest.digest(text.toByteArray())
val hexOfHash = byteArrayToHexString(hash)
val hashStringLength = numberOfChars ?: hexOfHash.length
return hexOfHash.substring(0, hashStringLength)
}
@JvmStatic
private fun byteArrayToHexString(byteArray: ByteArray): String {
return byteArray.joinToString("") { "%02x".format(it) }
}
}
} | BEM/src/main/kotlin/BlindEncryptionMigrator.kt | 232701547 |
interface IStorageManager {
fun storeHashSet(hashes: HashSet<String>)
fun readHashSet(): HashSet<String>
} | BEM/src/main/kotlin/IStorageManager.kt | 1956985560 |
package com.example.lab3
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.lab3", appContext.packageName)
}
} | android-lab3/app/src/androidTest/java/com/example/lab3/ExampleInstrumentedTest.kt | 2655181882 |
package com.example.lab3
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | android-lab3/app/src/test/java/com/example/lab3/ExampleUnitTest.kt | 3387524120 |
package com.example.lab3
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.LinearLayout
import android.widget.TableRow
import android.widget.TextView
import android.widget.Toast
import com.example.lab3.databinding.ActivityMainBinding
class MainActivity : AppCompatActivity() {
val waterData: ArrayList<WaterData> = arrayListOf()
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
binding.addResourceButton.setOnClickListener {
val name :String = binding.waterResourceNameField.text.toString().trim()
val location :String = binding.locationField.text.toString().trim()
val type :String = binding.typeField.text.toString().trim()
if(name.isEmpty() || location.isEmpty() || type.isEmpty()){
Toast.makeText(this, "Fields cannot be empty!!", Toast.LENGTH_LONG).show()
}else{
val w = WaterData(name, location, type)
waterData.add(w)
addWaterDataToTable(w)
}
}
waterData.forEach {
addWaterDataToTable(it)
}
setContentView(binding.root)
}
fun addWaterDataToTable(waterData: WaterData){
val t = TableRow(this).apply {
showDividers = LinearLayout.SHOW_DIVIDER_BEGINNING
}
t.addView(TextView(this,).apply {
this.text = waterData.name
})
t.addView(TextView(this,).apply {
this.text = waterData.location
})
t.addView(TextView(this,).apply {
this.text = waterData.type
})
binding.table.addView(t)
}
} | android-lab3/app/src/main/java/com/example/lab3/MainActivity.kt | 3038461756 |
package com.example.lab3
data class WaterData(val name: String, val location:String, val type:String)
| android-lab3/app/src/main/java/com/example/lab3/WaterData.kt | 1388530948 |
package edu.put.inf153931
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("edu.put.inf153931", appContext.packageName)
}
} | BGC-app/BGC_app/app/src/androidTest/java/edu/put/inf153931/ExampleInstrumentedTest.kt | 2436832619 |
package edu.put.inf153931
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | BGC-app/BGC_app/app/src/test/java/edu/put/inf153931/ExampleUnitTest.kt | 1482623621 |
package edu.put.inf153931
import android.content.ContentValues
import android.content.Context
import android.content.Intent
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.TextView
import java.io.File
import java.text.SimpleDateFormat
import java.util.Date
class MainActivity : AppCompatActivity() {
val dbHandler = MyDBHandler(this, null, null, 1)
val imagesDir = "images"
override fun onCreate(savedInstanceState: Bundle?) {
Log.i("MainActivity", "onCreate")
dbHandler.deleteAccountData()
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
findViewById<Button>(R.id.syncView).setOnClickListener {
startActivity(Intent(this, SyncActivity::class.java))
}
findViewById<Button>(R.id.eraseData).setOnClickListener {
finishAffinity()
}
findViewById<Button>(R.id.gameList).setOnClickListener {
val intent = Intent(this, GamesActivity::class.java)
intent.putExtra("expansion", false)
startActivity(intent)
}
findViewById<Button>(R.id.expansionsList).setOnClickListener {
val intent = Intent(this, GamesActivity::class.java)
intent.putExtra("expansion", true)
startActivity(intent)
}
val imagesDir = File(applicationContext.filesDir, imagesDir)
if (!imagesDir.exists()) {
imagesDir.mkdir()
} else{
val images = imagesDir.listFiles()
for (image in images) {
image.delete()
}
}
}
override fun onResume() {
Log.i("MainActivity", "onResume")
super.onResume()
if (!dbHandler.isAccountAdded()) {
Log.i("MainActivity", "isAccountAdded: false")
startActivity(Intent(this, UsernameActivity::class.java))
} else if (dbHandler.getLastSync() == null) {
Log.i("MainActivity", "getLastSync: null")
startActivity(Intent(this, SyncActivity::class.java))
} else {
findViewById<TextView>(R.id.username).text = dbHandler.getUsername()
findViewById<TextView>(R.id.numberOfGames).text =
dbHandler.getNumberOfGames().toString()
findViewById<TextView>(R.id.numberOfExpansions).text =
dbHandler.getNumberOfExpansions().toString()
findViewById<TextView>(R.id.lastSync).text =
SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(dbHandler.getLastSync())
}
}
}
class MyDBHandler(
context: Context, name: String?, factory: SQLiteDatabase.CursorFactory?, version: Int
) : SQLiteOpenHelper(context, DATABASE_NAME, factory, DATABASE_VERSION) {
companion object {
private val DATABASE_VERSION = 1
private val DATABASE_NAME = "bgc.db"
val TABLE_ACCOUNT = "account"
val COLLECTION_TABLE = "collection"
val PHOTOS_TABLE = "photos"
val COLUMN_ID = "_id"
val COLUMN_USERNAME = "username"
val COLUMN_LAST_SYNC = "lastsync"
val COLUMN_LIST_MODIFIED_SINCE_LAST_SYNC = "list_modified_since_last_sync"
val COLUMN_TITLE = "title"
val COLUMN_YEAR = "year"
val COLUMN_THUMBNAIL_URL = "thumbnail_url"
val COLUMN_GAMEID = "game_id"
val COLUMN_EXPANSION = "expansion"
val GAME_ID = "game_id"
val PHOTO = "photo"
}
override fun onCreate(db: SQLiteDatabase?) {
val CREATE_ACCOUNT_TABLE =
("CREATE TABLE $TABLE_ACCOUNT($COLUMN_ID INTEGER PRIMARY KEY,$COLUMN_USERNAME TEXT,$COLUMN_LAST_SYNC DATETIME, $COLUMN_LIST_MODIFIED_SINCE_LAST_SYNC INTEGER)")
db?.execSQL(CREATE_ACCOUNT_TABLE)
val CREATE_COLLECTION_TABLE =
("CREATE TABLE $COLLECTION_TABLE($COLUMN_ID INTEGER PRIMARY KEY,$COLUMN_TITLE TEXT,$COLUMN_YEAR INTEGER, $COLUMN_THUMBNAIL_URL TEXT, $COLUMN_GAMEID INTEGER UNIQUE, $COLUMN_EXPANSION INTEGER)")
db?.execSQL(CREATE_COLLECTION_TABLE)
val CREATE_PHOTOS_TABLE =
("CREATE TABLE $PHOTOS_TABLE($COLUMN_ID INTEGER PRIMARY KEY,$GAME_ID INTEGER,$PHOTO TEXT)")
db?.execSQL(CREATE_PHOTOS_TABLE)
}
override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
db?.execSQL("DROP TABLE IF EXISTS $TABLE_ACCOUNT")
onCreate(db)
}
fun isAccountAdded(): Boolean {
val db = this.readableDatabase
val cursor = db.rawQuery("SELECT * FROM $TABLE_ACCOUNT", null)
if (!cursor.moveToFirst()) return false
if (cursor.count <= 0) {
cursor.close()
return false
}
cursor.close()
return true
}
fun addAccount(username: String) {
val db = this.writableDatabase
val values = ContentValues()
values.put(COLUMN_USERNAME, username)
values.put(COLUMN_LIST_MODIFIED_SINCE_LAST_SYNC, 0)
db.insert(TABLE_ACCOUNT, null, values)
db.close()
}
fun getUsername(): String? {
val db = this.readableDatabase
val cursor = db.rawQuery("SELECT * FROM $TABLE_ACCOUNT", null)
if (!cursor.moveToFirst()) return null
val username = cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_USERNAME))
cursor.close()
return username
}
fun updateLastSync() {
val db = this.writableDatabase
val values = ContentValues()
val currentDate = Date()
val dateFormat = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
val dateString = dateFormat.format(currentDate)
values.put(COLUMN_LAST_SYNC, dateString)
db.update(TABLE_ACCOUNT, values, null, null)
db.close()
}
fun getLastSync(): Date? {
val db = this.readableDatabase
val cursor = db.rawQuery("SELECT * FROM $TABLE_ACCOUNT", null)
if (!cursor.moveToFirst()) return null
val lastSync = cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_LAST_SYNC))
var date: Date? = null
Log.i("MyDBHandler", "lastSync: $lastSync")
if (lastSync != null) {
val format = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
date = format.parse(lastSync)
}
cursor.close()
return date
}
fun getModifiedSinceLastSync(): Boolean {
val db = this.readableDatabase
val cursor = db.rawQuery("SELECT * FROM $TABLE_ACCOUNT", null)
if (!cursor.moveToFirst()) return false
val modified =
cursor.getInt(cursor.getColumnIndexOrThrow(COLUMN_LIST_MODIFIED_SINCE_LAST_SYNC))
cursor.close()
return modified != 0
}
fun setModifiedSinceLastSync(bool: Boolean) {
val db = this.writableDatabase
val values = ContentValues()
val value = if (bool) 1 else 0
values.put(COLUMN_LIST_MODIFIED_SINCE_LAST_SYNC, value)
db.update(TABLE_ACCOUNT, values, null, null)
db.close()
}
fun deleteAccountData() {
val db = this.writableDatabase
db.delete(TABLE_ACCOUNT, null, null)
db.close()
}
fun deleteCollectionData() {
val db = this.writableDatabase
db.delete("collection", null, null)
db.close()
}
fun saveGame(id: Long?, title: String?, year: Int?, thumbnailUrl: String?) {
val db = this.writableDatabase
val values = ContentValues()
values.put(COLUMN_GAMEID, id)
values.put(COLUMN_TITLE, title)
values.put(COLUMN_YEAR, year)
values.put(COLUMN_THUMBNAIL_URL, thumbnailUrl)
values.put(COLUMN_EXPANSION, 0)
db.insert(COLLECTION_TABLE, null, values)
db.close()
}
fun makeExpansion(gameID: Long?) {
val db = this.writableDatabase
val values = ContentValues()
values.put(COLUMN_EXPANSION, 1)
db.update(COLLECTION_TABLE, values, "$COLUMN_GAMEID = ?", arrayOf(gameID.toString()))
db.close()
}
fun getNumberOfGames(): Int {
val db = this.readableDatabase
val cursor = db.rawQuery("SELECT * FROM $COLLECTION_TABLE WHERE expansion=0", null)
if (!cursor.moveToFirst()) return 0
val count = cursor.count
cursor.close()
return count
}
fun getNumberOfExpansions(): Int {
val db = this.readableDatabase
val cursor = db.rawQuery("SELECT * FROM $COLLECTION_TABLE WHERE expansion=1", null)
if (!cursor.moveToFirst()) return 0
val count = cursor.count
cursor.close()
return count
}
fun getGames(expansion: Boolean = false, orderByTitle: Boolean = true): ArrayList<Game> {
val db = this.readableDatabase
val cursor = if (orderByTitle)
db.rawQuery(
"SELECT * FROM $COLLECTION_TABLE WHERE expansion=? ORDER BY $COLUMN_TITLE",
arrayOf(if (expansion) "1" else "0"),
null
)
else
db.rawQuery(
"SELECT * FROM $COLLECTION_TABLE WHERE expansion=? ORDER BY $COLUMN_YEAR",
arrayOf(if (expansion) "1" else "0"),
null
)
val games = ArrayList<Game>()
if (!cursor.moveToFirst()) return games
do {
val id = cursor.getLong(cursor.getColumnIndexOrThrow(COLUMN_GAMEID))
val title = cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_TITLE))
val year = cursor.getInt(cursor.getColumnIndexOrThrow(COLUMN_YEAR))
val thumbnailUrl = cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_THUMBNAIL_URL))
val game = Game(id, title, year, thumbnailUrl)
games.add(game)
} while (cursor.moveToNext())
cursor.close()
return games
}
fun getGame(game_id: Long): Game? {
val db = this.readableDatabase
val cursor = db.rawQuery(
"SELECT * FROM $COLLECTION_TABLE WHERE $COLUMN_GAMEID = ?",
arrayOf(game_id.toString()),
null
)
if (!cursor.moveToFirst()) return null
val id = cursor.getLong(cursor.getColumnIndexOrThrow(COLUMN_GAMEID))
val title = cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_TITLE))
val year = cursor.getInt(cursor.getColumnIndexOrThrow(COLUMN_YEAR))
val thumbnailUrl = cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_THUMBNAIL_URL))
val game = Game(id, title, year, thumbnailUrl)
cursor.close()
return game
}
} | BGC-app/BGC_app/app/src/main/java/edu/put/inf153931/MainActivity.kt | 2455827556 |
package edu.put.inf153931
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
class UsernameActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_username)
findViewById<Button>(R.id.button_saveAccount).setOnClickListener {
saveAccount()
}
}
fun saveAccount() {
val dbHandler = MyDBHandler(this, null, null, 1)
val username = findViewById<EditText>(R.id.editText_username).text.toString()
if (username != "") {
dbHandler.addAccount(username)
Toast.makeText(this, "Zapisano konto", Toast.LENGTH_SHORT).show()
finish()
} else {
Toast.makeText(this, "Nie podano nazwy użytkownika", Toast.LENGTH_SHORT).show()
}
}
} | BGC-app/BGC_app/app/src/main/java/edu/put/inf153931/UsernameActivity.kt | 1818676127 |
package edu.put.inf153931
import android.content.Context
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.ImageView
import android.widget.LinearLayout
import android.widget.ScrollView
import android.widget.TableLayout
import android.widget.TableRow
import android.widget.TextView
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
val requestSemaphore = java.util.concurrent.Semaphore(5)
class Game(id: Long, title: String?, year: Int?, thumbnailUrl: String?) {
val ID: Long = id
val name: String? = title
val year: Int? = year
val thumbnailURL: String? = thumbnailUrl
}
class GameRow(context: Context, game: Game, idx: Int, on: Int?) : TableRow(context) {
var thumbnail_bmp: android.graphics.Bitmap? = null
init {
addView(TextView(context).apply {
if (game.ID == -1L) {
text = "lp."
} else {
text = on.toString()
}
layoutParams = LayoutParams(
LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT, 1f
)
width = 200
})
addView(TextView(context).apply {
if (game.ID == -1L) {
text = "Tytuł"
} else {
text = game.name
}
layoutParams = LayoutParams(
LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT, 1f
)
width = 500
})
addView(TextView(context).apply {
if (game.ID == -1L) {
text = "Rok"
} else {
text = game.year.toString()
}
layoutParams = LayoutParams(
LinearLayout.LayoutParams.WRAP_CONTENT,
LinearLayout.LayoutParams.WRAP_CONTENT,
1f,
)
width = 200
})
if (game.ID == -1L) {
addView(TextView(context).apply {
if (game.ID == -1L) {
text = "Miniaturka"
} else {
text = game.thumbnailURL
}
layoutParams = LayoutParams(
LinearLayout.LayoutParams.WRAP_CONTENT,
LinearLayout.LayoutParams.WRAP_CONTENT,
1f
)
width = 500
})
} else {
CoroutineScope(Dispatchers.IO).launch {
requestSemaphore.acquire()
val url = game.thumbnailURL
try {
val str = java.net.URL(url).openStream()
thumbnail_bmp = android.graphics.BitmapFactory.decodeStream(str)
val bmp =
android.graphics.Bitmap.createScaledBitmap(thumbnail_bmp!!, 300, 300, false)
requestSemaphore.release()
withContext(Dispatchers.Main) {
addView(ImageView(context).apply {
layoutParams = LayoutParams(
LinearLayout.LayoutParams.WRAP_CONTENT,
LinearLayout.LayoutParams.WRAP_CONTENT,
1f
)
setImageBitmap(bmp)
})
}
} catch (e: Exception) {
Log.e("GameRow", "Error while loading image: $e")
}
}
}
apply {
LayoutParams(
LayoutParams.WRAP_CONTENT
)
if (game.ID == -1L) {
setBackgroundColor(0xFF80572C.toInt())
} else {
setBackgroundColor(if (idx % 2 == 0) 0xFF534E4E.toInt() else 0xFF644C32.toInt())
}
setPadding(20, 40, 20, 40)
setOnClickListener {
val intent = Intent(context, OneGameActivity::class.java)
intent.putExtra("game_id", game.ID)
intent.putExtra("thumbnail_bmp", thumbnail_bmp)
context.startActivity(intent)
}
}
}
}
class GamesActivity : AppCompatActivity() {
lateinit var dbHandler: MyDBHandler
var expantion: Boolean = false
var sort_by_title: Boolean = true
var gameList: ArrayList<Game> = ArrayList()
override fun onCreate(savedInstanceState: Bundle?) {
for (i in 1..5)
requestSemaphore.release()
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_games)
dbHandler = MyDBHandler(this, null, null, 1)
expantion = intent.getBooleanExtra("expansion", false)
sort_by_title = intent.getBooleanExtra("sort_by_title", true)
gameList = dbHandler.getGames(expansion = expantion, orderByTitle = sort_by_title)
val tableLayout = TableLayout(this)
tableLayout.apply {
layoutParams = TableLayout.LayoutParams(
TableLayout.LayoutParams.WRAP_CONTENT, TableLayout.LayoutParams.WRAP_CONTENT
)
}
tableLayout.addView(GameRow(this, Game(-1, null, null, null), -1, null))
var on = 1
for (game in gameList) {
tableLayout.addView(GameRow(this, game, gameList.indexOf(game), on))
on++
}
findViewById<ScrollView>(R.id.scroll_view).addView(tableLayout)
findViewById<Button>(R.id.sort_by_title).setOnClickListener {
val intent = Intent(this, GamesActivity::class.java)
intent.putExtra("expansion", expantion)
intent.putExtra("sort_by_title", true)
intent.flags = Intent.FLAG_ACTIVITY_CLEAR_TOP
startActivity(intent)
}
findViewById<Button>(R.id.sort_by_year).setOnClickListener {
val intent = Intent(this, GamesActivity::class.java)
intent.putExtra("expansion", expantion)
intent.putExtra("sort_by_title", false)
intent.flags = Intent.FLAG_ACTIVITY_CLEAR_TOP
startActivity(intent)
}
findViewById<Button>(R.id.main_screen).setOnClickListener {
finish()
}
}
} | BGC-app/BGC_app/app/src/main/java/edu/put/inf153931/GamesActivity.kt | 1223487236 |
package edu.put.inf153931
import android.annotation.SuppressLint
import android.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.ProgressBar
import android.widget.TextView
import android.widget.Toast
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.xmlpull.v1.XmlPullParser
import org.xmlpull.v1.XmlPullParserFactory
import java.io.BufferedInputStream
import java.io.File
import java.io.FileOutputStream
import java.net.URL
import java.text.SimpleDateFormat
import java.time.temporal.ChronoUnit
import java.util.Date
class SyncActivity : AppCompatActivity() {
lateinit var dbHandler: MyDBHandler
@SuppressLint("MissingInflatedId")
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_sync)
dbHandler = MyDBHandler(this, null, null, 1)
updateLastSyncText()
findViewById<Button>(R.id.sync_button).setOnClickListener {
findViewById<TextView>(R.id.progress_text).visibility = TextView.VISIBLE
findViewById<ProgressBar>(R.id.progress_bar).visibility = ProgressBar.VISIBLE
sync()
}
findViewById<Button>(R.id.sync_button_collection).setOnClickListener {
findViewById<TextView>(R.id.progress_text).visibility = TextView.VISIBLE
findViewById<ProgressBar>(R.id.progress_bar).visibility = ProgressBar.VISIBLE
sync(1)
}
findViewById<Button>(R.id.mainScreen_button).setOnClickListener {
finish()
}
findViewById<Button>(R.id.eraseData2).setOnClickListener {
dbHandler.deleteAccountData()
finishAffinity()
}
}
private fun sync(extension: Int = 0) {
fun downloadFile() {
var urlString: String
if (extension == 0) urlString =
"https://boardgamegeek.com/xmlapi2/collection?username=${dbHandler.getUsername()}"
else {
urlString =
"https://boardgamegeek.com/xmlapi2/collection?username=${dbHandler.getUsername()}&subtype=boardgameexpansion"
}
Log.i("downloadFile", urlString)
val xmlDirectory = File(filesDir, "xml")
if (!xmlDirectory.exists()) {
xmlDirectory.mkdir()
}
if (xmlDirectory.listFiles() != null) {
for (file in xmlDirectory.listFiles()) {
file.delete()
}
}
val xmlFile = File(xmlDirectory, "collection.xml")
Log.i("downloadFile", xmlFile.toString())
CoroutineScope(Dispatchers.IO).launch {
try {
val url = URL(urlString)
val connection = url.openConnection()
connection.connect()
val input = BufferedInputStream(url.openStream())
val output = FileOutputStream(xmlFile)
val data = ByteArray(1024)
var count: Int
while (input.read(data).also { count = it } != -1) {
output.write(data, 0, count)
}
output.flush()
output.close()
input.close()
if (xmlFile.readText().contains("Please try again later for access.")) {
throw Exception("Spróbuj ponownie później.")
}
if (xmlFile.readText().contains("Invalid username specified")) {
throw Exception("Login użytkownika nie istnieje w BGG.")
}
if (xmlFile.readText().contains("<error>")) {
throw Exception("Wystąpił nieznany błąd.")
}
withContext(Dispatchers.Main) {
dbHandler.updateLastSync()
updateLastSyncText()
dbHandler.setModifiedSinceLastSync(true)
val xmlDirectory = File(filesDir, "xml")
val file = File(xmlDirectory, "collection.xml")
if (file.exists()) {
if (extension == 0) {
dbHandler.deleteCollectionData()
}
val factory = XmlPullParserFactory.newInstance()
factory.isNamespaceAware = true
val parser = factory.newPullParser()
parser.setInput(file.inputStream(), null)
var objectID: Long? = null
var name: String? = null
var yearPublished: Int? = null
var thumbnail: String? = null
var subtype: String? = null
var eventType = parser.eventType
while (eventType != XmlPullParser.END_DOCUMENT) {
when (eventType) {
XmlPullParser.START_TAG -> {
val tagName = parser.name
when (tagName) {
"item" -> {
objectID =
parser.getAttributeValue(null, "objectid")
.toLong()
subtype = parser.getAttributeValue(null, "subtype")
}
"name" -> {
name = parser.nextText()
}
"yearpublished" -> {
yearPublished = parser.nextText().toInt()
}
"thumbnail" -> {
thumbnail = parser.nextText()
}
}
}
XmlPullParser.END_TAG -> {
val tagName = parser.name
when (tagName) {
"item" -> {
if (extension == 0 && objectID != null) dbHandler.saveGame(
objectID, name, yearPublished, thumbnail
)
else if (extension == 1 && objectID != null) dbHandler.makeExpansion(
objectID
)
objectID = null
name = null
yearPublished = null
thumbnail = null
}
}
}
}
eventType = parser.next()
}
}
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
Toast.makeText(
this@SyncActivity, "$e", Toast.LENGTH_SHORT
).show()
}
findViewById<TextView>(R.id.progress_text).visibility = TextView.INVISIBLE
findViewById<ProgressBar>(R.id.progress_bar).visibility = ProgressBar.INVISIBLE
Log.e("downloadFile", e.toString())
val incompleteFile = File(xmlDirectory, "collection.xml")
if (incompleteFile.exists()) {
incompleteFile.delete()
}
}
}
}
fun properSync() {
downloadFile()
}
val lastSync = dbHandler.getLastSync()
if (lastSync != null) {
if (dbHandler.getModifiedSinceLastSync() || extension == 1) {
if (ChronoUnit.DAYS.between(lastSync.toInstant(), Date().toInstant()) >= 1) {
properSync()
} else {
val builder = AlertDialog.Builder(this)
builder.setTitle("Potwierdzenie synchronizacji")
if (extension == 0) builder.setMessage("Synchronizację wykonano mniej niż 24h temu. Czy na pewno chcesz ją wykonać?")
else builder.setMessage("Upewnij się, że wcześniej wykonałeś standardową synchronizację.")
builder.setPositiveButton("OK") { dialog, _ ->
properSync()
dialog.dismiss()
}
builder.setNegativeButton("ANULUJ") { dialog, _ ->
Toast.makeText(this, "Anulowano synchronizację", Toast.LENGTH_SHORT).show()
findViewById<TextView>(R.id.progress_text).visibility = TextView.INVISIBLE
findViewById<ProgressBar>(R.id.progress_bar).visibility =
ProgressBar.INVISIBLE
dialog.dismiss()
}
val alert = builder.create()
alert.show()
}
} else {
Toast.makeText(this, "Brak zmian do synchronizacji", Toast.LENGTH_SHORT).show()
findViewById<TextView>(R.id.progress_text).visibility = TextView.INVISIBLE
findViewById<ProgressBar>(R.id.progress_bar).visibility = ProgressBar.INVISIBLE
}
} else {
properSync()
}
}
private fun updateLastSyncText() {
val lastSync = dbHandler.getLastSync()
if (lastSync != null) {
val formatter = SimpleDateFormat("dd.MM.yyyy HH:mm:ss")
findViewById<TextView>(R.id.last_sync).text = formatter.format(lastSync)
} else {
findViewById<TextView>(R.id.last_sync).text = "Brak (synchronizacja wymagana)"
}
findViewById<TextView>(R.id.progress_text).visibility = TextView.INVISIBLE
findViewById<ProgressBar>(R.id.progress_bar).visibility = ProgressBar.INVISIBLE
}
} | BGC-app/BGC_app/app/src/main/java/edu/put/inf153931/SyncActivity.kt | 595175321 |
package edu.put.inf153931
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class FullActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_full)
val thumbnail_bmp = intent.getParcelableExtra<android.graphics.Bitmap>("thumbnail_bmp")
findViewById<android.widget.ImageView>(R.id.imageView).setImageBitmap(thumbnail_bmp)
}
} | BGC-app/BGC_app/app/src/main/java/edu/put/inf153931/FullActivity.kt | 907462937 |
package edu.put.inf153931
import android.app.AlertDialog
import android.content.Intent
import android.graphics.BitmapFactory
import android.net.Uri
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.ImageView
import android.widget.LinearLayout
import android.widget.TextView
import android.widget.Toast
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.content.FileProvider
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.xmlpull.v1.XmlPullParser
import org.xmlpull.v1.XmlPullParserFactory
import java.io.BufferedInputStream
import java.io.File
import java.io.FileOutputStream
import java.net.URL
import kotlin.random.Random
class OneGameActivity : AppCompatActivity() {
var game: Game? = null
var thumbnail_bmp: android.graphics.Bitmap? = null
lateinit var dbHandler: MyDBHandler
lateinit var imageView: ImageView
var description: String? = null
val imagesDir = "images"
var image: File? = null
lateinit var linearView: LinearLayout
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_one_game)
val game_id = intent.getLongExtra("game_id", -1)
dbHandler = MyDBHandler(this, null, null, 1)
game = dbHandler.getGame(game_id)
thumbnail_bmp = intent.getParcelableExtra("thumbnail_bmp")
linearView = findViewById(R.id.linearView)
val imDir = File(applicationContext.filesDir, imagesDir)
// imDir.mkdir()
for (f in imDir.listFiles()) {
if (f.name.startsWith(game_id.toString())) addImageToGallery(f)
}
findViewById<ImageView>(R.id.thumbnail).setImageBitmap(thumbnail_bmp)
findViewById<ImageView>(R.id.thumbnail).setOnClickListener {
val intent = Intent(this, FullActivity::class.java)
intent.putExtra("thumbnail_bmp", thumbnail_bmp)
startActivity(intent)
}
findViewById<TextView>(R.id.title).text = game?.name + " \n\n(" + game?.year + ")"
downloadFile()
val button = findViewById<Button>(R.id.doPhoto)
val resultLauncher: ActivityResultLauncher<Uri> =
registerForActivityResult(ActivityResultContracts.TakePicture()) { success ->
Log.i("doPhoto", "success: $success")
Log.i("doPhoto", "imageUri: ${image!!.absolutePath}")
if (success && image != null) {
addImageToGallery(image!!)
}
}
button.setOnClickListener {
val imageUri = initUri(game_id)
resultLauncher.launch(imageUri)
}
}
private fun addImageToGallery(f: File) {
linearView.addView(ImageView(this).apply {
setImageBitmap(
android.graphics.Bitmap.createScaledBitmap(
BitmapFactory.decodeFile(
f.path
), 500, 500, false
)
)
setOnClickListener{
val builder = AlertDialog.Builder(this@OneGameActivity)
builder.setTitle("Potwierdzenie usunięcia")
builder.setMessage("Czy na pewno chcesz usunąć zdjecia.")
builder.setPositiveButton("OK") { dialog, _ ->
f.delete()
dialog.dismiss()
recreate()
}
builder.setNegativeButton("ANULUJ") { dialog, _ ->
dialog.dismiss()
}
val alert = builder.create()
alert.show()
}
})
}
private fun initUri(gameID: Long): Uri {
val imagesDir = File(applicationContext.filesDir, imagesDir)
image = File(imagesDir, "${gameID}_${gameID + Random.nextInt()}.jpg")
Log.i("initUri", image!!.absolutePath)
return FileProvider.getUriForFile(
applicationContext, "com.example.inf153931.provider", image!!
)
}
fun downloadFile() {
var urlString: String =
"https://www.boardgamegeek.com/xmlapi2/thing?id=" + game?.ID + "&stats=1"
Log.i("downloadFile", urlString)
val xmlDirectory = File(filesDir, "xml")
if (!xmlDirectory.exists()) {
xmlDirectory.mkdir()
}
if (xmlDirectory.listFiles() != null) {
for (file in xmlDirectory.listFiles()) {
file.delete()
}
}
val xmlFile = File(xmlDirectory, "game.xml")
Log.i("downloadFile", xmlFile.toString())
CoroutineScope(Dispatchers.IO).launch {
try {
val url = URL(urlString)
val connection = url.openConnection()
connection.connect()
val input = BufferedInputStream(url.openStream())
val output = FileOutputStream(xmlFile)
val data = ByteArray(1024)
var count: Int
while (input.read(data).also { count = it } != -1) {
output.write(data, 0, count)
}
output.flush()
output.close()
input.close()
if (xmlFile.readText().contains("Please try again later for access.")) {
throw Exception("Dane na serwerze są przygotowywane. Spróbuj ponownie za kilka sekund.")
}
if (xmlFile.readText().contains("Invalid username specified")) {
throw Exception("Taki użytkownik nie istnieje w bazie BGC.")
}
if (xmlFile.readText().contains("<error>")) {
throw Exception("Wystąpił nieznany błąd. Spróbuj ponownie później.")
}
withContext(Dispatchers.Main) {
val xmlDirectory = File(filesDir, "xml")
val file = File(xmlDirectory, "game.xml")
if (file.exists()) {
// parse XML file
val factory = XmlPullParserFactory.newInstance()
factory.isNamespaceAware = true
val parser = factory.newPullParser()
parser.setInput(file.inputStream(), null)
var eventType = parser.eventType
while (eventType != XmlPullParser.END_DOCUMENT) {
when (eventType) {
XmlPullParser.START_TAG -> {
val tagName = parser.name
when (tagName) {
"description" -> {
description = parser.nextText()
Log.i("description", description.toString())
}
}
}
}
eventType = parser.next()
}
}
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
Toast.makeText(
applicationContext, e.toString(), Toast.LENGTH_LONG
).show()
}
val incompleteFile = File(xmlDirectory, "game.xml")
if (incompleteFile.exists()) {
incompleteFile.delete()
}
}
findViewById<TextView>(R.id.description).text = description?.substring(0, 300) + "..."
}
}
} | BGC-app/BGC_app/app/src/main/java/edu/put/inf153931/OneGameActivity.kt | 3609419123 |
package com.example.getsunset
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.getsunset", appContext.packageName)
}
} | GetSunSet/app/src/androidTest/java/com/example/getsunset/ExampleInstrumentedTest.kt | 813677389 |
package com.example.getsunset
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | GetSunSet/app/src/test/java/com/example/getsunset/ExampleUnitTest.kt | 1501598983 |
package com.example.getsunset
import android.os.AsyncTask
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import com.example.getsunset.databinding.ActivityMainBinding
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStream
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
class MainActivity : AppCompatActivity() {
lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding=ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
}
fun GetSunset(view:View){
var city=findViewById<EditText>(R.id.etCityName).text.toString()
val url="https://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20weather.forecast%20where%20woeid%20in%20(select%20woeid%20from%20geo.places(1)%20where%20text%3D%22"+ city +"%22)&format=json&env=store%3A%2F%2Fdatatables.org%2Falltableswithkeys"
MyAsyncTask().execute(url)
}
inner class MyAsyncTask: AsyncTask<String, String, String>() {
private fun ConvertStreamToString(inputStream: InputStream?): String? {
val bufferReader= BufferedReader(InputStreamReader(inputStream))
var line:String
var AllString:String=""
try {
do{
line=bufferReader.readLine()
if(line!=null){
AllString+=line
}
}while (line!=null)
inputStream?.close()
}
catch (ex:Exception){}
return AllString
}
override fun doInBackground(vararg p0: String?): String {
try {
val url= URL(p0[0])
val urlConnect=url.openConnection() as HttpURLConnection
urlConnect.connectTimeout=7000
var inString= ConvertStreamToString(urlConnect.inputStream)
//Cannot access to ui
publishProgress(inString)
}
catch (ex:Exception){}
return " "
}
override fun onProgressUpdate(vararg values: String?) {
var json= JSONObject(values[0])
val query=json.getJSONObject("query")
val results=query.getJSONObject("results")
val channel=results.getJSONObject("channel")
val astronomy=channel.getJSONObject("astronomy")
var sunrise=astronomy.getString("sunrise")
binding.tvSunSetTime.text = " Sunrise time is "+ sunrise
}
}
}
| GetSunSet/app/src/main/java/com/example/getsunset/MainActivity.kt | 2689319187 |
package com.rafver.core_testing.util
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.TestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.setMain
import org.junit.rules.TestWatcher
import org.junit.runner.Description
@OptIn(ExperimentalCoroutinesApi::class)
class TestCoroutineRule(
private val testDispatcher: TestDispatcher = StandardTestDispatcher(),
) : TestWatcher() {
override fun starting(description: Description) {
super.starting(description)
Dispatchers.setMain(testDispatcher)
}
override fun finished(description: Description) {
super.finished(description)
Dispatchers.resetMain()
}
} | simple-crud/core/core_testing/src/main/java/com/rafver/core_testing/util/TestCoroutineRule.kt | 857703259 |
package com.rafver.core_data.di
import com.rafver.core_data.repositories.UserRepositoryImpl
import com.rafver.core_data.repositories.UserRepository
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module
@InstallIn(SingletonComponent::class)
interface DataModule {
@Binds
fun bindUserRepository(userRepositoryImpl: UserRepositoryImpl): UserRepository
} | simple-crud/core/core_data/src/main/java/com/rafver/core_data/di/DataModule.kt | 2730516406 |
package com.rafver.core_data.repositories
import com.rafver.core_data.dtos.UserDTO
interface UserRepository {
fun getUser(userId: String): Result<UserDTO>
fun getUserList(): Result<List<UserDTO>>
fun createUser(name: String, age: Int, email: String): Result<Boolean>
fun updateUser(id: String, name: String, age: Int, email: String): Result<Boolean>
fun deleteUser(userId: String): Result<Boolean>
} | simple-crud/core/core_data/src/main/java/com/rafver/core_data/repositories/UserRepository.kt | 1101954392 |
package com.rafver.core_data.repositories
import com.rafver.core_data.dtos.UserDTO
import javax.inject.Inject
class UserRepositoryImpl @Inject constructor(): UserRepository {
override fun getUser(userId: String): Result<UserDTO> {
// ToDo: To Be Implemented
val userList = getUserList().getOrNull()
val user = userList?.firstOrNull { user -> user.id == userId }
return if(user != null) Result.success(user) else Result.failure(Exception("User not found"))
}
override fun getUserList(): Result<List<UserDTO>> {
// ToDo: To Be Implemented
return Result.success(listOf(
UserDTO("1", "John", 30, "[email protected]"),
UserDTO("2", "Audrey", 40, "[email protected]"),
UserDTO("3", "Jane", 32, "[email protected]"),
UserDTO("4", "James", 50, "[email protected]"),
))
}
override fun createUser(name: String, age: Int, email: String): Result<Boolean> {
// ToDo: To Be Implemented
return Result.success(true)
}
override fun updateUser(id: String, name: String, age: Int, email: String): Result<Boolean> {
// ToDo: To Be Implemented
return Result.success(true)
}
override fun deleteUser(id: String): Result<Boolean> {
// ToDo: To Be Implemented
return Result.success(true)
}
} | simple-crud/core/core_data/src/main/java/com/rafver/core_data/repositories/UserRepositoryImpl.kt | 3410625548 |
package com.rafver.core_data.dtos
data class UserDTO(
val id: String,
val name: String,
val age: Int,
val email: String
)
| simple-crud/core/core_data/src/main/java/com/rafver/core_data/dtos/UserDTO.kt | 2108155208 |
package com.rafver.core_ui.viewmodel
import androidx.annotation.VisibleForTesting
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.rafver.core_ui.util.SingleEvent
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch
abstract class BaseViewModel<State: UiState, Event: ViewEvent, Effect: ViewModelEffect>(
initialUiState: State
): ViewModel() {
// State
private val _uiState = MutableStateFlow(initialUiState)
val uiState: Flow<State> = _uiState.onEach {
println("Emitted new State: $it")
}
val currentState get() = _uiState.value
@VisibleForTesting(otherwise = VisibleForTesting.PROTECTED)
fun updateState(newState: State) {
_uiState.value = newState
}
// -------
// Event
private val _events = MutableSharedFlow<SingleEvent<Event>>()
fun onViewEvent(newEvent: Event) {
viewModelScope.launch {
_events.emit(SingleEvent(newEvent))
}
}
protected abstract suspend fun handleViewEvent(event: Event)
init {
viewModelScope.launch {
_events.collect { event ->
event.handleSingleEvent()?.let {
println("Emitted new Event: $it")
handleViewEvent(it)
}
}
}
}
// -------
// Effect
@VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
val effectsChannel = Channel<Effect>()
val effects = effectsChannel.receiveAsFlow().onEach {
println("Emitted new Effect: $it")
}
protected fun onViewModelEffect(effect: Effect) {
viewModelScope.launch {
effectsChannel.send(effect)
}
}
// -------
// Error Handling
abstract fun handleException(error: Throwable?)
}
| simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/viewmodel/BaseViewModel.kt | 162051442 |
package com.rafver.core_ui.viewmodel
interface UiState
interface ViewEvent
interface ViewModelEffect | simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/viewmodel/UiState.kt | 1596929296 |
package com.rafver.core_ui.util
/**
* Wrapper for an event that should be consumed only once
*/
class SingleEvent<out T>(private val content: T) {
var hasBeenHandled: Boolean = false
private set
fun handleSingleEvent(): T? {
return if(!hasBeenHandled) {
hasBeenHandled = true
content
} else {
null
}
}
fun peekContent(): T = content
} | simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/util/SingleEvent.kt | 922899564 |
package com.rafver.core_ui.models
import com.rafver.core_domain.models.UserModel
data class UserUiModel(val id: String, val name: String, val age: Int, val email: String)
fun UserModel.toUiModel(): UserUiModel = UserUiModel(id = id, name = name, age = age, email = email)
fun List<UserModel>.toUiModel(): List<UserUiModel> = map { it.toUiModel() }
fun UserUiModel.toDomainModel(): UserModel = UserModel(id = id, name = name, age = age, email = email)
fun List<UserUiModel>.toDomainModel(): List<UserModel> = map { it.toDomainModel() } | simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/models/UserUiModel.kt | 1871257763 |
package com.rafver.core_ui.extensions
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import com.rafver.core_ui.viewmodel.BaseViewModel
import com.rafver.core_ui.viewmodel.UiState
import com.rafver.core_ui.viewmodel.ViewEvent
import com.rafver.core_ui.viewmodel.ViewModelEffect
import androidx.compose.runtime.State as ComposeState
/**
* Method that observes [UiState] and triggers Recomposition every time the value is updated.
*/
@Composable
fun <State: UiState, Event: ViewEvent, Effect: ViewModelEffect>BaseViewModel<State, Event, Effect>
.collectUiState(): ComposeState<State> {
return uiState.collectAsState(initial = currentState)
} | simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/extensions/BaseViewModelExtension.kt | 4273613016 |
package com.rafver.core_ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/theme/Color.kt | 43957131 |
@file:Suppress("unused")
package com.rafver.core_ui.theme
import androidx.compose.ui.unit.dp
object Dimensions {
/**
* 0.5 dp
*/
val TINY = 0.5.dp
/**
* 4 dp
*/
val SMALL_50 = 4.dp
/**
* 8 dp
*/
val SMALL_100 = 8.dp
/**
* 12 dp
*/
val SMALL_150 = 12.dp
/**
* 16 dp
*/
val NORMAL_100 = 16.dp
/**
* 20 dp
*/
val NORMAL_125 = 20.dp
/**
* 24 dp
*/
val NORMAL_150 = 24.dp
/**
* 28 dp
*/
val NORMAL_175 = 28.dp
/**
* 32 dp
*/
val NORMAL_200 = 32.dp
/**
* 36 dp
*/
val NORMAL_225 = 36.dp
/**
* 40 dp
*/
val NORMAL_250 = 40.dp
/**
* 44 dp
*/
val NORMAL_275 = 44.dp
/**
* 48 dp
*/
val LARGE_150 = 48.dp
/**
* 56 dp
*/
val LARGE_175 = 56.dp
/**
* 64 dp
*/
val LARGE_200 = 64.dp
/**
* 2 dp
*/
val ELEVATION_SMALL = 2.dp
/**
* 4 dp
*/
val ELEVATION_NORMAL = 4.dp
/**
* 8 dp
*/
val ELEVATION_LARGE = 8.dp
/**
* 16 dp
*/
val ELEVATION_EXTRA_LARGE = 16.dp
/**
* 2 dp
*/
val ROUNDED_EDGE_SMALL = 2.dp
/**
* 4 dp
*/
val ROUNDED_EDGE_NORMAL = 4.dp
/**
* 8 dp
*/
val ROUNDED_EDGE_LARGE = 8.dp
/**
* 16 dp
*/
val ROUNDED_EDGE_EXTRA_LARGE = 16.dp
} | simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/theme/Dimensions.kt | 395917014 |
package com.rafver.core_ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun SimpleCRUDTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/theme/Theme.kt | 3941891767 |
package com.rafver.core_ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/theme/Type.kt | 1931464593 |
package com.rafver.core_ui.widgets
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Icon
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.vector.ImageVector
@Composable
fun AlertDialogWidget(
onDismissRequest: () -> Unit,
onConfirmation: () -> Unit,
dialogTitle: String,
dialogText: String,
confirmationText: String,
dismissText: String,
icon: ImageVector,
iconContentDescription: String = "Alert Icon",
canDismiss: Boolean = true,
) {
AlertDialog(
icon = { Icon(icon, contentDescription = iconContentDescription) },
title = { Text(text = dialogTitle) },
text = { Text(text = dialogText) },
onDismissRequest = onDismissRequest,
confirmButton = { TextButton(onClick = onConfirmation) { Text(confirmationText) } },
dismissButton = {
if(canDismiss) {
TextButton(onClick = onDismissRequest) { Text(dismissText) }
}
}
)
} | simple-crud/core/core_ui/src/main/java/com/rafver/core_ui/widgets/AlertDialogWidget.kt | 3697142499 |
package com.rafver.core_domain.usecases
import com.rafver.core_data.dtos.UserDTO
import com.rafver.core_data.repositories.UserRepository
import com.rafver.core_domain.models.UserModel
import com.rafver.core_domain.usecases.GetUser
import io.mockk.every
import io.mockk.mockk
import kotlinx.coroutines.test.runTest
import org.amshove.kluent.`should be equal to`
import org.amshove.kluent.`should not be`
import org.junit.Test
class GetUserTest {
private val userRepository: UserRepository = mockk(relaxed = true)
private lateinit var useCase: GetUser
@Test
fun `when use case is invoked, if error occurs, return failure with exception`() = runTest {
// Given
`given the tested use case`()
every { userRepository.getUser(any()) } returns Result.failure(Exception("some exception"))
val expectedException = Exception("some exception")
// When
val result = useCase("some-id")
// Then
result.isFailure `should be equal to` true
result.exceptionOrNull() `should not be` null
result.exceptionOrNull()?.message `should be equal to` expectedException.message
}
@Test
fun `when use case is invoked, if operation is successful, return success with domain model`() = runTest {
// Given
`given the tested use case`()
every {
userRepository.getUser("1")
} returns Result.success(
UserDTO(id = "1", name = "john", age = 20, email = "[email protected]")
)
val expectedUser = UserModel(id = "1", name = "john", age = 20, email = "[email protected]")
// When
val result = useCase("1")
// Then
result.isSuccess `should be equal to` true
result.getOrNull() `should be equal to` expectedUser
}
private fun `given the tested use case`() {
useCase = GetUser(userRepository = userRepository)
}
} | simple-crud/core/core_domain/src/test/java/com/rafver/core_domain/usecases/GetUserTest.kt | 1935880806 |
package com.rafver.core_domain.models
import com.rafver.core_data.dtos.UserDTO
data class UserModel(
val id: String,
val name: String,
val age: Int,
val email: String
)
fun UserModel.toDTO(): UserDTO = UserDTO(id = id, name = name, age = age, email = email)
fun List<UserModel>.toDTO(): List<UserDTO> = map { it.toDTO() }
fun UserDTO.toDomainModel(): UserModel = UserModel(id = id, name = name, age = age, email = email)
fun List<UserDTO>.toDomainModel(): List<UserModel> = map { it.toDomainModel() } | simple-crud/core/core_domain/src/main/java/com/rafver/core_domain/models/UserModel.kt | 3293114654 |
package com.rafver.core_domain.usecases
import com.rafver.core_data.repositories.UserRepository
import com.rafver.core_domain.models.UserModel
import com.rafver.core_domain.models.toDomainModel
import javax.inject.Inject
class GetUser @Inject constructor(private val userRepository: UserRepository){
operator fun invoke(userId: String): Result<UserModel> {
val result = userRepository.getUser(userId)
val user = result.getOrNull()
if (user != null) {
return Result.success(user.toDomainModel())
}
return Result.failure(result.exceptionOrNull()!!)
}
} | simple-crud/core/core_domain/src/main/java/com/rafver/core_domain/usecases/GetUser.kt | 3437967727 |
package com.rafver.simplecrud.ui
import com.rafver.core_ui.viewmodel.BaseViewModel
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
@HiltViewModel
class MainViewModel @Inject constructor(): BaseViewModel<MainUiState, MainViewEvent, MainViewModelEffect>(
MainUiState()
) {
override suspend fun handleViewEvent(event: MainViewEvent) {
when(event) {
is MainViewEvent.OnBottomNavigationItemClicked -> {
updateState(currentState.copy(currentSelectedNavigationItemIndex = event.itemIndex))
onViewModelEffect(MainViewModelEffect.NavigateTo(event.route))
}
}
}
override fun handleException(error: Throwable?) {
}
} | simple-crud/app/src/main/java/com/rafver/simplecrud/ui/MainViewModel.kt | 3458550800 |
package com.rafver.simplecrud.ui
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.rafver.core_ui.theme.SimpleCRUDTheme
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
SimpleCRUDTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
MainScreen()
}
}
}
}
}
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
Text(
text = "Hello $name!",
modifier = modifier
)
}
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
SimpleCRUDTheme {
Greeting("Android")
}
} | simple-crud/app/src/main/java/com/rafver/simplecrud/ui/MainActivity.kt | 675959465 |
package com.rafver.simplecrud.ui.navigation
import androidx.compose.ui.graphics.vector.ImageVector
data class MainBottomNavigationItem(
val label: String,
val icon: ImageVector,
val route: String
) | simple-crud/app/src/main/java/com/rafver/simplecrud/ui/navigation/MainBottomNavigationItem.kt | 3475751799 |
package com.rafver.simplecrud.ui.navigation
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Home
data object MainBottomNavigation {
fun getNavigationItems(): List<MainBottomNavigationItem> {
return listOf(
MainBottomNavigationItem(
label = "Home", // ToDo use extracted string
icon = Icons.Filled.Home,
route = Destinations.Read.name,
),
MainBottomNavigationItem(
label = "Create", // ToDo use extracted string
icon = Icons.Filled.Add,
route = Destinations.Create.name,
),
)
}
} | simple-crud/app/src/main/java/com/rafver/simplecrud/ui/navigation/MainBottomNavigation.kt | 3090418259 |
package com.rafver.simplecrud.ui.navigation
sealed class Destinations(val name: String) {
data object Create: Destinations(name = "create")
data object Read: Destinations(name = "read")
} | simple-crud/app/src/main/java/com/rafver/simplecrud/ui/navigation/Destinations.kt | 1876576760 |
package com.rafver.simplecrud.ui
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Icon
import androidx.compose.material3.NavigationBar
import androidx.compose.material3.NavigationBarItem
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.rafver.core_ui.extensions.collectUiState
import com.rafver.core_ui.theme.SimpleCRUDTheme
import com.rafver.create.ui.CreateScreen
import com.rafver.create.ui.CreateViewModel
import com.rafver.create.ui.navigation.editScreen
import com.rafver.details.ui.navigation.detailsScreen
import com.rafver.read.ui.ReadScreen
import com.rafver.read.ui.ReadViewModel
import com.rafver.simplecrud.ui.navigation.Destinations
import com.rafver.simplecrud.ui.navigation.MainBottomNavigation
@Composable
fun MainScreen(
viewModel: MainViewModel = hiltViewModel<MainViewModel>(),
) {
val uiState by viewModel.collectUiState()
val onViewEvent = viewModel::onViewEvent
val navController = rememberNavController()
LaunchedEffect(key1 = viewModel.effects) {
viewModel.effects.collect { effect ->
when(effect) {
is MainViewModelEffect.NavigateTo -> navController.navigate(effect.route)
}
}
}
Scaffold(
bottomBar = {
MainBottomBar(
uiState = uiState,
onViewEvent = onViewEvent,
)
},
) { paddingValues ->
MainContent(
navController = navController,
modifier = Modifier.padding(paddingValues)
)
}
}
@Composable
private fun MainContent(
navController: NavHostController,
modifier: Modifier = Modifier,
) {
Surface(modifier = modifier) {
NavHost(navController = navController, startDestination = Destinations.Read.name) {
composable(Destinations.Create.name) { CreateScreen(viewModel = hiltViewModel<CreateViewModel>()) }
composable(Destinations.Read.name) {
ReadScreen(
navController = navController,
viewModel = hiltViewModel<ReadViewModel>()
)
}
detailsScreen(navController)
editScreen()
}
}
}
@Composable
private fun MainBottomBar(
uiState: MainUiState,
onViewEvent: (MainViewEvent) -> Unit,
) {
NavigationBar {
MainBottomNavigation.getNavigationItems().forEachIndexed { index, item ->
NavigationBarItem(
selected = index == uiState.currentSelectedNavigationItemIndex,
onClick = {
onViewEvent(MainViewEvent.OnBottomNavigationItemClicked(
route = item.route,
itemIndex = index,
))
},
icon = {
Icon(imageVector = item.icon, contentDescription = item.label)
}
)
}
}
}
@Preview
@Composable
private fun PreviewMainScreen() {
SimpleCRUDTheme {
MainScreen()
}
} | simple-crud/app/src/main/java/com/rafver/simplecrud/ui/MainScreen.kt | 232645052 |
package com.rafver.simplecrud.ui
import com.rafver.core_ui.viewmodel.UiState
import com.rafver.core_ui.viewmodel.ViewEvent
import com.rafver.core_ui.viewmodel.ViewModelEffect
data class MainUiState(
val currentSelectedNavigationItemIndex: Int = 0,
): UiState
sealed class MainViewEvent: ViewEvent {
data class OnBottomNavigationItemClicked(
val route: String,
val itemIndex: Int,
): MainViewEvent()
}
sealed class MainViewModelEffect: ViewModelEffect {
data class NavigateTo(val route: String): MainViewModelEffect()
} | simple-crud/app/src/main/java/com/rafver/simplecrud/ui/MainUiState.kt | 5981371 |
package com.rafver.simplecrud
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class SimpleCrudApplication: Application() | simple-crud/app/src/main/java/com/rafver/simplecrud/SimpleCrudApplication.kt | 776199108 |
package com.rafver.read.ui
import app.cash.turbine.test
import com.rafver.core_domain.models.UserModel
import com.rafver.core_testing.util.TestCoroutineRule
import com.rafver.read.R
import com.rafver.read.domain.usecases.GetUserList
import com.rafver.read.ui.models.ReadViewModelEffect
import com.rafver.core_ui.models.UserUiModel
import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import kotlinx.coroutines.test.runTest
import org.amshove.kluent.`should be equal to`
import org.amshove.kluent.`should not be equal to`
import org.junit.Rule
import org.junit.Test
class ReadViewModelTest {
@get:Rule
val testCoroutineRule = TestCoroutineRule()
private val getUserList: GetUserList = mockk(relaxed = true)
private lateinit var viewModel: ReadViewModel
@Test
fun `when view model is initialized, try to get user list and if failed, the correct snackbar event is triggered`() = runTest {
// Given
`given the tested view model`()
val expectedException = Exception("Some exception")
every { getUserList() } returns Result.failure(expectedException)
val expectedSnackbarEvent = ReadViewModelEffect.DisplaySnackbar(R.string.error_read_generic)
// When
viewModel.uiState.test {
// Then
awaitItem().userList `should be equal to` null
expectNoEvents()
}
viewModel.effectsChannel.receive() `should be equal to` expectedSnackbarEvent
verify(exactly = 1) {
getUserList()
}
}
@Test
fun `when view model is initialized, try to get user list and if successful, the ui state is correctly updated`() = runTest {
// Given
`given the tested view model`()
every { getUserList() } returns Result.success(MOCK_USERS)
val expectedUserList = MOCK_USERS_UI
// When
viewModel.uiState.test {
// Then
awaitItem().userList `should be equal to` null
awaitItem().run {
userList?.size `should be equal to` expectedUserList.size
userList.compareWith(expectedUserList)
}
expectNoEvents()
}
verify(exactly = 1) {
getUserList()
}
}
@Test
fun `when view model is initialized, try to get user list and if successful, the ui state is correctly updated, even if the request result is empty`() = runTest {
// Given
`given the tested view model`()
every { getUserList() } returns Result.success(emptyList())
val expectedUserList = emptyList<UserUiModel>()
// When
viewModel.uiState.test {
// Then
awaitItem().userList `should be equal to` null
awaitItem().userList `should be equal to` expectedUserList
expectNoEvents()
}
verify(exactly = 1) {
getUserList()
}
}
private fun List<UserUiModel>?.compareWith(other: List<UserUiModel>?) {
if(this == null) {
other `should be equal to` null
return
}
other `should not be equal to` null
forEachIndexed { index, user ->
user.id `should be equal to` other!![index].id
user.name `should be equal to` other[index].name
user.age `should be equal to` other[index].age
user.email `should be equal to` other[index].email
}
}
private fun `given the tested view model`() {
viewModel = ReadViewModel(getUserList = getUserList)
}
private val MOCK_USERS = listOf(
UserModel("1", "John", 30, "[email protected]"),
UserModel("2", "Audrey", 40, "[email protected]"),
UserModel("3", "Jane", 32, "[email protected]"),
UserModel("4", "James", 50, "[email protected]"),
)
private val MOCK_USERS_UI = listOf(
UserUiModel("1", "John", 30, "[email protected]"),
UserUiModel("2", "Audrey", 40, "[email protected]"),
UserUiModel("3", "Jane", 32, "[email protected]"),
UserUiModel("4", "James", 50, "[email protected]"),
)
} | simple-crud/features/read/src/test/java/com/rafver/read/ui/ReadViewModelTest.kt | 1710109885 |
package com.rafver.read.ui
import com.rafver.core_ui.models.toUiModel
import com.rafver.core_ui.viewmodel.BaseViewModel
import com.rafver.read.R
import com.rafver.read.domain.usecases.GetUserList
import com.rafver.read.ui.models.ReadUiState
import com.rafver.read.ui.models.ReadViewEvent
import com.rafver.read.ui.models.ReadViewModelEffect
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
@HiltViewModel
class ReadViewModel @Inject constructor(
private val getUserList: GetUserList,
) : BaseViewModel<ReadUiState, ReadViewEvent, ReadViewModelEffect>(ReadUiState()) {
init {
onViewEvent(ReadViewEvent.OnInitialize)
}
override suspend fun handleViewEvent(event: ReadViewEvent) {
when(event) {
is ReadViewEvent.OnListItemClicked -> {
onViewModelEffect(ReadViewModelEffect.NavigateToDetails(event.userId))
}
ReadViewEvent.OnInitialize -> {
val result = getUserList()
if(result.isFailure) {
handleException(result.exceptionOrNull())
} else {
updateState(currentState.copy(userList = result.getOrNull()?.toUiModel()))
}
}
}
}
override fun handleException(error: Throwable?) {
println("An error has occurred: ${error?.message}")
when(error) {
else -> {
onViewModelEffect(
ReadViewModelEffect.DisplaySnackbar(
resId = R.string.error_read_generic
)
)
}
}
}
} | simple-crud/features/read/src/main/java/com/rafver/read/ui/ReadViewModel.kt | 1749646408 |
package com.rafver.read.ui.models
import androidx.annotation.StringRes
import com.rafver.core_ui.models.UserUiModel
import com.rafver.core_ui.viewmodel.UiState
import com.rafver.core_ui.viewmodel.ViewEvent
import com.rafver.core_ui.viewmodel.ViewModelEffect
data class ReadUiState(
val userList: List<UserUiModel>? = null,
val loading: Boolean = false,
): UiState
sealed class ReadViewEvent: ViewEvent {
data object OnInitialize: ReadViewEvent()
data class OnListItemClicked(val userId: String): ReadViewEvent()
}
sealed class ReadViewModelEffect: ViewModelEffect {
data class DisplaySnackbar(@StringRes val resId: Int): ReadViewModelEffect()
data class NavigateToDetails(val userId: String): ReadViewModelEffect()
} | simple-crud/features/read/src/main/java/com/rafver/read/ui/models/ReadUiState.kt | 3722640893 |
@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3Api::class)
package com.rafver.read.ui
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.navigation.NavHostController
import androidx.navigation.compose.rememberNavController
import com.rafver.core_ui.extensions.collectUiState
import com.rafver.core_ui.theme.Dimensions
import com.rafver.core_ui.theme.SimpleCRUDTheme
import com.rafver.read.R
import com.rafver.read.ui.models.ReadUiState
import com.rafver.read.ui.models.ReadViewEvent
import com.rafver.core_ui.models.UserUiModel
import com.rafver.details.ui.navigation.navigateToDetails
import com.rafver.read.ui.models.ReadViewModelEffect
import com.rafver.read.ui.widgets.UserListItem
@Composable
fun ReadScreen(
viewModel: ReadViewModel = viewModel(),
navController: NavHostController
) {
val uiState by viewModel.collectUiState()
val onViewEvent = viewModel::onViewEvent
val snackbarHostState = remember { SnackbarHostState() }
val context = LocalContext.current
LaunchedEffect(key1 = viewModel.effects) {
viewModel.effects.collect { effect ->
when(effect) {
is ReadViewModelEffect.DisplaySnackbar -> {
snackbarHostState.showSnackbar(context.getString(effect.resId))
}
is ReadViewModelEffect.NavigateToDetails -> {
navController.navigateToDetails(effect.userId)
}
}
}
}
Scaffold(
topBar = { ReadTopBar() }
) { padding ->
ReadContent(
uiState = uiState,
onViewEvent = onViewEvent,
modifier = Modifier.padding(padding),
)
}
}
@Composable
private fun ReadTopBar() {
TopAppBar(
title = { Text(stringResource(id = R.string.title_read_user)) }
)
}
@Composable
private fun ReadContent(
uiState: ReadUiState,
onViewEvent: (ReadViewEvent) -> Unit,
modifier: Modifier = Modifier,
) {
Surface(modifier = modifier) {
if(uiState.loading) {
//ToDo: loading widget here
} else {
with(uiState.userList) {
if (isNullOrEmpty()) {
Box(modifier = Modifier.fillMaxSize()) {
Text(stringResource(id = R.string.empty_list))
}
} else {
LazyColumn(
verticalArrangement = Arrangement.spacedBy(Dimensions.NORMAL_100),
modifier = Modifier
.fillMaxSize()
.padding(Dimensions.NORMAL_100)
) {
items(this@with) { user ->
UserListItem(
user = user,
onViewEvent = onViewEvent,
)
}
}
}
}
}
}
}
@Preview
@Composable
private fun PreviewReadScreenContent() {
SimpleCRUDTheme {
ReadContent(
uiState = ReadUiState(
userList = listOf(
UserUiModel("1", "John", 30, "[email protected]"),
UserUiModel("2", "Audrey", 40, "[email protected]"),
UserUiModel("3", "Jane", 32, "[email protected]"),
UserUiModel("4", "James", 50, "[email protected]"),
),
),
onViewEvent = {},
)
}
} | simple-crud/features/read/src/main/java/com/rafver/read/ui/ReadScreen.kt | 2459375239 |
package com.rafver.read.ui.widgets
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import com.rafver.core_ui.theme.Dimensions
import com.rafver.core_ui.theme.SimpleCRUDTheme
import com.rafver.read.R
import com.rafver.read.ui.models.ReadViewEvent
import com.rafver.core_ui.models.UserUiModel
@Composable
fun UserListItem(
user: UserUiModel,
onViewEvent: (ReadViewEvent) -> Unit,
modifier: Modifier = Modifier,
) {
Card(
modifier = modifier
.fillMaxWidth()
.clickable(
enabled = true,
onClick = { onViewEvent(ReadViewEvent.OnListItemClicked(user.id)) },
)
) {
Column(
modifier = modifier.padding(Dimensions.NORMAL_100)
) {
Text(text = user.name, style = MaterialTheme.typography.titleLarge)
Text(text = "${stringResource(id = R.string.lbl_age)}: ${user.age}")
Text(text = "${stringResource(id = R.string.lbl_email)}: ${user.email}")
}
}
}
@Preview
@Composable
private fun PreviewUserListItem() {
SimpleCRUDTheme {
UserListItem(
user = UserUiModel(
id = "1",
name = "John",
age = 30,
email = "[email protected]",
),
onViewEvent = {},
)
}
} | simple-crud/features/read/src/main/java/com/rafver/read/ui/widgets/UserListItem.kt | 119980125 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.