content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package me.yufan.kmmtranslator.core.domain.util
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
actual open class CommonMutableStateFlow<T> actual constructor(
private val flow: MutableStateFlow<T>
) : CommonStateFlow<T>(flow), MutableStateFlow<T> {
override var value: T
get() = super.value
set(value) {
flow.value = value
}
override val subscriptionCount: StateFlow<Int>
get() = flow.subscriptionCount
override fun compareAndSet(expect: T, update: T): Boolean {
return flow.compareAndSet(expect, update)
}
@ExperimentalCoroutinesApi
override fun resetReplayCache() {
flow.resetReplayCache()
}
override fun tryEmit(value: T): Boolean {
return flow.tryEmit(value)
}
override suspend fun emit(value: T) {
flow.emit(value)
}
} | KMMTranslator/shared/src/iosMain/kotlin/me/yufan/kmmtranslator/core/domain/util/CommonMutableStateFlow.kt | 3882256288 |
package me.yufan.kmmtranslator.core.presentation
import me.yufan.kmmtranslator.core.domain.language.Language
actual class UILanguage(
actual val language: Language,
val imageName: String
) {
actual companion object {
actual fun byCode(langCode: String): UILanguage {
return allLanguages.find { it.language.langCode == langCode }
?: throw IllegalArgumentException("Invalid or unsupported language code")
}
actual val allLanguages: List<UILanguage>
get() = Language.entries.map { language ->
UILanguage(
language = language,
imageName = language.langName.lowercase()
)
}
}
} | KMMTranslator/shared/src/iosMain/kotlin/me/yufan/kmmtranslator/core/presentation/UILanguage.kt | 3028127937 |
package me.yufan.kmmtranslator.translate.data.local
import com.squareup.sqldelight.Transacter
import com.squareup.sqldelight.db.SqlCursor
import com.squareup.sqldelight.db.SqlDriver
import com.squareup.sqldelight.db.SqlPreparedStatement
actual class DatabaseDriverFactory {
actual fun create(): SqlDriver {
// return NativeSqliteDriver(
// TranslateDatabase.Schema,
// "translate.db"
// )
return Driver()
}
class Driver() : SqlDriver {
override fun currentTransaction(): Transacter.Transaction? {
TODO("Not yet implemented")
}
override fun execute(
identifier: Int?,
sql: String,
parameters: Int,
binders: (SqlPreparedStatement.() -> Unit)?
) {
TODO("Not yet implemented")
}
override fun executeQuery(
identifier: Int?,
sql: String,
parameters: Int,
binders: (SqlPreparedStatement.() -> Unit)?
): SqlCursor {
TODO("Not yet implemented")
}
override fun newTransaction(): Transacter.Transaction {
TODO("Not yet implemented")
}
override fun close() {
TODO("Not yet implemented")
}
}
} | KMMTranslator/shared/src/iosMain/kotlin/me/yufan/kmmtranslator/translate/data/local/DatabaseDriverFactory.kt | 1948489734 |
package me.yufan.kmmtranslator.translate.data.remote
import io.ktor.client.HttpClient
import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
import io.ktor.serialization.kotlinx.json.json
actual class HttpClientFactory {
actual fun create(): HttpClient {
// Darwin
return HttpClient() {
install(ContentNegotiation) {
json()
}
}
}
} | KMMTranslator/shared/src/iosMain/kotlin/me/yufan/kmmtranslator/translate/data/remote/HttpClientFactory.kt | 3231448526 |
package me.yufan.kmmtranslator
import platform.UIKit.UIDevice
class IOSPlatform: Platform {
override val name: String = UIDevice.currentDevice.systemName() + " " + UIDevice.currentDevice.systemVersion
}
actual fun getPlatform(): Platform = IOSPlatform() | KMMTranslator/shared/src/iosMain/kotlin/me/yufan/kmmtranslator/Platform.ios.kt | 553821409 |
package me.yufan.kmmtranslator.core.domain.util
import kotlinx.coroutines.flow.Flow
expect class CommonFlow<T>(flow: Flow<T>): Flow<T>
fun <T> Flow<T>.toCommonFlow() = CommonFlow(this) | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/core/domain/util/CommonFlow.kt | 1303189296 |
package me.yufan.kmmtranslator.core.domain.util
import kotlinx.coroutines.flow.StateFlow
expect class CommonStateFlow<T>(flow: StateFlow<T>) : StateFlow<T>
fun <T> StateFlow<T>.toCommonStateFlow() = CommonStateFlow(this) | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/core/domain/util/CommonStateFlow.kt | 2731102216 |
package me.yufan.kmmtranslator.core.domain.util
sealed class Resource<T>(val data: T?, val throwable: Throwable? = null) {
class Success<T>(data: T) : Resource<T>(data)
class Error<T>(throwable: Throwable) : Resource<T>(null, throwable)
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/core/domain/util/Resource.kt | 2819407139 |
package me.yufan.kmmtranslator.core.domain.util
import kotlinx.coroutines.flow.MutableStateFlow
expect class CommonMutableStateFlow<T>(flow: MutableStateFlow<T>) : MutableStateFlow<T>
fun <T> MutableStateFlow<T>.toCommonMutableStateFlow() = CommonMutableStateFlow(this) | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/core/domain/util/CommonMutableStateFlow.kt | 2587932068 |
package me.yufan.kmmtranslator.core.domain.language
enum class Language(
val langCode: String,
val langName: String
) {
ENGLISH("en", "English"),
ARABIC("ar", "Arabic"),
AZERBAIJANI("az", "Azerbaijani"),
CHINESE("zh", "Chinese"),
CZECH("cs", "Czech"),
DANISH("da", "Danish"),
DUTCH("nl", "Dutch"),
FINNISH("fi", "Finnish"),
FRENCH("fr", "French"),
GERMAN("de", "German"),
GREEK("el", "Greek"),
HEBREW("he", "Hebrew"),
HINDI("hi", "Hindi"),
HUNGARIAN("hu", "Hungarian"),
INDONESIAN("id", "Indonesian"),
IRISH("ga", "Irish"),
ITALIAN("it", "Italian"),
JAPANESE("ja", "Japanese"),
KOREAN("ko", "Korean"),
PERSIAN("fa", "Persian"),
POLISH("pl", "Polish"),
PORTUGUESE("pt", "Portuguese"),
RUSSIAN("ru", "Russian"),
SLOVAK("sk", "Slovak"),
SPANISH("es", "Spanish"),
SWEDISH("sv", "Swedish"),
TURKISH("tr", "Turkish"),
UKRAINIAN("uk", "Ukrainian");
companion object {
fun byCode(code: String): Language {
return entries.find { it.langCode == code }
?: throw IllegalArgumentException("Invalid or unsupported language code")
}
}
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/core/domain/language/Language.kt | 594411105 |
package me.yufan.kmmtranslator.core.presentation
object Colors {
const val LightBlue = 0xFFA8A5BB
const val LightBlueGrey = 0xFFF6F4F4
const val AccentViolet = 0xFF5643C9
const val TextBlack = 0xFF111111
const val DarkGrey = 0xFF282C31
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/core/presentation/Colors.kt | 518216573 |
package me.yufan.kmmtranslator.core.presentation
import me.yufan.kmmtranslator.core.domain.language.Language
expect class UILanguage {
val language: Language
companion object {
fun byCode(langCode: String): UILanguage
val allLanguages: List<UILanguage>
}
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/core/presentation/UILanguage.kt | 3611781916 |
package me.yufan.kmmtranslator
interface Platform {
val name: String
}
expect fun getPlatform(): Platform | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/Platform.kt | 1994930261 |
package me.yufan.kmmtranslator.translate.data.translate
import kotlinx.serialization.SerialName
@kotlinx.serialization.Serializable
data class TranslateDto(
@SerialName("q") val textToTranslate: String,
@SerialName("source") val sourceLanguageCode: String,
@SerialName("target") val targetLanguage: String
)
| KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/data/translate/TranslateDto.kt | 3570117673 |
package me.yufan.kmmtranslator.translate.data.translate
@kotlinx.serialization.Serializable
data class TranslatedDto(
val translatedText: String
)
| KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/data/translate/TranslatedDto.kt | 3255309848 |
package me.yufan.kmmtranslator.translate.data.translate
import io.ktor.client.HttpClient
import io.ktor.client.call.body
import io.ktor.client.request.post
import io.ktor.client.request.setBody
import io.ktor.client.request.url
import io.ktor.http.ContentType
import io.ktor.http.contentType
import io.ktor.utils.io.errors.IOException
import me.yufan.kmmtranslator.NetworkConstants
import me.yufan.kmmtranslator.core.domain.language.Language
import me.yufan.kmmtranslator.translate.domain.translate.TranslateClient
import me.yufan.kmmtranslator.translate.domain.translate.TranslateError
import me.yufan.kmmtranslator.translate.domain.translate.TranslateException
class KtorTranslateClient(
private val httpClient: HttpClient
) : TranslateClient {
override suspend fun translate(
fromLanguage: Language,
fromText: String,
toLanguage: Language
): String {
val result = try {
httpClient.post {
url(NetworkConstants.BASE_URL + "/translate")
contentType(ContentType.Application.Json)
setBody(
TranslateDto(
textToTranslate = fromText,
sourceLanguageCode = fromLanguage.langCode,
targetLanguage = toLanguage.langCode
)
)
}
} catch (e: IOException) {
throw TranslateException(TranslateError.SERVICE_UNAVAILABLE)
}
when (result.status.value) {
in 200..299 -> Unit
500 -> throw TranslateException(TranslateError.SERVER_ERROR)
in 400..499 -> throw TranslateException(TranslateError.CLIENT_ERROR)
else -> throw TranslateException(TranslateError.UNKNOWN_ERROR)
}
return try {
result.body<TranslatedDto>().translatedText
} catch (e: Exception) {
throw TranslateException(TranslateError.SERVER_ERROR)
}
}
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/data/translate/KtorTranslateClient.kt | 3347713347 |
package me.yufan.kmmtranslator.translate.data.local
import com.squareup.sqldelight.db.SqlDriver
expect class DatabaseDriverFactory {
fun create(): SqlDriver
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/data/local/DatabaseDriverFactory.kt | 3353724033 |
package me.yufan.kmmtranslator.translate.data.history
import com.squareup.sqldelight.runtime.coroutines.asFlow
import com.squareup.sqldelight.runtime.coroutines.mapToList
import kotlinx.coroutines.flow.map
import kotlinx.datetime.Clock
import me.yufan.kmmtranslator.core.domain.util.CommonFlow
import me.yufan.kmmtranslator.core.domain.util.toCommonFlow
import me.yufan.kmmtranslator.database.TranslateDatabase
import me.yufan.kmmtranslator.translate.domain.history.HistoryDataSource
import me.yufan.kmmtranslator.translate.domain.history.HistoryItem
class SqlDelightHistoryDataSource(
db: TranslateDatabase
) : HistoryDataSource {
private val queries = db.translateQueries
override fun getHistory(): CommonFlow<List<HistoryItem>> {
return queries
.getHistory()
.asFlow()
.mapToList()
.map { historyList ->
historyList.map { history ->
history.toHistoryItem()
}
}.toCommonFlow()
}
override suspend fun insertHistoryItem(item: HistoryItem) {
queries.insertHistoryEntity(
id = item.id,
fromLanguageCode = item.fromLanguageCode,
fromText = item.fromText,
toLanguageCode = item.toLanguageCode,
toText = item.toText,
timestamp = Clock.System.now().toEpochMilliseconds()
)
}
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/data/history/SqlDelightHistoryDataSource.kt | 728315514 |
package me.yufan.kmmtranslator.translate.data.history
import database.HistoryEntity
import me.yufan.kmmtranslator.translate.domain.history.HistoryItem
fun HistoryEntity.toHistoryItem(): HistoryItem {
return HistoryItem(
id = id,
fromLanguageCode = fromLanguageCode,
fromText = fromText,
toLanguageCode = toLanguageCode,
toText = toText
)
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/data/history/HistoryItemMapper.kt | 308120002 |
package me.yufan.kmmtranslator.translate.data.remote
import io.ktor.client.HttpClient
expect class HttpClientFactory {
fun create(): HttpClient
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/data/remote/HttpClientFactory.kt | 2781125700 |
package me.yufan.kmmtranslator.translate.domain.translate
import me.yufan.kmmtranslator.core.domain.language.Language
interface TranslateClient {
suspend fun translate(
fromLanguage: Language,
fromText: String,
toLanguage: Language
): String
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/domain/translate/TranslateClient.kt | 2439357598 |
package me.yufan.kmmtranslator.translate.domain.translate
import me.yufan.kmmtranslator.core.domain.language.Language
import me.yufan.kmmtranslator.core.domain.util.Resource
import me.yufan.kmmtranslator.translate.domain.history.HistoryDataSource
import me.yufan.kmmtranslator.translate.domain.history.HistoryItem
class Translate(
private val client: TranslateClient,
private val historyDataSource: HistoryDataSource
) {
suspend fun execute(
fromLanguage: Language,
fromText: String,
toLanguage: Language
): Resource<String> {
return try {
val translateText = client.translate(
fromLanguage,
fromText,
toLanguage
)
historyDataSource.insertHistoryItem(
HistoryItem(
id = null,
fromLanguageCode = fromLanguage.langCode,
fromText = fromText,
toLanguageCode = toLanguage.langCode,
toText = translateText
)
)
Resource.Success(translateText)
} catch (e: TranslateException) {
e.printStackTrace()
Resource.Error(e)
}
}
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/domain/translate/Translate.kt | 2018013179 |
package me.yufan.kmmtranslator.translate.domain.translate
enum class TranslateError {
SERVICE_UNAVAILABLE,
CLIENT_ERROR,
SERVER_ERROR,
UNKNOWN_ERROR
}
class TranslateException(val error: TranslateError) : Exception(
"An error occurred when translating: $error"
)
| KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/domain/translate/TranslateError.kt | 2769032667 |
package me.yufan.kmmtranslator.translate.domain.history
data class HistoryItem(
val id: Long?,
val fromLanguageCode: String,
val fromText: String,
val toLanguageCode: String,
val toText: String
)
| KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/domain/history/HistoryItem.kt | 1265973341 |
package me.yufan.kmmtranslator.translate.domain.history
import me.yufan.kmmtranslator.core.domain.util.CommonFlow
interface HistoryDataSource {
fun getHistory(): CommonFlow<List<HistoryItem>>
suspend fun insertHistoryItem(item: HistoryItem)
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/domain/history/HistoryDataSource.kt | 3591613755 |
package me.yufan.kmmtranslator.translate.presentation
import me.yufan.kmmtranslator.core.presentation.UILanguage
import me.yufan.kmmtranslator.translate.domain.translate.TranslateError
data class TranslateState(
val fromText: String = "",
val toText: String? = null,
val isTranslating: Boolean = false,
val fromLanguage: UILanguage = UILanguage.byCode("en"),
val toLanguage: UILanguage = UILanguage.byCode("zh"),
val isChoosingFromLanguage: Boolean = false,
val isChoosingToLanguage: Boolean = false,
val error: TranslateError? = null,
val historyItemList: List<UIHistoryItem> = emptyList()
)
| KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/presentation/TranslateState.kt | 4096014660 |
package me.yufan.kmmtranslator.translate.presentation
import me.yufan.kmmtranslator.core.presentation.UILanguage
data class UIHistoryItem(
val id: Long,
val fromText: String,
val toText: String,
val fromLanguage: UILanguage,
val toLanguage: UILanguage
) | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/presentation/UIHistoryItem.kt | 2564638966 |
package me.yufan.kmmtranslator.translate.presentation
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.flow.updateAndGet
import kotlinx.coroutines.launch
import me.yufan.kmmtranslator.core.domain.util.Resource
import me.yufan.kmmtranslator.core.domain.util.toCommonStateFlow
import me.yufan.kmmtranslator.core.presentation.UILanguage
import me.yufan.kmmtranslator.translate.domain.history.HistoryDataSource
import me.yufan.kmmtranslator.translate.domain.translate.Translate
import me.yufan.kmmtranslator.translate.domain.translate.TranslateException
class TranslateViewModel(
private val translate: Translate,
private val historyDataSource: HistoryDataSource,
private val coroutineScope: CoroutineScope?
) {
private val viewModelScope = coroutineScope ?: CoroutineScope(Dispatchers.Main)
private val _state = MutableStateFlow(TranslateState())
val state = combine(
_state,
historyDataSource.getHistory()
) { state, list ->
if (state.historyItemList != list) {
state.copy(
historyItemList = list.mapNotNull { item ->
UIHistoryItem(
id = item.id ?: return@mapNotNull null,
fromText = item.fromText,
toText = item.toText,
fromLanguage = UILanguage.byCode(item.fromLanguageCode),
toLanguage = UILanguage.byCode(item.toLanguageCode)
)
}
)
} else state
}.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), TranslateState())
.toCommonStateFlow()
private var translateJob: Job? = null
private fun translate(state: TranslateState) {
if (state.isTranslating || state.fromText.isBlank()) {
return
}
translateJob = viewModelScope.launch {
_state.update {
it.copy(
isTranslating = true
)
}
val result = translate.execute(
fromLanguage = state.fromLanguage.language,
fromText = state.fromText,
toLanguage = state.toLanguage.language
)
when (result) {
is Resource.Success -> {
_state.update {
it.copy(
isTranslating = false,
toText = result.data
)
}
}
is Resource.Error -> {
_state.update {
it.copy(
isTranslating = false,
error = (result.throwable as? TranslateException)?.error
)
}
}
}
}
}
fun onEvent(event: TranslateEvent) {
when (event) {
is TranslateEvent.ChangeTranslationText -> {
_state.update {
it.copy(
fromText = event.text
)
}
}
is TranslateEvent.ChooseFromLanguage -> {
_state.update {
it.copy(
isChoosingFromLanguage = false,
fromLanguage = event.language
)
}
}
is TranslateEvent.ChooseToLanguage -> {
val newState = _state.updateAndGet {
it.copy(
isChoosingToLanguage = false,
toLanguage = event.language
)
}
translate(newState)
}
TranslateEvent.CloseTranslation -> {
_state.update {
it.copy(
isTranslating = false,
fromText = "",
toText = null
)
}
}
TranslateEvent.EditTranslation -> {
if (state.value.toText != null) {
_state.update {
it.copy(
toText = null,
isTranslating = false
)
}
}
}
TranslateEvent.OnErrorSeen -> {
_state.update { it.copy(error = null) }
}
TranslateEvent.OpenFromLanguageDropDown -> {
_state.update {
it.copy(
isChoosingFromLanguage = true
)
}
}
TranslateEvent.OpenToLanguageDropDown -> {
_state.update {
it.copy(
isChoosingToLanguage = true
)
}
}
is TranslateEvent.SelectHistoryItem -> {
translateJob?.cancel()
_state.update {
it.copy(
fromText = event.item.fromText,
toText = event.item.toText,
isTranslating = false,
fromLanguage = event.item.fromLanguage,
toLanguage = event.item.toLanguage
)
}
}
TranslateEvent.StopChoosingLanguage -> {
_state.update {
it.copy(
isChoosingFromLanguage = false,
isChoosingToLanguage = false
)
}
}
is TranslateEvent.SubmitVoiceResult -> {
_state.update {
it.copy(
fromText = event.result ?: it.fromText,
isTranslating = if (event.result != null) false else it.isTranslating,
toText = if (event.result != null) null else it.toText
)
}
}
TranslateEvent.SwapLanguages -> {
_state.update {
it.copy(
fromLanguage = it.toLanguage,
toLanguage = it.fromLanguage,
fromText = it.toText ?: "",
toText = if (it.toText != null) it.fromText else null
)
}
}
TranslateEvent.Translate -> translate(state.value)
else -> Unit
}
}
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/presentation/TranslateViewModel.kt | 1313948781 |
package me.yufan.kmmtranslator.translate.presentation
import me.yufan.kmmtranslator.core.presentation.UILanguage
sealed class TranslateEvent {
data class ChooseFromLanguage(val language: UILanguage) : TranslateEvent()
data class ChooseToLanguage(val language: UILanguage) : TranslateEvent()
object StopChoosingLanguage : TranslateEvent()
object SwapLanguages : TranslateEvent()
data class ChangeTranslationText(val text: String) : TranslateEvent()
object Translate : TranslateEvent()
object OpenFromLanguageDropDown : TranslateEvent()
object OpenToLanguageDropDown : TranslateEvent()
object CloseTranslation : TranslateEvent()
data class SelectHistoryItem(val item: UIHistoryItem) : TranslateEvent()
object EditTranslation : TranslateEvent()
object RecordAudio : TranslateEvent()
data class SubmitVoiceResult(val result: String?) : TranslateEvent()
object OnErrorSeen : TranslateEvent()
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/translate/presentation/TranslateEvent.kt | 2329723350 |
package me.yufan.kmmtranslator
object NetworkConstants {
const val BASE_URL = ""
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/NetworkConstants.kt | 3945433013 |
package me.yufan.kmmtranslator
class Greeting {
private val platform: Platform = getPlatform()
fun greet(): String {
return "Hello, ${platform.name}!"
}
} | KMMTranslator/shared/src/commonMain/kotlin/me/yufan/kmmtranslator/Greeting.kt | 2759727415 |
package me.yufan.kmmtranslator.core.domain.util
import kotlinx.coroutines.flow.Flow
actual class CommonFlow<T> actual constructor(
private val flow: Flow<T>
) : Flow<T> by flow | KMMTranslator/shared/src/androidMain/kotlin/me/yufan/kmmtranslator/core/domain/util/CommonFlow.kt | 2438423750 |
package me.yufan.kmmtranslator.core.domain.util
import kotlinx.coroutines.flow.StateFlow
actual class CommonStateFlow<T> actual constructor(
private val flow: StateFlow<T>
) : StateFlow<T> by flow | KMMTranslator/shared/src/androidMain/kotlin/me/yufan/kmmtranslator/core/domain/util/CommonStateFlow.kt | 3679640966 |
package me.yufan.kmmtranslator.core.domain.util
import kotlinx.coroutines.flow.MutableStateFlow
actual class CommonMutableStateFlow<T> actual constructor(
private val flow: MutableStateFlow<T>
) : MutableStateFlow<T> by flow | KMMTranslator/shared/src/androidMain/kotlin/me/yufan/kmmtranslator/core/domain/util/CommonMutableStateFlow.kt | 2764339007 |
package me.yufan.kmmtranslator.core.presentation
import androidx.annotation.DrawableRes
import me.yufan.kmmtranslator.R
import me.yufan.kmmtranslator.core.domain.language.Language
import java.util.Locale
actual class UILanguage(
@DrawableRes val drawableRes: Int,
actual val language: Language
) {
fun toLocale(): Locale? {
return when (language) {
Language.ENGLISH -> Locale.ENGLISH
Language.CHINESE -> Locale.CHINESE
Language.FRENCH -> Locale.FRENCH
Language.GERMAN -> Locale.GERMAN
Language.ITALIAN -> Locale.ITALIAN
Language.JAPANESE -> Locale.JAPANESE
Language.KOREAN -> Locale.KOREAN
else -> null
}
}
actual companion object {
actual fun byCode(langCode: String): UILanguage {
return allLanguages.find {
it.language.langCode == langCode
} ?: throw IllegalArgumentException(
"Invalid or unsupported language code"
)
}
actual val allLanguages: List<UILanguage>
get() = Language.entries.map { language ->
UILanguage(
language = language,
drawableRes = when (language) {
Language.ENGLISH -> R.drawable.english
Language.ARABIC -> R.drawable.arabic
Language.AZERBAIJANI -> R.drawable.azerbaijani
Language.CHINESE -> R.drawable.chinese
Language.CZECH -> R.drawable.czech
Language.DANISH -> R.drawable.danish
Language.DUTCH -> R.drawable.dutch
Language.FINNISH -> R.drawable.finnish
Language.FRENCH -> R.drawable.french
Language.GERMAN -> R.drawable.german
Language.GREEK -> R.drawable.greek
Language.HEBREW -> R.drawable.hebrew
Language.HINDI -> R.drawable.hindi
Language.HUNGARIAN -> R.drawable.hungarian
Language.INDONESIAN -> R.drawable.indonesian
Language.IRISH -> R.drawable.irish
Language.ITALIAN -> R.drawable.italian
Language.JAPANESE -> R.drawable.japanese
Language.KOREAN -> R.drawable.korean
Language.PERSIAN -> R.drawable.persian
Language.POLISH -> R.drawable.polish
Language.PORTUGUESE -> R.drawable.portuguese
Language.RUSSIAN -> R.drawable.russian
Language.SLOVAK -> R.drawable.slovak
Language.SPANISH -> R.drawable.spanish
Language.SWEDISH -> R.drawable.swedish
Language.TURKISH -> R.drawable.turkish
Language.UKRAINIAN -> R.drawable.ukrainian
}
)
}.sortedBy { it.language.langName }
}
} | KMMTranslator/shared/src/androidMain/kotlin/me/yufan/kmmtranslator/core/presentation/UILanguage.kt | 4173065897 |
package me.yufan.kmmtranslator.translate.data.local
import android.content.Context
import com.squareup.sqldelight.android.AndroidSqliteDriver
import com.squareup.sqldelight.db.SqlDriver
import me.yufan.kmmtranslator.database.TranslateDatabase
actual class DatabaseDriverFactory(
private val context: Context
) {
actual fun create(): SqlDriver {
return AndroidSqliteDriver(
TranslateDatabase.Schema,
context,
"translate.db"
)
}
} | KMMTranslator/shared/src/androidMain/kotlin/me/yufan/kmmtranslator/translate/data/local/DatabaseDriverFactory.kt | 780599704 |
package me.yufan.kmmtranslator.translate.data.remote
import io.ktor.client.HttpClient
import io.ktor.client.engine.android.Android
import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
import io.ktor.serialization.kotlinx.json.json
actual class HttpClientFactory {
actual fun create(): HttpClient {
return HttpClient(Android) {
install(ContentNegotiation) {
json()
}
}
}
} | KMMTranslator/shared/src/androidMain/kotlin/me/yufan/kmmtranslator/translate/data/remote/HttpClientFactory.kt | 2165910001 |
package me.yufan.kmmtranslator
class AndroidPlatform : Platform {
override val name: String = "Android ${android.os.Build.VERSION.SDK_INT}"
}
actual fun getPlatform(): Platform = AndroidPlatform() | KMMTranslator/shared/src/androidMain/kotlin/me/yufan/kmmtranslator/Platform.android.kt | 862414602 |
object Deps {
// COMPOSE
private const val activityCompseVersion = "1.6.1"
const val activityCompose = "androidx.activity:activity-compose:$activityCompseVersion"
const val composeVersion = "1.4.0-alpha02"
const val composeUi = "androidx.compose.ui:ui:$composeVersion"
const val composeUiTooling = "androidx.compose.ui:ui-tooling:$composeVersion"
const val composeUiToolingPreview = "androidx.compose.ui:ui-tooling-preview:$composeVersion"
const val composeFoundation = "androidx.compose.foundation:foundation:$composeVersion"
const val composeMaterial = "androidx.compose.material:material:$composeVersion"
const val composeIconsExtended = "androidx.compose.material:material-icons-extended:$composeVersion"
private const val composeNavigationVersion = "2.5.3"
const val composeNavigation = "androidx.navigation:navigation-compose:$composeNavigationVersion"
private const val coilComposeVersion = "2.1.0"
const val coilCompose = "io.coil-kt:coil-compose:$coilComposeVersion"
// KOTLIN DATE TIME
private const val dateTimeVersion = "0.4.0"
const val kotlinDateTime = "org.jetbrains.kotlinx:kotlinx-datetime:$dateTimeVersion"
// HILT
private const val hiltVersion = "2.42"
private const val hiltCompilerVersion = "1.0.0"
const val hiltAndroid = "com.google.dagger:hilt-android:$hiltVersion"
const val hiltAndroidCompiler = "com.google.dagger:hilt-android-compiler:$hiltVersion"
const val hiltCompiler = "androidx.hilt:hilt-compiler:$hiltCompilerVersion"
const val hiltNavigationCompose = "androidx.hilt:hilt-navigation-compose:$hiltCompilerVersion"
// KTOR
private const val ktorVersion = "2.1.3"
const val ktorCore = "io.ktor:ktor-client-core:$ktorVersion"
const val ktorSerialization = "io.ktor:ktor-client-content-negotiation:$ktorVersion"
const val ktorSerializationJson = "io.ktor:ktor-serialization-kotlinx-json:$ktorVersion"
const val ktorAndroid = "io.ktor:ktor-client-android:$ktorVersion"
const val ktorIOS = "io.ktor:ktor-client-ios:$ktorVersion"
// GRADLE PLUGINS
const val kotlinVersion = "1.7.21"
const val kotlinGradlePlugin = "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
private const val gradleVersion = "7.2.2"
const val androidBuildTools = "com.android.tools.build:gradle:$gradleVersion"
private const val sqlDelightGradleVersion = "1.5.3"
const val sqlDelightGradlePlugin = "com.squareup.sqldelight:gradle-plugin:$sqlDelightGradleVersion"
const val hiltGradlePlugin = "com.google.dagger:hilt-android-gradle-plugin:$hiltVersion"
// SQLDELIGHT
private const val sqlDelightVersion = "1.5.4"
const val sqlDelightRuntime = "com.squareup.sqldelight:runtime:$sqlDelightVersion"
const val sqlDelightAndroidDriver = "com.squareup.sqldelight:android-driver:$sqlDelightVersion"
const val sqlDelightNativeDriver = "com.squareup.sqldelight:native-driver:$sqlDelightVersion"
const val sqlDelightCoroutinesExtensions = "com.squareup.sqldelight:coroutines-extensions:$sqlDelightVersion"
// TESTING
private const val assertKVersion = "0.25"
const val assertK = "com.willowtreeapps.assertk:assertk:$assertKVersion"
private const val turbineVersion = "0.7.0"
const val turbine = "app.cash.turbine:turbine:$turbineVersion"
private const val jUnitVersion = "4.13.2"
const val jUnit = "junit:junit:$jUnitVersion"
private const val testRunnerVersion = "1.5.1"
const val testRunner = "androidx.test:runner:$testRunnerVersion"
const val composeTesting = "androidx.compose.ui:ui-test-junit4:$composeVersion"
const val composeTestManifest = "androidx.compose.ui:ui-test-manifest:$composeVersion"
const val hiltTesting = "com.google.dagger:hilt-android-testing:$hiltVersion"
} | KMMTranslator/buildSrc/src/main/kotlin/Deps.kt | 1764157948 |
package me.yufan.kmmtranslator.android
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import dagger.hilt.android.AndroidEntryPoint
import me.yufan.kmmtranslator.android.core.presentation.Routes
import me.yufan.kmmtranslator.android.core.theme.TranslatorTheme
import me.yufan.kmmtranslator.android.translate.presentation.AndroidTranslateViewModel
import me.yufan.kmmtranslator.android.translate.presentation.TranslateScreen
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
TranslatorTheme {
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colors.background
) {
TranslateRoot()
}
}
}
}
}
@Composable
fun TranslateRoot() {
val navController = rememberNavController()
NavHost(
navController = navController,
startDestination = Routes.TRANSLATE
) {
composable(route = Routes.TRANSLATE) {
val viewModel = hiltViewModel<AndroidTranslateViewModel>()
val state by viewModel.state.collectAsState()
TranslateScreen(
state = state,
onEvent = viewModel::onEvent
)
}
}
}
| KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/MainActivity.kt | 1026185516 |
package me.yufan.kmmtranslator.android.di
import android.app.Application
import com.squareup.sqldelight.db.SqlDriver
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import io.ktor.client.HttpClient
import me.yufan.kmmtranslator.database.TranslateDatabase
import me.yufan.kmmtranslator.translate.data.history.SqlDelightHistoryDataSource
import me.yufan.kmmtranslator.translate.data.local.DatabaseDriverFactory
import me.yufan.kmmtranslator.translate.data.remote.HttpClientFactory
import me.yufan.kmmtranslator.translate.data.translate.KtorTranslateClient
import me.yufan.kmmtranslator.translate.domain.history.HistoryDataSource
import me.yufan.kmmtranslator.translate.domain.translate.Translate
import me.yufan.kmmtranslator.translate.domain.translate.TranslateClient
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
@Provides
@Singleton
fun provideHttpClient(): HttpClient {
return HttpClientFactory().create()
}
@Provides
@Singleton
fun provideTranslateClient(httpClient: HttpClient): TranslateClient {
return KtorTranslateClient(httpClient)
}
@Provides
@Singleton
fun provideDatabaseDriver(app: Application): SqlDriver {
return DatabaseDriverFactory(app).create()
}
@Provides
@Singleton
fun provideHistoryDataSource(driver: SqlDriver): HistoryDataSource {
return SqlDelightHistoryDataSource(TranslateDatabase(driver))
}
@Provides
@Singleton
fun provideTranslateUseCase(
client: TranslateClient,
dataSource: HistoryDataSource
): Translate {
return Translate(client, dataSource)
}
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/di/AppModule.kt | 1579779789 |
package me.yufan.kmmtranslator.android.core.theme
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Shapes
import androidx.compose.material.Typography
import androidx.compose.material.darkColors
import androidx.compose.material.lightColors
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.Font
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import me.yufan.kmmtranslator.android.R
import me.yufan.kmmtranslator.core.presentation.Colors
@Composable
fun TranslatorTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
content: @Composable () -> Unit
) {
val darkColors = darkColors(
primary = accentViolet,
background = darkGrey,
onPrimary = Color.White,
onBackground = Color.White,
surface = darkGrey,
onSurface = Color.White
)
val lightColors = lightColors(
primary = accentViolet,
background = lightBlueGrey,
onPrimary = Color.White,
onBackground = textBlack,
surface = Color.White,
onSurface = textBlack
)
val colors = if (darkTheme) {
darkColors
} else {
lightColors
}
val sfProText = FontFamily(
Font(
resId = R.font.sf_pro_text_regular,
weight = FontWeight.Normal
),
Font(
resId = R.font.sf_pro_text_medium,
weight = FontWeight.Medium
),
Font(
resId = R.font.sf_pro_text_bold,
weight = FontWeight.Bold
)
)
val typography = Typography(
h1 = TextStyle(
fontFamily = sfProText,
fontWeight = FontWeight.Bold,
fontSize = 30.sp
),
h2 = TextStyle(
fontFamily = sfProText,
fontWeight = FontWeight.Bold,
fontSize = 24.sp
),
h3 = TextStyle(
fontFamily = sfProText,
fontWeight = FontWeight.Medium,
fontSize = 18.sp
),
body1 = TextStyle(
fontFamily = sfProText,
fontWeight = FontWeight.Normal,
fontSize = 14.sp
),
body2 = TextStyle(
fontFamily = sfProText,
fontWeight = FontWeight.Normal,
fontSize = 12.sp
),
)
val shapes = Shapes(
small = RoundedCornerShape(4.dp),
medium = RoundedCornerShape(4.dp),
large = RoundedCornerShape(0.dp)
)
MaterialTheme(
colors = colors,
typography = typography,
shapes = shapes,
content = content
)
}
| KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/core/theme/TranslatorTheme.kt | 1903521959 |
package me.yufan.kmmtranslator.android.core.theme
import androidx.compose.ui.graphics.Color
import me.yufan.kmmtranslator.core.presentation.Colors
val accentViolet = Color(Colors.AccentViolet)
val lightBlue = Color(Colors.LightBlue)
val lightBlueGrey = Color(Colors.LightBlueGrey)
val textBlack = Color(Colors.TextBlack)
val darkGrey = Color(Colors.DarkGrey) | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/core/theme/Color.kt | 3945922189 |
package me.yufan.kmmtranslator.android.core.presentation
object Routes {
const val TRANSLATE = "translate"
const val VOICE_TO_TEXT = "voice_to_text"
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/core/presentation/Route.kt | 3845542918 |
package me.yufan.kmmtranslator.android.translate.presentation
import android.widget.Toast
import androidx.compose.foundation.layout.Arrangement
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.material.Scaffold
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalClipboardManager
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.unit.dp
import me.yufan.kmmtranslator.android.R
import me.yufan.kmmtranslator.android.translate.presentation.components.LanguageDropDown
import me.yufan.kmmtranslator.android.translate.presentation.components.SwapLanguagesButton
import me.yufan.kmmtranslator.android.translate.presentation.components.TranslateTextField
import me.yufan.kmmtranslator.translate.presentation.TranslateEvent
import me.yufan.kmmtranslator.translate.presentation.TranslateState
@Composable
fun TranslateScreen(
state: TranslateState,
onEvent: (TranslateEvent) -> Unit
) {
val context = LocalContext.current
Scaffold(
floatingActionButton = {}
) { padding ->
LazyColumn(
modifier = Modifier
.fillMaxSize()
.padding(padding)
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
item {
Row(
modifier = Modifier
.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.SpaceBetween
) {
LanguageDropDown(
language = state.fromLanguage,
isOpen = state.isChoosingFromLanguage,
onClick = {
onEvent(TranslateEvent.OpenFromLanguageDropDown)
},
onDismiss = {
onEvent(TranslateEvent.StopChoosingLanguage)
},
onSelectLanguage = {
onEvent(TranslateEvent.ChooseFromLanguage(it))
}
)
Spacer(modifier = Modifier.weight(1f))
SwapLanguagesButton(onClick = {
onEvent(TranslateEvent.SwapLanguages)
})
Spacer(modifier = Modifier.weight(1f))
LanguageDropDown(
language = state.toLanguage,
isOpen = state.isChoosingToLanguage,
onClick = {
onEvent(TranslateEvent.OpenToLanguageDropDown)
},
onDismiss = {
onEvent(TranslateEvent.StopChoosingLanguage)
},
onSelectLanguage = {
onEvent(TranslateEvent.ChooseToLanguage(it))
}
)
}
}
item {
val clipboardManager = LocalClipboardManager.current
val keyboardController = LocalSoftwareKeyboardController.current
TranslateTextField(
fromText = state.fromText,
toText = state.toText,
isTranslating = state.isTranslating,
fromLanguage = state.fromLanguage,
toLanguage = state.toLanguage,
onTranslateClick = {
keyboardController?.hide()
onEvent(TranslateEvent.Translate)
},
onTextChange = {
onEvent(TranslateEvent.ChangeTranslationText(it))
},
onCopyClick = { text ->
clipboardManager.setText(
buildAnnotatedString {
append(text)
}
)
Toast.makeText(
context,
context.getString(
R.string.copied_to_clipboard
),
Toast.LENGTH_LONG
).show()
},
onCloseClick = {
onEvent(TranslateEvent.CloseTranslation)
},
onSpeakerClick = {
},
onTextFieldClick = {
onEvent(TranslateEvent.EditTranslation)
},
modifier = Modifier.fillMaxWidth()
)
}
}
}
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/TranslateScreen.kt | 1727300421 |
package me.yufan.kmmtranslator.android.translate.presentation.components
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.width
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import me.yufan.kmmtranslator.android.core.theme.lightBlue
import me.yufan.kmmtranslator.core.presentation.UILanguage
@Composable
fun LanguageDisplay(
language: UILanguage,
modifier: Modifier = Modifier
) {
Row(
modifier = modifier,
verticalAlignment = Alignment.CenterVertically
) {
SmallLanguageIcon(language = language)
Spacer(modifier = Modifier.width(8.dp))
Text(
text = language.language.langName,
color = lightBlue
)
}
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/components/LanguageDisplay.kt | 2642381366 |
package me.yufan.kmmtranslator.android.translate.presentation.components
import androidx.compose.foundation.background
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.Icon
import androidx.compose.material.IconButton
import androidx.compose.material.MaterialTheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.res.vectorResource
import me.yufan.kmmtranslator.android.R
@Composable
fun SwapLanguagesButton(
onClick: () -> Unit,
modifier: Modifier = Modifier
) {
IconButton(
onClick = onClick,
modifier = modifier
.clip(CircleShape)
.background(MaterialTheme.colors.primary)
) {
Icon(
imageVector = ImageVector.vectorResource(id = R.drawable.swap_languages),
contentDescription = stringResource(id = R.string.swap_languages),
tint = MaterialTheme.colors.onPrimary
)
}
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/components/SwapLanguagesButton.kt | 709631864 |
package me.yufan.kmmtranslator.android.translate.presentation.components
import androidx.compose.animation.AnimatedContent
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.material.Divider
import androidx.compose.material.Icon
import androidx.compose.material.IconButton
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.rounded.Close
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.res.vectorResource
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.unit.dp
import me.yufan.kmmtranslator.android.R
import me.yufan.kmmtranslator.android.core.theme.lightBlue
import me.yufan.kmmtranslator.core.presentation.UILanguage
@Composable
fun TranslateTextField(
fromText: String,
toText: String?,
isTranslating: Boolean,
fromLanguage: UILanguage,
toLanguage: UILanguage,
onTranslateClick: () -> Unit,
onTextChange: (String) -> Unit,
onCopyClick: (String) -> Unit,
onCloseClick: () -> Unit,
onSpeakerClick: () -> Unit,
onTextFieldClick: () -> Unit,
modifier: Modifier = Modifier
) {
Box(
modifier = modifier
.shadow(
elevation = 5.dp,
shape = RoundedCornerShape(20.dp)
)
.clip(RoundedCornerShape(20.dp))
.gradientSurface()
.clickable(onClick = onTextFieldClick)
.padding(16.dp)
) {
AnimatedContent(
targetState = toText,
label = ""
) { toText ->
if (toText == null || isTranslating) {
IdleTranslateTextField(
fromText = fromText,
isTranslating = isTranslating,
onTextChange = onTextChange,
onTranslateClick = onTranslateClick,
modifier = Modifier
.fillMaxWidth()
.aspectRatio(2f)
)
} else {
TranslatedTextField(
fromText = fromText,
toText = toText,
fromLanguage = fromLanguage,
toLanguage = toLanguage,
onCopyClick = onCopyClick,
onCloseClick = onCloseClick,
onSpeakerClick = onSpeakerClick,
modifier = Modifier.fillMaxWidth()
)
}
}
}
}
@Composable
private fun TranslatedTextField(
fromText: String,
toText: String,
fromLanguage: UILanguage,
toLanguage: UILanguage,
onCopyClick: (String) -> Unit,
onCloseClick: () -> Unit,
onSpeakerClick: () -> Unit,
modifier: Modifier = Modifier
) {
Column(
modifier = modifier
) {
LanguageDisplay(language = fromLanguage)
Spacer(modifier = Modifier.height(16.dp))
Text(
text = fromText,
color = MaterialTheme.colors.onSurface
)
Spacer(modifier = Modifier.height(16.dp))
Row(
modifier = Modifier.align(Alignment.End)
) {
IconButton(onClick = {
onCopyClick(fromText)
}) {
Icon(
imageVector = ImageVector.vectorResource(id = R.drawable.copy),
contentDescription = stringResource(id = R.string.copy),
tint = lightBlue
)
}
IconButton(onClick = onCloseClick) {
Icon(
imageVector = Icons.Rounded.Close,
contentDescription = stringResource(id = R.string.close),
tint = lightBlue
)
}
}
Spacer(modifier = Modifier.height(16.dp))
Divider()
Spacer(modifier = Modifier.height(16.dp))
LanguageDisplay(language = toLanguage)
Spacer(modifier = Modifier.height(16.dp))
Text(
text = toText,
color = MaterialTheme.colors.onSurface
)
Spacer(modifier = Modifier.height(16.dp))
Row(
modifier = Modifier.align(Alignment.End)
) {
IconButton(onClick = {
onCopyClick(toText)
}) {
Icon(
imageVector = ImageVector.vectorResource(id = R.drawable.copy),
contentDescription = stringResource(id = R.string.copy),
tint = lightBlue
)
}
IconButton(onClick = onSpeakerClick) {
Icon(
imageVector = ImageVector.vectorResource(id = R.drawable.speaker),
contentDescription = stringResource(id = R.string.play_loud),
tint = lightBlue
)
}
}
}
}
@Composable
private fun IdleTranslateTextField(
fromText: String,
isTranslating: Boolean,
onTextChange: (String) -> Unit,
onTranslateClick: () -> Unit,
modifier: Modifier = Modifier
) {
var isFocused by remember {
mutableStateOf(false)
}
Box(modifier = modifier) {
BasicTextField(
value = fromText,
onValueChange = onTextChange,
cursorBrush = SolidColor(MaterialTheme.colors.primary),
modifier = Modifier
.fillMaxSize()
.onFocusChanged { isFocused = it.isFocused },
textStyle = TextStyle(
color = MaterialTheme.colors.onSurface
)
)
if (fromText.isEmpty() && !isFocused) {
Text(
text = stringResource(
id = R.string.enter_a_text_to_translate
),
color = lightBlue
)
}
ProgressButton(
text = stringResource(
id = R.string.translate
),
isLoading = isTranslating,
onClick = onTranslateClick,
modifier = Modifier.align(Alignment.BottomEnd)
)
}
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/components/TranslateTextField.kt | 3909790026 |
package me.yufan.kmmtranslator.android.translate.presentation.components
import androidx.compose.animation.AnimatedContent
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.CircularProgressIndicator
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.unit.dp
@Composable
fun ProgressButton(
text: String,
isLoading: Boolean,
onClick: () -> Unit,
modifier: Modifier = Modifier
) {
Box(
modifier = modifier
.clip(RoundedCornerShape(100))
.background(MaterialTheme.colors.primary)
.clickable(onClick = onClick)
.padding(8.dp),
contentAlignment = Alignment.Center
) {
AnimatedContent(
targetState = isLoading,
label = ""
) { isLoading ->
if (isLoading) {
CircularProgressIndicator(
modifier = Modifier.size(20.dp),
color = MaterialTheme.colors.onPrimary,
strokeWidth = 2.dp
)
} else {
Text(
text = text.uppercase(),
color = MaterialTheme.colors.onPrimary
)
}
}
}
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/components/ProgressButton.kt | 1388462866 |
package me.yufan.kmmtranslator.android.translate.presentation.components
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
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.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.material.DropdownMenu
import androidx.compose.material.Icon
import androidx.compose.material.Text
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowDropDown
import androidx.compose.material.icons.filled.ArrowDropUp
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import coil.compose.AsyncImage
import me.yufan.kmmtranslator.android.R
import me.yufan.kmmtranslator.android.core.theme.lightBlue
import me.yufan.kmmtranslator.core.presentation.UILanguage
@Composable
fun LanguageDropDown(
language: UILanguage,
isOpen: Boolean,
onClick: () -> Unit,
onDismiss: () -> Unit,
onSelectLanguage: (UILanguage) -> Unit,
modifier: Modifier = Modifier
) {
Box(modifier = modifier) {
DropdownMenu(
expanded = isOpen,
onDismissRequest = onDismiss
) {
UILanguage.allLanguages.forEach { language ->
LanguageDropDownItem(
language = language,
onClick = {
onSelectLanguage(language)
},
modifier = Modifier.fillMaxWidth()
)
}
}
Row(
modifier = Modifier
.clickable(onClick = onClick)
.padding(16.dp),
verticalAlignment = Alignment.CenterVertically
) {
AsyncImage(
model = language.drawableRes,
contentDescription = language.language.langName,
modifier = Modifier.size(30.dp)
)
Spacer(modifier = Modifier.width(16.dp))
Text(
text = language.language.langName,
color = lightBlue
)
Icon(
imageVector = if (isOpen) Icons.Default.ArrowDropUp else Icons.Default.ArrowDropDown,
contentDescription = if (isOpen) {
stringResource(id = R.string.close)
} else {
stringResource(id = R.string.open)
},
tint = lightBlue,
modifier = Modifier.size(30.dp)
)
}
}
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/components/LanguageDropDown.kt | 2433666122 |
package me.yufan.kmmtranslator.android.translate.presentation.components
import androidx.compose.foundation.layout.size
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import coil.compose.AsyncImage
import me.yufan.kmmtranslator.core.presentation.UILanguage
@Composable
fun SmallLanguageIcon(
language: UILanguage,
modifier: Modifier = Modifier
) {
AsyncImage(
model = language.drawableRes,
contentDescription = language.language.langName,
modifier = modifier.size(25.dp)
)
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/components/SmallLanguageIcon.kt | 2221059082 |
package me.yufan.kmmtranslator.android.translate.presentation.components
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.material.DropdownMenuItem
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.dp
import me.yufan.kmmtranslator.core.presentation.UILanguage
@Composable
fun LanguageDropDownItem(
language: UILanguage,
onClick: () -> Unit,
modifier: Modifier
) {
DropdownMenuItem(
onClick = onClick,
modifier = modifier
) {
Image(
painter = painterResource(id = language.drawableRes),
contentDescription = language.language.langName,
modifier = Modifier.size(40.dp)
)
Spacer(modifier = Modifier.width(16.dp))
Text(
text = language.language.langName
)
}
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/components/LanguageDropDownItem.kt | 916760821 |
package me.yufan.kmmtranslator.android.translate.presentation.components
import androidx.compose.foundation.background
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material.MaterialTheme
import androidx.compose.ui.Modifier
import androidx.compose.ui.composed
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
fun Modifier.gradientSurface(): Modifier = composed {
if (isSystemInDarkTheme()) {
Modifier.background(
brush = Brush.verticalGradient(
colors = listOf(
Color(0xFF23262E),
Color(0xFF212329)
)
)
)
} else Modifier.background(MaterialTheme.colors.surface)
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/components/GradientSurface.kt | 2071565276 |
package me.yufan.kmmtranslator.android.translate.presentation
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import me.yufan.kmmtranslator.translate.domain.history.HistoryDataSource
import me.yufan.kmmtranslator.translate.domain.translate.Translate
import me.yufan.kmmtranslator.translate.presentation.TranslateEvent
import me.yufan.kmmtranslator.translate.presentation.TranslateViewModel
import javax.inject.Inject
@HiltViewModel
class AndroidTranslateViewModel @Inject constructor(
private val translate: Translate,
private val historyDataSource: HistoryDataSource
) : ViewModel() {
private val viewModel by lazy {
TranslateViewModel(
translate = translate,
historyDataSource = historyDataSource,
coroutineScope = viewModelScope
)
}
val state = viewModel.state
fun onEvent(event: TranslateEvent) {
viewModel.onEvent(event)
}
} | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/translate/presentation/AndroidTranslateViewModel.kt | 4116943635 |
package me.yufan.kmmtranslator.android
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class TranslateApp : Application() | KMMTranslator/androidApp/src/main/java/me/yufan/kmmtranslator/android/TranslateApp.kt | 3480829099 |
package com.android.gutendex
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.android.gutendex", appContext.packageName)
}
} | gutendex/app/src/androidTest/java/com/android/gutendex/ExampleInstrumentedTest.kt | 3096744537 |
package com.android.gutendex
import com.android.gutendex.helpers.CoroutineTestRule
import com.android.gutendex.helpers.RobolectricTest
import com.android.gutendex.helpers.mockListBookDomain
import com.android.gutendex.helpers.runFlowTest
import com.android.gutendex.helpers.runTest
import com.android.gutendex.helpers.toFlow
import com.android.gutendex.room.RoomBookRepository
import com.android.gutendex.screens.books.BookInteractorImpl
import com.android.gutendex.screens.books.BooksInteractor
import com.android.gutendex.screens.books.BooksPartialState
import com.android.gutendex.screens.books.BooksRepository
import com.android.gutendex.screens.books.BooksRepositoryResponse
import junit.framework.TestCase
import kotlinx.coroutines.CoroutineScope
import org.junit.After
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.mockito.ArgumentMatchers
import org.mockito.Mockito
import org.mockito.MockitoAnnotations
import org.mockito.Spy
class TestsBooksIneractor : RobolectricTest() {
@get:Rule
val coroutineRule = CoroutineTestRule()
private lateinit var bookInteractor: BooksInteractor
@Spy
private lateinit var booksRepository: BooksRepository
@Spy
private lateinit var roomBookRepository: RoomBookRepository
@Spy
private lateinit var coroutineScope: CoroutineScope
@Before
fun before() {
MockitoAnnotations.openMocks(this)
bookInteractor = BookInteractorImpl(booksRepository, roomBookRepository, coroutineScope)
}
@After
fun after() {
coroutineRule.cancelScopeAndDispatcher()
}
@Test
fun `Given Success from BooksRepositoryResponse, When retrieveBooks is called, Then BooksPartialState Success emitted`() {
coroutineRule.runTest {
//Given
getBooksRepoInterceptor(BooksRepositoryResponse.Success(mockListBookDomain, 3))
//When
bookInteractor.retrieveBooks(ArgumentMatchers.anyInt()).runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Success(mockListBookDomain, 3),
awaitItem()
)
}
}
}
@Test
fun `Given Failed from BooksRepositoryResponse, When retrieveBooks is called, Then BooksPartialState Failed emitted`() {
coroutineRule.runTest {
//Given
getBooksRepoInterceptor(BooksRepositoryResponse.Failed("error"))
//When
bookInteractor.retrieveBooks(ArgumentMatchers.anyInt()).runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Failed("error"),
awaitItem()
)
}
}
}
@Test
fun `Given Error from BooksRepositoryResponse, When retrieveBooks is called, Then BooksPartialState Failed emitted`() {
coroutineRule.runTest {
//Given
getBooksRepoInterceptor(BooksRepositoryResponse.Error("error"))
//When
bookInteractor.retrieveBooks(ArgumentMatchers.anyInt()).runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Failed("error"),
awaitItem()
)
}
}
}
@Test
fun `Given Success from BooksRepositoryResponse, When retrieveNextBooks is called, Then BooksPartialState Success emitted`() {
coroutineRule.runTest {
//Given
getBooksRepoInterceptor(
BooksRepositoryResponse.Success(mockListBookDomain, ArgumentMatchers.anyInt())
)
//When
bookInteractor.retrieveBooks(ArgumentMatchers.anyInt()).runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Success(mockListBookDomain, ArgumentMatchers.anyInt()),
awaitItem()
)
}
}
}
@Test
fun `Given Failed from BooksRepositoryResponse, When retrieveNextBooks is called, Then BooksPartialState Success emitted`() {
coroutineRule.runTest {
//Given
getBooksRepoInterceptor(
BooksRepositoryResponse.Failed("error")
)
//When
bookInteractor.retrieveBooks(ArgumentMatchers.anyInt()).runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Failed("error"),
awaitItem()
)
}
}
}
@Test
fun `Given Error BooksRepositoryResponse, When retrieveNextBooks is called, Then BooksPartialState Failed emitted`() {
coroutineRule.runTest {
//Given
getBooksRepoInterceptor(
BooksRepositoryResponse.Error("error")
)
//When
bookInteractor.retrieveBooks(ArgumentMatchers.anyInt()).runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Failed("error"),
awaitItem()
)
}
}
}
@Test
fun `Given Success BooksRepositoryResponse, When retrieveRoomBooks is called, Then BooksPartialState Success emitted`() {
coroutineRule.runTest {
//Given
getRoomBooksRepoInterceptor(
BooksRepositoryResponse.Success(mockListBookDomain, ArgumentMatchers.anyInt())
)
//When
bookInteractor.retrieveRoomBooks().runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Success(mockListBookDomain, ArgumentMatchers.anyInt()),
awaitItem()
)
}
}
}
@Test
fun `Given Failed BooksRepositoryResponse, When retrieveRoomBooks is called, Then BooksPartialState Failed emitted`() {
coroutineRule.runTest {
//Given
getRoomBooksRepoInterceptor(
BooksRepositoryResponse.Failed("error")
)
//When
bookInteractor.retrieveRoomBooks().runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Failed("error"),
awaitItem()
)
}
}
}
@Test
fun `Given Error BooksRepositoryResponse, When retrieveRoomBooks is called, Then BooksPartialState Failed emitted`() {
coroutineRule.runTest {
//Given
getRoomBooksRepoInterceptor(
BooksRepositoryResponse.Error("error")
)
//When
bookInteractor.retrieveRoomBooks().runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Failed("error"),
awaitItem()
)
}
}
}
@Test
fun `Given Success BooksRepositoryResponse, When retrieveRoomBooksPaginated is called, Then BooksPartialState Success emitted`() {
coroutineRule.runTest {
//Given
getRoomBooksPaginatedRepoInterceptor(
BooksRepositoryResponse.Success(mockListBookDomain, ArgumentMatchers.anyInt())
)
//When
bookInteractor.retrieveRoomBooks().runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Success(mockListBookDomain, ArgumentMatchers.anyInt()),
awaitItem()
)
}
}
}
@Test
fun `Given Failed BooksRepositoryResponse, When retrieveRoomBooksPaginated is called, Then BooksPartialState Failed emitted`() {
coroutineRule.runTest {
//Given
getRoomBooksPaginatedRepoInterceptor(
BooksRepositoryResponse.Failed("error")
)
//When
bookInteractor.retrieveRoomBooks().runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Failed("error"),
awaitItem()
)
}
}
}
@Test
fun `Given Error BooksRepositoryResponse, When retrieveRoomBooksPaginated is called, Then BooksPartialState Failed emitted`() {
coroutineRule.runTest {
//Given
getRoomBooksPaginatedRepoInterceptor(
BooksRepositoryResponse.Error("error")
)
//When
bookInteractor.retrieveRoomBooks().runFlowTest {
//Then
TestCase.assertEquals(
BooksPartialState.Failed("error"),
awaitItem()
)
}
}
}
private fun getBooksRepoInterceptor(repositoryResponse: BooksRepositoryResponse) {
Mockito.`when`(booksRepository.getBooks(ArgumentMatchers.anyInt()))
.thenReturn(repositoryResponse.toFlow())
}
private fun getRoomBooksRepoInterceptor(repositoryResponse: BooksRepositoryResponse) {
Mockito.`when`(booksRepository.getBooks(ArgumentMatchers.anyInt()))
.thenReturn(repositoryResponse.toFlow())
}
private suspend fun getRoomBooksPaginatedRepoInterceptor(repositoryResponse: BooksRepositoryResponse) {
Mockito.`when`(
roomBookRepository.getBooksPaged(
ArgumentMatchers.anyInt(),
ArgumentMatchers.anyInt()
)
)
.thenReturn(repositoryResponse.toFlow())
}
}
| gutendex/app/src/test/java/com/android/gutendex/TestsBooksIneractor.kt | 3552482918 |
package com.android.gutendex
import com.android.gutendex.helpers.CoroutineTestRule
import com.android.gutendex.helpers.RobolectricTest
import com.android.gutendex.helpers.mockListBookDomain
import com.android.gutendex.helpers.runFlowTest
import com.android.gutendex.helpers.runTest
import com.android.gutendex.helpers.toFlow
import com.android.gutendex.screens.books.BooksInteractor
import com.android.gutendex.screens.books.BooksPartialState
import com.android.gutendex.screens.books.BooksViewModel
import com.android.gutendex.screens.books.Effect
import com.android.gutendex.screens.books.Event
import com.android.gutendex.screens.books.State
import junit.framework.TestCase
import org.junit.After
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.mockito.ArgumentMatchers.anyInt
import org.mockito.Mockito
import org.mockito.MockitoAnnotations
import org.mockito.Spy
import org.mockito.kotlin.times
class TestBooksViewModel : RobolectricTest() {
@get:Rule
val coroutineRule = CoroutineTestRule()
@Spy
private lateinit var booksInteractor: BooksInteractor
private lateinit var booksViewModel: BooksViewModel
private var initialState = State(
pages = 1, isLoading = true, apiPages = 1
)
@Before
fun before() {
MockitoAnnotations.openMocks(this)
booksViewModel = BooksViewModel(booksInteractor)
}
@After
fun after() {
coroutineRule.cancelScopeAndDispatcher()
}
@Test
fun `When Event#GetInitialBooks and BooksPartialState#Success then Assert State`() =
coroutineRule.runTest {
getBooksIntercetor(
BooksPartialState.Success(
mockListBookDomain, anyInt()
)
)
val event = Event.GetInitialBooks
booksViewModel.setEvent(event)
Mockito.verify(booksInteractor, times(1)).retrieveRoomBooks()
Mockito.verify(booksInteractor, times(1)).retrieveRoomBooksPaginated(anyInt(), anyInt())
booksViewModel.viewStateHistory.runFlowTest {
val state = awaitItem()
TestCase.assertEquals(state, initialState.copy(isLoading = true))
val state2 = awaitItem()
TestCase.assertEquals(
state2, initialState.copy(
listOfBooks = mockListBookDomain, isLoadingNext = false, isLoading = false
)
)
}
}
@Test
fun `When Event#GetInitialBooks and BooksPartialState#Failed then Assert State and Effects`() =
coroutineRule.runTest {
getBooksIntercetor(
BooksPartialState.Failed(
"errorMessage"
)
)
val event = Event.GetInitialBooks
booksViewModel.setEvent(event)
Mockito.verify(booksInteractor, times(1)).retrieveRoomBooks()
Mockito.verify(booksInteractor, times(1)).retrieveRoomBooksPaginated(anyInt(), anyInt())
booksViewModel.viewStateHistory.runFlowTest {
val state = awaitItem()
TestCase.assertEquals(state, initialState.copy(isLoading = true))
booksViewModel.effect.runFlowTest {
TestCase.assertEquals(
awaitItem(), Effect.GetMoreBooks(anyInt())
)
}
}
}
@Test
fun `When Event#GetMoreBooks and BooksPartialState#Success then Assert State and Effects`() =
coroutineRule.runTest {
getBooksNextIntercetor(
BooksPartialState.Success(
mockListBookDomain, anyInt()
)
)
val event = Event.GetMoreBooks(anyInt())
booksViewModel.setEvent(event)
Mockito.verify(booksInteractor, times(1)).retrieveNextBooks(anyInt())
booksViewModel.viewStateHistory.runFlowTest {
val state = awaitItem()
TestCase.assertEquals(state, initialState.copy(isLoadingNext = true))
booksViewModel.effect.runFlowTest {
TestCase.assertEquals(
awaitItem(), Effect.SaveToDB(mockListBookDomain)
)
}
val state2 = awaitItem()
TestCase.assertEquals(state2, state.copy(isLoadingNext = false))
}
}
@Test
fun `When Event#GetMoreBooks and BooksPartialState#Failed then Assert State and Effects`() =
coroutineRule.runTest {
getBooksNextIntercetor(
BooksPartialState.Failed(
"error"
)
)
val event = Event.GetMoreBooks(anyInt())
booksViewModel.setEvent(event)
Mockito.verify(booksInteractor, times(1)).retrieveNextBooks(anyInt())
booksViewModel.viewStateHistory.runFlowTest {
val state = awaitItem()
TestCase.assertEquals(state, initialState.copy(isLoadingNext = true))
val state2 = awaitItem()
TestCase.assertEquals(
state2, state.copy(isLoadingNext = false, errorMessage = "error")
)
}
}
@Test
fun `When Event#SaveToDb Assert State and Effects`() = coroutineRule.runTest {
val event = Event.SaveToDb(mockListBookDomain)
booksViewModel.setEvent(event)
Mockito.verify(booksInteractor, times(1)).saveBooksToDb(mockListBookDomain)
}
private fun getBooksIntercetor(partialState: BooksPartialState) {
Mockito.`when`(
booksInteractor.retrieveRoomBooksPaginated(
anyInt(), anyInt()
)
).thenReturn(partialState.toFlow())
}
private fun getBooksNextIntercetor(partialState: BooksPartialState) {
Mockito.`when`(
booksInteractor.retrieveNextBooks(
anyInt(),
)
).thenReturn(partialState.toFlow())
}
} | gutendex/app/src/test/java/com/android/gutendex/TestBooksViewModel.kt | 3448166653 |
package com.android.gutendex
import com.android.gutendex.helpers.CoroutineTestRule
import com.android.gutendex.helpers.RobolectricTest
import com.android.gutendex.helpers.mockBookInfo
import com.android.gutendex.helpers.runFlowTest
import com.android.gutendex.helpers.runTest
import com.android.gutendex.helpers.toFlow
import com.android.gutendex.screens.info.BookInfoPartialState
import com.android.gutendex.screens.info.Event
import com.android.gutendex.screens.info.InfoInteractor
import com.android.gutendex.screens.info.InfoViewModel
import com.android.gutendex.screens.info.State
import junit.framework.TestCase
import org.junit.After
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.mockito.ArgumentMatchers
import org.mockito.Mockito
import org.mockito.MockitoAnnotations
import org.mockito.Spy
import org.mockito.kotlin.times
class TestInfoViewModel : RobolectricTest() {
@get:Rule
val coroutineRule = CoroutineTestRule()
@Spy
private lateinit var infoInteractor: InfoInteractor
private lateinit var bookInfoViewModel: InfoViewModel
private var initialState = State(isLoading = true)
@Before
fun before() {
MockitoAnnotations.openMocks(this)
bookInfoViewModel = InfoViewModel(infoInteractor)
}
@After
fun after() {
coroutineRule.cancelScopeAndDispatcher()
}
@Test
fun `When Event#GetBookInfo and BookInfoPartialState#Success then Assert State`() =
coroutineRule.runTest {
getBookInfoIntercetpr(BookInfoPartialState.Success(mockBookInfo))
val event = Event.GetBookInfo("")
bookInfoViewModel.setEvent(event)
Mockito.verify(infoInteractor, times(1)).retrieveBookInfo("")
bookInfoViewModel.viewStateHistory.runFlowTest {
val state = awaitItem()
TestCase.assertEquals(state, initialState.copy(isLoading = true))
val state2 = awaitItem()
TestCase.assertEquals(
state2,
initialState.copy(isLoading = false, bookInfo = mockBookInfo)
)
}
}
@Test
fun `When Event#GetBookInfo and BookInfoPartialState#Failed then Assert State`() =
coroutineRule.runTest {
getBookInfoIntercetpr(BookInfoPartialState.Success(mockBookInfo))
val event = Event.GetBookInfo("")
bookInfoViewModel.setEvent(event)
Mockito.verify(infoInteractor, times(1)).retrieveBookInfo("")
bookInfoViewModel.viewStateHistory.runFlowTest {
val state = awaitItem()
TestCase.assertEquals(state, initialState.copy(isLoading = true))
val state2 = awaitItem()
TestCase.assertEquals(
state2,
initialState.copy(
isLoading = false,
errorMessage = ArgumentMatchers.anyString()
)
)
}
}
private fun getBookInfoIntercetpr(partialState: BookInfoPartialState) {
Mockito.`when`(infoInteractor.retrieveBookInfo(ArgumentMatchers.anyString()))
.thenReturn(partialState.toFlow())
}
}
| gutendex/app/src/test/java/com/android/gutendex/TestInfoViewModel.kt | 2573745739 |
package com.android.gutendex
import com.android.gutendex.helpers.CoroutineTestRule
import com.android.gutendex.helpers.RobolectricTest
import com.android.gutendex.helpers.mockBookInfo
import com.android.gutendex.helpers.runFlowTest
import com.android.gutendex.helpers.runTest
import com.android.gutendex.helpers.toFlow
import com.android.gutendex.screens.info.BookInfoPartialState
import com.android.gutendex.screens.info.BookInfoRepositoryResponse
import com.android.gutendex.screens.info.InfoInteractor
import com.android.gutendex.screens.info.InfoInteractorImpl
import com.android.gutendex.screens.info.InfoRepository
import junit.framework.TestCase
import org.junit.After
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.mockito.ArgumentMatchers
import org.mockito.Mockito
import org.mockito.MockitoAnnotations
import org.mockito.Spy
class TestInfoInteractor : RobolectricTest() {
@get:Rule
val coroutineRule = CoroutineTestRule()
private lateinit var infoInteractor: InfoInteractor
@Spy
private lateinit var infoRepository: InfoRepository
@Before
fun before() {
MockitoAnnotations.openMocks(this)
infoInteractor = InfoInteractorImpl(infoRepository)
}
@After
fun after() {
coroutineRule.cancelScopeAndDispatcher()
}
@Test
fun `Given Success from BookInfoRepositoryResponse, When retrieveBookInfo is called, Then BookInfoPartialState Success emitted`() {
coroutineRule.runTest {
//Given
getGameDetailsInterceptor(BookInfoRepositoryResponse.Success(mockBookInfo))
//When
infoInteractor.retrieveBookInfo("").runFlowTest {
//Then
TestCase.assertEquals(
BookInfoPartialState.Success(mockBookInfo),
awaitItem()
)
}
}
}
@Test
fun `Given Failed from BookInfoRepositoryResponse, When retrieveBookInfo is called, Then BookInfoPartialState Failed emitted`() {
coroutineRule.runTest {
//Given
getGameDetailsInterceptor(BookInfoRepositoryResponse.Failed("error"))
//When
infoInteractor.retrieveBookInfo("").runFlowTest {
//Then
TestCase.assertEquals(
BookInfoPartialState.Failed("error"),
awaitItem()
)
}
}
}
@Test
fun `Given Error from BookInfoRepositoryResponse, When retrieveBookInfo is called, Then BookInfoPartialState Failed emitted`() {
coroutineRule.runTest {
//Given
getGameDetailsInterceptor(BookInfoRepositoryResponse.Error("error"))
//When
infoInteractor.retrieveBookInfo("").runFlowTest {
//Then
TestCase.assertEquals(
BookInfoPartialState.Failed("error"),
awaitItem()
)
}
}
}
private fun getGameDetailsInterceptor(repositoryResponse: BookInfoRepositoryResponse) {
Mockito.`when`(infoRepository.getBookInfo(ArgumentMatchers.anyString()))
.thenReturn(repositoryResponse.toFlow())
}
}
| gutendex/app/src/test/java/com/android/gutendex/TestInfoInteractor.kt | 1120325155 |
package com.android.gutendex.helpers
import app.cash.turbine.ReceiveTurbine
import app.cash.turbine.test
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.cancel
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.TestDispatcher
import kotlinx.coroutines.test.TestScope
import kotlinx.coroutines.test.runTest
import org.junit.rules.TestWatcher
class CoroutineTestRule constructor(
private val testDispatcher: TestDispatcher = StandardTestDispatcher(),
val testScope: TestScope = TestScope(testDispatcher)
) : TestWatcher() {
fun cancelScopeAndDispatcher() {
testScope.cancel()
testDispatcher.cancel()
}
}
fun CoroutineTestRule.runTest(block: suspend CoroutineScope.() -> Unit): Unit =
testScope.runTest { block() }
/**
* This function starts collecting events from the flow.
* Then cancelAndConsumeRemainingEvents function cancels the flow and consumes any remaining events in the flow, which is important to prevent any possible leaks.
*/
suspend fun <T> Flow<T>.runFlowTest(block: suspend ReceiveTurbine<T>.() -> Unit) {
test {
block()
cancelAndConsumeRemainingEvents()
}
} | gutendex/app/src/test/java/com/android/gutendex/helpers/CoroutineTestRule.kt | 1343026081 |
package com.android.gutendex.helpers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
fun <T> T.toFlow(): StateFlow<T> =
MutableStateFlow(this).asStateFlow() | gutendex/app/src/test/java/com/android/gutendex/helpers/FLowExtension.kt | 1085507481 |
package com.android.gutendex.helpers
import com.android.gutendex.models.BookDomain
import com.android.gutendex.models.BookInfo
val mockBookInfo = BookInfo(
"title", "author", "birth", "subject", "img"
)
val mockBooDkomain = BookDomain(
title = "title", author = "author", id = 1, popularity = 10, img = "img"
)
val mockListBookDomain = listOf(
BookDomain(
title = "title", author = "author", id = 1, popularity = 10, img = "img"
),
BookDomain(
title = "title", author = "author", id = 2, popularity = 12, img = "img"
),
BookDomain(
title = "title", author = "author", id = 45, popularity = 55, img = "img"
)
) | gutendex/app/src/test/java/com/android/gutendex/helpers/Mocks.kt | 2217004271 |
package com.android.gutendex.helpers
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
const val CONFIG_SDK = 33
@RunWith(RobolectricTestRunner::class)
@Config(
sdk = [CONFIG_SDK],
instrumentedPackages = [
"androidx.loader.content"
]
)
abstract class RobolectricTest | gutendex/app/src/test/java/com/android/gutendex/helpers/RoboElectricTest.kt | 3391944230 |
package com.android.gutendex.di
import android.content.Context
import androidx.room.Room
import com.android.gutendex.room.BookDao
import com.android.gutendex.room.BookDatabase
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class RoomModule {
@Provides
@Singleton
fun provideAppDatabase(@ApplicationContext appContext: Context): BookDatabase {
return Room.databaseBuilder(
appContext,
BookDatabase::class.java,
"Books"
).build()
}
@Provides
fun provideChannelDao(appDatabase: BookDatabase): BookDao {
return appDatabase.bookDao()
}
}
| gutendex/app/src/main/java/com/android/gutendex/di/RoomModule.kt | 2842168520 |
package com.android.gutendex.di
import com.android.gutendex.networking.baseUrl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class NetworkModule {
/**
* Constructs and provides a singleton [Retrofit] instance used to perform api calls.
*/
@Provides
@Singleton
fun provideRetrofit(
okHttpClient: OkHttpClient,
converterFactory: GsonConverterFactory,
): Retrofit = Retrofit.Builder()
.addConverterFactory(converterFactory)
.baseUrl(baseUrl)
.client(okHttpClient)
.build()
/**
* Constructs and provides a singleton [OkHttpClient] used for [Retrofit] instance
* initialization.
*
* @return A [OkHttpClient] instance.
*/
@Singleton
@Provides
fun provideOkHttpClient(
httpLoggingInterceptor: HttpLoggingInterceptor,
): OkHttpClient {
val client = OkHttpClient.Builder()
.addInterceptor(httpLoggingInterceptor)
.readTimeout(3000, TimeUnit.MILLISECONDS)
.connectTimeout(3000, TimeUnit.MILLISECONDS)
.writeTimeout(3000, TimeUnit.MILLISECONDS)
return client.build()
}
@Singleton
@Provides
fun provideConverterFactory(): GsonConverterFactory = GsonConverterFactory.create()
/** Constructs and provides a singleton [HttpLoggingInterceptor] instance.
*
* @return A [HttpLoggingInterceptor] instance.
*/
@Singleton
@Provides
fun providesHttpLoggingInterceptor(
) = HttpLoggingInterceptor()
.apply {
level = HttpLoggingInterceptor.Level.BODY
}
} | gutendex/app/src/main/java/com/android/gutendex/di/NetworkModule.kt | 1509599543 |
package com.android.gutendex.di
import com.android.gutendex.screens.books.BookInteractorImpl
import com.android.gutendex.screens.books.BooksInteractor
import com.android.gutendex.screens.info.InfoInteractor
import com.android.gutendex.screens.info.InfoInteractorImpl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.components.ViewModelComponent
@Module
@InstallIn(ViewModelComponent::class)
class InteractorModule {
@Provides
fun provideBooksInteractor(impl: BookInteractorImpl): BooksInteractor = impl
@Provides
fun provideBookInfoInteractor(impl: InfoInteractorImpl): InfoInteractor = impl
} | gutendex/app/src/main/java/com/android/gutendex/di/InteractorModule.kt | 2591922052 |
package com.android.gutendex.di
import com.android.gutendex.networking.ApiClient
import com.android.gutendex.networking.ApiClientImpl
import com.android.gutendex.networking.ApiService
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import retrofit2.Retrofit
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class ApiModule {
@Provides
@Singleton
fun provideApiService(retrofit: Retrofit): ApiService = retrofit.create(ApiService::class.java)
@Provides
@Singleton
fun provideApiClient(impl: ApiClientImpl): ApiClient = impl
} | gutendex/app/src/main/java/com/android/gutendex/di/ApiModule.kt | 3600475503 |
package com.android.gutendex.di
import com.android.gutendex.room.RoomBookRepository
import com.android.gutendex.room.RoomBookRepositoryImpl
import com.android.gutendex.screens.books.BooksRepository
import com.android.gutendex.screens.books.BooksRepositoryImpl
import com.android.gutendex.screens.info.InfoRepository
import com.android.gutendex.screens.info.InfoRepositoryImpl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class RepositoryModule {
@Provides
@Singleton
fun provideBooksRepository(impl: BooksRepositoryImpl): BooksRepository = impl
@Provides
@Singleton
fun provideRoomBooksRepository(impl: RoomBookRepositoryImpl): RoomBookRepository = impl
@Provides
@Singleton
fun provideInfoRepository(impl: InfoRepositoryImpl): InfoRepository = impl
}
| gutendex/app/src/main/java/com/android/gutendex/di/RepositoryModule.kt | 2784645982 |
package com.android.gutendex.di
import com.android.gutendex.helpers.ResourceProvider
import com.android.gutendex.helpers.ResourceProviderImpl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.SupervisorJob
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class ResourceModule {
@Provides
@Singleton
fun provideResourceProvider(impl: ResourceProviderImpl): ResourceProvider = impl
@Provides
@Singleton
fun provideCoroutineScopes(): CoroutineScope {
return CoroutineScope(SupervisorJob())
}
} | gutendex/app/src/main/java/com/android/gutendex/di/ResourceModule.kt | 214242010 |
package com.android.gutendex.room
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity(tableName = "books")
data class BookEntity(
@PrimaryKey @ColumnInfo(name = "id") val id: Int,
@ColumnInfo(name = "title") val title: String,
@ColumnInfo(name = "author") val author: String,
@ColumnInfo(name = "polularity") val popularity: Int,
@ColumnInfo(name = "image") val image: String?
) | gutendex/app/src/main/java/com/android/gutendex/room/BookEntity.kt | 625995040 |
package com.android.gutendex.room
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
@Database(entities = [BookEntity::class], version = 1)
abstract class BookDatabase : RoomDatabase() {
abstract fun bookDao(): BookDao
companion object {
private var INSTANCE: BookDatabase? = null
fun getDatabaseInstance(context: Context): BookDatabase {
return INSTANCE ?: synchronized(this) {
val instance = Room.databaseBuilder(
context.applicationContext,
BookDatabase::class.java,
"books"
).build()
INSTANCE = instance
instance
}
}
}
} | gutendex/app/src/main/java/com/android/gutendex/room/BookDB.kt | 3156989511 |
package com.android.gutendex.room
import com.android.gutendex.models.BookDomain
import com.android.gutendex.models.toBooksDomain
import com.android.gutendex.screens.books.BooksRepositoryResponse
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch
import javax.inject.Inject
interface RoomBookRepository {
fun getBooks(): Flow<BooksRepositoryResponse>
suspend fun getBooksPaged(pageSize: Int, offset: Int): Flow<BooksRepositoryResponse>
suspend fun saveBooksToDb(books: List<BookDomain>)
suspend fun clearBooks()
}
class RoomBookRepositoryImpl @Inject constructor(
private val bookDao: BookDao,
private var coroutineScope: CoroutineScope
) :
RoomBookRepository {
override fun getBooks(): Flow<BooksRepositoryResponse> = flow {
val books = bookDao.getAllBooks()
if (books.isEmpty().not()) {
emit(BooksRepositoryResponse.Success(books.toBooksDomain(), books.size))
} else {
emit(BooksRepositoryResponse.Error("no books in db"))
}
}
override suspend fun getBooksPaged(pageSize: Int, offset: Int): Flow<BooksRepositoryResponse> =
flow {
bookDao.getBooks(pageSize = pageSize, offset = offset).collect {
if (it.isEmpty().not()) {
emit(BooksRepositoryResponse.Success(it.toBooksDomain(), it.size))
} else {
emit(BooksRepositoryResponse.Error("no books in db"))
}
}
}
override suspend fun saveBooksToDb(books: List<BookDomain>) {
val dbBooks = books.map {
BookEntity(
it.id,
title = it.title ?: "",
author = it.author ?: "",
popularity = it.popularity,
image = it.img
)
}
coroutineScope.launch(Dispatchers.IO) {
bookDao.insertBooks(dbBooks)
}
}
override suspend fun clearBooks() {
bookDao.deleteAll()
}
} | gutendex/app/src/main/java/com/android/gutendex/room/RoomBookRepository.kt | 851904009 |
package com.android.gutendex.room
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import kotlinx.coroutines.flow.Flow
@Dao
interface BookDao {
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertBooks(books: List<BookEntity>)
@Query("SELECT * FROM books ORDER BY polularity DESC")
suspend fun getAllBooks(): List<BookEntity>
@Query("SELECT * FROM books LIMIT :pageSize OFFSET :offset")
fun getBooks(pageSize: Int, offset: Int): Flow<List<BookEntity>>
@Query("DELETE FROM books")
suspend fun deleteAll()
} | gutendex/app/src/main/java/com/android/gutendex/room/BookDao.kt | 3565082930 |
package com.android.gutendex
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class Application: Application() {
override fun onCreate() {
super.onCreate()
}
} | gutendex/app/src/main/java/com/android/gutendex/Application.kt | 1699884028 |
package com.android.gutendex.networking
import retrofit2.Response
import retrofit2.http.GET
import retrofit2.http.Path
import retrofit2.http.Query
import javax.inject.Inject
const val baseUrl = "http://gutendex.com"
interface ApiService {
@GET("/books?page=")
suspend fun retrieveBooksList(
@Query("page") page: Int
): Response<BooksResponseDto>
@GET("/books/{id}")
suspend fun retrieveBookById(
@Path("id") id: String,
): Response<SingeBookResponseDto>
}
interface ApiClient {
suspend fun retrieveBooksList(page: Int): Response<BooksResponseDto>
suspend fun retrieveBookById(id: String): Response<SingeBookResponseDto>
}
class ApiClientImpl @Inject constructor(private val apiService: ApiService) : ApiClient {
override suspend fun retrieveBooksList(page: Int): Response<BooksResponseDto> =
apiService.retrieveBooksList(page = page)
override suspend fun retrieveBookById(id: String): Response<SingeBookResponseDto> =
apiService.retrieveBookById(id)
} | gutendex/app/src/main/java/com/android/gutendex/networking/Api.kt | 3697411524 |
package com.android.gutendex.networking
import com.google.gson.annotations.SerializedName
data class BooksResponseDto(
val count: Int,
val next: String,
val previous: Any,
val results: List<BookResults>
)
data class BookResults(
val authors: List<Author>,
val bookshelves: List<String>,
val copyright: Boolean,
val download_count: Int,
val formats: Formats,
val id: Int,
val languages: List<String>,
val media_type: String,
val subjects: List<String>,
val title: String,
val translators: List<Translator>
)
data class Author(
val birth_year: Int,
val death_year: Int,
val name: String
)
data class Formats(
@SerializedName("text/html") val txtHmtl: String,
@SerializedName("application/epub+zip") val applicationEpub: String,
@SerializedName("application/x-mobipocket-ebook") val applicationEbook: String,
@SerializedName("application/rdf+xml") val applicationRdf: String,
@SerializedName("image/jpeg") val image: String,
@SerializedName("application/octet-stream") val applicationStream: String,
@SerializedName("text/plain; charset=us-ascii") val textPlain: String
)
data class Translator(
val birth_year: Int,
val death_year: Int,
val name: String
)
data class SingeBookResponseDto(
val authors: List<Author>,
val bookshelves: List<String>,
val copyright: Boolean,
val download_count: Int,
val formats: Formats,
val id: Int,
val languages: List<String>,
val media_type: String,
val subjects: List<String>,
val title: String,
val translators: List<Any>
)
| gutendex/app/src/main/java/com/android/gutendex/networking/NetworkingModels.kt | 1308759378 |
package com.android.gutendex.models
import com.android.gutendex.networking.BookResults
import com.android.gutendex.networking.BooksResponseDto
import com.android.gutendex.networking.SingeBookResponseDto
import com.android.gutendex.room.BookEntity
enum class NavRoutes(val route: String) {
BOOKS("/books"), BOOK("/book/{id}")
}
data class BookDomain(
val title: String? = "",
val author: String? = "",
val id: Int,
val popularity: Int,
val img: String? = ""
)
data class BookInfo(
val title: String,
val author: String,
val authorsBirth: String? = null,
val subject: String,
val img: String?
)
fun SingeBookResponseDto.toBookInfoDomain(): BookInfo {
return BookInfo(
title = this.title,
author = this.authors.joinToString { it.name },
authorsBirth = this.authors.joinToString { it.birth_year.toString() },
subject = this.subjects.first(),
img = this.formats.image
)
}
fun BooksResponseDto.toBooksDomain(): List<BookDomain> {
return this.results.map { bookResults ->
bookResults.toBookListing()
}
}
fun List<BookEntity>.toBooksDomain(): List<BookDomain> {
return this.map { bookEntity ->
bookEntity.toBookListing()
}
}
fun BookEntity.toBookListing(): BookDomain {
return BookDomain(
title = this.title,
author = this.author,
id = this.id,
popularity = this.popularity,
img = this.image
)
}
fun BookResults.toBookListing(): BookDomain {
return BookDomain(
title = this.title,
author = this.authors.joinToString { it.name },
id = this.id,
popularity = this.download_count,
img = this.formats.image
)
}
| gutendex/app/src/main/java/com/android/gutendex/models/Models.kt | 1603877772 |
package com.android.gutendex.screens.books
import android.util.Log
import androidx.lifecycle.viewModelScope
import androidx.navigation.NavController
import com.android.gutendex.base.MviViewModel
import com.android.gutendex.base.ViewEvent
import com.android.gutendex.base.ViewSideEffect
import com.android.gutendex.base.ViewState
import com.android.gutendex.models.BookDomain
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import javax.inject.Inject
data class State(
val listOfBooks: List<BookDomain> = listOf(),
val errorMessage: String? = null,
val totalBooksOnList: Int? = null,
val pages: Int,
val hasCashed: Boolean = false,
val isLoadingNext: Boolean = false,
val totalBooksCount: Int? = null,
val booksDbCount: Int? = null,
val isLoading: Boolean? = null,
val apiPages: Int,
val isRefreshing: Boolean = false
) : ViewState
sealed class Event : ViewEvent {
data object GetInitialBooks : Event()
data class GetMoreBooks(val page: Int) : Event()
data class LoadBooks(val page: Int) : Event()
data class NavigateToInfo(val id: Int, val navController: NavController) : Event()
data class SaveToDb(val books: List<BookDomain>) : Event()
data object ClearCache : Event()
data class UpdatePage(val pages: Int) : Event()
}
sealed class Effect : ViewSideEffect {
data class SaveToDB(val books: List<BookDomain>) : Effect()
data class LoadBooks(val page: Int) : Effect()
data class GetMoreBooks(val page: Int) : Effect()
}
@HiltViewModel
class BooksViewModel @Inject constructor(
private val booksInteractor: BooksInteractor,
) : MviViewModel<Event, State, Effect>() {
private val booksList = mutableListOf<BookDomain>()
override fun setInitialState(): State = State(
pages = 1,
isLoading = true,
apiPages = 1
)
override fun handleEvents(event: Event) {
when (event) {
is Event.GetInitialBooks -> {
setState { copy(isLoading = true) }
getRoomBooks(viewState.value.pages)
}
is Event.GetMoreBooks -> {
getMoreBooksFromApi(viewState.value.apiPages)
setState {
copy(apiPages = viewState.value.apiPages + 1)
}
}
is Event.LoadBooks -> {
setState { copy(isLoading = viewState.value.pages == 1) }
getRoomBooks(event.page)
}
is Event.NavigateToInfo -> {
event.navController.navigate("/book/${event.id}")
}
is Event.SaveToDb -> {
viewModelScope.launch(Dispatchers.IO) {
booksInteractor.saveBooksToDb(event.books)
delay(2000)
}
setEffect { Effect.LoadBooks(viewState.value.pages) }
}
is Event.ClearCache -> {
viewModelScope.launch(Dispatchers.IO) {
booksInteractor.clearCache()
}
}
is Event.UpdatePage -> {
getAllBooks()
setState {
copy(pages = event.pages + 1)
}
setEffect { Effect.LoadBooks(viewState.value.pages) }
}
}
}
private fun getAllBooks() {
viewModelScope.launch(Dispatchers.IO) {
booksInteractor.retrieveRoomBooks().collect {
when (it) {
is BooksPartialState.Success -> {
setState { copy(booksDbCount = it.totalCount) }
}
is BooksPartialState.Failed -> {
setState { copy(errorMessage = it.errorMessage) }
}
}
}
delay(1000)
}
}
private fun getMoreBooksFromApi(page: Int) {
viewModelScope.launch(Dispatchers.IO) {
setState { copy(isLoadingNext = true) }
booksInteractor.retrieveNextBooks(page).collect {
when (it) {
is BooksPartialState.Success -> {
setEffect { Effect.SaveToDB(it.books ?: listOf()) }
setState { copy(isLoadingNext = false) }
}
is BooksPartialState.Failed -> {
setState {
copy(
errorMessage = it.errorMessage,
)
}
}
}
}
}
}
private fun getRoomBooks(page: Int) {
getAllBooks()
setState {
copy(
isLoadingNext = viewState.value.pages > 1,
isLoading = viewState.value.pages == 1
)
}
viewModelScope.launch {
booksInteractor.retrieveRoomBooksPaginated(8, page).collect {
when (it) {
is BooksPartialState.Success -> {
it.books?.let { books -> booksList.addAll(books) }
setState {
copy(
listOfBooks = booksList.toSet().toList(),
isLoadingNext = false,
isLoading = false
)
}
}
is BooksPartialState.Failed -> {
setEffect { Effect.GetMoreBooks(viewState.value.pages) }
setState { copy(isLoading = false) }
}
}
}
viewState.value.booksDbCount?.let { dbcount ->
viewState.value.listOfBooks.let { bookList ->
if (dbcount - 1 == bookList.size && viewState.value.pages > 1) {
setEffect { Effect.GetMoreBooks(viewState.value.apiPages) }
}
}
}
}
}
} | gutendex/app/src/main/java/com/android/gutendex/screens/books/BooksViewModel.kt | 3918221497 |
package com.android.gutendex.screens.books
import com.android.gutendex.models.BookDomain
import com.android.gutendex.room.RoomBookRepository
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch
import javax.inject.Inject
interface BooksInteractor {
fun retrieveBooks(page: Int): Flow<BooksPartialState>
fun retrieveNextBooks(page: Int): Flow<BooksPartialState>
fun retrieveRoomBooks(): Flow<BooksPartialState>
fun retrieveRoomBooksPaginated(pageSIze: Int, offset: Int): Flow<BooksPartialState>
suspend fun saveBooksToDb(books: List<BookDomain>)
suspend fun clearCache()
}
class BookInteractorImpl @Inject constructor(
private val booksRepository: BooksRepository,
private val roomBookRepository: RoomBookRepository,
private val coroutineScope: CoroutineScope,
) : BooksInteractor {
override fun retrieveBooks(page: Int): Flow<BooksPartialState> = flow {
booksRepository.getBooks(page = page).collect {
when (it) {
is BooksRepositoryResponse.Failed -> {
emit(BooksPartialState.Failed(it.errorMessage))
}
is BooksRepositoryResponse.Success -> {
emit(BooksPartialState.Success(it.booksList, it.totalCount))
}
is BooksRepositoryResponse.Error -> {
emit(BooksPartialState.Failed(it.errorResponse))
}
}
}
}
override fun retrieveNextBooks(page: Int): Flow<BooksPartialState> = flow {
booksRepository.getBooks(page = page).collect {
when (it) {
is BooksRepositoryResponse.Failed -> {
emit(BooksPartialState.Failed(it.errorMessage))
}
is BooksRepositoryResponse.Success -> {
emit(BooksPartialState.Success(it.booksList, it.totalCount))
}
is BooksRepositoryResponse.Error -> {
emit(BooksPartialState.Failed(it.errorResponse))
}
}
}
}
override fun retrieveRoomBooks(): Flow<BooksPartialState> = flow {
roomBookRepository.getBooks().collect {
when (it) {
is BooksRepositoryResponse.Success -> {
emit(BooksPartialState.Success(it.booksList, it.totalCount))
}
is BooksRepositoryResponse.Error -> {
emit(BooksPartialState.Failed(it.errorResponse))
}
is BooksRepositoryResponse.Failed -> {
emit(BooksPartialState.Failed(it.errorMessage))
}
}
}
}
override fun retrieveRoomBooksPaginated(pageSIze: Int, offset: Int): Flow<BooksPartialState> =
flow {
roomBookRepository.getBooksPaged(pageSIze, offset).collect {
when (it) {
is BooksRepositoryResponse.Success -> {
emit(BooksPartialState.Success(it.booksList, it.totalCount))
}
is BooksRepositoryResponse.Error -> {
emit(BooksPartialState.Failed(it.errorResponse))
}
is BooksRepositoryResponse.Failed -> {
emit(BooksPartialState.Failed(it.errorMessage))
}
}
}
}
override suspend fun saveBooksToDb(books: List<BookDomain>) {
coroutineScope.launch(Dispatchers.IO) {
roomBookRepository.saveBooksToDb(books)
}
}
override suspend fun clearCache() {
roomBookRepository.clearBooks()
}
}
sealed class BooksPartialState {
data class Success(val books: List<BookDomain>?, val totalCount: Int?) : BooksPartialState()
data class Failed(val errorMessage: String) : BooksPartialState()
} | gutendex/app/src/main/java/com/android/gutendex/screens/books/BooksInteractor.kt | 2529090471 |
package com.android.gutendex.screens.books
import com.android.gutendex.models.BookDomain
import com.android.gutendex.models.toBooksDomain
import com.android.gutendex.networking.ApiClient
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
interface BooksRepository {
fun getBooks(page: Int): Flow<BooksRepositoryResponse>
}
class BooksRepositoryImpl @Inject constructor(private val apiClient: ApiClient) : BooksRepository {
override fun getBooks(page: Int) = flow {
val response = apiClient.retrieveBooksList(page)
if (response.isSuccessful) {
emit(
BooksRepositoryResponse.Success(
response.body()?.toBooksDomain(),
response.body()?.count
)
)
} else
emit(BooksRepositoryResponse.Error(response.errorBody().toString()))
}.catch {
emit(BooksRepositoryResponse.Failed(errorMessage = "something went wrong"))
}
}
sealed class BooksRepositoryResponse {
data class Success(val booksList: List<BookDomain>?, val totalCount: Int?) :
BooksRepositoryResponse()
data class Error(val errorResponse: String) : BooksRepositoryResponse()
data class Failed(val errorMessage: String) : BooksRepositoryResponse()
} | gutendex/app/src/main/java/com/android/gutendex/screens/books/BooksRepository.kt | 2466117246 |
package com.android.gutendex.screens.books
import android.annotation.SuppressLint
import android.util.Log
import androidx.compose.foundation.Image
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardColors
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.flowWithLifecycle
import androidx.navigation.NavController
import coil.compose.rememberAsyncImagePainter
import coil.request.CachePolicy.ENABLED
import coil.request.ImageRequest
import com.android.gutendex.R
import com.android.gutendex.helpers.LifecycleEffect
import com.android.gutendex.helpers.LoadingIndicator
import com.android.gutendex.models.BookDomain
@OptIn(ExperimentalMaterial3Api::class)
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@Composable
fun BooksScreen(navController: NavController) {
val viewModel = hiltViewModel<BooksViewModel>()
val lifecycleOwner = LocalLifecycleOwner.current
val state = viewModel.viewState
val lazyColumnListState = rememberLazyListState()
LifecycleEffect(
lifecycleOwner = LocalLifecycleOwner.current, lifecycleEvent = Lifecycle.Event.ON_CREATE
) {
viewModel.setEvent(Event.GetInitialBooks)
}
Scaffold(topBar = {
TopAppBar(colors = TopAppBarDefaults.topAppBarColors(
containerColor = MaterialTheme.colorScheme.primaryContainer,
titleContentColor = MaterialTheme.colorScheme.surfaceTint
), title = { Text(text = stringResource(id = R.string.app_name)) })
}) { paddingValues ->
if (state.value.isLoading == true) {
Box(
modifier = Modifier
.fillMaxSize(),
contentAlignment = Alignment.Center
) {
CircularProgressIndicator()
}
}
LazyColumn(
state = lazyColumnListState,
modifier = Modifier.padding(top = paddingValues.calculateTopPadding())
) {
state.value.listOfBooks.let { books ->
items(books.size) { index ->
BookItem(book = books[index]) { _ ->
viewModel.setEvent(Event.NavigateToInfo(books[index].id, navController))
}
state.value.totalBooksCount ?: state.value.booksDbCount?.let {
if (index == books.lastIndex && books.size < it && state.value.isLoadingNext.not()
) {
viewModel.setEvent(Event.UpdatePage(state.value.pages))
}
}
}
if (state.value.isLoadingNext) {
item { LoadingIndicator() }
}
}
}
}
LaunchedEffect(Unit) {
viewModel.effect.flowWithLifecycle(lifecycleOwner.lifecycle, Lifecycle.State.RESUMED)
.collect { effect ->
when (effect) {
is Effect.SaveToDB -> {
viewModel.setEvent(Event.SaveToDb(effect.books))
}
is Effect.LoadBooks -> {
viewModel.setEvent(Event.LoadBooks(effect.page))
}
is Effect.GetMoreBooks -> {
viewModel.setEvent(Event.GetMoreBooks(effect.page))
}
}
}
}
}
@Composable
fun BookItem(book: BookDomain, onClickAction: (Int) -> Unit) {
Card(colors = CardColors(
containerColor = MaterialTheme.colorScheme.primaryContainer,
contentColor = MaterialTheme.colorScheme.surfaceTint,
disabledContainerColor = MaterialTheme.colorScheme.primaryContainer,
disabledContentColor = MaterialTheme.colorScheme.primaryContainer
),
elevation = CardDefaults.cardElevation(defaultElevation = 3.dp),
shape = RoundedCornerShape(6.dp),
modifier = Modifier
.padding(top = 8.dp, bottom = 8.dp, start = 16.dp, end = 16.dp)
.fillMaxWidth()
.height(100.dp)
.clickable { onClickAction.invoke(book.id) }) {
Row {
Column {
book.img?.let {
val builder = ImageRequest.Builder(LocalContext.current)
.data(it)
.memoryCacheKey(it)
.diskCacheKey(it)
.diskCachePolicy(ENABLED)
.memoryCachePolicy(ENABLED)
.placeholder(R.drawable.ic_launcher_foreground)
Image(
painter = rememberAsyncImagePainter(remember(it) {
builder.build()
}),
contentScale = ContentScale.Fit,
contentDescription = null,
)
}
}
Column(modifier = Modifier.padding(16.dp)) {
Text(text = "Title: ${book.title ?: ""}")
Text(text = "Auhor: ${book.author ?: ""}")
}
}
}
}
| gutendex/app/src/main/java/com/android/gutendex/screens/books/BooksScreen.kt | 2536342001 |
package com.android.gutendex.screens.info
import com.android.gutendex.models.BookInfo
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
interface InfoInteractor {
fun retrieveBookInfo(id: String): Flow<BookInfoPartialState>
}
class InfoInteractorImpl @Inject constructor(private val infoRepository: InfoRepository) :
InfoInteractor {
override fun retrieveBookInfo(id: String): Flow<BookInfoPartialState> = flow {
infoRepository.getBookInfo(id).collect {
when (it) {
is BookInfoRepositoryResponse.Success -> {
emit(BookInfoPartialState.Success(it.bookInfo))
}
is BookInfoRepositoryResponse.Failed->{
emit(BookInfoPartialState.Failed(it.errorMessage))
}
is BookInfoRepositoryResponse.Error->{
emit(BookInfoPartialState.Failed(it.errorResponse))
}
}
}
}
}
sealed class BookInfoPartialState {
data class Success(val bookInfo: BookInfo?) : BookInfoPartialState()
data class Failed(val errorMessage: String) : BookInfoPartialState()
} | gutendex/app/src/main/java/com/android/gutendex/screens/info/InfoInteractor.kt | 2681620461 |
package com.android.gutendex.screens.info
import com.android.gutendex.models.BookInfo
import com.android.gutendex.models.toBookInfoDomain
import com.android.gutendex.networking.ApiClient
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
interface InfoRepository {
fun getBookInfo(id: String): Flow<BookInfoRepositoryResponse>
}
class InfoRepositoryImpl @Inject constructor(private val apiClient: ApiClient) : InfoRepository {
override fun getBookInfo(id: String) = flow {
val response = apiClient.retrieveBookById(id)
if (response.isSuccessful) {
emit(BookInfoRepositoryResponse.Success(response.body()?.toBookInfoDomain()))
} else
emit(BookInfoRepositoryResponse.Error(response.errorBody().toString()))
}.catch {
emit(BookInfoRepositoryResponse.Failed(it.localizedMessage.toString()))
}
}
sealed class BookInfoRepositoryResponse {
data class Success(val bookInfo: BookInfo?) : BookInfoRepositoryResponse()
data class Error(val errorResponse: String) : BookInfoRepositoryResponse()
data class Failed(val errorMessage: String) : BookInfoRepositoryResponse()
} | gutendex/app/src/main/java/com/android/gutendex/screens/info/InfoRepository.kt | 3238257007 |
package com.android.gutendex.screens.info
import android.annotation.SuppressLint
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.Lifecycle
import androidx.navigation.NavController
import coil.compose.rememberAsyncImagePainter
import coil.request.CachePolicy
import coil.request.ImageRequest
import com.android.gutendex.R
import com.android.gutendex.helpers.LifecycleEffect
import com.android.gutendex.helpers.LoadingIndicatorFull
import com.android.gutendex.models.BookInfo
@OptIn(ExperimentalMaterial3Api::class)
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@Composable
fun InfoScreen(navController: NavController, bookId: String) {
val viewModel = hiltViewModel<InfoViewModel>()
val lifecycleOwner = LocalLifecycleOwner.current
val state = viewModel.viewState
LifecycleEffect(
lifecycleOwner = LocalLifecycleOwner.current, lifecycleEvent = Lifecycle.Event.ON_RESUME
) {
viewModel.setEvent(Event.GetBookInfo(bookId))
}
Scaffold(topBar = {
TopAppBar(colors = TopAppBarDefaults.topAppBarColors(
containerColor = MaterialTheme.colorScheme.primaryContainer,
titleContentColor = MaterialTheme.colorScheme.surfaceTint
), title = {
state.value.bookInfo?.title?.let {
Text(
text = it, maxLines = 1, overflow = TextOverflow.Ellipsis
)
}
}, navigationIcon = {
IconButton(onClick = { navController.popBackStack() }) {
Icon(
imageVector = Icons.Default.ArrowBack,
contentDescription = "",
tint = MaterialTheme.colorScheme.surfaceTint
)
}
})
}) { paddongValues ->
Column(
modifier = Modifier
.padding(paddongValues)
.fillMaxSize()
) {
if (state.value.errorMessage?.isNotEmpty() == true) {
Text(text = state.value.errorMessage.toString())
}
if (state.value.isLoading) {
LoadingIndicatorFull()
} else BookInfo(state.value.bookInfo)
}
}
}
@Composable
fun BookInfo(bookInfo: BookInfo?) {
Box(
modifier = Modifier
.padding(top = 16.dp, bottom = 8.dp, start = 16.dp, end = 16.dp)
.fillMaxWidth()
.height(250.dp)
) {
Row {
Column {
bookInfo?.img?.let {
val builder =
ImageRequest.Builder(LocalContext.current).data(it).memoryCacheKey(it)
.diskCacheKey(it).diskCachePolicy(CachePolicy.ENABLED)
.memoryCachePolicy(CachePolicy.ENABLED)
.placeholder(R.drawable.ic_launcher_foreground)
Image(
painter = rememberAsyncImagePainter(remember(it) {
builder.build()
}),
contentScale = ContentScale.Fit,
contentDescription = null,
)
}
}
Column(modifier = Modifier.padding(start = 16.dp)) {
Text(text = "Title: ${bookInfo?.title}")
Text(text = "Author: ${bookInfo?.author}")
Text(text = "AuthorBirth: ${bookInfo?.authorsBirth}")
Text(text = "subject: ${bookInfo?.subject}")
}
}
}
}
| gutendex/app/src/main/java/com/android/gutendex/screens/info/InfoScreen.kt | 1633775799 |
package com.android.gutendex.screens.info
import androidx.lifecycle.viewModelScope
import com.android.gutendex.base.MviViewModel
import com.android.gutendex.base.ViewEvent
import com.android.gutendex.base.ViewSideEffect
import com.android.gutendex.base.ViewState
import com.android.gutendex.models.BookInfo
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import javax.inject.Inject
data class State(
val isLoading: Boolean = false,
val bookInfo: BookInfo?= null,
val errorMessage: String? = ""
) : ViewState
sealed class Event : ViewEvent {
data class GetBookInfo(val bookId: String) : Event()
}
sealed class Effect : ViewSideEffect {
}
@HiltViewModel
class InfoViewModel @Inject constructor(
private val infoInteractor: InfoInteractor
) :
MviViewModel<Event, State, Effect>() {
override fun setInitialState(): State =
State(
isLoading = true,
)
override fun handleEvents(event: Event) {
when (event) {
is Event.GetBookInfo -> {
viewModelScope.launch {
infoInteractor.retrieveBookInfo(event.bookId).collect {
when (it) {
is BookInfoPartialState.Success -> {
setState {
copy(
bookInfo = it.bookInfo,
isLoading = false
)
}
}
is BookInfoPartialState.Failed -> {
setState {
copy(
errorMessage = it.errorMessage,
isLoading = false
)
}
}
}
}
}
}
}
}
} | gutendex/app/src/main/java/com/android/gutendex/screens/info/InfoViewModel.kt | 1767472767 |
package com.android.gutendex.screens.main
import android.annotation.SuppressLint
import android.os.Build
import androidx.annotation.RequiresApi
import androidx.compose.material3.Scaffold
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.Lifecycle
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import androidx.navigation.navArgument
import com.android.gutendex.helpers.LifecycleEffect
import com.android.gutendex.models.NavRoutes
import com.android.gutendex.screens.books.BooksScreen
import com.android.gutendex.screens.info.InfoScreen
@RequiresApi(Build.VERSION_CODES.TIRAMISU)
@SuppressLint("UnusedMaterialScaffoldPaddingParameter", "UnusedMaterial3ScaffoldPaddingParameter")
@Composable
fun MainScreen() {
val navController = rememberNavController()
Scaffold {
NavHost(
navController = navController,
startDestination = NavRoutes.BOOKS.route
) {
composable(route = NavRoutes.BOOKS.route) {
BooksScreen(navController)
}
composable(
route = NavRoutes.BOOK.route,
arguments = listOf(navArgument("id") {
type = NavType.StringType
})
) { backStackEntry ->
InfoScreen(navController, backStackEntry.arguments?.getString("id") ?: "")
}
}
}
}
| gutendex/app/src/main/java/com/android/gutendex/screens/main/MainScreen.kt | 2679579603 |
package com.android.gutendex.theme
import androidx.compose.material3.ColorScheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
data class ThemeColorsTemplate(
private val darkTheme: Boolean, val light: ColorScheme, val dark: ColorScheme
) {
val colors: ColorScheme
get() {
return when (darkTheme) {
true -> dark
false -> light
}
}
}
val md_theme_light_primary = Color(0xFFAE907B)
val md_theme_light_primaryContainer = Color(0xfff6f0e5)
val md_theme_light_secondaryContainer = Color(0xFFE9DDC7)
val md_theme_light_onSurface = Color(0xffFDFAF4)
val md_theme_light_surfaceTint = Color(0xFF000000)
val md_theme_light_outlineVariant = Color(0x80404040)
val md_theme_light_scrim = Color(0xFFFFFFFF)
private val LightColors = lightColorScheme(
primary = md_theme_light_primary,
primaryContainer = md_theme_light_primaryContainer,
secondaryContainer = md_theme_light_secondaryContainer,
onSurface = md_theme_light_onSurface,
surfaceTint = md_theme_light_surfaceTint,
outlineVariant = md_theme_light_outlineVariant,
scrim = md_theme_light_scrim,
)
private val DarkColors = darkColorScheme()
@Composable
fun themeColors(darkTheme: Boolean): ThemeColorsTemplate {
return ThemeColorsTemplate(darkTheme, LightColors, DarkColors)
}
| gutendex/app/src/main/java/com/android/gutendex/theme/Color.kt | 1477693750 |
package com.android.gutendex.theme
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Shapes
import androidx.compose.ui.unit.dp
val Shapes = Shapes(
small = RoundedCornerShape(4.dp),
medium = RoundedCornerShape(4.dp),
large = RoundedCornerShape(20.dp)
) | gutendex/app/src/main/java/com/android/gutendex/theme/Shapes.kt | 1122148736 |
package com.android.gutendex.theme
import android.os.Build
import androidx.annotation.RequiresApi
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.ui.platform.LocalContext
import com.google.accompanist.systemuicontroller.rememberSystemUiController
@RequiresApi(Build.VERSION_CODES.S)
@Composable
fun AppTheme(
darkTheme: Boolean = false /*isSystemInDarkTheme()*/,
content: @Composable () -> Unit
) {
val useDynamicColors = false//Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
val colors = when {
useDynamicColors && darkTheme -> dynamicDarkColorScheme(LocalContext.current)
useDynamicColors && !darkTheme -> dynamicLightColorScheme(LocalContext.current)
else -> themeColors(darkTheme = darkTheme).colors
}
// Remember a SystemUiController
val systemUiController = rememberSystemUiController()
val useDarkIcons = !darkTheme
val background = colors.background
DisposableEffect(systemUiController, useDarkIcons) {
// Update all of the system bar colors to be transparent, and use
// dark icons if we're in light theme
systemUiController.setSystemBarsColor(
color = background,
darkIcons = useDarkIcons
)
systemUiController.setNavigationBarColor(
color = background,
darkIcons = useDarkIcons
)
onDispose {}
}
MaterialTheme(
colorScheme = colors,
typography = typography().typography,
shapes = Shapes,
content = content
)
} | gutendex/app/src/main/java/com/android/gutendex/theme/Theme.kt | 1473853283 |
package com.android.gutendex.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.Font
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
import com.android.gutendex.R
data class ThemeTypoTemplate(
val typography: Typography
)
fun typography(): ThemeTypoTemplate {
return ThemeTypoTemplate(typography = applicationTypo)
}
val publicSans = FontFamily(
Font(R.font.public_san_regular, FontWeight.Normal),
Font(R.font.public_san_bold, FontWeight.Bold),
Font(R.font.public_san_extra_bold, FontWeight.ExtraBold),
Font(R.font.public_san_italic, FontWeight.Normal),
Font(R.font.public_san_thin, FontWeight.Thin)
)
private val applicationTypo = Typography(
displayLarge = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 57.sp,
lineHeight = 64.sp,
letterSpacing = (-0.25).sp
),
displayMedium = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 45.sp,
lineHeight = 52.sp
),
displaySmall = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 36.sp,
lineHeight = 44.sp
),
headlineLarge = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 32.sp,
lineHeight = 40.sp
),
headlineMedium = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 28.sp,
lineHeight = 36.sp
),
headlineSmall = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 24.sp,
lineHeight = 32.sp
),
titleLarge = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Bold,
fontSize = 22.sp,
lineHeight = 28.sp
),
titleMedium = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.SemiBold,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.4.sp
),
titleSmall = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Medium,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.1.sp
),
bodyLarge = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
),
bodyMedium = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 14.sp,
lineHeight = 19.6.sp,
letterSpacing = 0.25.sp
),
bodySmall = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 12.sp,
lineHeight = 16.sp,
letterSpacing = 0.4.sp
),
labelLarge = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 14.sp,
lineHeight = 20.sp,
letterSpacing = 0.1.sp
),
labelMedium = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Normal,
fontSize = 12.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
),
labelSmall = TextStyle(
fontFamily = publicSans,
fontWeight = FontWeight.Medium,
fontSize = 10.sp,
lineHeight = 16.sp
),
) | gutendex/app/src/main/java/com/android/gutendex/theme/Type.kt | 4049128827 |
package com.android.gutendex.helpers
import android.content.Context
import androidx.annotation.StringRes
import dagger.hilt.android.qualifiers.ApplicationContext
import javax.inject.Inject
interface ResourceProvider {
fun provideContext(): Context
fun getString(@StringRes resId: Int): String
fun getString(@StringRes resId: Int, vararg formatArgs: Any): String
}
class ResourceProviderImpl @Inject constructor(
@ApplicationContext private val context: Context
) : ResourceProvider {
override fun provideContext() = context
override fun getString(@StringRes resId: Int): String = context.getString(resId)
override fun getString(resId: Int, vararg formatArgs: Any): String {
return context.getString(resId, *formatArgs)
}
} | gutendex/app/src/main/java/com/android/gutendex/helpers/ResourceProvider.kt | 2634864112 |
package com.android.gutendex.helpers
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.zIndex
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwner
/**
* Execute an effect based on [Lifecycle.Event]
*
* @param lifecycleOwner The lifecycle owner
* @param lifecycleEvent The lifecycle event that code needs to be executed
*/
@Composable
fun LifecycleEffect(
lifecycleOwner: LifecycleOwner, lifecycleEvent: Lifecycle.Event, block: () -> Unit,
) {
DisposableEffect(lifecycleOwner) {
val observer = LifecycleEventObserver { _, event ->
if (event == lifecycleEvent) {
block()
}
}
// Add the observer to the lifecycle
lifecycleOwner.lifecycle.addObserver(observer)
// When the effect leaves the Composition, remove the observer
onDispose {
lifecycleOwner.lifecycle.removeObserver(observer)
}
}
}
@Composable
fun LoadingIndicator() {
Box(
modifier = Modifier
.background(Color.Transparent)
.fillMaxWidth()
.height(100.dp)
.padding(vertical = 8.dp)
.zIndex(20f),
contentAlignment = Alignment.Center
) {
CircularProgressIndicator()
}
}
@Composable
fun LoadingIndicatorFull() {
Box(
modifier = Modifier
.background(Color.Transparent)
.fillMaxSize()
.padding(vertical = 8.dp)
.zIndex(20f),
contentAlignment = Alignment.Center
) {
CircularProgressIndicator()
}
}
@Preview
@Composable
fun LoadingIndicatorPreview() {
LoadingIndicator()
}
| gutendex/app/src/main/java/com/android/gutendex/helpers/ViewHelpers.kt | 4292912341 |
package com.android.gutendex.base
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch
interface ViewEvent
interface ViewState
interface ViewSideEffect
abstract class MviViewModel<Event : ViewEvent, UiState : ViewState, Effect : ViewSideEffect> :
ViewModel() {
private val initialState: UiState by lazy { setInitialState() }
abstract fun setInitialState(): UiState
private val _viewState: MutableState<UiState> by lazy { mutableStateOf(initialState) }
val viewState: State<UiState> by lazy { _viewState }
private val _event: MutableSharedFlow<Event> = MutableSharedFlow()
private val _effect: Channel<Effect> = Channel()
val effect = _effect.receiveAsFlow()
private val _viewStateHistory: Channel<UiState> = Channel()
val viewStateHistory get() = _viewStateHistory.receiveAsFlow()
init {
subscribeToEvents()
}
fun setEvent(event: Event) {
viewModelScope.launch { _event.emit(event) }
}
protected fun setState(reducer: UiState.() -> UiState) {
val newState = viewState.value.reducer()
_viewState.value = newState
notifyViewStateHistoryChanged(newState)
}
private fun subscribeToEvents() {
viewModelScope.launch {
_event.collect {
handleEvents(it)
}
}
}
private fun notifyViewStateHistoryChanged(state: UiState) {
viewModelScope.launch { _viewStateHistory.send(state) }
}
abstract fun handleEvents(event: Event)
protected fun setEffect(builder: () -> Effect) {
val effectValue = builder()
viewModelScope.launch { _effect.send(effectValue) }
}
} | gutendex/app/src/main/java/com/android/gutendex/base/BaseViewModel.kt | 4268076636 |
package com.android.gutendex.base
import android.annotation.SuppressLint
import android.os.Build
import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.annotation.RequiresApi
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.ui.Modifier
import androidx.fragment.app.FragmentActivity
import com.android.gutendex.screens.main.MainScreen
import com.android.gutendex.theme.AppTheme
import dagger.hilt.android.AndroidEntryPoint
@ExperimentalMaterial3Api
@AndroidEntryPoint
class BaseContainer : FragmentActivity() {
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@RequiresApi(Build.VERSION_CODES.TIRAMISU)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
AppTheme {
Scaffold(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colorScheme.onSurface)
) {
MainScreen()
}
}
}
}
} | gutendex/app/src/main/java/com/android/gutendex/base/BaseContainer.kt | 3951541198 |
package com.example.a3lab3
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.a3lab3", appContext.packageName)
}
} | 3lab3/app/src/androidTest/java/com/example/a3lab3/ExampleInstrumentedTest.kt | 484804915 |
package com.example.a3lab3
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)
}
} | 3lab3/app/src/test/java/com/example/a3lab3/ExampleUnitTest.kt | 3750811594 |
package com.example.a3lab3.ui.home
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class HomeViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is home Fragment"
}
val text: LiveData<String> = _text
} | 3lab3/app/src/main/java/com/example/a3lab3/ui/home/HomeViewModel.kt | 3992996953 |
package com.example.a3lab3.ui.home
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.example.a3lab3.databinding.FragmentHomeBinding
class HomeFragment : Fragment() {
private var _binding: FragmentHomeBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val homeViewModel =
ViewModelProvider(this).get(HomeViewModel::class.java)
_binding = FragmentHomeBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textHome
homeViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | 3lab3/app/src/main/java/com/example/a3lab3/ui/home/HomeFragment.kt | 3762416924 |
package com.example.a3lab3.ui.dashboard
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.example.a3lab3.databinding.FragmentDashboardBinding
class DashboardFragment : Fragment() {
private var _binding: FragmentDashboardBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val dashboardViewModel =
ViewModelProvider(this).get(DashboardViewModel::class.java)
_binding = FragmentDashboardBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textDashboard
dashboardViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | 3lab3/app/src/main/java/com/example/a3lab3/ui/dashboard/DashboardFragment.kt | 2247054373 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.