content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.hanbikan.nook.core.designsystem.component
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import com.hanbikan.nook.core.designsystem.theme.NkTheme
@Composable
fun NkBackground(
modifier: Modifier = Modifier,
content: @Composable () -> Unit,
) {
Surface(
color = NkTheme.colorScheme.background,
modifier = modifier.fillMaxSize()
) {
content()
}
} | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/component/Background.kt | 2719294729 |
package com.hanbikan.nook.core.designsystem.component
import androidx.compose.foundation.text.InlineTextContent
import androidx.compose.material3.LocalTextStyle
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.TextLayoutResult
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextDecoration
import androidx.compose.ui.text.style.TextOverflow
import com.hanbikan.nook.core.designsystem.theme.Fonts
import com.hanbikan.nook.core.designsystem.theme.NkTheme
@Composable
fun NkText(
text: String,
modifier: Modifier = Modifier,
color: Color = NkTheme.colorScheme.primary,
fontWeight: FontWeight? = null,
fontFamily: FontFamily? = Fonts.joa,
textDecoration: TextDecoration? = null,
textAlign: TextAlign? = null,
overflow: TextOverflow = TextOverflow.Ellipsis,
maxLines: Int = Int.MAX_VALUE,
onTextLayout: (TextLayoutResult) -> Unit = {},
style: TextStyle = LocalTextStyle.current
) {
Text(
text = text,
modifier = modifier,
color = color,
fontWeight = fontWeight,
fontFamily = fontFamily,
textDecoration = textDecoration,
textAlign = textAlign,
overflow = overflow,
maxLines = maxLines,
onTextLayout = onTextLayout,
style = style
)
}
@Composable
fun NkText(
text: AnnotatedString,
modifier: Modifier = Modifier,
color: Color = NkTheme.colorScheme.primary,
fontWeight: FontWeight? = null,
fontFamily: FontFamily? = Fonts.joa,
textDecoration: TextDecoration? = null,
textAlign: TextAlign? = null,
overflow: TextOverflow = TextOverflow.Ellipsis,
maxLines: Int = Int.MAX_VALUE,
inlineContent: Map<String, InlineTextContent> = mapOf(),
onTextLayout: (TextLayoutResult) -> Unit = {},
style: TextStyle = LocalTextStyle.current
) {
Text(
text = text,
modifier = modifier,
color = color,
fontWeight = fontWeight,
fontFamily = fontFamily,
textDecoration = textDecoration,
textAlign = textAlign,
overflow = overflow,
maxLines = maxLines,
inlineContent = inlineContent,
onTextLayout = onTextLayout,
style = style,
)
} | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/component/NkText.kt | 2307720227 |
package com.hanbikan.nook.core.designsystem.component
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.ProgressIndicatorDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
@Composable
fun AnimatedLinearProgressIndicator(
progress: Float,
modifier: Modifier = Modifier,
color: Color = ProgressIndicatorDefaults.linearColor,
trackColor: Color = ProgressIndicatorDefaults.linearTrackColor
) {
val animateFloat by animateFloatAsState(
targetValue = progress,
label = "AnimatedLinearProgressIndicator",
)
LinearProgressIndicator(
progress = { animateFloat },
modifier = modifier,
color = color,
trackColor = trackColor,
)
} | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/component/AnimatedLinearProgressIndicator.kt | 878645284 |
package com.hanbikan.nook.core.designsystem.component
import androidx.compose.foundation.clickable
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.layout.size
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Info
import androidx.compose.material.ripple.rememberRipple
import androidx.compose.material3.Icon
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.Dp
import com.hanbikan.nook.core.designsystem.theme.Dimens
import com.hanbikan.nook.core.designsystem.theme.NkTheme
@Composable
fun NkSmallButton(
onClick: () -> Unit,
modifier: Modifier = Modifier,
imageVector: ImageVector,
size: Dp = Dimens.IconExtraSmall,
tint: Color = NkTheme.colorScheme.primaryContainer,
) {
Icon(
modifier = modifier
.size(size)
.clickable(
onClick = onClick,
interactionSource = remember { MutableInteractionSource() },
indication = rememberRipple(
bounded = false,
radius = size,
color = NkTheme.colorScheme.primary,
),
),
imageVector = imageVector,
contentDescription = null,
tint = tint
)
}
@Composable
@Preview
fun NkSmallButtonPreview() {
NkSmallButton(
onClick = {},
imageVector = Icons.Default.Info,
)
} | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/component/NkSmallButton.kt | 2955583615 |
package com.hanbikan.nook.core.designsystem.theme
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
object Dimens {
val SpacingExtraSmall: Dp = 4.dp
val SpacingSmall: Dp = 8.dp
val SpacingMedium: Dp = 16.dp
val SpacingLarge: Dp = 24.dp
val SpacingExtraLarge: Dp = 32.dp
val SideMargin: Dp = SpacingLarge
val IconExtraSmall: Dp = 16.dp
val IconSmall: Dp = 24.dp
val IconMedium: Dp = 80.dp
val IconLarge: Dp = 160.dp
val IconExtraLarge: Dp = 240.dp
} | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/theme/Dimens.kt | 1021765624 |
package com.hanbikan.nook.core.designsystem.theme
import androidx.compose.ui.text.font.Font
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontStyle
import androidx.compose.ui.text.font.FontWeight
import com.hanbikan.nook.core.designsystem.R
object Fonts {
val joa = FontFamily(
Font(R.font.jua_regular, FontWeight.Medium, FontStyle.Normal),
Font(R.font.jua_regular, FontWeight.Normal, FontStyle.Normal),
)
} | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/theme/Fonts.kt | 3751593555 |
package com.hanbikan.nook.core.designsystem.theme
import androidx.compose.ui.graphics.Color
val Brown = Color(0xFF786951)
val LightBrown = Color(0xFFAD9C82)
val CrimeWhite = Color(0xFFFFF9E5)
val DarkBlue = Color(0xFF017C74)
val Blue = Color(0xFF5BC5BB)
val LightBlue = Color(0xFF8ECFCA)
val DarkYellowGreen = Color(0xFF68B893)
val YellowGreen = Color(0xFF88C9A1)
val LightYellowGreen = Color(0xFFA4D4A2)
val DarkYellow = Color(0xFFF5C24C)
val Yellow = Color(0xFFFCEA64)
val LightYellow = Color(0xFFF8EEBC)
val LightGreen = Color(0xFFDFEDD4)
val Green = Color(0xFF5EBB5D) | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/theme/Color.kt | 562617413 |
package com.hanbikan.nook.core.designsystem.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.ColorScheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Shapes
import androidx.compose.material3.Typography
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.Color
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 = CrimeWhite,
primaryContainer = CrimeWhite,
secondary = LightGreen,
secondaryContainer = Green,
tertiary = Blue,
tertiaryContainer = Color.White,
background = Color.Black,
onBackground = Brown,
)
private val LightColorScheme = lightColorScheme(
primary = Brown,
primaryContainer = LightBrown,
secondary = Green,
secondaryContainer = LightGreen,
tertiary = Blue,
tertiaryContainer = Color.White,
background = CrimeWhite,
onBackground = Color.White,
)
@Composable
fun NkTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
dynamicColor: Boolean = false,
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.background.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = !darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
}
object NkTheme {
val colorScheme: ColorScheme
@Composable
get() = MaterialTheme.colorScheme
val typography: Typography
@Composable
get() = MaterialTheme.typography
val shapes: Shapes
@Composable
get() = MaterialTheme.shapes
} | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/theme/Theme.kt | 2763265674 |
package com.hanbikan.nook.core.designsystem.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
)
*/
) | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/theme/Type.kt | 4268260787 |
package com.hanbikan.nook.core.designsystem
class NkConst {
companion object {
const val AlphaEnabled = 1.0f
const val AlphaDisabled = 0.5f
}
} | Nook/core/designsystem/src/main/java/com/hanbikan/nook/core/designsystem/NkConst.kt | 2712582184 |
package com.hanbikan.nook.core.testing
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.hanbikan.nook.core.testing.test", appContext.packageName)
}
} | Nook/core/testing/src/androidTest/java/com/hanbikan/nook/core/testing/ExampleInstrumentedTest.kt | 3526996440 |
package com.hanbikan.nook.core.testing
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)
}
} | Nook/core/testing/src/test/java/com/hanbikan/nook/core/testing/ExampleUnitTest.kt | 2136561549 |
package com.hanbikan.nook.core.datastore
import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.intPreferencesKey
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import javax.inject.Inject
val Context.dataStore: DataStore<Preferences> by preferencesDataStore("preferences")
class NkDataStore @Inject constructor(
private val context: Context,
) {
val activeUserIdFlow: Flow<Int?> = context.dataStore.data.map { it[ACTIVE_USER_ID] }
val lastVisitedRouteFlow: Flow<String?> = context.dataStore.data.map { it[LAST_VISITED_ROUTE] }
suspend fun setActiveUserId(id: Int) {
context.dataStore.edit {
it[ACTIVE_USER_ID] = id
}
}
suspend fun setLastVisitedRoute(route: String) {
context.dataStore.edit {
it[LAST_VISITED_ROUTE] = route
}
}
companion object {
val ACTIVE_USER_ID = intPreferencesKey("active_user_id")
val LAST_VISITED_ROUTE = stringPreferencesKey("last_visited_route")
}
} | Nook/core/datastore/src/main/java/com/hanbikan/nook/core/datastore/NkDataStore.kt | 1112802372 |
package com.hanbikan.nook.core.datastore.repository
import com.hanbikan.nook.core.datastore.NkDataStore
import com.hanbikan.nook.core.domain.repository.AppStateRepository
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
class AppStateRepositoryImpl @Inject constructor(
private val nkDataStore: NkDataStore
) : AppStateRepository {
override fun getActiveUserId(): Flow<Int?> {
return nkDataStore.activeUserIdFlow
}
override fun getLastVisitedRoute(): Flow<String?> {
return nkDataStore.lastVisitedRouteFlow
}
override suspend fun setActiveUserId(id: Int) {
nkDataStore.setActiveUserId(id)
}
override suspend fun setLastVisitedRoute(route: String) {
nkDataStore.setLastVisitedRoute(route)
}
} | Nook/core/datastore/src/main/java/com/hanbikan/nook/core/datastore/repository/AppStateRepositoryImpl.kt | 3634760612 |
package com.hanbikan.nook.core.datastore.di
import com.hanbikan.nook.core.datastore.repository.AppStateRepositoryImpl
import com.hanbikan.nook.core.domain.repository.AppStateRepository
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module
@InstallIn(SingletonComponent::class)
interface DataStoreRepositoryModule {
@Binds
fun bindsAppStateRepository(
appStateRepositoryImpl: AppStateRepositoryImpl,
): AppStateRepository
} | Nook/core/datastore/src/main/java/com/hanbikan/nook/core/datastore/di/DataStoreRepositoryModule.kt | 369970 |
package com.hanbikan.nook.core.datastore.di
import android.content.Context
import com.hanbikan.nook.core.datastore.NkDataStore
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object DataStoreModule {
@Provides
@Singleton
fun providesNkDataStore(
@ApplicationContext context: Context
) : NkDataStore = NkDataStore(context)
} | Nook/core/datastore/src/main/java/com/hanbikan/nook/core/datastore/di/DataStoreModule.kt | 846943132 |
package com.hanbikan.nook.core.common
inline fun <T1, T2> executeIfBothNonNull(a: T1?, b: T2?, block: (T1, T2) -> Any) {
if (a != null && b != null) {
block(a, b)
}
} | Nook/core/common/src/main/java/com/hanbikan/nook/core/common/Standard.kt | 1059816758 |
package com.nook.core.domain_test.repository
import com.hanbikan.nook.core.domain.model.Task
import com.hanbikan.nook.core.domain.repository.TaskRepository
import com.nook.core.domain_test.data.tasksTestData
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flowOf
val testTaskRepository = TestTaskRepository()
class TestTaskRepository : TaskRepository {
override fun getAllTasksByUserId(userId: Int): Flow<List<Task>> {
val tasks = tasksTestData.filter { it.userId == userId }
return flowOf(tasks)
}
override suspend fun insertTasks(taskList: List<Task>) {
tasksTestData = tasksTestData + taskList
}
override suspend fun updateTask(task: Task) {
val indexToUpdate = tasksTestData.indexOfFirst { it.id == task.id }
if (indexToUpdate == -1) return
val newTasks = tasksTestData.toMutableList().apply {
this[indexToUpdate] = task
}
tasksTestData = newTasks
}
override suspend fun deleteTaskById(id: Int) {
val newTasks = tasksTestData.filter { it.id != id }
tasksTestData = newTasks
}
override suspend fun resetAllDailyTasks() {
tasksTestData = listOf()
}
} | Nook/core/domain-test/src/main/java/com/nook/core/domain_test/repository/TestTaskRepository.kt | 1117204280 |
package com.nook.core.domain_test.repository
import com.hanbikan.nook.core.domain.model.TutorialTask
import com.hanbikan.nook.core.domain.repository.TutorialTaskRepository
import com.nook.core.domain_test.data.tutorialTasksTestData
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flowOf
val testTutorialTaskRepository = TestTutorialTaskRepository()
class TestTutorialTaskRepository : TutorialTaskRepository {
override fun getTutorialTasksByUserId(userId: Int): Flow<List<TutorialTask>> {
return flowOf(tutorialTasksTestData)
}
override fun getTutorialTasksByUserIdAndDay(userId: Int, day: Int): Flow<List<TutorialTask>> {
val tutorialTasks = tutorialTasksTestData.filter {
it.userId == userId && it.day == day
}
return flowOf(tutorialTasks)
}
override suspend fun insertTutorialTasks(tutorialTaskList: List<TutorialTask>) {
tutorialTasksTestData = tutorialTasksTestData + tutorialTaskList
}
override suspend fun updateTutorialTask(tutorialTask: TutorialTask) {
val indexToUpdate = tutorialTasksTestData.indexOfFirst { it.id == tutorialTask.id }
if (indexToUpdate == -1) return
val newTutorialTasks = tutorialTasksTestData.toMutableList().apply {
this[indexToUpdate] = tutorialTask
}
tutorialTasksTestData = newTutorialTasks.toList()
}
override suspend fun resetTutorialTasks() {
tutorialTasksTestData = listOf()
}
} | Nook/core/domain-test/src/main/java/com/nook/core/domain_test/repository/TestTutorialTaskRepository.kt | 2976089309 |
package com.nook.core.domain_test.repository
import com.hanbikan.nook.core.domain.repository.AppStateRepository
import com.nook.core.domain_test.data.activeUserIdTestData
import com.nook.core.domain_test.data.lastVisitedRouteTestData
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flowOf
val testAppStateRepository = TestAppStateRepository()
class TestAppStateRepository : AppStateRepository {
override fun getActiveUserId(): Flow<Int?> {
return flowOf(activeUserIdTestData)
}
override fun getLastVisitedRoute(): Flow<String?> {
return flowOf(lastVisitedRouteTestData)
}
override suspend fun setActiveUserId(id: Int) {
activeUserIdTestData = id
}
override suspend fun setLastVisitedRoute(route: String) {
lastVisitedRouteTestData = route
}
} | Nook/core/domain-test/src/main/java/com/nook/core/domain_test/repository/TestAppStateRepository.kt | 2836152782 |
package com.nook.core.domain_test.repository
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.repository.UserRepository
import com.nook.core.domain_test.data.userTestData
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flowOf
val testUserRepository = TestUserRepository()
class TestUserRepository : UserRepository {
override fun getAllUsers(): Flow<List<User>> {
return flowOf(userTestData)
}
override fun getUserById(id: Int): Flow<User?> {
val user = userTestData.find { it.id == id }
return flowOf(user)
}
override suspend fun insertUser(user: User): Int {
val addedUserId = if (userTestData.isNotEmpty()) {
userTestData.last().id + 1
} else {
0
}
val newUserTestData = userTestData.toMutableList().apply {
add(user.copy(id = addedUserId))
}
userTestData = newUserTestData
return addedUserId
}
override suspend fun deleteUserById(id: Int) {
userTestData = userTestData.filter { it.id != id }
}
} | Nook/core/domain-test/src/main/java/com/nook/core/domain_test/repository/TestUserRepository.kt | 4285124771 |
package com.nook.core.domain_test.data
import com.hanbikan.nook.core.domain.model.User
var userTestData: List<User> = listOf(
User(
id = 0,
name = "user0",
islandName = "island0",
tutorialDay = 0,
),
User(
id = 1,
name = "user1",
islandName = "island1",
tutorialDay = 1,
),
User(
id = 2,
name = "user2",
islandName = "island2",
tutorialDay = 2,
),
User(
id = 3,
name = "user3",
islandName = "island3",
tutorialDay = 3,
),
) | Nook/core/domain-test/src/main/java/com/nook/core/domain_test/data/UserTestData.kt | 4213343430 |
package com.nook.core.domain_test.data
import com.hanbikan.nook.core.domain.model.Task
var tasksTestData: List<Task> = listOf() | Nook/core/domain-test/src/main/java/com/nook/core/domain_test/data/TaskTestData.kt | 2284412457 |
package com.nook.core.domain_test.data
var activeUserIdTestData: Int = userTestData[0].id
var lastVisitedRouteTestData: String = "testRoute" | Nook/core/domain-test/src/main/java/com/nook/core/domain_test/data/AppStateTestData.kt | 2171261882 |
package com.nook.core.domain_test.data
import com.hanbikan.nook.core.domain.model.TutorialTask
var tutorialTasksTestData: List<TutorialTask> = listOf(
TutorialTask(id = 0, userId = 0, day = 0, name = "", isDone = false, details = listOf()),
TutorialTask(id = 1, userId = 0, day = 1, name = "", isDone = false, details = listOf()),
TutorialTask(id = 2, userId = 0, day = 2, name = "", isDone = false, details = listOf()),
TutorialTask(id = 3, userId = 0, day = 3, name = "", isDone = false, details = listOf()),
) | Nook/core/domain-test/src/main/java/com/nook/core/domain_test/data/TutorialTaskTestData.kt | 3380834477 |
package com.hanbikan.nook.core.domain
import com.hanbikan.nook.core.domain.usecase.GetTutorialDayRangeUseCase
import com.nook.core.domain_test.repository.testTutorialTaskRepository
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.test.runTest
import org.junit.Assert.assertEquals
import org.junit.Test
class GetTutorialDayRangeUseCaseTest {
private val useCase = GetTutorialDayRangeUseCase(
tutorialTaskRepository = testTutorialTaskRepository
)
@Test
fun getTutorialDayRange_returnsMinMaxDayRangeForUser() = runTest {
val testUserId = 0
val result = useCase(testUserId).first()
val tutorialTasks = testTutorialTaskRepository.getTutorialTasksByUserId(testUserId).first()
.filter { it.userId == testUserId }
val minDay = tutorialTasks.minOf { it.day }
val maxDay = tutorialTasks.maxOf { it.day }
assertEquals(result, minDay.rangeTo(maxDay))
}
} | Nook/core/domain/src/test/java/com/hanbikan/nook/core/domain/GetTutorialDayRangeUseCaseTest.kt | 1193070578 |
package com.hanbikan.nook.core.domain.repository
import com.hanbikan.nook.core.domain.model.TutorialTask
import kotlinx.coroutines.flow.Flow
interface TutorialTaskRepository {
fun getTutorialTasksByUserId(userId: Int): Flow<List<TutorialTask>>
fun getTutorialTasksByUserIdAndDay(userId: Int, day: Int): Flow<List<TutorialTask>>
suspend fun insertTutorialTasks(tutorialTaskList: List<TutorialTask>)
suspend fun updateTutorialTask(tutorialTask: TutorialTask)
suspend fun resetTutorialTasks()
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/repository/TutorialTaskRepository.kt | 3811709779 |
package com.hanbikan.nook.core.domain.repository
import com.hanbikan.nook.core.domain.model.User
import kotlinx.coroutines.flow.Flow
interface UserRepository {
fun getAllUsers(): Flow<List<User>>
fun getUserById(id: Int): Flow<User?>
suspend fun insertUser(user: User): Int
suspend fun deleteUserById(id: Int)
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/repository/UserRepository.kt | 368823596 |
package com.hanbikan.nook.core.domain.repository
import kotlinx.coroutines.flow.Flow
interface AppStateRepository {
fun getActiveUserId(): Flow<Int?>
fun getLastVisitedRoute(): Flow<String?>
suspend fun setActiveUserId(id: Int)
suspend fun setLastVisitedRoute(route: String)
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/repository/AppStateRepository.kt | 1551271670 |
package com.hanbikan.nook.core.domain.repository
import com.hanbikan.nook.core.domain.model.Task
import kotlinx.coroutines.flow.Flow
interface TaskRepository {
fun getAllTasksByUserId(userId: Int): Flow<List<Task>>
suspend fun insertTasks(taskList: List<Task>)
suspend fun updateTask(task: Task)
suspend fun deleteTaskById(id: Int)
suspend fun resetAllDailyTasks()
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/repository/TaskRepository.kt | 4286598810 |
package com.hanbikan.nook.core.domain.model
import kotlinx.serialization.Serializable
@Serializable
data class Detail(
val description: String,
val imageId: Int? = null
) | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/model/Detail.kt | 2221479820 |
package com.hanbikan.nook.core.domain.model
data class TutorialTask(
val id: Int = 0,
val userId: Int,
val day: Int,
override val name: String,
override val isDone: Boolean,
override val details: List<Detail>? = null,
) : Completable, HasDetail {
companion object // For companion extension functions outside
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/model/TutorialTask.kt | 2820134301 |
package com.hanbikan.nook.core.domain.model
interface Completable {
val isDone: Boolean
val name: String
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/model/Completable.kt | 4142886175 |
package com.hanbikan.nook.core.domain.model
data class User(
val id: Int = 0,
val name: String,
val islandName: String,
val tutorialDay: Int = 0,
) {
companion object {
val DEFAULT = User(id = 0, name = "", islandName = "", tutorialDay = 0)
const val NAME_MAX_LENGTH = 10
const val ISLAND_NAME_MAX_LENGTH = 10
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/model/User.kt | 1341433366 |
package com.hanbikan.nook.core.domain.model
data class Task(
val id: Int = 0,
val userId: Int,
val isDaily: Boolean,
val isVisible: Boolean = true,
override val name: String,
override val isDone: Boolean = false,
override val details: List<Detail>? = null,
) : Completable, HasDetail {
companion object // For companion extension functions outside
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/model/Task.kt | 3715041131 |
package com.hanbikan.nook.core.domain.model
interface HasDetail {
val details: List<Detail>?
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/model/HasDetail.kt | 796737638 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.repository.UserRepository
import javax.inject.Inject
class UpdateUserUseCase @Inject constructor(
private val userRepository: UserRepository
) {
suspend operator fun invoke(user: User) {
userRepository.insertUser(user)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/UpdateUserUseCase.kt | 3340845484 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.repository.AppStateRepository
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
class GetLastVisitedRouteUseCase @Inject constructor(
private val appStateRepository: AppStateRepository
) {
operator fun invoke(): Flow<String?> {
return appStateRepository.getLastVisitedRoute()
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/GetLastVisitedRouteUseCase.kt | 2983751701 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.model.TutorialTask
import com.hanbikan.nook.core.domain.repository.TutorialTaskRepository
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
class GetTutorialTasksByUserIdAndDayUseCase @Inject constructor(
private val tutorialTaskRepository: TutorialTaskRepository
) {
operator fun invoke(userId: Int, day: Int): Flow<List<TutorialTask>> {
return tutorialTaskRepository.getTutorialTasksByUserIdAndDay(userId, day)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/GetTutorialTasksByUserIdAndDayUseCase.kt | 1457804644 |
package com.hanbikan.nook.core.domain.usecase
/**
* TutorialTask๊ฐ ๋น์์ ๊ฒฝ์ฐ ์ด๋ฅผ ์ด๊ธฐํํ๋ ์ ์ค์ผ์ด์ค์
๋๋ค. ์ด๊ธฐํ ๋ก์ง์ด ์๋๋ก์ด๋์ ๋ฆฌ์์ค์ ์์กดํ๊ธฐ ๋๋ฌธ์ ์์ ์๋๋ก์ด๋
* ๋ชจ๋์์ DI๋ก ๊ตฌํ์ฒด๋ฅผ ๋ฃ์ด์ฃผ๋ ๋ฐฉ์์ ์ ํํ์์ต๋๋ค.
*/
interface UpdateTutorialTasksIfEmptyUseCase {
suspend operator fun invoke(userId: Int)
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/UpdateTutorialTasksIfEmptyUseCase.kt | 521213919 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.repository.TaskRepository
import javax.inject.Inject
class DeleteTaskUseCase @Inject constructor(
private val taskRepository: TaskRepository,
) {
suspend operator fun invoke(id: Int) {
taskRepository.deleteTaskById(id)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/DeleteTaskUseCase.kt | 2958664045 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.repository.AppStateRepository
import javax.inject.Inject
class SetActiveUserIdUseCase @Inject constructor(
private val appStateRepository: AppStateRepository
) {
suspend operator fun invoke(id: Int) {
appStateRepository.setActiveUserId(id)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/SetActiveUserIdUseCase.kt | 753923884 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.repository.UserRepository
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
class GetAllUsersUseCase @Inject constructor(
private val userRepository: UserRepository,
) {
operator fun invoke(): Flow<List<User>> {
return userRepository.getAllUsers()
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/GetAllUsersUseCase.kt | 2508304412 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.model.Task
import com.hanbikan.nook.core.domain.repository.TaskRepository
import javax.inject.Inject
class AddTaskUseCase @Inject constructor(
private val taskRepository: TaskRepository,
) {
suspend operator fun invoke(task: Task) {
taskRepository.insertTasks(listOf(task))
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/AddTaskUseCase.kt | 1830565784 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.repository.TaskRepository
import javax.inject.Inject
class ResetAllDailyTasksUseCase @Inject constructor(
private val taskRepository: TaskRepository,
) {
suspend operator fun invoke() {
taskRepository.resetAllDailyTasks()
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/ResetAllDailyTasksUseCase.kt | 2821470475 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.model.Task
import com.hanbikan.nook.core.domain.repository.TaskRepository
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
class GetAllTasksByUserIdUseCase @Inject constructor(
private val taskRepository: TaskRepository,
) {
operator fun invoke(userId: Int): Flow<List<Task>> {
return taskRepository.getAllTasksByUserId(userId)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/GetAllTasksByUserIdUseCase.kt | 896845117 |
package com.hanbikan.nook.core.domain.usecase
/**
* Task๊ฐ ๋น์์ ๊ฒฝ์ฐ ์ด๋ฅผ ์ด๊ธฐํํ๋ ์ ์ค์ผ์ด์ค์
๋๋ค. ์ด๊ธฐํ ๋ก์ง์ด ์๋๋ก์ด๋์ ๋ฆฌ์์ค์ ์์กดํ๊ธฐ ๋๋ฌธ์ ์์ ์๋๋ก์ด๋ ๋ชจ๋์์
* DI๋ก ๊ตฌํ์ฒด๋ฅผ ๋ฃ์ด์ฃผ๋ ๋ฐฉ์์ ์ ํํ์์ต๋๋ค.
*/
interface UpdateTasksIfEmptyUseCase {
suspend operator fun invoke(userId: Int)
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/UpdateTasksIfEmptyUseCase.kt | 1658035004 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.repository.AppStateRepository
import com.hanbikan.nook.core.domain.repository.UserRepository
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.flowOf
import javax.inject.Inject
class GetActiveUserUseCase @Inject constructor(
private val appStateRepository: AppStateRepository,
private val userRepository: UserRepository,
) {
@OptIn(ExperimentalCoroutinesApi::class)
operator fun invoke(): Flow<User?> {
return appStateRepository.getActiveUserId()
.flatMapLatest {
if (it == null) {
flowOf(null)
} else {
userRepository.getUserById(it)
}
}
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/GetActiveUserUseCase.kt | 3055441287 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.repository.AppStateRepository
import com.hanbikan.nook.core.domain.repository.UserRepository
import javax.inject.Inject
class AddUserUseCase @Inject constructor(
private val userRepository: UserRepository,
private val appStateRepository: AppStateRepository,
private val updateTasksIfEmptyUseCase: UpdateTasksIfEmptyUseCase,
private val updateTutorialTasksIfEmptyUseCase: UpdateTutorialTasksIfEmptyUseCase,
) {
suspend operator fun invoke(user: User) {
val addedUserId = userRepository.insertUser(user)
// ํ์ ์์
appStateRepository.setActiveUserId(addedUserId)
updateTasksIfEmptyUseCase(addedUserId)
updateTutorialTasksIfEmptyUseCase(addedUserId)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/AddUserUseCase.kt | 2600918865 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.repository.UserRepository
import javax.inject.Inject
class DeleteUserByIdUseCase @Inject constructor(
private val userRepository: UserRepository
) {
suspend operator fun invoke(id: Int) {
userRepository.deleteUserById(id)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/DeleteUserByIdUseCase.kt | 1384848703 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.repository.TutorialTaskRepository
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.mapLatest
import javax.inject.Inject
import kotlin.math.max
import kotlin.math.min
class GetTutorialDayRangeUseCase @Inject constructor(
private val tutorialTaskRepository: TutorialTaskRepository
) {
@OptIn(ExperimentalCoroutinesApi::class)
operator fun invoke(userId: Int?): Flow<IntRange?> {
return if (userId == null) {
flowOf(null)
} else {
tutorialTaskRepository.getTutorialTasksByUserId(userId).mapLatest { tutorialTasks ->
var minTutorialDay: Int? = null
var maxTutorialDay: Int? = null
tutorialTasks.forEach {
minTutorialDay = min(minTutorialDay ?: Int.MAX_VALUE, it.day) // null์ด๋ฉด it.day ๋์
maxTutorialDay = max(maxTutorialDay ?: 0, it.day) // null์ด๋ฉด it.day ๋์
}
maxTutorialDay?.let { minTutorialDay?.rangeTo(it) }
}
}
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/GetTutorialDayRangeUseCase.kt | 3132981210 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.model.Task
import com.hanbikan.nook.core.domain.repository.TaskRepository
import javax.inject.Inject
class UpdateTaskUseCase @Inject constructor(
private val taskRepository: TaskRepository
) {
suspend operator fun invoke(task: Task) {
taskRepository.updateTask(task)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/UpdateTaskUseCase.kt | 173361012 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.model.TutorialTask
import com.hanbikan.nook.core.domain.repository.TutorialTaskRepository
import javax.inject.Inject
class UpdateTutorialTaskUseCase @Inject constructor(
private val tutorialTaskRepository: TutorialTaskRepository
) {
suspend operator fun invoke(tutorialTask: TutorialTask) {
tutorialTaskRepository.updateTutorialTask(tutorialTask)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/UpdateTutorialTaskUseCase.kt | 4188481960 |
package com.hanbikan.nook.core.domain.usecase
import com.hanbikan.nook.core.domain.repository.AppStateRepository
import javax.inject.Inject
class SetLastVisitedRouteUseCase @Inject constructor(
private val appStateRepository: AppStateRepository
) {
suspend operator fun invoke(route: String) {
appStateRepository.setLastVisitedRoute(route)
}
} | Nook/core/domain/src/main/java/com/hanbikan/nook/core/domain/usecase/SetLastVisitedRouteUseCase.kt | 1461219494 |
package com.hanbikan.nook
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import org.junit.Assert.*
import org.junit.Test
import org.junit.runner.RunWith
/**
* 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.hanbikan.nook", appContext.packageName)
}
} | Nook/app/src/androidTest/java/com/hanbikan/nook/ExampleInstrumentedTest.kt | 1645305838 |
package com.hanbikan.nook
import org.junit.Assert.assertEquals
import org.junit.Test
/**
* 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)
}
} | Nook/app/src/test/java/com/hanbikan/nook/ExampleUnitTest.kt | 845492991 |
package com.hanbikan.nook
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.hanbikan.nook.core.domain.usecase.GetLastVisitedRouteUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class MainViewModel @Inject constructor(
private val getLastVisitedRouteUseCase: GetLastVisitedRouteUseCase
): ViewModel() {
private val _isReady: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isReady = _isReady.asStateFlow()
private val _lastVisitedRoute: MutableStateFlow<String?> = MutableStateFlow(null)
val lastVisitedRoute = _lastVisitedRoute.asStateFlow()
init {
viewModelScope.launch(Dispatchers.IO) {
getLastVisitedRouteUseCase().collect {
_isReady.value = true
_lastVisitedRoute.value = it
}
}
}
} | Nook/app/src/main/java/com/hanbikan/nook/MainViewModel.kt | 980104080 |
package com.hanbikan.nook.ui
import androidx.compose.runtime.Composable
import com.hanbikan.nook.core.designsystem.component.NkBackground
import com.hanbikan.nook.navigation.NkAppState
import com.hanbikan.nook.navigation.NkNavHost
import com.hanbikan.nook.navigation.rememberNkAppState
@Composable
fun NkApp(
startDestination: String,
appState: NkAppState = rememberNkAppState(
startDestination = startDestination,
),
) {
NkBackground {
NkNavHost(appState = appState)
}
} | Nook/app/src/main/java/com/hanbikan/nook/ui/NkApp.kt | 735909353 |
package com.hanbikan.nook
import android.annotation.SuppressLint
import android.os.Bundle
import android.view.View
import android.view.ViewTreeObserver
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.ui.Modifier
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.hanbikan.nook.core.designsystem.theme.NkTheme
import com.hanbikan.nook.feature.tutorial.navigation.welcomeScreenRoute
import com.hanbikan.nook.ui.NkApp
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
private val viewModel: MainViewModel by viewModels()
@SuppressLint("Recycle")
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
NkTheme {
val lastVisitedRoute = viewModel.lastVisitedRoute.collectAsStateWithLifecycle().value
val isReady = viewModel.isReady.collectAsStateWithLifecycle().value
if (isReady) {
NkApp(startDestination = lastVisitedRoute ?: welcomeScreenRoute)
} else {
Column(
modifier = Modifier
.fillMaxSize()
.background(NkTheme.colorScheme.background)
) {}
}
}
}
// Set up an OnPreDrawListener to the root view.
val content: View = findViewById(android.R.id.content)
content.viewTreeObserver.addOnPreDrawListener(
object : ViewTreeObserver.OnPreDrawListener {
override fun onPreDraw(): Boolean {
// Check whether the initial data is ready.
return if (viewModel.isReady.value) {
// The content is ready. Start drawing.
content.viewTreeObserver.removeOnPreDrawListener(this)
true
} else {
// The content isn't ready. Suspend.
false
}
}
}
)
}
} | Nook/app/src/main/java/com/hanbikan/nook/MainActivity.kt | 3700135708 |
package com.hanbikan.nook
import android.app.Application
import com.hanbikan.nook.core.ui.receiver.DailyResetScheduler
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class NkApplication : Application() {
override fun onCreate() {
super.onCreate()
DailyResetScheduler.scheduleDailyAlarm(this)
}
} | Nook/app/src/main/java/com/hanbikan/nook/NkApplication.kt | 632565610 |
package com.hanbikan.nook.navigation
import androidx.compose.runtime.Composable
import androidx.navigation.compose.NavHost
import com.hanbikan.nook.feature.phone.navigation.phoneGraph
import com.hanbikan.nook.feature.phone.navigation.phoneGraphRoute
@Composable
fun NkNavHost(
appState: NkAppState,
) {
NavHost(
navController = appState.navController,
startDestination = phoneGraphRoute,
) {
phoneGraph(
navController = appState.navController,
startDestination = appState.startDestination,
)
}
} | Nook/app/src/main/java/com/hanbikan/nook/navigation/NkNavHost.kt | 1752553643 |
package com.hanbikan.nook.navigation
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.navigation.NavHostController
import androidx.navigation.compose.rememberNavController
@Composable
fun rememberNkAppState(
startDestination: String,
navController: NavHostController = rememberNavController(),
): NkAppState {
return remember(
startDestination,
navController,
) {
NkAppState(
navController,
startDestination
)
}
}
class NkAppState(
val navController: NavHostController,
val startDestination: String,
) | Nook/app/src/main/java/com/hanbikan/nook/navigation/NkAppState.kt | 1741901028 |
package com.hanbikan.nook.feature.tutorial
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import org.junit.Assert.*
import org.junit.Test
import org.junit.runner.RunWith
/**
* 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.hanbikan.nook.feature.tutorial.test", appContext.packageName)
}
} | Nook/feature/tutorial/src/androidTest/java/com/hanbikan/nook/feature/tutorial/ExampleInstrumentedTest.kt | 3793466520 |
package com.hanbikan.nook.feature.tutorial
import android.content.Context
import com.hanbikan.nook.core.domain.repository.TutorialTaskRepository
import com.hanbikan.nook.core.domain.usecase.UpdateTutorialTasksIfEmptyUseCase
import com.hanbikan.nook.feature.tutorial.usecase.UpdateTutorialTasksIfEmptyUseCaseImpl
import com.nook.core.domain_test.data.tutorialTasksTestData
import com.nook.core.domain_test.data.userTestData
import com.nook.core.domain_test.repository.TestTutorialTaskRepository
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.test.runTest
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNotEquals
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.ArgumentMatchers
import org.mockito.Mock
import org.mockito.junit.MockitoJUnitRunner
import org.mockito.kotlin.mock
@RunWith(MockitoJUnitRunner::class)
class UpdateTutorialTasksIfEmptyUseCaseTest {
@Mock
lateinit var context: Context
private lateinit var testTutorialTaskRepository: TutorialTaskRepository
private lateinit var useCase: UpdateTutorialTasksIfEmptyUseCase
@Before
fun setup() {
context = mock<Context> {
on { getString(ArgumentMatchers.anyInt()) }.thenReturn("")
}
testTutorialTaskRepository = TestTutorialTaskRepository()
useCase = UpdateTutorialTasksIfEmptyUseCaseImpl(
testTutorialTaskRepository,
context
)
}
@Test
fun updateTutorialTasks_ifNotEmpty_keepsPreviousTasksUnchanged() = runTest {
val userIdWithTutorialTask = tutorialTasksTestData[0].userId
val prevTutorialTasks = testTutorialTaskRepository.getTutorialTasksByUserId(userIdWithTutorialTask).first()
useCase(userIdWithTutorialTask)
val tutorialTasks = testTutorialTaskRepository.getTutorialTasksByUserId(userIdWithTutorialTask).first()
assertEquals(prevTutorialTasks, tutorialTasks)
}
@Test
fun updateTutorialTasks_ifEmpty_updatesTutorialTasks() = runTest {
val userIdWithoutTutorialTask = userTestData.find { user ->
// tutorialTasksTestData์์ ์์ ์ id๋ฅผ ์ฐพ์ ์ ์๋ ๊ฒฝ์ฐ ์ฐพ๊ธฐ
tutorialTasksTestData.firstOrNull { it.userId == user.id } == null
}!!.id
val prevTutorialTasks = testTutorialTaskRepository.getTutorialTasksByUserId(userIdWithoutTutorialTask).first()
useCase(userIdWithoutTutorialTask)
val tutorialTask = testTutorialTaskRepository.getTutorialTasksByUserId(userIdWithoutTutorialTask)
assertNotEquals(prevTutorialTasks, tutorialTask)
}
} | Nook/feature/tutorial/src/test/java/com/hanbikan/nook/feature/tutorial/UpdateTutorialTasksIfEmptyUseCaseTest.kt | 3950818677 |
package com.hanbikan.nook.feature.tutorial
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.hanbikan.nook.core.common.executeIfBothNonNull
import com.hanbikan.nook.core.domain.model.Detail
import com.hanbikan.nook.core.domain.model.TutorialTask
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.usecase.GetActiveUserUseCase
import com.hanbikan.nook.core.domain.usecase.GetTutorialDayRangeUseCase
import com.hanbikan.nook.core.domain.usecase.GetTutorialTasksByUserIdAndDayUseCase
import com.hanbikan.nook.core.domain.usecase.SetLastVisitedRouteUseCase
import com.hanbikan.nook.core.domain.usecase.UpdateUserUseCase
import com.hanbikan.nook.core.domain.usecase.UpdateTutorialTaskUseCase
import com.hanbikan.nook.core.domain.usecase.UpdateTutorialTasksIfEmptyUseCase
import com.hanbikan.nook.feature.tutorial.navigation.tutorialScreenRoute
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.mapLatest
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class TutorialViewModel @Inject constructor(
private val getTutorialTasksByUserIdAndDayUseCase: GetTutorialTasksByUserIdAndDayUseCase,
private val updateTutorialTaskUseCase: UpdateTutorialTaskUseCase,
setLastVisitedRouteUseCase: SetLastVisitedRouteUseCase,
getActiveUserUseCase: GetActiveUserUseCase,
getTutorialDayRangeUseCase: GetTutorialDayRangeUseCase,
private val updateUserUseCase: UpdateUserUseCase,
) : ViewModel() {
// Data for UI
val activeUser: StateFlow<User?> = getActiveUserUseCase()
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), null)
@OptIn(ExperimentalCoroutinesApi::class)
val tutorialDayRange: StateFlow<IntRange?> = activeUser
.flatMapLatest {
if (it == null) {
flowOf(null)
} else {
getTutorialDayRangeUseCase(it.id)
}
}
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), null)
@OptIn(ExperimentalCoroutinesApi::class)
val tutorialTaskList: StateFlow<List<TutorialTask>> = activeUser
.flatMapLatest {
if (it == null) {
flowOf(listOf())
} else {
getTutorialTasksByUserIdAndDayUseCase(it.id, it.tutorialDay)
}
}
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), listOf())
// Ui state
@OptIn(ExperimentalCoroutinesApi::class)
val uiState: StateFlow<TutorialUiState> = tutorialTaskList
.mapLatest {
if (it.isEmpty()) {
TutorialUiState.Loading
} else {
TutorialUiState.Success
}
}
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), TutorialUiState.Loading)
// Dialog
private val _isUserDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isUserDialogShown = _isUserDialogShown.asStateFlow()
private val _isProgressCardInfoDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isProgressCardInfoDialogShown = _isProgressCardInfoDialogShown.asStateFlow()
private val _isNextDayDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isNextDayDialogShown = _isNextDayDialogShown.asStateFlow()
private val _isTutorialEndDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isTutorialEndDialogShown = _isTutorialEndDialogShown.asStateFlow()
// Detail dialog
private val _isDetailDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isDetailDialogShown = _isDetailDialogShown.asStateFlow()
private val _detailsToShow: MutableStateFlow<List<Detail>> = MutableStateFlow(listOf())
val detailsToShow = _detailsToShow.asStateFlow()
init {
viewModelScope.launch(Dispatchers.IO) {
setLastVisitedRouteUseCase(tutorialScreenRoute)
}
viewModelScope.launch(Dispatchers.IO) {
tutorialTaskList.collectLatest { tutorialTaskList ->
if (tutorialTaskList.all { it.isDone }) {
executeIfBothNonNull(activeUser.value, tutorialDayRange.value) { activeUser, tutorialDayRange ->
if (activeUser.tutorialDay in tutorialDayRange.first until tutorialDayRange.last) {
_isNextDayDialogShown.value = true
} else if (activeUser.tutorialDay == tutorialDayRange.last) {
_isTutorialEndDialogShown.value = true
}
}
}
}
}
}
fun switchUserDialog() {
_isUserDialogShown.value = !isUserDialogShown.value
}
fun switchProgressCardInfoDialog() {
_isProgressCardInfoDialogShown.value = !isProgressCardInfoDialogShown.value
}
fun switchNextDayDialog() {
_isNextDayDialogShown.value = !isNextDayDialogShown.value
}
fun switchTutorialEndDialog() {
_isTutorialEndDialogShown.value = !isTutorialEndDialogShown.value
}
fun switchTutorialTask(index: Int) {
val target = tutorialTaskList.value.getOrNull(index) ?: return
val newTutorialTask = target.copy(isDone = !target.isDone)
viewModelScope.launch(Dispatchers.IO) {
updateTutorialTaskUseCase(newTutorialTask)
}
}
fun showDetailDialog(details: List<Detail>) {
_detailsToShow.value = details
_isDetailDialogShown.value = true
}
fun hideDetailDialog() {
_isDetailDialogShown.value = false
_detailsToShow.value = listOf()
}
fun increaseTutorialDay() {
viewModelScope.launch(Dispatchers.IO) {
executeIfBothNonNull(activeUser.value, tutorialDayRange.value) { activeUser, tutorialDayRange ->
val nextTutorialDay = activeUser.tutorialDay + 1
if (nextTutorialDay in tutorialDayRange) {
updateUserUseCase(activeUser.copy(tutorialDay = nextTutorialDay))
}
}
}
}
fun decreaseTutorialDay() {
viewModelScope.launch(Dispatchers.IO) {
executeIfBothNonNull(activeUser.value, tutorialDayRange.value) { activeUser, tutorialDayRange ->
val nextTutorialDay = activeUser.tutorialDay - 1
if (nextTutorialDay in tutorialDayRange) {
updateUserUseCase(activeUser.copy(tutorialDay = nextTutorialDay))
}
}
}
}
}
sealed interface TutorialUiState {
object Loading : TutorialUiState
object Success : TutorialUiState
} | Nook/feature/tutorial/src/main/java/com/hanbikan/nook/feature/tutorial/TutorialViewModel.kt | 2552485396 |
package com.hanbikan.nook.feature.tutorial
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowLeft
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
import androidx.compose.material.icons.filled.Info
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.IconButtonDefaults
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.hanbikan.nook.core.designsystem.component.AppBarIcon
import com.hanbikan.nook.core.designsystem.component.FadeAnimatedVisibility
import com.hanbikan.nook.core.designsystem.component.NkDialog
import com.hanbikan.nook.core.designsystem.component.NkSmallButton
import com.hanbikan.nook.core.designsystem.component.NkTopAppBar
import com.hanbikan.nook.core.designsystem.component.TitleTextWithSpacer
import com.hanbikan.nook.core.designsystem.theme.Dimens
import com.hanbikan.nook.core.designsystem.theme.NkTheme
import com.hanbikan.nook.core.domain.model.Detail
import com.hanbikan.nook.core.domain.model.TutorialTask
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.ui.DetailDialog
import com.hanbikan.nook.core.ui.ProgressCard
import com.hanbikan.nook.core.ui.TaskCard
import com.hanbikan.nook.core.ui.UserDialog
import com.hanbikan.nook.core.ui.WelcomeText
@Composable
fun TutorialScreen(
navigateToAddUser: () -> Unit,
navigateToPhone: () -> Unit,
navigateToTodo: () -> Unit,
viewModel: TutorialViewModel = hiltViewModel(),
) {
val isUserDialogShown = viewModel.isUserDialogShown.collectAsStateWithLifecycle().value
val isProgressCardInfoDialogShown =
viewModel.isProgressCardInfoDialogShown.collectAsStateWithLifecycle().value
val isDetailDialogShown = viewModel.isDetailDialogShown.collectAsStateWithLifecycle().value
val isNextDayDialogShown = viewModel.isNextDayDialogShown.collectAsStateWithLifecycle().value
val isTutorialEndDialogShown = viewModel.isTutorialEndDialogShown.collectAsStateWithLifecycle().value
val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
val tutorialDayRange = viewModel.tutorialDayRange.collectAsStateWithLifecycle().value
val activeUser = viewModel.activeUser.collectAsStateWithLifecycle().value ?: User.DEFAULT
val tutorialTaskList = viewModel.tutorialTaskList.collectAsStateWithLifecycle().value
val detailsToShow = viewModel.detailsToShow.collectAsStateWithLifecycle().value
Box {
Column(
modifier = Modifier.fillMaxSize(),
horizontalAlignment = Alignment.CenterHorizontally,
) {
NkTopAppBar(
leftAppBarIcons = listOf(
AppBarIcon.appListAppBarIcon(onClick = navigateToPhone)
),
rightAppBarIcons = listOf(
AppBarIcon.userDialogAppBarIcon(onClick = viewModel::switchUserDialog)
),
)
TutorialScreenContents(
uiState = uiState,
activeUser = activeUser,
tutorialTaskList = tutorialTaskList,
switchTutorialTask = viewModel::switchTutorialTask,
decreaseTutorialDay = viewModel::decreaseTutorialDay,
increaseTutorialDay = viewModel::increaseTutorialDay,
tutorialDayRange = tutorialDayRange,
switchProgressCardInfoDialog = viewModel::switchProgressCardInfoDialog,
onClickInfo = viewModel::showDetailDialog,
)
}
UserDialog(
visible = isUserDialogShown,
navigateToAddUser = navigateToAddUser,
onDismissRequest = viewModel::switchUserDialog
)
NkDialog(
visible = isProgressCardInfoDialogShown,
description = stringResource(id = R.string.progress_card_description),
onDismissRequest = viewModel::switchProgressCardInfoDialog,
onConfirmation = viewModel::switchProgressCardInfoDialog,
hasOnlyConfirmationButton = true
)
DetailDialog(
visible = isDetailDialogShown,
detailsToShow = detailsToShow,
hideDetailDialog = viewModel::hideDetailDialog
)
NkDialog(
visible = isNextDayDialogShown,
description = stringResource(
id = R.string.move_to_next_day_description,
activeUser.tutorialDay + 1
),
onDismissRequest = viewModel::switchNextDayDialog,
onConfirmation = {
viewModel.increaseTutorialDay()
viewModel.switchNextDayDialog()
}
)
NkDialog(
visible = isTutorialEndDialogShown,
description = stringResource(id = R.string.move_to_todo_description),
onDismissRequest = viewModel::switchTutorialEndDialog,
onConfirmation = navigateToTodo
)
}
}
@Composable
fun TutorialScreenContents(
uiState: TutorialUiState,
activeUser: User,
tutorialTaskList: List<TutorialTask>,
switchTutorialTask: (Int) -> Unit,
decreaseTutorialDay: () -> Unit,
increaseTutorialDay: () -> Unit,
tutorialDayRange: IntRange?,
switchProgressCardInfoDialog: () -> Unit,
onClickInfo: (List<Detail>) -> Unit,
) {
FadeAnimatedVisibility(visible = uiState is TutorialUiState.Success) {
Column {
LazyColumn(
modifier = Modifier
.padding(Dimens.SideMargin)
.weight(1f),
) {
item {
WelcomeText(userName = activeUser.name)
// Progress card
TitleTextWithSpacer(
title = stringResource(
id = R.string.progress_by_day,
activeUser.tutorialDay
)
) {
NkSmallButton(
onClick = switchProgressCardInfoDialog,
imageVector = Icons.Default.Info
)
}
ProgressCard(completableList = tutorialTaskList)
// Today's tutorial task list
TitleTextWithSpacer(title = stringResource(id = R.string.today_task))
}
itemsIndexed(tutorialTaskList) { index, item ->
TaskCard(
completable = item,
onClickCheckbox = { switchTutorialTask(index) },
onClickInfo = item.details?.let { { onClickInfo(it) } }
)
}
}
Row {
IconButton(
onClick = decreaseTutorialDay,
modifier = Modifier.weight(1f),
colors = IconButtonDefaults.iconButtonColors(
contentColor = NkTheme.colorScheme.primary,
),
enabled = tutorialDayRange != null && (activeUser.tutorialDay - 1) in tutorialDayRange
) {
Icon(
imageVector = Icons.AutoMirrored.Filled.KeyboardArrowLeft,
contentDescription = stringResource(id = R.string.previous),
)
}
IconButton(
onClick = increaseTutorialDay,
modifier = Modifier.weight(1f),
colors = IconButtonDefaults.iconButtonColors(
contentColor = NkTheme.colorScheme.primary,
),
enabled = tutorialDayRange != null && (activeUser.tutorialDay + 1) in tutorialDayRange
) {
Icon(
imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
contentDescription = stringResource(id = R.string.next),
)
}
}
}
}
}
@Composable
@Preview
fun TutorialScreenPreview() {
TutorialScreen({}, {}, {})
} | Nook/feature/tutorial/src/main/java/com/hanbikan/nook/feature/tutorial/TutorialScreen.kt | 4175423418 |
package com.hanbikan.nook.feature.tutorial.di
import com.hanbikan.nook.core.domain.usecase.UpdateTutorialTasksIfEmptyUseCase
import com.hanbikan.nook.feature.tutorial.usecase.UpdateTutorialTasksIfEmptyUseCaseImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module
@InstallIn(SingletonComponent::class)
interface UpdateTutorialTasksIfEmptyUseCaseModule {
@Binds
fun bindsUpdateTutorialTasksIfEmptyUseCase(
updateTutorialTasksIfEmptyUseCaseImpl: UpdateTutorialTasksIfEmptyUseCaseImpl,
): UpdateTutorialTasksIfEmptyUseCase
} | Nook/feature/tutorial/src/main/java/com/hanbikan/nook/feature/tutorial/di/UpdateTutorialTasksIfEmptyUseCaseModule.kt | 2583383288 |
package com.hanbikan.nook.feature.tutorial
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.res.vectorResource
import androidx.compose.ui.tooling.preview.Preview
import com.hanbikan.nook.core.designsystem.component.EnterFadeInAnimatedVisibility
import com.hanbikan.nook.core.designsystem.component.NkText
import com.hanbikan.nook.core.designsystem.component.NkTextButton
import com.hanbikan.nook.core.designsystem.theme.Dimens
import com.hanbikan.nook.core.designsystem.theme.NkTheme
@Composable
fun WelcomeScreen(
navigateToAddUser: () -> Unit,
) {
Column(
modifier = Modifier
.fillMaxSize()
.padding(Dimens.SideMargin),
) {
EnterFadeInAnimatedVisibility {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
) {
Column(
modifier = Modifier.weight(1f),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
) {
Image(
imageVector = ImageVector.vectorResource(id = R.drawable.welcome_cats),
contentDescription = stringResource(id = R.string.welcome_message_title),
modifier = Modifier.size(Dimens.IconExtraLarge)
)
NkText(
text = stringResource(id = R.string.welcome_message_title),
style = NkTheme.typography.titleLarge,
)
Spacer(modifier = Modifier.height(Dimens.SpacingExtraSmall))
NkText(
text = stringResource(id = R.string.welcome_message_body),
style = NkTheme.typography.titleMedium,
color = NkTheme.colorScheme.primaryContainer,
)
}
NkTextButton(
modifier = Modifier.fillMaxWidth(),
onClick = navigateToAddUser,
text = stringResource(id = R.string.start),
)
}
}
}
}
@Composable
@Preview
fun WelcomeScreenPreview() {
WelcomeScreen({})
} | Nook/feature/tutorial/src/main/java/com/hanbikan/nook/feature/tutorial/WelcomeScreen.kt | 1982383311 |
package com.hanbikan.nook.feature.tutorial.navigation
import androidx.navigation.NavController
import androidx.navigation.NavGraphBuilder
import androidx.navigation.compose.composable
import com.hanbikan.nook.feature.tutorial.AddUserScreen
import com.hanbikan.nook.feature.tutorial.TutorialScreen
import com.hanbikan.nook.feature.tutorial.WelcomeScreen
const val welcomeScreenRoute = "welcome_screen_route"
const val addUserScreenRoute = "add_user_screen_route"
const val tutorialScreenRoute = "tutorial_screen_route"
fun NavGraphBuilder.welcomeScreen(
navigateToAddUser: () -> Unit,
) {
composable(
route = welcomeScreenRoute,
) {
WelcomeScreen(
navigateToAddUser = navigateToAddUser,
)
}
}
fun NavGraphBuilder.addUserScreen(
navigateUp: () -> Unit,
navigateToTutorial: () -> Unit,
) {
composable(
route = addUserScreenRoute,
) {
AddUserScreen(
navigateUp = navigateUp,
navigateToTutorial = navigateToTutorial
)
}
}
fun NavGraphBuilder.tutorialScreen(
navigateToAddUser: () -> Unit,
navigateToPhone: () -> Unit,
navigateToTodo: () -> Unit,
) {
composable(
route = tutorialScreenRoute,
) {
TutorialScreen(
navigateToAddUser = navigateToAddUser,
navigateToPhone = navigateToPhone,
navigateToTodo = navigateToTodo,
)
}
}
fun NavController.navigateToWelcome() {
navigate(welcomeScreenRoute)
}
fun NavController.navigateToAddUser() {
navigate(addUserScreenRoute)
}
fun NavController.navigateToTutorial() {
navigate(tutorialScreenRoute)
} | Nook/feature/tutorial/src/main/java/com/hanbikan/nook/feature/tutorial/navigation/TutorialNavigation.kt | 3025254914 |
package com.hanbikan.nook.feature.tutorial
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.usecase.AddUserUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import javax.inject.Inject
@HiltViewModel
class AddUserViewModel @Inject constructor(
private val addUserUseCase: AddUserUseCase,
) : ViewModel() {
private val _name: MutableStateFlow<String> = MutableStateFlow("")
val name = _name.asStateFlow()
private val _islandName: MutableStateFlow<String> = MutableStateFlow("")
val islandName = _islandName.asStateFlow()
fun setName(newName: String) {
if (newName.length >= User.NAME_MAX_LENGTH) return
_name.value = newName
}
fun setIslandName(newIslandName: String) {
if (newIslandName.length >= User.ISLAND_NAME_MAX_LENGTH) return
_islandName.value = newIslandName
}
fun addUser(onComplete: () -> Unit) {
if (name.value.isEmpty() || islandName.value.isEmpty()) return
viewModelScope.launch(Dispatchers.IO) {
val user = User(name = name.value, islandName = islandName.value)
addUserUseCase(user)
// onComplete์์ navigate์ ๊ฐ์ ๋์์ ์ํํ๋ฏ๋ก Main Thread์์ ์ํ๋์ด์ผ ํฉ๋๋ค.
withContext(Dispatchers.Main) {
onComplete()
}
}
}
} | Nook/feature/tutorial/src/main/java/com/hanbikan/nook/feature/tutorial/AddUserViewModel.kt | 362101403 |
package com.hanbikan.nook.feature.tutorial
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.tooling.preview.Preview
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.hanbikan.nook.core.designsystem.component.AppBarIcon
import com.hanbikan.nook.core.designsystem.component.NkPlaceholder
import com.hanbikan.nook.core.designsystem.component.NkText
import com.hanbikan.nook.core.designsystem.component.NkTextButton
import com.hanbikan.nook.core.designsystem.component.NkTextField
import com.hanbikan.nook.core.designsystem.component.NkTopAppBar
import com.hanbikan.nook.core.designsystem.theme.Dimens
import com.hanbikan.nook.core.designsystem.theme.NkTheme
@Composable
fun AddUserScreen(
navigateUp: () -> Unit,
navigateToTutorial: () -> Unit,
viewModel: AddUserViewModel = hiltViewModel(),
) {
val name = viewModel.name.collectAsStateWithLifecycle().value
val islandName = viewModel.islandName.collectAsStateWithLifecycle().value
Column(modifier = Modifier.fillMaxSize()) {
NkTopAppBar(leftAppBarIcons = listOf(AppBarIcon.backAppBarIcon(onClick = navigateUp)))
AddUserScreenContents(
name = name,
islandName = islandName,
setName = viewModel::setName,
setIslandName = viewModel::setIslandName,
onClickAddButton = {
viewModel.addUser {
navigateToTutorial()
}
}
)
}
}
@Composable
fun AddUserScreenContents(
name: String,
islandName: String,
setName: (String) -> Unit,
setIslandName: (String) -> Unit,
onClickAddButton: () -> Unit,
) {
val secondFocusRequester = remember { FocusRequester() }
val scrollState = rememberScrollState()
Column(
modifier = Modifier
.fillMaxSize()
.padding(Dimens.SideMargin),
) {
Column(
modifier = Modifier
.verticalScroll(scrollState)
.weight(1f),
verticalArrangement = Arrangement.spacedBy(Dimens.SpacingSmall),
) {
NkText(
text = stringResource(id = R.string.add_user_title),
style = NkTheme.typography.headlineLarge,
fontWeight = FontWeight.Bold,
)
NkText(
text = stringResource(id = R.string.add_user_body),
color = NkTheme.colorScheme.primaryContainer
)
Spacer(modifier = Modifier.height(Dimens.SpacingLarge))
NkText(
text = stringResource(id = R.string.name),
style = NkTheme.typography.titleMedium
)
NkTextField(
modifier = Modifier.fillMaxWidth(),
value = name,
onValueChange = setName,
placeholder = {
NkPlaceholder(text = stringResource(id = R.string.name_placeholder))
},
keyboardOptions = KeyboardOptions.Default.copy(
imeAction = ImeAction.Next
),
keyboardActions = KeyboardActions {
secondFocusRequester.requestFocus()
},
singleLine = true,
)
Spacer(modifier = Modifier.height(Dimens.SpacingExtraSmall))
NkText(
text = stringResource(id = R.string.island_name),
style = NkTheme.typography.titleMedium
)
NkTextField(
modifier = Modifier
.focusRequester(secondFocusRequester)
.fillMaxWidth(),
value = islandName,
onValueChange = setIslandName,
placeholder = {
NkPlaceholder(text = stringResource(id = R.string.island_name_placeholder))
},
singleLine = true,
)
}
NkTextButton(
modifier = Modifier.fillMaxWidth(),
onClick = onClickAddButton,
text = stringResource(id = R.string.add),
)
}
}
@Composable
@Preview
fun AddUserScreenPreview() {
AddUserScreen({}, {})
} | Nook/feature/tutorial/src/main/java/com/hanbikan/nook/feature/tutorial/AddUserScreen.kt | 1555500788 |
package com.hanbikan.nook.feature.tutorial.model
import android.content.Context
import com.hanbikan.nook.core.domain.model.Detail
import com.hanbikan.nook.core.domain.model.TutorialTask
import com.hanbikan.nook.feature.tutorial.R
fun TutorialTask.Companion.createInitialTutorialTasks(
userId: Int,
context: Context,
): List<TutorialTask> = listOf(
// DAY 0
TutorialTask(
day = 0,
name = context.getString(R.string.tutorial_task_name1),
details = listOf(Detail(description = context.getString(R.string.tutorial_task_detail_description1))),
userId = userId,
isDone = false
),
TutorialTask(
day = 0,
name = context.getString(R.string.tutorial_task_name2),
userId = userId,
isDone = false
),
// DAY 1
TutorialTask(
day = 1,
name = context.getString(R.string.tutorial_task_name3),
details = listOf(Detail(description = context.getString(R.string.tutorial_task_detail_description3))),
userId = userId,
isDone = false
),
TutorialTask(
day = 1,
name = context.getString(R.string.tutorial_task_name4),
details = listOf(
Detail(description = context.getString(R.string.tutorial_task_detail_description4_1)),
Detail(description = context.getString(R.string.tutorial_task_detail_description4_2)),
),
userId = userId,
isDone = false
),
// DAY 2
TutorialTask(
day = 2,
name = context.getString(R.string.tutorial_task_name5),
details = listOf(
Detail(description = context.getString(R.string.tutorial_task_detail_description5_1)),
Detail(description = context.getString(R.string.tutorial_task_detail_description5_2)),
),
userId = userId,
isDone = false
),
TutorialTask(
day = 2,
name = context.getString(R.string.tutorial_task_name6),
userId = userId,
isDone = false
),
TutorialTask(
day = 2,
name = context.getString(R.string.tutorial_task_name7),
details = listOf(
Detail(description = context.getString(R.string.tutorial_task_detail_description7_1)),
Detail(description = context.getString(R.string.tutorial_task_detail_description7_2), imageId = R.drawable.eight_rocks),
Detail(description = context.getString(R.string.tutorial_task_detail_description7_3)),
Detail(description = context.getString(R.string.tutorial_task_detail_description7_4)),
),
userId = userId,
isDone = false
),
// DAY 3
TutorialTask(
day = 3,
name = context.getString(R.string.tutorial_task_name8),
userId = userId,
isDone = false
),
TutorialTask(
day = 3,
name = context.getString(R.string.tutorial_task_name9),
userId = userId,
isDone = false
),
TutorialTask(
day = 3,
name = context.getString(R.string.tutorial_task_name10),
details = listOf(
Detail(description = context.getString(R.string.tutorial_task_detail_description10_1)),
Detail(description = context.getString(R.string.tutorial_task_detail_description10_2)),
Detail(description = context.getString(R.string.tutorial_task_detail_description10_3)),
Detail(description = context.getString(R.string.tutorial_task_detail_description10_4)),
),
userId = userId,
isDone = false
),
) | Nook/feature/tutorial/src/main/java/com/hanbikan/nook/feature/tutorial/model/TutorialTask.kt | 3369614521 |
package com.hanbikan.nook.feature.tutorial.usecase
import android.content.Context
import com.hanbikan.nook.core.domain.model.TutorialTask
import com.hanbikan.nook.core.domain.repository.TutorialTaskRepository
import com.hanbikan.nook.core.domain.usecase.UpdateTutorialTasksIfEmptyUseCase
import com.hanbikan.nook.feature.tutorial.model.createInitialTutorialTasks
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.flow.first
import javax.inject.Inject
class UpdateTutorialTasksIfEmptyUseCaseImpl @Inject constructor(
private val tutorialTaskRepository: TutorialTaskRepository,
@ApplicationContext private val context: Context,
) : UpdateTutorialTasksIfEmptyUseCase {
override suspend operator fun invoke(userId: Int) {
val tutorialTasks = tutorialTaskRepository.getTutorialTasksByUserId(userId)
if (tutorialTasks.first().isEmpty()) {
val tutorialTasksToInsert = TutorialTask.createInitialTutorialTasks(userId, context)
tutorialTaskRepository.insertTutorialTasks(tutorialTasksToInsert)
}
}
} | Nook/feature/tutorial/src/main/java/com/hanbikan/nook/feature/tutorial/usecase/UpdateTutorialTasksIfEmptyUseCaseImpl.kt | 3060601914 |
package com.hanbikan.nook.feature.todo
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.hanbikan.nook.feature.todo.test", appContext.packageName)
}
} | Nook/feature/todo/src/androidTest/java/com/hanbikan/nook/feature/todo/ExampleInstrumentedTest.kt | 52934271 |
package com.hanbikan.nook.feature.todo
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)
}
} | Nook/feature/todo/src/test/java/com/hanbikan/nook/feature/todo/ExampleUnitTest.kt | 1717602939 |
package com.hanbikan.nook.feature.todo.di
import com.hanbikan.nook.core.domain.usecase.UpdateTasksIfEmptyUseCase
import com.hanbikan.nook.feature.todo.usecase.UpdateTasksIfEmptyUseCaseImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module
@InstallIn(SingletonComponent::class)
interface UpdateTasksIfEmptyUseCaseModule {
@Binds
fun bindsUpdateTasksIfEmptyUseCase(
updateTasksIfEmptyUseCaseImpl: UpdateTasksIfEmptyUseCaseImpl,
): UpdateTasksIfEmptyUseCase
} | Nook/feature/todo/src/main/java/com/hanbikan/nook/feature/todo/di/UpdateTasksIfEmptyUseCaseModule.kt | 2752796243 |
package com.hanbikan.nook.feature.todo
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.hanbikan.nook.core.domain.model.Detail
import com.hanbikan.nook.core.domain.model.Task
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.usecase.AddTaskUseCase
import com.hanbikan.nook.core.domain.usecase.DeleteTaskUseCase
import com.hanbikan.nook.core.domain.usecase.GetActiveUserUseCase
import com.hanbikan.nook.core.domain.usecase.GetAllTasksByUserIdUseCase
import com.hanbikan.nook.core.domain.usecase.SetLastVisitedRouteUseCase
import com.hanbikan.nook.core.domain.usecase.UpdateTaskUseCase
import com.hanbikan.nook.core.domain.usecase.UpdateTasksIfEmptyUseCase
import com.hanbikan.nook.feature.todo.component.AddOrUpdateTaskDialogStatus
import com.hanbikan.nook.feature.todo.navigation.todoScreenRoute
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.mapLatest
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class TodoViewModel @Inject constructor(
setLastVisitedRouteUseCase: SetLastVisitedRouteUseCase,
getAllTasksByUserIdUseCase: GetAllTasksByUserIdUseCase,
private val addTaskUseCase: AddTaskUseCase,
private val updateTaskUseCase: UpdateTaskUseCase,
private val deleteTaskUseCase: DeleteTaskUseCase,
getActiveUserUseCase: GetActiveUserUseCase,
) : ViewModel() {
// Ui state
private val _uiState: MutableStateFlow<TodoUiState> = MutableStateFlow(TodoUiState.Loading)
val uiState = _uiState.asStateFlow()
// Data for UI
val activeUser: StateFlow<User?> = getActiveUserUseCase()
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), null)
@OptIn(ExperimentalCoroutinesApi::class)
val taskList: StateFlow<List<Task>> = activeUser
.flatMapLatest {
if (it == null) {
flowOf(listOf())
} else {
getAllTasksByUserIdUseCase(it.id).onEach { taskList ->
_uiState.value =
if (taskList.isEmpty()) TodoUiState.Success.Empty else TodoUiState.Success.NotEmpty
}
}
}
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), listOf())
@OptIn(ExperimentalCoroutinesApi::class)
val visibleTaskList: StateFlow<List<Task>> = taskList
.mapLatest { taskList ->
taskList.filter { it.isVisible }
}
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), listOf())
@OptIn(ExperimentalCoroutinesApi::class)
val invisibleTaskList: StateFlow<List<Task>> = taskList
.mapLatest { taskList ->
taskList.filter { !it.isVisible }
}
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), listOf())
private val _showsAllItems: MutableStateFlow<Boolean> = MutableStateFlow(false)
val showsAllItems = _showsAllItems.asStateFlow()
// Dialog
private val _addOrUpdateTaskDialogStatus: MutableStateFlow<AddOrUpdateTaskDialogStatus> = MutableStateFlow(AddOrUpdateTaskDialogStatus.Invisible)
val addOrUpdateTaskDialogStatus = _addOrUpdateTaskDialogStatus.asStateFlow()
private val _isDeleteTaskDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isDeleteTaskDialogShown = _isDeleteTaskDialogShown.asStateFlow()
private val _taskIdToDelete: MutableStateFlow<Int?> = MutableStateFlow(null)
private val _isUserDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isUserDialogShown = _isUserDialogShown.asStateFlow()
// Detail dialog
private val _isDetailDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isDetailDialogShown = _isDetailDialogShown.asStateFlow()
private val _detailsToShow: MutableStateFlow<List<Detail>> = MutableStateFlow(listOf())
val detailsToShow = _detailsToShow.asStateFlow()
init {
viewModelScope.launch(Dispatchers.IO) {
setLastVisitedRouteUseCase(todoScreenRoute)
}
}
fun addTask(name: String, isDaily: Boolean, isVisible: Boolean) {
if (name.isEmpty()) return
viewModelScope.launch(Dispatchers.IO) {
activeUser.value?.let {
val task = Task(userId = it.id, name = name, isDaily = isDaily, isVisible = isVisible)
addTaskUseCase(task)
setAddOrUpdateTaskDialogStatus(AddOrUpdateTaskDialogStatus.Invisible)
}
}
}
fun updateTask(name: String, isDaily: Boolean, isVisible: Boolean) {
viewModelScope.launch(Dispatchers.IO) {
val status = addOrUpdateTaskDialogStatus.value
if (status is AddOrUpdateTaskDialogStatus.Update) {
val newTask = status.taskToUpdate.copy(name = name, isDaily = isDaily, isVisible = isVisible)
updateTaskUseCase(newTask)
setAddOrUpdateTaskDialogStatus(AddOrUpdateTaskDialogStatus.Invisible)
}
}
}
fun onLongClickTask(task: Task) {
val updateStatus = AddOrUpdateTaskDialogStatus.Update(task)
setAddOrUpdateTaskDialogStatus(updateStatus)
}
fun onClickDeleteAction(task: Task) {
_taskIdToDelete.value = task.id
switchDeleteTaskDialog()
}
fun onConfirmDeleteTask() {
viewModelScope.launch(Dispatchers.IO) {
_taskIdToDelete.value?.let {
deleteTaskUseCase(it)
switchDeleteTaskDialog()
}
}
}
fun switchTask(task: Task) {
val newTask = task.copy(isDone = !task.isDone)
viewModelScope.launch(Dispatchers.IO) {
updateTaskUseCase(newTask)
}
}
fun switchShowsAllItems() {
_showsAllItems.value = !showsAllItems.value
}
fun setAddOrUpdateTaskDialogStatus(status: AddOrUpdateTaskDialogStatus) {
_addOrUpdateTaskDialogStatus.value = status
}
fun switchDeleteTaskDialog() {
_isDeleteTaskDialogShown.value = !isDeleteTaskDialogShown.value
}
fun switchUserDialog() {
_isUserDialogShown.value = !isUserDialogShown.value
}
fun showDetailDialog(details: List<Detail>) {
_detailsToShow.value = details
_isDetailDialogShown.value = true
}
fun hideDetailDialog() {
_isDetailDialogShown.value = false
_detailsToShow.value = listOf()
}
}
sealed interface TodoUiState {
object Loading : TodoUiState
sealed interface Success : TodoUiState {
object Empty : Success
object NotEmpty : Success
}
} | Nook/feature/todo/src/main/java/com/hanbikan/nook/feature/todo/TodoViewModel.kt | 1900082071 |
package com.hanbikan.nook.feature.todo
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.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.ripple.rememberRipple
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.alpha
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.res.vectorResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.hanbikan.nook.core.designsystem.component.AppBarIcon
import com.hanbikan.nook.core.designsystem.component.FadeAnimatedVisibility
import com.hanbikan.nook.core.designsystem.component.NkDialog
import com.hanbikan.nook.core.designsystem.component.NkText
import com.hanbikan.nook.core.designsystem.component.NkTopAppBar
import com.hanbikan.nook.core.designsystem.component.TitleTextWithSpacer
import com.hanbikan.nook.core.designsystem.theme.Dimens
import com.hanbikan.nook.core.designsystem.theme.NkTheme
import com.hanbikan.nook.core.domain.model.Task
import com.hanbikan.nook.core.ui.ProgressCard
import com.hanbikan.nook.core.ui.TaskCard
import com.hanbikan.nook.core.designsystem.component.SwipeAction
import com.hanbikan.nook.core.designsystem.component.SwipeActions
import com.hanbikan.nook.core.designsystem.getAlphaByEnabled
import com.hanbikan.nook.core.domain.model.Detail
import com.hanbikan.nook.core.ui.DetailDialog
import com.hanbikan.nook.core.ui.UserDialog
import com.hanbikan.nook.core.ui.WelcomeText
import com.hanbikan.nook.feature.todo.component.AddOrUpdateTaskDialog
import com.hanbikan.nook.feature.todo.component.AddOrUpdateTaskDialogStatus
@Composable
fun TodoScreen(
navigateToAddUser: () -> Unit,
navigateToPhone: () -> Unit,
viewModel: TodoViewModel = hiltViewModel(),
) {
val addOrUpdateTaskDialogStatus = viewModel.addOrUpdateTaskDialogStatus.collectAsStateWithLifecycle().value
val isDeleteTaskDialogShown = viewModel.isDeleteTaskDialogShown.collectAsStateWithLifecycle().value
val isUserDialogShown = viewModel.isUserDialogShown.collectAsStateWithLifecycle().value
val isDetailDialogShown = viewModel.isDetailDialogShown.collectAsStateWithLifecycle().value
val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
val activeUser = viewModel.activeUser.collectAsStateWithLifecycle().value
val visibleTaskList = viewModel.visibleTaskList.collectAsStateWithLifecycle().value
val invisibleTaskList = viewModel.invisibleTaskList.collectAsStateWithLifecycle().value
val showsAllItems = viewModel.showsAllItems.collectAsStateWithLifecycle().value
val detailsToShow = viewModel.detailsToShow.collectAsStateWithLifecycle().value
Box {
Column(modifier = Modifier.fillMaxSize()) {
NkTopAppBar(
leftAppBarIcons = listOf(
AppBarIcon.appListAppBarIcon(onClick = navigateToPhone)
),
rightAppBarIcons = listOf(
AppBarIcon.userDialogAppBarIcon(onClick = viewModel::switchUserDialog)
),
)
Box {
FadeAnimatedVisibility(visible = uiState is TodoUiState.Success.NotEmpty) {
TodoScreenSuccess(
userName = activeUser?.name ?: "",
visibleTaskList = visibleTaskList,
invisibleTaskList = invisibleTaskList,
onClickCheckbox = viewModel::switchTask,
onLongClickTask = viewModel::onLongClickTask,
onClickDeleteAction = viewModel::onClickDeleteAction,
showsAllItems = showsAllItems,
switchShowsAllItems = viewModel::switchShowsAllItems,
onClickInfo = viewModel::showDetailDialog
)
}
FadeAnimatedVisibility(visible = uiState is TodoUiState.Success.Empty) {
TodoScreenEmpty()
}
FadeAnimatedVisibility(visible = uiState is TodoUiState.Loading) {}
}
}
FloatingActionButton(
modifier = Modifier
.align(Alignment.BottomEnd)
.padding(Dimens.SpacingLarge),
onClick = { viewModel.setAddOrUpdateTaskDialogStatus(AddOrUpdateTaskDialogStatus.Add) },
containerColor = NkTheme.colorScheme.primary,
) {
Icon(
imageVector = Icons.Default.Add,
contentDescription = stringResource(id = R.string.add_task),
tint = NkTheme.colorScheme.onBackground,
)
}
AddOrUpdateTaskDialog(
status = addOrUpdateTaskDialogStatus,
dismissDialog = { viewModel.setAddOrUpdateTaskDialogStatus(AddOrUpdateTaskDialogStatus.Invisible) },
addTask = viewModel::addTask,
updateTask = viewModel::updateTask,
)
DetailDialog(
visible = isDetailDialogShown,
detailsToShow = detailsToShow,
hideDetailDialog = viewModel::hideDetailDialog
)
NkDialog(
visible = isDeleteTaskDialogShown,
description = stringResource(id = R.string.sure_to_delete_task),
onDismissRequest = viewModel::switchDeleteTaskDialog,
onConfirmation = viewModel::onConfirmDeleteTask
)
UserDialog(
visible = isUserDialogShown,
navigateToAddUser = navigateToAddUser,
onDismissRequest = viewModel::switchUserDialog
)
}
}
@Composable
fun TodoScreenSuccess(
userName: String,
visibleTaskList: List<Task>,
invisibleTaskList: List<Task>,
onClickCheckbox: (Task) -> Unit,
onLongClickTask: (Task) -> Unit,
onClickDeleteAction: (Task) -> Unit,
showsAllItems: Boolean,
switchShowsAllItems: () -> Unit,
onClickInfo: (List<Detail>) -> Unit,
) {
LazyColumn(
modifier = Modifier.padding(Dimens.SideMargin),
) {
item {
WelcomeText(userName = userName)
// Progress card
TitleTextWithSpacer(title = stringResource(id = R.string.progress))
ProgressCard(completableList = visibleTaskList)
// To-do list
TitleTextWithSpacer(title = stringResource(id = R.string.todo)) {
VisibilityButton(
showsAllItems = showsAllItems,
switchShowsAllItems = switchShowsAllItems,
)
}
}
items(visibleTaskList) { item ->
TaskCard(
completable = item,
onClickCheckbox = { onClickCheckbox(item) },
onLongClickTask = { onLongClickTask(item) },
onClickInfo = item.details?.let { { onClickInfo(it) } },
tag = if (item.isDaily) stringResource(id = R.string.daily) else null,
swipeActions = SwipeActions.withSameActions(
action = SwipeAction.deleteAction { onClickDeleteAction(item) }
),
)
}
if (showsAllItems) {
items(invisibleTaskList) { item ->
TaskCard(
completable = item,
onClickCheckbox = { onClickCheckbox(item) },
onLongClickTask = { onLongClickTask(item) },
tag = if (item.isDaily) stringResource(id = R.string.daily) else null,
swipeActions = SwipeActions.withSameActions(
action = SwipeAction.deleteAction { onClickDeleteAction(item) }
),
enabled = false
)
}
}
}
}
@Composable
fun VisibilityButton(
showsAllItems: Boolean,
switchShowsAllItems: () -> Unit,
) {
val size = Dimens.IconExtraSmall
val interactionSource: MutableInteractionSource = remember { MutableInteractionSource() }
Icon(
imageVector = ImageVector.vectorResource(
id = if (showsAllItems) R.drawable.visibility else R.drawable.visibility_off
),
contentDescription = stringResource(
id = if (showsAllItems) R.string.show_all_items else R.string.show_only_visible_items
),
modifier = Modifier
.size(size)
.clickable(
onClick = switchShowsAllItems,
interactionSource = interactionSource,
indication = rememberRipple(
bounded = false,
radius = size
)
)
.alpha(alpha = getAlphaByEnabled(showsAllItems)),
tint = NkTheme.colorScheme.primary
)
}
@Composable
fun TodoScreenEmpty() {
Column(
modifier = Modifier.fillMaxSize(),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
) {
Image(
imageVector = ImageVector.vectorResource(id = R.drawable.no_data),
contentDescription = stringResource(id = R.string.empty_todo_list),
modifier = Modifier.size(Dimens.IconMedium)
)
Spacer(modifier = Modifier.height(Dimens.SpacingLarge))
NkText(
text = stringResource(id = R.string.empty_todo_list),
textAlign = TextAlign.Center,
)
Spacer(modifier = Modifier.height(Dimens.SpacingLarge))
}
}
@Preview
@Composable
fun TodoScreenPreview() {
TodoScreen({}, {})
} | Nook/feature/todo/src/main/java/com/hanbikan/nook/feature/todo/TodoScreen.kt | 3349789425 |
package com.hanbikan.nook.feature.todo.navigation
import androidx.navigation.NavController
import androidx.navigation.NavGraphBuilder
import androidx.navigation.compose.composable
import com.hanbikan.nook.feature.todo.TodoScreen
const val todoScreenRoute = "todo_screen_route"
fun NavGraphBuilder.todoScreen(
navigateToAddUser: () -> Unit,
navigateToPhone: () -> Unit,
) {
composable(
route = todoScreenRoute,
) {
TodoScreen(
navigateToAddUser = navigateToAddUser,
navigateToPhone = navigateToPhone,
)
}
}
fun NavController.navigateToTodo() {
navigate(todoScreenRoute)
} | Nook/feature/todo/src/main/java/com/hanbikan/nook/feature/todo/navigation/TodoNavigation.kt | 972205479 |
package com.hanbikan.nook.feature.todo.component
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
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.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import com.hanbikan.nook.core.designsystem.component.NkCheckboxWithTextSmall
import com.hanbikan.nook.core.designsystem.component.NkDialogWithTextField
import com.hanbikan.nook.core.designsystem.theme.Dimens
import com.hanbikan.nook.core.domain.model.Task
import com.hanbikan.nook.feature.todo.R
@Composable
fun AddOrUpdateTaskDialog(
status: AddOrUpdateTaskDialogStatus,
dismissDialog: () -> Unit,
addTask: (name: String, isDaily: Boolean, isVisible: Boolean) -> Unit,
updateTask: (name: String, isDaily: Boolean, isVisible: Boolean) -> Unit,
) {
val title = when (status) {
is AddOrUpdateTaskDialogStatus.Add -> stringResource(id = R.string.add_task)
is AddOrUpdateTaskDialogStatus.Update -> stringResource(id = R.string.update_task)
is AddOrUpdateTaskDialogStatus.Invisible -> ""
}
var defaultInput = ""
var defaultIsDaily = false
var defaultIsVisible = true
if (status is AddOrUpdateTaskDialogStatus.Update) {
defaultInput = status.taskToUpdate.name
defaultIsDaily = status.taskToUpdate.isDaily
defaultIsVisible = status.taskToUpdate.isVisible
}
var isDaily by remember { mutableStateOf(defaultIsDaily) }
var isVisible by remember { mutableStateOf(defaultIsVisible) }
NkDialogWithTextField(
visible = status !is AddOrUpdateTaskDialogStatus.Invisible,
title = title,
defaultInput = defaultInput,
placeholder = stringResource(id = R.string.add_task_placeholder),
onDismissRequest = dismissDialog,
onConfirmation = { input ->
when (status) {
is AddOrUpdateTaskDialogStatus.Add -> addTask(input, isDaily, isVisible)
is AddOrUpdateTaskDialogStatus.Update -> updateTask(input, isDaily, isVisible)
is AddOrUpdateTaskDialogStatus.Invisible -> {}
}
},
) {
Spacer(modifier = Modifier.height(Dimens.SpacingSmall))
Row(
modifier = Modifier.fillMaxWidth()
) {
NkCheckboxWithTextSmall(
modifier = Modifier.weight(1f),
text = stringResource(id = R.string.repeat_daily),
checked = isDaily,
onCheckedChange = { isDaily = !isDaily },
)
NkCheckboxWithTextSmall(
modifier = Modifier.weight(1f),
text = stringResource(id = R.string.hiding),
checked = !isVisible,
onCheckedChange = { isVisible = !isVisible },
)
}
}
}
sealed interface AddOrUpdateTaskDialogStatus {
object Add: AddOrUpdateTaskDialogStatus
data class Update(val taskToUpdate: Task): AddOrUpdateTaskDialogStatus
object Invisible: AddOrUpdateTaskDialogStatus
}
@Composable
@Preview
fun AddOrUpdateTaskDialogPreview() {
AddOrUpdateTaskDialog(status = AddOrUpdateTaskDialogStatus.Add, {}, { _, _, _-> }, { _, _, _ -> })
} | Nook/feature/todo/src/main/java/com/hanbikan/nook/feature/todo/component/AddOrUpdateTaskDialog.kt | 1631992696 |
package com.hanbikan.nook.feature.todo.model
import android.content.Context
import com.hanbikan.nook.core.domain.model.Detail
import com.hanbikan.nook.core.domain.model.Task
import com.hanbikan.nook.feature.todo.R
fun Task.Companion.createInitialTasks(
userId: Int,
context: Context,
): List<Task> = listOf(
Task(
name = context.getString(R.string.task_name1),
userId = userId,
isDaily = true,
),
Task(
name = context.getString(R.string.task_name2),
userId = userId,
isDaily = true,
),
Task(
name = context.getString(R.string.task_name3),
userId = userId,
isDaily = true,
details = listOf(
Detail(
description = context.getString(R.string.task_detail_description3_1),
imageId = R.drawable.shine_spot
),
Detail(description = context.getString(R.string.task_detail_description3_2))
)
),
Task(
name = context.getString(R.string.task_name4),
userId = userId,
isDaily = true,
),
Task(
name = context.getString(R.string.task_name5),
userId = userId,
isDaily = true,
),
Task(
name = context.getString(R.string.task_name6),
userId = userId,
isDaily = true,
),
) | Nook/feature/todo/src/main/java/com/hanbikan/nook/feature/todo/model/Task.kt | 3700659110 |
package com.hanbikan.nook.feature.todo.usecase
import android.content.Context
import com.hanbikan.nook.core.domain.model.Task
import com.hanbikan.nook.core.domain.repository.TaskRepository
import com.hanbikan.nook.core.domain.usecase.UpdateTasksIfEmptyUseCase
import com.hanbikan.nook.feature.todo.model.createInitialTasks
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.flow.first
import javax.inject.Inject
class UpdateTasksIfEmptyUseCaseImpl @Inject constructor(
private val taskRepository: TaskRepository,
@ApplicationContext private val context: Context,
) : UpdateTasksIfEmptyUseCase {
override suspend fun invoke(userId: Int) {
val tasks = taskRepository.getAllTasksByUserId(userId)
if (tasks.first().isEmpty()) {
val tasksToInsert = Task.createInitialTasks(userId, context)
taskRepository.insertTasks(tasksToInsert)
}
}
} | Nook/feature/todo/src/main/java/com/hanbikan/nook/feature/todo/usecase/UpdateTasksIfEmptyUseCaseImpl.kt | 3403461566 |
package com.hanbikan.nook.feature.profile
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.hanbikan.nook.feature.profile.test", appContext.packageName)
}
} | Nook/feature/profile/src/androidTest/java/com/hanbikan/nook/feature/profile/ExampleInstrumentedTest.kt | 409714858 |
package com.hanbikan.nook.feature.profile
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)
}
} | Nook/feature/profile/src/test/java/com/hanbikan/nook/feature/profile/ExampleUnitTest.kt | 994067211 |
package com.hanbikan.nook.feature.profile.navigation
import androidx.navigation.NavController
import androidx.navigation.NavGraphBuilder
import androidx.navigation.compose.composable
import com.hanbikan.nook.feature.profile.ProfileScreen
const val profileScreenRoute = "profile_screen_route"
fun NavGraphBuilder.profileScreen(
navigateToAddUser: () -> Unit,
navigateToPhone: () -> Unit,
) {
composable(
route = profileScreenRoute,
) {
ProfileScreen(
navigateToAddUser = navigateToAddUser,
navigateToPhone = navigateToPhone,
)
}
}
fun NavController.navigateToProfile() {
navigate(profileScreenRoute)
} | Nook/feature/profile/src/main/java/com/hanbikan/nook/feature/profile/navigation/ProfileNavigation.kt | 700278863 |
package com.hanbikan.nook.feature.profile
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.usecase.GetActiveUserUseCase
import com.hanbikan.nook.core.domain.usecase.UpdateUserUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class ProfileViewModel @Inject constructor(
getActiveUserUseCase: GetActiveUserUseCase,
private val updateUserUseCase: UpdateUserUseCase,
) : ViewModel() {
val activeUser: StateFlow<User?> = getActiveUserUseCase()
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), null)
// Dialog
private val _isUserDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isUserDialogShown = _isUserDialogShown.asStateFlow()
private val _isUpdateNameDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isUpdateNameDialogShown = _isUpdateNameDialogShown.asStateFlow()
private val _isUpdateIslandNameDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isUpdateIslandNameDialogShown = _isUpdateIslandNameDialogShown.asStateFlow()
fun switchUserDialog() {
_isUserDialogShown.value = !isUserDialogShown.value
}
fun switchUpdateNameDialog() {
_isUpdateNameDialogShown.value = !_isUpdateNameDialogShown.value
}
fun switchUpdateIslandNameDialog() {
_isUpdateIslandNameDialogShown.value = !isUpdateIslandNameDialogShown.value
}
fun onConfirmUpdateName(name: String) {
viewModelScope.launch(Dispatchers.IO) {
activeUser.value?.let {
val newUser = it.copy(name = name)
updateUserUseCase(newUser)
}
switchUpdateNameDialog()
}
}
fun onConfirmUpdateIslandName(islandName: String) {
viewModelScope.launch(Dispatchers.IO) {
activeUser.value?.let {
val newUser = it.copy(islandName = islandName)
updateUserUseCase(newUser)
}
switchUpdateIslandNameDialog()
}
}
} | Nook/feature/profile/src/main/java/com/hanbikan/nook/feature/profile/ProfileViewModel.kt | 3519476330 |
package com.hanbikan.nook.feature.profile
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Edit
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.hanbikan.nook.core.designsystem.component.AppBarIcon
import com.hanbikan.nook.core.designsystem.component.NkDialogWithTextField
import com.hanbikan.nook.core.designsystem.component.NkSmallButton
import com.hanbikan.nook.core.designsystem.component.NkText
import com.hanbikan.nook.core.designsystem.component.NkTopAppBar
import com.hanbikan.nook.core.designsystem.component.TitleTextWithSpacer
import com.hanbikan.nook.core.designsystem.theme.Dimens
import com.hanbikan.nook.core.designsystem.theme.NkTheme
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.ui.UserDialog
@Composable
fun ProfileScreen(
navigateToAddUser: () -> Unit,
navigateToPhone: () -> Unit,
viewModel: ProfileViewModel = hiltViewModel(),
) {
val isUserDialogShown = viewModel.isUserDialogShown.collectAsStateWithLifecycle().value
val isUpdateNameDialogShown =
viewModel.isUpdateNameDialogShown.collectAsStateWithLifecycle().value
val isUpdateIslandNameDialogShown =
viewModel.isUpdateIslandNameDialogShown.collectAsStateWithLifecycle().value
val activeUser = viewModel.activeUser.collectAsStateWithLifecycle().value
Box {
Column(modifier = Modifier.fillMaxSize()) {
NkTopAppBar(
leftAppBarIcons = listOf(
AppBarIcon.appListAppBarIcon(onClick = navigateToPhone)
),
rightAppBarIcons = listOf(
AppBarIcon.userDialogAppBarIcon(onClick = viewModel::switchUserDialog)
),
)
Column(
modifier = Modifier.padding(Dimens.SideMargin),
) {
NkText(
text = stringResource(id = R.string.profile),
style = NkTheme.typography.headlineLarge,
fontWeight = FontWeight.Bold,
)
// ์ด๋ฆ
TitleTextWithSpacer(title = stringResource(id = R.string.name)) {
NkSmallButton(
onClick = viewModel::switchUpdateNameDialog,
imageVector = Icons.Default.Edit,
)
}
NkText(
text = activeUser?.name ?: "",
style = NkTheme.typography.headlineMedium,
)
// ์ฌ ์ด๋ฆ
TitleTextWithSpacer(title = stringResource(id = R.string.island_name)) {
NkSmallButton(
onClick = viewModel::switchUpdateIslandNameDialog,
imageVector = Icons.Default.Edit,
)
}
NkText(
text = activeUser?.islandName ?: "",
style = NkTheme.typography.headlineMedium,
)
// TODO: ๋ฌ์ฑ๋ฅ
}
}
UserDialog(
visible = isUserDialogShown,
navigateToAddUser = navigateToAddUser,
onDismissRequest = viewModel::switchUserDialog
)
NkDialogWithTextField(
visible = isUpdateNameDialogShown,
title = stringResource(id = R.string.update_name_description),
onDismissRequest = viewModel::switchUpdateNameDialog,
onConfirmation = viewModel::onConfirmUpdateName,
maxInputLength = User.NAME_MAX_LENGTH,
)
NkDialogWithTextField(
visible = isUpdateIslandNameDialogShown,
title = stringResource(id = R.string.update_island_name_description),
onDismissRequest = viewModel::switchUpdateIslandNameDialog,
onConfirmation = viewModel::onConfirmUpdateIslandName,
maxInputLength = User.ISLAND_NAME_MAX_LENGTH,
)
}
}
@Composable
@Preview
fun ProfileScreenPreview() {
ProfileScreen(navigateToAddUser = { /*TODO*/ }, navigateToPhone = { /*TODO*/ })
} | Nook/feature/profile/src/main/java/com/hanbikan/nook/feature/profile/ProfileScreen.kt | 2849345943 |
package com.hanbikan.nook.feature.phone
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import org.junit.Assert.*
import org.junit.Test
import org.junit.runner.RunWith
/**
* 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.hanbikan.nook.feature.phone.test", appContext.packageName)
}
} | Nook/feature/phone/src/androidTest/java/com/hanbikan/nook/feature/phone/ExampleInstrumentedTest.kt | 783541521 |
package com.hanbikan.nook.feature.phone
import android.content.Context
import com.hanbikan.nook.core.domain.model.User
import com.hanbikan.nook.core.domain.repository.AppStateRepository
import com.hanbikan.nook.core.domain.repository.TaskRepository
import com.hanbikan.nook.core.domain.repository.TutorialTaskRepository
import com.hanbikan.nook.core.domain.repository.UserRepository
import com.hanbikan.nook.core.domain.usecase.AddUserUseCase
import com.hanbikan.nook.core.domain.usecase.UpdateTasksIfEmptyUseCase
import com.hanbikan.nook.core.domain.usecase.UpdateTutorialTasksIfEmptyUseCase
import com.hanbikan.nook.feature.todo.usecase.UpdateTasksIfEmptyUseCaseImpl
import com.hanbikan.nook.feature.tutorial.usecase.UpdateTutorialTasksIfEmptyUseCaseImpl
import com.nook.core.domain_test.repository.testAppStateRepository
import com.nook.core.domain_test.repository.testTaskRepository
import com.nook.core.domain_test.repository.testTutorialTaskRepository
import com.nook.core.domain_test.repository.testUserRepository
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.test.runTest
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.ArgumentMatchers.anyInt
import org.mockito.Mock
import org.mockito.junit.MockitoJUnitRunner
import org.mockito.kotlin.mock
@RunWith(MockitoJUnitRunner::class)
class AddUserUseCaseTest {
@Mock
lateinit var context: Context
private lateinit var userRepository: UserRepository
private lateinit var appStateRepository: AppStateRepository
private lateinit var taskRepository: TaskRepository
private lateinit var tutorialTaskRepository: TutorialTaskRepository
private lateinit var updateTasksIfEmptyUseCase: UpdateTasksIfEmptyUseCase
private lateinit var updateTutorialTasksIfEmptyUseCase: UpdateTutorialTasksIfEmptyUseCase
private lateinit var useCase: AddUserUseCase
@Before
fun setup() {
context = mock<Context> {
on { getString(anyInt()) }.thenReturn("")
}
userRepository = testUserRepository
appStateRepository = testAppStateRepository
taskRepository = testTaskRepository
tutorialTaskRepository = testTutorialTaskRepository
updateTasksIfEmptyUseCase = UpdateTasksIfEmptyUseCaseImpl(
taskRepository,
context
)
updateTutorialTasksIfEmptyUseCase = UpdateTutorialTasksIfEmptyUseCaseImpl(
tutorialTaskRepository,
context
)
useCase = AddUserUseCase(
userRepository,
appStateRepository,
updateTasksIfEmptyUseCase,
updateTutorialTasksIfEmptyUseCase
)
}
@Test
fun addUser_updateActiveUserIdAndTasksAndTutorialTasks() = runTest {
val userId = userRepository.getAllUsers().first().maxOf { it.id } + 1
val userToAdd = User(
id = userId,
name = "",
islandName = "",
tutorialDay = 0
)
useCase(userToAdd)
// activeUserId ํ์ธ
val currentUserId = appStateRepository.getActiveUserId().first()
assertEquals(userId, currentUserId)
// Task ํ์ธ
val currentTasks = taskRepository.getAllTasksByUserId(userId).first()
assertTrue(currentTasks.isNotEmpty())
// TutorialTask ํ์ธ
val currentTutorialTasks = tutorialTaskRepository.getTutorialTasksByUserId(userId).first()
assertTrue(currentTutorialTasks.isNotEmpty())
}
} | Nook/feature/phone/src/test/java/com/hanbikan/nook/feature/phone/AddUserUseCaseTest.kt | 455198859 |
package com.hanbikan.nook.feature.phone
import org.junit.Assert.assertEquals
import org.junit.Test
/**
* 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)
}
} | Nook/feature/phone/src/test/java/com/hanbikan/nook/feature/phone/ExampleUnitTest.kt | 2602085079 |
package com.hanbikan.nook.feature.phone
import androidx.compose.foundation.Image
import androidx.compose.foundation.clickable
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.aspectRatio
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.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.ripple.rememberRipple
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.hanbikan.nook.core.designsystem.component.AppBarIcon
import com.hanbikan.nook.core.designsystem.component.NkText
import com.hanbikan.nook.core.designsystem.component.NkTopAppBar
import com.hanbikan.nook.core.designsystem.theme.Dimens
import com.hanbikan.nook.core.designsystem.theme.NkTheme
import com.hanbikan.nook.core.ui.NkApp
import com.hanbikan.nook.core.ui.NkAppWithNavigation
import com.hanbikan.nook.core.ui.UserDialog
@Composable
fun PhoneScreen(
nkApps: List<NkAppWithNavigation>,
navigateToAddUser: () -> Unit,
viewModel: PhoneViewModel = hiltViewModel(),
) {
val isUserDialogShown = viewModel.isUserDialogShown.collectAsStateWithLifecycle().value
Box {
Column(
modifier = Modifier.fillMaxSize(),
horizontalAlignment = Alignment.CenterHorizontally,
) {
NkTopAppBar(
rightAppBarIcons = listOf(
AppBarIcon.userDialogAppBarIcon(onClick = viewModel::switchUserDialog),
),
)
NkText(
text = stringResource(id = R.string.phone_screen_title),
style = NkTheme.typography.titleLarge,
)
Spacer(modifier = Modifier.height(Dimens.SpacingMedium))
LazyVerticalGrid(
columns = GridCells.Fixed(3),
modifier = Modifier
.fillMaxWidth()
.padding(Dimens.SideMargin, 0.dp)
) {
items(nkApps) {
Column(
modifier = Modifier
.padding(Dimens.SpacingSmall),
horizontalAlignment = Alignment.CenterHorizontally,
) {
Image(
painter = it.painter,
contentDescription = it.name,
modifier = Modifier
.aspectRatio(1f)
.clip(RoundedCornerShape(Dimens.SpacingExtraLarge))
.clickable(
onClick = {
viewModel.setLastVisitedRoute(it.route)
it.navigate()
},
interactionSource = remember { MutableInteractionSource() },
indication = rememberRipple(
bounded = true,
color = NkTheme.colorScheme.primary,
)
)
)
Spacer(modifier = Modifier.height(Dimens.SpacingSmall))
NkText(text = it.name)
}
}
}
}
UserDialog(
visible = isUserDialogShown,
navigateToAddUser = navigateToAddUser,
onDismissRequest = viewModel::switchUserDialog
)
}
}
@Composable
@Preview
fun PhoneScreenPreview() {
PhoneScreen(
listOf(
NkApp.PROFILE.toNkAppWithNavigation("") {},
NkApp.TUTORIAL.toNkAppWithNavigation("") {},
NkApp.TODO.toNkAppWithNavigation("") {},
),
{}
)
} | Nook/feature/phone/src/main/java/com/hanbikan/nook/feature/phone/PhoneScreen.kt | 4037857143 |
package com.hanbikan.nook.feature.phone
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.hanbikan.nook.core.domain.usecase.SetLastVisitedRouteUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class PhoneViewModel @Inject constructor(
private val setLastVisitedRouteUseCase: SetLastVisitedRouteUseCase,
): ViewModel() {
// Dialog
private val _isUserDialogShown: MutableStateFlow<Boolean> = MutableStateFlow(false)
val isUserDialogShown = _isUserDialogShown.asStateFlow()
fun switchUserDialog() {
_isUserDialogShown.value = !isUserDialogShown.value
}
fun setLastVisitedRoute(route: String) {
viewModelScope.launch(Dispatchers.IO) {
setLastVisitedRouteUseCase(route)
}
}
} | Nook/feature/phone/src/main/java/com/hanbikan/nook/feature/phone/PhoneViewModel.kt | 1569613852 |
package com.hanbikan.nook.feature.phone.navigation
import androidx.navigation.NavController
import androidx.navigation.NavGraphBuilder
import androidx.navigation.NavHostController
import androidx.navigation.compose.composable
import androidx.navigation.navigation
import com.hanbikan.nook.core.ui.NkApp
import com.hanbikan.nook.feature.museum.navigation.museumScreen
import com.hanbikan.nook.feature.museum.navigation.museumScreenRoute
import com.hanbikan.nook.feature.museum.navigation.navigateToMuseum
import com.hanbikan.nook.feature.phone.PhoneScreen
import com.hanbikan.nook.feature.profile.navigation.navigateToProfile
import com.hanbikan.nook.feature.profile.navigation.profileScreen
import com.hanbikan.nook.feature.profile.navigation.profileScreenRoute
import com.hanbikan.nook.feature.todo.navigation.navigateToTodo
import com.hanbikan.nook.feature.todo.navigation.todoScreen
import com.hanbikan.nook.feature.todo.navigation.todoScreenRoute
import com.hanbikan.nook.feature.tutorial.navigation.addUserScreen
import com.hanbikan.nook.feature.tutorial.navigation.navigateToAddUser
import com.hanbikan.nook.feature.tutorial.navigation.navigateToTutorial
import com.hanbikan.nook.feature.tutorial.navigation.tutorialScreen
import com.hanbikan.nook.feature.tutorial.navigation.tutorialScreenRoute
import com.hanbikan.nook.feature.tutorial.navigation.welcomeScreen
const val phoneGraphRoute = "phone_graph"
const val phoneScreenRoute = "phone_screen_route"
fun NavGraphBuilder.phoneGraph(
navController: NavHostController,
startDestination: String,
) {
navigation(
route = phoneGraphRoute,
startDestination = startDestination,
) {
welcomeScreen(
navigateToAddUser = navController::navigateToAddUser,
)
addUserScreen(
navigateUp = navController::navigateUp,
navigateToTutorial = navController::navigateToTutorial
)
phoneScreen(
navigateToProfile = navController::navigateToProfile,
navigateToTutorial = navController::navigateToTutorial,
navigateToTodo = navController::navigateToTodo,
navigateToAddUser = navController::navigateToAddUser,
navigateToMuseum = navController::navigateToMuseum,
)
profileScreen(
navigateToAddUser = navController::navigateToAddUser,
navigateToPhone = navController::navigateToPhone,
)
tutorialScreen(
navigateToAddUser = navController::navigateToAddUser,
navigateToPhone = navController::navigateToPhone,
navigateToTodo = navController::navigateToTodo,
)
todoScreen(
navigateToAddUser = navController::navigateToAddUser,
navigateToPhone = navController::navigateToPhone,
)
museumScreen(
navigateToAddUser = navController::navigateToAddUser,
navigateToPhone = navController::navigateToPhone,
)
}
}
fun NavGraphBuilder.phoneScreen(
navigateToProfile: () -> Unit,
navigateToTutorial: () -> Unit,
navigateToTodo: () -> Unit,
navigateToAddUser: () -> Unit,
navigateToMuseum: () -> Unit,
) {
composable(
route = phoneScreenRoute,
) {
PhoneScreen(
nkApps = listOf(
NkApp.PROFILE.toNkAppWithNavigation(profileScreenRoute, navigateToProfile),
NkApp.TUTORIAL.toNkAppWithNavigation(tutorialScreenRoute, navigateToTutorial),
NkApp.TODO.toNkAppWithNavigation(todoScreenRoute, navigateToTodo),
NkApp.MUSEUM.toNkAppWithNavigation(museumScreenRoute, navigateToMuseum),
),
navigateToAddUser = navigateToAddUser,
)
}
}
fun NavController.navigateToPhone() {
navigate(phoneScreenRoute)
} | Nook/feature/phone/src/main/java/com/hanbikan/nook/feature/phone/navigation/PhoneNavigation.kt | 1921910801 |
package com.hanbikan.nook.feature.museum
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.hanbikan.nook.feature.museum.test", appContext.packageName)
}
} | Nook/feature/museum/src/androidTest/java/com/hanbikan/nook/feature/museum/ExampleInstrumentedTest.kt | 4276094919 |
package com.hanbikan.nook.feature.museum
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)
}
} | Nook/feature/museum/src/test/java/com/hanbikan/nook/feature/museum/ExampleUnitTest.kt | 3351298116 |
package com.hanbikan.nook.feature.museum
import androidx.lifecycle.ViewModel
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
@HiltViewModel
class MuseumViewModel @Inject constructor(
) : ViewModel() {
} | Nook/feature/museum/src/main/java/com/hanbikan/nook/feature/museum/MuseumViewModel.kt | 240460384 |
package com.hanbikan.nook.feature.museum.navigation
import androidx.navigation.NavController
import androidx.navigation.NavGraphBuilder
import androidx.navigation.compose.composable
import com.hanbikan.nook.feature.museum.MuseumScreen
const val museumScreenRoute = "museum_screen_route"
fun NavGraphBuilder.museumScreen(
navigateToAddUser: () -> Unit,
navigateToPhone: () -> Unit,
) {
composable(
route = museumScreenRoute,
) {
MuseumScreen(
navigateToAddUser = navigateToAddUser,
navigateToPhone = navigateToPhone,
)
}
}
fun NavController.navigateToMuseum() {
navigate(museumScreenRoute)
} | Nook/feature/museum/src/main/java/com/hanbikan/nook/feature/museum/navigation/MuseumNavigation.kt | 652219796 |
package com.hanbikan.nook.feature.museum
import androidx.compose.runtime.Composable
import androidx.hilt.navigation.compose.hiltViewModel
@Composable
fun MuseumScreen(
navigateToAddUser: () -> Unit,
navigateToPhone: () -> Unit,
viewModel: MuseumViewModel = hiltViewModel(),
) {
} | Nook/feature/museum/src/main/java/com/hanbikan/nook/feature/museum/MuseumScreen.kt | 3800090730 |
package com.k21091.wearsensing.presentation
import android.content.Intent
import android.content.res.Configuration
import android.util.Log
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.platform.LocalContext
import androidx.wear.compose.material.Chip
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Devices
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.content.ContextCompat.startActivity
import androidx.wear.compose.material.MaterialTheme
import androidx.wear.compose.material.Switch
import androidx.wear.compose.material.Text
import androidx.wear.compose.material.ToggleChip
class ReusableComponents {
@Composable
fun AccToggle(modifier: Modifier = Modifier) {
val globalvariable = GlobalVariable.getInstance()
var checked by remember { mutableStateOf(globalvariable.isAccSensorEnabled) }
ToggleChip(
modifier = modifier,
checked = checked,
toggleControl = {
Switch(
checked = checked,
modifier = Modifier.semantics {
this.contentDescription = if (checked) "On" else "Off"
}
)
},
onCheckedChange = {
checked = it
globalvariable.isAccSensorEnabled = checked
},
label = {
Text(
text = "ๅ ้ๅบฆ",
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
}
)
}
@Composable
fun GyroToggle(modifier: Modifier = Modifier) {
val globalvariable = GlobalVariable.getInstance()
var checked by remember { mutableStateOf(globalvariable.isGyroSensorEnabled) }
ToggleChip(
modifier = modifier,
checked = checked,
toggleControl = {
Switch(
checked = checked,
modifier = Modifier.semantics {
this.contentDescription = if (checked) "On" else "Off"
}
)
},
onCheckedChange = {
checked = it
globalvariable.isGyroSensorEnabled = checked
},
label = {
Text(
text = "ใธใฃใคใญ",
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
}
)
}
@Composable
fun HeartRateToggle(modifier: Modifier = Modifier) {
val globalvariable = GlobalVariable.getInstance()
var checked by remember { mutableStateOf(globalvariable.isHeartRateSensorEnabled) }
ToggleChip(
modifier = modifier,
checked = checked,
toggleControl = {
Switch(
checked = checked,
modifier = Modifier.semantics {
this.contentDescription = if (checked) "On" else "Off"
}
)
},
onCheckedChange = {
checked = it
globalvariable.isHeartRateSensorEnabled = checked
},
label = {
Text(
text = "ๅฟๆ",
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
}
)
}
@Composable
fun LightToggle(modifier: Modifier = Modifier) {
val globalvariable = GlobalVariable.getInstance()
var checked by remember { mutableStateOf(globalvariable.isLightSensorEnabled) }
ToggleChip(
modifier = modifier,
checked = checked,
toggleControl = {
Switch(
checked = checked,
modifier = Modifier.semantics {
this.contentDescription = if (checked) "On" else "Off"
}
)
},
onCheckedChange = {
checked = it
globalvariable.isLightSensorEnabled = checked
},
label = {
Text(
text = "็
งๅบฆ",
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
}
)
}
@Composable
fun SetMultiChip(
modifier: Modifier = Modifier,
iconModifier: Modifier = Modifier
) {
val context = LocalContext.current
Chip(
modifier = modifier,
onClick = {
val intent = Intent(context, MultiSensor::class.java)
startActivity(context, intent, null)
},
label = {
Text(
text = "ไฝฟ็จใปใณใต็ขบๅฎ",
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
},
)
}
@Composable
fun MultiView(sensor: String, modifier: Modifier = Modifier, sensorDataArray: Array<MutableState<String>>) {
Column(
modifier = modifier
) {
Text(
textAlign = TextAlign.Center,
color = MaterialTheme.colors.primary,
text = sensor,
modifier = Modifier.padding(bottom = 4.dp)
)
Text(
textAlign = TextAlign.Left,
color = MaterialTheme.colors.primary,
text = sensorDataArray[0].value,
modifier = Modifier.padding(bottom = 4.dp)
)
Text(
textAlign = TextAlign.Left,
color = MaterialTheme.colors.primary,
text = sensorDataArray[1].value,
modifier = Modifier.padding(bottom = 4.dp)
)
Text(
textAlign = TextAlign.Left,
color = MaterialTheme.colors.primary,
text = sensorDataArray[2].value,
)
}
}
} | WearOS_Sensing/app/src/main/java/com/k21091/wearsensing/presentation/ReusableComponents.kt | 2569590501 |
package com.k21091.wearsensing.presentation
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
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.layout.wrapContentSize
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.wear.compose.material.AutoCenteringParams
import androidx.wear.compose.material.PositionIndicator
import androidx.wear.compose.material.Scaffold
import androidx.wear.compose.material.ScalingLazyColumn
import androidx.wear.compose.material.Text
import androidx.wear.compose.material.TimeText
import androidx.wear.compose.material.Vignette
import androidx.wear.compose.material.VignettePosition
import androidx.wear.compose.material.rememberScalingLazyListState
import androidx.wear.compose.material.scrollAway
import com.k21091.wearsensing.presentation.theme.WearSensingTheme
private var globalvariable = GlobalVariable.getInstance()
class MainActivity : ComponentActivity(){
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
WearApp()
}
}
override fun onResume() {
super.onResume()
globalvariable.isAccSensorEnabled = false
globalvariable.isGyroSensorEnabled = false
globalvariable.isHeartRateSensorEnabled = false
globalvariable.isLightSensorEnabled = false
setContent {
WearApp()
}
}
@Composable
fun WearApp() {
WearSensingTheme {
// TODO: Swap to ScalingLazyListState
val listState = rememberScalingLazyListState()
val contentModifier = Modifier
.fillMaxWidth()
.padding(bottom = 8.dp)
val iconModifier = Modifier
.size(24.dp)
.wrapContentSize(align = Alignment.Center)
/* *************************** Part 4: Wear OS Scaffold *************************** */
// TODO (Start): Create a Scaffold (Wear Version)
Scaffold(
timeText = {
TimeText(modifier = Modifier.scrollAway(listState))
},
vignette = {
// Only show a Vignette for scrollable screens. This code lab only has one screen,
// which is scrollable, so we show it all the time.
Vignette(vignettePosition = VignettePosition.TopAndBottom)
},
positionIndicator = {
PositionIndicator(
scalingLazyListState = listState
)
}
) {
// Modifiers used by our Wear composables.
val contentModifier = Modifier
.fillMaxWidth()
.padding(bottom = 8.dp)
val iconModifier = Modifier
.size(24.dp)
.wrapContentSize(align = Alignment.Center)
/* *************************** Part 3: ScalingLazyColumn *************************** */
ScalingLazyColumn(
modifier = Modifier.fillMaxSize(),
autoCentering = AutoCenteringParams(itemIndex = 0),
state = listState
) {
val reusableComponents = ReusableComponents()
item {
Text("ไฝฟใใปใณใตใผใ",fontSize = 20.sp)
}
item {
Text("้ธใใงใ",fontSize = 20.sp)
}
item { reusableComponents.AccToggle(contentModifier) }
item { reusableComponents.GyroToggle(contentModifier) }
item { reusableComponents.HeartRateToggle(contentModifier) }
item { reusableComponents.LightToggle(contentModifier) }
item { reusableComponents.SetMultiChip(contentModifier) }
}
}
}
}
}
| WearOS_Sensing/app/src/main/java/com/k21091/wearsensing/presentation/MainActivity.kt | 719470769 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.