content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.organisation.educationui.screens
import androidx.compose.foundation.Image
import androidx.compose.foundation.clickable
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Text
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.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.navigation.NavController
import com.organisation.educationui.R
import com.organisation.educationui.ui.theme.BackgroundButton
import com.organisation.educationui.ui.theme.ExoFamily
import com.organisation.educationui.ui.theme.TextColor
import com.organisation.educationui.ui.theme.TextColorDescription
import com.organisation.educationui.ui.theme.TextColorSkip
@Composable
fun OnBoardScreen() {
Column(
modifier = Modifier.fillMaxSize(),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.SpaceEvenly
) {
Image(painter = painterResource(id = R.drawable.firstimage), contentDescription = "Image")
Column(
modifier = Modifier.padding(top = 30.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
Text(
text = "Let's find the \"A\" with us",
textAlign = TextAlign.Center,
fontFamily = ExoFamily,
fontSize = 20.sp,
fontWeight = FontWeight.ExtraBold,
color = TextColor
)
Text(
text = "Please Sign in to view personalized recommendations",
fontFamily = ExoFamily,
fontSize = 18.sp,
textAlign = TextAlign.Center,
fontWeight = FontWeight.Normal,
color = TextColorDescription
)
}
Column(modifier = Modifier.padding(top = 30.dp).align(Alignment.CenterHorizontally)) {
Button(
onClick = {},
colors = ButtonDefaults.buttonColors(BackgroundButton),
shape = RoundedCornerShape(12.dp),
modifier = Modifier.size(267.dp, 61.dp).align(Alignment.CenterHorizontally),
enabled = true
) {
Text(
text = "Sign up",
color = Color.White,
fontFamily = ExoFamily,
fontSize = 18.sp,
textAlign = TextAlign.Center,
fontWeight = FontWeight.Normal
)
}
Text(
modifier =
Modifier.align(Alignment.CenterHorizontally).padding(top = 30.dp).clickable(
indication = null,
interactionSource = remember { MutableInteractionSource() }
) {
//
},
text = "Skip",
fontFamily = ExoFamily,
fontSize = 18.sp,
fontWeight = FontWeight.Normal,
color = TextColorSkip
)
}
}
}
| EducationApp/app/src/main/java/com/organisation/educationui/screens/FirstScreen.kt | 1913016904 |
package com.mania.sise_d240222
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.mania.sise_d240222", appContext.packageName)
}
} | mania_sise_240222/app/src/androidTest/java/com/mania/sise_d240222/ExampleInstrumentedTest.kt | 748075790 |
package com.mania.sise_d240222
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)
}
} | mania_sise_240222/app/src/test/java/com/mania/sise_d240222/ExampleUnitTest.kt | 224832338 |
package com.mania.sise_d240222.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) | mania_sise_240222/app/src/main/java/com/mania/sise_d240222/ui/theme/Color.kt | 2715735625 |
package com.mania.sise_d240222.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 ManiaSise_240222Theme(
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
)
} | mania_sise_240222/app/src/main/java/com/mania/sise_d240222/ui/theme/Theme.kt | 1780822764 |
package com.mania.sise_d240222.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
)
*/
) | mania_sise_240222/app/src/main/java/com/mania/sise_d240222/ui/theme/Type.kt | 3397131954 |
package com.mania.sise_d240222
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.mania.sise_d240222.ui.theme.ManiaSise_240222Theme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
ManiaSise_240222Theme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
Greeting("Android")
}
}
}
}
}
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
Text(
text = "Hello $name!",
modifier = modifier
)
}
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
ManiaSise_240222Theme {
Greeting("Android")
}
} | mania_sise_240222/app/src/main/java/com/mania/sise_d240222/MainActivity.kt | 3025676577 |
package com.fitness.bodybalance
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.fitness.bodybalance", appContext.packageName)
}
} | body-balance/app/src/androidTest/kotlin/com/fitness/bodybalance/ExampleInstrumentedTest.kt | 4023978838 |
package com.fitness.bodybalance
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)
}
} | body-balance/app/src/test/kotlin/com/fitness/bodybalance/ExampleUnitTest.kt | 3265070831 |
package com.fitness.bodybalance.viewmodel
import com.fitness.authentication.manager.AuthenticationState
import com.fitness.theme.AppTheme
data class AppState(
val authState: AuthenticationState,
val appTheme: AppTheme,
val showMainHubAnimation: Boolean,
val isNewUser: Boolean,
)
sealed class AppEvent {
object AppStartUp: AppEvent()
} | body-balance/app/src/main/kotlin/com/fitness/bodybalance/viewmodel/AppContract.kt | 4164032003 |
package com.fitness.bodybalance.viewmodel
import com.fitness.authentication.manager.AuthenticationManager
import com.fitness.authentication.manager.AuthenticationState
import com.fitness.theme.AppTheme
import com.fitness.theme.ThemeManager
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.StateFlow
import viewmodel.BaseViewModel
import javax.inject.Inject
@HiltViewModel
class AppViewModel @Inject constructor(
private val authManager: AuthenticationManager,
private val themeManager: ThemeManager
) : BaseViewModel() {
val authState: StateFlow<AuthenticationState> get() = authManager.authState
val appTheme: StateFlow<AppTheme> get() = themeManager.appTheme
val showMainHubAnimation: Boolean = authState.value == AuthenticationState.Authenticated
} | body-balance/app/src/main/kotlin/com/fitness/bodybalance/viewmodel/AppViewModel.kt | 1650843064 |
package com.fitness.bodybalance.di
import android.app.Application
import android.content.Context
import com.fitness.navigation.Destinations
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.firestore.FirebaseFirestore
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class AppModule {
@Provides
fun provideFirebaseAuth(): FirebaseAuth = FirebaseAuth.getInstance()
@Provides
fun provideFirebaseFirestore(): FirebaseFirestore = FirebaseFirestore.getInstance()
@Provides
@Singleton
fun provideContext(application: Application): Context = application
@Provides
@Singleton
fun provideAppProvider(destinations: Destinations): AppProvider = AppProvider(destinations)
} | body-balance/app/src/main/kotlin/com/fitness/bodybalance/di/AppModule.kt | 191696758 |
package com.fitness.bodybalance.di
import com.fitness.authentication.di.AuthEntryModule
import com.fitness.dashboard.di.DashboardEntryModule
import com.fitness.onboard.di.OnboardEntryModule
import com.fitness.recipebuilder.di.RecipeBuilderEntryModule
import com.fitness.search.di.RecipeSearchEntryModule
import com.fitness.signout.di.SignOutEntryModule
import com.fitness.userprofile.di.UserProfileEntryModule
import com.fitness.welcome.di.WelcomeEntryModule
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module(
includes = [
OnboardEntryModule::class,
SignOutEntryModule::class,
AuthEntryModule::class,
DashboardEntryModule::class,
UserProfileEntryModule::class,
WelcomeEntryModule::class,
RecipeSearchEntryModule::class,
RecipeBuilderEntryModule::class
]
)
@InstallIn(SingletonComponent::class)
interface NavigationModule | body-balance/app/src/main/kotlin/com/fitness/bodybalance/di/NavigationModule.kt | 4180452463 |
package com.fitness.bodybalance.di
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
import javax.inject.Inject
@HiltAndroidApp
class BodyBalanceApplication: Application() {
@Inject
lateinit var appProvider: AppProvider
} | body-balance/app/src/main/kotlin/com/fitness/bodybalance/di/BodyBalanceApplication.kt | 3135291346 |
package com.fitness.bodybalance.di
import androidx.compose.runtime.compositionLocalOf
import com.fitness.navigation.Destinations
import javax.inject.Inject
class AppProvider @Inject constructor(val destinations: Destinations)
val LocalAppProvider = compositionLocalOf<AppProvider> { error("No app provider found!") } | body-balance/app/src/main/kotlin/com/fitness/bodybalance/di/AppProvider.kt | 2196524453 |
package com.fitness.bodybalance.view
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.Crossfade
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.material3.DrawerState
import androidx.compose.material3.DrawerValue
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalDrawerSheet
import androidx.compose.material3.ModalNavigationDrawer
import androidx.compose.material3.NavigationBar
import androidx.compose.material3.NavigationBarItem
import androidx.compose.material3.NavigationBarItemDefaults
import androidx.compose.material3.NavigationDrawerItem
import androidx.compose.material3.NavigationDrawerItemDefaults
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.rememberDrawerState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.State
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
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.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.currentBackStackEntryAsState
import androidx.navigation.compose.rememberNavController
import com.fitness.authentication.AuthEntry
import com.fitness.authentication.manager.AuthenticationState
import com.fitness.bodybalance.di.AppProvider
import com.fitness.dashboard.DashboardEntry
import com.fitness.theme.ui.BodyBalanceTheme
import com.fitness.navigation.BottomNavigationUtil
import com.fitness.navigation.Destinations
import com.fitness.navigation.DrawerItem
import com.fitness.navigation.DrawerNavigationUtil
import com.fitness.navigation.find
import com.fitness.onboard.OnboardEntry
import com.fitness.recipebuilder.RecipeBuilderEntry
import com.fitness.welcome.WelcomeEntry
import com.fitness.resources.R
import com.fitness.search.RecipeSearchEntry
import com.fitness.signout.SignOutEntry
import com.fitness.theme.AppTheme
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch
@Composable
fun AppContent(
authStateFlow: StateFlow<AuthenticationState>,
appTheme: State<AppTheme>,
showMainHubAnimation: Boolean,
appProvider: AppProvider
) {
BodyBalanceTheme(appTheme = appTheme) {
Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.surface) {
AppHub(authStateFlow, appProvider, showMainHubAnimation)
}
}
}
@Composable
fun AppHub(
authStateFlow: StateFlow<AuthenticationState>,
appProvider: AppProvider,
showMainHubAnimation: Boolean
) {
val authState by authStateFlow.collectAsState()
Crossfade(targetState = authState, label = "") {
when(it){
is AuthenticationState.Authenticated -> {
MainHub(showMainHubAnimation = showMainHubAnimation, destinations = appProvider.destinations)
}
is AuthenticationState.UnAuthenticated -> {
AuthenticationHub(destinations = appProvider.destinations)
}
is AuthenticationState.OnBoard -> {
OnboardHub(destinations = appProvider.destinations)
}
}
}
}
@Composable
fun MainHub(
showMainHubAnimation: Boolean,
destinations: Destinations,
scope: CoroutineScope = rememberCoroutineScope(),
navController: NavHostController = rememberNavController(),
items: List<DrawerItem> = DrawerNavigationUtil.drawerNavItems,
drawerState: DrawerState = rememberDrawerState(initialValue = DrawerValue.Closed),
) {
var bottomNavState by remember { mutableStateOf(false) }
ModalNavigationDrawer(
drawerState = drawerState,
drawerContent = {
ModularDrawSheet(items, scope, drawerState) { item ->
navController.navigate(item.route)
bottomNavState = !showMainHubAnimation
}
}) {
MainHubNavigation(
bottomNavState = bottomNavState,
showMainHubAnimation = showMainHubAnimation,
destinations = destinations,
scope = scope,
drawerState = drawerState,
navController = navController
)
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun MainHubNavigation(
bottomNavState: Boolean,
showMainHubAnimation: Boolean,
destinations: Destinations,
scope: CoroutineScope,
drawerState: DrawerState,
navController: NavHostController,
) {
Scaffold(
topBar = { TopAppBar(title = {}, navigationIcon = { NavDrawerIcon(scope, drawerState) }) },
bottomBar = {
AnimatedVisibility(visible = bottomNavState) {
NavBar(navController = navController)
}
}
) { innerPadding ->
val welcome = destinations.find<WelcomeEntry>()
val dashboard = destinations.find<DashboardEntry>()
val signOut = destinations.find<SignOutEntry>()
val recipeSearch = destinations.find<RecipeSearchEntry>()
val recipeBuilder = destinations.find<RecipeBuilderEntry>()
val startDestination = if(showMainHubAnimation) welcome else dashboard
val temp = destinations.find<OnboardEntry>()
NavHost(navController = navController, startDestination = recipeBuilder.featureRoute, modifier = Modifier.padding(innerPadding)) {
with(welcome){
composable(navController, destinations)
}
with(dashboard){
composable(navController, destinations)
}
with(signOut){
composable(navController, destinations)
}
with(recipeSearch){
navigation(navController, destinations)
}
with(recipeBuilder){
navigation(navController, destinations)
}
with(temp){
navigation(navController, destinations)
}
}
}
}
@Composable
fun NavDrawerIcon(
scope: CoroutineScope,
drawerState: DrawerState
) {
IconButton(onClick = { scope.launch { drawerState.open() } }) {
Icon(
painter = painterResource(id = R.drawable.icon_menu),
contentDescription = stringResource(id = R.string.content_description_menu),
Modifier.size(24.dp)
)
}
}
@Composable
fun NavBar(
navController: NavHostController
){
val backStackEntry = navController.currentBackStackEntryAsState()
NavigationBar(containerColor = Color.Black) {
BottomNavigationUtil.bottomNavItems.forEach { item ->
val selected = item.route == backStackEntry.value?.destination?.route
NavigationBarItem(
selected = selected,
onClick = { navController.navigate(item.route) },
colors = NavigationBarItemDefaults.colors(indicatorColor = Color.Black),
icon = {
Icon(
painter = painterResource(id = item.icon),
modifier = Modifier.size(32.dp),
tint = Color.Blue,
contentDescription = "${item.name} Icon")
}
)
}
}
}
@Composable
fun AuthenticationHub(
destinations: Destinations,
navController: NavHostController = rememberNavController(),
) {
val welcomeEntry = destinations.find<WelcomeEntry>()
val authEntry = destinations.find<AuthEntry>()
NavHost(navController, startDestination = authEntry.featureRoute) {
with(welcomeEntry) {
composable(navController, destinations)
}
with(authEntry) {
navController.popBackStack(welcomeEntry.featureRoute, false)
navigation(navController, destinations)
}
}
}
@Composable
fun OnboardHub(
destinations: Destinations,
navController: NavHostController = rememberNavController(),
) {
val onboardEntry = destinations.find<OnboardEntry>()
NavHost(navController, startDestination = onboardEntry.featureRoute) {
with(onboardEntry){
navigation(navController, destinations)
}
}
}
@Composable
fun ModularDrawSheet(
items: List<DrawerItem>,
scope: CoroutineScope,
drawerState: DrawerState,
onSelectionChange: (DrawerItem) -> Unit
) {
var selectedItem by remember { mutableStateOf(items[0]) }
ModalDrawerSheet {
Spacer(Modifier.height(12.dp))
items.forEach { item ->
NavigationDrawerItem(
icon = {
Icon(
painterResource(id = item.icon),
contentDescription = stringResource(id = item.contentDescription),
modifier = Modifier.size(24.dp)
)
},
label = { Text(item.name) },
selected = item == selectedItem,
onClick = {
scope.launch { drawerState.close() }
if (selectedItem != item) {
selectedItem = item
onSelectionChange(selectedItem)
}
},
modifier = Modifier.padding(NavigationDrawerItemDefaults.ItemPadding)
)
}
}
} | body-balance/app/src/main/kotlin/com/fitness/bodybalance/view/AppContent.kt | 97405336 |
package com.fitness.bodybalance.view
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
import androidx.lifecycle.viewmodel.compose.viewModel
import com.fitness.bodybalance.viewmodel.AppViewModel
import com.fitness.bodybalance.di.BodyBalanceApplication
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.delay
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val splashScreen = installSplashScreen()
splashScreen.setKeepOnScreenCondition{ true }
setContent {
var showMainScreen by remember { mutableStateOf(false) }
LaunchedEffect(key1 = Unit) {
delay(2000)
splashScreen.setKeepOnScreenCondition{ false }
showMainScreen = true
}
if (showMainScreen) {
val viewModel: AppViewModel = viewModel()
AppContent(
authStateFlow = viewModel.authState,
appTheme = viewModel.appTheme.collectAsState(),
showMainHubAnimation = viewModel.showMainHubAnimation,
appProvider = (application as BodyBalanceApplication).appProvider
)
}
}
}
} | body-balance/app/src/main/kotlin/com/fitness/bodybalance/view/MainActivity.kt | 1056093642 |
package com.fitness.recipebuilder.di
import com.fitness.navigation.FeatureEntry
import com.fitness.navigation.FeatureEntryKey
import com.fitness.recipebuilder.RecipeBuilderEntry
import com.fitness.recipebuilder.navigation.RecipeBuilderEntryImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import dagger.multibindings.IntoMap
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
interface RecipeBuilderEntryModule {
@Binds
@Singleton
@IntoMap
@FeatureEntryKey(RecipeBuilderEntry::class)
fun recipeBuilderEntry(entry: RecipeBuilderEntryImpl): FeatureEntry
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/di/RecipeBuilderEntryModule.kt | 2736517775 |
package com.fitness.recipebuilder.di
import com.fitness.recipebuilder.util.RecipeBuilderStateHolder
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class RecipeBuilderModule {
@Provides
@Singleton
fun provideRecipeBuilderStateHolder(): RecipeBuilderStateHolder = RecipeBuilderStateHolder
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/di/RecipeBuilderModule.kt | 2086418722 |
package com.fitness.recipebuilder.util
import androidx.compose.foundation.Image
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
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.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.DropdownMenu
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.constraintlayout.compose.ConstraintLayout
import androidx.constraintlayout.compose.Dimension
import com.fitness.domain.model.nutrition.Measure
import com.fitness.resources.R
import com.fitness.theme.ui.Green
import com.skydoves.landscapist.coil.CoilImage
import extensions.Dark
import extensions.Light
@Light
@Dark
@Composable
@OptIn(ExperimentalMaterial3Api::class)
fun SmallNutritionItem(
title: String = "Kreplach",
quantity: Double = 3.0,
measure: String = "Servings",
onClickModify: () -> Unit = {},
) = Card(
elevation = CardDefaults.cardElevation(defaultElevation = 1.dp),
modifier = Modifier
.height(50.dp)
.width(55.dp)
.clickable { onClickModify() }
) {
ConstraintLayout(modifier = Modifier.fillMaxSize()) {
val (titleRef, quantityRef, modifyRef) = createRefs()
val topGuide = createGuidelineFromTop(5.dp)
val endGuide = createGuidelineFromEnd(5.dp)
val startGuide = createGuidelineFromStart(5.dp)
Text(
text = title,
fontSize = 8.sp,
textAlign = TextAlign.Start,
overflow = TextOverflow.Ellipsis,
maxLines = 1,
modifier = Modifier
.constrainAs(titleRef) {
top.linkTo(topGuide)
start.linkTo(startGuide)
end.linkTo(endGuide)
bottom.linkTo(quantityRef.top)
width = Dimension.fillToConstraints
}
)
Text(
text = "$quantity $measure",
fontSize = 8.sp,
textAlign = TextAlign.Start,
overflow = TextOverflow.Ellipsis,
maxLines = 1,
modifier = Modifier
.constrainAs(quantityRef) {
start.linkTo(startGuide)
bottom.linkTo(modifyRef.top)
end.linkTo(endGuide)
top.linkTo(titleRef.bottom)
width = Dimension.fillToConstraints
}
)
Card(
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp),
colors = CardDefaults.cardColors(containerColor = Green),
shape = RoundedCornerShape(topStart = 0.dp, topEnd = 0.dp),
onClick = { onClickModify() },
modifier = Modifier.height(15.dp).constrainAs(modifyRef) {
end.linkTo(parent.end)
start.linkTo(parent.start)
bottom.linkTo(parent.bottom)
width = Dimension.fillToConstraints
}
) {
Icon(
painter = painterResource(id = R.drawable.icon_edit),
contentDescription = stringResource(id = R.string.content_description_icon_edit),
modifier = Modifier.fillMaxWidth()
)
}
}
}
@Light
@Dark
@Composable
fun NutritionItem(
title: String = "Kreplach",
imageModel: String? = "",
energy: Double? = 0.0,
fat: Double? = 0.0,
protein: Double? = 0.0,
net: Double? = 0.0,
onClickItem: () -> Unit = {},
) = Card(
elevation = CardDefaults.cardElevation(defaultElevation = 1.dp),
modifier = Modifier.clickable { onClickItem() }) {
ConstraintLayout(
modifier = Modifier
.fillMaxWidth()
.height(75.dp)
) {
val (imageRef, titleRef, nutrientsEnergyFat, nutrientsProteinNet) = createRefs()
val guideTop = createGuidelineFromTop(.10f)
val guideMid = createGuidelineFromEnd(.35f)
val guideEnd = createGuidelineFromEnd(.05f)
val guideBottom = createGuidelineFromBottom(.10f)
ItemImage(
imageModel = imageModel,
size = 75.dp,
modifier = Modifier
.constrainAs(imageRef) {
top.linkTo(guideTop)
start.linkTo(parent.start)
bottom.linkTo(guideBottom)
}
)
Text(
text = title,
overflow = TextOverflow.Ellipsis,
maxLines = 2,
modifier = Modifier.constrainAs(titleRef) {
top.linkTo(guideTop)
end.linkTo(guideMid)
start.linkTo(imageRef.end, 10.dp)
bottom.linkTo(guideBottom)
height = Dimension.fillToConstraints
width = Dimension.fillToConstraints
}
)
Row(modifier = Modifier.constrainAs(nutrientsEnergyFat) {
top.linkTo(titleRef.top)
end.linkTo(guideEnd)
}
) {
Row(verticalAlignment = Alignment.CenterVertically) {
energy?.let {
Icon(
painter = painterResource(id = R.drawable.icon_calories),
contentDescription = stringResource(id = R.string.content_description_icon_energy)
)
Spacer(modifier = Modifier.width(5.dp))
Text(text = it.toInt().toString())
}
}
Spacer(modifier = Modifier.width(40.dp))
Row(verticalAlignment = Alignment.CenterVertically) {
fat?.let {
Icon(
painter = painterResource(id = R.drawable.icon_fat),
contentDescription = stringResource(id = R.string.content_description_icon_fat)
)
Spacer(modifier = Modifier.width(5.dp))
Text(text = it.toInt().toString())
}
}
}
Row(modifier = Modifier.constrainAs(nutrientsProteinNet) {
bottom.linkTo(guideBottom)
end.linkTo(guideEnd)
}
) {
Row(verticalAlignment = Alignment.CenterVertically) {
protein?.let {
Icon(
painter = painterResource(id = R.drawable.icon_fat),
contentDescription = stringResource(id = R.string.content_description_icon_protein)
)
Spacer(modifier = Modifier.width(5.dp))
Text(text = it.toInt().toString())
}
}
Spacer(modifier = Modifier.width(40.dp))
Row(verticalAlignment = Alignment.CenterVertically) {
net?.let {
Icon(
painter = painterResource(id = R.drawable.icon_carbs),
contentDescription = stringResource(id = R.string.content_description_icon_net_carbs)
)
Spacer(modifier = Modifier.width(5.dp))
Text(text = it.toInt().toString())
}
}
}
}
}
@Composable
fun ItemImage(modifier: Modifier = Modifier, size: Dp, imageModel: String? = "") {
Card(shape = CircleShape, modifier = modifier.size(size)) {
Box(contentAlignment = Alignment.Center) {
Image(
painter = painterResource(id = R.drawable.ic_plate),
contentDescription = stringResource(id = R.string.content_description_icon_plate),
contentScale = ContentScale.Crop,
modifier = Modifier.fillMaxSize()
)
var isVisible by remember { mutableStateOf(false) }
imageModel?.let {
Card(
shape = CircleShape,
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp),
modifier = if (isVisible) Modifier.size(size.div(2)) else Modifier
) {
CoilImage(
imageModel = { it },
success = { _, painter ->
isVisible = true
Image(
painter = painter,
contentDescription = "Loaded image",
modifier = Modifier.fillMaxSize() // Adjust modifier as needed
)
},
failure = {
isVisible = false
}
)
}
}
}
}
}
@Composable
fun DropDownMenu(modifier: Modifier = Modifier, measures: List<Measure>) {
var expanded by remember { mutableStateOf(false) }
DropdownMenu(
expanded = expanded,
onDismissRequest = { expanded = false }
) {
measures.forEach {
DropdownMenuItem(
text = { it.label },
onClick = {
expanded = false
}
)
}
}
}
| body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/util/Items.kt | 806745473 |
package com.fitness.recipebuilder.util
import com.fitness.domain.model.nutrition.Ingredient
import com.fitness.domain.model.nutrition.Nutrition
import com.fitness.domain.model.nutrition.Recipe
import enums.EMealType
object RecipeBuilderStateHolder {
private var state: BuilderState = BuilderState()
fun state() = state
fun updateState(newState: BuilderState) {
state = newState
}
fun clearState() {
state = BuilderState()
}
}
data class BuilderState(
val name: String? = null,
val date: Long? = null,
val hour: Int? = null,
val minute: Int? = null,
val type: EMealType? = null,
val recordId: String? = null,
val recipe: Recipe? = null,
val myRecipes: List<Nutrition> = mutableListOf(),
val ingredients: List<Ingredient> = mutableListOf(),
val instructions: List<String> = mutableListOf(),
val searchResults: List<Ingredient> = emptyList(),
)
enum class RecipeSelectionStep {
PENDING,
NAME,
CREATE,
MODIFY,
}
enum class RecipeBuilderStep {
PENDING,
COMPLETE
}
| body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/util/RecipeBuilderStateHolder.kt | 1548905130 |
package com.fitness.recipebuilder.navigation
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavGraphBuilder
import androidx.navigation.NavHostController
import androidx.navigation.compose.composable
import androidx.navigation.navigation
import com.fitness.navigation.Destinations
import com.fitness.recipebuilder.RecipeBuilderEntry
import com.fitness.recipebuilder.screens.builder.RecipeBuilder
import com.fitness.recipebuilder.screens.builder.RecipeBuilderViewModel
import com.fitness.recipebuilder.screens.confirmation.SaveAndConfirm
import com.fitness.recipebuilder.screens.confirmation.SaveConfirmViewModel
import com.fitness.recipebuilder.screens.date.PickDate
import com.fitness.recipebuilder.screens.date.PickDateViewModel
import com.fitness.recipebuilder.screens.recipes.RecipeSelection
import com.fitness.recipebuilder.screens.recipes.RecipeSelectionViewModel
import com.fitness.recipebuilder.screens.search.IngredientSearch
import com.fitness.recipebuilder.screens.search.IngredientSearchViewModel
import com.fitness.recipebuilder.screens.time.PickTime
import com.fitness.recipebuilder.screens.time.PickTimeViewModel
import extensions.cast
import javax.inject.Inject
class RecipeBuilderEntryImpl @Inject constructor(): RecipeBuilderEntry {
override val featureRoute: String get() = "recipe-builder"
companion object{
const val MY_RECIPES: String = "my-recipes"
const val RECIPE_BUILDER: String = "recipe-build"
const val INGREDIENTS: String = "search-ingredients"
const val DATE: String = "pick-date"
const val TIME: String = "pick-time"
const val MEAL_TYPE: String = "pick-meal-type"
const val CONFIRMATION: String = "confirmation"
}
override fun NavGraphBuilder.navigation(navController: NavHostController, destinations: Destinations) {
navigation(startDestination = MY_RECIPES, route = featureRoute) {
composable(MY_RECIPES){
val viewModel: RecipeSelectionViewModel = hiltViewModel()
RecipeSelection(
state = viewModel.uiState.cast(),
onPopBack = { navController.popBackStack() },
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onNavigate = { navController.navigate(it) }
)
}
composable(RECIPE_BUILDER){
val viewModel: RecipeBuilderViewModel = hiltViewModel()
RecipeBuilder(
state = viewModel.uiState.cast(),
onPopBack = { navController.popBackStack() },
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onIngredientSearch = {navController.navigate(INGREDIENTS)}
)
}
composable(INGREDIENTS){
val viewModel: IngredientSearchViewModel = hiltViewModel()
IngredientSearch(
state = viewModel.uiState.cast(),
onPopBack = { navController.popBackStack() },
onTriggerEvent = { viewModel.onTriggerEvent(it) }
)
}
composable(DATE) {
val viewModel: PickDateViewModel = hiltViewModel()
PickDate(
state = viewModel.uiState.cast(),
onPopBack = { navController.popBackStack() },
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onPickTime = { navController.navigate(TIME) }
)
}
composable(TIME) {
val viewModel: PickTimeViewModel = hiltViewModel()
PickTime(
state = viewModel.uiState.cast(),
onPopBack = { navController.popBackStack() },
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onConfirmation = { navController.navigate(MEAL_TYPE) }
)
}
composable(MEAL_TYPE) {
val viewModel: PickTimeViewModel = hiltViewModel()
PickTime(
state = viewModel.uiState.cast(),
onPopBack = { navController.popBackStack() },
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onConfirmation = { navController.navigate(MY_RECIPES) }
)
}
composable(CONFIRMATION) {
val viewModel: SaveConfirmViewModel = hiltViewModel()
SaveAndConfirm(
state = viewModel.uiState.cast(),
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onPopBack = { navController.popBackStack() },
onComplete = {
navController.navigate(MY_RECIPES)
},
)
}
}
}
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/navigation/RecipeBuilderEntryImpl.kt | 3218366639 |
package com.fitness.recipebuilder.screens.mealtype
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.component.screens.SelectMealType
import com.fitness.recipebuilder.util.RecipeBuilderStep
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun PreviewPickMealType() = BodyBalanceTheme {
Surface {
PickMealTypeContent(onTriggerEvent = {})
}
}
@Composable
fun PickMealType(
state: StateFlow<BaseViewState<PickMealTypeState>>,
onTriggerEvent: (PickMealTypeEvent) -> Unit,
onPopBack: () -> Unit = {},
onConfirmation: () -> Unit = {}
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
val currentState = uiState.cast<BaseViewState.Data<PickMealTypeState>>().value
if (currentState.step == RecipeBuilderStep.PENDING) {
PickMealTypeContent(onTriggerEvent)
} else {
onConfirmation()
}
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
private fun PickMealTypeContent(onTriggerEvent: (PickMealTypeEvent) -> Unit) {
SelectMealType(
onConfirm = {
onTriggerEvent(PickMealTypeEvent.MealTypeSelected(type = it))
}
)
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/mealtype/PickMealType.kt | 1816037102 |
package com.fitness.recipebuilder.screens.mealtype
import com.fitness.recipebuilder.util.RecipeBuilderStep
import enums.EMealType
data class PickMealTypeState(val step: RecipeBuilderStep = RecipeBuilderStep.PENDING)
sealed class PickMealTypeEvent{
data class MealTypeSelected(val type: EMealType): PickMealTypeEvent()
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/mealtype/PickMealTypeContract.kt | 429867506 |
package com.fitness.recipebuilder.screens.mealtype
import com.fitness.recipebuilder.util.RecipeBuilderStep
import com.fitness.recipebuilder.util.RecipeBuilderStateHolder
import dagger.hilt.android.lifecycle.HiltViewModel
import failure.GenericFailure
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class PickMealTypeViewModel @Inject constructor(private val stateHolder: RecipeBuilderStateHolder) : IntentViewModel<BaseViewState<PickMealTypeState>, PickMealTypeEvent>() {
init { initialize() }
override fun onTriggerEvent(event: PickMealTypeEvent) {
if(event is PickMealTypeEvent.MealTypeSelected){
onTimeSelected(event)
}else{
handleError(GenericFailure())
}
}
private fun initialize() = setState(BaseViewState.Data(PickMealTypeState()))
private fun onTimeSelected(event: PickMealTypeEvent.MealTypeSelected) = safeLaunch {
val state = stateHolder.state().copy(type = event.type)
stateHolder.updateState(state)
setState(BaseViewState.Data(PickMealTypeState(step = RecipeBuilderStep.COMPLETE)))
}
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/mealtype/PickMealTypeViewModel.kt | 297481509 |
package com.fitness.recipebuilder.screens.date
import com.fitness.recipebuilder.util.RecipeBuilderStep
data class PickDateState(val step: RecipeBuilderStep = RecipeBuilderStep.PENDING)
sealed class PickDateEvent{
data class DateSelected(val date: Long): PickDateEvent()
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/date/PickDateContract.kt | 1424934619 |
package com.fitness.recipebuilder.screens.date
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import com.fitness.component.screens.BalanceDatePicker
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.resources.R
import com.fitness.recipebuilder.util.RecipeBuilderStep
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun PreviewPickDate() = BodyBalanceTheme {
Surface {
PickDateContent(onTriggerEvent = {})
}
}
@Composable
fun PickDate(
state: StateFlow<BaseViewState<PickDateState>>,
onTriggerEvent: (PickDateEvent) -> Unit,
onPopBack: () -> Unit = {},
onPickTime: () -> Unit = {}
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
val currentState = uiState.cast<BaseViewState.Data<PickDateState>>().value
if(currentState.step == RecipeBuilderStep.PENDING){
PickDateContent(onTriggerEvent)
}else{
onPickTime()
}
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
private fun PickDateContent(onTriggerEvent: (PickDateEvent) -> Unit) {
BalanceDatePicker(onDatesPicked = { onTriggerEvent(PickDateEvent.DateSelected(it)) })
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/date/PickDate.kt | 332729500 |
package com.fitness.recipebuilder.screens.date
import com.fitness.recipebuilder.util.RecipeBuilderStep
import com.fitness.recipebuilder.util.RecipeBuilderStateHolder
import dagger.hilt.android.lifecycle.HiltViewModel
import failure.GenericFailure
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class PickDateViewModel @Inject constructor(private val searchStateHolder: RecipeBuilderStateHolder, ) : IntentViewModel<BaseViewState<PickDateState>, PickDateEvent>() {
init { initialize() }
override fun onTriggerEvent(event: PickDateEvent) {
if(event is PickDateEvent.DateSelected){
onDateSelected(event)
}else{
handleError(GenericFailure())
}
}
private fun initialize() = setState(BaseViewState.Data(PickDateState()))
private fun onDateSelected(event: PickDateEvent.DateSelected) = safeLaunch {
val state = searchStateHolder.state().copy(date = event.date)
searchStateHolder.updateState(state)
setState(
BaseViewState.Data(
PickDateState(step = RecipeBuilderStep.COMPLETE)
)
)
}
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/date/PickDateViewModel.kt | 171836124 |
package com.fitness.recipebuilder.screens.confirmation
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.res.stringResource
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.resources.R
import com.fitness.recipebuilder.util.RecipeBuilderStep
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
import util.convertLongToDate
import util.formatTimeWithAmPm
@Light
@Dark
@Composable
private fun PreviewConfirmation() = BodyBalanceTheme {
Surface {
ConfirmationContent(state = SaveAndConfirmState(), onComplete = {})
}
}
@Composable
fun SaveAndConfirm(
state: StateFlow<BaseViewState<SaveAndConfirmState>>,
onTriggerEvent: (SaveAndConfirmEvent) -> Unit,
onComplete: () -> Unit = {},
onPopBack: () -> Unit = {},
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
val currentState = uiState.cast<BaseViewState.Data<SaveAndConfirmState>>().value
if(currentState.step == RecipeBuilderStep.PENDING){
onTriggerEvent(SaveAndConfirmEvent.Save)
}else{
ConfirmationContent(uiState.cast<BaseViewState.Data<SaveAndConfirmState>>().value, onComplete)
}
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
private fun ConfirmationContent(
state: SaveAndConfirmState,
onComplete: () -> Unit
) {
MessageScreen(
message = stringResource(
id = R.string.meal_success_message,
convertLongToDate(state.date),
formatTimeWithAmPm(state.hour, state.minute)
),
onClick = onComplete
)
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/confirmation/SaveAndConfirmation.kt | 3811042499 |
package com.fitness.recipebuilder.screens.confirmation
import com.fitness.recipebuilder.util.RecipeBuilderStep
data class SaveAndConfirmState(
val date: Long? = null,
val hour: Int? = null,
val minute: Int? = null,
val step: RecipeBuilderStep = RecipeBuilderStep.PENDING,
)
sealed class SaveAndConfirmEvent {
object Save : SaveAndConfirmEvent()
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/confirmation/SaveAndConfirmContract.kt | 446763699 |
package com.fitness.recipebuilder.screens.confirmation
import com.fitness.domain.usecase.nutrition.CreateNutritionRecordUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.recipebuilder.util.RecipeBuilderStateHolder
import com.fitness.recipebuilder.util.RecipeBuilderStep
import dagger.hilt.android.lifecycle.HiltViewModel
import failure.GenericFailure
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class SaveConfirmViewModel @Inject constructor(
private val stateHolder: RecipeBuilderStateHolder,
private val getCurrentUserIdUseCase: GetCurrentUserIdUseCase,
private val createNutritionRecordUseCase: CreateNutritionRecordUseCase,
) : IntentViewModel<BaseViewState<SaveAndConfirmState>, SaveAndConfirmEvent>() {
init {
initialize()
}
override fun onTriggerEvent(event: SaveAndConfirmEvent) {
if(event is SaveAndConfirmEvent.Save){
onSaveNutritionRecord()
}else {
handleError(GenericFailure())
}
}
override fun handleError(exception: Throwable) {
super.handleError(exception)
exception.printStackTrace()
}
private fun initialize() = setState(BaseViewState.Data(SaveAndConfirmState(step = RecipeBuilderStep.PENDING)))
private fun onSaveNutritionRecord() = safeLaunch {
execute(getCurrentUserIdUseCase(GetCurrentUserIdUseCase.Params)) {
onVerify(it)
}
}
private fun onVerify(id: String){
val state = stateHolder.state()
val date = state.date
val hour = state.hour
val minute = state.minute
val type = state.type
if(date != null && hour != null && minute != null && type != null){
// val params = CreateNutritionRecordUseCase.Params(
// userId = id,
// date = state.date,
// hour = state.hour,
// minute = state.minute,
// mealType = state.type
// )
// saveNutritionRecord(params)
}else{
setState(BaseViewState.Error(GenericFailure()))
}
}
private fun saveNutritionRecord(params: CreateNutritionRecordUseCase.Params) = safeLaunch {
val state = stateHolder.state()
execute(createNutritionRecordUseCase(params)) {
setState(
BaseViewState.Data(
SaveAndConfirmState(
step = RecipeBuilderStep.COMPLETE,
date = state.date,
hour = state.hour,
minute = state.minute
)
)
)
}
}
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/confirmation/SaveConfirmViewModel.kt | 2090680483 |
package com.fitness.recipebuilder.screens.time
import com.fitness.recipebuilder.util.RecipeBuilderStep
data class PickTimeState(val step: RecipeBuilderStep = RecipeBuilderStep.PENDING, )
sealed class PickTimeEvent{
data class TimeSelected(val hour: Int, val minute: Int): PickTimeEvent()
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/time/PickTimeContract.kt | 2202008210 |
package com.fitness.recipebuilder.screens.time
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import com.fitness.component.screens.BalanceTimePicker
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.resources.R
import com.fitness.recipebuilder.util.RecipeBuilderStep
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun PreviewPickTime() = BodyBalanceTheme {
Surface {
PickTimeContent(onTriggerEvent = {})
}
}
@Composable
fun PickTime(
state: StateFlow<BaseViewState<PickTimeState>>,
onTriggerEvent: (PickTimeEvent) -> Unit,
onPopBack: () -> Unit = {},
onConfirmation: () -> Unit = {}
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
val currentState = uiState.cast<BaseViewState.Data<PickTimeState>>().value
if(currentState.step == RecipeBuilderStep.PENDING){
PickTimeContent(onTriggerEvent)
}else{
onConfirmation()
}
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
private fun PickTimeContent(onTriggerEvent: (PickTimeEvent) -> Unit) {
BalanceTimePicker(
onTimePicked = {hour, minute ->
onTriggerEvent(PickTimeEvent.TimeSelected(hour = hour, minute = minute))
}
)
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/time/PickTime.kt | 2925110026 |
package com.fitness.recipebuilder.screens.time
import com.fitness.recipebuilder.util.RecipeBuilderStep
import com.fitness.recipebuilder.util.RecipeBuilderStateHolder
import dagger.hilt.android.lifecycle.HiltViewModel
import failure.GenericFailure
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class PickTimeViewModel @Inject constructor(private val searchStateHolder: RecipeBuilderStateHolder, ) : IntentViewModel<BaseViewState<PickTimeState>, PickTimeEvent>() {
init { initialize() }
override fun onTriggerEvent(event: PickTimeEvent) {
if(event is PickTimeEvent.TimeSelected){
onTimeSelected(event)
}else{
handleError(GenericFailure())
}
}
private fun initialize() = setState(BaseViewState.Data(PickTimeState()))
private fun onTimeSelected(event: PickTimeEvent.TimeSelected) = safeLaunch {
val state = searchStateHolder.state().copy(hour = event.hour, minute = event.minute)
searchStateHolder.updateState(state)
setState(BaseViewState.Data(PickTimeState(step = RecipeBuilderStep.COMPLETE,)))
}
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/time/PickTimeViewModel.kt | 2461092715 |
package com.fitness.recipebuilder.screens.search
import com.fitness.domain.model.nutrition.Ingredient
import com.fitness.recipebuilder.util.RecipeBuilderStep
data class IngredientSearchState(
val autoComplete: List<String> = emptyList(),
val searchResults: List<Ingredient> = emptyList(),
val ingredients: List<Ingredient> = emptyList(),
val step: RecipeBuilderStep = RecipeBuilderStep.PENDING
)
sealed class IngredientSearchEvent{
data class AutoComplete(val search: String): IngredientSearchEvent()
data class Search(val search: String): IngredientSearchEvent()
data class AddIngredient(val ingredient: Ingredient, val ingredients: List<Ingredient>): IngredientSearchEvent()
data class RemoveIngredient(val ingredient: Ingredient, val ingredients: List<Ingredient>): IngredientSearchEvent()
data class CloseIngredientBuilder(val ingredients: List<Ingredient>): IngredientSearchEvent()
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/search/IngredientSearchContract.kt | 2536870152 |
package com.fitness.recipebuilder.screens.search
import com.fitness.domain.model.user.UserBasicNutritionInfo
import com.fitness.domain.usecase.search.EdamamAutoCompleteUseCase
import com.fitness.domain.usecase.search.EdamamFetchAllIngredientsUseCase
import com.fitness.domain.usecase.search.EdamamIngredientSearchUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.domain.usecase.user.GetUserBasicNutritionInfoUseCase
import com.fitness.recipebuilder.util.RecipeBuilderStateHolder
import com.fitness.recipebuilder.util.RecipeBuilderStep
import dagger.hilt.android.lifecycle.HiltViewModel
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class IngredientSearchViewModel @Inject constructor(
private val stateHolder: RecipeBuilderStateHolder,
private val getCurrentUserIdUseCase: GetCurrentUserIdUseCase,
private val getNutritionalInfoUseCase: GetUserBasicNutritionInfoUseCase,
private val getAllIngredientsUseCase: EdamamFetchAllIngredientsUseCase,
private val edamamAutoCompleteUseCase: EdamamAutoCompleteUseCase,
private val edamamFoodSearchUseCase: EdamamIngredientSearchUseCase,
) : IntentViewModel<BaseViewState<IngredientSearchState>, IngredientSearchEvent>() {
init {
initialize()
}
override fun onTriggerEvent(event: IngredientSearchEvent) {
when (event) {
is IngredientSearchEvent.AutoComplete -> onAutoComplete(event)
is IngredientSearchEvent.Search -> onIngredientSearch(event)
is IngredientSearchEvent.AddIngredient -> onAddIngredient(event)
is IngredientSearchEvent.RemoveIngredient -> onRemoveIngredient(event)
is IngredientSearchEvent.CloseIngredientBuilder -> onCloseRecipeBuilder(event)
}
}
override fun handleError(exception: Throwable) {
super.handleError(exception)
exception.printStackTrace()
}
private fun initialize() = safeLaunch {
execute(getCurrentUserIdUseCase(GetCurrentUserIdUseCase.Params)) {
currentUserNutritionalInfo(it)
}
}
private fun currentUserNutritionalInfo(id: String) = safeLaunch {
val state = RecipeBuilderStateHolder.state().copy(ingredients = mutableListOf())
RecipeBuilderStateHolder.updateState(state)
val params = GetUserBasicNutritionInfoUseCase.Params(id = id)
execute(getNutritionalInfoUseCase(params)) {
onFetchContentFromCacheIfExist(it)
}
}
private fun onFetchContentFromCacheIfExist(nutrition: UserBasicNutritionInfo) = safeLaunch {
val param = EdamamFetchAllIngredientsUseCase.Params
execute(getAllIngredientsUseCase(param)) {
val state = stateHolder.state().copy(searchResults = it)
stateHolder.updateState(state)
setState(BaseViewState.Data(IngredientSearchState(searchResults = state.searchResults)))
}
}
private fun onAutoComplete(event: IngredientSearchEvent.AutoComplete) = safeLaunch {
val param = EdamamAutoCompleteUseCase.Params(event.search)
call(edamamAutoCompleteUseCase(param)) {
val state = stateHolder.state()
setState(
BaseViewState.Data(
IngredientSearchState(
autoComplete = it,
searchResults = state.searchResults
)
)
)
}
}
private fun onIngredientSearch(event: IngredientSearchEvent.Search) = safeLaunch {
stateHolder.updateState(stateHolder.state().copy(searchResults = emptyList()))
val param = EdamamIngredientSearchUseCase.Params(event.search)
execute(edamamFoodSearchUseCase(param)) {
val state = stateHolder.state().copy(searchResults = it)
stateHolder.updateState(state)
setState(BaseViewState.Data(IngredientSearchState(searchResults = it)))
}
}
private fun onAddIngredient(event: IngredientSearchEvent.AddIngredient) = safeLaunch {
val state = stateHolder.state()
val ingredient = event.ingredient
val ingredients = event.ingredients.toMutableList()
ingredients.add(ingredient)
setState(
BaseViewState.Data(
IngredientSearchState(
searchResults = state.searchResults,
ingredients = ingredients
)
)
)
}
private fun onRemoveIngredient(event: IngredientSearchEvent.RemoveIngredient) = safeLaunch {
val state = stateHolder.state()
val ingredient = event.ingredient
val ingredients = event.ingredients.toMutableList()
ingredients.remove(ingredient)
setState(
BaseViewState.Data(
IngredientSearchState(
searchResults = state.searchResults,
ingredients = ingredients
)
)
)
}
private fun onCloseRecipeBuilder(event: IngredientSearchEvent.CloseIngredientBuilder) = safeLaunch {
val state = stateHolder.state().copy(ingredients = event.ingredients)
stateHolder.updateState(state)
setState(BaseViewState.Data(IngredientSearchState(step = RecipeBuilderStep.COMPLETE)))
}
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/search/IngredientSearchViewModel.kt | 2647545628 |
package com.fitness.recipebuilder.screens.search
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.core.MutableTransitionState
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.asPaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.ime
import androidx.compose.foundation.layout.isImeVisible
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Search
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextFieldDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableDoubleStateOf
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.runtime.toMutableStateList
import androidx.compose.ui.Alignment
import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import androidx.constraintlayout.compose.ConstraintLayout
import androidx.constraintlayout.compose.Dimension
import com.fitness.component.components.CircleProgressWithTextComponent
import com.fitness.component.components.SquareItem
import com.fitness.component.properties.GuidelineProperties
import com.fitness.component.screens.ErrorDialog
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageDialog
import com.fitness.component.screens.MessageScreen
import com.fitness.data.util.TotalNutrientsKeys
import com.fitness.domain.model.nutrition.Ingredient
import com.fitness.domain.model.nutrition.Measure
import com.fitness.domain.model.nutrition.Qualified
import com.fitness.domain.model.nutrition.Qualifier
import com.fitness.recipebuilder.util.NutritionItem
import com.fitness.recipebuilder.util.RecipeBuilderStep
import com.fitness.recipebuilder.util.SmallNutritionItem
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import com.fitness.theme.ui.Red
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
import kotlin.math.abs
@Light
@Dark
@Composable
fun MetricSelectionDialogPreview(
onContinue: (String) -> Unit = {},
onDismissRequest: () -> Unit = {}
) = BodyBalanceTheme {
Surface {
MetricSelectionDialog(measuresForPreview)
}
}
@Light
@Dark
@Composable
fun ModifyMetricSelectionDialogPreview(
onContinue: (String) -> Unit = {},
onDismissRequest: () -> Unit = {}
) = BodyBalanceTheme {
Surface {
ModifyMetricSelectionDialog(ingredientForPreview)
}
}
@Light
@Dark
@Composable
private fun PreviewIngredientSearch() = BodyBalanceTheme {
Surface {
IngredientSearchContent(
state = IngredientSearchState(
ingredients = ingredientsForPreview,
searchResults = searchResultsForPreview
),
onTriggerEvent = {}
)
}
}
@Light
@Dark
@Composable
private fun PreviewIngredientSearchEmpty() = BodyBalanceTheme {
Surface {
IngredientSearchContent(
state = IngredientSearchState(searchResults = searchResultsForPreview),
onTriggerEvent = {}
)
}
}
@Composable
fun IngredientSearch(
state: StateFlow<BaseViewState<IngredientSearchState>>,
onTriggerEvent: (IngredientSearchEvent) -> Unit,
onPopBack: () -> Unit = {},
onPickDate: () -> Unit = {}
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
val currentState = uiState.cast<BaseViewState.Data<IngredientSearchState>>().value
if (currentState.step == RecipeBuilderStep.PENDING) {
IngredientSearchContent(state = currentState, onTriggerEvent = onTriggerEvent)
} else {
onPickDate()
}
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
@OptIn(ExperimentalLayoutApi::class, ExperimentalComposeUiApi::class)
private fun IngredientSearchContent(
state: IngredientSearchState,
onTriggerEvent: (IngredientSearchEvent) -> Unit
) {
val ime = WindowInsets.ime
val insets = ime.asPaddingValues().calculateBottomPadding()
val keyboardController = LocalSoftwareKeyboardController.current
val focusManager = LocalFocusManager.current
val isImeVisible = WindowInsets.isImeVisible
ConstraintLayout(
modifier = Modifier
.fillMaxSize()
.padding(bottom = if (isImeVisible) insets else 0.dp)
.pointerInput(Unit) {
detectTapGestures(onPress = {}) {
focusManager.clearFocus()
keyboardController?.hide()
}
}
) {
val (metrics, searchField, ingredients, autoComplete) = createRefs()
var search by remember { mutableStateOf("") }
var isFocused by remember { mutableStateOf(false) }
val startGuide = createGuidelineFromStart(GuidelineProperties.START)
val endGuide = createGuidelineFromEnd(GuidelineProperties.END)
val bottomGuide = createGuidelineFromBottom(GuidelineProperties.BOTTOM)
var totalEnergy by remember { mutableDoubleStateOf(0.0) }
var totalProtein by remember { mutableDoubleStateOf(0.0) }
var totalFat by remember { mutableDoubleStateOf(0.0) }
var totalCarbs by remember { mutableDoubleStateOf(0.0) }
var totalFiber by remember { mutableDoubleStateOf(0.0) }
var selectedIngredient by remember { mutableStateOf<Ingredient?>(null) }
val selectedIngredients = remember { state.ingredients.toMutableStateList() }
var showConfirmDialog by remember { mutableStateOf(false) }
var showSelectMetricsDialog by remember { mutableStateOf(false) }
var showModifyMetricsDialog by remember { mutableStateOf(false) }
SelectedIngredientsSummary(
ingredients = selectedIngredients,
onClickModify = {
selectedIngredient = it
showModifyMetricsDialog = true
},
totalEnergy = totalEnergy,
totalProtein = totalProtein,
totalFat = totalFat,
totalCarbs = totalCarbs,
totalFiber = totalFiber,
modifier = Modifier.constrainAs(metrics) {
end.linkTo(parent.end)
top.linkTo(parent.top)
start.linkTo(parent.start)
width = Dimension.fillToConstraints
}
)
LazyColumn(
modifier = Modifier
.fillMaxWidth()
.constrainAs(ingredients) {
top.linkTo(metrics.bottom)
bottom.linkTo(parent.bottom)
height = Dimension.fillToConstraints
},
verticalArrangement = Arrangement.spacedBy(10.dp)
) {
item { Spacer(modifier = Modifier.size(10.dp)) }
items(state.searchResults) {
val energy = it.nutrients?.get(TotalNutrientsKeys.KEY_ENERGY)?.quantity
val fat = it.nutrients?.get(TotalNutrientsKeys.KEY_TOTAL_FAT)?.quantity
val protein = it.nutrients?.get(TotalNutrientsKeys.KEY_PROTEIN)?.quantity
val carbs = it.nutrients?.get(TotalNutrientsKeys.KEY_CARBOHYDRATES)?.quantity
val fiber = it.nutrients?.get(TotalNutrientsKeys.KEY_FIBER)?.quantity
val net = abs((carbs ?: 0.0) - (fiber ?: 0.0))
it.name?.let { title ->
NutritionItem(
title = title,
imageModel = it.image,
energy = energy,
fat = fat,
protein = protein,
net = net,
onClickItem = {
selectedIngredient = it
if (selectedIngredients.contains(it)) {
showModifyMetricsDialog = true
} else {
showConfirmDialog = true
}
}
)
}
}
item { Spacer(modifier = Modifier.size(75.dp)) }
}
AutoComplete(
autoComplete = state.autoComplete,
isFocused = isFocused,
isSearchable = search.isNotEmpty(),
onClick = {
search = it
focusManager.clearFocus()
onTriggerEvent(IngredientSearchEvent.Search(search = search))
},
modifier = Modifier.constrainAs(autoComplete) {
end.linkTo(endGuide)
start.linkTo(startGuide)
bottom.linkTo(searchField.bottom)
width = Dimension.fillToConstraints
}
)
SearchBox(
search = search,
onValueChange = { search = it },
onClick = { onTriggerEvent(IngredientSearchEvent.Search(search = search)) },
modifier = Modifier
.onFocusChanged { isFocused = it.isFocused }
.constrainAs(searchField) {
end.linkTo(endGuide)
start.linkTo(startGuide)
bottom.linkTo(bottomGuide)
width = Dimension.fillToConstraints
}
)
if (showConfirmDialog && selectedIngredient != null) {
selectedIngredient?.name?.let {
MessageDialog(
title = stringResource(id = R.string.confirmation_dialog_title),
description = stringResource(id = R.string.confirmation_dialog_description, selectedIngredient?.name ?: ""),
onContinue = {
showConfirmDialog = false
showSelectMetricsDialog = true
},
onCancel = { showConfirmDialog = false }
)
} ?: run {
selectedIngredient = null
showConfirmDialog = false
}
}
if (showSelectMetricsDialog && selectedIngredient != null) {
selectedIngredient!!.measures?.let {
MetricSelectionDialog(
inMeasures = it,
onContinue = { measure, qualifier, quantity ->
val ingredient = selectedIngredient!!.copy(
measureName = measure.label,
measureWeight = measure.weight,
measureUri = measure.uri,
quantity = quantity,
qualifiedName = qualifier?.label,
qualifiedWeight = qualifier?.weight,
qualifiedUri = qualifier?.uri
)
totalEnergy += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_ENERGY)?.quantity ?: 0.0
totalFat += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_TOTAL_FAT)?.quantity ?: 0.0
totalProtein += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_PROTEIN)?.quantity ?: 0.0
totalCarbs += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_CARBOHYDRATES)?.quantity ?: 0.0
totalFiber += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_FIBER)?.quantity ?: 0.0
selectedIngredients.add(ingredient)
showSelectMetricsDialog = false
},
onDismissRequest = {
selectedIngredient = null
showSelectMetricsDialog = false
}
)
} ?: run {
ErrorDialog(
title = stringResource(id = R.string.error_title_incomplete_data),
description = stringResource(id = R.string.error_message_incomplete_data),
onDismiss = {
selectedIngredient = null
showSelectMetricsDialog = false
}
)
}
}
if (showModifyMetricsDialog) {
selectedIngredient?.let {
val tempEnergy = selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_ENERGY)?.quantity ?: 0.0
val tempFat = selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_TOTAL_FAT)?.quantity ?: 0.0
val tempProtein = selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_PROTEIN)?.quantity ?: 0.0
val tempCarbs = selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_CARBOHYDRATES)?.quantity ?: 0.0
val tempFiber = selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_FIBER)?.quantity ?: 0.0
ModifyMetricSelectionDialog(
ingredient = it,
onContinue = { measure, qualifier, quantity ->
val indexOf = selectedIngredients.indexOf(selectedIngredient)
val ingredient = selectedIngredients[indexOf].copy(
measureName = measure.label,
measureWeight = measure.weight,
measureUri = measure.uri,
quantity = quantity,
qualifiedName = qualifier?.label,
qualifiedWeight = qualifier?.weight,
qualifiedUri = qualifier?.uri
)
totalEnergy += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_ENERGY)?.quantity ?: 0.0
totalFat += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_TOTAL_FAT)?.quantity ?: 0.0
totalProtein += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_PROTEIN)?.quantity ?: 0.0
totalCarbs += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_CARBOHYDRATES)?.quantity ?: 0.0
totalFiber += selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_FIBER)?.quantity ?: 0.0
totalEnergy -= tempEnergy
totalFat -= tempFat
totalProtein -= tempProtein
totalCarbs -= tempCarbs
totalFiber -= tempFiber
selectedIngredients.remove(selectedIngredient)
selectedIngredients.add(ingredient)
showModifyMetricsDialog = false
},
onDismiss = {
selectedIngredient = null
showModifyMetricsDialog = false
},
onRemove = {
totalEnergy -= selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_ENERGY)?.quantity ?: 0.0
totalFat -= selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_TOTAL_FAT)?.quantity ?: 0.0
totalProtein -= selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_PROTEIN)?.quantity ?: 0.0
totalCarbs -= selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_CARBOHYDRATES)?.quantity ?: 0.0
totalFiber -= selectedIngredient?.nutrients?.get(TotalNutrientsKeys.KEY_FIBER)?.quantity ?: 0.0
selectedIngredients.remove(selectedIngredient)
selectedIngredient = null
showModifyMetricsDialog = false
}
)
} ?: run {
ErrorDialog(
title = stringResource(id = R.string.error_title_incomplete_data),
description = stringResource(id = R.string.error_message_incomplete_data),
onDismiss = { showModifyMetricsDialog = false }
)
}
}
LaunchedEffect(key1 = search) {
if (search.isNotEmpty()) {
onTriggerEvent(IngredientSearchEvent.AutoComplete(search))
}
}
}
}
@Composable
private fun AutoComplete(
isFocused: Boolean,
isSearchable: Boolean,
autoComplete: List<String>,
modifier: Modifier,
onClick: (String) -> Unit
) {
if (isFocused && isSearchable && autoComplete.isNotEmpty()) {
LazyColumn(
modifier = modifier
.wrapContentHeight()
.background(
color = MaterialTheme.colorScheme.surfaceVariant,
RoundedCornerShape(40.dp)
)
.padding(start = 15.dp, end = 15.dp, top = 15.dp, bottom = 65.dp)
) {
items(autoComplete) { suggestion ->
Text(
text = suggestion,
modifier = Modifier
.padding(2.dp)
.clickable {
onClick(suggestion)
}
)
}
}
}
}
@Composable
private fun SearchBox(
search: String,
modifier: Modifier,
onValueChange: (String) -> Unit,
onClick: () -> Unit
) {
OutlinedTextField(
value = search,
onValueChange = { onValueChange(it) },
singleLine = true,
trailingIcon = {
Icon(
imageVector = Icons.Default.Search,
contentDescription = stringResource(id = R.string.content_description_search),
modifier = Modifier.clickable { onClick() }
)
},
shape = RoundedCornerShape(40.dp),
colors = TextFieldDefaults
.colors(
focusedContainerColor = MaterialTheme.colorScheme.surfaceVariant,
unfocusedContainerColor = MaterialTheme.colorScheme.surfaceVariant,
),
modifier = modifier.shadow(2.dp, RoundedCornerShape(40.dp))
)
}
@Composable
private fun SelectedIngredientsSummary(
ingredients: List<Ingredient>,
modifier: Modifier,
onClickModify: (Ingredient) -> Unit,
totalEnergy: Double? = 45.0,
totalProtein: Double? = 15.0,
totalFat: Double? = 35.0,
totalCarbs: Double? = 85.0,
totalFiber: Double? = 15.0,
targetEnergy: Double? = 100.0,
targetProtein: Double? = 100.0,
targetFat: Double? = 100.0,
targetNet: Double? = 100.0,
) {
Card(
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp),
shape = RoundedCornerShape(0.dp),
modifier = modifier.size(150.dp)
) {
if (ingredients.isNotEmpty()) {
ConstraintLayout(
modifier = Modifier
.padding(5.dp)
.fillMaxSize()
) {
val (ingredientsRef, metricsRef) = createRefs()
LazyRow(horizontalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier
.padding()
.constrainAs(ingredientsRef) {
top.linkTo(parent.top)
end.linkTo(parent.end)
start.linkTo(parent.start)
width = Dimension.fillToConstraints
}) {
item { Spacer(modifier = Modifier.size(2.dp)) }
items(ingredients) { ingredient ->
ingredient.name?.let { title ->
SmallNutritionItem(
title = title,
onClickModify = { onClickModify(ingredient) }
)
}
}
item { Spacer(modifier = Modifier.size(2.dp)) }
}
Row(horizontalArrangement = Arrangement.SpaceAround,
modifier = Modifier
.fillMaxWidth()
.wrapContentHeight()
.constrainAs(metricsRef) {
top.linkTo(ingredientsRef.bottom)
bottom.linkTo(parent.bottom)
}
) {
if (totalEnergy != null && targetEnergy != null) {
CircleProgressWithTextComponent(
title = stringResource(id = R.string.calories),
currentValue = totalEnergy,
targetValue = targetEnergy,
modifier = Modifier.size(50.dp)
)
}
if (totalProtein != null && targetProtein != null) {
CircleProgressWithTextComponent(
title = stringResource(id = R.string.protein),
currentValue = totalProtein,
targetValue = targetProtein,
modifier = Modifier.size(50.dp)
)
}
if (totalFat != null && targetFat != null) {
CircleProgressWithTextComponent(
title = stringResource(id = R.string.fat),
currentValue = totalFat,
targetValue = targetFat,
modifier = Modifier.size(50.dp)
)
}
val totalNet = totalCarbs?.let { carbs ->
totalFiber?.let { fiber ->
carbs - fiber
}
}
if (totalNet != null && targetNet != null) {
CircleProgressWithTextComponent(
title = stringResource(id = R.string.net_carbs),
currentValue = totalNet,
targetValue = targetNet,
modifier = Modifier.size(50.dp)
)
}
}
}
} else {
Box(
contentAlignment = Alignment.Center, modifier = Modifier
.fillMaxSize()
.padding(20.dp)
) {
Text(
text = stringResource(id = R.string.ingredient_metrics_prompt),
textAlign = TextAlign.Center
)
}
}
}
}
@Composable
fun MetricSelectionDialog(
inMeasures: List<Measure>,
onContinue: (measure: Measure, qualifier: DisplayQualifier?, quantity: Double) -> Unit = { _, _, _ -> },
onDismissRequest: () -> Unit = {}
) {
var showError by remember { mutableStateOf(false) }
var errorId by remember { mutableIntStateOf(-1) }
var quantityText by remember { mutableStateOf("") }
val measures = remember { inMeasures.toMutableList() }
var qualifiers = remember { listOf<DisplayQualifier>() }
var selectedMeasure by remember { mutableStateOf<Measure?>(null) }
var selectedQualifier by remember { mutableStateOf<DisplayQualifier?>(null) }
var selectedMeasureIndexed by remember { mutableIntStateOf(-1) }
var selectedQualifierIndexed by remember { mutableIntStateOf(-1) }
Dialog(onDismissRequest = onDismissRequest) {
Card {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalAlignment = Alignment.Start
) {
Text(text = stringResource(id = R.string.select_base_measure))
Spacer(modifier = Modifier.height(10.dp))
LazyRow(
horizontalArrangement = Arrangement.spacedBy(10.dp),
modifier = Modifier.fillMaxWidth()
) {
item { Spacer(modifier = Modifier.size(1.dp)) }
itemsIndexed(measures) { indexed, measure ->
measure.label?.let {
SquareItem(
title = it,
isSelected = selectedMeasureIndexed == indexed,
onClick = {
selectedMeasure = measure
selectedMeasureIndexed = indexed
qualifiers = measure.qualified?.flatMap { qualified ->
qualified.qualifiers?.map { qualifier ->
DisplayQualifier(
qualifier.label,
qualifier.uri,
qualified.weight
)
} ?: run {
emptyList()
}
} ?: run {
emptyList()
}
}
)
}
}
item { Spacer(modifier = Modifier.size(1.dp)) }
}
val qualifierVisibilityState = remember { MutableTransitionState(false) }
AnimatedVisibility(visibleState = qualifierVisibilityState) {
Column {
Spacer(modifier = Modifier.height(25.dp))
Text(text = stringResource(id = R.string.select_qualified_measure))
Spacer(modifier = Modifier.height(10.dp))
LazyRow(
horizontalArrangement = Arrangement.spacedBy(10.dp),
modifier = Modifier.fillMaxWidth()
) {
item { Spacer(modifier = Modifier.size(1.dp)) }
itemsIndexed(qualifiers) { indexed, qualifier ->
qualifier.label?.let {
SquareItem(
title = it,
isSelected = selectedQualifierIndexed == indexed,
onClick = {
selectedQualifierIndexed = indexed
selectedQualifier = qualifier
}
)
}
}
item { Spacer(modifier = Modifier.size(1.dp)) }
}
}
}
val quantityVisibilityState = remember { MutableTransitionState(false) }
AnimatedVisibility(visibleState = quantityVisibilityState) {
Column {
Spacer(modifier = Modifier.height(25.dp))
Text(
text = stringResource(
id = R.string.enter_base_measure_amount,
selectedMeasure?.label ?: ""
)
)
Spacer(modifier = Modifier.height(10.dp))
OutlinedTextField(
value = quantityText,
onValueChange = {
quantityText = it
showError = false
},
isError = showError,
)
if (showError && errorId != -1) {
Text(
text = stringResource(id = errorId),
color = Red,
modifier = Modifier.padding(top = 4.dp)
)
}
}
}
Spacer(modifier = Modifier.height(50.dp))
Row(horizontalArrangement = Arrangement.End, modifier = Modifier.fillMaxWidth()) {
Button(onClick = onDismissRequest) {
Text(text = stringResource(id = R.string.title_dismiss))
}
Spacer(modifier = Modifier.size(20.dp))
Button(onClick = {
if (selectedMeasure != null && (selectedQualifier != null || qualifiers.isEmpty()) && quantityText.toDoubleOrNull() != null) {
onContinue(
selectedMeasure!!,
selectedQualifier,
quantityText.toDouble()
)
} else {
showError = true
errorId = determineErrorMessage(
selectedMeasure,
selectedQualifier,
quantityText
)
}
}) {
Text(text = stringResource(id = R.string.title_continue))
}
}
LaunchedEffect(key1 = selectedMeasure, selectedQualifier) {
qualifierVisibilityState.targetState =
selectedMeasure != null && qualifiers.isNotEmpty()
quantityVisibilityState.targetState =
selectedMeasure != null && (selectedQualifier != null || qualifiers.isEmpty())
}
}
}
}
}
@Composable
fun ModifyMetricSelectionDialog(
ingredient: Ingredient,
onContinue: (measure: Measure, qualifier: DisplayQualifier?, quantity: Double) -> Unit = { _, _, _ -> },
onDismiss: () -> Unit = {},
onRemove: () -> Unit = {}
) {
var showError by remember { mutableStateOf(false) }
var errorId by remember { mutableIntStateOf(-1) }
var quantityText by remember { mutableStateOf( ingredient.quantity.toString() ) }
val measures = remember { ingredient.measures ?: emptyList() }
val selectedMeasureIndex = measures.indexOfFirst { it.label == ingredient.measureName }
val initialSelectedMeasure = selectedMeasureIndex.let { measures[it] }
var selectedMeasure by remember { mutableStateOf(initialSelectedMeasure) }
var selectedMeasureIndexed by remember { mutableIntStateOf(selectedMeasureIndex) }
var qualifiers = remember(selectedMeasure) {
selectedMeasure.qualified?.flatMap { qualified ->
qualified.qualifiers?.map { qualifier ->
DisplayQualifier(qualifier.label, qualifier.uri, qualified.weight)
} ?: emptyList()
} ?: emptyList()
}
val selectedQualifierIndex = qualifiers.indexOfFirst { it.label == ingredient.qualifiedName }
val initialSelectedQualifier = selectedQualifierIndex.takeIf { it >= 0 }?.let { qualifiers[it] }
var selectedQualifier by remember { mutableStateOf(initialSelectedQualifier) }
var selectedQualifierIndexed by remember { mutableIntStateOf(selectedQualifierIndex) }
val measuresState = rememberLazyListState()
val qualifiersState = rememberLazyListState()
LaunchedEffect(selectedMeasureIndexed) {
measuresState.scrollToItem(selectedMeasureIndexed)
}
LaunchedEffect(selectedQualifierIndexed) {
qualifiersState.scrollToItem(selectedQualifierIndexed)
}
Dialog(onDismissRequest = onDismiss) {
Card {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalAlignment = Alignment.Start
) {
Text(text = stringResource(id = R.string.select_base_measure))
Spacer(modifier = Modifier.height(10.dp))
LazyRow(
state = measuresState,
horizontalArrangement = Arrangement.spacedBy(10.dp),
modifier = Modifier.fillMaxWidth()
) {
item { Spacer(modifier = Modifier.size(1.dp)) }
itemsIndexed(measures) { indexed, measure ->
measure.label?.let { name ->
SquareItem(
title = name,
isSelected = selectedMeasureIndexed == indexed,
onClick = {
selectedMeasure = measure
selectedMeasureIndexed = indexed
qualifiers = measure.qualified?.flatMap { qualified ->
qualified.qualifiers?.map { qualifier ->
DisplayQualifier(qualifier.label, qualifier.uri, qualified.weight)
} ?: run {
emptyList()
}
} ?: run {
emptyList()
}
}
)
}
}
item { Spacer(modifier = Modifier.size(1.dp)) }
}
val qualifierVisibilityState = remember { MutableTransitionState(false) }
AnimatedVisibility(visibleState = qualifierVisibilityState) {
Column {
Spacer(modifier = Modifier.height(25.dp))
Text(text = stringResource(id = R.string.select_qualified_measure))
Spacer(modifier = Modifier.height(10.dp))
LazyRow(
state = qualifiersState,
horizontalArrangement = Arrangement.spacedBy(10.dp),
modifier = Modifier.fillMaxWidth()
) {
item { Spacer(modifier = Modifier.size(1.dp)) }
itemsIndexed(qualifiers) { indexed, qualifier ->
qualifier.label?.let {
SquareItem(
title = it,
isSelected = selectedQualifierIndexed == indexed,
onClick = {
selectedQualifierIndexed = indexed
selectedQualifier = qualifier
}
)
}
}
item { Spacer(modifier = Modifier.size(1.dp)) }
}
}
}
val quantityVisibilityState = remember { MutableTransitionState(false) }
AnimatedVisibility(visibleState = quantityVisibilityState) {
Column {
Spacer(modifier = Modifier.height(25.dp))
Text(
text = stringResource(
id = R.string.enter_base_measure_amount,
selectedMeasure.label ?: ""
)
)
Spacer(modifier = Modifier.height(10.dp))
OutlinedTextField(
value = quantityText,
onValueChange = {
quantityText = it
showError = false
},
isError = showError,
)
if (showError && errorId != -1) {
Text(
text = stringResource(id = errorId),
color = Red,
modifier = Modifier.padding(top = 4.dp)
)
}
}
}
Spacer(modifier = Modifier.height(50.dp))
Row(horizontalArrangement = Arrangement.SpaceEvenly, modifier = Modifier.fillMaxWidth()) {
Button(onClick = onDismiss) {
Text(text = stringResource(id = R.string.title_dismiss))
}
Spacer(modifier = Modifier.size(20.dp))
Button(
onClick = onRemove,
colors = ButtonDefaults.buttonColors(containerColor = Red)
) {
Text(text = stringResource(id = R.string.title_remove))
}
}
Spacer(modifier = Modifier.height(5.dp))
OutlinedButton(modifier = Modifier.fillMaxWidth().padding(15.dp), onClick = {
if (quantityText.toDoubleOrNull() != null) {
onContinue(selectedMeasure, selectedQualifier, quantityText.toDouble())
} else {
showError = true
errorId = determineErrorMessage(
selectedMeasure,
selectedQualifier,
quantityText
)
}
}) {
Text(text = stringResource(id = R.string.title_continue))
}
LaunchedEffect(key1 = selectedMeasure, selectedQualifier) {
qualifierVisibilityState.targetState = qualifiers.isNotEmpty()
quantityVisibilityState.targetState = qualifiers.isEmpty()
}
}
}
}
}
private val ingredientsForPreview = listOf(
Ingredient(name = "Burger"),
Ingredient(name = "Buns"),
Ingredient(name = "Lettuce"),
Ingredient(name = "Pepper"),
Ingredient(name = "Salt"),
Ingredient(name = "Cheese"),
Ingredient(name = "Tomato"),
Ingredient(name = "Mayonnaise")
)
private val searchResultsForPreview = listOf(
Ingredient(name = "Burger"),
Ingredient(name = "Buns"),
Ingredient(name = "Lettuce"),
Ingredient(name = "Pepper"),
Ingredient(name = "Salt"),
Ingredient(name = "Cheese"),
Ingredient(name = "Tomato"),
Ingredient(name = "Mayonnaise"),
Ingredient(name = "Brisket"),
Ingredient(name = "Linguica"),
Ingredient(name = "Chorizo"),
Ingredient(name = "Chicken"),
Ingredient(name = "Whole Chicken"),
Ingredient(name = "Beef Ribs"),
Ingredient(name = "SpareRibs"),
Ingredient(name = "Rice")
)
val measuresForPreview = listOf(
Measure(
label = "Slice",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_slice"
),
Measure(
label = "Whole",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_unit"
),
Measure(
label = "Block",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_block"
),
Measure(
label = "Piece",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_piece"
),
Measure(
label = "Serving",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_serving"
),
Measure(
label = "Slice",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_slice"
),
Measure(
label = "Whole",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_unit"
),
Measure(
label = "Block",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_block"
),
Measure(
label = "Piece",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_piece"
),
Measure(
label = "Serving",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_serving"
),
Measure(
label = "Slice",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_slice"
),
Measure(
label = "Whole",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_unit"
),
Measure(
label = "Block",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_block"
),
Measure(
label = "Piece",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_piece"
),
Measure(
label = "Serving",
weight = 28.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_serving"
),
Measure(
label = "Cup",
weight = 132.0,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_cup",
qualified = listOf(
Qualified(
weight = 132.0,
qualifiers = listOf(
Qualifier(
label = "diced",
uri = "http://www.edamam.com/ontologies/edamam.owl#Qualifier_diced"
)
)
),
Qualified(
weight = 113.0,
qualifiers = listOf(
Qualifier(
label = "shredded",
uri = "http://www.edamam.com/ontologies/edamam.owl#Qualifier_shredded"
)
)
),
Qualified(
weight = 244.0,
qualifiers = listOf(
Qualifier(
label = "melted",
uri = "http://www.edamam.com/ontologies/edamam.owl#Qualifier_melted"
)
)
)
)
),
Measure(
label = "Ounce",
weight = 28.349523125,
uri = "http://www.edamam.com/ontologies/edamam.owl#Measure_ounce"
)
)
data class DisplayQualifier(
val label: String?,
val uri: String?,
val weight: Double?
)
private val ingredientForPreview = Ingredient(
name = "Burger",
qualifiedUri = "http://www.edamam.com/ontologies/edamam.owl#Qualifier_shredded",
qualifiedName = "shredded",
qualifiedWeight = 113.0,
measureUri = "http://www.edamam.com/ontologies/edamam.owl#Measure_cup",
measureName = "Cup",
measureWeight = 132.0,
measures = measuresForPreview
)
private fun determineErrorMessage(
selectedMeasure: Measure?,
selectedQualifier: DisplayQualifier?,
quantityText: String?
): Int {
return if (selectedMeasure == null) {
R.string.error_measure_not_selected
} else if (selectedQualifier == null) {
R.string.error_qualifier_not_selected
} else if (quantityText == null || quantityText.toDoubleOrNull() == null) {
R.string.error_invalid_quantity
} else {
R.string.error_unknown
}
}
| body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/search/IngredientSearch.kt | 3981825868 |
package com.fitness.recipebuilder.screens.recipes
import com.fitness.domain.model.nutrition.getDateAsLong
import com.fitness.domain.model.nutrition.getTimeFromDate
import com.fitness.domain.usecase.nutrition.GetEditableNutritionRecordsUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.recipebuilder.util.RecipeBuilderStateHolder
import com.fitness.recipebuilder.util.RecipeSelectionStep
import dagger.hilt.android.lifecycle.HiltViewModel
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class RecipeSelectionViewModel @Inject constructor(
private val stateHolder: RecipeBuilderStateHolder,
private val getCurrentUserIdUseCase: GetCurrentUserIdUseCase,
private val getEditableNutritionRecordsUseCase: GetEditableNutritionRecordsUseCase
) : IntentViewModel<BaseViewState<RecipeSelectionState>, RecipeSelectionEvent>() {
init {
initialize()
}
override fun onTriggerEvent(event: RecipeSelectionEvent) {
when (event) {
is RecipeSelectionEvent.RecipeSelected -> onNutritionRecordSelected(event)
is RecipeSelectionEvent.CreateNewRecipe -> onCreateNewRecord()
is RecipeSelectionEvent.CancelCreate -> onCancelCreateRecord()
is RecipeSelectionEvent.GiveName -> onGiveName(event)
}
}
override fun handleError(exception: Throwable) {
super.handleError(exception)
exception.printStackTrace()
}
private fun initialize() = onGetCurrentUserId()
private fun onGetCurrentUserId() = safeLaunch {
execute(getCurrentUserIdUseCase(GetCurrentUserIdUseCase.Params)){
onGetEditableRecipes(it)
}
}
private fun onGetEditableRecipes(userId: String) = safeLaunch {
execute(getEditableNutritionRecordsUseCase(GetEditableNutritionRecordsUseCase.Params(userId))){
stateHolder.updateState(stateHolder.state().copy(myRecipes = it))
setState(BaseViewState.Data(RecipeSelectionState(myRecipes = it, step = RecipeSelectionStep.PENDING)))
}
}
private fun onNutritionRecordSelected(event: RecipeSelectionEvent.RecipeSelected) {
val nutrition = event.nutrition
val (hour, minute) = nutrition.getTimeFromDate()
val state = stateHolder.state().copy(
name = nutrition.recipe.name,
date = nutrition.getDateAsLong(),
hour = hour,
minute = minute,
type = nutrition.mealType,
recordId = nutrition.recordId,
recipe = nutrition.recipe,
ingredients = nutrition.recipe.ingredients?.toMutableList() ?: mutableListOf(),
instructions = nutrition.recipe.instructions?.toMutableList() ?: mutableListOf()
)
stateHolder.updateState(state)
setState(BaseViewState.Data(RecipeSelectionState(step = RecipeSelectionStep.MODIFY)))
}
private fun onCreateNewRecord() {
setState(BaseViewState.Data(RecipeSelectionState(step = RecipeSelectionStep.NAME)))
}
private fun onGiveName(event: RecipeSelectionEvent.GiveName) {
stateHolder.clearState()
stateHolder.updateState(stateHolder.state().copy(name = event.name))
setState(BaseViewState.Data(RecipeSelectionState(step = RecipeSelectionStep.CREATE)))
}
private fun onCancelCreateRecord() {
setState(BaseViewState.Data(RecipeSelectionState(myRecipes = stateHolder.state().myRecipes, step = RecipeSelectionStep.PENDING)))
}
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/recipes/RecipeSelectionViewModel.kt | 3532294324 |
package com.fitness.recipebuilder.screens.recipes
import com.fitness.domain.model.nutrition.Nutrition
import com.fitness.recipebuilder.util.RecipeSelectionStep
data class RecipeSelectionState(
val myRecipes: List<Nutrition> = emptyList(),
val step: RecipeSelectionStep = RecipeSelectionStep.PENDING
)
sealed class RecipeSelectionEvent{
data class RecipeSelected(val nutrition: Nutrition): RecipeSelectionEvent()
object CancelCreate: RecipeSelectionEvent()
object CreateNewRecipe: RecipeSelectionEvent()
data class GiveName(val name: String): RecipeSelectionEvent()
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/recipes/RecipeSelectionContract.kt | 4060213445 |
package com.fitness.recipebuilder.screens.recipes
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
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.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.component.screens.PromptUserDialog
import com.fitness.data.util.TotalNutrientsKeys
import com.fitness.recipebuilder.navigation.RecipeBuilderEntryImpl
import com.fitness.recipebuilder.screens.builder.RecipeBuilderState
import com.fitness.recipebuilder.util.NutritionItem
import com.fitness.recipebuilder.util.RecipeSelectionStep
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun PreviewRecipeSelection() = BodyBalanceTheme {
Surface {
RecipeSelectionContent(state = RecipeSelectionState())
}
}
@Composable
fun RecipeSelection(
state: StateFlow<BaseViewState<RecipeBuilderState>>,
onTriggerEvent: (RecipeSelectionEvent) -> Unit = {},
onNavigate: (destination: String) -> Unit = {},
onPopBack: () -> Unit = {}
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
RecipeSelectionContent(
state = uiState.cast<BaseViewState.Data<RecipeSelectionState>>().value,
onTriggerEvent = onTriggerEvent,
onNavigate = onNavigate
)
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
private fun RecipeSelectionContent(
state: RecipeSelectionState,
onTriggerEvent: (RecipeSelectionEvent) -> Unit = {},
onNavigate: (destination: String) -> Unit = {}
) {
when(state.step){
RecipeSelectionStep.PENDING -> {
val myRecipes = remember { state.myRecipes.toMutableList() }
if (myRecipes.isEmpty()) {
CreateFirstRecipe(onTriggerEvent = onTriggerEvent)
} else {
MyRecipes(state = state, onTriggerEvent = onTriggerEvent)
}
}
RecipeSelectionStep.NAME -> PromptUserDialog(
title = stringResource(id = R.string.recipe_name_dialog_title),
description = stringResource(id = R.string.recipe_name_dialog_message),
label = stringResource(id = R.string.recipe_name_dialog_label),
onContinue = { onTriggerEvent(RecipeSelectionEvent.GiveName(name = it)) },
onCancel = { onTriggerEvent(RecipeSelectionEvent.CancelCreate) },
)
RecipeSelectionStep.CREATE -> onNavigate(RecipeBuilderEntryImpl.INGREDIENTS)
RecipeSelectionStep.MODIFY -> onNavigate(RecipeBuilderEntryImpl.RECIPE_BUILDER)
}
}
@Composable
private fun CreateFirstRecipe(onTriggerEvent: (RecipeSelectionEvent) -> Unit = {}) {
Column(
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier.fillMaxSize()
) {
IconButton(
onClick = { onTriggerEvent(RecipeSelectionEvent.CreateNewRecipe) }, modifier = Modifier
.padding(start = 50.dp, end = 50.dp, top = 50.dp)
.size(100.dp)
) {
Icon(
painter = painterResource(id = R.drawable.icon_add_more),
contentDescription = stringResource(id = R.string.content_description_icon_add),
)
}
Text(
text = stringResource(id = R.string.empty_recipe_book_message),
textAlign = TextAlign.Center,
modifier = Modifier
.fillMaxWidth()
.padding(start = 20.dp, end = 20.dp)
)
}
}
@Composable
private fun MyRecipes(
state: RecipeSelectionState,
onTriggerEvent: (RecipeSelectionEvent) -> Unit = {}
) {
Box(contentAlignment = Alignment.BottomEnd, modifier = Modifier
.fillMaxSize()
.padding(10.dp)) {
LazyColumn(
verticalArrangement = Arrangement.spacedBy(10.dp),
modifier = Modifier.fillMaxSize()
) {
items(state.myRecipes) {
it.recipe.name?.let { title ->
NutritionItem(
title = title,
energy = it.recipe.nutrients?.get(TotalNutrientsKeys.KEY_ENERGY)?.quantity,
fat = it.recipe.nutrients?.get(TotalNutrientsKeys.KEY_TOTAL_FAT)?.quantity,
protein = it.recipe.nutrients?.get(TotalNutrientsKeys.KEY_PROTEIN)?.quantity,
net = it.recipe.nutrients?.get(TotalNutrientsKeys.KEY_NET_CARBS)?.quantity,
onClickItem = { onTriggerEvent(RecipeSelectionEvent.RecipeSelected(it)) }
)
}
}
}
Card(
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.primary),
elevation = CardDefaults.cardElevation(defaultElevation = 1.dp),
shape = CircleShape,
modifier = Modifier.padding(end = 25.dp, bottom = 40.dp)
) {
IconButton(
onClick = { onTriggerEvent(RecipeSelectionEvent.CreateNewRecipe) },
) {
Icon(
painter = painterResource(id = R.drawable.icon_add_more),
contentDescription = stringResource(id = R.string.content_description_icon_add),
)
}
}
}
}
| body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/recipes/RecipeSelection.kt | 3301928379 |
package com.fitness.recipebuilder.screens.builder
import androidx.compose.foundation.Image
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.asPaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.ime
import androidx.compose.foundation.layout.isImeVisible
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.constraintlayout.compose.ConstraintLayout
import androidx.constraintlayout.compose.Dimension
import com.fitness.component.properties.GuidelineProperties
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.data.util.TotalNutrientsKeys
import com.fitness.recipebuilder.util.NutritionItem
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import enums.EMealType
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun PreviewRecipeBuilder() = BodyBalanceTheme {
Surface {
RecipeBuilderContent(
state = RecipeBuilderState("Hamburger Surprise"),
onTriggerEvent = {},
ingredientSearch = {})
}
}
@Light
@Dark
@Composable
fun PreviewNutritionItem() = BodyBalanceTheme {
Surface {
NutritionItem()
}
}
@Composable
fun RecipeBuilder(
state: StateFlow<BaseViewState<RecipeBuilderState>>,
onTriggerEvent: (RecipeBuilderEvent) -> Unit,
onPopBack: () -> Unit = {},
onIngredientSearch: () -> Unit = {}
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
RecipeBuilderContent(
state = uiState.cast<BaseViewState.Data<RecipeBuilderState>>().value,
onTriggerEvent = onTriggerEvent,
ingredientSearch = onIngredientSearch
)
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
@OptIn(ExperimentalLayoutApi::class, ExperimentalComposeUiApi::class, ExperimentalMaterial3Api::class)
private fun RecipeBuilderContent(
state: RecipeBuilderState,
onTriggerEvent: (RecipeBuilderEvent) -> Unit,
ingredientSearch: () -> Unit,
) {
val ime = WindowInsets.ime
val insets = ime.asPaddingValues().calculateBottomPadding()
val keyboardController = LocalSoftwareKeyboardController.current
val focusManager = LocalFocusManager.current
val isImeVisible = WindowInsets.isImeVisible
val scrollState = rememberScrollState()
ConstraintLayout(
modifier = Modifier
.fillMaxSize()
.verticalScroll(scrollState)
.padding(bottom = if (isImeVisible) insets else 0.dp)
.pointerInput(Unit) {
detectTapGestures(onPress = {}) {
focusManager.clearFocus()
keyboardController?.hide()
}
}
) {
var name by remember { mutableStateOf(state.name) }
var date by remember { mutableStateOf(state.date) }
var type by remember { mutableStateOf(state.type) }
val ingredients = remember { state.ingredients }
val instructions = remember { state.instructions }
val (
titleRef,
imageRef,
addIngredientsRef,
ingredientsTitleRef,
ingredientsCountRef,
ingredientsListRef,
instructionsTitleRef,
instructionsListRef,
createInstructionsRef
) = createRefs()
val topGuide = createGuidelineFromTop(25.dp)
val startGuide = createGuidelineFromStart(GuidelineProperties.START)
val endGuide = createGuidelineFromEnd(GuidelineProperties.END)
Text(
text = name,
fontSize = 22.sp,
modifier = Modifier.constrainAs(titleRef) {
top.linkTo(topGuide)
start.linkTo(startGuide)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
)
Card(
modifier = Modifier
.height(250.dp)
.constrainAs(imageRef) {
top.linkTo(titleRef.bottom, 20.dp)
start.linkTo(startGuide)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
) {
Image(
painter = painterResource(id = R.drawable.image_placeholder),
contentDescription = "",
contentScale = ContentScale.FillWidth,
modifier = Modifier.fillMaxSize()
)
}
Text(
text = stringResource(id = R.string.title_ingredients),
fontSize = 18.sp,
modifier = Modifier.constrainAs(ingredientsTitleRef) {
top.linkTo(imageRef.bottom, 40.dp)
start.linkTo(startGuide)
end.linkTo(ingredientsCountRef.start)
width = Dimension.fillToConstraints
}
)
Text(
text = stringResource(id = R.string.ingredients_count, ingredients.size),
textAlign = TextAlign.End,
modifier = Modifier.constrainAs(ingredientsCountRef) {
top.linkTo(ingredientsTitleRef.top)
end.linkTo(endGuide)
start.linkTo(ingredientsTitleRef.end)
width = Dimension.fillToConstraints
}
)
LazyColumn(
verticalArrangement = Arrangement.spacedBy(5.dp),
modifier = Modifier
.fillMaxWidth()
.height(350.dp)
.constrainAs(ingredientsListRef) {
top.linkTo(ingredientsTitleRef.bottom, 20.dp)
start.linkTo(startGuide)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
) {
item {
Spacer(modifier = Modifier.height(5.dp))
}
items(ingredients) { ingredient ->
ingredient.name?.let { name ->
NutritionItem(
title = name,
energy = ingredient.nutrients?.get(TotalNutrientsKeys.KEY_ENERGY)?.quantity,
fat = ingredient.nutrients?.get(TotalNutrientsKeys.KEY_TOTAL_FAT)?.quantity,
protein = ingredient.nutrients?.get(TotalNutrientsKeys.KEY_PROTEIN)?.quantity,
net = ingredient.nutrients?.get(TotalNutrientsKeys.KEY_NET_CARBS)?.quantity,
)
}
}
item {
Spacer(modifier = Modifier.height(25.dp))
}
}
Card(
shape = RoundedCornerShape(5.dp),
onClick = { ingredientSearch() },
modifier = Modifier.constrainAs(addIngredientsRef) {
end.linkTo(endGuide)
bottom.linkTo(ingredientsListRef.bottom)
}
) {
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.SpaceBetween,
modifier = Modifier.padding(10.dp)
) {
Icon(
painter = painterResource(id = R.drawable.icon_add_more),
contentDescription = stringResource(id = R.string.content_description_icon_add),
modifier = Modifier.size(16.dp)
)
Spacer(modifier = Modifier.width(10.dp))
Text(text = stringResource(id = R.string.title_add_more))
}
}
Text(
text = stringResource(id = R.string.title_instructions),
fontSize = 18.sp,
modifier = Modifier.constrainAs(instructionsTitleRef) {
top.linkTo(addIngredientsRef.bottom, 50.dp)
start.linkTo(startGuide)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
)
if (instructions.isEmpty()) {
Button(
shape = RoundedCornerShape(5.dp),
onClick = { onTriggerEvent(RecipeBuilderEvent.GenerateInstructions) },
modifier = Modifier.constrainAs(instructionsListRef) {
end.linkTo(endGuide)
bottom.linkTo(instructionsTitleRef.bottom)
}
) {
Text(text = stringResource(id = R.string.title_generate))
}
Text(
text = stringResource(id = R.string.empty_instructions_message),
textAlign = TextAlign.Center,
modifier = Modifier.constrainAs(createInstructionsRef) {
top.linkTo(instructionsTitleRef.bottom, 40.dp)
bottom.linkTo(parent.bottom, 50.dp)
start.linkTo(startGuide)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
)
} else {
LazyColumn(
verticalArrangement = Arrangement.spacedBy(5.dp),
modifier = Modifier
.height(250.dp)
.constrainAs(instructionsListRef) {
top.linkTo(instructionsTitleRef.bottom, 20.dp)
start.linkTo(startGuide)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
) {
items(EMealType.values()) {
NutritionItem()
}
}
}
}
}
| body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/builder/RecipeBuilder.kt | 4004156056 |
package com.fitness.recipebuilder.screens.builder
import com.fitness.domain.model.nutrition.Ingredient
import com.fitness.recipebuilder.util.RecipeBuilderStep
import enums.EMealType
data class RecipeBuilderState(
val name: String,
val date: Long? = null,
val hour: Int? = null,
val minute: Int? = null,
val type: EMealType? = null,
val ingredients: List<Ingredient> = mutableListOf(),
val instructions: List<String> = mutableListOf(),
val step: RecipeBuilderStep = RecipeBuilderStep.PENDING
)
sealed class RecipeBuilderEvent {
object GenerateInstructions : RecipeBuilderEvent()
data class EditName(val name: String) : RecipeBuilderEvent()
data class EditDate(val date: String) : RecipeBuilderEvent()
data class EditType(val type: EMealType) : RecipeBuilderEvent()
data class EditInstructions(val name: String) : RecipeBuilderEvent()
data class RemoveIngredient(val ingredient: Ingredient) : RecipeBuilderEvent()
object SaveNutritionRecord : RecipeBuilderEvent()
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/builder/RecipeBuilderContract.kt | 1521149388 |
package com.fitness.recipebuilder.screens.builder
import com.fitness.recipebuilder.util.RecipeBuilderStateHolder
import dagger.hilt.android.lifecycle.HiltViewModel
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class RecipeBuilderViewModel @Inject constructor(
private val stateHolder: RecipeBuilderStateHolder
) :
IntentViewModel<BaseViewState<RecipeBuilderState>, RecipeBuilderEvent>() {
init {
initialize()
}
override fun onTriggerEvent(event: RecipeBuilderEvent) {
when (event) {
is RecipeBuilderEvent.EditName -> onEditName(event)
is RecipeBuilderEvent.GenerateInstructions -> onGenerateInstructions()
is RecipeBuilderEvent.EditDate -> {}
is RecipeBuilderEvent.EditType -> {}
is RecipeBuilderEvent.EditInstructions -> {}
is RecipeBuilderEvent.RemoveIngredient -> {}
is RecipeBuilderEvent.SaveNutritionRecord -> {}
}
}
override fun handleError(exception: Throwable) {
super.handleError(exception)
exception.printStackTrace()
}
private fun initialize() {
val state = stateHolder.state()
setState(
BaseViewState.Data(
RecipeBuilderState(
name = state.name ?: "Create a name",
date = state.date,
hour = state.hour,
minute = state.minute,
type = state.type,
ingredients = state.ingredients,
instructions = state.instructions
)
)
)
}
private fun verified() {
}
private fun onEditName(event: RecipeBuilderEvent.EditName) = safeLaunch {
}
private fun onGenerateInstructions() = safeLaunch {
}
} | body-balance/features/recipe-builder/impl/src/main/kotlin/com/fitness/recipebuilder/screens/builder/RecipeBuilderViewModel.kt | 1795069660 |
package com.fitness.recipebuilder
import com.fitness.navigation.AggregateFeatureEntry
interface RecipeBuilderEntry: AggregateFeatureEntry | body-balance/features/recipe-builder/api/src/main/kotlin/com/fitness/recipebuilder/RecipeBuilderEntry.kt | 3629779250 |
package com.fitness.welcome.viewmodel
import com.fitness.authentication.manager.AuthenticationManager
import com.fitness.authentication.manager.AuthenticationState
import dagger.hilt.android.lifecycle.HiltViewModel
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class WelcomeViewModel @Inject constructor(private val authManager: AuthenticationManager): IntentViewModel<BaseViewState<WelcomeState>, WelcomeEvent>(){
init {
onTriggerEvent(WelcomeEvent.AuthCheckEvent)
}
override fun onTriggerEvent(event: WelcomeEvent) {
if(event is WelcomeEvent.AuthCheckEvent){
onCheckAuthStatus()
}
}
private fun onCheckAuthStatus() {
setState(
BaseViewState.Data(
WelcomeState(isAuthenticated = isAuthenticated(authManager.authState.value))
)
)
}
private fun isAuthenticated(state: AuthenticationState) = state == AuthenticationState.Authenticated
} | body-balance/features/welcome/impl/src/main/kotlin/com/fitness/welcome/viewmodel/WelcomeViewModel.kt | 1134018306 |
package com.fitness.welcome.viewmodel
data class WelcomeState(val isAuthenticated: Boolean = false)
sealed class WelcomeEvent{
object AuthCheckEvent: WelcomeEvent()
} | body-balance/features/welcome/impl/src/main/kotlin/com/fitness/welcome/viewmodel/WelcomeContract.kt | 3431360269 |
package com.fitness.welcome.di
import com.fitness.navigation.FeatureEntry
import com.fitness.navigation.FeatureEntryKey
import com.fitness.welcome.WelcomeEntry
import com.fitness.welcome.navigation.WelcomeEntryImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import dagger.multibindings.IntoMap
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
interface WelcomeEntryModule {
@Binds
@Singleton
@IntoMap
@FeatureEntryKey(WelcomeEntry::class)
fun welcomeEntry(entry: WelcomeEntryImpl): FeatureEntry
} | body-balance/features/welcome/impl/src/main/kotlin/com/fitness/welcome/di/WelcomeEntryModule.kt | 956828878 |
package com.fitness.welcome.navigation
import androidx.compose.runtime.Composable
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavBackStackEntry
import androidx.navigation.NavHostController
import com.fitness.authentication.AuthEntry
import com.fitness.dashboard.DashboardEntry
import com.fitness.navigation.Destinations
import com.fitness.navigation.find
import com.fitness.welcome.WelcomeEntry
import com.fitness.welcome.view.WelcomeScreen
import com.fitness.welcome.viewmodel.WelcomeViewModel
import extensions.cast
import javax.inject.Inject
class WelcomeEntryImpl @Inject constructor() : WelcomeEntry() {
@Composable
override fun Composable(
navController: NavHostController,
destinations: Destinations,
backStackEntry: NavBackStackEntry
) {
val viewModel = hiltViewModel<WelcomeViewModel>()
WelcomeScreen(
state = viewModel.uiState.cast(),
onComplete = { authenticated ->
if(authenticated){
navigate(navController, destinations.find<DashboardEntry>().featureRoute)
}else{
navigate(navController, destinations.find<AuthEntry>().featureRoute)
}
}
)
}
private fun navigate(navController: NavHostController, destination: String){
navController.navigate(destination) {
popUpTo(featureRoute){
inclusive = true
}
}
}
} | body-balance/features/welcome/impl/src/main/kotlin/com/fitness/welcome/navigation/WelcomeEntryImpl.kt | 2358100536 |
package com.fitness.welcome.view
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.Spring.DampingRatioHighBouncy
import androidx.compose.animation.core.Spring.DampingRatioMediumBouncy
import androidx.compose.animation.core.Spring.StiffnessVeryLow
import androidx.compose.animation.core.spring
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.offset
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.constraintlayout.compose.ConstraintLayout
import auth.AuthFailure
import com.fitness.component.components.BodyBalanceImageLogo
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import com.fitness.welcome.viewmodel.WelcomeState
import extensions.Dark
import extensions.Light
import extensions.cast
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun WelcomePreview() {
BodyBalanceTheme {
Surface {
WelcomeScreen(MutableStateFlow(BaseViewState.Data(WelcomeState())), {})
}
}
}
@Composable
fun WelcomeScreen(
state: StateFlow<BaseViewState<WelcomeState>>,
onComplete: (Boolean) -> Unit,
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
WelcomeScreenContent(
state = uiState.cast<BaseViewState.Data<WelcomeState>>().value,
onComplete = onComplete
)
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as AuthFailure
ErrorScreen(title = failure.title, description = failure.description) {
onComplete(false)
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(
message = R.string.unknown,
onClick = { onComplete(false) }
)
}
}
}
@Composable
fun WelcomeScreenContent(
state: WelcomeState,
onComplete: (Boolean) -> Unit
) {
var showTopText by remember { mutableStateOf(true) }
var showBottomText by remember { mutableStateOf(false) }
var currentPhase by remember { mutableIntStateOf(0) }
LaunchedEffect(key1 = currentPhase) {
delay(900) // Delay for each phase
currentPhase++
if (currentPhase > 2) {
onComplete(state.isAuthenticated)
} else {
showTopText = currentPhase % 2 == 0
showBottomText = !showTopText
}
}
val topText = when (currentPhase) {
0 -> "Embark"
1 -> ""
else -> "Evolve"
}
val bottomText = when (currentPhase) {
1 -> "Endure"
else -> ""
}
Box(contentAlignment = Alignment.BottomCenter, modifier = Modifier.fillMaxSize()) {
val offsetY = remember { Animatable(400f) }
LaunchedEffect(Unit) {
offsetY.animateTo(
targetValue = 200f,
spring(
dampingRatio = DampingRatioMediumBouncy,
stiffness = StiffnessVeryLow
),
)
}
BodyBalanceImageLogo(
contentScale = ContentScale.Crop, // This will crop the image to fill the bounds
modifier = Modifier
.offset(y = offsetY.value.dp)
)
}
ConstraintLayout(
modifier = Modifier
.fillMaxSize()
.padding(16.dp),
) {
val (topRef, bottomRef) = createRefs()
Box(modifier = Modifier.constrainAs(topRef) {
start.linkTo(parent.start)
end.linkTo(parent.end)
top.linkTo(parent.top, 50.dp)
}) {
AnimatedVisibility(
visible = showTopText,
enter = fadeIn(
animationSpec = spring(
DampingRatioHighBouncy,
stiffness = StiffnessVeryLow
)
),
exit = fadeOut(
animationSpec = spring(
DampingRatioHighBouncy,
stiffness = StiffnessVeryLow
)
)
) {
Text(
text = topText,
fontSize = 32.sp,
)
}
}
Box(modifier = Modifier.constrainAs(bottomRef) {
start.linkTo(parent.start)
end.linkTo(parent.end)
top.linkTo(parent.top, 50.dp)
}) {
AnimatedVisibility(
visible = showBottomText,
enter = fadeIn(
animationSpec = spring(
DampingRatioHighBouncy,
stiffness = StiffnessVeryLow
)
),
exit = fadeOut(
animationSpec = spring(
DampingRatioHighBouncy,
stiffness = StiffnessVeryLow
)
)
) {
Text(
text = bottomText,
fontSize = 24.sp,
)
}
}
}
}
| body-balance/features/welcome/impl/src/main/kotlin/com/fitness/welcome/view/Welcome.kt | 3077421107 |
package com.fitness.welcome
import com.fitness.navigation.ComposableFeatureEntry
abstract class WelcomeEntry: ComposableFeatureEntry {
override val featureRoute: String get() = "welcome"
} | body-balance/features/welcome/api/src/main/kotlin/com/fitness/welcome/WelcomeEntry.kt | 3271604870 |
package com.fitness.onboard.di
import com.fitness.navigation.FeatureEntry
import com.fitness.navigation.FeatureEntryKey
import com.fitness.onboard.OnboardEntry
import com.fitness.onboard.navigation.OnboardEntryImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import dagger.multibindings.IntoMap
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
interface OnboardEntryModule {
@Binds
@Singleton
@IntoMap
@FeatureEntryKey(OnboardEntry::class)
fun onboardEntry(entry: OnboardEntryImpl): FeatureEntry
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/di/OnboardEntryModule.kt | 3228447959 |
package com.fitness.onboard.di
import com.fitness.onboard.onboard.basic.BasicInformationStateHolder
import com.fitness.onboard.onboard.finalize.FinalizeStateHolder
import com.fitness.onboard.onboard.fitness.FitnessStateHolder
import com.fitness.onboard.onboard.goal.GoalStateHolder
import com.fitness.onboard.onboard.nutrition.NutritionStateHolder
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class OnboardModule {
@Provides
@Singleton
fun provideBasicInformationStateHolder(): BasicInformationStateHolder = BasicInformationStateHolder
@Provides
@Singleton
fun provideFitnessStateHolder(): FitnessStateHolder = FitnessStateHolder
@Provides
@Singleton
fun provideNutritionStateHolder(): NutritionStateHolder = NutritionStateHolder
@Provides
@Singleton
fun provideGoalStateHolder(): GoalStateHolder = GoalStateHolder
@Provides
@Singleton
fun provideFinalizeStateHolder(): FinalizeStateHolder = FinalizeStateHolder
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/di/OnboardModule.kt | 1857780499 |
package com.fitness.onboard.util
import com.fitness.resources.R
import failure.AuthStateFailure
import failure.Failure
import failure.MinimumNumberOfSelectionFailure
import failure.TimeoutCancellationFailure
import kotlinx.coroutines.TimeoutCancellationException
sealed class OnboardFailure : Failure() {
data class UnknownFailure(override val description: Int = R.string.desc_onboarding_unknown_failure, override val title: Int = R.string.title_onboarding_unknown_failure) : OnboardFailure()
data class SystemFailure(override val description: Int = R.string.desc_onboarding_unknown_failure, override val title: Int = R.string.title_onboarding_unknown_failure) : OnboardFailure()
data class UserFailure(override val description: Int = R.string.desc_onboarding_unknown_failure, override val title: Int = R.string.title_onboarding_unknown_failure) : OnboardFailure()
}
fun Throwable.toOnboardFailure(): Failure =
when(this){
is AuthStateFailure -> this
is MinimumNumberOfSelectionFailure -> this
is TimeoutCancellationException -> TimeoutCancellationFailure()
else -> OnboardFailure.UnknownFailure(description = R.string.desc_onboarding_unknown_failure, title = R.string.title_onboarding_unknown_failure)
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/util/OnboardFailure.kt | 2342643667 |
package com.fitness.onboard.util
fun isMinSelection(selection: Int, minSelection: Int): Boolean = selection >= minSelection
const val HABITS_MIN_SELECTION = 2
const val GOALS_MIN_SELECTION = 3
const val HEALTH_LABELS_MIN_SELECTION = 2
const val DIETARY_RESTRICTIONS_MIN_SELECTION = 2
const val CUISINE_TYPE_MIN_SELECTION = 3 | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/util/OnboardUtil.kt | 3280606617 |
package com.fitness.onboard.navigation
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavGraphBuilder
import androidx.navigation.NavHostController
import androidx.navigation.compose.composable
import androidx.navigation.navigation
import com.fitness.navigation.Destinations
import com.fitness.navigation.find
import com.fitness.onboard.OnboardEntry
import com.fitness.onboard.onboard.basic.BasicInformationScreen
import com.fitness.onboard.onboard.basic.viewmodel.BasicInformationViewModel
import com.fitness.onboard.onboard.finalize.FinalizeOnboardingScreen
import com.fitness.onboard.onboard.finalize.viewmodel.FinalizeEvent
import com.fitness.onboard.onboard.finalize.viewmodel.FinalizeViewModel
import com.fitness.onboard.onboard.fitness.FitnessScreen
import com.fitness.onboard.onboard.fitness.viewmodel.FitnessViewModel
import com.fitness.onboard.onboard.goal.view.GoalsScreen
import com.fitness.onboard.onboard.goal.viewmodel.GoalViewModel
import com.fitness.onboard.onboard.nutrition.NutritionScreen
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionViewModel
import com.fitness.onboard.onboard.welcome.WelcomeScreen
import com.fitness.signout.SignOutEntry
import extensions.cast
import javax.inject.Inject
class OnboardEntryImpl @Inject constructor() : OnboardEntry() {
companion object{
const val WELCOME = "welcome"
const val BASIC_INFORMATION = "basic_information"
const val FITNESS_LEVEL_ASSESSMENT = "fitness_level_assessment"
const val NUTRITION_PREFERENCES = "nutritional_preferences"
const val INITIAL_GOALS = "goals"
const val FINALIZE = "finalize"
}
override fun NavGraphBuilder.navigation(navController: NavHostController, destinations: Destinations) {
val signOut = destinations.find<SignOutEntry>()
navigation(startDestination = WELCOME, route = featureRoute) {
composable(WELCOME){
WelcomeScreen(onContinue = { navController.navigate(BASIC_INFORMATION)} )
}
composable(BASIC_INFORMATION){
val viewmodel: BasicInformationViewModel = hiltViewModel()
BasicInformationScreen(
stateFlow = viewmodel.uiState.cast(),
onTriggerEvent = { viewmodel.onTriggerEvent(it) },
onComplete = { navController.navigate(FITNESS_LEVEL_ASSESSMENT) },
onForceSignOut = { navController.navigate(signOut.featureRoute) }
)
}
composable(FITNESS_LEVEL_ASSESSMENT){
val viewmodel: FitnessViewModel = hiltViewModel()
FitnessScreen(
state = viewmodel.uiState.cast(),
onTriggerEvent = { viewmodel.onTriggerEvent(it) },
onComplete = { navController.navigate(NUTRITION_PREFERENCES) },
onForceSignOut = { navController.navigate(signOut.featureRoute) }
)
}
composable(NUTRITION_PREFERENCES){
val viewmodel: NutritionViewModel = hiltViewModel()
NutritionScreen(
state = viewmodel.uiState.cast(),
onTriggerEvent = { viewmodel.onTriggerEvent(it) },
onComplete = { navController.navigate(INITIAL_GOALS) },
onForceSignOut = { navController.navigate(signOut.featureRoute) }
)
}
composable(INITIAL_GOALS){
val viewmodel: GoalViewModel = hiltViewModel()
GoalsScreen(
state = viewmodel.uiState.cast(),
onTriggerEvent = { viewmodel.onTriggerEvent(it) },
onComplete = { navController.navigate(FINALIZE) },
onForceSignOut = { navController.navigate(signOut.featureRoute) }
)
}
composable(FINALIZE){
val viewmodel: FinalizeViewModel = hiltViewModel()
FinalizeOnboardingScreen(
state = viewmodel.uiState.cast(),
onTriggerEvent = { viewmodel.onTriggerEvent(it) },
onForceSignOut = { navController.navigate(signOut.featureRoute) },
onComplete = { viewmodel.onTriggerEvent(FinalizeEvent.Complete) }
)
}
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/navigation/OnboardEntryImpl.kt | 3006644636 |
package com.fitness.onboard.onboard.basic.viewmodel
import enums.EGender
import enums.SystemOfMeasurement
data class BasicInformationState(
val units: SystemOfMeasurement = SystemOfMeasurement.METRIC,
val step: BasicInformationStep = BasicInformationStep.GENDER_AGE
)
sealed class BasicInformationEvent{
data class SystemOfMeasurement(val systemOfMeasurement: enums.SystemOfMeasurement): BasicInformationEvent()
data class GenderAge(val gender: EGender, val age: Int): BasicInformationEvent()
data class Height(val height: Double): BasicInformationEvent()
data class Weight(val weight: Double): BasicInformationEvent()
data class Waist(val waist: Double): BasicInformationEvent()
object SaveBasicInformation: BasicInformationEvent()
}
enum class BasicInformationStep {
SYSTEM_OF_MEASUREMENTS,
GENDER_AGE,
HEIGHT,
WEIGHT,
WAIST,
SAVE_BASIC_INFORMATION,
COMPLETE
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/basic/viewmodel/BasicInformationContract.kt | 4032898338 |
package com.fitness.onboard.onboard.basic.viewmodel
import com.fitness.domain.model.user.UserBasicInfo
import com.fitness.domain.model.user.UserPreferences
import com.fitness.domain.usecase.user.CreateBasicUserInfoUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.domain.usecase.user.UpdateUserPreferencesUseCase
import com.fitness.onboard.onboard.basic.BasicInformationStateHolder
import com.fitness.onboard.util.OnboardFailure
import com.fitness.onboard.util.toOnboardFailure
import dagger.hilt.android.lifecycle.HiltViewModel
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class BasicInformationViewModel @Inject constructor(
private val stateHolder: BasicInformationStateHolder,
private val currentUserIdUseCase: GetCurrentUserIdUseCase,
private val updateUserPreferencesUseCase: UpdateUserPreferencesUseCase,
private val createBasicUserInfoUseCase: CreateBasicUserInfoUseCase
) : IntentViewModel<BaseViewState<BasicInformationState>, BasicInformationEvent>() {
init {
setState(BaseViewState.Data(BasicInformationState(step = BasicInformationStep.SYSTEM_OF_MEASUREMENTS)))
}
override fun onTriggerEvent(event: BasicInformationEvent) {
when (event) {
is BasicInformationEvent.SystemOfMeasurement -> getCurrentUserId(event)
is BasicInformationEvent.GenderAge -> onGenderAge(event)
is BasicInformationEvent.Weight -> onWeight(event)
is BasicInformationEvent.Height -> onHeight(event)
is BasicInformationEvent.Waist -> onWaist(event)
is BasicInformationEvent.SaveBasicInformation -> getCurrentUserId(event)
}
}
override fun handleError(exception: Throwable) {
super.handleError(exception.toOnboardFailure())
}
private fun getCurrentUserId(event: BasicInformationEvent) = safeLaunch {
execute(currentUserIdUseCase(GetCurrentUserIdUseCase.Params)) {
when (event) {
is BasicInformationEvent.SystemOfMeasurement -> onSystemOfMeasurement(it, event)
else -> onVerify(it)
}
}
}
private fun onSystemOfMeasurement(
id: String,
event: BasicInformationEvent.SystemOfMeasurement
) = safeLaunch {
stateHolder.updateState(stateHolder.getState().copy(preferredMeasurement = event.systemOfMeasurement))
val params = UpdateUserPreferencesUseCase.Params(id = id, userPreferences = UserPreferences(systemOfMeasurement = event.systemOfMeasurement))
execute(updateUserPreferencesUseCase(params = params)) {
setState(
BaseViewState.Data(
BasicInformationState(
units = stateHolder.getState().preferredMeasurement,
step = BasicInformationStep.GENDER_AGE
)
)
)
}
}
private fun onGenderAge(event: BasicInformationEvent.GenderAge) {
stateHolder.updateState(stateHolder.getState().copy(age = event.age, gender = event.gender))
setState(
BaseViewState.Data(
BasicInformationState(
units = stateHolder.getState().preferredMeasurement,
step = BasicInformationStep.WEIGHT
)
)
)
}
private fun onWeight(event: BasicInformationEvent.Weight) {
stateHolder.updateState(stateHolder.getState().copy(weight = event.weight))
setState(
BaseViewState.Data(
BasicInformationState(
units = stateHolder.getState().preferredMeasurement,
step = BasicInformationStep.HEIGHT
)
)
)
}
private fun onHeight(event: BasicInformationEvent.Height) {
stateHolder.updateState(stateHolder.getState().copy(height = event.height))
setState(
BaseViewState.Data(
BasicInformationState(
units = stateHolder.getState().preferredMeasurement,
step = BasicInformationStep.WAIST
)
)
)
}
private fun onWaist(event: BasicInformationEvent.Waist) {
stateHolder.updateState(stateHolder.getState().copy(waist = event.waist))
setState(
BaseViewState.Data(
BasicInformationState(
units = stateHolder.getState().preferredMeasurement,
step = BasicInformationStep.SAVE_BASIC_INFORMATION
)
)
)
}
private fun onVerify(id: String) {
val basicInformation = stateHolder.getState()
val age = basicInformation.age
val gender = basicInformation.gender
val height = basicInformation.height
val weight = basicInformation.weight
val waist = basicInformation.waist
val system = basicInformation.preferredMeasurement
if (age != null &&
gender != null &&
height != null &&
weight != null &&
waist != null
) {
val userBasicInfo = UserBasicInfo(
userId = id,
age = age,
gender = gender,
height = height,
weight = weight,
waist = waist,
)
onSaveBasicInformation(userBasicInfo)
} else {
setState(BaseViewState.Error(OnboardFailure.UnknownFailure()))
}
}
private fun onSaveBasicInformation(info: UserBasicInfo) = safeLaunch {
val param = CreateBasicUserInfoUseCase.Params(info)
execute(createBasicUserInfoUseCase(param)) {
setState(BaseViewState.Data(BasicInformationState(step = BasicInformationStep.COMPLETE)))
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/basic/viewmodel/BasicInformationViewModel.kt | 1689783688 |
package com.fitness.onboard.onboard.basic
import androidx.compose.animation.Crossfade
import androidx.compose.animation.core.tween
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.component.screens.SystemOfMeasurementDialog
import com.fitness.onboard.onboard.basic.view.GenderAge
import com.fitness.onboard.onboard.basic.view.HeightMeasurement
import com.fitness.onboard.onboard.basic.view.WaistMeasurement
import com.fitness.onboard.onboard.basic.view.WeightMeasurement
import com.fitness.onboard.onboard.basic.viewmodel.BasicInformationEvent
import com.fitness.onboard.onboard.basic.viewmodel.BasicInformationState
import com.fitness.onboard.onboard.basic.viewmodel.BasicInformationStep
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.AuthStateFailure
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun BasicInformationPreview() = BodyBalanceTheme {
Surface {
BasicInformationContent(state = BasicInformationState())
}
}
@Composable
fun BasicInformationScreen(
stateFlow: StateFlow<BaseViewState<BasicInformationState>>,
onTriggerEvent: (BasicInformationEvent) -> Unit,
onComplete: () -> Unit,
onForceSignOut: () -> Unit
) {
val uiState by stateFlow.collectAsState()
Crossfade(
targetState = uiState,
animationSpec = tween(durationMillis = 1000),
label = "BasicInformationContent"
) { state ->
when (state) {
is BaseViewState.Data -> {
BasicInformationContent(
state = state.cast<BaseViewState.Data<BasicInformationState>>().value,
onTriggerEvent = onTriggerEvent,
onComplete = onComplete
)
}
is BaseViewState.Error -> {
val failure = state.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
if(failure is AuthStateFailure){
onForceSignOut()
}
else{
onComplete()
}
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onComplete)
}
}
}
}
@Composable
private fun BasicInformationContent(
state: BasicInformationState,
onTriggerEvent: (BasicInformationEvent) -> Unit = {},
onComplete: () -> Unit = {}
) {
Crossfade(
targetState = state.step,
animationSpec = tween(durationMillis = 1000),
label = "BasicInformationContent"
) { step ->
when (step) {
BasicInformationStep.SYSTEM_OF_MEASUREMENTS -> SystemOfMeasurementDialog(onClick = { onTriggerEvent(BasicInformationEvent.SystemOfMeasurement(it)) })
BasicInformationStep.GENDER_AGE -> GenderAge(onTriggerEvent = onTriggerEvent)
BasicInformationStep.WEIGHT -> WeightMeasurement(state.units, onTriggerEvent = onTriggerEvent)
BasicInformationStep.HEIGHT -> HeightMeasurement(state.units, onTriggerEvent = onTriggerEvent)
BasicInformationStep.WAIST -> WaistMeasurement(state.units, onTriggerEvent = onTriggerEvent)
BasicInformationStep.SAVE_BASIC_INFORMATION -> onTriggerEvent(BasicInformationEvent.SaveBasicInformation)
BasicInformationStep.COMPLETE -> onComplete()
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/basic/BasicInformation.kt | 3792464080 |
package com.fitness.onboard.onboard.basic.view
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.animateColorAsState
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.LinearEasing
import androidx.compose.animation.core.tween
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.size
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Check
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableDoubleStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.constraintlayout.compose.ConstraintLayout
import androidx.constraintlayout.compose.Dimension
import com.fitness.component.HorizontalRuler
import com.fitness.component.VerticalRuler
import com.fitness.component.components.StandardTextSmall
import com.fitness.component.components.StandardTitleText
import com.fitness.component.properties.GuidelineProperties
import com.fitness.onboard.onboard.basic.viewmodel.BasicInformationEvent
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import com.fitness.theme.ui.Green
import enums.ELengthUnit
import enums.EMassUnit
import enums.SystemOfMeasurement
import enums.formatHeight
import enums.formatWeight
import extensions.Dark
import extensions.Light
import kotlinx.coroutines.delay
@Light
@Dark
@Composable
private fun WeightPreview() = BodyBalanceTheme {
Surface {
WeightMeasurement(SystemOfMeasurement.METRIC)
}
}
@Light
@Dark
@Composable
private fun HeightPreview() = BodyBalanceTheme {
Surface {
HeightMeasurement(SystemOfMeasurement.METRIC)
}
}
@Composable
fun WeightMeasurement(units: SystemOfMeasurement, onTriggerEvent: (BasicInformationEvent) -> Unit = {}) {
ConstraintLayout(modifier = Modifier.fillMaxSize()) {
val (title, desc, image, weightMeasurement, weightValue, continueButton) = createRefs()
val topGuide = createGuidelineFromTop(50.dp)
val startGuide = createGuidelineFromStart(GuidelineProperties.START)
val endGuide = createGuidelineFromEnd(GuidelineProperties.END)
val bottomGuide = createGuidelineFromBottom(10.dp)
var weightNumber by remember { mutableDoubleStateOf(0.0) }
StandardTitleText(text = R.string.select_weight,
modifier = Modifier.constrainAs(title) {
top.linkTo(topGuide)
start.linkTo(startGuide)
}
)
StandardTextSmall(
text = R.string.desc_select_weight,
textAlign = TextAlign.Start,
modifier = Modifier.constrainAs(desc) {
top.linkTo(title.bottom, 10.dp)
start.linkTo(startGuide)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
)
Image(
painter = painterResource(id = R.drawable.icon_women_temp),
contentDescription = "women",
modifier = Modifier.constrainAs(image) {
top.linkTo(desc.bottom, 75.dp)
start.linkTo(startGuide)
end.linkTo(endGuide, 75.dp)
}
)
val massUnits = if(units == SystemOfMeasurement.METRIC) EMassUnit.KILOGRAM else EMassUnit.POUNDS
Text(text = formatWeight(weightNumber, massUnits),
fontSize = 24.sp,
modifier = Modifier.constrainAs(weightValue) {
top.linkTo(image.bottom)
bottom.linkTo(continueButton.top)
start.linkTo(startGuide)
end.linkTo(endGuide)
})
Button(
onClick = { onTriggerEvent(BasicInformationEvent.Weight(weight = weightNumber)) },
modifier = Modifier.constrainAs(continueButton) {
end.linkTo(endGuide)
bottom.linkTo(weightMeasurement.top, 20.dp)
})
{
Text(text = stringResource(id = R.string.title_continue))
}
HorizontalRuler(
steps = 700,
onValueChanged = { weightNumber = it.toDouble() },
modifier = Modifier.constrainAs(weightMeasurement) {
start.linkTo(parent.start)
end.linkTo(parent.end)
bottom.linkTo(bottomGuide)
}
)
}
}
@Composable
fun HeightMeasurement(units: SystemOfMeasurement, onTriggerEvent: (BasicInformationEvent) -> Unit = {}) {
ConstraintLayout(modifier = Modifier.fillMaxSize()) {
val (title, desc, image, weightLocked, heightMeasurement, heightValue, continueButton) = createRefs()
val topGuide = createGuidelineFromTop(50.dp)
val bottomGuide = createGuidelineFromBottom(GuidelineProperties.BOTTOM_100)
val startGuide = createGuidelineFromStart(GuidelineProperties.START)
val endGuide = createGuidelineFromEnd(GuidelineProperties.END)
var heightNumber by remember { mutableDoubleStateOf(0.0) }
StandardTitleText(text = R.string.select_height,
modifier = Modifier.constrainAs(title) {
top.linkTo(topGuide)
end.linkTo(endGuide)
}
)
StandardTextSmall(
text = R.string.desc_select_height,
textAlign = TextAlign.End,
modifier = Modifier.constrainAs(desc) {
top.linkTo(title.bottom, 10.dp)
start.linkTo(heightMeasurement.end)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
)
val isVisible = remember { mutableStateOf(false) }
val rotationYAnimatable = remember { Animatable(0f) }
val textColor by animateColorAsState(
targetValue = if (isVisible.value) Green else Color.Black,
animationSpec = tween(durationMillis = 2000),
label = "textColor"
)
LaunchedEffect(key1 = Unit) {
delay(250)
isVisible.value = true
rotationYAnimatable.animateTo(
targetValue = 720f, // Rotate 360 degrees
animationSpec = tween(durationMillis = 1000, easing = LinearEasing)
)
}
AnimatedVisibility(
visible = isVisible.value,
modifier = Modifier.constrainAs(weightLocked) {
top.linkTo(desc.bottom, 10.dp)
end.linkTo(endGuide)
}
) {
Row(verticalAlignment = Alignment.CenterVertically) {
Icon(imageVector = Icons.Default.Check,
tint = textColor,
contentDescription = stringResource(id = R.string.content_description_checkmark),
modifier = Modifier.graphicsLayer {
rotationY = rotationYAnimatable.value
cameraDistance = 12f * density
}
)
Spacer(modifier = Modifier.size(5.dp))
StandardTextSmall(
text = R.string.weight,
color = textColor
)
}
}
Image(
painter = painterResource(id = R.drawable.icon_women_temp),
contentDescription = "women",
modifier = Modifier.constrainAs(image) {
top.linkTo(desc.bottom, 75.dp)
start.linkTo(startGuide, 75.dp)
end.linkTo(endGuide)
}
)
val lengthUnits = if(units == SystemOfMeasurement.METRIC) ELengthUnit.CENTIMETER else ELengthUnit.FEET
Text(text = formatHeight(heightNumber, lengthUnits),
fontSize = 24.sp,
modifier = Modifier.constrainAs(heightValue) {
top.linkTo(image.bottom)
bottom.linkTo(continueButton.top)
start.linkTo(startGuide, 75.dp)
end.linkTo(endGuide)
}
)
Button(
onClick = { onTriggerEvent(BasicInformationEvent.Height(height = heightNumber)) },
modifier = Modifier.constrainAs(continueButton) {
end.linkTo(endGuide)
bottom.linkTo(bottomGuide)
}
) {
Text(text = stringResource(id = R.string.title_continue))
}
VerticalRuler(
steps = 200,
onValueChanged = { heightNumber = it.toDouble() },
modifier = Modifier.constrainAs(heightMeasurement) {
start.linkTo(parent.start)
top.linkTo(parent.top)
bottom.linkTo(parent.bottom)
}
)
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/basic/view/HeightWeight.kt | 1320005548 |
package com.fitness.onboard.onboard.basic.view
import androidx.compose.animation.core.MutableTransitionState
import androidx.compose.animation.core.Spring
import androidx.compose.animation.core.animateDp
import androidx.compose.animation.core.spring
import androidx.compose.animation.core.updateTransition
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.gestures.snapping.rememberSnapFlingBehavior
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.offset
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.KeyboardArrowUp
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
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.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.constraintlayout.compose.ChainStyle
import androidx.constraintlayout.compose.ConstraintLayout
import androidx.constraintlayout.compose.Dimension
import com.fitness.component.components.StandardTextSmall
import com.fitness.component.components.StandardTitleText
import com.fitness.component.properties.GuidelineProperties
import com.fitness.onboard.onboard.basic.viewmodel.BasicInformationEvent
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import enums.EGender
import extensions.Dark
import extensions.Light
import kotlin.math.abs
import kotlin.math.round
@Light
@Dark
@Composable
private fun PreviewGenderAge() = BodyBalanceTheme {
Surface {
GenderAge()
}
}
@Composable
fun GenderAge(onTriggerEvent: (BasicInformationEvent) -> Unit = {}) {
ConstraintLayout(modifier = Modifier.fillMaxSize()) {
val (
genderTitle,
genderDesc,
ageTitle,
ageDesc,
maleImage,
maleCircle,
femaleImage,
femaleCircle,
genderToggle,
agePicker,
arrowUp,
continueButton
) = createRefs()
val topGuide = createGuidelineFromTop(GuidelineProperties.TOP)
val secondTopGuide = createGuidelineFromTop(GuidelineProperties.SECOND_TOP)
val midGuide = createGuidelineFromTop(.5f)
val bottomGuide = createGuidelineFromBottom(GuidelineProperties.BOTTOM_100)
val startGuide = createGuidelineFromStart(GuidelineProperties.START)
val endGuide = createGuidelineFromEnd(GuidelineProperties.END)
createHorizontalChain(maleImage, femaleImage, chainStyle = ChainStyle.Spread)
var isMale by remember { mutableStateOf(true) }
val maleColor = if (!isMale) Color.Transparent else MaterialTheme.colorScheme.secondaryContainer
val femaleColor = if (isMale) Color.Transparent else MaterialTheme.colorScheme.secondaryContainer
val gender by remember { mutableStateOf(if (isMale) EGender.MALE else EGender.FEMALE) }
var age by remember { mutableIntStateOf(18) }
StandardTitleText(
text = R.string.select_gender,
modifier = Modifier.constrainAs(genderTitle) {
start.linkTo(startGuide)
top.linkTo(topGuide)
}
)
StandardTextSmall(
text = R.string.desc_select_gender,
textAlign = TextAlign.Start,
modifier = Modifier.constrainAs(genderDesc) {
start.linkTo(startGuide)
top.linkTo(genderTitle.bottom, 10.dp)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
)
Box(modifier = Modifier
.background(maleColor, CircleShape)
.constrainAs(maleCircle) {
start.linkTo(maleImage.start, 15.dp)
end.linkTo(maleImage.end, 15.dp)
top.linkTo(maleImage.top, 35.dp)
bottom.linkTo(maleImage.bottom)
height = Dimension.fillToConstraints
width = Dimension.fillToConstraints
}
)
Image(
painter = painterResource(id = R.drawable.icon_man),
contentDescription = stringResource(id = R.string.content_description_sex_male),
modifier = Modifier
.size(120.dp)
.constrainAs(maleImage) {
start.linkTo(startGuide)
end.linkTo(femaleImage.start)
top.linkTo(secondTopGuide, 20.dp)
}
)
Box(modifier = Modifier
.background(femaleColor, CircleShape)
.constrainAs(femaleCircle) {
start.linkTo(femaleImage.start, 15.dp)
end.linkTo(femaleImage.end, 15.dp)
top.linkTo(femaleImage.top, 35.dp)
bottom.linkTo(femaleImage.bottom)
height = Dimension.fillToConstraints
width = Dimension.fillToConstraints
}
)
Image(
painter = painterResource(id = R.drawable.icon_woman),
contentDescription = stringResource(id = R.string.content_description_sex_female),
modifier = Modifier
.size(120.dp)
.constrainAs(femaleImage) {
start.linkTo(maleImage.end)
end.linkTo(endGuide)
top.linkTo(secondTopGuide, 20.dp)
}
)
TextToggleSwitch(
isChecked = isMale,
onCheckedChange = { isMale = !isMale },
modifier = Modifier.constrainAs(genderToggle) {
top.linkTo(maleImage.bottom)
start.linkTo(maleImage.start)
end.linkTo(femaleImage.end)
bottom.linkTo(midGuide)
width = Dimension.fillToConstraints
}
)
StandardTitleText(
text = R.string.select_age,
modifier = Modifier.constrainAs(ageTitle) {
start.linkTo(startGuide)
top.linkTo(midGuide, 20.dp)
}
)
StandardTextSmall(
text = R.string.desc_select_age,
textAlign = TextAlign.Start,
modifier = Modifier.constrainAs(ageDesc) {
end.linkTo(endGuide)
start.linkTo(startGuide)
top.linkTo(ageTitle.bottom, 10.dp)
width = Dimension.fillToConstraints
}
)
AgePickerLazyRow(
onAgeChanged = { age = it },
modifier = Modifier.constrainAs(agePicker) {
top.linkTo(midGuide, 20.dp)
start.linkTo(startGuide)
end.linkTo(endGuide)
bottom.linkTo(continueButton.top)
})
Icon(
imageVector = Icons.Default.KeyboardArrowUp,
contentDescription = stringResource(id = R.string.content_description_arrow_up),
modifier = Modifier.constrainAs(arrowUp) {
start.linkTo(parent.start)
end.linkTo(parent.end)
top.linkTo(agePicker.bottom, 10.dp)
}
)
Button(
onClick = {
onTriggerEvent(
BasicInformationEvent.GenderAge(
gender = gender,
age = age
)
)
},
modifier = Modifier.constrainAs(continueButton) {
end.linkTo(endGuide)
bottom.linkTo(bottomGuide)
}
) {
Text(text = stringResource(id = R.string.title_continue))
}
}
}
@Composable
private fun TextToggleSwitch(
modifier: Modifier = Modifier,
isChecked: Boolean,
onCheckedChange: (Boolean) -> Unit
) {
// Define the base state for animation
val transitionState = remember { MutableTransitionState(isChecked) }
transitionState.targetState = isChecked
BoxWithConstraints(modifier = modifier) {
// Total width of the container
val containerWidth = maxWidth
// Size and padding of the toggle circle
val toggleSize = 50.dp
val togglePadding = 8.dp
val toggleDiameterAndPadding = toggleSize + (togglePadding * 2)
// Define the transition for the toggle animation
val transition = updateTransition(transitionState, label = "ToggleSwitch")
val toggleOffset by transition.animateDp(
label = "ToggleOffset",
transitionSpec = {
if (targetState) {
spring(dampingRatio = Spring.DampingRatioMediumBouncy)
} else {
spring(dampingRatio = Spring.DampingRatioMediumBouncy)
}
}
) { state ->
if (state)
0.dp
else
containerWidth - toggleDiameterAndPadding
}
Box(
modifier = Modifier
.fillMaxWidth()
.clip(CircleShape)
.background(MaterialTheme.colorScheme.secondaryContainer)
.clickable { onCheckedChange(!isChecked) }
) {
Box(
modifier = Modifier
.padding(togglePadding)
.align(Alignment.CenterStart)
.offset(toggleOffset)
.clip(CircleShape)
.background(MaterialTheme.colorScheme.primary)
.size(toggleSize)
)
Text(
text = if (isChecked) "Male" else "Female",
modifier = Modifier.align(Alignment.Center)
)
}
}
}
@Light
@Dark
@Composable
private fun TextToggleSwitchPreview() {
var isChecked by remember { mutableStateOf(true) }
TextToggleSwitch(
modifier = Modifier.padding(16.dp),
isChecked = isChecked,
onCheckedChange = { isChecked = it }
)
}
@Composable
@OptIn(ExperimentalFoundationApi::class)
private fun AgePickerLazyRow(modifier: Modifier = Modifier, onAgeChanged: (Int) -> Unit = {}) {
val numbers = (18..100).toMutableList()
val itemWidth = 100.dp
val halfItemWidth = itemWidth / 2
val lazyRowWidth = itemWidth * 3
numbers.add(numbers.size, 0)
numbers.add(0, 0)
val state = rememberLazyListState()
val centeredNumber = remember { mutableIntStateOf(0) }
LazyRow(
modifier = modifier.width(lazyRowWidth),
state = state,
flingBehavior = rememberSnapFlingBehavior(lazyListState = state)
) {
items(numbers) { number ->
Box(
modifier = Modifier
.width(itemWidth)
.padding(8.dp),
contentAlignment = Alignment.Center
) {
if (number != 0) {
val isCentered = number == centeredNumber.intValue
Text(
text = number.toString(),
fontSize = if (isCentered) 22.sp else 16.sp,
fontWeight = if (isCentered) FontWeight.SemiBold else FontWeight.Normal
)
}
}
}
}
val density = LocalDensity.current
LaunchedEffect(state) {
snapshotFlow { state.layoutInfo.visibleItemsInfo }
.collect { visibleItems ->
val center = lazyRowWidth / 2
val centeredItem = visibleItems.minByOrNull { visibleItem ->
val itemCenter =
visibleItem.offset + with(density) { halfItemWidth.roundToPx() }
abs(itemCenter - with(density) { center.roundToPx() })
}
centeredItem?.let {
val newCenteredNumber = numbers[it.index]
if (centeredNumber.intValue != newCenteredNumber) {
centeredNumber.intValue = newCenteredNumber
onAgeChanged(centeredNumber.intValue)
}
}
}
}
}
| body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/basic/view/GenderAge.kt | 3107186862 |
package com.fitness.onboard.onboard.basic.view
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.Button
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableDoubleStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.constraintlayout.compose.ConstraintLayout
import androidx.constraintlayout.compose.Dimension
import com.fitness.component.HorizontalRuler
import com.fitness.component.components.StandardTextSmall
import com.fitness.component.components.StandardTitleText
import com.fitness.onboard.onboard.basic.viewmodel.BasicInformationEvent
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import enums.ELengthUnit
import enums.SystemOfMeasurement
import enums.formatLength
import extensions.Dark
import extensions.Light
@Light
@Dark
@Composable
private fun PreviewWaistSize() = BodyBalanceTheme {
Surface {
WaistMeasurement(SystemOfMeasurement.METRIC)
}
}
@Composable
fun WaistMeasurement(units: SystemOfMeasurement, onTriggerEvent: (BasicInformationEvent) -> Unit = {}) {
ConstraintLayout(modifier = Modifier.fillMaxSize()) {
val (titleRef, descriptionRef, waistSizeRef, horizontalRulerRef, measurementIconRef, continueRef) = createRefs()
val topGuide = createGuidelineFromTop(50.dp)
val startGuideline = createGuidelineFromStart(.05f)
val endGuideline = createGuidelineFromEnd(.05f)
var waistSize by remember { mutableDoubleStateOf(30.0) }
StandardTitleText(
text = R.string.title_waist_size,
textAlign = TextAlign.Start,
modifier = Modifier.constrainAs(titleRef) {
top.linkTo(topGuide)
start.linkTo(startGuideline)
end.linkTo(endGuideline)
width = Dimension.fillToConstraints
}
)
StandardTextSmall(
text = R.string.description_waist_size,
textAlign = TextAlign.Start,
modifier = Modifier.constrainAs(descriptionRef) {
top.linkTo(titleRef.bottom, 20.dp)
start.linkTo(startGuideline)
end.linkTo(endGuideline)
width = Dimension.fillToConstraints
}
)
val lengthUnits = if(units == SystemOfMeasurement.METRIC) ELengthUnit.CENTIMETER else ELengthUnit.INCHES
Text(
text = formatLength(waistSize, lengthUnits),
fontSize = 24.sp,
modifier = Modifier.constrainAs(waistSizeRef) {
top.linkTo(descriptionRef.bottom, 20.dp)
start.linkTo(startGuideline)
end.linkTo(endGuideline)
bottom.linkTo(continueRef.top)
}
)
HorizontalRuler(
steps = 200,
onValueChanged = {waistSize = it.toDouble() },
modifier = Modifier.constrainAs(horizontalRulerRef) {
start.linkTo(parent.start)
end.linkTo(parent.end)
bottom.linkTo(parent.bottom)
}
)
Button(
onClick = { onTriggerEvent(BasicInformationEvent.Waist(waistSize)) },
modifier = Modifier.constrainAs(continueRef) {
end.linkTo(endGuideline)
bottom.linkTo(horizontalRulerRef.top, 20.dp)
}
) {
Text(text = stringResource(id = R.string.title_continue))
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/basic/view/Waist.kt | 781970441 |
package com.fitness.onboard.onboard.basic
import enums.EGender
import enums.ELengthUnit
import enums.EMassUnit
import enums.SystemOfMeasurement
object BasicInformationStateHolder {
private var BasicInformationState: BasicInformationState = BasicInformationState()
fun getState() = BasicInformationState
fun updateState(newState: BasicInformationState) {
BasicInformationState = newState
}
fun clearState() {
BasicInformationState = BasicInformationState()
}
}
data class BasicInformationState(
val age: Int? = null,
val gender: EGender? = null,
val height: Double? = null,
val weight: Double? = null,
val waist: Double? = null,
val preferredMeasurement: SystemOfMeasurement = SystemOfMeasurement.METRIC
)
| body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/basic/BasicInformationStateHolder.kt | 2786857300 |
package com.fitness.onboard.onboard.welcome
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.size
import androidx.compose.material3.Button
import androidx.compose.material3.Surface
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.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.constraintlayout.compose.ConstraintLayout
import androidx.constraintlayout.compose.Dimension
import com.fitness.component.components.StandardHeadlineText
import com.fitness.component.components.StandardText
import com.fitness.component.components.StandardTitleText
import com.fitness.component.properties.GuidelineProperties
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
@Preview
@Composable
fun PreviewVerificationCodeInput() = BodyBalanceTheme {
Surface {
WelcomeScreen()
}
}
@Composable
fun WelcomeScreen(onContinue: () -> Unit = {}) {
ConstraintLayout(modifier = Modifier.fillMaxSize()) {
val (title, description, features, getStarted) = createRefs()
val titleTop = createGuidelineFromTop(GuidelineProperties.SECOND_TOP)
val titleBottom = createGuidelineFromTop(275.dp)
val startGuide = createGuidelineFromStart(GuidelineProperties.START)
val endGuide = createGuidelineFromEnd(GuidelineProperties.END)
val bottomGuide = createGuidelineFromBottom(GuidelineProperties.BOTTOM_100)
StandardTitleText(
fontSize = 36.sp,
text = R.string.app_name,
modifier = Modifier.constrainAs(title) {
top.linkTo(titleTop)
bottom.linkTo(titleBottom)
start.linkTo(startGuide)
}
)
StandardHeadlineText(
text = R.string.onboarding_welcome_description,
textAlign = TextAlign.Start,
modifier = Modifier.constrainAs(description) {
top.linkTo(title.bottom, 20.dp)
start.linkTo(startGuide)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
)
FeatureList(modifier = Modifier.constrainAs(features) {
top.linkTo(description.bottom, 20.dp)
bottom.linkTo(getStarted.top)
start.linkTo(startGuide)
height = Dimension.fillToConstraints
})
Button(
onClick = { onContinue() },
modifier = Modifier.constrainAs(getStarted) {
end.linkTo(endGuide)
bottom.linkTo(bottomGuide)
}
) {
Text(text = stringResource(id = R.string.title_continue))
}
}
}
@Composable
fun FeatureList(modifier: Modifier){
Column(modifier=modifier) {
Spacer(modifier = Modifier.size(50.dp))
StandardText(
text = R.string.feature_planning,
textAlign = TextAlign.Start,
)
Spacer(modifier = Modifier.size(20.dp))
StandardText(
text = R.string.feature_tracking,
textAlign = TextAlign.Start,
)
Spacer(modifier = Modifier.size(20.dp))
StandardText(
text = R.string.feature_deep_analysis,
textAlign = TextAlign.Start,
)
}
}
| body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/welcome/Welcome.kt | 2872580740 |
package com.fitness.onboard.onboard.fitness.viewmodel
import enums.EFitnessInterest
import enums.EPhysicalActivityLevel
data class FitnessState(val step: FitnessStep = FitnessStep.FITNESS_LEVELS, val habits: List<EFitnessInterest> = emptyList())
sealed class FitnessEvent{
data class FitnessLevel(val level: EPhysicalActivityLevel): FitnessEvent()
data class Habits(val habits: List<EFitnessInterest>): FitnessEvent()
object DismissDialog: FitnessEvent()
object SaveFitnessInfo: FitnessEvent()
}
enum class FitnessStep {
FITNESS_LEVELS,
HABITS,
SAVE_FITNESS_INFO,
COMPLETE
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/fitness/viewmodel/FitnessContract.kt | 3094317414 |
package com.fitness.onboard.onboard.fitness.viewmodel
import com.fitness.domain.model.user.UserFitnessLevel
import com.fitness.domain.usecase.user.CreateUserBasicFitnessUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.onboard.onboard.fitness.FitnessStateHolder
import com.fitness.onboard.util.HABITS_MIN_SELECTION
import com.fitness.onboard.util.OnboardFailure
import com.fitness.onboard.util.isMinSelection
import com.fitness.onboard.util.toOnboardFailure
import dagger.hilt.android.lifecycle.HiltViewModel
import failure.MinimumNumberOfSelectionFailure
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class FitnessViewModel @Inject constructor(
private val stateHolder: FitnessStateHolder,
private val currentUserIdUseCase: GetCurrentUserIdUseCase,
private val createUserBasicFitnessUseCase: CreateUserBasicFitnessUseCase
): IntentViewModel<BaseViewState<FitnessState>, FitnessEvent>(){
init { setState(BaseViewState.Data(FitnessState())) }
override fun onTriggerEvent(event: FitnessEvent) {
when(event){
is FitnessEvent.FitnessLevel -> onFitnessLevels(event)
is FitnessEvent.Habits -> onHabits(event)
is FitnessEvent.SaveFitnessInfo -> getCurrentUserId()
is FitnessEvent.DismissDialog -> onDismissDialog()
}
}
override fun handleError(exception: Throwable) {
super.handleError(exception.toOnboardFailure())
}
private fun onDismissDialog(){
val state = stateHolder.getState()
setState(BaseViewState.Data(FitnessState(step = state.currentStep, habits = state.habits)))
}
private fun onFitnessLevels(event: FitnessEvent.FitnessLevel){
stateHolder.updateState(stateHolder.getState().copy(currentStep = FitnessStep.HABITS, level = event.level))
setState(BaseViewState.Data(FitnessState(FitnessStep.HABITS)))
}
private fun onHabits(event: FitnessEvent.Habits){
stateHolder.updateState(stateHolder.getState().copy(habits = event.habits))
if(isMinSelection(event.habits.size, HABITS_MIN_SELECTION)){
setState(BaseViewState.Data(FitnessState(FitnessStep.SAVE_FITNESS_INFO)))
}
else{
setState(BaseViewState.Error(MinimumNumberOfSelectionFailure(minSelection = HABITS_MIN_SELECTION)))
}
}
private fun getCurrentUserId() = safeLaunch {
execute(currentUserIdUseCase(GetCurrentUserIdUseCase.Params)){
onVerify(it)
}
}
private fun onVerify(id: String){
val fitness = stateHolder.getState()
val level = fitness.level
val habits = fitness.habits
if(level != null && habits.isNotEmpty()){
val userBasicInfo = UserFitnessLevel(id, level, habits)
onSaveFitnessLevelsInfo(userBasicInfo)
}else{
setState(BaseViewState.Error(OnboardFailure.UnknownFailure()))
}
}
private fun onSaveFitnessLevelsInfo(userBasicInfoDomain: UserFitnessLevel) = safeLaunch {
val param = CreateUserBasicFitnessUseCase.Params(userBasicInfoDomain)
execute(createUserBasicFitnessUseCase(param)){
setState(BaseViewState.Data(FitnessState(FitnessStep.COMPLETE)))
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/fitness/viewmodel/FitnessViewModel.kt | 1167269697 |
package com.fitness.onboard.onboard.fitness
import android.content.res.Configuration
import androidx.compose.animation.Crossfade
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import com.fitness.component.screens.ErrorDialog
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.onboard.onboard.fitness.view.FitnessLevels
import com.fitness.onboard.onboard.fitness.view.Habits
import com.fitness.onboard.onboard.fitness.viewmodel.FitnessEvent
import com.fitness.onboard.onboard.fitness.viewmodel.FitnessState
import com.fitness.onboard.onboard.fitness.viewmodel.FitnessStep
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.cast
import failure.AuthStateFailure
import failure.Failure
import failure.MinimumNumberOfSelectionFailure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Preview(name = "Light", showBackground = true)
@Preview(name = "Dark", showBackground = true, uiMode = Configuration.UI_MODE_NIGHT_YES)
@Composable
private fun FitnessLevelsPreview() = BodyBalanceTheme {
Surface {
FitnessLevels()
}
}
@Composable
fun FitnessScreen(
state: StateFlow<BaseViewState<FitnessState>>,
onTriggerEvent: (FitnessEvent) -> Unit,
onComplete: () -> Unit,
onForceSignOut: () -> Unit
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
Fitness(
state = uiState.cast<BaseViewState.Data<FitnessState>>().value,
onTriggerEvent = onTriggerEvent,
onComplete = onComplete
)
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
if(failure is MinimumNumberOfSelectionFailure){
ErrorDialog(
title = stringResource(id = failure.title),
description = stringResource(id = failure.description, failure.minSelection),
onDismiss = { onTriggerEvent(FitnessEvent.DismissDialog) }
)
}
else {
ErrorScreen(title = failure.title, description = failure.description) {
if (failure is AuthStateFailure) {
onForceSignOut()
} else {
onComplete()
}
}
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onComplete)
}
}
}
@Composable
private fun Fitness(
state: FitnessState,
onTriggerEvent: (FitnessEvent) -> Unit = {},
onComplete: () -> Unit = {}
) {
Crossfade(targetState = state.step, label = "Fitness") {
when(it){
FitnessStep.FITNESS_LEVELS -> FitnessLevels(onTriggerEvent = onTriggerEvent)
FitnessStep.HABITS -> Habits(state, onTriggerEvent = onTriggerEvent)
FitnessStep.SAVE_FITNESS_INFO -> onTriggerEvent(FitnessEvent.SaveFitnessInfo)
FitnessStep.COMPLETE -> onComplete()
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/fitness/Fitness.kt | 448324516 |
package com.fitness.onboard.onboard.fitness
import com.fitness.onboard.onboard.fitness.viewmodel.FitnessStep
import enums.EFitnessInterest
import enums.EPhysicalActivityLevel
object FitnessStateHolder {
private var fitnessState: FitnessState = FitnessState()
fun getState() = fitnessState
fun updateState(newState: FitnessState) {
fitnessState = newState
}
fun clearState() {
fitnessState = FitnessState()
}
}
data class FitnessState(
val currentStep: FitnessStep = FitnessStep.FITNESS_LEVELS,
val level: EPhysicalActivityLevel? = null,
val habits: List<EFitnessInterest> = emptyList()
)
| body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/fitness/FitnessStateHolder.kt | 3451245039 |
package com.fitness.onboard.onboard.fitness.view
import androidx.compose.foundation.Image
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.constraintlayout.compose.ConstraintLayout
import androidx.constraintlayout.compose.Dimension
import com.fitness.component.components.StandardTextSmall
import com.fitness.component.components.StandardTitleText
import com.fitness.component.properties.GuidelineProperties
import com.fitness.component.properties.GuidelineProperties.TOP
import com.fitness.onboard.onboard.fitness.viewmodel.FitnessEvent
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import com.fitness.theme.ui.Green
import enums.EPhysicalActivityLevel
import extensions.Dark
import extensions.Light
@Light
@Dark
@Composable
private fun PreviewFitnessLevels() = BodyBalanceTheme {
Surface {
FitnessLevels()
}
}
@Composable
fun FitnessLevels(onTriggerEvent: (FitnessEvent) -> Unit = {}) {
ConstraintLayout(modifier = Modifier.fillMaxSize()) {
val (title,
desc,
avatar,
levels,
levelDescription,
continueButton
) = createRefs()
val topGuide = createGuidelineFromTop(TOP)
val bottomGuide = createGuidelineFromBottom(GuidelineProperties.BOTTOM)
val startGuide = createGuidelineFromStart(GuidelineProperties.START)
val endGuide = createGuidelineFromEnd(GuidelineProperties.END)
var currentLevel by remember { mutableStateOf(EPhysicalActivityLevel.SEDENTARY) }
StandardTitleText(
text = R.string.title_activity_level,
modifier = Modifier.constrainAs(title) {
start.linkTo(startGuide)
top.linkTo(topGuide)
}
)
StandardTextSmall(
text = R.string.desc_current_activity_level,
textAlign = TextAlign.Start,
modifier = Modifier.constrainAs(desc) {
start.linkTo(startGuide)
top.linkTo(title.bottom, 10.dp)
end.linkTo(endGuide)
width = Dimension.fillToConstraints
}
)
Image(
painter = painterResource(id = R.drawable.icon_fruit),
contentDescription = "women",
modifier = Modifier.constrainAs(avatar) {
top.linkTo(desc.bottom)
bottom.linkTo(bottomGuide)
start.linkTo(startGuide)
end.linkTo(levels.start)
height = Dimension.fillToConstraints
width = Dimension.fillToConstraints
}
)
Column(
horizontalAlignment = Alignment.Start,
verticalArrangement = Arrangement.SpaceEvenly,
modifier = Modifier
.padding(16.dp)
.constrainAs(levels) {
end.linkTo(parent.end)
top.linkTo(desc.bottom)
bottom.linkTo(continueButton.top)
height = Dimension.fillToConstraints
}
) {
EPhysicalActivityLevel.values().forEach { cardLevel ->
PhysicalActivityCard(
size = 90.dp,
level = cardLevel,
currentLevel = currentLevel,
onClick = { currentLevel = it }
)
}
}
Text(
text = stringResource(id = currentLevel.description),
modifier = Modifier.constrainAs(levelDescription) {
start.linkTo(startGuide)
end.linkTo(continueButton.start)
top.linkTo(continueButton.top)
bottom.linkTo(continueButton.bottom)
width = Dimension.fillToConstraints
}
)
Button(
onClick = { onTriggerEvent(FitnessEvent.FitnessLevel(level = currentLevel)) },
modifier = Modifier.padding(15.dp).constrainAs(continueButton) {
end.linkTo(endGuide)
bottom.linkTo(bottomGuide)
})
{
Text(text = stringResource(id = R.string.title_continue))
}
}
}
@Composable
private fun PhysicalActivityCard(
size: Dp,
level: EPhysicalActivityLevel,
currentLevel: EPhysicalActivityLevel,
onClick: (EPhysicalActivityLevel) -> Unit
) {
val cardLevel by remember { mutableStateOf(level) }
Card(
colors = CardDefaults.cardColors(
containerColor =
if (cardLevel == currentLevel)
Green
else
MaterialTheme.colorScheme.surfaceVariant
),
shape = CircleShape,
modifier = Modifier
.size(size)
.clickable {
if (cardLevel != currentLevel) {
onClick(cardLevel)
}
}
) {
Column(
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier.size(size)
) {
StandardTextSmall(text = level.title)
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/fitness/view/Levels.kt | 3671438562 |
package com.fitness.onboard.onboard.fitness.view
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import com.fitness.component.screens.BalanceLazyColumn
import com.fitness.onboard.onboard.fitness.viewmodel.FitnessEvent
import com.fitness.onboard.onboard.fitness.viewmodel.FitnessState
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import enums.EFitnessInterest
import extensions.Dark
import extensions.Light
@Light
@Dark
@Composable
private fun PreviewHabitsContent() = BodyBalanceTheme {
Surface {
Habits(FitnessState())
}
}
@Composable
fun Habits(state: FitnessState, onTriggerEvent: (FitnessEvent) -> Unit = {}) =
BalanceLazyColumn(
title = R.string.title_fitness_habits,
description = R.string.desc_fitness_habits,
items = EFitnessInterest.values(),
selections = state.habits.toMutableList(),
onButtonClicked = {
onTriggerEvent(FitnessEvent.Habits(habits = it))
}
) | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/fitness/view/Habits.kt | 2667944035 |
package com.fitness.onboard.onboard.finalize.viewmodel
import com.fitness.authentication.manager.AuthenticationManager
import com.fitness.authentication.manager.AuthenticationState
import com.fitness.domain.model.user.UserBasicInfo
import com.fitness.domain.usecase.metrics.CreateUserBodyMetricsFromUserInfoUseCase
import com.fitness.domain.usecase.user.GetBasicUserInfoUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.domain.usecase.user.GetCurrentUserUseCase
import com.fitness.onboard.onboard.finalize.FinalizeStateHolder
import com.fitness.onboard.util.OnboardFailure
import dagger.hilt.android.lifecycle.HiltViewModel
import enums.SystemOfMeasurement
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class FinalizeViewModel @Inject constructor(
private val currentUserIdUseCase: GetCurrentUserIdUseCase,
private val currentUserUseCase: GetCurrentUserUseCase,
private val basicUserInfoUseCase: GetBasicUserInfoUseCase,
private val createRecommendedMetricsUseCase: CreateUserBodyMetricsFromUserInfoUseCase,
private val stateHolder: FinalizeStateHolder,
private val authenticationManager: AuthenticationManager
): IntentViewModel<BaseViewState<FinalizeState>, FinalizeEvent>() {
init {
setState(BaseViewState.Data(FinalizeState()))
}
override fun onTriggerEvent(event: FinalizeEvent) {
when(event){
FinalizeEvent.Initialize -> onGetCurrentUserId()
FinalizeEvent.SaveRecommendedMetrics -> onSaveRecommended()
FinalizeEvent.Complete -> onComplete()
}
}
private fun onGetCurrentUserId() = safeLaunch {
execute(currentUserIdUseCase(params = GetCurrentUserIdUseCase.Params)){
onGetCurrentUser(id = it)
}
}
private fun onGetCurrentUser(id: String) = safeLaunch {
execute(currentUserUseCase(params = GetCurrentUserUseCase.Params(id))){
val state = stateHolder.getState().copy(unitSystem = it.userPreferences.systemOfMeasurement)
stateHolder.updateState(newState = state)
onGetCurrentUserBasicInfo(id = id)
}
}
private fun onGetCurrentUserBasicInfo(id: String) = safeLaunch {
execute(basicUserInfoUseCase(params = GetBasicUserInfoUseCase.Params(id))){
val state = stateHolder.getState().copy(userBasicInfo = it, currentStep = FinalizeStep.SAVE_RECOMMENDED)
stateHolder.updateState(newState = state)
setState(BaseViewState.Data(FinalizeState(step = FinalizeStep.SAVE_RECOMMENDED)))
}
}
private fun onSaveRecommended(){
val state = stateHolder.getState()
val basicInfo = state.userBasicInfo
val unitSystem = state.unitSystem
if(basicInfo != null && unitSystem != null){
saveRecommended(basicInfo = basicInfo, unitSystem = unitSystem)
}else{
setState(state = BaseViewState.Error(failure = OnboardFailure.UnknownFailure()))
}
}
private fun saveRecommended(basicInfo: UserBasicInfo, unitSystem: SystemOfMeasurement) = safeLaunch {
execute(createRecommendedMetricsUseCase(params = CreateUserBodyMetricsFromUserInfoUseCase.Params(info = basicInfo, unitSystem = unitSystem))){
val state = stateHolder.getState().copy(currentStep = FinalizeStep.COMPLETE)
stateHolder.updateState(newState = state)
setState(BaseViewState.Data(FinalizeState(step = FinalizeStep.COMPLETE)))
}
}
private fun onComplete() = authenticationManager.update(AuthenticationState.Authenticated)
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/finalize/viewmodel/FinalizeViewModel.kt | 2238834818 |
package com.fitness.onboard.onboard.finalize.viewmodel
data class FinalizeState(val step: FinalizeStep = FinalizeStep.INITIALIZE)
sealed class FinalizeEvent{
object Initialize: FinalizeEvent()
object SaveRecommendedMetrics: FinalizeEvent()
object Complete: FinalizeEvent()
}
enum class FinalizeStep {
INITIALIZE,
SAVE_RECOMMENDED,
COMPLETE
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/finalize/viewmodel/FinalizeContract.kt | 346538714 |
package com.fitness.onboard.onboard.finalize
import android.content.res.Configuration
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.tooling.preview.Preview
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.onboard.onboard.finalize.viewmodel.FinalizeEvent
import com.fitness.onboard.onboard.finalize.viewmodel.FinalizeState
import com.fitness.onboard.onboard.finalize.viewmodel.FinalizeStep
import com.fitness.onboard.onboard.fitness.view.FitnessLevels
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.cast
import failure.AuthStateFailure
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Preview(name = "Light", showBackground = true)
@Preview(name = "Dark", showBackground = true, uiMode = Configuration.UI_MODE_NIGHT_YES)
@Composable
private fun FinalizeOnboardingPreview() = BodyBalanceTheme {
Surface {
FitnessLevels()
}
}
@Composable
fun FinalizeOnboardingScreen(
state: StateFlow<BaseViewState<FinalizeState>>,
onTriggerEvent: (FinalizeEvent) -> Unit,
onComplete: () -> Unit,
onForceSignOut: () -> Unit
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
FinalizeOnboardingScreen(
state = uiState.cast<BaseViewState.Data<FinalizeState>>().value,
onTriggerEvent = onTriggerEvent,
onComplete = onComplete
)
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
if (failure is AuthStateFailure) {
onForceSignOut()
} else {
onComplete()
}
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onComplete)
}
}
}
@Composable
private fun FinalizeOnboardingScreen(
state: FinalizeState,
onTriggerEvent: (FinalizeEvent) -> Unit = {},
onComplete: () -> Unit = {}
){
when(state.step){
FinalizeStep.INITIALIZE -> onTriggerEvent(FinalizeEvent.Initialize)
FinalizeStep.SAVE_RECOMMENDED -> onTriggerEvent(FinalizeEvent.SaveRecommendedMetrics)
FinalizeStep.COMPLETE -> onComplete()
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/finalize/FinalizeOnboarding.kt | 2860568300 |
package com.fitness.onboard.onboard.finalize
import com.fitness.domain.model.user.UserBasicInfo
import com.fitness.onboard.onboard.finalize.viewmodel.FinalizeStep
import enums.SystemOfMeasurement
object FinalizeStateHolder {
private var finalizeHolderState: FinalizeHolderState = FinalizeHolderState()
fun getState() = finalizeHolderState
fun updateState(newState: FinalizeHolderState) {
finalizeHolderState = newState
}
fun clearState() {
finalizeHolderState = FinalizeHolderState()
}
}
data class FinalizeHolderState(
val currentStep: FinalizeStep = FinalizeStep.INITIALIZE,
val unitSystem: SystemOfMeasurement? = null,
val userBasicInfo: UserBasicInfo? = null
)
| body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/finalize/FinalizeStateHolder.kt | 2914471575 |
package com.fitness.onboard.onboard.nutrition
import androidx.compose.animation.Crossfade
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.res.stringResource
import com.fitness.component.screens.ErrorDialog
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.onboard.onboard.nutrition.view.CuisineType
import com.fitness.onboard.onboard.nutrition.view.DietaryRestrictions
import com.fitness.onboard.onboard.nutrition.view.HealthLabels
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionEvent
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionState
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionStep
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.AuthStateFailure
import failure.Failure
import failure.MinimumNumberOfSelectionFailure
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun NutritionPreview() = BodyBalanceTheme {
Surface {
Nutrition(NutritionState())
}
}
@Composable
fun NutritionScreen(
state: StateFlow<BaseViewState<NutritionState>> = MutableStateFlow(BaseViewState.Data(NutritionState())),
onTriggerEvent: (NutritionEvent) -> Unit,
onComplete: () -> Unit,
onForceSignOut: () -> Unit
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
Nutrition(
state = uiState.cast<BaseViewState.Data<NutritionState>>().value,
onTriggerEvent = onTriggerEvent,
onComplete = onComplete
)
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
if(failure is MinimumNumberOfSelectionFailure){
ErrorDialog(
title = stringResource(id = failure.title),
description = stringResource(id = failure.description, failure.minSelection),
onDismiss = { onTriggerEvent(NutritionEvent.DismissDialog) }
)
}
else{
ErrorScreen(title = failure.title, description = failure.description) {
if(failure is AuthStateFailure){
onForceSignOut()
}
else{
onComplete()
}
}
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onComplete)
}
}
}
@Composable
private fun Nutrition(
state: NutritionState,
onTriggerEvent: (NutritionEvent) -> Unit = {},
onComplete: () -> Unit = {}
) {
Crossfade(targetState = state.step, label = "Nutrition") {
when(it){
NutritionStep.NUTRITION_PREFERENCES -> HealthLabels(state, onTriggerEvent = onTriggerEvent)
NutritionStep.DIETARY_RESTRICTIONS -> DietaryRestrictions(state, onTriggerEvent = onTriggerEvent)
NutritionStep.CUISINE_TYPE -> CuisineType(state, onTriggerEvent = onTriggerEvent)
NutritionStep.SAVE_INFO -> onTriggerEvent(NutritionEvent.SaveFitnessInfo)
NutritionStep.COMPLETE -> onComplete()
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/nutrition/Nutrition.kt | 257221238 |
package com.fitness.onboard.onboard.nutrition.viewmodel
import enums.ECuisineType
import enums.EDietaryRestrictions
import enums.EHealthLabel
data class NutritionState(
val step: NutritionStep = NutritionStep.NUTRITION_PREFERENCES,
val labels: List<EHealthLabel> = emptyList(),
val restrictions: List<EDietaryRestrictions> = emptyList(),
val cuisineType: List<ECuisineType> = emptyList()
)
sealed class NutritionEvent{
data class HealthLabels(val labels: List<EHealthLabel>): NutritionEvent()
data class DietaryRestrictions(val restrictions: List<EDietaryRestrictions>): NutritionEvent()
data class CuisineType(val cuisineType: List<ECuisineType>): NutritionEvent()
object DismissDialog: NutritionEvent()
object SaveFitnessInfo: NutritionEvent()
}
enum class NutritionStep {
NUTRITION_PREFERENCES,
DIETARY_RESTRICTIONS,
CUISINE_TYPE,
SAVE_INFO,
COMPLETE
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/nutrition/viewmodel/NutritionContract.kt | 2090827224 |
package com.fitness.onboard.onboard.nutrition.viewmodel
import com.fitness.domain.model.user.UserBasicNutritionInfo
import com.fitness.domain.usecase.user.CreateUserBasicNutritionInfoUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.onboard.onboard.nutrition.NutritionStateHolder
import com.fitness.onboard.util.CUISINE_TYPE_MIN_SELECTION
import com.fitness.onboard.util.DIETARY_RESTRICTIONS_MIN_SELECTION
import com.fitness.onboard.util.HEALTH_LABELS_MIN_SELECTION
import com.fitness.onboard.util.OnboardFailure
import com.fitness.onboard.util.isMinSelection
import com.fitness.onboard.util.toOnboardFailure
import dagger.hilt.android.lifecycle.HiltViewModel
import failure.MinimumNumberOfSelectionFailure
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class NutritionViewModel @Inject constructor(
private val stateHolder: NutritionStateHolder,
private val currentUserIdUseCase: GetCurrentUserIdUseCase,
private val createUserBasicNutritionInfoUseCase: CreateUserBasicNutritionInfoUseCase
): IntentViewModel<BaseViewState<NutritionState>, NutritionEvent>(){
init { setState(BaseViewState.Data(NutritionState())) }
override fun onTriggerEvent(event: NutritionEvent) {
when(event){
is NutritionEvent.HealthLabels -> onHealthLabels (event)
is NutritionEvent.DietaryRestrictions -> onDietaryRestrictions(event)
is NutritionEvent.CuisineType -> onCuisineType(event)
is NutritionEvent.SaveFitnessInfo -> getCurrentUserId()
is NutritionEvent.DismissDialog -> onDismissDialog()
}
}
override fun handleError(exception: Throwable) {
super.handleError(exception.toOnboardFailure())
}
private fun onDismissDialog(){
val state = stateHolder.getState()
setState(BaseViewState.Data(NutritionState(step = state.currentStep, labels = state.labels, restrictions = state.restrictions, cuisineType = state.cuisineType)))
}
private fun onHealthLabels (event: NutritionEvent.HealthLabels){
stateHolder.updateState(stateHolder.getState().copy(labels = event.labels))
if (isMinSelection(event.labels.size, HEALTH_LABELS_MIN_SELECTION)) {
setState(BaseViewState.Data(NutritionState(NutritionStep.DIETARY_RESTRICTIONS)))
stateHolder.updateState(stateHolder.getState().copy(currentStep = NutritionStep.DIETARY_RESTRICTIONS))
}
else{
setState(BaseViewState.Error(MinimumNumberOfSelectionFailure(minSelection = HEALTH_LABELS_MIN_SELECTION)))
}
}
private fun onDietaryRestrictions(event: NutritionEvent.DietaryRestrictions){
stateHolder.updateState(stateHolder.getState().copy(restrictions = event.restrictions))
if (isMinSelection(event.restrictions.size, DIETARY_RESTRICTIONS_MIN_SELECTION)) {
setState(BaseViewState.Data(NutritionState(NutritionStep.CUISINE_TYPE)))
stateHolder.updateState(stateHolder.getState().copy(currentStep = NutritionStep.CUISINE_TYPE))
}
else{
setState(BaseViewState.Error(MinimumNumberOfSelectionFailure(minSelection = DIETARY_RESTRICTIONS_MIN_SELECTION)))
}
}
private fun onCuisineType(event: NutritionEvent.CuisineType){
stateHolder.updateState(stateHolder.getState().copy(cuisineType = event.cuisineType))
if (isMinSelection(event.cuisineType.size, CUISINE_TYPE_MIN_SELECTION)) {
setState(BaseViewState.Data(NutritionState(NutritionStep.SAVE_INFO)))
}
else{
setState(BaseViewState.Error(MinimumNumberOfSelectionFailure(minSelection = CUISINE_TYPE_MIN_SELECTION)))
}
}
private fun getCurrentUserId() = safeLaunch {
execute(currentUserIdUseCase(GetCurrentUserIdUseCase.Params)){
onVerify(it)
}
}
private fun onVerify(id: String){
val fitness = stateHolder.getState()
val restrictions = fitness.restrictions
val labels = fitness.labels
val cuisineType = fitness.cuisineType
if(restrictions.isNotEmpty() && labels.isNotEmpty() && cuisineType.isNotEmpty()){
val userBasicInfo = UserBasicNutritionInfo(
userId = id,
restrictions = restrictions,
healthLabels = labels,
cuisineType = cuisineType
)
onSaveFitnessLevelsInfo(userBasicInfo)
}else{
setState(BaseViewState.Error(OnboardFailure.UnknownFailure()))
}
}
private fun onSaveFitnessLevelsInfo(userBasicInfoDomain: UserBasicNutritionInfo) = safeLaunch {
val param = CreateUserBasicNutritionInfoUseCase.Params(userBasicInfoDomain)
execute(createUserBasicNutritionInfoUseCase(param)){
setState(BaseViewState.Data(NutritionState(NutritionStep.COMPLETE)))
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/nutrition/viewmodel/NutritionViewModel.kt | 2366607433 |
package com.fitness.onboard.onboard.nutrition
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionStep
import enums.ECuisineType
import enums.EDietaryRestrictions
import enums.EHealthLabel
object NutritionStateHolder {
private var nutritionState: NutritionState = NutritionState()
fun getState() = nutritionState
fun updateState(newState: NutritionState) {
nutritionState = newState
}
fun clearState() {
nutritionState = NutritionState()
}
}
data class NutritionState(
val currentStep: NutritionStep = NutritionStep.NUTRITION_PREFERENCES,
val labels: List<EHealthLabel> = emptyList(),
val restrictions: List<EDietaryRestrictions> = emptyList(),
val cuisineType: List<ECuisineType> = emptyList()
)
| body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/nutrition/NutritionStateHolder.kt | 3538139882 |
package com.fitness.onboard.onboard.nutrition.view
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import com.fitness.component.screens.BalanceLazyColumn
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionEvent
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionState
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import enums.EHealthLabel
import extensions.Dark
import extensions.Light
@Light
@Dark
@Composable
private fun HealthLabelsPreview() = BodyBalanceTheme {
Surface {
HealthLabels(NutritionState())
}
}
@Composable
fun HealthLabels(state: NutritionState, onTriggerEvent: (NutritionEvent) -> Unit = {}) = BalanceLazyColumn (
title = R.string.onboarding_health_labels_title,
description = R.string.onboarding_health_labels_description,
items = EHealthLabel.values(),
selections = state.labels.toMutableList(),
onButtonClicked = { onTriggerEvent(NutritionEvent.HealthLabels(labels = it)) }
) | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/nutrition/view/HealthLabels.kt | 1023764537 |
package com.fitness.onboard.onboard.nutrition.view
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import com.fitness.component.screens.BalanceLazyColumn
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionEvent
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionState
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import enums.ECuisineType
import extensions.Dark
import extensions.Light
@Light
@Dark
@Composable
private fun CuisineTypePreview() = BodyBalanceTheme {
Surface {
CuisineType(NutritionState())
}
}
@Composable
fun CuisineType(state: NutritionState, onTriggerEvent: (NutritionEvent) -> Unit = {}) = BalanceLazyColumn (
title = R.string.onboarding_cuisine_types_title,
description = R.string.onboarding_cuisine_types_description,
items = ECuisineType.values(),
selections = state.cuisineType.toMutableList(),
onButtonClicked = { onTriggerEvent(NutritionEvent.CuisineType(cuisineType = it)) }
)
| body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/nutrition/view/CuisineType.kt | 625365944 |
package com.fitness.onboard.onboard.nutrition.view
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import com.fitness.component.screens.BalanceLazyColumn
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionEvent
import com.fitness.onboard.onboard.nutrition.viewmodel.NutritionState
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import enums.EDietaryRestrictions
import extensions.Dark
import extensions.Light
@Light
@Dark
@Composable
private fun DietaryRestrictionsPreview() = BodyBalanceTheme {
Surface {
DietaryRestrictions(NutritionState())
}
}
@Composable
fun DietaryRestrictions(state: NutritionState, onTriggerEvent: (NutritionEvent) -> Unit = {}) = BalanceLazyColumn (
title = R.string.title_dietary_restrictions,
description = R.string.desc_dietary_restrictions,
items = EDietaryRestrictions.values(),
selections = state.restrictions.toMutableList(),
onButtonClicked = { onTriggerEvent(NutritionEvent.DietaryRestrictions(restrictions = it)) }
) | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/nutrition/view/DietaryRestrictions.kt | 4251406949 |
package com.fitness.onboard.onboard.goal.viewmodel
import com.fitness.domain.model.user.UserBasicGoalsInfo
import com.fitness.domain.usecase.user.CreateUserBasicGoalsInfoUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.onboard.onboard.goal.GoalStateHolder
import com.fitness.onboard.util.GOALS_MIN_SELECTION
import com.fitness.onboard.util.OnboardFailure
import com.fitness.onboard.util.isMinSelection
import com.fitness.onboard.util.toOnboardFailure
import dagger.hilt.android.lifecycle.HiltViewModel
import failure.MinimumNumberOfSelectionFailure
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class GoalViewModel @Inject constructor(
private val stateHolder: GoalStateHolder,
private val currentUserIdUseCase: GetCurrentUserIdUseCase,
private val createUserBasicNutritionInfoUseCase: CreateUserBasicGoalsInfoUseCase
): IntentViewModel<BaseViewState<GoalState>, GoalEvent>(){
init { setState(BaseViewState.Data(GoalState())) }
override fun onTriggerEvent(event: GoalEvent) {
when(event){
is GoalEvent.Goals -> onGoals (event)
is GoalEvent.SaveInfo -> onGetCurrentUserID()
is GoalEvent.DismissDialog -> onDismissDialog()
}
}
override fun handleError(exception: Throwable) {
super.handleError(exception.toOnboardFailure())
}
private fun onDismissDialog(){
val state = stateHolder.getState()
setState(BaseViewState.Data( GoalState(step = state.currentStep, goals = state.goals)))
}
private fun onGoals (event: GoalEvent.Goals){
stateHolder.updateState(stateHolder.getState().copy(goals = event.goals))
if (isMinSelection(event.goals.size, GOALS_MIN_SELECTION)) {
setState(BaseViewState.Data(GoalState(GoalStep.SAVE_INFO)))
}
else{
setState(BaseViewState.Error(MinimumNumberOfSelectionFailure(minSelection = GOALS_MIN_SELECTION)))
}
}
private fun onGetCurrentUserID() = safeLaunch {
execute(currentUserIdUseCase(GetCurrentUserIdUseCase.Params)){
onVerify(it)
}
}
private fun onVerify(id: String){
val holder = stateHolder.getState()
val goals = holder.goals
if(goals.isNotEmpty()){
val userGoalsInfo = UserBasicGoalsInfo(userId = id, goals = goals)
onSaveFitnessLevelsInfo(userGoalsInfo)
}
else{
setState(BaseViewState.Error(OnboardFailure.UnknownFailure()))
}
}
private fun onSaveFitnessLevelsInfo(userGoalsInfo: UserBasicGoalsInfo) = safeLaunch {
val param = CreateUserBasicGoalsInfoUseCase.Params(userGoalsInfo)
execute(createUserBasicNutritionInfoUseCase(param)){
setState(BaseViewState.Data(GoalState(GoalStep.COMPLETE)))
}
}
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/goal/viewmodel/GoalViewModel.kt | 1406023514 |
package com.fitness.onboard.onboard.goal.viewmodel
import enums.EGoals
data class GoalState(val step: GoalStep = GoalStep.GOALS, val goals: List<EGoals> = emptyList())
sealed class GoalEvent{
data class Goals(val goals: List<EGoals>): GoalEvent()
object SaveInfo: GoalEvent()
object DismissDialog: GoalEvent()
}
enum class GoalStep {
GOALS,
SAVE_INFO,
COMPLETE,
} | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/goal/viewmodel/GoalContract.kt | 4264675308 |
package com.fitness.onboard.onboard.goal
import com.fitness.onboard.onboard.goal.viewmodel.GoalStep
import enums.EGoals
object GoalStateHolder {
private var goalState: GoalState = GoalState()
fun getState() = goalState
fun updateState(newState: GoalState) {
goalState = newState
}
fun clearState() {
goalState = GoalState()
}
}
data class GoalState(val currentStep: GoalStep = GoalStep.GOALS, val goals: List<EGoals> = emptyList())
| body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/goal/GoalStateHolder.kt | 3783281546 |
package com.fitness.onboard.onboard.goal.view
import androidx.compose.animation.Crossfade
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.res.stringResource
import com.fitness.component.screens.BalanceLazyColumn
import com.fitness.component.screens.ErrorDialog
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.onboard.onboard.goal.viewmodel.GoalEvent
import com.fitness.onboard.onboard.goal.viewmodel.GoalState
import com.fitness.onboard.onboard.goal.viewmodel.GoalStep
import com.fitness.resources.R
import com.fitness.theme.ui.BodyBalanceTheme
import enums.EGoals
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.AuthStateFailure
import failure.Failure
import failure.MinimumNumberOfSelectionFailure
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun GoalsPreview() = BodyBalanceTheme {
Surface {
Goals(state = GoalState())
}
}
@Composable
fun GoalsScreen(
state: StateFlow<BaseViewState<GoalState>> = MutableStateFlow(BaseViewState.Data(GoalState())),
onTriggerEvent: (GoalEvent) -> Unit,
onComplete: () -> Unit,
onForceSignOut: () -> Unit
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
Goals(
state = uiState.cast<BaseViewState.Data<GoalState>>().value,
onTriggerEvent = onTriggerEvent,
)
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
if(failure is MinimumNumberOfSelectionFailure){
ErrorDialog(
title = stringResource(id = failure.title),
description = stringResource(id = failure.description, failure.minSelection),
onDismiss = { onTriggerEvent(GoalEvent.DismissDialog) }
)
}
else {
ErrorScreen(title = failure.title, description = failure.description) {
if (failure is AuthStateFailure) {
onForceSignOut()
} else {
onComplete()
}
}
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(
message = R.string.unknown,
onClick = onComplete
)
}
}
}
@Composable
private fun Goals(
state: GoalState,
onTriggerEvent: (GoalEvent) -> Unit = {},
onComplete:() -> Unit = {}
) {
Crossfade(targetState = state.step, label = "Fitness") {
when (it) {
GoalStep.GOALS -> GoalsContent(state, onTriggerEvent = onTriggerEvent)
GoalStep.SAVE_INFO -> onTriggerEvent(GoalEvent.SaveInfo)
GoalStep.COMPLETE -> onComplete()
}
}
}
@Composable
private fun GoalsContent(state: GoalState, onTriggerEvent: (GoalEvent) -> Unit = {}) = BalanceLazyColumn (
title = R.string.title_personal_health_goals,
description = R.string.desc_personal_health_goals,
items = EGoals.values(),
selections = state.goals.toMutableList(),
onButtonClicked = { onTriggerEvent(GoalEvent.Goals(goals = it)) }
) | body-balance/features/onboard/impl/src/main/kotlin/com/fitness/onboard/onboard/goal/view/Goals.kt | 1131243169 |
package com.fitness.onboard
import com.fitness.navigation.AggregateFeatureEntry
abstract class OnboardEntry : AggregateFeatureEntry {
override val featureRoute: String get() = "onboard"
} | body-balance/features/onboard/api/src/main/kotlin/com/fitness/onboard/OnboardEntry.kt | 3608909838 |
package com.fitness.search.di
import com.fitness.navigation.FeatureEntry
import com.fitness.navigation.FeatureEntryKey
import com.fitness.search.RecipeSearchEntry
import com.fitness.search.navigation.RecipeSearchEntryImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import dagger.multibindings.IntoMap
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
interface RecipeSearchEntryModule {
@Binds
@Singleton
@IntoMap
@FeatureEntryKey(RecipeSearchEntry::class)
fun recipeSearchEntry(entry: RecipeSearchEntryImpl): FeatureEntry
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/di/RecipeSearchEntryModule.kt | 1744242163 |
package com.fitness.search.di
import com.fitness.search.RecipeSearchStateHolder
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class RecipeSearchModule {
@Provides
@Singleton
fun recipeSearchStateHolder(): RecipeSearchStateHolder = RecipeSearchStateHolder
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/di/RecipeSearchModule.kt | 1463690612 |
package com.fitness.search
import com.fitness.domain.model.nutrition.Recipe
import enums.EMealType
object RecipeSearchStateHolder {
private var state: SearchRecipeState = SearchRecipeState()
fun state() = state
fun updateState(newState: SearchRecipeState) {
state = newState
}
fun clearState() {
state = SearchRecipeState()
}
}
data class SearchRecipeState(
val recipesSearchResults: List<Recipe> = emptyList(),
val recipe: Recipe = Recipe(),
val date: Long = 0L,
val hour: Int = 0,
val minute: Int = 0,
val type: EMealType = EMealType.BREAKFAST,
)
enum class SearchRecipeStep {
PENDING,
COMPLETE
}
| body-balance/features/search/impl/src/main/kotlin/com/fitness/search/util/StateHolder.kt | 3173088191 |
package com.fitness.search.navigation
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavGraphBuilder
import androidx.navigation.NavHostController
import androidx.navigation.compose.composable
import androidx.navigation.navigation
import com.fitness.navigation.Destinations
import com.fitness.search.RecipeSearchEntry
import com.fitness.search.screens.confirmation.SaveAndConfirm
import com.fitness.search.screens.confirmation.SaveConfirmViewModel
import com.fitness.search.screens.recipe.NutritionSearch
import com.fitness.search.screens.date.PickDate
import com.fitness.search.screens.date.PickDateViewModel
import com.fitness.search.screens.time.PickTime
import com.fitness.search.screens.recipe.RecipeSearchViewModel
import com.fitness.search.screens.time.PickTimeViewModel
import extensions.cast
import javax.inject.Inject
class RecipeSearchEntryImpl @Inject constructor() : RecipeSearchEntry {
override val featureRoute: String get() = "recipe-search"
private companion object{
private const val RECIPE: String = "search"
private const val DATE: String = "pick-date"
private const val TIME: String = "pick-time"
private const val CONFIRMATION: String = "confirmation"
}
override fun NavGraphBuilder.navigation(
navController: NavHostController,
destinations: Destinations
) {
navigation(startDestination = RECIPE, route = featureRoute) {
composable(RECIPE) {
val viewModel: RecipeSearchViewModel = hiltViewModel()
NutritionSearch(
state = viewModel.uiState.cast(),
onPopBack = { navController.popBackStack() },
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onPickDate = { navController.navigate(DATE) }
)
}
composable(DATE) {
val viewModel: PickDateViewModel = hiltViewModel()
PickDate(
state = viewModel.uiState.cast(),
onPopBack = { navController.popBackStack() },
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onPickTime = { navController.navigate(TIME) }
)
}
composable(TIME) {
val viewModel: PickTimeViewModel = hiltViewModel()
PickTime(
state = viewModel.uiState.cast(),
onPopBack = { navController.popBackStack() },
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onConfirmation = { navController.navigate(CONFIRMATION) }
)
}
composable(CONFIRMATION) {
val viewModel: SaveConfirmViewModel = hiltViewModel()
SaveAndConfirm(
state = viewModel.uiState.cast(),
onTriggerEvent = { viewModel.onTriggerEvent(it) },
onPopBack = { navController.popBackStack() },
onComplete = {
navController.navigate(RECIPE) {
popUpTo(featureRoute) { inclusive = true }
}
},
)
}
}
}
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/navigation/RecipeSearchEntryImpl.kt | 1348015333 |
package com.fitness.search.screens.recipe
import com.fitness.domain.model.user.UserBasicNutritionInfo
import com.fitness.domain.usecase.search.EdamamAutoCompleteUseCase
import com.fitness.domain.usecase.search.EdamamRecipeSearchUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.domain.usecase.user.GetUserBasicNutritionInfoUseCase
import com.fitness.search.SearchRecipeStep
import com.fitness.search.RecipeSearchStateHolder
import dagger.hilt.android.lifecycle.HiltViewModel
import state.BaseViewState
import util.RecipeFetchUseCase
import util.RecipeSearchUseCase
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class RecipeSearchViewModel @Inject constructor(
private val searchStateHolder: RecipeSearchStateHolder,
private val getCurrentUserIdUseCase: GetCurrentUserIdUseCase,
private val getBasicNutritionInfoCacheInfoUseCase: GetUserBasicNutritionInfoUseCase,
private val edamamAutoCompleteUseCase: EdamamAutoCompleteUseCase,
@RecipeSearchUseCase private val edamamRecipeSearchUseCase: EdamamRecipeSearchUseCase,
@RecipeFetchUseCase private val edamamFetchRecipesUseCase: EdamamRecipeSearchUseCase,
) : IntentViewModel<BaseViewState<RecipeSearchState>, RecipeSearchEvent>() {
init { initialize() }
override fun onTriggerEvent(event: RecipeSearchEvent) {
when (event) {
is RecipeSearchEvent.AutoComplete -> onAutoComplete(event)
is RecipeSearchEvent.Search -> onRecipeSearch(event)
is RecipeSearchEvent.RecipeSelected -> onRecipeSelected(event)
}
}
private fun initialize() = safeLaunch {
execute(getCurrentUserIdUseCase(GetCurrentUserIdUseCase.Params)) {
currentUserNutritionalInfo(it)
}
}
private fun currentUserNutritionalInfo(id: String) = safeLaunch {
val params = GetUserBasicNutritionInfoUseCase.Params(id = id)
execute(getBasicNutritionInfoCacheInfoUseCase(params)) {
onFetchContentFromCache(it)
}
}
private fun onFetchContentFromCache(nutrition: UserBasicNutritionInfo) = safeLaunch {
val param = EdamamRecipeSearchUseCase.Params(search = "", cuisineType = nutrition.cuisineTypeApi)
execute(edamamFetchRecipesUseCase(param)) {
val state = searchStateHolder.state().copy(recipesSearchResults = it)
searchStateHolder.updateState(state)
setState(BaseViewState.Data(RecipeSearchState(searchResults = state.recipesSearchResults)))
}
}
private fun onAutoComplete(event: RecipeSearchEvent.AutoComplete) = safeLaunch {
val param = EdamamAutoCompleteUseCase.Params(event.search)
call(edamamAutoCompleteUseCase(param)) {
val state = searchStateHolder.state()
setState(
BaseViewState.Data(
RecipeSearchState(
autoComplete = it,
searchResults = state.recipesSearchResults
)
)
)
}
}
private fun onRecipeSearch(event: RecipeSearchEvent.Search) = safeLaunch {
searchStateHolder.updateState(
searchStateHolder.state().copy(recipesSearchResults = emptyList())
)
val param = EdamamRecipeSearchUseCase.Params(event.search)
execute(edamamRecipeSearchUseCase(param)) {
val state = searchStateHolder.state().copy(recipesSearchResults = it)
searchStateHolder.updateState(state)
setState(BaseViewState.Data(RecipeSearchState(searchResults = it)))
}
}
private fun onRecipeSelected(event: RecipeSearchEvent.RecipeSelected) = safeLaunch {
val state = searchStateHolder.state().copy(recipe = event.recipe)
searchStateHolder.updateState(state)
setState(
BaseViewState.Data(
RecipeSearchState(
autoComplete = emptyList(),
searchResults = state.recipesSearchResults,
step = SearchRecipeStep.COMPLETE,
)
)
)
}
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/recipe/RecipeSearchViewModel.kt | 2287686751 |
package com.fitness.search.screens.recipe
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.asPaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.ime
import androidx.compose.foundation.layout.isImeVisible
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Search
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextFieldDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.constraintlayout.compose.ConstraintLayout
import androidx.constraintlayout.compose.Dimension
import com.fitness.component.ItemState
import com.fitness.component.components.NutritionItemWithImage
import com.fitness.component.properties.GuidelineProperties
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.data.util.TotalNutrientsKeys.KEY_CARBOHYDRATES
import com.fitness.data.util.TotalNutrientsKeys.KEY_ENERGY
import com.fitness.data.util.TotalNutrientsKeys.KEY_NET_CARBS
import com.fitness.data.util.TotalNutrientsKeys.KEY_TOTAL_FAT
import com.fitness.resources.R
import com.fitness.search.SearchRecipeStep
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun PreviewNutritionSearch() = BodyBalanceTheme {
Surface {
NutritionSearchContent(state = RecipeSearchState(), onTriggerEvent = {})
}
}
@Composable
fun NutritionSearch(
state: StateFlow<BaseViewState<RecipeSearchState>>,
onTriggerEvent: (RecipeSearchEvent) -> Unit,
onPopBack: () -> Unit = {},
onPickDate: () -> Unit = {}
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
val currentState = uiState.cast<BaseViewState.Data<RecipeSearchState>>().value
if(currentState.step == SearchRecipeStep.PENDING){
NutritionSearchContent(state = currentState, onTriggerEvent = onTriggerEvent)
}else{
onPickDate()
}
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
@OptIn(ExperimentalLayoutApi::class, ExperimentalComposeUiApi::class)
private fun NutritionSearchContent(
state: RecipeSearchState,
onTriggerEvent: (RecipeSearchEvent) -> Unit
) {
val ime = WindowInsets.ime
val insets = ime.asPaddingValues().calculateBottomPadding()
val keyboardController = LocalSoftwareKeyboardController.current
val focusManager = LocalFocusManager.current
val isImeVisible = WindowInsets.isImeVisible
ConstraintLayout(
modifier = Modifier
.fillMaxSize()
.padding(bottom = if (isImeVisible) insets else 0.dp)
.pointerInput(Unit) {
detectTapGestures(onPress = {}) {
focusManager.clearFocus()
keyboardController?.hide()
}
}
) {
val (searchField, autoComplete) = createRefs()
var search by remember { mutableStateOf("") }
var isFocused by remember { mutableStateOf(false) }
val startGuide = createGuidelineFromStart(GuidelineProperties.START)
val endGuide = createGuidelineFromEnd(GuidelineProperties.END)
val bottomGuide = createGuidelineFromBottom(GuidelineProperties.BOTTOM)
LazyColumn(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.spacedBy(40.dp)
) {
items(state.searchResults) { recipe ->
val itemState by remember { mutableStateOf(ItemState.UNSELECTED) }
val image = recipe.standardImage
val title = recipe.name
val nutrients = recipe.nutrients
val energy = nutrients?.get(KEY_ENERGY)
val fat = nutrients?.get(KEY_TOTAL_FAT)
val net = nutrients?.get(KEY_NET_CARBS) ?: nutrients?.get(KEY_CARBOHYDRATES)
if (image != null && title != null) {
NutritionItemWithImage(
title = title,
imageModel = image,
itemState = itemState,
energy = energy?.quantity,
fat = fat?.quantity,
net = net?.quantity,
onClickAdd = {
onTriggerEvent(RecipeSearchEvent.RecipeSelected(recipe))
}
)
}
}
item { Spacer(modifier = Modifier.size(125.dp)) }
}
if (isFocused && search.isNotEmpty() && state.autoComplete.isNotEmpty()) {
LazyColumn(
modifier = Modifier
.wrapContentHeight()
.background(
color = MaterialTheme.colorScheme.surfaceVariant,
RoundedCornerShape(40.dp)
)
.padding(start = 15.dp, end = 15.dp, top = 15.dp, bottom = 65.dp)
.constrainAs(autoComplete) {
end.linkTo(endGuide)
start.linkTo(startGuide)
bottom.linkTo(searchField.bottom)
width = Dimension.fillToConstraints
}
) {
items(state.autoComplete) { suggestion ->
Text(
text = suggestion,
modifier = Modifier
.padding(2.dp)
.clickable {
search = suggestion
focusManager.clearFocus()
onTriggerEvent(RecipeSearchEvent.Search(search = search))
}
)
}
}
}
OutlinedTextField(
value = search,
onValueChange = { search = it },
singleLine = true,
trailingIcon = {
Icon(
imageVector = Icons.Default.Search,
contentDescription = stringResource(id = R.string.content_description_search),
modifier = Modifier.clickable {
onTriggerEvent(
RecipeSearchEvent.Search(
search = search
)
)
}
)
},
shape = RoundedCornerShape(40.dp),
colors = TextFieldDefaults
.colors(
focusedContainerColor = MaterialTheme.colorScheme.surfaceVariant,
unfocusedContainerColor = MaterialTheme.colorScheme.surfaceVariant,
),
modifier = Modifier
.shadow(5.dp, RoundedCornerShape(40.dp))
.onFocusChanged { isFocused = it.isFocused }
.constrainAs(searchField) {
end.linkTo(endGuide)
start.linkTo(startGuide)
bottom.linkTo(bottomGuide)
width = Dimension.fillToConstraints
}
)
LaunchedEffect(key1 = search) {
if (search.isNotEmpty()) {
onTriggerEvent(RecipeSearchEvent.AutoComplete(search))
}
}
}
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/recipe/RecipeSearch.kt | 1863624377 |
package com.fitness.search.screens.recipe
import com.fitness.domain.model.nutrition.Recipe
import com.fitness.search.SearchRecipeStep
data class RecipeSearchState(
val autoComplete: List<String> = emptyList(),
val searchResults: List<Recipe> = emptyList(),
val step: SearchRecipeStep = SearchRecipeStep.PENDING,
)
sealed class RecipeSearchEvent{
data class AutoComplete(val search: String): RecipeSearchEvent()
data class Search(val search: String): RecipeSearchEvent()
data class RecipeSelected(val recipe: Recipe): RecipeSearchEvent()
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/recipe/RecipeContract.kt | 1375159260 |
package com.fitness.search.screens.date
import com.fitness.search.SearchRecipeStep
data class PickDateState(val step: SearchRecipeStep = SearchRecipeStep.PENDING)
sealed class PickDateEvent{
data class DateSelected(val date: Long): PickDateEvent()
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/date/PickDateContract.kt | 3901835786 |
package com.fitness.search.screens.date
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import com.fitness.component.screens.BalanceDatePicker
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.resources.R
import com.fitness.search.SearchRecipeStep
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun PreviewPickDate() = BodyBalanceTheme {
Surface {
PickDateContent(onTriggerEvent = {})
}
}
@Composable
fun PickDate(
state: StateFlow<BaseViewState<PickDateState>>,
onTriggerEvent: (PickDateEvent) -> Unit,
onPopBack: () -> Unit = {},
onPickTime: () -> Unit = {}
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
val currentState = uiState.cast<BaseViewState.Data<PickDateState>>().value
if(currentState.step == SearchRecipeStep.PENDING){
PickDateContent(onTriggerEvent)
}else{
onPickTime()
}
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
private fun PickDateContent(onTriggerEvent: (PickDateEvent) -> Unit) {
BalanceDatePicker(onDatesPicked = { onTriggerEvent(PickDateEvent.DateSelected(it)) })
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/date/PickDate.kt | 3153370904 |
package com.fitness.search.screens.date
import com.fitness.search.SearchRecipeStep
import com.fitness.search.RecipeSearchStateHolder
import dagger.hilt.android.lifecycle.HiltViewModel
import failure.GenericFailure
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class PickDateViewModel @Inject constructor(private val searchStateHolder: RecipeSearchStateHolder, ) : IntentViewModel<BaseViewState<PickDateState>, PickDateEvent>() {
init { initialize() }
override fun onTriggerEvent(event: PickDateEvent) {
if(event is PickDateEvent.DateSelected){
onDateSelected(event)
}else{
handleError(GenericFailure())
}
}
private fun initialize() = setState(BaseViewState.Data(PickDateState()))
private fun onDateSelected(event: PickDateEvent.DateSelected) = safeLaunch {
val state = searchStateHolder.state().copy(date = event.date)
searchStateHolder.updateState(state)
setState(
BaseViewState.Data(
PickDateState(step = SearchRecipeStep.COMPLETE)
)
)
}
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/date/PickDateViewModel.kt | 2032661336 |
package com.fitness.search.screens.confirmation
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.res.stringResource
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.resources.R
import com.fitness.search.SearchRecipeStep
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
import util.convertLongToDate
import util.formatTimeWithAmPm
@Light
@Dark
@Composable
private fun PreviewConfirmation() = BodyBalanceTheme {
Surface {
ConfirmationContent(state = SaveAndConfirmState(), onComplete = {})
}
}
@Composable
fun SaveAndConfirm(
state: StateFlow<BaseViewState<SaveAndConfirmState>>,
onTriggerEvent: (SaveAndConfirmEvent) -> Unit,
onComplete: () -> Unit = {},
onPopBack: () -> Unit = {},
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
val currentState = uiState.cast<BaseViewState.Data<SaveAndConfirmState>>().value
if(currentState.step == SearchRecipeStep.PENDING){
onTriggerEvent(SaveAndConfirmEvent.Save)
}else{
ConfirmationContent(uiState.cast<BaseViewState.Data<SaveAndConfirmState>>().value, onComplete)
}
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
private fun ConfirmationContent(
state: SaveAndConfirmState,
onComplete: () -> Unit
) {
MessageScreen(
message = stringResource(
id = R.string.meal_success_message, convertLongToDate(state.date),
formatTimeWithAmPm(state.hour, state.minute)
),
onClick = onComplete
)
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/confirmation/SaveAndConfirmation.kt | 113247084 |
package com.fitness.search.screens.confirmation
import com.fitness.search.SearchRecipeStep
data class SaveAndConfirmState(
val date: Long = 0,
val hour: Int = 0,
val minute: Int = 0,
val step: SearchRecipeStep = SearchRecipeStep.PENDING,
)
sealed class SaveAndConfirmEvent {
object Save : SaveAndConfirmEvent()
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/confirmation/SaveAndConfirmContract.kt | 780592532 |
package com.fitness.search.screens.confirmation
import com.fitness.domain.usecase.nutrition.CreateNutritionRecordUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.search.SearchRecipeStep
import com.fitness.search.RecipeSearchStateHolder
import dagger.hilt.android.lifecycle.HiltViewModel
import failure.GenericFailure
import state.BaseViewState
import viewmodel.IntentViewModel
import javax.inject.Inject
@HiltViewModel
class SaveConfirmViewModel @Inject constructor(
private val searchStateHolder: RecipeSearchStateHolder,
private val getCurrentUserIdUseCase: GetCurrentUserIdUseCase,
private val createNutritionRecordUseCase: CreateNutritionRecordUseCase,
) : IntentViewModel<BaseViewState<SaveAndConfirmState>, SaveAndConfirmEvent>() {
init {
initialize()
}
override fun onTriggerEvent(event: SaveAndConfirmEvent) {
if(event is SaveAndConfirmEvent.Save){
onSaveMeal()
}else {
handleError(GenericFailure())
}
}
override fun handleError(exception: Throwable) {
super.handleError(exception)
exception.printStackTrace()
}
private fun initialize() = setState(BaseViewState.Data(SaveAndConfirmState(step = SearchRecipeStep.PENDING)))
private fun onSaveMeal() = safeLaunch {
execute(getCurrentUserIdUseCase(GetCurrentUserIdUseCase.Params)) {
saveMealRecord(it)
}
}
private fun saveMealRecord(userId: String) = safeLaunch {
val state = searchStateHolder.state()
val params = CreateNutritionRecordUseCase.Params(
userId = userId,
recipe = state.recipe,
date = state.date,
hour = state.hour,
minute = state.minute,
mealType = state.type
)
execute(createNutritionRecordUseCase(params)) {
setState(
BaseViewState.Data(
SaveAndConfirmState(
step = SearchRecipeStep.COMPLETE,
date = state.date,
hour = state.hour,
minute = state.minute
)
)
)
}
}
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/confirmation/SaveConfirmViewModel.kt | 872751088 |
package com.fitness.search.screens.time
import com.fitness.search.SearchRecipeStep
import com.fitness.search.screens.date.PickDateEvent
data class PickTimeState(val step: SearchRecipeStep = SearchRecipeStep.PENDING, )
sealed class PickTimeEvent{
data class TimeSelected(val hour: Int, val minute: Int): PickTimeEvent()
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/time/PickTimeContract.kt | 1875187685 |
package com.fitness.search.screens.time
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import com.fitness.component.screens.BalanceTimePicker
import com.fitness.component.screens.ErrorScreen
import com.fitness.component.screens.LoadingScreen
import com.fitness.component.screens.MessageScreen
import com.fitness.resources.R
import com.fitness.search.SearchRecipeStep
import com.fitness.theme.ui.BodyBalanceTheme
import extensions.Dark
import extensions.Light
import extensions.cast
import failure.Failure
import kotlinx.coroutines.flow.StateFlow
import state.BaseViewState
@Light
@Dark
@Composable
private fun PreviewPickTime() = BodyBalanceTheme {
Surface {
PickTimeContent(onTriggerEvent = {})
}
}
@Composable
fun PickTime(
state: StateFlow<BaseViewState<PickTimeState>>,
onTriggerEvent: (PickTimeEvent) -> Unit,
onPopBack: () -> Unit = {},
onConfirmation: () -> Unit = {}
) {
val uiState by state.collectAsState()
when (uiState) {
is BaseViewState.Data -> {
val currentState = uiState.cast<BaseViewState.Data<PickTimeState>>().value
if(currentState.step == SearchRecipeStep.PENDING){
PickTimeContent(onTriggerEvent)
}else{
onConfirmation()
}
}
is BaseViewState.Error -> {
val failure = uiState.cast<BaseViewState.Error>().failure as Failure
ErrorScreen(title = failure.title, description = failure.description) {
onPopBack()
}
}
is BaseViewState.Loading -> {
LoadingScreen()
}
else -> {
MessageScreen(message = R.string.unknown, onClick = onPopBack)
}
}
}
@Composable
private fun PickTimeContent(onTriggerEvent: (PickTimeEvent) -> Unit) {
BalanceTimePicker(
onTimePicked = {hour, minute ->
onTriggerEvent(PickTimeEvent.TimeSelected(hour = hour, minute = minute))
}
)
} | body-balance/features/search/impl/src/main/kotlin/com/fitness/search/screens/time/PickTime.kt | 51336351 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.