content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.example.rickandmortyv2compose.features.base
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.ui.Modifier
import com.example.rickandmortyv2compose.features.navigation.Navigation
import com.example.rickandmortyv2compose.ui.theme.RickAndMortyV2ComposeTheme
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
RickAndMortyV2ComposeTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
Navigation()
}
}
}
}
} | RickAndMortyAndroidAppV2Compose/app/src/main/java/com/example/rickandmortyv2compose/features/base/MainActivity.kt | 1551163067 |
package com.example.rickandmortyv2compose.features.base
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
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.tooling.preview.Preview
import androidx.navigation.NavController
import androidx.navigation.compose.rememberNavController
import com.example.rickandmortyv2compose.features.componets.Toolbar
import com.example.rickandmortyv2compose.features.componets.ToolbarConfiguration
import com.example.rickandmortyv2compose.ui.theme.Background
@Composable
fun BaseView(
navController: NavController,
toolbarConfiguration: ToolbarConfiguration = ToolbarConfiguration(),
background: Color = Background,
content: @Composable () -> Unit
) {
Scaffold(
topBar = {
if (toolbarConfiguration.isWithBackIcon) {
Toolbar(
navController = navController, toolbarConfiguration
)
}
}
) { paddingValues ->
Column(
Modifier
.fillMaxSize()
.padding(paddingValues)
.background(background)
) {
content()
}
}
}
@Composable
@Preview(showBackground = true)
fun BaseViewPreview() {
BaseView(navController = rememberNavController()) {
Text(text = "I am just trying to be my best software engineer version")
}
} | RickAndMortyAndroidAppV2Compose/app/src/main/java/com/example/rickandmortyv2compose/features/base/BaseComposeView.kt | 1155831165 |
package com.example.inventory
import android.content.Context
import androidx.room.Room
import androidx.room.Room.inMemoryDatabaseBuilder
import androidx.test.core.app.ApplicationProvider
import androidx.test.ext.junit.runners.AndroidJUnit4
import com.example.inventory.data.InventoryDatabase
import com.example.inventory.data.Item
import com.example.inventory.data.ItemDao
import junit.framework.TestCase.assertEquals
import junit.framework.TestCase.assertTrue
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.runBlocking
import org.junit.After
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import java.io.IOException
import kotlin.jvm.Throws
@RunWith(AndroidJUnit4::class)
class ItemDaoTest {
private lateinit var itemDao: ItemDao
private lateinit var inventoryDatabase: InventoryDatabase
@Before
fun createDb() {
val context: Context = ApplicationProvider.getApplicationContext()
inventoryDatabase = inMemoryDatabaseBuilder(context, InventoryDatabase::class.java)
.allowMainThreadQueries()
.build()
itemDao = inventoryDatabase.itemDao()
}
@After
@Throws(IOException::class)
fun closeDb() {
inventoryDatabase.close()
}
private var item1 = Item(1, "Apples", 10.0, 20)
private var item2 = Item(2, "Bananas", 20.0, 98)
private suspend fun addOneItemToDb() {
itemDao.insert(item1)
}
private suspend fun addTwoItemsToDb() {
itemDao.insert(item1)
itemDao.insert(item2)
}
@Test
@Throws(Exception::class)
fun daoInsert_insertsItemIntoDB() = runBlocking {
addOneItemToDb()
val allItems = itemDao.getAllItems().first()
assertEquals(allItems[0], item1)
}
@Test
@Throws(Exception::class)
fun daoGetAllItems_returnsAllItemsFromDB() = runBlocking {
addTwoItemsToDb()
val allItems = itemDao.getAllItems().first()
assertEquals(allItems[0], item1)
assertEquals(allItems[1], item2)
}
@Test
@Throws(Exception::class)
fun daoUpdateItems_updatesItemsInDB() = runBlocking {
addTwoItemsToDb()
itemDao.update(Item(1, "Apples", 15.0, 25))
itemDao.update(Item(2, "Banana", 5.0, 50))
val allItems = itemDao.getAllItems().first()
assertEquals(allItems[0], Item(1, "Apples", 15.0, 25))
assertEquals(allItems[1], Item(2, "Banana", 5.0, 50))
}
@Test
@Throws(Exception::class)
fun daoDeleteItems_deletesAllItemsFromDB() = runBlocking {
addTwoItemsToDb()
itemDao.delete(item1)
itemDao.delete(item2)
val allItems = itemDao.getAllItems().first()
assertTrue(allItems.isEmpty())
}
@Test
@Throws(Exception::class)
fun daoGetItem_returnsItemFromDB() = runBlocking {
addOneItemToDb()
val item = itemDao.getItem(1)
assertEquals(item.first(), item1)
}
} | StockCheck/app/src/androidTest/kotlin/ItemDaoTest.kt | 4022280530 |
package com.example.inventory.ui.home
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.inventory.data.Item
import com.example.inventory.data.ItemsRepository
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
/**
* ViewModel to retrieve all items in the Room database.
*/
class HomeViewModel(itemsRepository: ItemsRepository) : ViewModel() {
val homeUiState : StateFlow<HomeUiState> =
itemsRepository.getAllItemsStream().map { HomeUiState(it) }
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(TIMEOUT_MILLIS),
initialValue = HomeUiState()
)
companion object {
private const val TIMEOUT_MILLIS = 5_000L
}
}
/**
* Ui State for HomeScreen
*/
data class HomeUiState(val itemList: List<Item> = listOf())
| StockCheck/app/src/main/java/com/example/inventory/ui/home/HomeViewModel.kt | 3165493196 |
package com.example.inventory.ui.home
import android.annotation.SuppressLint
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.input.nestedscroll.nestedScroll
import androidx.compose.ui.res.dimensionResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.inventory.InventoryTopAppBar
import com.example.inventory.R
import com.example.inventory.data.Item
import com.example.inventory.ui.AppViewModelProvider
import com.example.inventory.ui.item.formatedPrice
import com.example.inventory.ui.navigation.NavigationDestination
import com.example.inventory.ui.theme.InventoryTheme
object HomeDestination : NavigationDestination {
override val route = "home"
override val titleRes = R.string.app_name
}
/**
* Entry route for Home screen
*/
@OptIn(ExperimentalMaterial3Api::class)
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@Composable
fun HomeScreen(
navigateToItemEntry: () -> Unit,
navigateToItemUpdate: (Int) -> Unit,
modifier: Modifier = Modifier,
viewModel: HomeViewModel = viewModel(factory = AppViewModelProvider.Factory)
) {
val scrollBehavior = TopAppBarDefaults.enterAlwaysScrollBehavior()
val homeUiState by viewModel.homeUiState.collectAsState()
Scaffold(
modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
topBar = {
InventoryTopAppBar(
title = stringResource(HomeDestination.titleRes),
canNavigateBack = false,
scrollBehavior = scrollBehavior
)
},
floatingActionButton = {
FloatingActionButton(
onClick = navigateToItemEntry,
shape = MaterialTheme.shapes.medium,
modifier = Modifier.padding(dimensionResource(id = R.dimen.padding_large))
) {
Icon(
imageVector = Icons.Default.Add,
contentDescription = stringResource(R.string.item_entry_title)
)
}
},
) { innerPadding ->
HomeBody(
itemList = homeUiState.itemList,
onItemClick = navigateToItemUpdate,
modifier = Modifier
.padding(innerPadding)
.fillMaxSize()
)
}
}
@Composable
private fun HomeBody(
itemList: List<Item>, onItemClick: (Int) -> Unit, modifier: Modifier = Modifier
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = modifier
) {
if (itemList.isEmpty()) {
Text(
text = stringResource(R.string.no_item_description),
textAlign = TextAlign.Center,
style = MaterialTheme.typography.titleLarge
)
} else {
InventoryList(
itemList = itemList,
onItemClick = { onItemClick(it.id) },
modifier = Modifier.padding(horizontal = dimensionResource(id = R.dimen.padding_small))
)
}
}
}
@Composable
private fun InventoryList(
itemList: List<Item>, onItemClick: (Item) -> Unit, modifier: Modifier = Modifier
) {
LazyColumn(modifier = modifier) {
items(items = itemList, key = { it.id }) { item ->
InventoryItem(item = item,
modifier = Modifier
.padding(dimensionResource(id = R.dimen.padding_small))
.clickable { onItemClick(item) })
}
}
}
@Composable
private fun InventoryItem(
item: Item, modifier: Modifier = Modifier
) {
Card(
modifier = modifier,
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
) {
Column(
modifier = Modifier.padding(dimensionResource(id = R.dimen.padding_large)),
verticalArrangement = Arrangement.spacedBy(dimensionResource(id = R.dimen.padding_small))
) {
Row(
modifier = Modifier.fillMaxWidth()
) {
Text(
text = item.name,
style = MaterialTheme.typography.titleLarge,
)
Spacer(Modifier.weight(1f))
Text(
text = item.formatedPrice(),
style = MaterialTheme.typography.titleMedium
)
}
Text(
text = stringResource(R.string.in_stock, item.quantity),
style = MaterialTheme.typography.titleMedium
)
}
}
}
@Preview(showBackground = true)
@Composable
fun HomeBodyPreview() {
InventoryTheme {
HomeBody(listOf(
Item(1, "Game", 100.0, 20), Item(2, "Pen", 200.0, 30), Item(3, "TV", 300.0, 50)
), onItemClick = {})
}
}
@Preview(showBackground = true)
@Composable
fun HomeBodyEmptyListPreview() {
InventoryTheme {
HomeBody(listOf(), onItemClick = {})
}
}
@Preview(showBackground = true)
@Composable
fun InventoryItemPreview() {
InventoryTheme {
InventoryItem(
Item(1, "Game", 100.0, 20),
)
}
}
| StockCheck/app/src/main/java/com/example/inventory/ui/home/HomeScreen.kt | 4091096793 |
package com.example.inventory.ui
import android.app.Application
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory
import androidx.lifecycle.createSavedStateHandle
import androidx.lifecycle.viewmodel.CreationExtras
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.inventory.InventoryApplication
import com.example.inventory.ui.home.HomeViewModel
import com.example.inventory.ui.item.ItemDetailsViewModel
import com.example.inventory.ui.item.ItemEditViewModel
import com.example.inventory.ui.item.ItemEntryViewModel
/**
* Provides Factory to create instance of ViewModel for the entire Inventory app
*/
object AppViewModelProvider {
val Factory = viewModelFactory {
// Initializer for ItemEditViewModel
initializer {
ItemEditViewModel(
this.createSavedStateHandle(),
inventoryApplication().container.itemsRepository
)
}
// Initializer for ItemEntryViewModel
initializer {
ItemEntryViewModel(inventoryApplication().container.itemsRepository)
}
// Initializer for ItemDetailsViewModel
initializer {
ItemDetailsViewModel(
this.createSavedStateHandle(),
inventoryApplication().container.itemsRepository
)
}
// Initializer for HomeViewModel
initializer {
HomeViewModel(inventoryApplication().container.itemsRepository)
}
}
}
/**
* Extension function to queries for [Application] object and returns an instance of
* [InventoryApplication].
*/
fun CreationExtras.inventoryApplication(): InventoryApplication =
(this[AndroidViewModelFactory.APPLICATION_KEY] as InventoryApplication)
| StockCheck/app/src/main/java/com/example/inventory/ui/AppViewModelProvider.kt | 3916659223 |
package com.example.inventory.ui.navigation
/**
* Interface to describe the navigation destinations for the app
*/
interface NavigationDestination {
/**
* Unique name to define the path for a composable
*/
val route: String
/**
* String resource id to that contains title to be displayed for the screen.
*/
val titleRes: Int
}
| StockCheck/app/src/main/java/com/example/inventory/ui/navigation/NavigationDestination.kt | 2539647000 |
package com.example.inventory.ui.navigation
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.navigation.NavHostController
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.navArgument
import com.example.inventory.ui.home.HomeDestination
import com.example.inventory.ui.home.HomeScreen
import com.example.inventory.ui.item.ItemDetailsDestination
import com.example.inventory.ui.item.ItemDetailsScreen
import com.example.inventory.ui.item.ItemEditDestination
import com.example.inventory.ui.item.ItemEditScreen
import com.example.inventory.ui.item.ItemEntryDestination
import com.example.inventory.ui.item.ItemEntryScreen
/**
* Provides Navigation graph for the application.
*/
@Composable
fun InventoryNavHost(
navController: NavHostController,
modifier: Modifier = Modifier,
) {
NavHost(
navController = navController, startDestination = HomeDestination.route, modifier = modifier
) {
composable(route = HomeDestination.route) {
HomeScreen(navigateToItemEntry = { navController.navigate(ItemEntryDestination.route) },
navigateToItemUpdate = {
navController.navigate("${ItemDetailsDestination.route}/${it}")
})
}
composable(route = ItemEntryDestination.route) {
ItemEntryScreen(navigateBack = { navController.popBackStack() },
onNavigateUp = { navController.navigateUp() })
}
composable(
route = ItemDetailsDestination.routeWithArgs,
arguments = listOf(navArgument(ItemDetailsDestination.itemIdArg) {
type = NavType.IntType
})
) {
ItemDetailsScreen(
navigateToEditItem =
{
navController.navigate("${ItemEditDestination.route}/$it")
},
navigateBack = { navController.navigateUp() })
}
composable(
route = ItemEditDestination.routeWithArgs,
arguments = listOf(navArgument(ItemEditDestination.itemIdArg) {
type = NavType.IntType
})
) {
ItemEditScreen(navigateBack = { navController.popBackStack() },
onNavigateUp = { navController.navigateUp() })
}
}
}
| StockCheck/app/src/main/java/com/example/inventory/ui/navigation/InventoryNavGraph.kt | 2482109795 |
/*
* Copyright (C) 2023 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.inventory.ui.theme
import androidx.compose.foundation.shape.CutCornerShape
import androidx.compose.material3.Shapes
import androidx.compose.ui.unit.dp
val Shapes = Shapes(
extraSmall = CutCornerShape(topEnd = 8.dp, bottomStart = 8.dp),
small = CutCornerShape(topEnd = 8.dp, bottomStart = 8.dp),
medium = CutCornerShape(topEnd = 16.dp, bottomStart = 16.dp)
)
| StockCheck/app/src/main/java/com/example/inventory/ui/theme/Shape.kt | 634724571 |
/*
* Copyright (C) 2023 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.inventory.ui.theme
import androidx.compose.ui.graphics.Color
val md_theme_light_primary = Color(0xFF6B3DD4)
val md_theme_light_onPrimary = Color(0xFFFFFFFF)
val md_theme_light_primaryContainer = Color(0xFFE9DDFF)
val md_theme_light_onPrimaryContainer = Color(0xFF22005D)
val md_theme_light_secondary = Color(0xFF625B71)
val md_theme_light_onSecondary = Color(0xFFFFFFFF)
val md_theme_light_secondaryContainer = Color(0xFFE8DEF8)
val md_theme_light_onSecondaryContainer = Color(0xFF1E192B)
val md_theme_light_tertiary = Color(0xFF7E5260)
val md_theme_light_onTertiary = Color(0xFFFFFFFF)
val md_theme_light_tertiaryContainer = Color(0xFFFFD9E3)
val md_theme_light_onTertiaryContainer = Color(0xFF31101D)
val md_theme_light_error = Color(0xFFBA1A1A)
val md_theme_light_errorContainer = Color(0xFFFFDAD6)
val md_theme_light_onError = Color(0xFFFFFFFF)
val md_theme_light_onErrorContainer = Color(0xFF410002)
val md_theme_light_background = Color(0xFFF3FEFF)
val md_theme_light_onBackground = Color(0xFF002022)
val md_theme_light_surface = Color(0xFFF3FEFF)
val md_theme_light_onSurface = Color(0xFF002022)
val md_theme_light_surfaceVariant = Color(0xFFE7E0EB)
val md_theme_light_onSurfaceVariant = Color(0xFF49454E)
val md_theme_light_outline = Color(0xFF7A757F)
val md_theme_light_inverseOnSurface = Color(0xFFC3FBFF)
val md_theme_light_inverseSurface = Color(0xFF00373A)
val md_theme_light_inversePrimary = Color(0xFFCFBCFF)
val md_theme_light_surfaceTint = Color(0xFF6B3DD4)
val md_theme_light_outlineVariant = Color(0xFFCAC4CF)
val md_theme_light_scrim = Color(0xFF000000)
val md_theme_dark_primary = Color(0xFFCFBCFF)
val md_theme_dark_onPrimary = Color(0xFF3A0092)
val md_theme_dark_primaryContainer = Color(0xFF531BBC)
val md_theme_dark_onPrimaryContainer = Color(0xFFE9DDFF)
val md_theme_dark_secondary = Color(0xFFCBC2DB)
val md_theme_dark_onSecondary = Color(0xFF332D41)
val md_theme_dark_secondaryContainer = Color(0xFF4A4458)
val md_theme_dark_onSecondaryContainer = Color(0xFFE8DEF8)
val md_theme_dark_tertiary = Color(0xFFEFB8C8)
val md_theme_dark_onTertiary = Color(0xFF4A2532)
val md_theme_dark_tertiaryContainer = Color(0xFF633B48)
val md_theme_dark_onTertiaryContainer = Color(0xFFFFD9E3)
val md_theme_dark_error = Color(0xFFFFB4AB)
val md_theme_dark_errorContainer = Color(0xFF93000A)
val md_theme_dark_onError = Color(0xFF690005)
val md_theme_dark_onErrorContainer = Color(0xFFFFDAD6)
val md_theme_dark_background = Color(0xFF002022)
val md_theme_dark_onBackground = Color(0xFF70F5FF)
val md_theme_dark_surface = Color(0xFF002022)
val md_theme_dark_onSurface = Color(0xFF70F5FF)
val md_theme_dark_surfaceVariant = Color(0xFF49454E)
val md_theme_dark_onSurfaceVariant = Color(0xFFCAC4CF)
val md_theme_dark_outline = Color(0xFF948F99)
val md_theme_dark_inverseOnSurface = Color(0xFF002022)
val md_theme_dark_inverseSurface = Color(0xFF70F5FF)
val md_theme_dark_inversePrimary = Color(0xFF6B3DD4)
val md_theme_dark_surfaceTint = Color(0xFFCFBCFF)
val md_theme_dark_outlineVariant = Color(0xFF49454E)
val md_theme_dark_scrim = Color(0xFF000000)
| StockCheck/app/src/main/java/com/example/inventory/ui/theme/Color.kt | 3223178890 |
/*
* Copyright (C) 2023 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.inventory.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.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 LightColorScheme = lightColorScheme(
primary = md_theme_light_primary,
onPrimary = md_theme_light_onPrimary,
primaryContainer = md_theme_light_primaryContainer,
onPrimaryContainer = md_theme_light_onPrimaryContainer,
secondary = md_theme_light_secondary,
onSecondary = md_theme_light_onSecondary,
secondaryContainer = md_theme_light_secondaryContainer,
onSecondaryContainer = md_theme_light_onSecondaryContainer,
tertiary = md_theme_light_tertiary,
onTertiary = md_theme_light_onTertiary,
tertiaryContainer = md_theme_light_tertiaryContainer,
onTertiaryContainer = md_theme_light_onTertiaryContainer,
error = md_theme_light_error,
errorContainer = md_theme_light_errorContainer,
onError = md_theme_light_onError,
onErrorContainer = md_theme_light_onErrorContainer,
background = md_theme_light_background,
onBackground = md_theme_light_onBackground,
surface = md_theme_light_surface,
onSurface = md_theme_light_onSurface,
surfaceVariant = md_theme_light_surfaceVariant,
onSurfaceVariant = md_theme_light_onSurfaceVariant,
outline = md_theme_light_outline,
inverseOnSurface = md_theme_light_inverseOnSurface,
inverseSurface = md_theme_light_inverseSurface,
inversePrimary = md_theme_light_inversePrimary,
surfaceTint = md_theme_light_surfaceTint,
outlineVariant = md_theme_light_outlineVariant,
scrim = md_theme_light_scrim,
)
private val DarkColorScheme = darkColorScheme(
primary = md_theme_dark_primary,
onPrimary = md_theme_dark_onPrimary,
primaryContainer = md_theme_dark_primaryContainer,
onPrimaryContainer = md_theme_dark_onPrimaryContainer,
secondary = md_theme_dark_secondary,
onSecondary = md_theme_dark_onSecondary,
secondaryContainer = md_theme_dark_secondaryContainer,
onSecondaryContainer = md_theme_dark_onSecondaryContainer,
tertiary = md_theme_dark_tertiary,
onTertiary = md_theme_dark_onTertiary,
tertiaryContainer = md_theme_dark_tertiaryContainer,
onTertiaryContainer = md_theme_dark_onTertiaryContainer,
error = md_theme_dark_error,
errorContainer = md_theme_dark_errorContainer,
onError = md_theme_dark_onError,
onErrorContainer = md_theme_dark_onErrorContainer,
background = md_theme_dark_background,
onBackground = md_theme_dark_onBackground,
surface = md_theme_dark_surface,
onSurface = md_theme_dark_onSurface,
surfaceVariant = md_theme_dark_surfaceVariant,
onSurfaceVariant = md_theme_dark_onSurfaceVariant,
outline = md_theme_dark_outline,
inverseOnSurface = md_theme_dark_inverseOnSurface,
inverseSurface = md_theme_dark_inverseSurface,
inversePrimary = md_theme_dark_inversePrimary,
surfaceTint = md_theme_dark_surfaceTint,
outlineVariant = md_theme_dark_outlineVariant,
scrim = md_theme_dark_scrim,
)
@Composable
fun InventoryTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
// Dynamic color in this app is turned off for learning purposes
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
if (darkTheme) {
window.statusBarColor = colorScheme.primary.toArgb()
} else {
window.statusBarColor = Color.Transparent.toArgb()
}
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = !darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
shapes = Shapes,
content = content
)
}
| StockCheck/app/src/main/java/com/example/inventory/ui/theme/Theme.kt | 689949842 |
package com.example.inventory.ui.item
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import com.example.inventory.data.Item
import com.example.inventory.data.ItemsRepository
import java.text.NumberFormat
/**
* ViewModel to validate and insert items in the Room database.
*/
class ItemEntryViewModel(private val itemsRepository: ItemsRepository) : ViewModel() {
/**
* Holds current item ui state
*/
var itemUiState by mutableStateOf(ItemUiState())
private set
/**
* Updates the [itemUiState] with the value provided in the argument. This method also triggers
* a validation for input values.
*/
fun updateUiState(itemDetails: ItemDetails) {
itemUiState =
ItemUiState(itemDetails = itemDetails, isEntryValid = validateInput(itemDetails))
}
suspend fun saveItem() {
if (validateInput()) {
itemsRepository.insertItem(itemUiState.itemDetails.toItem())
}
}
private fun validateInput(uiState: ItemDetails = itemUiState.itemDetails): Boolean {
return with(uiState) {
name.isNotBlank() && price.isNotBlank() && quantity.isNotBlank()
}
}
}
/**
* Represents Ui State for an Item.
*/
data class ItemUiState(
val itemDetails: ItemDetails = ItemDetails(),
val isEntryValid: Boolean = false
)
data class ItemDetails(
val id: Int = 0,
val name: String = "",
val price: String = "",
val quantity: String = "",
)
/**
* Extension function to convert [ItemDetails] to [Item]. If the value of [ItemDetails.price] is
* not a valid [Double], then the price will be set to 0.0. Similarly if the value of
* [ItemDetails.quantity] is not a valid [Int], then the quantity will be set to 0
*/
fun ItemDetails.toItem(): Item = Item(
id = id,
name = name,
price = price.toDoubleOrNull() ?: 0.0,
quantity = quantity.toIntOrNull() ?: 0
)
fun Item.formatedPrice(): String {
return NumberFormat.getCurrencyInstance().format(price)
}
/**
* Extension function to convert [Item] to [ItemUiState]
*/
fun Item.toItemUiState(isEntryValid: Boolean = false): ItemUiState = ItemUiState(
itemDetails = this.toItemDetails(),
isEntryValid = isEntryValid
)
/**
* Extension function to convert [Item] to [ItemDetails]
*/
fun Item.toItemDetails(): ItemDetails = ItemDetails(
id = id,
name = name,
price = price.toString(),
quantity = quantity.toString()
)
| StockCheck/app/src/main/java/com/example/inventory/ui/item/ItemEntryViewModel.kt | 815180513 |
package com.example.inventory.ui.item
import androidx.annotation.StringRes
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.dimensionResource
import androidx.compose.ui.res.integerResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.inventory.InventoryTopAppBar
import com.example.inventory.R
import com.example.inventory.data.Item
import com.example.inventory.ui.AppViewModelProvider
import com.example.inventory.ui.navigation.NavigationDestination
import com.example.inventory.ui.theme.InventoryTheme
import kotlinx.coroutines.launch
object ItemDetailsDestination : NavigationDestination {
override val route = "item_details"
override val titleRes = R.string.item_detail_title
const val itemIdArg = "itemId"
val routeWithArgs = "$route/{$itemIdArg}"
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ItemDetailsScreen(
modifier: Modifier = Modifier,
navigateToEditItem: (Int) -> Unit,
navigateBack: () -> Unit,
viewModel: ItemDetailsViewModel = viewModel(factory = AppViewModelProvider.Factory),
) {
val uiState = viewModel.uiState.collectAsState()
val coroutineScope = rememberCoroutineScope()
Scaffold(
topBar = {
InventoryTopAppBar(
title = stringResource(ItemDetailsDestination.titleRes),
canNavigateBack = true,
navigateUp = navigateBack
)
},
floatingActionButton = {
FloatingActionButton(
onClick = { navigateToEditItem(uiState.value.itemDetails.id) },
shape = MaterialTheme.shapes.medium,
modifier = Modifier.padding(dimensionResource(id = R.dimen.padding_large))
) {
Icon(
imageVector = Icons.Default.Edit,
contentDescription = stringResource(R.string.edit_item_title),
)
}
}, modifier = modifier
) { innerPadding ->
ItemDetailsBody(
itemUiState = uiState.value,
onSellItem = { viewModel.reduceQuantityByOne() },
onDelete = {
coroutineScope.launch {
viewModel.deleteItem()
navigateBack()
}
},
modifier = Modifier
.padding(innerPadding)
.verticalScroll(rememberScrollState())
)
}
}
@Composable
private fun ItemDetailsBody(
itemUiState: ItemDetailsUiState,
onSellItem: () -> Unit,
onDelete: () -> Unit,
modifier: Modifier = Modifier
) {
Column(
modifier = modifier.padding(dimensionResource(id = R.dimen.padding_medium)),
verticalArrangement = Arrangement.spacedBy(dimensionResource(id = R.dimen.padding_medium))
) {
var deleteConfirmationRequired by rememberSaveable { mutableStateOf(false) }
ItemDetails(
item = itemUiState.itemDetails.toItem(),
modifier = Modifier.fillMaxWidth()
)
Button(
onClick = onSellItem,
modifier = Modifier.fillMaxWidth(),
shape = MaterialTheme.shapes.small,
enabled = true
) {
Text(stringResource(R.string.sell))
}
OutlinedButton(
onClick = { deleteConfirmationRequired = true },
shape = MaterialTheme.shapes.small,
modifier = Modifier.fillMaxWidth()
) {
Text(stringResource(R.string.delete))
}
if (deleteConfirmationRequired) {
DeleteConfirmationDialog(
onDeleteConfirm = {
deleteConfirmationRequired = false
onDelete()
},
onDeleteCancel = { deleteConfirmationRequired = false },
modifier = Modifier.padding(dimensionResource(id = R.dimen.padding_medium))
)
}
}
}
@Composable
fun ItemDetails(
item: Item,
modifier: Modifier = Modifier
) {
Card(
modifier = modifier, colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.primaryContainer,
contentColor = MaterialTheme.colorScheme.onPrimaryContainer
)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(dimensionResource(id = R.dimen.padding_medium)),
verticalArrangement = Arrangement.spacedBy(dimensionResource(id = R.dimen.padding_medium))
) {
ItemDetailsRow(
labelResID = R.string.item,
itemDetail = item.name,
modifier = Modifier.padding(
horizontal = dimensionResource(
id = R.dimen
.padding_medium
)
)
)
ItemDetailsRow(
labelResID = R.string.quantity_in_stock,
itemDetail = item.quantity.toString(),
modifier = Modifier.padding(
horizontal = dimensionResource(
id = R.dimen
.padding_medium
)
)
)
ItemDetailsRow(
labelResID = R.string.price,
itemDetail = item.formatedPrice(),
modifier = Modifier.padding(
horizontal = dimensionResource(
id = R.dimen
.padding_medium
)
)
)
}
}
}
@Composable
private fun ItemDetailsRow(
@StringRes labelResID: Int,
itemDetail: String,
modifier: Modifier = Modifier
) {
Row(modifier = modifier) {
Text(stringResource(labelResID))
Spacer(modifier = Modifier.weight(1f))
Text(text = itemDetail, fontWeight = FontWeight.Bold)
}
}
@Composable
private fun DeleteConfirmationDialog(
onDeleteConfirm: () -> Unit,
onDeleteCancel: () -> Unit,
modifier: Modifier = Modifier
) {
AlertDialog(onDismissRequest = { /* Do nothing */ },
title = { Text(stringResource(R.string.attention)) },
text = { Text(stringResource(R.string.delete_question)) },
modifier = modifier,
dismissButton = {
TextButton(onClick = onDeleteCancel) {
Text(stringResource(R.string.no))
}
},
confirmButton = {
TextButton(onClick = onDeleteConfirm) {
Text(stringResource(R.string.yes))
}
})
}
@Preview
@Composable
fun ItemDetailsRowPreview() {
InventoryTheme {
ItemDetailsRow(
labelResID = integerResource(androidx.core.R.integer.status_bar_notification_info_maxnum),
itemDetail = "a"
)
}
}
@Preview(showBackground = true)
@Composable
fun ItemDetailsScreenPreview() {
InventoryTheme {
ItemDetailsBody(
ItemDetailsUiState(
outOfStock = true,
itemDetails = ItemDetails(1, "Pen", "$100", "10")
),
onSellItem = {},
onDelete = {}
)
}
}
| StockCheck/app/src/main/java/com/example/inventory/ui/item/ItemDetailsScreen.kt | 3287535505 |
package com.example.inventory.ui.item
import androidx.compose.runtime.rememberCoroutineScope
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.inventory.data.ItemsRepository
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
/**
* ViewModel to retrieve, update and delete an item from the [ItemsRepository]'s data source.
*/
class ItemDetailsViewModel(
savedStateHandle: SavedStateHandle,
private val itemsRepository: ItemsRepository
) : ViewModel() {
private val itemId: Int = checkNotNull(savedStateHandle[ItemDetailsDestination.itemIdArg])
val uiState: StateFlow<ItemDetailsUiState> =
itemsRepository.getItemStream(itemId)
.filterNotNull()
.map {
ItemDetailsUiState(outOfStock = it.quantity <= 0, itemDetails = it.toItemDetails())
}.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(TIMEOUT_MILLIS),
initialValue = ItemDetailsUiState()
)
companion object {
private const val TIMEOUT_MILLIS = 5_000L
}
fun reduceQuantityByOne() {
viewModelScope.launch {
val currentItem = uiState.value.toItem()
if (currentItem.quantity > 0) {
itemsRepository.updateItem(currentItem.copy(quantity = currentItem.quantity - 1))
}
}
}
suspend fun deleteItem() {
itemsRepository.deleteItem(uiState.value.toItem())
}
}
/**
* UI state for ItemDetailsScreen
*/
data class ItemDetailsUiState(
val outOfStock: Boolean = true,
val itemDetails: ItemDetails = ItemDetails()
)
| StockCheck/app/src/main/java/com/example/inventory/ui/item/ItemDetailsViewModel.kt | 3718043866 |
package com.example.inventory.ui.item
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.inventory.data.ItemsRepository
import kotlinx.coroutines.launch
import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.flow.first
/**
* ViewModel to retrieve and update an item from the [ItemsRepository]'s data source.
*/
class ItemEditViewModel(
savedStateHandle: SavedStateHandle,
private val itemsRepository: ItemsRepository
) : ViewModel() {
init {
viewModelScope.launch {
itemUiState = itemsRepository.getItemStream(itemId)
.filterNotNull()//In this launch block, you add a filter to return a flow that only contains values that are not null
.first()
.toItemUiState(true)
}
}
/**
* Holds current item ui state
*/
var itemUiState by mutableStateOf(ItemUiState())
private set
private val itemId: Int = checkNotNull(savedStateHandle[ItemEditDestination.itemIdArg])
private fun validateInput(uiState: ItemDetails = itemUiState.itemDetails): Boolean {
return with(uiState) {
name.isNotBlank() && price.isNotBlank() && quantity.isNotBlank()
}
}
fun updateUiState(itemDetails: ItemDetails) {
itemUiState =
ItemUiState(
itemDetails = itemDetails,
isEntryValid = validateInput(itemDetails)
)
}
suspend fun updateItem() {
if (validateInput(itemUiState.itemDetails)) {
itemsRepository.updateItem(itemUiState.itemDetails.toItem())
}
}
} | StockCheck/app/src/main/java/com/example/inventory/ui/item/ItemEditViewModel.kt | 881626674 |
package com.example.inventory.ui.item
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.OutlinedTextFieldDefaults
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.dimensionResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.tooling.preview.Preview
import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.inventory.InventoryTopAppBar
import com.example.inventory.R
import com.example.inventory.ui.AppViewModelProvider
import com.example.inventory.ui.navigation.NavigationDestination
import com.example.inventory.ui.theme.InventoryTheme
import kotlinx.coroutines.launch
import java.util.Currency
import java.util.Locale
object ItemEntryDestination : NavigationDestination {
override val route = "item_entry"
override val titleRes = R.string.item_entry_title
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ItemEntryScreen(
navigateBack: () -> Unit,
onNavigateUp: () -> Unit,
canNavigateBack: Boolean = true,
viewModel: ItemEntryViewModel = viewModel(factory = AppViewModelProvider.Factory)
) {
val coroutineScope = rememberCoroutineScope()
Scaffold(
topBar = {
InventoryTopAppBar(
title = stringResource(ItemEntryDestination.titleRes),
canNavigateBack = canNavigateBack,
navigateUp = onNavigateUp
)
}
) { innerPadding ->
ItemEntryBody(
itemUiState = viewModel.itemUiState,
onItemValueChange = viewModel::updateUiState,
onSaveClick = {
coroutineScope.launch {
viewModel.saveItem()
navigateBack()
}
},
modifier = Modifier
.padding(innerPadding)
.verticalScroll(rememberScrollState())
.fillMaxWidth()
)
}
}
@Composable
fun ItemEntryBody(
itemUiState: ItemUiState,
onItemValueChange: (ItemDetails) -> Unit,
onSaveClick: () -> Unit,
modifier: Modifier = Modifier
) {
Column(
verticalArrangement = Arrangement.spacedBy(dimensionResource(id = R.dimen.padding_large)),
modifier = modifier.padding(dimensionResource(id = R.dimen.padding_medium))
) {
ItemInputForm(
itemDetails = itemUiState.itemDetails,
onValueChange = onItemValueChange,
modifier = Modifier.fillMaxWidth()
)
Button(
onClick = onSaveClick,
enabled = itemUiState.isEntryValid,
shape = MaterialTheme.shapes.small,
modifier = Modifier.fillMaxWidth()
) {
Text(stringResource(R.string.save_action))
}
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ItemInputForm(
itemDetails: ItemDetails,
modifier: Modifier = Modifier,
onValueChange: (ItemDetails) -> Unit = {},
enabled: Boolean = true
) {
Column(
modifier = modifier,
verticalArrangement = Arrangement.spacedBy(dimensionResource(id = R.dimen.padding_medium))
) {
OutlinedTextField(
value = itemDetails.name,
onValueChange = { onValueChange(itemDetails.copy(name = it)) },
label = { Text(stringResource(R.string.item_name_req)) },
colors = OutlinedTextFieldDefaults.colors(
focusedContainerColor = MaterialTheme.colorScheme.secondaryContainer,
unfocusedContainerColor = MaterialTheme.colorScheme.secondaryContainer,
disabledContainerColor = MaterialTheme.colorScheme.secondaryContainer,
),
modifier = Modifier.fillMaxWidth(),
enabled = enabled,
singleLine = true
)
OutlinedTextField(
value = itemDetails.price,
onValueChange = { onValueChange(itemDetails.copy(price = it)) },
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
label = { Text(stringResource(R.string.item_price_req)) },
colors = OutlinedTextFieldDefaults.colors(
focusedContainerColor = MaterialTheme.colorScheme.secondaryContainer,
unfocusedContainerColor = MaterialTheme.colorScheme.secondaryContainer,
disabledContainerColor = MaterialTheme.colorScheme.secondaryContainer,
),
leadingIcon = { Text(Currency.getInstance(Locale.getDefault()).symbol) },
modifier = Modifier.fillMaxWidth(),
enabled = enabled,
singleLine = true
)
OutlinedTextField(
value = itemDetails.quantity,
onValueChange = { onValueChange(itemDetails.copy(quantity = it)) },
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
label = { Text(stringResource(R.string.quantity_req)) },
colors = OutlinedTextFieldDefaults.colors(
focusedContainerColor = MaterialTheme.colorScheme.secondaryContainer,
unfocusedContainerColor = MaterialTheme.colorScheme.secondaryContainer,
disabledContainerColor = MaterialTheme.colorScheme.secondaryContainer,
),
modifier = Modifier.fillMaxWidth(),
enabled = enabled,
singleLine = true
)
if (enabled) {
Text(
text = stringResource(R.string.required_fields),
modifier = Modifier.padding(start = dimensionResource(id = R.dimen.padding_medium))
)
}
}
}
@Preview(showBackground = true)
@Composable
private fun ItemEntryScreenPreview() {
InventoryTheme {
ItemEntryBody(itemUiState = ItemUiState(
ItemDetails(
name = "Item name", price = "10.00", quantity = "5"
)
), onItemValueChange = {}, onSaveClick = {})
}
}
| StockCheck/app/src/main/java/com/example/inventory/ui/item/ItemEntryScreen.kt | 2822052769 |
package com.example.inventory.ui.item
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Scaffold
import androidx.compose.runtime.Composable
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.inventory.InventoryTopAppBar
import com.example.inventory.R
import com.example.inventory.ui.AppViewModelProvider
import com.example.inventory.ui.navigation.NavigationDestination
import com.example.inventory.ui.theme.InventoryTheme
import kotlinx.coroutines.launch
object ItemEditDestination : NavigationDestination {
override val route = "item_edit"
override val titleRes = R.string.edit_item_title
const val itemIdArg = "itemId"
val routeWithArgs = "$route/{$itemIdArg}"
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ItemEditScreen(
navigateBack: () -> Unit,
onNavigateUp: () -> Unit,
modifier: Modifier = Modifier,
viewModel: ItemEditViewModel = viewModel(factory = AppViewModelProvider.Factory)
) {
val coroutineScope = rememberCoroutineScope()
Scaffold(
topBar = {
InventoryTopAppBar(
title = stringResource(ItemEditDestination.titleRes),
canNavigateBack = true,
navigateUp = onNavigateUp
)
},
modifier = modifier
) { innerPadding ->
ItemEntryBody(
itemUiState = viewModel.itemUiState,
onItemValueChange = viewModel::updateUiState,
onSaveClick = {
coroutineScope.launch {
viewModel.updateItem()
navigateBack()
}
},
modifier = Modifier.padding(innerPadding)
)
}
}
@Preview(showBackground = true)
@Composable
fun ItemEditScreenPreview() {
InventoryTheme {
ItemEditScreen(navigateBack = { /*Do nothing*/ }, onNavigateUp = { /*Do nothing*/ })
}
}
| StockCheck/app/src/main/java/com/example/inventory/ui/item/ItemEditScreen.kt | 20694200 |
package com.example.inventory
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.ui.Modifier
import com.example.inventory.ui.theme.InventoryTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
InventoryTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background
) {
InventoryApp()
}
}
}
}
}
| StockCheck/app/src/main/java/com/example/inventory/MainActivity.kt | 2479102124 |
package com.example.inventory
import android.app.Application
import com.example.inventory.data.AppContainer
import com.example.inventory.data.AppDataContainer
class InventoryApplication : Application() {
/**
* AppContainer instance used by the rest of classes to obtain dependencies
*/
lateinit var container: AppContainer
override fun onCreate() {
super.onCreate()
container = AppDataContainer(this)
}
}
| StockCheck/app/src/main/java/com/example/inventory/InventoryApplication.kt | 970956739 |
package com.example.inventory.data
import kotlinx.coroutines.flow.Flow
class OfflineItemsRepository(private val itemDao: ItemDao) : ItemsRepository {
override fun getAllItemsStream(): Flow<List<Item>> = itemDao.getAllItems()
override fun getItemStream(id: Int): Flow<Item?> = itemDao.getItem(id)
override suspend fun insertItem(item: Item) = itemDao.insert(item)
override suspend fun deleteItem(item: Item) = itemDao.delete(item)
override suspend fun updateItem(item: Item) = itemDao.update(item)
}
| StockCheck/app/src/main/java/com/example/inventory/data/OfflineItemsRepository.kt | 4140395798 |
package com.example.inventory.data
import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import kotlinx.coroutines.flow.Flow
@Dao
interface ItemDao {
@Insert(onConflict = OnConflictStrategy.IGNORE)
suspend fun insert(item: Item)
@Update
suspend fun update(item: Item)
@Delete
suspend fun delete(item: Item)
@Query("SELECT * from items WHERE id = :id")
fun getItem(id: Int): Flow<Item>
@Query("SELECT * from items ORDER BY name ASC")
fun getAllItems(): Flow<List<Item>>
}
| StockCheck/app/src/main/java/com/example/inventory/data/ItemDao.kt | 3800320983 |
package com.example.inventory.data
import androidx.room.Entity
import androidx.room.PrimaryKey
/**
* Entity data class represents a single row in the database.
*/
@Entity(tableName = "items")
data class Item(
@PrimaryKey(autoGenerate = true)
val id: Int = 0,
val name: String,
val price: Double,
val quantity: Int
)
| StockCheck/app/src/main/java/com/example/inventory/data/Item.kt | 4077189430 |
package com.example.inventory.data
import kotlinx.coroutines.flow.Flow
/**
* Repository that provides insert, update, delete, and retrieve of [Item] from a given data source.
*/
interface ItemsRepository {
/**
* Retrieve all the items from the the given data source.
*/
fun getAllItemsStream(): Flow<List<Item>>
/**
* Retrieve an item from the given data source that matches with the [id].
*/
fun getItemStream(id: Int): Flow<Item?>
/**
* Insert item in the data source
*/
suspend fun insertItem(item: Item)
/**
* Delete item from the data source
*/
suspend fun deleteItem(item: Item)
/**
* Update item in the data source
*/
suspend fun updateItem(item: Item)
}
| StockCheck/app/src/main/java/com/example/inventory/data/ItemsRepository.kt | 2043176709 |
package com.example.inventory.data
import android.content.Context
/**
* App container for Dependency injection.
*/
interface AppContainer {
val itemsRepository: ItemsRepository
}
/**
* [AppContainer] implementation that provides instance of [OfflineItemsRepository]
*/
class AppDataContainer(private val context: Context) : AppContainer {
/**
* Implementation for [ItemsRepository]
*/
override val itemsRepository: ItemsRepository by lazy {
OfflineItemsRepository(InventoryDatabase.getDatabase(context).itemDao())
}
}
| StockCheck/app/src/main/java/com/example/inventory/data/AppContainer.kt | 2511871268 |
package com.example.inventory.data
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
@Database(entities = [Item::class], version = 1, exportSchema = false)
abstract class InventoryDatabase : RoomDatabase() {
abstract fun itemDao(): ItemDao
companion object {
@Volatile
private var Instance: InventoryDatabase? = null
fun getDatabase(context: Context): InventoryDatabase {
// if the Instance is not null, return it, otherwise create a new database instance.
return Instance ?: synchronized(this) {
Room.databaseBuilder(context, InventoryDatabase::class.java, "item_database")
.build().also { Instance = it }
}
}
}
}
| StockCheck/app/src/main/java/com/example/inventory/data/InventoryDatabase.kt | 3257546420 |
package com.example.inventory
import android.annotation.SuppressLint
import androidx.compose.material.icons.Icons.Filled
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material3.CenterAlignedTopAppBar
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBarScrollBehavior
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.navigation.NavHostController
import androidx.navigation.compose.rememberNavController
import com.example.inventory.R.string
import com.example.inventory.ui.navigation.InventoryNavHost
/**
* Top level composable that represents screens for the application.
*/
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@Composable
fun InventoryApp(navController: NavHostController = rememberNavController()) {
InventoryNavHost(navController = navController)
}
/**
* App bar to display title and conditionally display the back navigation.
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun InventoryTopAppBar(
title: String,
canNavigateBack: Boolean,
modifier: Modifier = Modifier,
scrollBehavior: TopAppBarScrollBehavior? = null,
navigateUp: () -> Unit = {}
) {
CenterAlignedTopAppBar(title = { Text(title) },
modifier = modifier,
scrollBehavior = scrollBehavior,
navigationIcon = {
if (canNavigateBack) {
IconButton(onClick = navigateUp) {
Icon(
imageVector = Filled.ArrowBack,
contentDescription = stringResource(string.back_button)
)
}
}
})
}
| StockCheck/app/src/main/java/com/example/inventory/InventoryApp.kt | 2327427723 |
package net.sharplab.epubtranslator.core.repository
import io.quarkus.test.junit.QuarkusTest
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertDoesNotThrow
import jakarta.inject.Inject
@QuarkusTest
internal class TranslationMemoryRepositoryTest {
@Inject
private lateinit var translationMemoryRepository: TranslationMemoryRepository
@Test
fun findAll_test(){
assertDoesNotThrow {
translationMemoryRepository.findAll()
}
}
@Test
fun find_test(){
assertDoesNotThrow {
translationMemoryRepository.find("test", "en", "ja")
}
}
} | nu/src/test/java/net/sharplab/epubtranslator/core/repository/TranslationMemoryRepositoryTest.kt | 106879 |
package net.sharplab.epubtranslator.core.repository
import io.quarkus.hibernate.orm.panache.kotlin.PanacheRepository
import net.sharplab.epubtranslator.core.entity.TranslationMemoryEntity
import jakarta.enterprise.context.ApplicationScoped
@ApplicationScoped
class TranslationMemoryRepository : PanacheRepository<TranslationMemoryEntity> {
fun find(source: String, sourceLang: String, targetLang: String): TranslationMemoryEntity? {
return find("from net.sharplab.epubtranslator.core.entity.TranslationMemoryEntity where source = ?1 and sourceLang = ?2 and targetLang = ?3", source, sourceLang, targetLang).firstResult()
}
}
| nu/src/main/java/net/sharplab/epubtranslator/core/repository/TranslationMemoryRepository.kt | 2218886986 |
package net.sharplab.epubtranslator.core.util
import net.sharplab.epubtranslator.core.service.EPubTranslatorException
import org.w3c.dom.Document
import org.w3c.dom.DocumentFragment
import org.xml.sax.InputSource
import org.xml.sax.SAXException
import java.io.StringReader
import javax.xml.parsers.DocumentBuilder
import javax.xml.parsers.DocumentBuilderFactory
import javax.xml.parsers.ParserConfigurationException
/**
* Utility for Xml handling
*/
object XmlUtils {
private fun createDocumentBuilder(): DocumentBuilder {
val builder: DocumentBuilder
try {
val factory = DocumentBuilderFactory.newDefaultInstance()
factory.isNamespaceAware = true
factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false)
builder = factory.newDocumentBuilder()
} catch (e: ParserConfigurationException) {
throw EPubTranslatorException(e)
}
return builder
}
@JvmStatic
fun parseXmlStringToDocument(xmlString: String): Document {
val inputSource = InputSource(StringReader(xmlString))
return try {
val builder = createDocumentBuilder()
builder.parse(inputSource)
} catch (e: SAXException) {
throw EPubTranslatorException(e)
}
}
/**
* Parse xml string and return as [DocumentFragment].
*
* @param document document that the new [DocumentFragment] belongs
* @param xmlString xml string
* @return [DocumentFragment] represents the xml string
*/
@JvmStatic
fun parseXmlStringToDocumentFragment(document: Document, xmlString: String): DocumentFragment {
return try {
val builder = createDocumentBuilder()
val envelopedXmlString = "<envelope>$xmlString</envelope>"
val parsed = builder.parse(InputSource(StringReader(envelopedXmlString)))
val fragment = parsed.createDocumentFragment()
val children = parsed.documentElement.childNodes
while (children.length > 0) {
fragment.appendChild(children.item(0))
}
document.adoptNode(fragment) as DocumentFragment
} catch (e: SAXException) {
throw EPubTranslatorException(e)
}
}
} | nu/src/main/java/net/sharplab/epubtranslator/core/util/XmlUtils.kt | 4049886169 |
/*
* Copyright 2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sharplab.epubtranslator.core.util
object ArrayUtil {
fun clone(value: ByteArray): ByteArray {
return value.clone()
}
} | nu/src/main/java/net/sharplab/epubtranslator/core/util/ArrayUtil.kt | 2690226409 |
package net.sharplab.epubtranslator.core.driver.translator
class DeepLTranslatorException(message: String?, e: Throwable?) : RuntimeException(message, e)
| nu/src/main/java/net/sharplab/epubtranslator/core/driver/translator/DeepLTranslatorException.kt | 4158292186 |
package net.sharplab.epubtranslator.core.driver.translator
interface Translator {
fun translate(texts: List<String>, srcLang: String, dstLang: String): List<String>
}
| nu/src/main/java/net/sharplab/epubtranslator/core/driver/translator/Translator.kt | 2901698353 |
package net.sharplab.epubtranslator.core.driver.translator
import com.deepl.api.DeepLException
import com.deepl.api.TextResult
import com.deepl.api.TextTranslationOptions
import com.deepl.api.TranslatorOptions
import net.sharplab.epubtranslator.core.service.EPubTranslatorServiceImpl
class DeepLTranslator(apiEndpoint: String, apiKey: String) : Translator {
private val deepLApi : com.deepl.api.Translator;
init {
val translatorOptions = TranslatorOptions()
translatorOptions.serverUrl = apiEndpoint
deepLApi = com.deepl.api.Translator(apiKey,translatorOptions)
}
override fun translate(texts: List<String>, srcLang: String, dstLang: String): List<String> {
if (texts.isEmpty()) {
return emptyList()
}
val translations: List<TextResult>
try {
val textTranslatorOptions = TextTranslationOptions()
textTranslatorOptions.nonSplittingTags = EPubTranslatorServiceImpl.INLINE_ELEMENT_NAMES
textTranslatorOptions.ignoreTags = IGNORE_ELEMENT_NAMES
textTranslatorOptions.tagHandling = "xml"
translations = deepLApi.translateText(texts, srcLang, dstLang, textTranslatorOptions)
} catch (e: DeepLException) {
throw DeepLTranslatorException("DeepL error is thrown", e)
}
return translations.map{ it.text }
}
companion object {
private val IGNORE_ELEMENT_NAMES = listOf("abbr", "b", "cite", "code", "data", "dfn", "kbd", "rp", "rt", "rtc", "ruby", "samp", "time", "var")
}
} | nu/src/main/java/net/sharplab/epubtranslator/core/driver/translator/DeepLTranslator.kt | 4153566604 |
package net.sharplab.epubtranslator.core.driver.epub
import net.sharplab.epubtranslator.core.model.EPubContentFile
import net.sharplab.epubtranslator.core.model.EPubFile
import net.sharplab.epubtranslator.core.model.FileEntry
import net.sharplab.epubtranslator.core.provider.epub.ContentFileProviderNotFoundException
import net.sharplab.epubtranslator.core.provider.epub.EPubContentFileProvider
import java.io.*
import java.util.*
import java.util.zip.ZipInputStream
class EPubReader(ePubContentFileProviders: List<EPubContentFileProvider>) {
private var ePubContentFileProviders: List<EPubContentFileProvider> = Collections.unmodifiableList(ePubContentFileProviders)
fun read(srcFile: File): EPubFile {
val contentFiles: MutableList<EPubContentFile> = LinkedList()
ZipInputStream(FileInputStream(srcFile)).use {
var zipEntry = it.nextEntry
while (zipEntry != null) {
if (zipEntry.isDirectory) {
zipEntry = it.nextEntry
continue
}
val data = readZipEntry(it)
val fileEntry = FileEntry(zipEntry.name, data)
contentFiles.add(createEPubContentFile(fileEntry))
zipEntry = it.nextEntry
}
return EPubFile(contentFiles)
}
}
private fun createEPubContentFile(fileEntry: FileEntry): EPubContentFile {
ePubContentFileProviders.forEach {
if (it.canHandle(fileEntry)) {
return it.provide(fileEntry)
}
}
throw ContentFileProviderNotFoundException()
}
private fun readZipEntry(zipInputStream: ZipInputStream): ByteArray {
val bufferSize = 1024
val buffer = ByteArray(bufferSize)
ByteArrayOutputStream().use { byteArrayOutputStream ->
while (true) {
val readSize = zipInputStream.read(buffer, 0, buffer.size)
if (readSize < 0) {
break
}
byteArrayOutputStream.write(buffer, 0, readSize)
}
return byteArrayOutputStream.toByteArray()
}
}
} | nu/src/main/java/net/sharplab/epubtranslator/core/driver/epub/EPubReader.kt | 444589856 |
package net.sharplab.epubtranslator.core.driver.epub
import net.sharplab.epubtranslator.core.model.EPubFile
import java.io.File
import java.io.FileOutputStream
import java.util.zip.ZipEntry
import java.util.zip.ZipOutputStream
class EPubWriter {
fun write(ePubFile: EPubFile, dstFile: File) {
FileOutputStream(dstFile).use { fileOutputStream ->
ZipOutputStream(fileOutputStream).use { zipOutputStream ->
ePubFile.contentFiles.forEach {
val zipEntry = ZipEntry(it.name)
zipOutputStream.putNextEntry(zipEntry)
zipOutputStream.write(it.data)
}
}
}
}
} | nu/src/main/java/net/sharplab/epubtranslator/core/driver/epub/EPubWriter.kt | 3667025435 |
package net.sharplab.epubtranslator.core.entity
import jakarta.persistence.*
@Table(indexes = [
Index(name = "idx_source_sourceLang_targetLang", columnList = "source, sourceLang, targetLang")
])
@Entity(name = "translation_memory")
open class TranslationMemoryEntity {
@Id
@GeneratedValue
open var id: Int? = null
@Column(length = 65535)
open lateinit var source: String
@Column(length = 65535)
open lateinit var target: String
open lateinit var sourceLang: String
open lateinit var targetLang: String
}
| nu/src/main/java/net/sharplab/epubtranslator/core/entity/TranslationMemoryEntity.kt | 139776325 |
package net.sharplab.epubtranslator.core.provider.epub
import net.sharplab.epubtranslator.core.model.EPubContentFile
import net.sharplab.epubtranslator.core.model.FileEntry
/**
* ファイルエントリからEPubContentFileを生成するプロバイダ
*/
interface EPubContentFileProvider {
/**
* 対象のファイルエントリを扱うことが出来るかを返却する
*
* @param fileEntry ファイルエントリ
* @return ファイルエントリを扱える場合true
*/
fun canHandle(fileEntry: FileEntry): Boolean
/**
* EPubContentFileを生成する
*
* @param fileEntry ファイルエントリ
* @return EPubContentFile
*/
fun provide(fileEntry: FileEntry): EPubContentFile
}
| nu/src/main/java/net/sharplab/epubtranslator/core/provider/epub/EPubContentFileProvider.kt | 3815602749 |
package net.sharplab.epubtranslator.core.provider.epub
import net.sharplab.epubtranslator.core.model.EPubChapter
import net.sharplab.epubtranslator.core.model.FileEntry
/**
* EPubChapterを生成するプロバイダ
*/
class EPubChapterProvider : EPubContentFileProvider {
override fun canHandle(fileEntry: FileEntry): Boolean {
return fileEntry.name.endsWith(".xhtml") || fileEntry.name.endsWith(".html") || fileEntry.name.endsWith(".htm")
}
override fun provide(fileEntry: FileEntry): EPubChapter {
require(canHandle(fileEntry))
return EPubChapter(fileEntry.name, fileEntry.data)
}
}
| nu/src/main/java/net/sharplab/epubtranslator/core/provider/epub/EPubChapterProvider.kt | 2422388018 |
package net.sharplab.epubtranslator.core.provider.epub
import net.sharplab.epubtranslator.core.model.EPubContentFile
import net.sharplab.epubtranslator.core.model.FileEntry
/**
* EPubContentFileを返却するプロバイダ
*/
class DefaultEPubContentFileProvider : EPubContentFileProvider {
/**
* {@inheritDoc}
*/
override fun canHandle(fileEntry: FileEntry): Boolean {
return true
}
/**
* {@inheritDoc}
*/
override fun provide(fileEntry: FileEntry): EPubContentFile {
require(canHandle(fileEntry))
return EPubContentFile(fileEntry.name, fileEntry.data)
}
} | nu/src/main/java/net/sharplab/epubtranslator/core/provider/epub/DefaultEPubContentFileProvider.kt | 3464387625 |
package net.sharplab.epubtranslator.core.provider.epub
class ContentFileProviderNotFoundException : RuntimeException() | nu/src/main/java/net/sharplab/epubtranslator/core/provider/epub/ContentFileProviderNotFoundException.kt | 2027681541 |
package net.sharplab.epubtranslator.core.model
import java.nio.charset.StandardCharsets
/**
* EPubChapter
*/
class EPubChapter(name: String, data: ByteArray) : EPubContentFile(name, data) {
val dataAsString: String
get() = String(data, StandardCharsets.UTF_8)
}
| nu/src/main/java/net/sharplab/epubtranslator/core/model/EPubChapter.kt | 611841480 |
package net.sharplab.epubtranslator.core.model
/**
* EPubFile
*/
class EPubFile(val contentFiles: List<EPubContentFile>) {
}
| nu/src/main/java/net/sharplab/epubtranslator/core/model/EPubFile.kt | 3942604374 |
package net.sharplab.epubtranslator.core.model
import net.sharplab.epubtranslator.core.util.ArrayUtil
class FileEntry(val name: String, data: ByteArray) {
val data: ByteArray = ArrayUtil.clone(data)
get() = ArrayUtil.clone(field)
} | nu/src/main/java/net/sharplab/epubtranslator/core/model/FileEntry.kt | 2907818866 |
package net.sharplab.epubtranslator.core.model
import net.sharplab.epubtranslator.core.util.ArrayUtil
/**
* EPubContentFile
*/
open class EPubContentFile(val name: String, data: ByteArray) {
val data: ByteArray = ArrayUtil.clone(data)
get() = ArrayUtil.clone(field)
} | nu/src/main/java/net/sharplab/epubtranslator/core/model/EPubContentFile.kt | 430910422 |
package net.sharplab.epubtranslator.core.service
interface TranslationMemoryService {
fun load(source: String, sourceLang: String, targetLang: String): String?
fun save(source: String, target:String, sourceLang: String, targetLang: String)
} | nu/src/main/java/net/sharplab/epubtranslator/core/service/TranslationMemoryService.kt | 4094919973 |
package net.sharplab.epubtranslator.core.service
class EPubTranslatorException(e: Exception?) : RuntimeException(e) | nu/src/main/java/net/sharplab/epubtranslator/core/service/EPubTranslatorException.kt | 2699724469 |
package net.sharplab.epubtranslator.core.service
import net.sharplab.epubtranslator.core.model.EPubFile
interface EPubTranslatorService {
fun translate(ePubFile: EPubFile, srcLang: String, dstLang: String): EPubFile
}
| nu/src/main/java/net/sharplab/epubtranslator/core/service/EPubTranslatorService.kt | 719456584 |
package net.sharplab.epubtranslator.core.service
import org.w3c.dom.Document
import org.w3c.dom.Node
import org.w3c.dom.ls.DOMImplementationLS
/**
* 翻訳リクエスト
*
*
* 対象のドキュメントにおける翻訳要求の一つを表現するデータ構造
*/
class TranslationRequest
/**
* 翻訳リクエストのコンストラクタ
*
* @param document 翻訳対象ドキュメント
* @param target 翻訳対象ノードのリスト
*/(
/**
* 翻訳対象ドキュメント
*/
val document: Document,
/**
* 翻訳対象ノードのリスト
*/
val target: MutableList<Node>) {
/**
* 翻訳対象ノードの文字列表現を返却する
*/
val sourceXmlString: String
get() {
val stringBuilder = StringBuilder()
val domImplementation = document.implementation as DOMImplementationLS
val lsSerializer = domImplementation.createLSSerializer()
lsSerializer.domConfig.setParameter("xml-declaration", false)
lsSerializer.domConfig.setParameter("element-content-whitespace", true)
lsSerializer.domConfig.setParameter("canonical-form", false)
for (node in target) {
stringBuilder.append(lsSerializer.writeToString(node))
}
return stringBuilder.toString()
}
override fun toString(): String {
return sourceXmlString
}
} | nu/src/main/java/net/sharplab/epubtranslator/core/service/TranslationRequest.kt | 3881854 |
package net.sharplab.epubtranslator.core.service
import java.util.*
/**
* TranslateRequestChunk
*/
class TranslationRequestChunk(translationRequests: List<TranslationRequest>) {
val translationRequests: List<TranslationRequest> = Collections.unmodifiableList(translationRequests)
}
| nu/src/main/java/net/sharplab/epubtranslator/core/service/TranslationRequestChunk.kt | 301161930 |
package net.sharplab.epubtranslator.core.service
import net.sharplab.epubtranslator.core.driver.translator.Translator
import net.sharplab.epubtranslator.core.model.EPubChapter
import net.sharplab.epubtranslator.core.model.EPubContentFile
import net.sharplab.epubtranslator.core.model.EPubFile
import net.sharplab.epubtranslator.core.util.XmlUtils.parseXmlStringToDocument
import net.sharplab.epubtranslator.core.util.XmlUtils.parseXmlStringToDocumentFragment
import org.slf4j.LoggerFactory
import org.w3c.dom.Document
import org.w3c.dom.Node
import org.w3c.dom.ls.DOMImplementationLS
import java.nio.charset.StandardCharsets
import java.util.function.Consumer
import java.util.function.Predicate
import jakarta.enterprise.context.Dependent
@Dependent
class EPubTranslatorServiceImpl(private val translator: Translator, private val translationMemoryService: TranslationMemoryService) : EPubTranslatorService {
private val logger = LoggerFactory.getLogger(EPubTranslatorServiceImpl::class.java)
override fun translate(ePubFile: EPubFile, srcLang: String, dstLang: String): EPubFile {
val contentFiles = ePubFile.contentFiles
val translatedContentFiles = contentFiles.map { contentFile: EPubContentFile ->
if (contentFile is EPubChapter) {
val contents = contentFile.dataAsString
val translatedContents = translateEPubXhtmlString(contents, srcLang, dstLang)
val ePubChapter = EPubChapter(contentFile.name, translatedContents.toByteArray(StandardCharsets.UTF_8))
logger.info("{} is translated.", ePubChapter.name)
return@map ePubChapter
} else {
return@map contentFile
}
}
return EPubFile(translatedContentFiles)
}
fun translateEPubXhtmlString(xhtmlString: String, srcLang: String, dstLang: String): String {
val document = parseXmlStringToDocument(xhtmlString)
val translatedDocument = translateEPubXhtmlDocument(document, srcLang, dstLang)
val domImplementation = translatedDocument.implementation as DOMImplementationLS
val lsSerializer = domImplementation.createLSSerializer()
lsSerializer.domConfig.setParameter("xml-declaration", true)
lsSerializer.domConfig.setParameter("element-content-whitespace", true)
lsSerializer.domConfig.setParameter("canonical-form", false)
return lsSerializer.writeToString(translatedDocument)
}
private fun translateEPubXhtmlDocument(document: Document, srcLang: String, dstLang: String): Document {
preProcessNode(document)
var translationRequests = generateTranslationRequests(document)
translationRequests = translateWithTranslationMemory(translationRequests, srcLang, dstLang)
val translationRequestChunks = formTranslationRequestChunks(translationRequests)
translateWithDeepL(translationRequestChunks, srcLang, dstLang)
return document
}
private fun translateWithTranslationMemory(
translationRequests: List<TranslationRequest>,
srcLang: String,
dstLang: String
): List<TranslationRequest> {
val list = ArrayList<TranslationRequest>()
translationRequests.forEach {
val translatedString = translationMemoryService.load(it.sourceXmlString, srcLang, dstLang)
if(translatedString == null){
list.add(it)
}
else{
replaceWithTranslatedString(it, translatedString)
}
}
return list
}
/**
* 翻訳リクエストのリストを作成する
*
* @param document 翻訳元のXML文書
* @return 翻訳リクエストのリスト
*/
private fun generateTranslationRequests(document: Document): List<TranslationRequest> {
val translationRequests: MutableList<TranslationRequest> = ArrayList()
val wip = TranslationRequest(document, ArrayList())
translationRequests.add(wip)
walkToGenerateTranslationRequests(document, HashSet(), translationRequests)
return translationRequests.filter { it.sourceXmlString.trim(' ').isNotEmpty() }
}
/**
* XML文書を走査して翻訳リクエストのリストを作成する
*
* @param node 走査対象のノード
* @param processedSet 処理済ノードのセット
* @param translationRequests 翻訳リクエストのリスト
*/
private fun walkToGenerateTranslationRequests(node: Node, processedSet: MutableSet<Node>, translationRequests: MutableList<TranslationRequest>) {
val document = node.ownerDocument
//処理済のNodeはスキップ
if (processedSet.contains(node)) {
return
}
if (isExcludedNode(node)) {
return
}
var wip = translationRequests.last()
//翻訳対象ノードの場合
if (isTranslationTargetNode(node)) { //テキスト中なので、リストに追加
wip.target.add(node)
//同一階層の次以降のノードの探索
var nextNode = node.nextSibling
while (nextNode != null) {
//翻訳対象Nodeならリストに追加、処理済セットに追加
if (isTranslationTargetNode(nextNode)) {
wip.target.add(nextNode)
processedSet.add(nextNode)
} else if (wip.target.isEmpty()) {
wip = TranslationRequest(document, ArrayList())
translationRequests.add(wip)
break
}
nextNode = nextNode.nextSibling
}
//親ノードが、翻訳対象ノード以外の場合、テキストの末尾なので次のTranslateRequestを準備、但しWIPが0件でない場合に限る
if (!isTranslationTargetNode(node.parentNode) && wip.target.size > 0) {
wip = TranslationRequest(document, ArrayList())
translationRequests.add(wip)
}
} else { //子ノードを走査し、再帰処理
val childNodes = node.childNodes
for (i in 0 until childNodes.length) {
val child = childNodes.item(i)
walkToGenerateTranslationRequests(child, processedSet, translationRequests)
}
}
}
/**
* 翻訳除外ノードか判定する
*
* @param node 判定対象ノード
* @return 翻訳除外ノードの場合、true
*/
private fun isExcludedNode(node: Node): Boolean {
return EXCLUDED_ELEMENT_NAMES.contains(node.nodeName) || isTranslationTargetNode(node) && lookupNode(node) { isExcludedNode(it) }
}
/**
* 翻訳リクエストのリストを翻訳リクエストのチャンクに構成する
*
* @param translationRequests 翻訳リクエストのリスト
* @return 翻訳リクエストのチャンクのリスト
*/
private fun formTranslationRequestChunks(translationRequests: List<TranslationRequest>): List<TranslationRequestChunk> {
var textLengthCounter = 0
val translationRequestChunks: MutableList<TranslationRequestChunk> = ArrayList()
var workingTranslationRequestList: MutableList<TranslationRequest> = ArrayList()
for (translateRequest in translationRequests) {
val sourceXmlString = translateRequest.sourceXmlString
if (textLengthCounter + sourceXmlString.length > MAX_REQUESTABLE_TEXT_LENGTH) {
translationRequestChunks.add(TranslationRequestChunk(workingTranslationRequestList))
workingTranslationRequestList = ArrayList()
textLengthCounter = 0
}
workingTranslationRequestList.add(translateRequest)
textLengthCounter += sourceXmlString.length
}
translationRequestChunks.add(TranslationRequestChunk(workingTranslationRequestList))
return translationRequestChunks
}
/**
* XML文書中の翻訳リクエストのチャンクで指定された箇所を翻訳する
*
* @param translationRequestChunks 翻訳リクエストチャンクのリスト
*/
private fun translateWithDeepL(translationRequestChunks: List<TranslationRequestChunk>, srcLang: String, dstLang: String) {
translationRequestChunks.forEach(Consumer { translationRequestChunk: TranslationRequestChunk ->
val translationRequests = translationRequestChunk.translationRequests
val translationResponse: List<String> =
translator.translate(translationRequests.map(TranslationRequest::sourceXmlString), srcLang, dstLang)
for (i in translationRequests.indices) {
val translationRequest = translationRequests[i]
val translatedString = translationResponse[i]
translationMemoryService.save(translationRequest.sourceXmlString, translatedString, srcLang, dstLang)
replaceWithTranslatedString(translationRequest, translatedString)
}
})
}
private fun replaceWithTranslatedString(translationRequest: TranslationRequest, translatedString: String){
val document = translationRequest.document
val firstNode = translationRequest.target.first()
val documentFragment = parseXmlStringToDocumentFragment(document, translatedString)
val translatedTextContainerDiv = document.createElement("div")
translatedTextContainerDiv.appendChild(documentFragment)
firstNode.parentNode.insertBefore(translatedTextContainerDiv, firstNode)
val originalTextContainerDiv = document.createElement("div")
translatedTextContainerDiv.parentNode.insertBefore(originalTextContainerDiv, translatedTextContainerDiv)
val targetNodes = translationRequest.target
for (targetNode in targetNodes) {
originalTextContainerDiv.appendChild(targetNode)
}
}
private fun preProcessNode(node: Node) {
val children = node.childNodes
for (i in 0 until children.length) {
val child = children.item(i)
if (isEmptyElement(child)) {
child.appendChild(node.ownerDocument.createComment("place holder"))
} else {
preProcessNode(child)
}
}
}
/**
* 翻訳対象ノードか判定する
*
* @param node 判定対象ノード
* @return 翻訳対象ノードの場合、true
*/
private fun isTranslationTargetNode(node: Node): Boolean {
return node.nodeType == Node.TEXT_NODE || node.nodeType == Node.ELEMENT_NODE && INLINE_ELEMENT_NAMES.contains(node.nodeName)
}
private fun isEmptyElement(node: Node): Boolean {
return node.nodeType == Node.ELEMENT_NODE && !node.hasChildNodes()
}
private fun lookupNode(node: Node, condition: Predicate<Node>): Boolean {
val childNodes = node.childNodes
for (i in 0 until childNodes.length) {
val child = childNodes.item(i)
if (condition.test(child)) {
return true
} else {
if (lookupNode(child, condition)) {
return true
}
}
}
return false
}
companion object {
/**
* 一つの翻訳リクエストチャンクに含めることが可能な最大文字数
*/
@Suppress("SpellCheckingInspection")
private const val MAX_REQUESTABLE_TEXT_LENGTH = 1000
/**
* インライン要素のタグリスト
*/
val INLINE_ELEMENT_NAMES = listOf("a", "abbr", "b", "bdi", "bdo", "br", "cite", "code", "data", "dfn", "em", "i", "kbd", "mark", "q", "rp", "rt", "rtc", "ruby", "s", "samp", "small", "span", "strong", "sub", "sup", "time", "u", "var", "wbr")
/**
* 翻訳除外要素のリスト
*/
private val EXCLUDED_ELEMENT_NAMES = listOf("head", "pre", "tt")
}
} | nu/src/main/java/net/sharplab/epubtranslator/core/service/EPubTranslatorServiceImpl.kt | 1074079040 |
package net.sharplab.epubtranslator.core.service
import net.sharplab.epubtranslator.core.entity.TranslationMemoryEntity
import net.sharplab.epubtranslator.core.repository.TranslationMemoryRepository
import jakarta.enterprise.context.ApplicationScoped
import jakarta.transaction.Transactional
@ApplicationScoped
class TranslationMemoryServiceImpl(private val translationMemoryRepository: TranslationMemoryRepository) : TranslationMemoryService {
@Transactional
override fun load(source: String, sourceLang: String, targetLang: String): String? {
return translationMemoryRepository.find(source, sourceLang, targetLang)?.target
}
@Transactional
override fun save(source: String, target: String, sourceLang: String, targetLang: String) {
translationMemoryRepository.persist(TranslationMemoryEntity().also { it.source = source; it.target = target; it.sourceLang = sourceLang; it.targetLang = targetLang })
}
} | nu/src/main/java/net/sharplab/epubtranslator/core/service/TranslationMemoryServiceImpl.kt | 2756076836 |
package net.sharplab.epubtranslator.app
import org.eclipse.microprofile.config.inject.ConfigProperty
import jakarta.enterprise.context.Dependent
@Dependent
class EPubTranslatorSetting {
@ConfigProperty(name = "ePubTranslator.deepL.apiEndpoint", defaultValue = "https://api.deepl.com")
var deepLApiEndpoint: String? = null
@ConfigProperty(name = "ePubTranslator.deepL.apiKey")
var deepLApiKey: String? = null
@ConfigProperty(name = "ePubTranslator.language.source", defaultValue = "en")
var defaultSrcLang: String? = null
@ConfigProperty(name = "ePubTranslator.language.destination", defaultValue = "ja")
var defaultDstLang: String? = null
}
| nu/src/main/java/net/sharplab/epubtranslator/app/EPubTranslatorSetting.kt | 408107119 |
package net.sharplab.epubtranslator.app.config
import net.sharplab.epubtranslator.app.EPubTranslatorSetting
import net.sharplab.epubtranslator.core.driver.epub.EPubReader
import net.sharplab.epubtranslator.core.driver.epub.EPubWriter
import net.sharplab.epubtranslator.core.driver.translator.DeepLTranslator
import net.sharplab.epubtranslator.core.driver.translator.Translator
import net.sharplab.epubtranslator.core.provider.epub.DefaultEPubContentFileProvider
import net.sharplab.epubtranslator.core.provider.epub.EPubChapterProvider
import java.util.*
import jakarta.enterprise.context.Dependent
import jakarta.enterprise.inject.Produces
@Dependent
class AppConfig(private val ePubTranslatorSetting: EPubTranslatorSetting) {
@Produces
fun translator(): Translator {
var apiEndpoint = ePubTranslatorSetting.deepLApiEndpoint
val apiKey = ePubTranslatorSetting.deepLApiKey
if(apiEndpoint == null){
throw RuntimeException("ePubTranslator.deepL.apiEndpoint must be provided in application.yml")
}
if(apiKey == null){
throw RuntimeException("ePubTranslator.deepL.apiKey must be provided in application.yml")
}
return DeepLTranslator(apiEndpoint, apiKey)
}
@Produces
fun ePubReader(): EPubReader {
val contentFileProviders = listOf(EPubChapterProvider(), DefaultEPubContentFileProvider())
return EPubReader(contentFileProviders)
}
@Produces
fun ePubWriter(): EPubWriter {
return EPubWriter()
}
} | nu/src/main/java/net/sharplab/epubtranslator/app/config/AppConfig.kt | 791322592 |
package net.sharplab.epubtranslator.app.cli
import net.sharplab.epubtranslator.app.EPubTranslatorSetting
import net.sharplab.epubtranslator.app.service.EPubTranslateParameters
import net.sharplab.epubtranslator.app.service.EPubTranslatorAppService
import picocli.CommandLine
import java.io.File
import java.lang.IllegalArgumentException
@CommandLine.Command
class EPubTranslatorCli(private val ePubTranslatorAppService: EPubTranslatorAppService, private val ePubTranslatorSetting: EPubTranslatorSetting) : Runnable {
@CommandLine.Option(order = 0, names = ["--src"], description = ["source file"], required = true)
private var src: File? = null
@CommandLine.Option(order = 1, names = ["--dst"], description = ["destination file"])
private var dst: File? = null
@CommandLine.Option(order = 2, names = ["--srcLang"], description = ["source language"])
private var srcLang: String? = null
@CommandLine.Option(order = 3, names = ["--dstLang"], description = ["destination language"])
private var dstLang: String? = null
@CommandLine.Option(order = 9, names = ["--help", "-h"], description = ["print help"], usageHelp = true)
private var help = false
override fun run() {
val srcFile = src?: throw IllegalArgumentException("src must be provided")
val resolvedSrcLang = srcLang ?: ePubTranslatorSetting.defaultSrcLang ?: throw IllegalArgumentException("srcLang must be provided")
val resolvedDstLang = dstLang ?: ePubTranslatorSetting.defaultDstLang ?: throw IllegalArgumentException("dstLang must be provided")
val resolvedDst = dst ?: constructDstFileFromSrcFile(srcFile, resolvedDstLang)
val ePubTranslateParameters = EPubTranslateParameters(srcFile, resolvedDst, resolvedSrcLang, resolvedDstLang)
ePubTranslatorAppService.translateEPubFile(ePubTranslateParameters)
}
private fun constructDstFileFromSrcFile(src: File, dstLang: String): File {
val srcFileName = src.name
val dstFileName: String
dstFileName = if (!srcFileName.contains(".")) {
"$srcFileName.$dstLang"
} else {
srcFileName.substring(0, srcFileName.lastIndexOf('.')) + "." + dstLang + srcFileName.substring(srcFileName.lastIndexOf('.'), srcFileName.length)
}
return File(src.parent, dstFileName)
}
} | nu/src/main/java/net/sharplab/epubtranslator/app/cli/EPubTranslatorCli.kt | 3590213401 |
package net.sharplab.epubtranslator.app.service
import java.io.File
class EPubTranslateParameters(var srcFile: File, var dstFile: File, var srcLang: String, var dstLang: String) | nu/src/main/java/net/sharplab/epubtranslator/app/service/EPubTranslateParameters.kt | 2541277169 |
package net.sharplab.epubtranslator.app.service
interface EPubTranslatorAppService {
fun translateEPubFile(ePubTranslateParameters: EPubTranslateParameters)
} | nu/src/main/java/net/sharplab/epubtranslator/app/service/EPubTranslatorAppService.kt | 2124995411 |
package net.sharplab.epubtranslator.app.service
import net.sharplab.epubtranslator.core.driver.epub.EPubReader
import net.sharplab.epubtranslator.core.driver.epub.EPubWriter
import net.sharplab.epubtranslator.core.service.EPubTranslatorService
import jakarta.enterprise.context.Dependent
@Dependent
class EPubTranslatorAppServiceImpl(private val ePubTranslatorService: EPubTranslatorService, private val ePubReader: EPubReader, private val ePubWriter: EPubWriter) : EPubTranslatorAppService {
override fun translateEPubFile(ePubTranslateParameters: EPubTranslateParameters) {
val ePubFile = ePubReader.read(ePubTranslateParameters.srcFile)
val translated = ePubTranslatorService.translate(ePubFile, ePubTranslateParameters.srcLang, ePubTranslateParameters.dstLang)
ePubWriter.write(translated, ePubTranslateParameters.dstFile)
}
}
| nu/src/main/java/net/sharplab/epubtranslator/app/service/EPubTranslatorAppServiceImpl.kt | 1431191520 |
package com.example.zero_chart
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.zero_chart.test", appContext.packageName)
}
} | ZERO_Chart/ZERO_Chart/src/androidTest/java/com/example/zero_chart/ExampleInstrumentedTest.kt | 915247833 |
package com.example.zero_chart
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)
}
} | ZERO_Chart/ZERO_Chart/src/test/java/com/example/zero_chart/ExampleUnitTest.kt | 497604922 |
package com.example.zero_chart
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.tween
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.drawWithCache
import androidx.compose.ui.geometry.CornerRadius
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.unit.dp
@Composable
fun DrawBarGraph(
modifier: Modifier = Modifier,
data: List<Float>,
barWidth: Float,
barCornerRadius: Float = 0f,
horizontalLines: Int,
isAnimation: Boolean = true,
animationDuration: Int = 1000
) {
Box(modifier = modifier
) {
val animationProgress = remember { Animatable(0f) }
val progress = remember { mutableFloatStateOf(0f) }
if(isAnimation) {
LaunchedEffect(Unit) {
animationProgress.animateTo(1f, tween(animationDuration))
}
progress.value = animationProgress.value
}
else
progress.value = 1f
Spacer(modifier = Modifier
.padding(8.dp)
.fillMaxSize()
.drawWithCache {
onDrawBehind {
val max = data.max()
val min = 0
val rectLineWidthPx = 1.dp.toPx()
drawRect(Color.White, style = Stroke(rectLineWidthPx))
//Horizontal
val sectionSize = size.height / (horizontalLines - 1)
repeat(horizontalLines) { i ->
val startY = sectionSize * i
drawLine(
Color.White,
start = Offset(0f, startY),
end = Offset(size.width, startY),
strokeWidth = rectLineWidthPx
)
}
for (r: Int in 0..data.size - 1) {
val xOffset = (size.width / data.size) * r + ((size.width / data.size) / 2)
val dataHeight = ((data[r] - min) / (max - min)) * size.height
drawRoundRect(
color = Color.Blue,
topLeft = Offset(xOffset - barWidth / 2, size.height),
size = Size(barWidth.toDp().toPx(), -dataHeight * progress.value),
cornerRadius = CornerRadius(barCornerRadius, barCornerRadius),
)
}
}
}
)
}
} | ZERO_Chart/ZERO_Chart/src/main/java/com/example/zero_chart/BarGraph.kt | 3635405405 |
package com.example.zero_chart
import androidx.compose.animation.core.LinearOutSlowInEasing
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.animation.core.tween
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.drawWithCache
import androidx.compose.ui.draw.rotate
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.StrokeCap
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.unit.dp
data class pieData(
val data: Int,
val color: Color
)
@Composable
fun DrawPieChart(
modifier: Modifier = Modifier,
pieData: List<pieData>,
radiusOuter: Float = 90f,
chartBarWidth: Float = 90f,
isAnimation: Boolean = true,
animationDuration: Int = 1000
) {
Box(modifier = modifier
) {
val totalSum = pieData.sumOf { it.data }
val dataList = mutableListOf<Float>()
pieData.forEachIndexed { index, pieData ->
dataList.add(index, 360f * pieData.data / totalSum)
}
var lastValue = 0f
var isAnimation_ by remember { mutableStateOf(false) }
val animateSize by animateFloatAsState(
targetValue = if(isAnimation_) radiusOuter * 2f else 0f,
animationSpec = tween(
durationMillis = animationDuration,
delayMillis = 0,
easing = LinearOutSlowInEasing
)
)
var chartSize: Float = animateSize
val animateRotation by animateFloatAsState(
targetValue = if(isAnimation_) 90f * 11f else 0f,
animationSpec = tween(
durationMillis = animationDuration,
delayMillis = 0,
easing = LinearOutSlowInEasing
)
)
var chartRotation: Float = animateRotation
LaunchedEffect(Unit) {
isAnimation_ = isAnimation
}
if(!isAnimation) {
chartSize = radiusOuter * 2f
chartRotation = 0f
}
Spacer(modifier = Modifier
.padding(8.dp)
.align(Alignment.Center)
.size(chartSize.dp)
.rotate(chartRotation)
.drawWithCache {
onDrawBehind {
dataList.forEachIndexed { index, value ->
drawArc(
color = pieData[index].color,
lastValue,
value,
useCenter = false,
style = Stroke(chartBarWidth.toDp().toPx(), cap = StrokeCap.Butt),
)
lastValue += value
}
}
}
)
}
} | ZERO_Chart/ZERO_Chart/src/main/java/com/example/zero_chart/PieChart.kt | 2166579954 |
package com.example.zero_chart
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.compose.foundation.layout.Spacer
import androidx.compose.runtime.remember
import androidx.compose.ui.draw.drawWithCache
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Path
import androidx.compose.ui.graphics.drawscope.Fill
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.tween
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.ui.graphics.drawscope.clipRect
data class lineData(
val data: List<Float>,
val lineColor: Color,
val isFill: Boolean
)
data class pathSet(
var linePath: Path,
var filledPath: Path
)
fun GeneratePath(data: List<Float>, size: Size, dataSize: Int, max: Float, min: Float): Path {
val path = Path()
val dataHeight = size.height - ((data[0] - min) / (max - min)) * size.height
path.moveTo(0f, dataHeight)
for(i: Int in 1..data.size - 1)
path.lineTo(size.width / (dataSize - 1) * i.toFloat(), size.height - ((data[i] - min) / (max - min)) * size.height)
return path
}
fun GenerateSmoothPath(data: List<Float>, size: Size, dataSize: Int, max: Float, min: Float): Path {
val path = Path()
val max = data.max()
val min = data.min()
var formerX: Float = 0f
var formerY: Float = size.height - ((data[0] - min) / (max - min)) * size.height
path.moveTo(formerX, formerY)
for(i: Int in 1..data.size - 1) {
val controlPoint1x = (formerX + (size.width / (dataSize - 1) * i.toFloat())) / 2f
val controlPoint1y = formerY
val controlPoint2x = (formerX + (size.width / (dataSize - 1) * i.toFloat())) / 2f
val controlPoint2y = size.height - ((data[i] - min) / (max - min)) * size.height
path.cubicTo(controlPoint1x, controlPoint1y, controlPoint2x, controlPoint2y, size.width / (dataSize - 1) * i.toFloat(), size.height - ((data[i] - min) / (max - min)) * size.height)
formerX = size.width / (dataSize - 1) * i.toFloat()
formerY = size.height - ((data[i] - min) / (max - min)) * size.height
}
return path
}
@Composable
fun DrawLineChart(
modifier: Modifier = Modifier,
lineData: List<lineData> = emptyList(),
verticalLines: Int,
horizontalLines: Int,
lineWidth: Int = 2,
isSmooth: Boolean = false,
isAnimation: Boolean = true,
animationDuration: Int = 1000
) {
Box(modifier = modifier
) {
val animationProgress = remember { Animatable(0f) }
val progress = remember { mutableFloatStateOf(0f) }
if(isAnimation) {
LaunchedEffect(Unit) {
animationProgress.animateTo(1f, tween(animationDuration))
}
progress.value = animationProgress.value
}
else
progress.value = 1f
Spacer(modifier = Modifier
.padding(8.dp)
.fillMaxSize()
.drawWithCache {
//Generate Paths
val pathList = MutableList<pathSet>(lineData.size) { pathSet(Path(), Path()) }
val combinedList = emptyList<Float>().toMutableList()
//Calculate Max and Min
for (p: Int in 0..lineData.size - 1) {
combinedList += lineData[p].data
}
val max = mutableFloatStateOf(0f)
max.value = combinedList.max()
val min = mutableFloatStateOf(0f)
min.value = combinedList.min()
for (p: Int in 0..lineData.size - 1) {
var path = GeneratePath(lineData[p].data, size, lineData[p].data.size, max.value, min.value)
if (isSmooth)
path = GenerateSmoothPath(lineData[p].data, size, lineData[p].data.size, max.value, min.value)
val filledPath = Path()
filledPath.addPath(path)
filledPath.lineTo(size.width, size.height)
filledPath.lineTo(0f, size.height)
filledPath.close()
pathList[p].linePath = path;
pathList[p].filledPath = filledPath
}
onDrawBehind {
val barWidthPx = 1.dp.toPx()
drawRect(Color.White, style = Stroke(barWidthPx))
//Vertical
val verticalSize = size.width / (verticalLines - 1)
repeat(verticalLines) { i ->
val startX = verticalSize * (i + 1)
drawLine(
Color.White,
start = Offset(startX, 0f),
end = Offset(startX, size.height),
strokeWidth = barWidthPx
)
}
//Horizontal
val sectionSize = size.height / (horizontalLines - 1)
repeat(horizontalLines) { i ->
val startY = sectionSize * i
drawLine(
Color.White,
start = Offset(0f, startY),
end = Offset(size.width, startY),
strokeWidth = barWidthPx
)
}
val brushList = MutableList<Brush>(lineData.size) { Brush.verticalGradient() }
for(b: Int in 0..lineData.size - 1) {
brushList[b] = Brush.verticalGradient(
listOf(
lineData[b].lineColor.copy(alpha = 0.4f),
Color.Transparent
)
)
}
for (p: Int in 0..lineData.size - 1) {
clipRect(right = size.width * progress.value) {
drawPath(
pathList[p].linePath,
lineData[p].lineColor,
style = Stroke(lineWidth.dp.toPx())
)
if(lineData[p].isFill) {
drawPath(
pathList[p].filledPath,
brush = brushList[p],
style = Fill,
)
// drawPath(
// pathList[p].filledPath,
// color = lineData[p].lineColor
// )
}
}
}
}
}
)
}
}
/* 라인 클릭시 정보 표시해주는 예시 코드 */
//@Composable
//fun DrawLineChart(
// // ... (your existing parameters)
//) {
// var selectedLineIndex by remember { mutableStateOf(-1) }
//
// // ... (existing code)
//
// Spacer(
// modifier = Modifier
// .padding(8.dp)
// .aspectRatio(3 / 2f)
// .fillMaxSize()
// .clickable {
// // Calculate the touched position and find the corresponding line index
// val touchedX = it.position.x
// val lineIndex = (touchedX / size.width * verticalLines).toInt()
// selectedLineIndex = lineIndex
// }
// .drawWithCache {
// // ... (existing code)
//
// onDrawBehind {
// // ... (existing code)
//
// for (p: Int in 0 until lineData.size) {
// val isSelectedLine = p == selectedLineIndex
//
// // Draw the line with different color if it's the selected line
// drawPath(
// pathList[p].linePath,
// if (isSelectedLine) Color.Red else lineData[p].lineColor,
// style = Stroke(lineWidth.dp.toPx())
// )
//
// if (lineData[p].isFill) {
// // Draw the filled path with different color if it's the selected line
// drawPath(
// pathList[p].filledPath,
// brush = if (isSelectedLine) Brush.verticalGradient(
// listOf(Color.Red.copy(alpha = 0.4f), Color.Transparent)
// ) else brushList[p],
// style = Fill,
// )
// }
//
// // Display the value when the line is selected
// if (isSelectedLine) {
// val value = lineData[p].data[selectedLineIndex]
// drawText(
// text = "Value: $value",
// color = Color.White,
// fontSize = 16.sp,
// offset = Offset(touchedX, size.height / 2),
// textAlign = TextAlign.Center
// )
// }
// }
// }
// }
// )
//} | ZERO_Chart/ZERO_Chart/src/main/java/com/example/zero_chart/LineChart.kt | 2643451542 |
package com.example.zero_chart
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.zero_chart", appContext.packageName)
}
} | ZERO_Chart/app/src/androidTest/java/com/example/zero_chart/ExampleInstrumentedTest.kt | 1394295679 |
package com.example.zero_chart
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)
}
} | ZERO_Chart/app/src/test/java/com/example/zero_chart/ExampleUnitTest.kt | 497604922 |
package com.example.zero_chart.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | ZERO_Chart/app/src/main/java/com/example/zero_chart/ui/theme/Color.kt | 63956176 |
package com.example.zero_chart.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun ZERO_ChartTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | ZERO_Chart/app/src/main/java/com/example/zero_chart/ui/theme/Theme.kt | 3610511472 |
package com.example.zero_chart.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | ZERO_Chart/app/src/main/java/com/example/zero_chart/ui/theme/Type.kt | 1985384215 |
package com.example.zero_chart
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.tooling.preview.Preview
import com.example.zero_chart.ui.theme.ZERO_ChartTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
ZERO_ChartTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
Column {
DrawLineChart(
modifier = Modifier
.background(Color.DarkGray)
.fillMaxWidth()
.fillMaxHeight()
.weight(1f),
lineData = listOf(
lineData(listOf(100f, 40f, 20f, 80f, 60f), Color.Red, true),
lineData(listOf(60f, 80f, 20f, 40f, 100f), Color.Blue, true),
lineData(listOf(20f, 40f, 60f, 80f, 100f), Color.Green, true)
),
verticalLines = 5,
horizontalLines = 4,
lineWidth = 3,
isSmooth = true,
isAnimation = true,
animationDuration = 3000
)
DrawBarGraph(
modifier = Modifier
.background(Color.DarkGray)
.fillMaxWidth()
.fillMaxHeight()
.weight(1f),
data = listOf(100f, 200f, 50f, 80f),
barWidth = 100f,
barCornerRadius = 20f,
horizontalLines = 4,
isAnimation = true,
animationDuration = 3000
)
DrawPieChart(
modifier = Modifier
.background(Color.DarkGray)
.fillMaxWidth()
.fillMaxHeight()
.weight(1f),
pieData = listOf(
pieData(150, Color.Blue),
pieData(120, Color.Cyan),
pieData(110, Color.Red),
pieData(170, Color.Green),
pieData(120, Color.Yellow)
),
radiusOuter = 90f,
chartBarWidth = 90f,
isAnimation = true,
animationDuration = 1000
)
}
}
}
}
}
}
@Preview
@Composable
fun PreviewLineChart() {
DrawLineChart(
modifier = Modifier
.background(Color.DarkGray)
.fillMaxWidth()
.fillMaxHeight(1 / 2f),
lineData = listOf(
lineData(listOf(100f, 40f, 60f, 20f, 80f), Color.Blue, true),
lineData(listOf(80f, 20f, 60f, 40f, 100f), Color.Red, true)
),
verticalLines = 4,
horizontalLines = 4,
lineWidth = 3,
isSmooth = true,
isAnimation = true,
animationDuration = 3000
)
} | ZERO_Chart/app/src/main/java/com/example/zero_chart/MainActivity.kt | 3168604216 |
package com.example.myussd
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.myussd", appContext.packageName)
}
} | USSD-APP/app/src/androidTest/java/com/example/myussd/ExampleInstrumentedTest.kt | 256830055 |
package com.example.myussd
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)
}
} | USSD-APP/app/src/test/java/com/example/myussd/ExampleUnitTest.kt | 2336569564 |
package com.example.myussd.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | USSD-APP/app/src/main/java/com/example/myussd/ui/theme/Color.kt | 1128845693 |
package com.example.myussd.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun MyUSSDTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | USSD-APP/app/src/main/java/com/example/myussd/ui/theme/Theme.kt | 327632038 |
package com.example.myussd.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | USSD-APP/app/src/main/java/com/example/myussd/ui/theme/Type.kt | 1945592923 |
package com.example.myussd
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import android.Manifest
import android.content.pm.PackageManager
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
class MainActivity : ComponentActivity() {
private var pendingUssdCode: String? = null
companion object {
private const val REQUEST_PHONE_CALL = 1
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MainScreen(onExecuteUssd = { ussdCode ->
pendingUssdCode = ussdCode
if (isCallPermissionGranted()) {
executePendingUssdCode()
} else {
ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CALL_PHONE), REQUEST_PHONE_CALL)
}
})
}
}
private fun isCallPermissionGranted(): Boolean {
return ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED
}
private fun executePendingUssdCode() {
pendingUssdCode?.let { ussdCode ->
val encodedHash = Uri.encode("#")
val ussd = ussdCode.replace("#", encodedHash)
startActivity(Intent(Intent.ACTION_CALL, Uri.parse("tel:$ussd")))
pendingUssdCode = null // Clear the pending USSD code after executing
}
}
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
if (requestCode == REQUEST_PHONE_CALL && grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// Permission was granted. Execute the pending USSD code.
executePendingUssdCode()
} else {
// Permission was denied. Handle the failure.
// Optionally, show a message to the user explaining that the USSD code cannot be executed without the permission.
pendingUssdCode = null // Clear the pending USSD code as we can't execute it
}
}
}
| USSD-APP/app/src/main/java/com/example/myussd/MainActivity.kt | 4154347897 |
package com.example.myussd
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
//import com.google.firebase.inappmessaging.model.Button
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun MainScreen(onExecuteUssd: (String) -> Unit) {
var ussdCode by remember { mutableStateOf("") }
Column(
modifier = Modifier.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(10.dp)
) {
TextField(
value = ussdCode,
onValueChange = { ussdCode = it },
label = { Text("USSD Code") },
modifier = Modifier.fillMaxWidth()
)
Button(
onClick = { onExecuteUssd(ussdCode) },
modifier = Modifier.align(Alignment.End)
) {
Text("Execute")
}
}
}
| USSD-APP/app/src/main/java/com/example/myussd/MainScreen.kt | 3094823230 |
package com.example.vviiblue.horoscapp.ui.home
import android.content.Intent
import androidx.fragment.app.testing.FragmentScenario
import androidx.recyclerview.widget.RecyclerView
import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.action.ViewActions.click
import androidx.test.espresso.contrib.RecyclerViewActions
import androidx.test.espresso.intent.Intents
import androidx.test.espresso.intent.Intents.intended
import androidx.test.espresso.intent.matcher.IntentMatchers.hasComponent
import androidx.test.espresso.matcher.ViewMatchers.withId
import androidx.test.ext.junit.rules.ActivityScenarioRule
import androidx.test.runner.AndroidJUnit4
import com.example.vviiblue.horoscapp.R
import com.example.vviiblue.horoscapp.ui.detail.HoroscopeDetailActivity
import dagger.hilt.android.testing.HiltAndroidRule
import dagger.hilt.android.testing.HiltAndroidTest
import org.junit.After
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
/**
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* Si sale este error, hay que hacer lo siguiente
* java.lang.IllegalStateException: Hilt test, com.example.vviiblue.horoscapp.ui.home.MainActivityTest,
* cannot use a @HiltAndroidApp application but found com.example.vviiblue.horoscapp.HoroscApp. To fix,
* configure the test to use HiltTestApplication or a custom Hilt test application generated with @CustomTestApplication.
*
* -->
* Se debe crear la clase "CustomTestRunner" y esa clase sera la que hara de lanzador,
* se debera especificara en el Build.gradle de "app" de la siguiente manera
* testInstrumentationRunner = "com.example.vviiblue.horoscapp.CustomTestRunner"
*
* */
@RunWith(AndroidJUnit4::class) //Le indico que los test se deben correr con "AndroidJUnit4"
@HiltAndroidTest //Annotation necesaria para realiza los test con DaggerHilt
class MainActivityTest{
/** Las reglas (Rule) son configuraciones necesarias que se deben meter en la pantalla para realizar el test en la ui
* las reglas se les puede especificar un orden en que se van a ir ejecutando,
* como se va a testear tambien las inyecciones con "DaggerHilt", entonces se agrega en el orden
* para que la primera regla sea la de DaggerHilt, es imprensendible*/
// Con esto se prepara, para que la clase pueda ser "inyectada" o inyectar cosas
@get:Rule(order = 0)
val hiltRule = HiltAndroidRule(this)
/** Para configurar a que Activity se le va a realizar el test, en este caso hacer que se haga test del Activity Main
* se debe especificar en la siguiente Regla
* Aqui se define el escenario del test, IMPORTANTE "para los Fragment es igual" se le indica por medio de "FragmentScenario(elFragment)"
* tener cuidado, porque los que llevan Rule "ActivityScenarioRule" al final se definen en las reglas,
* los que llevan solo "ActivityScenario", es para definir los escenarios de test en los metodos con el Annotation "@Before"
* ejemplo fun setUp()*/
@get:Rule(order=1)
val mainActivityRule = ActivityScenarioRule(MainActivity::class.java)
/** Realizo las configuraciones antes de lanzar el test, en este caso se inyecta daggerHilt */
@Before
fun setUp(){
hiltRule.inject() //se inyecta daggerHilt
//preparo los Intents, para el Test que comprueba que si doy click en un item del recycleView,
// el Intent se carga con un activity que tiene como nombre HoroscopeDetailActivity
Intents.init()
}
@After
fun tearDown(){
/** importante hacer esto!!!!!!!!, para liberar la carga e los intents luego de correr los test y
* asi evitar fallos de test */
Intents.release()
}
/** En los test de UI no se pueden poner los nombres de las operaciones con las palabras separadas, se debe usar "_" */
/** Testeo que cuando la activity se lance vaya a la BottomBar y seleccione el Fragment "luckFragment"*/
@Test
fun when_mainactivity_is_created_then_open_luck_fragment() {
/** "onView" = En la vista que yo te diga , busca por la Id "withId", la vista que tenga esta referencia (R.id.luckFragment),
* y a esa vista, vas hacer una accion "perform", que accion? vas hacer "click" sobre esa vista*/
onView(withId(R.id.luckFragment)).perform(click())
/** withId no es la unica forma de buscar la vista, se puede buscar por context, por un Tag por el nombre
* del recurso de la imagen que esta cargando... */
}
/** Testeo que cuando se haga cick en un Horoscopo, se vaya al activity Detail ,
* estos tipos de test, son muy utiles para saber si la navegacion es correcta ante cierta accion*/
@Test
fun when_horoscope_is_selected_then_open_detail() {
/** "onView" = En la vista que yo te diga , busca por la Id "withId", la vista que
* tenga esta referencia (R.id.rvHoroscope),
* entonces realizo un perfom sobre el recycleview, como es un "recycleview", no puedo simplemente hacer click
* debo hacer click en uno de los items del "recycleview",
* entonces especifico que para ese Recyclview se genere una "accion de RecycleView" para el item que esta en
* la posicion 3, y dicha accion que se le va a hacer a ese item sera "hacer un click"*/
//When
onView(withId(R.id.rvHoroscope)).perform(
RecyclerViewActions.actionOnItemAtPosition<RecyclerView.ViewHolder>(
3,
click()
)
)
//then
/** Se testea el Intent, que es el que tiene la informacion hacia donde va a navegar,
* asi que compruebo que cuando yo doy click en la posicion 3 del "recycleView",
* se cargue un Intent con esta informacion "HoroscopeDetailActivity::class.java.name" */
intended(hasComponent(HoroscopeDetailActivity::class.java.name))
/** **** Tip ********¡¡¡¡¡¡ IMPORTANTE !!!!!!!!************ Tip **** */
/** como la navegacion a HoroscopeDetailActivity implica una animacion antes de pasar a la activity, el test eso
* no lo espera y falla , para solucionar esto, hay que DESACTIVAR LAS ANIMACIONES DEL DISPOSITIVO donde
* se esta corriendo los test, desde LA PANTALLA DE DESSARROLLADOR y DESACTIVAR
* Windows Animation scale
* Transition animation scale
* Animator duration scale
* las 3 deben estar en off
* luego de hacer eso, el test se hara de forma correcta*/
}
} | Horoscope/app/src/androidTest/java/com/example/vviiblue/horoscapp/ui/home/MainActivityTest.kt | 1589705585 |
package com.example.vviiblue.horoscapp
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).
*/
/**
* ESTOS TEST DE "UI" LLEVAN MAS TIEMPO, NO SON COMO LOS TEST UNITARIOS( directorio "test") QUE IMPLICAN SEGUNDOS
* */
/**
*
* AQUI VAN LOS TEST QUE IMPLICAN COSAS DE ANDROID, POR EJEMPLO TESTEAR QUE SE HA IDO DE UNA PANTALLA HA OTRA
* QUE SE CORROBORE QUE LA NAVEGACION HA SIDO CORRECTA
* (TODO ESO IMPLICA LANZAR UN INTENT, IMPLICA CAPTURAR UN ACTIVITY)
*
* */
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.vviiblue.horoscapp", appContext.packageName)
}
} | Horoscope/app/src/androidTest/java/com/example/vviiblue/horoscapp/ExampleInstrumentedTest.kt | 2984181195 |
package com.example.vviiblue.horoscapp
import android.app.Application
import android.content.Context
import androidx.test.runner.AndroidJUnitRunner
import dagger.hilt.android.testing.HiltTestApplication
/** Creo mi Runner personalizado, por lo que debo extender de "AndroidJUnitRunner"
* luego para la configuracion que permita realizar test con Dagger Hilt
* se debe sobrescribir (override) la funcion "newApplication"
* y cambiar el valor que se le pasa a "newApplication" de
* "newApplication(cl, className, context)" ha "newApplication(cl, HiltTestApplication::class.java.name, context)"
* listo, eso es lo que faltaba para configurar y permitir realizar los test con daggerHilt*/
class CustomTestRunner: AndroidJUnitRunner() {
override fun newApplication(
cl: ClassLoader?,
className: String?,
context: Context?
): Application {
//return super.newApplication(cl, className, context)
/** de forma sencilla, se le indica que para lanzar los test, se pase por DaggerHilt antes */
return super.newApplication(cl, HiltTestApplication::class.java.name, context)
}
} | Horoscope/app/src/androidTest/java/com/example/vviiblue/horoscapp/CustomTestRunner.kt | 1352426571 |
package com.example.vviiblue.horoscapp.ui.horoscope
import com.example.vviiblue.horoscapp.data.providers.HoroscopeProvider
import com.example.vviiblue.horoscapp.motherobject.HoroscopeMotherObject.horoscopeInfoList
import io.mockk.MockKAnnotations
import io.mockk.every
import io.mockk.impl.annotations.MockK
import org.junit.After
import org.junit.Before
import org.junit.Test
import org.junit.jupiter.api.Assertions.*
class HoroscopeViewModelTest{
/** creo una instancia del "HoroscopeProvider" Mockeado, para
* asi pasar un HoroscopeProvider falso, que me sea util para comprobar /testear otras cosas
* Recordar: Lo que mockeo no es lo que estoy testeando!!! simplemente son una cosa que me ayuda con el test de algo mas*/
// esto depende de la libreria "mockk" // puede darse el caso que HoroscopeProvider tenga muchos metodos pero a
// mi solo me interesa testear getHoroscopes(), entonces para si aqui pongo al lado de
// la annotation "@MockK(relaxed = true)" con esto ninguna operacion se va a quejar por
// no haber una respuesta para los metodos, esto es peligroso porque puede dar lugar a que queden operaciones
// sin testear
@MockK
lateinit var horoscopeProvider: HoroscopeProvider
private lateinit var viewModel:HoroscopeViewModel
/** ANTES DE LANZAR LOS TEST Y LUEGO DE LANZAR LOS TEST
* SE PUEDEN REALIZAR CIERTAS OPERACIONES
* para hacer eso
* generalmente se crea una funcion
* llamada "setUp()" con una Annotation "@Before" para que se lance ANTES de un test
* y con la Annotation "@After" para que se lance DESPUES de un test
* generalmente esto es util si mas de una operacion de test tienen logica compartida
* por ejemplo inicializar una clase para hacer algo
* */
// Esta operacion es para hacer cosas que tengamos que hacer antes...
@Before
fun setUp(){
/**Abajo de la calse hay una expliccion de esto */
// Para que los MockK funcione, se debe hacer una configuracion ANTES de empezar los test
MockKAnnotations.init(this, relaxUnitFun = true)
}
/**
*
* Voy a testear que cuando este ViewModel "HoroscopeViewModel" se cree,
* le asigne el horoscopo que ha cargado
* "horoscopeProvider.getHoroscopes()"
* En resumidas cuentas, cuando se cargue el viewodel siempre cargue un horoscopo
*/
@Test
fun `when viewmodel is created then horoscopes are loaded`(){
//Given
/** esto solamente "horoscopeProvider.getHoroscopes()" va a generar un error porque "horoscopeProvider" es falso
* por lo que ademas, debo "mockKear una respuesta", entonces para eso hago lo siguiente
* que basicamente quiere decir : "Cada vez que alguien llame a horoscopeProvider.getHoroscopes(),
* se va a devolver "horoscopeInfoList" que es una respuesta predefinida ya en motherObject"*/
every { horoscopeProvider.getHoroscopes() } returns horoscopeInfoList
// si la operacion "getHoroscopes()" usara corrutina, entonces la respuesta MockKeada deberia ser "coEvery"
/** inicializo el viewModel, y obtengo su instancia */
viewModel = HoroscopeViewModel(horoscopeProvider) // el "HoroscopeViewModel" si es de verdad, el "horoscopeProvider" es el que es falso/el mockeado
//When
/** obtengo el horoscopo que tiene el viewModel asignado (deberia tener uno por defecto) */
val horoscopes = viewModel.horoscope.value
//Then
/** Compruebo que tiene Horoscopo guardado el viewModel */
assertTrue(horoscopes.isNotEmpty())
}
}
/** ****************EXPLICACION metodo setUp() y su contenido************************/
/**
* La función setUp() se encarga de inicializar y configurar el entorno de prueba. En este caso,
* se utiliza MockKAnnotations.init() para inicializar el entorno de pruebas con MockK.
*
* La función MockKAnnotations.init() toma dos parámetros:
*
* this: Esto hace referencia al objeto actual (en este caso, la clase de prueba o el contexto de prueba).
* relaxUnitFun = true: Este parámetro indica que se permitirá relajar (ignorar) las
* llamadas a funciones unitarias en los objetos simulados (mocks) dentro de las pruebas.
* Esto significa que si alguna función de un objeto simulado no está especificada en la prueba y
* es llamada durante la ejecución de la prueba, MockK no generará un error y simplemente la ignorará.
*
* En resumen, esta configuración se asegura de que el entorno de prueba esté preparado correctamente para
* utilizar MockK como framework de pruebas y permite relajar la implementación de
* funciones unitarias en los objetos simulados para simplificar las pruebas.
*
* */ | Horoscope/app/src/test/java/com/example/vviiblue/horoscapp/ui/horoscope/HoroscopeViewModelTest.kt | 126625574 |
package com.example.vviiblue.horoscapp.ui.providers
import org.junit.Test
import org.junit.jupiter.api.Assertions.*
class RandomCardProviderTest{
@Test
fun `getRandomCard should return a random card`(){
/**
* Given - Obtengo un valor a probar
* When - testeo la accion
* Then - Compruebo que sea lo que deberia haber pasado
* */
//Given
/** Obtengo la clase que me da la informacion, para hacer la prueba en getLuck*/
val randomCard = RandomCardProvider()
//When
val card = randomCard.getLuck()
//Then
/** "assert" es comprobar que algo se cumple, que eso pasa
* en este caso que el card que me devuelve la operacon que estoy testeando, no devuelva un valor null */
assertNotNull(card) //assert es una especie de "if" , cuando pase algo...
}
} | Horoscope/app/src/test/java/com/example/vviiblue/horoscapp/ui/providers/RandomCardProviderTest.kt | 3198925391 |
package com.example.vviiblue.horoscapp
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).
*/
/**
*
* AQUI VAN LOS TEST QUE SON DEPROGRAMACION, DE KOTLIN,
* TODO LO QUE IMPLIQUE LA CARPETA DE "Domain" POR EJEMPLO
* TODAS ESAS PRUEBAS QUE NO REQUIEREN NADA DE ANDROID, VAN AQUI
*
* */
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | Horoscope/app/src/test/java/com/example/vviiblue/horoscapp/ExampleUnitTest.kt | 2593681474 |
package com.example.vviiblue.horoscapp.data.network.response
import com.example.vviiblue.horoscapp.motherobject.HoroscopeMotherObject.anyResponse
import io.kotlintest.shouldBe
import org.junit.jupiter.api.Assertions.*
import org.junit.Test
class PredictionResponseTest{
/** ¡¡¡Los nombres de las operaciones de test, deben ser jodidamente explicativos
* no importa si son re largos
* esta correcto que se llame "toDomainShouldReturnACorrectPredictionModel" porque el nombre
* explica lo que deberia pasar en la operacion de test
* en este caso el metodo "toDomain" deberia retornar un objeto PredictionModel, listo mas nada
* SOLO PARA LOS TEST, LOS NOMBRES DE LAS OPERACIONES DE LOS TEST, PUEDEN IR SEPARADOS CON ESPACIOS USANDO COMILLAS
* fun `toDomain should return a correct PredictionModel`()
* */
@Test // para que la operacion de test, sea un TEST, debe tener su Annotation @Test
fun `toDomain should return a correct PredictionModel`(){
/** las operaciones de "test" se deben dividir en
*
* Given - Obtengo la informacion necesaria para el test
* When - Cuando "pase una accion"/"algo ocurra"/"Se ejecute" ...
* Then - Entonces verifico que ha pasado algo
*
* */
// val horoscopeResponse = PredictionResponse("date","prediction","taurus")
/** Given
* Genero un dato, da igual los parametros para este test
* aqui le doy lo que necesito testear*/
val horoscopeResponse = anyResponse
/** Para agregar nomas */
/** Si para alguna pruba no necesito modificar ese modelo basico para un test en especifico
* bastaria hacer algo asi...*/
// val horoscopeResponseModificado = anyResponse.copy(sign = "gemini")
/** y se trabaja con ese modelo basico pero con la modificacion.... */
//***************************
/**When
* Entonces cuando ocurra la "accion" que voy a "testear", en este caso sera "toDomain"
* */
val predictionModel = horoscopeResponse.toDomain()
/**Then
* Entonces, debo comprobar que lo que me dio el paso When el val "predictionModel"
* es igual a lo que me dio el paso Given "horoscopeResponse" en los sitios correctos
* (ej: que el atributo sign de "predictionModel" sea igual al sign de horoscopeResponse,
* y asi....)
* para este caso entonces, se comprueba que el modelo se convierto en el otro modelo, que se mappea correctamente
* */
predictionModel.sign shouldBe horoscopeResponse.sign //shouldBe es gracias a una de las librerias que se agrego
predictionModel.horoscope shouldBe horoscopeResponse.horoscope
}
} | Horoscope/app/src/test/java/com/example/vviiblue/horoscapp/data/network/response/PredictionResponseTest.kt | 1677970519 |
package com.example.vviiblue.horoscapp.motherobject
import com.example.vviiblue.horoscapp.data.network.response.PredictionResponse
import com.example.vviiblue.horoscapp.domain.model.HoroscopeInfo
/**
* MotherObject:
* un MotherObject es un "OBJECT" que tiene todos los modelos basicos que se necesitan para hacer las pruebas de
* test
*
* de esta manera no hay que estar creando por ejemplo "PredictionResponse("date","prediction","taurus")"
* en cada test que se necesite un "PredictionResponse"
*
* de esta manera si hay que cambiar algun modelo para la prueba, se cambia en un solo lugar y no en cada test
*
* */
object HoroscopeMotherObject {
val anyResponse = PredictionResponse("date", "prediction", "taurus")
val horoscopeInfoList = listOf(
HoroscopeInfo.Aries,
HoroscopeInfo.Taurus,
HoroscopeInfo.Gemini,
HoroscopeInfo.Cancer,
HoroscopeInfo.Leo,
HoroscopeInfo.Virgo,
HoroscopeInfo.Libra,
HoroscopeInfo.Scorpio,
HoroscopeInfo.Sagittarius,
HoroscopeInfo.Capricorn,
HoroscopeInfo.Aquarius,
HoroscopeInfo.Pisces
)
} | Horoscope/app/src/test/java/com/example/vviiblue/horoscapp/motherobject/HoroscopeMotherObject.kt | 3333510092 |
package com.example.vviiblue.horoscapp.ui.home
import android.os.Bundle
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat
import androidx.navigation.NavController
import androidx.navigation.fragment.NavHostFragment
import androidx.navigation.ui.setupWithNavController
import com.example.vviiblue.horoscapp.R
import com.example.vviiblue.horoscapp.databinding.ActivityMainBinding
import dagger.hilt.android.AndroidEntryPoint
/** Test de ui al Main Activity
* Por norma general, para testear ui, debe estar en los mismos directorios en el directorio "androidTest"
* entonces para no estar recreando todos los directorios para hacer el test de "MainActivity"
* lo mejor es posicionar el mouse sobre la operacion "MainActivity" y precionar CTRL+SHIFT+T
* por ultimo dar en crear test, crear*/
/** Para que esta classe reciba cosas inyectadas, basta poner el annotation @AndroidEntryPoint*/
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
private lateinit var navController: NavController /** NavController es la clase padre que gestiona el tema de la navegacion a travez de "NavigationComponent" */
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
initUI()
}
private fun initUI() {
initNavigation()
}
/** inicializo los recursos para la navegacion entre fragments */
private fun initNavigation() {
val navHost = supportFragmentManager.findFragmentById(R.id.fragmentContainerView) as NavHostFragment // realizo el casteo a un NavHostFragment
navController = navHost.navController // De esta manera el controlador definido va a controlar el "fragmentContainerView" definido en el xml del MainActivity
binding.bottomNavView.setupWithNavController(navController) // le paso al bottomNavegation, el navigationController
}
}
| Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/home/MainActivity.kt | 1128461380 |
package com.example.vviiblue.horoscapp.ui.horoscope.adapter
import android.view.View
import android.view.animation.LinearInterpolator
import androidx.recyclerview.widget.RecyclerView
import com.example.vviiblue.horoscapp.databinding.ItemHoroscopeBinding
import com.example.vviiblue.horoscapp.domain.model.HoroscopeInfo
class HoroscopeViewHolder(view: View) : RecyclerView.ViewHolder(view) {
private val binding = ItemHoroscopeBinding.bind(view)
private val context =
binding.tvHoroscope.context // cualquiera de las view/vistas tienen "contexto"
fun render(horoscopeInfo: HoroscopeInfo, onItemSelected: (HoroscopeInfo) -> Unit) {
binding.tvHoroscope.text = context.getString(horoscopeInfo.name)
binding.ivHoroscope.setImageResource(horoscopeInfo.img)
binding.parent.setOnClickListener { horoscopeSelected ->
/** antes de invocar a la operacion delegada(implementada en el HoroscopeFragment)
* voy a invocar una animacion, paso a la operacion la vista que se vera afectada por la animacion y
* una operacion lambda que "tendra dentro" la "opracion lambda onItemSelected"*/
startRotationAnimation(
binding.ivHoroscope,
newLambdaToExecItemSelected = { onItemSelected(horoscopeInfo) })
// onItemSelected(horoscopeInfo)
}
}
/** recibe una "View" por parametro que la operacion sea generica y acepte cualquier tipo de vista*/
fun startRotationAnimation(view: View, newLambdaToExecItemSelected: () -> Unit) {
/** agarro la animacion, le pido que se "anime" (animate()) , pero antes le aplico algunas propiedades "apply{}" */
view.animate().apply {
duration = 250// cuanto va a durar la animacion en milisegundos
interpolator =
LinearInterpolator() //El interpolator define el flujo/camino de la animacion, en este caso lineal "LinearInterpolator", la animacion va a tener la misma velocidad desde el principio hasta el final // Si se pusiera "acelerada", comenzarada lenta la animacion y luego terminaria mas rapido
// rotationBy(360f) //que el view gire 360° sobre su propio punto del medio, seria como una rueda
rotationYBy(180f) //que el view gire 180° sobre su eje y
/** Yo necesito que se ejecute la animacion entera, recien luego de que termina la animacion, ejecuto "onItemSelected(horoscopeInfo)"
* entonces para eso hago uso de "withEndAction{}", el codigo dentro de las llaves "{}" es otra funcion lambda, es por ello que
* le paso por paramtro la nueva operacion lambda (newLambdaToExecItemSelected que tiene dentro la operacion labda orginal) para que se ejecute dentro de las llaves
* asi es como se logra 1°) Animacion completa -> 2°) luego ejecucion de otra cosa*/
withEndAction { newLambdaToExecItemSelected() }
start()// que se ejecute la animacion
}
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/horoscope/adapter/HoroscopeViewHolder.kt | 835843116 |
package com.example.vviiblue.horoscapp.ui.horoscope.adapter
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import com.example.vviiblue.horoscapp.R
import com.example.vviiblue.horoscapp.domain.model.HoroscopeInfo
class HoroscopeAdapter(private var horoscopeList:List<HoroscopeInfo> = emptyList(), private val onItemSelected:(HoroscopeInfo) -> Unit) : RecyclerView.Adapter<HoroscopeViewHolder>() {
fun updateList(list:List<HoroscopeInfo>){
horoscopeList = list
notifyDataSetChanged()
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): HoroscopeViewHolder {
return HoroscopeViewHolder(LayoutInflater.from(parent.context).inflate( R.layout.item_horoscope,parent,false))
}
override fun getItemCount() = horoscopeList.size
override fun onBindViewHolder(holder: HoroscopeViewHolder, position: Int) {
/** "render" operacion definida en "HoroscopeViewHolder" */
holder.render(horoscopeList[position],onItemSelected)
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/horoscope/adapter/HoroscopeAdapter.kt | 3636263212 |
package com.example.vviiblue.horoscapp.ui.horoscope
import androidx.lifecycle.ViewModel
import com.example.vviiblue.horoscapp.data.providers.HoroscopeProvider
import com.example.vviiblue.horoscapp.domain.model.HoroscopeInfo
import com.example.vviiblue.horoscapp.domain.model.HoroscopeInfo.*
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import javax.inject.Inject
/** agregando la annotation @HiltViewModel, este viewModel ya queda preparado para conectar con DaggerHilr */
/** para meterle informacion/ inyectarle informacion , se agrega "@Inject constructor()",
* dentro de los parentecis del constructor() se puede inyetar la clase que se necesita en el HoroscopeViewModel, esto se encarga DaggerHilt */
@HiltViewModel
class HoroscopeViewModel @Inject constructor(private val horoscopeProvider: HoroscopeProvider) : ViewModel() {
/** el HoroscopeViewModel sera el encargadode recuperar la informacion (HoroscopeInfo)
* lo hara por estados (patron mvvm), para saber cuando debe obtener la informacion, siempre estara escuchando, para esto se usa StateFlow
* los FLow sera una comunicaacion constante siempre
* por lo tanta el fragment "HoroscopeFragment" se puede enganchar a un FLow que se defina aqui */
/** La idea es que el HoroscopeFragment se enganche al Flow que esta declarado en HoroscopeViewModel */
// **********************************************
/** declaro el flow, dentro del estado de Flow le pongo la lista de HoroscopeInfo y la inicializo vacia */
/** _horoscope es una variable mutable(que se puede modificar), pero la idea es que las modificaciones de esta variable no
* se generen de afuera, entonces se crea un valor que No es mutable que sea al que se pueda acceder desde afuera, y evito que desde
* afuera realicen modificaciones en la lista*/
private var _horoscope = MutableStateFlow<List<HoroscopeInfo>>(emptyList())
val horoscope:StateFlow<List<HoroscopeInfo>> = _horoscope // este valor sera el accesible desde el HoroscopeFragment...
/** viewmodel cuenta con un metodo especial, llamado "init", sera lo primero que se ejecutara es el "OnCreate" de las Activity */
init {
/** obtengo la lista de horoscopos de HoroscopeProvider, por medio de Dagger Hilt y se lo asigno al Flow */
val listHoroscopes:List<HoroscopeInfo> = horoscopeProvider.getHoroscopes()
_horoscope.value = listHoroscopes
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/horoscope/HoroscopeViewModel.kt | 1845549758 |
package com.example.vviiblue.horoscapp.ui.horoscope
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.viewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.navigation.fragment.findNavController
import androidx.recyclerview.widget.GridLayoutManager
import androidx.recyclerview.widget.LinearLayoutManager
import com.example.vviiblue.horoscapp.databinding.FragmentHoroscopeBinding
import com.example.vviiblue.horoscapp.domain.model.HoroscopeInfo
import com.example.vviiblue.horoscapp.domain.model.HoroscopeInfo.*
import com.example.vviiblue.horoscapp.domain.model.HoroscopeModel
import com.example.vviiblue.horoscapp.ui.horoscope.adapter.HoroscopeAdapter
import com.example.vviiblue.horoscapp.ui.palmistry.PalmistryFragment
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.launch
@AndroidEntryPoint
class HoroscopeFragment : Fragment() {
/** Tip: Si tuviera una "clase Padre" de esta(osea esta estenderia de esa clase padre), que estienda de "Fragment",
* se puede configurar el binding en esa clase padre y no es necesario inicializar el binding en cada una de estas clases */
/** La convención de nombres con un guión bajo inicial (_) indica que esta variable es mutable y puede cambiar su valor */
/** ¡Se declara el "binding" en un fragment, calramente es diferente de declararlo en un activity */
/** primero se declara un "_binding" que es nulleable
* luego si defino un "binding" que sobrescribe a la operacion get() y la igualo al "_binding"
* esto hace que cuando yo llame a "binding", lo que hare realmente es invocar a "_binding"*/
/** se definde _binding con la barra baja porque son variables privadas que no se deben acceder, se le pone el "_" para identificarlas
* entonces cuando se quiera accder al valor binding para usarlo, lo que va acceder es al "binding", que es un valor fijo pero
* por detras se estara llamando a la variable "_binding", que es el que se puede modificar o romper */
private var _binding: FragmentHoroscopeBinding? = null
private val binding get() = _binding!! // se le agrega "!!" porque cuando yo llame a "binding" yo estoy muy seguro que "_binding" NO va a ser null, porque primero le estoy inflando un valor al "_binding" en "onCreateView"
/** Para comunicar/enganchar el Fragment "HoroscopeFragment" con su ViewModel "HoroscopeViewModel" se */
/** se utiliza la función de extensión viewModels() para obtener una instancia de HoroscopeViewModel*/
/** viewModels() ayuda con la creación y recuperación de instancias de ViewModel.*/
private val horoscopeViewModel by viewModels<HoroscopeViewModel>() // by -> delega a ViewModelProvider la creacion de una instancia de HoroscopeViewModel
/** declaro adapter */
private lateinit var horoscopeAdapter: HoroscopeAdapter
/** Este metodo es el recomendado para cuando se trabaja con metodos configuracion,
* cuando la vista ya se ha creado, es mejor usar este metodo */
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
initUI()
}
private fun initUI() {
initUIState()
initRecycleview()
}
/** para que el fragment pueda leer/suscribirse/engancharse al StateFlow con la lista de horoscopos que tiene el viewModel
* y pueda quedar escuchando los cambios */
private fun initUIState() {
/** para realizar la suscripcion, necesito hacerlo dentro de la Corutine "lifecycleScope",
* porque usar la corutine "lifecycleScope"?, porque justa esta se engancha al ciclo de vida del Fragment, es idonea para eso
* de esta manera si el Fragmento va a morir, esta Corutine muere tambien, evitanso asi que se ejecuten metodos cuando el fragment este muriendo*/
/** SIEMPRE QUE SE VAYA A USAR UNA CORUTINE EN UN FRAGMENT O UN ACTIVITY, usar ----"lifecycleScope"!!!!!---- */
lifecycleScope.launch {
//"repeatOnLifecycle" -> es decir.. cuando empiece el ciclo de vida
repeatOnLifecycle(Lifecycle.State.STARTED) {
// agarro el HoroscopeViewModel y me engancho/suscribo(collect) al flow definido del el viewModel
horoscopeViewModel.horoscope.collect() { listHoroscopos ->
/** Entonces... para reafirmar conocimiento */
/** desde ahora SIEMPRE que modifique el "_horoscope.value" en el ViewModel
* automaticamente va a llmarse lo que se defino aqui dentro */
horoscopeAdapter.updateList(listHoroscopos)
}
}
}
}
private fun initRecycleview() {
horoscopeAdapter =
HoroscopeAdapter() { horoscopeSelected -> onItemSelected(horoscopeSelected) }
/** binding.rvHoroscope.apply = agarra esta vista (rvHoroscope) y le vas aplicar estos atributos*/
/** para evitar poner "binding.rvHoroscope.layoutManager" ,binding.rvHoroscope.adapter = ..... */
binding.rvHoroscope.apply {
// layoutManager = LinearLayoutManager(requireContext()) /** requireContext(),context -> para obtener el context en un FRAGMENT!! */
layoutManager = GridLayoutManager(
requireContext(),
2
) // Para que se muestra como grilla de 2 columnas de items el recycleview
adapter = horoscopeAdapter
}
}
private fun onItemSelected(horoscopeInfo: HoroscopeInfo) {
/** segun el tipo de HoroscopeInfo que entra por parametro, se devuelve el Enum correspondiente */
val tipoHoroscopoSeleccionado = when (horoscopeInfo){
Aries -> HoroscopeModel.Aries
Taurus -> HoroscopeModel.Taurus
Gemini -> HoroscopeModel.Gemini
Cancer -> HoroscopeModel.Cancer
Leo -> HoroscopeModel.Leo
Virgo -> HoroscopeModel.Virgo
Libra -> HoroscopeModel.Libra
Scorpio -> HoroscopeModel.Scorpio
Sagittarius -> HoroscopeModel.Sagittarius
Capricorn -> HoroscopeModel.Capricorn
Aquarius -> HoroscopeModel.Aquarius
Pisces -> HoroscopeModel.Pisces
}
/** entonces tipoHoroscopoSeleccionado contendra el modelo seleccionado representado como un Enumerado */
// ahora haciendo uso del navigation.safeargs se puede pasar el enumerado guardado en "tipoHoroscopoSeleccionado" a "HoroscopeDetailActivity"
// pero antes debe estar especificado en el main_graph que la pantalla "HoroscopeDetailActivity" va a recibir un argumento
/** una vez definido en el main_graph que tipo de argumento espera la pantalla, la action "actionHoroscopeFragmentToHoroscopeDetailActivity"
* se marcara en rojo exigiendo que se le pase ese argumento, por eso se le llama "safeargs" (argumento seguro) se encargara de obligarnos a pasar lo que se necestie*/
/** para navegar a la pantalla de detelles..., ya habiendo creado la "action" que se genera al hacer el enlace
* de la pantalla "HoroscopeFragment" con "HoroscopeDetailActivity" en el main_graph,
* se hace uso de "androidx.navigation.safeargs" que es la forma mas segura, "androidx.navigation.safeargs" autogenera clases por detras con las configuraciones necesarias.*/
/** entonces usando la operacion findNavController de "navController", se le pide que navegue a una pantalla (navigate) y
* en este caso navigate pide que se le pase una direction, en este caso ya deberia existir "HoroscopeFragmentDirections"
* que es la clase generada al realizar la conexion a los detalles en main_graph, dicha clase "HoroscopeFragmentDirections" conoce
* la action que se autogenero con el "id" que la representa "actionHoroscopeFragmentToHoroscopeDetailActivity"*/
findNavController().navigate(
HoroscopeFragmentDirections.actionHoroscopeFragmentToHoroscopeDetailActivity(tipoHoroscopoSeleccionado)
)
}
/** Este metodo se llama cuando se esta creando la vista del fragment */
/** es util para el principio de la vista*/
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
): View {
_binding = FragmentHoroscopeBinding.inflate(layoutInflater, container, false)
/** lo que devuelvo es el "binding" */
return binding.root
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/horoscope/HoroscopeFragment.kt | 2004281494 |
package com.example.vviiblue.horoscapp.ui.core
import android.content.Context
import android.view.GestureDetector
import android.view.MotionEvent
import android.view.View
/** como esto es algo "generico" para toda la aplicacion pero dentro de la capa ui
* genero un directorio core en "ui"
* la clase necesita "Context" y extiende de la clase "OnTouchListener" que pertenece a las vistas
* recordar que esta operacion sera una "personalizacion" de OnTouchListener para simular el "Swipe" para la ruleta*/
open class OnSwipeTouchListener(context: Context) : View.OnTouchListener {
companion object {
private const val SWIPE_THRESHOLD = 100
private const val SWIPE_VELOCITY_THRESHOLD = 100
}
/** GestureDetector: es una libreria de Android, que ayuda a detectar gestos */
private val gestureDetector: GestureDetector
// init es un contructor, es lo primero que se llama
init {
/** "Al detector de gestos" hay que pasarle un "Listener" (GestureListener())
* El "Listener" es el que crea lo que estamos haciendo con la mano */
gestureDetector = GestureDetector(context, GestureListener())
}
override fun onTouch(v: View, event: MotionEvent): Boolean {
return gestureDetector.onTouchEvent(event)
}
private inner class GestureListener : GestureDetector.SimpleOnGestureListener() {
override fun onDown(e: MotionEvent): Boolean {
return true
}
override fun onFling(
e1: MotionEvent?,
e2: MotionEvent,
velocityX: Float,
velocityY: Float
): Boolean {
var result = false
try {
val diffY = e2.y - e1!!.y
val diffX = e2.x - e1.x
if (Math.abs(diffX) > Math.abs(diffY)) {
if (Math.abs(diffX) > SWIPE_THRESHOLD && Math.abs(velocityX) > SWIPE_VELOCITY_THRESHOLD) {
if (diffX > 0) {
onSwipeRight()
} else {
onSwipeLeft()
}
result = true
}
} else if (Math.abs(diffY) > SWIPE_THRESHOLD && Math.abs(velocityY) > SWIPE_VELOCITY_THRESHOLD) {
if (diffY > 0) {
onSwipeBottom()
} else {
onSwipeTop()
}
result = true
}
} catch (exception: Exception) {
exception.printStackTrace()
}
return result
}
}
open fun onSwipeRight() {}
open fun onSwipeLeft() {}
open fun onSwipeTop() {}
open fun onSwipeBottom() {}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/core/OnSwipeTouchListener.kt | 3793029347 |
package com.example.vviiblue.horoscapp.ui.providers
import com.example.vviiblue.horoscapp.R
import com.example.vviiblue.horoscapp.ui.model.LuckyModel
import javax.inject.Inject
import kotlin.random.Random
/** Por norma general, para testear una operacion, debe estar en los mismos directorios en el directorio "test"
* entonces para no estar recreando todos los directorios para hacer el test de "RandomCardProvider"
* lo mejor es posicionar el mouse sobre la operacion "RandomCardProvider" y precionar CTRL+SHIFT+T
* por ultimo dar en crear test, crear*/
class RandomCardProvider @Inject constructor() {
fun getLuck(): LuckyModel?{
/** "when(Random.nextInt(0,32))" : hace un when con el valor int que me devuelva el int Random
* entre el valor "0" y el valor int "31", el "32" NO se incluye, cada int para obtener una de las 31 cartas
* nextInt(es "valor int inclusive" y "valor int exclusive")*/
return when(Random.nextInt(0,32)){
0 -> LuckyModel(R.drawable.card_fool, R.string.luck_0)
1 -> LuckyModel(R.drawable.card_moon, R.string.luck_1)
2 -> LuckyModel(R.drawable.card_hermit, R.string.luck_2)
3 -> LuckyModel(R.drawable.card_star, R.string.luck_3)
4 -> LuckyModel(R.drawable.card_sun, R.string.luck_4)
5 -> LuckyModel(R.drawable.card_sword, R.string.luck_5)
6 -> LuckyModel(R.drawable.card_chariot, R.string.luck_6)
7 -> LuckyModel(R.drawable.card_death, R.string.luck_7)
8 -> LuckyModel(R.drawable.card_devil, R.string.luck_8)
9 -> LuckyModel(R.drawable.card_empress, R.string.luck_9)
10 -> LuckyModel(R.drawable.card_hierophant, R.string.luck_10)
11 -> LuckyModel(R.drawable.card_ace_pentacles, R.string.luck_11)
12 -> LuckyModel(R.drawable.card_judgement, R.string.luck_12)
13 -> LuckyModel(R.drawable.card_world, R.string.luck_13)
14 -> LuckyModel(R.drawable.card_wheel_fortune, R.string.luck_14)
15 -> LuckyModel(R.drawable.card_tower, R.string.luck_15)
16 -> LuckyModel(R.drawable.card_temperance, R.string.luck_16)
17 -> LuckyModel(R.drawable.card_strength, R.string.luck_17)
18 -> LuckyModel(R.drawable.card_queen_wands, R.string.luck_18)
19 -> LuckyModel(R.drawable.card_queen_swords, R.string.luck_19)
20 -> LuckyModel(R.drawable.card_priestess, R.string.luck_20)
21 -> LuckyModel(R.drawable.card_nine_wands, R.string.luck_21)
22 -> LuckyModel(R.drawable.card_page_wands, R.string.luck_22)
23 -> LuckyModel(R.drawable.card_magician, R.string.luck_23)
24 -> LuckyModel(R.drawable.card_king_pentacles, R.string.luck_24)
25 -> LuckyModel(R.drawable.card_two_pentacles, R.string.luck_25)
26 -> LuckyModel(R.drawable.card_queen_pentacles, R.string.luck_26)
27 -> LuckyModel(R.drawable.card_justice, R.string.luck_27)
28 -> LuckyModel(R.drawable.card_king_swords, R.string.luck_28)
29 -> LuckyModel(R.drawable.card_king_wands, R.string.luck_29)
30 -> LuckyModel(R.drawable.card_king_cups, R.string.luck_30)
31 -> LuckyModel(R.drawable.card_king_pentacles, R.string.luck_31)
else -> null
}
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/providers/RandomCardProvider.kt | 1563667692 |
package com.example.vviiblue.horoscapp.ui.palmistry
import android.os.Bundle
import android.util.Log
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.camera.core.CameraSelector
import androidx.camera.core.Preview
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.core.content.ContextCompat
import androidx.core.content.PermissionChecker
import com.example.vviiblue.horoscapp.R
import com.example.vviiblue.horoscapp.databinding.FragmentPalmistryBinding
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class PalmistryFragment : Fragment() {
/** ¡Se declara el "binding" en un fragment, calramente es diferente de declararlo en un activity */
/** primero se declara un "_binding" que es nulleable
* luego si defino un "binding" que sobrescribe a la operacion get() y la igualo al "_binding"
* esto hace que cuando yo llame a "binding", lo que hare realmente es invocar a "_binding"*/
/** se definde _binding con la barra baja porque son variables privadas que no se deben acceder, se le pone el "_" para identificarlas
* entonces cuando se quiera accder al valor binding para usarlo, lo que va acceder es al "binding", que es un valor fijo pero
* por detras se estara llamando a la variable "_binding", que es el que se puede modificar o romper */
private var _binding: FragmentPalmistryBinding? = null
private val binding get() = _binding!!
/** Constante para guardar el permiso de la camara */
companion object {
private const val CAMERA_PERMISSION = android.Manifest.permission.CAMERA
}
/** para solicitar permiso en un fragment
* se inicializa y se carga "requestPermissionLauncher" con el resultado de llamar a "registerForActivityResult()"*/
private val requestPermissionLauncher = registerForActivityResult(
ActivityResultContracts.RequestPermission() //ActivityResultContracts.RequestPermission() : aqui se solicita el permiso
) { isGranted -> // isGranted: indica si el permiso fue otorgado o no (true o false)
if (isGranted) {
startCamera()
} else {
Toast.makeText(
requireContext(),
"Acepta los permisos para poder disfrutar de una experiencia mágica",
Toast.LENGTH_LONG
).show()
}
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
if (checkCameraPermission()) {
//Tiene permisos aceptados
startCamera()
} else {
/** Para pedir permisos en los Fragment se hace atravez de un luncher
* se le pide el permiso de camara (podria ser cualquier otro permiso) */
requestPermissionLauncher.launch(CAMERA_PERMISSION)
}
}
private fun startCamera() {
val cameraProviderFuture = ProcessCameraProvider.getInstance(requireContext())
// al gestor de la camara creado "cameraProviderFuture", se le agrega un listener
cameraProviderFuture.addListener({
/** Se obtiene el cameraProviderFuture y se le asocia al ciclo de vida del fragment */
val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
/** "also" es una funcion que permite hacer mas acciones sobre algo, en este caso sobre sobre el builder de Preview */
val preview = Preview.Builder()
.build()
.also {
/** para cargar la preview en la vista, se debe acceder asi "it.setSurfaceProvider(binding.viewFinder.surfaceProvider)"
* it es el Preview que estoy creando*/
it.setSurfaceProvider(binding.viewFinder.surfaceProvider)
}
/** se selecciona que camara se quiere usar por defecto, en este caso la camara de atras */
val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
try{
// unbindAll = que la cameraProvider que tengo se desenganche de cualquier cosa con la que se haya hecho bind ( por si se ha llamado muchas veces)
cameraProvider.unbindAll()
// ahora engancho el cameraProvider al ciclo de vida
cameraProvider.bindToLifecycle(this, cameraSelector, preview)
}catch (e:Exception){
Log.e("Error", "Algo fallo ${e.message}")
}
}, ContextCompat.getMainExecutor(requireContext()))
}
/** Operacion para gestionar los permisos, si el usuario ya acepto por ejemplo el permiso de la camara, no se lo voy a volver a pedir */
private fun checkCameraPermission(): Boolean {
/** PermissionChecker: Comprobador de permiso */
/** checkSelfPermission: Comprueba este permiso... */
return PermissionChecker.checkSelfPermission(
requireContext(),
CAMERA_PERMISSION
) == PermissionChecker.PERMISSION_GRANTED
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentPalmistryBinding.inflate(layoutInflater, container, false)
/** lo que devuelvo es el "binding" */
return binding.root
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/palmistry/PalmistryFragment.kt | 1620803508 |
package com.example.vviiblue.horoscapp.ui.detail
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.vviiblue.horoscapp.domain.model.HoroscopeModel
import com.example.vviiblue.horoscapp.domain.usecase.GetPredictionUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import javax.inject.Inject
/**Inyecto el caso de uso "getPredictionUseCase" para poder solicitar a la capa de domain, la informacion necesaria */
@HiltViewModel
class HoroscopeDetailViewModel @Inject constructor(private val getPredictionUseCase: GetPredictionUseCase) : ViewModel() {
/** Se crea el StateFlow, que sera enganchado por el "HoroscopeDetailActivity" */
private var _state =
MutableStateFlow<HoroscopeDetailState>(HoroscopeDetailState.Loading) // se le asigna un estado inicial
val state: StateFlow<HoroscopeDetailState> = _state
/** HoroscopeModel esta definido en domain, por la simplicidad del proyecto, se usa el model de la capa domain
* pero podria haber un model de horoscopo en la capa de ui y que se mappe por medio de una operacion,
* como lo hace "toDomain" para mappear de "PredictionResponse" definido en capa data a
* "HoroscopeModel" definida en domain y a su vez se podria pasar a "HoroscopeModel" definida en la capa ui con una operacion "toUi" por ejemplo....
* */
lateinit var horoscope: HoroscopeModel // este tipos de informacion que queremos mantener como un auxiliar, va simpre en el viewmodel
fun getHoroscope(sign: HoroscopeModel) {
horoscope = sign
/** lanzo una corrutina, para invocar la operacion del caso de uso que es Suspend */
viewModelScope.launch {
//cosas haciendose en el HILO principal
_state.value = HoroscopeDetailState.Loading
/** Como quiero que SOLO la logica del caso de uso lo haga en un hilo secundario, */
val result = withContext(Dispatchers.IO) { getPredictionUseCase(sign.name) } //cosas haciendose en el HILO secundario
//cosas haciendose en el HILO principal
if(result!=null){
_state.value = HoroscopeDetailState.Success(result.horoscope, result.sign, horoscope) // devuelvo un "HoroscopeDetailState" de tipo Success cargado con "(result.horoscope, result.sign, horoscope)"
}else{
_state.value = HoroscopeDetailState.Error("Ha ocurrido un error, intentelo mas tarde")
}
}
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/detail/HoroscopeDetailViewModel.kt | 3127151352 |
package com.example.vviiblue.horoscapp.ui.detail
import android.os.Bundle
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.isVisible
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.navigation.navArgs
import com.example.vviiblue.horoscapp.R
import com.example.vviiblue.horoscapp.databinding.ActivityHoroscopeDetailBinding
import com.example.vviiblue.horoscapp.domain.model.HoroscopeModel
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.launch
/** Activity a la que se llegara cuando se de click sobre uno de los hosocopos del HoroscopeFragment */
@AndroidEntryPoint
class HoroscopeDetailActivity : AppCompatActivity() {
private lateinit var binding: ActivityHoroscopeDetailBinding
/** Las dos formas son validas para inicializarel ViewModel, en uno se debe pasar el tipo al viewsModel porque no esta definido el tipo del valor*/
// private val horoscopeDetailViewModel by viewModels<HoroscopeDetailViewModel>()
private val horoscopeDetailViewModel: HoroscopeDetailViewModel by viewModels()
/** --------------------------------------------------- */
/** Recuperando el valor envidado desde "HoroscopeFragment" , las dos formas sirven*/
// private val args by navArgs<HoroscopeDetailActivityArgs>()
private val args: HoroscopeDetailActivityArgs by navArgs() // Ahora ya se sabe que tipo de horoscopo hay que consultar con Retrofi
/** Para esta pantalla se trabajara con FLow pero con Estados (pueden ser Error,Exito,Cargando ), para hacer esto, se crea una clase que gestione estos estados */
/** Entonces el mutable StateFlow sera de tipo "HoroscopeDetailState", entonces el viewModel seteara los estados en el Flow Loading, Error o Success ....
* */
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
/** args.tipoHoroscopoSeleccionado me devuelve el valor que pase por argumento, en este caso es el Enum que pase*/
binding = ActivityHoroscopeDetailBinding.inflate(layoutInflater)
setContentView(binding.root)
initUI()
horoscopeDetailViewModel.getHoroscope(args.tipoHoroscopoSeleccionado)
}
private fun initUI() {
initListeners()
initUIState()
}
private fun initListeners() {
//para el boton de retornar
binding.ivBack.setOnClickListener { onBackPressed() }
}
private fun initUIState() {
lifecycleScope.launch {
repeatOnLifecycle(Lifecycle.State.STARTED) {
horoscopeDetailViewModel.state.collect { estado ->
when (estado) { //Dependiendo del estado que se pone en el Flow, se realizara una accion en la ui
HoroscopeDetailState.Loading -> loadingState()
is HoroscopeDetailState.Error -> errorState()
is HoroscopeDetailState.Success -> successState(estado)
}
}
}
}
}
private fun loadingState() {
binding.pb.isVisible = true
}
private fun errorState() {
binding.pb.isVisible = false
}
private fun successState(estado: HoroscopeDetailState.Success) {
binding.pb.isVisible = false
binding.tvTitle.text = estado.sign
binding.tvBody.text = estado.prediccion
val referenciaImgHoroscopo = when (estado.horoscopeModel) {
HoroscopeModel.Aries -> R.drawable.detail_aries
HoroscopeModel.Taurus -> R.drawable.detail_taurus
HoroscopeModel.Gemini -> R.drawable.detail_gemini
HoroscopeModel.Cancer -> R.drawable.detail_cancer
HoroscopeModel.Leo -> R.drawable.detail_leo
HoroscopeModel.Virgo -> R.drawable.detail_virgo
HoroscopeModel.Libra -> R.drawable.detail_libra
HoroscopeModel.Scorpio -> R.drawable.detail_scorpio
HoroscopeModel.Sagittarius -> R.drawable.detail_sagittarius
HoroscopeModel.Capricorn -> R.drawable.detail_capricorn
HoroscopeModel.Aquarius -> R.drawable.detail_aquarius
HoroscopeModel.Pisces -> R.drawable.detail_pisces
}
binding.ivDetail.setImageResource(referenciaImgHoroscopo)
}
}
| Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/detail/HoroscopeDetailActivity.kt | 1596926357 |
package com.example.vviiblue.horoscapp.ui.detail
import com.example.vviiblue.horoscapp.domain.model.HoroscopeModel
/** Clase que gestiona los estados del Flow
* Segun el estado, la pantalla sabra lo que se tiene que hacer
* */
sealed class HoroscopeDetailState {
/** Cuando es un estado sencillo que no requiere parametros como por ejemplo Loading, se usa "data object" */
data object Loading:HoroscopeDetailState()
/** ¡¡¡¡ Cuando hay que pasarle parametros va a ser una "data class" !!!! */
data class Error(val errorMsg:String):HoroscopeDetailState()
data class Success(val prediccion:String,val sign:String, val horoscopeModel: HoroscopeModel):HoroscopeDetailState()
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/detail/HoroscopeDetailState.kt | 300619236 |
package com.example.vviiblue.horoscapp.ui.model
import androidx.annotation.DrawableRes
import androidx.annotation.StringRes
/** El modelo en ui que representara el modelo para mostrar la imagen y el texto de la prediccion */
/** como necetio un modelo de datos que pese lo menos posible, por eso solammente se pasa
* @DrawableRes val image:Int,
* @StringRes val text:Int
*sin necesidad de tener reerencias, porque no voy a necesitar tener todo a la vez
* @DrawableRes y @StringRes son anotaciones de "Android" por eso el modelo debe estar en la capa "ui"
* @DrawableRes nos obliga a que el valor que se le pase, sea una referencia de un Drawable
* @StringRes nos obliga a que el valor que se le pase, sea una referencia de un String
* Esto es una muy buena practica*/
data class LuckyModel(
@DrawableRes val image:Int,
@StringRes val text:Int
) | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/model/LuckyModel.kt | 3329139556 |
package com.example.vviiblue.horoscapp.ui.luck
import android.animation.ObjectAnimator
import android.annotation.SuppressLint
import android.content.Intent
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.animation.AlphaAnimation
import android.view.animation.Animation
import android.view.animation.Animation.AnimationListener
import android.view.animation.AnimationUtils
import android.view.animation.DecelerateInterpolator
import androidx.core.animation.doOnEnd
import androidx.core.view.isVisible
import com.example.vviiblue.horoscapp.R
import com.example.vviiblue.horoscapp.databinding.FragmentLuckBinding
import com.example.vviiblue.horoscapp.ui.core.OnSwipeTouchListener
import com.example.vviiblue.horoscapp.ui.providers.RandomCardProvider
import dagger.hilt.android.AndroidEntryPoint
import java.util.Random
import javax.inject.Inject
@AndroidEntryPoint
class LuckFragment : Fragment() {
private var _binding: FragmentLuckBinding? = null
private val binding get() = _binding!!
/** Inyecto el "RandomCardProvider" en el fragment "LuckFragment"
* esto funciona porque tengo la annotation "@AndroidEntryPoint"
* Esta es otra manera de hacer una inyeccion*/
@Inject
lateinit var randomCardProvider: RandomCardProvider
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
initUI()
}
private fun initUI() {
preparePrediction()
initListeners()
}
private fun preparePrediction() {
/** para tener una informacion lista para mostrar */
val luck = randomCardProvider.getLuck()
// Me aseguro que lo que se haga dentro de la llave{}, me asegura que no va a ser null porque tiene "?" y "let"
// por lo que se puede ver que el LuckModel dentro de la llave no es nullable (el "suerteQueMeTodo")
luck?.let { suerteQueMeTodo ->
val currentPrediccition = getString(suerteQueMeTodo.text)
binding.tvLucky.text = currentPrediccition
binding.ivLuckyCard.setImageResource(suerteQueMeTodo.image)
binding.tvShare.setOnClickListener { shareResult(currentPrediccition) }
}
}
/** Operacion para compartir con otras app */
private fun shareResult(currentPrediccition: String) {
/** para compartir uso un "Intent", con una accion especifica, los Intent tiene muchas acctiones */
val sendIntent= Intent().apply {
action = Intent.ACTION_SEND //la accion que se le va a dar al Intent, en este caso para "enviar"
putExtra(Intent.EXTRA_TEXT,currentPrediccition) //lo que voy a compartir
type = "text/plain" // Es importante especificar el tipo, para que sepa que lo que se va a comprarir es un texto
}
/** "createChooser": Es el seleccionador, dependiendo de las aplicaciones instaladas
* en el dispositivo mostrara mas o menos aplicaciones */
val shareIntent = Intent.createChooser(sendIntent,null) // se le pasa el intent creado con la "accion de enviar", y se le puede poner un "titulo", en este caso no se pone "titulo" y se dejo en "null"
startActivity(shareIntent) // se inicia el intent
}
@SuppressLint("ClickableViewAccessibility") //para anular wl warning que me daba en el metodo
private fun initListeners() {
// binding.ivRoulette.setOnClickListener { spinRoulette() }
/** Para hacer un Swipe, hay que hacerlo personalizado
* android no da nada para calcular un swipe izquierda o derecha,
* entonces hay que hacerlo personalizando uno de sus Listener, el "setOnTouchListener"
* para sobrescribir el "setOnTouchListener", se le pasa "setOnTouchListener(object : OnSwipeTouchListener(requireContext())"
* asi el setOnTouchListener recibe la calse que hice y que hereda de "OnTouchListener"
* */
binding.ivRoulette.setOnTouchListener(object : OnSwipeTouchListener(requireContext()){
/** como OnSwipeTouchListener es una clase abierta (open class) puedo sobreescribir los metodos que me interesan */
override fun onSwipeRight() {
spinRoulette()
}
override fun onSwipeLeft() {
spinRoulette()
}
})
}
private fun spinRoulette() { //metodo para que la ruleta gire, nada mas
val random = Random()
val degrees =
random.nextInt(1440) + 360 // cuantos grados va a girar, se agrega random para que la cantidad de grados no sea igual siempre
// creo un objeto animator
val animator = ObjectAnimator
.ofFloat(
binding.ivRoulette, //vista a la que quiero aplicar una animacion
View.ROTATION, //Se pueden hacer "muchos" cambios para aplicar y hacer la animacion, elijo ROTATION gira sobre el punto medio de la vista (la imagen) sino se puede poner para rotar sobre los ejes
0f, //va a rotar desde 0 grados
degrees.toFloat() // va a rotar hasta degrees.toFloat() grados
)
/** la animacion va a durar 2 segundos */
animator.duration = 2000
/** le indico el interpolator de la aniamcion si es lineal va siempre a la misma velocidad la animacion y si es "DecelerateInterpolator" empieza rapida y luego se va enlenteciendo (asi funcionan las ruletas...)*/
animator.interpolator = DecelerateInterpolator()
/** Le indico que "cuando termine la animacion", va a llamar a la funcion lambda slideCard() */
animator.doOnEnd { slideCard() }
/** ejecutar la animacion */
animator.start()
}
// Otra forma de crear animacion en android...
private fun slideCard() {
/** Esta funcion va a crear una animacion para mostrar que se desliza una carta hacia arriba,
* y si, esta animacion se ejecuta al final de la anterior, es un enganche de animaciones */
//Usando la herramienta "AnimationUtils" de animaciones de android,
// para cargar animaciones creadas en xml
/** Creo un directorio llamado anim y dentro creo la animacion "slide_up" */
/** en la animacion creada se define la traslacion de la vista "binding.ivReverse"*/
val slideUpAnimation = AnimationUtils
.loadAnimation( //cargo una animacion existente
requireContext(), // solicito un contexto
R.anim.slide_up //paso la animacion que quiero cargar del .xml
)
/** para conrolar los estados de la animacion */
/** cuando se usa "AnimationUtils" es por medio de */
/** para conrolar los estados de la animacion setAnimationListener */
/** Si quiero que haga algo "cuando empiece la animacion" impelemnto "onAnimationStart(p0: Animation?)" */
/** Si quiero que haga algo "cuando termine la animacion" impelemnto "onAnimationEnd(p0: Animation?)" */
/** Si quiero que haga algo "cuando se vata a REPETIR la animacion" impelemnto "onAnimationRepeat(p0: Animation?)" */
slideUpAnimation.setAnimationListener(object : Animation.AnimationListener {
override fun onAnimationStart(p0: Animation?) {
// Cuando la animacion vaya a empezar, hace visible la vista (el Imagen View)
binding.ivReverse.isVisible = true
}
override fun onAnimationEnd(p0: Animation?) {
//cuando la animacion finalice, invoco otra operacion para ejecutar la animacion que haga crecer la vista (ImagenView)
growCard()
}
/** Se puede configurar para que se ejecute n veces */
override fun onAnimationRepeat(p0: Animation?) {
// En este caso no quiero que haga nada
}
})
/** IMPORTANTE, para cargar una animacion la vista tiene que haber precargado el render, osea tiene que estar en la pantalla
* si no se quiere ver tiene que estar como Invisible, jamas como "gone",
* en "gone" no esta cargado aun en el render de la app" */
//por ulitmo para ejecutar la animacion, tomo la vista, le pido que inicie una animacion "startAnimation" y
// le paso la animacion que debe iniciar
binding.ivReverse.startAnimation(slideUpAnimation)
}
private fun growCard() {
val growAnimation = AnimationUtils.loadAnimation(requireContext(), R.anim.grow)
growAnimation.setAnimationListener(object : Animation.AnimationListener {
override fun onAnimationStart(p0: Animation?) {
}
override fun onAnimationEnd(p0: Animation?) {
// Cuando la animacion vaya a terminar, oculta la vista (el Imagen View)
binding.ivReverse.isVisible = false
//ejecuto funcion al finalizar la animacion, para mostrar la nueva vista, con una animacion que la muestre
showPremonitionView()
}
override fun onAnimationRepeat(p0: Animation?) {
}
})
binding.ivReverse.startAnimation(growAnimation)
}
private fun showPremonitionView() {
/** Otro tipo de animacion, ademas de la manual con AnimationObject o animationUtil */
/** animacion creada con "AlphaAnimation", AlphaAnimation lo que hace es cambiar la opacidad
* en este caso 1.0f es el 100% visible y lo pasa a 0.0f que seria 0% visible */
val disappearAnimation = AlphaAnimation(1.0f, 0.0f)
disappearAnimation.duration = 200 //la animacion va a pasar en 200 milisegundos
/** animacion creada con "AlphaAnimation",
* en este caso 0.0f es el 0% visible y lo pasa a 1.0f que seria 100% visible, esto
* para que la imagen de la vista de la prediccion se muestre de a poco y mejore la experiencia del usuario*/
val appearAnimation = AlphaAnimation(0.0f, 1.0f)
appearAnimation.duration = 1000
// ahora le aplico listener al "AlphaAnimation"
disappearAnimation.setAnimationListener(object : AnimationListener {
override fun onAnimationStart(p0: Animation?) {
}
override fun onAnimationEnd(p0: Animation?) {
/** Cuando termine esta aniamacion, voy a mandar a "Gone" la vista con que tiene la ruleta y
* a la vista que muestra la prediccion y el boton de compartir lo hago "Visible" */
binding.viewPreview.isVisible = false
binding.viewPrediction.isVisible = true
}
override fun onAnimationRepeat(p0: Animation?) {
}
})
binding.viewPreview.startAnimation(disappearAnimation)
binding.viewPrediction.startAnimation(appearAnimation)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentLuckBinding.inflate(layoutInflater, container, false)
return binding.root
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/luck/LuckFragment.kt | 3741635415 |
package com.example.vviiblue.horoscapp.ui.luck
import androidx.lifecycle.ViewModel
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
@HiltViewModel
class LuckViewModel @Inject constructor() : ViewModel(){
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/ui/luck/LuckViewModel.kt | 3557006375 |
package com.example.vviiblue.horoscapp
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
/** Defino la primer clase que se va a leer de toda la aplicacion, lo que define a esta clase como esa clase... , debe extender de "Application()" */
/** por ultimo de agregarla en el manifest
*
* para configurar DaggerHilt se agrega la annotation "HiltAndroidApp"*/
@HiltAndroidApp
class HoroscApp: Application() | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/HoroscApp.kt | 947615969 |
package com.example.vviiblue.horoscapp.data.core.interceptors
import okhttp3.Interceptor
import okhttp3.Response
import javax.inject.Inject
/** El directorio "core" tendra todas las cosas genericas que se puedan usar en la capa de "data" */
/** Entonces dentro del directorio de cosas genericas se hace un directorio solo para los interceptors*/
/** A modo de ejemplo, se pone en la situacion de por ejemplo esta es una aplicacion
* que tiene Login, despues de ese login el servidor te daria un token, entonces a cada llamada al servidor
* se le deberia pasar el "token" que te dio el servidor, y ese token se tiene que mandar en la cabecera de la llamada (Header)
* sea una consulta para obtener la prediccion del zodiaco o para crear un nuevo usuario...
* el "token" es un codigo de validacion, que confirma que yo soy el usuario que se acaba de loguear a la app
* asi que... un ejemplo de "Interceptor" para ese caso seria "AuthInterceptor", que se creeara de forma manual*/
class AuthInterceptor @Inject constructor(private val tokenManager: TokenManager) : Interceptor { // le agrego el "@Inject constructor" para poder inyectarla luego en el "NetworkModule"
override fun intercept(chain: Interceptor.Chain): Response {
// esta "chain: Interceptor.Chain" es la llamada que va hacer retrofit ,
// (chain.request() es justo la peticion al servidor), yo la obtengo y le agrego el "header" y
// por ultimo la devuelvo como "Response" para que siga su camino al servidor
val request = chain
.request()
.newBuilder() /** "newBuilder" = "vuelvete a crear sin perder la informacion, pero con algo nuevo (el header, en este caso) " */
.header("Autorization",tokenManager.getToken()) //header( clave = "Autorization", valor = tokenManager.getToken() )
.build()
return chain.proceed(request)
}
}
/** esta calse deberia estar en otro sitio, esta aqui para cumplir con el ejemplo */
class TokenManager @Inject constructor(){
fun getToken():String = "Esto es una prueba!!!"
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/data/core/interceptors/AuthInterceptor.kt | 365979457 |
package com.example.vviiblue.horoscapp.data.providers
import com.example.vviiblue.horoscapp.domain.model.HoroscopeInfo
import com.example.vviiblue.horoscapp.domain.model.HoroscopeInfo.*
import javax.inject.Inject
/** Clase encargada de mandar a domain los hoscopos */
/** para recuperar esta informacion, se puede hacer de 2 formas*/
/** 1° forma) Siguiendo Clean Arquitecture, en la capa de "domain" se puede crear un Caso de Uso,
* "Caso de Uso" (es una clase que hace realiza la logica necesaria para devolverle al "View Model" lo que necesita),
* en este caso se deberia realizar una clase en domain para devolverle al View Model la lista de horoscopos y mas nada,
* no seria correcto solo para esto.
* 2° forma) Aplicar inyeccion de dependencia (Dagger Hilt), entonces en el ViewModel, solicito un objeto de tipo HoroscopeProvider,
* y daggerHilt se encargara de devolverlo en ViewModel para luego ejecutar la operacion definida aqui getHoroscopes(),
* PERO para hacer eso, hay que preparar esta clase para que Dagger Hilt la pueda inyectar donde se necesite
* por lo que se agrega -- "@Inject constructor()" -- */
class HoroscopeProvider @Inject constructor() {
fun getHoroscopes():List<HoroscopeInfo>{
return listOf(
Aries,
Taurus,
Gemini,
Cancer,
Leo,
Virgo,
Libra,
Scorpio,
Sagittarius,
Capricorn,
Aquarius,
Pisces
)
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/data/providers/HoroscopeProvider.kt | 1162304921 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.