content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.example.cleanarchcrypto
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)
}
} | CleanArchJetpackCompose/app/src/test/java/com/example/cleanarchcrypto/ExampleUnitTest.kt | 1677347901 |
package com.example.cleanarchcrypto.utils
import com.example.cleanarchcrypto.data.remote.dto.CoinDetailDto
import com.example.cleanarchcrypto.data.remote.dto.CoinDto
import com.example.cleanarchcrypto.data.remote.dto.Links
import com.example.cleanarchcrypto.data.remote.dto.Whitepaper
object CommonObject {
val mockCoinList = listOf<CoinDto>(
CoinDto(
id = "id",
isActive = true,
name = "metc",
rank = 1,
symbol = "ask",
isNew = false,
type = "coin"
)
)
val mockCoinDetail =
CoinDetailDto(
description = "Sample Description",
developmentStatus = "Sample Development Status",
firstDataAt = "2022-01-01",
hardwareWallet = true,
hashAlgorithm = "Sample Hash Algorithm",
id = "sample_id",
isActive = true,
isNew = false,
lastDataAt = "2022-01-31",
links = Links(
explorer = emptyList(),
facebook = emptyList(),
reddit = emptyList(),
sourceCode = emptyList(),
website = emptyList(),
youtube = emptyList()
),
linksExtended = emptyList(),
message = "Sample Message",
name = "Sample Name",
openSource = true,
orgStructure = "Sample Org Structure",
proofType = "Sample Proof Type",
rank = 1,
startedAt = "2022-01-01",
symbol = "SAMPLE",
tags = emptyList(),
team = emptyList(),
type = "Sample Type",
whitepaper = Whitepaper(link = "link", thumbnail = "thumbnail")
)
} | CleanArchJetpackCompose/app/src/test/java/com/example/cleanarchcrypto/utils/CommonObjects.kt | 2142526313 |
package com.example.cleanarchcrypto.utils
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.TestDispatcher
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.setMain
import org.junit.rules.TestWatcher
import org.junit.runner.Description
@ExperimentalCoroutinesApi
class MainDispatcherRule(
private val testDispatcher: TestDispatcher = UnconfinedTestDispatcher(),
) : TestWatcher() {
override fun starting(description: Description) {
Dispatchers.setMain(testDispatcher)
}
override fun finished(description: Description) {
Dispatchers.resetMain()
}
} | CleanArchJetpackCompose/app/src/test/java/com/example/cleanarchcrypto/utils/MainDispatcherRule.kt | 1994704458 |
package com.example.cleanarchcrypto.data.repository
import com.example.cleanarchcrypto.data.remote.CoinPaprikaApi
import com.example.cleanarchcrypto.domain.repository.CoinRepository
import com.example.cleanarchcrypto.utils.CommonObject
import io.mockk.coEvery
import io.mockk.mockk
import kotlinx.coroutines.runBlocking
import org.junit.Assert.assertEquals
import org.junit.Before
import org.junit.Test
class CoinRepositoryImplTest {
private lateinit var api: CoinPaprikaApi
@Before
fun setup() {
api = mockk<CoinPaprikaApi>()
}
@Test
fun `getCoins should return a list of CoinDto`() = runBlocking {
// Given
val coinRepository: CoinRepository = CoinRepositoryImpl(api)
val mockCoinList = CommonObject.mockCoinList
coEvery { api.getCoins() } returns mockCoinList
// When
val result = coinRepository.getCoins()
// Then
assertEquals(mockCoinList, result)
}
@Test
fun `getCoinById should return a CoinDetailDto`() = runBlocking {
// Given
val coinRepository: CoinRepository = CoinRepositoryImpl(api)
val coinId = "CoinId"
val mockCoinDetailDto = CommonObject.mockCoinDetail
coEvery { api.getCoinById(coinId) } returns mockCoinDetailDto
// When
val result = coinRepository.getCoinById(coinId)
// Then
assertEquals(mockCoinDetailDto, result)
}
}
| CleanArchJetpackCompose/app/src/test/java/com/example/cleanarchcrypto/data/repository/CoinRepositoryImplTest.kt | 2234206050 |
package com.example.cleanarchcrypto.domain.use_case.get_coin
import android.net.http.HttpException
import com.example.cleanarchcrypto.common.Resource
import com.example.cleanarchcrypto.data.remote.dto.toCoinDetail
import com.example.cleanarchcrypto.domain.repository.CoinRepository
import com.example.cleanarchcrypto.utils.CommonObject
import io.mockk.coEvery
import io.mockk.coVerify
import io.mockk.mockk
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.runBlocking
import org.junit.Assert.*
import org.junit.Before
import org.junit.Test
import java.io.IOException
class GetCoinUseCaseTest {
private lateinit var mockRepository: CoinRepository
private lateinit var getCoinUseCase: GetCoinUseCase
private val coinId = "c1"
@Before
fun setup() {
mockRepository = mockk()
getCoinUseCase = GetCoinUseCase(mockRepository)
}
@Test
fun `invoke - should return loading and success`() = runBlocking {
// Arrange
val mockCoinDetail = CommonObject.mockCoinDetail
coEvery { mockRepository.getCoinById(coinId) } returns mockCoinDetail
// Act
val result = getCoinUseCase(coinId).toList()
// Assert emitted state
assertEquals(2, result.size)
// First emission should be Resource.Loading
assertEquals(Resource.Loading::class, result[0]::class)
assertTrue(result[1] is Resource.Success<*>)
assertEquals(mockCoinDetail.toCoinDetail(), result[1].data)
coVerify(exactly = 1) { mockRepository.getCoinById(coinId) }
}
@Test
fun `invoke - should return loading and error when HttpException occurs`() = runBlocking {
// Arrange
val errorMessage = "Server error"
coEvery { mockRepository.getCoinById(coinId) } throws HttpException(errorMessage, null)
// Act
val result = getCoinUseCase(coinId).toList()
// Assert
assertEquals(2, result.size)
assertTrue(result[0] is Resource.Loading<*>)
assertTrue(result[1] is Resource.Error)
coVerify(exactly = 1) { mockRepository.getCoinById(coinId) }
}
@Test
fun `invoke - should return loading and error when IOException occurs`() = runBlocking {
// Arrange
val errorMessage = "Couldn't reach server. Check your internet connection."
coEvery { mockRepository.getCoinById(coinId) } throws IOException()
// Act
val result = getCoinUseCase(coinId).toList()
// Assert
assertEquals(2, result.size)
assertTrue(result[0] is Resource.Loading<*>)
val secondEmission = result[1]
assertTrue(secondEmission is Resource.Error)
assertEquals(errorMessage, secondEmission.message)
coVerify(exactly = 1) { mockRepository.getCoinById(coinId) }
}
} | CleanArchJetpackCompose/app/src/test/java/com/example/cleanarchcrypto/domain/use_case/get_coin/GetCoinUseCaseTest.kt | 2959968737 |
import android.net.http.HttpException
import com.example.cleanarchcrypto.common.Resource
import com.example.cleanarchcrypto.data.remote.dto.toCoin
import com.example.cleanarchcrypto.domain.repository.CoinRepository
import com.example.cleanarchcrypto.domain.use_case.get_coins.GetCoinsUseCase
import com.example.cleanarchcrypto.utils.CommonObject
import io.mockk.*
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.runBlocking
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import java.io.IOException
class GetCoinsUseCaseTest {
// inline fun <reified T> isA() = isA<T>(T::class.java)
private lateinit var mockRepository: CoinRepository
private lateinit var getCoinsUseCase: GetCoinsUseCase
@Before
fun setUp() {
mockRepository = mockk()
getCoinsUseCase = GetCoinsUseCase(mockRepository)
}
@Test
fun `invoke - should return loading and success`() = runBlocking {
// Arrange
val mockCoinList = CommonObject.mockCoinList
coEvery { mockRepository.getCoins() } returns mockCoinList
// Act
val result = getCoinsUseCase().toList()
// Assert emitted state
assertEquals(2, result.size)
// First emission should be Resource.Loading
assertEquals(Resource.Loading::class, result[0]::class)
assertTrue(result[1] is Resource.Success<*>)
assertEquals(mockCoinList.map { it.toCoin() }, result[1].data)
coVerify(exactly = 1) { mockRepository.getCoins() }
}
@Test
fun `invoke - should return loading and success with empty list`() = runBlocking {
// Arrange
coEvery { mockRepository.getCoins() } returns emptyList()
// Act
val result = getCoinsUseCase().toList()
// Assert
assertEquals(2, result.size)
assertTrue(result[0] is Resource.Loading<*>)
val secondEmission = result[1]
assertTrue(secondEmission is Resource.Success)
assertTrue(secondEmission.data.isNullOrEmpty())
coVerify(exactly = 1) { mockRepository.getCoins() }
}
@Test
fun `invoke - should return loading and error when HttpException occurs`() = runBlocking {
// Arrange
val errorMessage = "Server error"
coEvery { mockRepository.getCoins() } throws HttpException(errorMessage, null)
// Act
val result = getCoinsUseCase().toList()
// Assert
assertEquals(2, result.size)
assertTrue(result[0] is Resource.Loading<*>)
assertTrue(result[1] is Resource.Error)
coVerify(exactly = 1) { mockRepository.getCoins() }
}
@Test
fun `invoke - should return loading and error when IOException occurs`() = runBlocking {
// Arrange
val errorMessage = "Couldn't reach server. Check your internet connection."
coEvery { mockRepository.getCoins() } throws IOException()
// Act
val result = getCoinsUseCase().toList()
// Assert
assertEquals(2, result.size)
assertTrue(result[0] is Resource.Loading<*>)
val secondEmission = result[1]
assertTrue(secondEmission is Resource.Error)
assertEquals(errorMessage, secondEmission.message)
coVerify(exactly = 1) { mockRepository.getCoins() }
}
} | CleanArchJetpackCompose/app/src/test/java/com/example/cleanarchcrypto/domain/use_case/get_coins/GetCoinsUseCaseTest.kt | 1364776963 |
package com.example.cleanarchcrypto.presentation.coin_list
import com.example.cleanarchcrypto.common.Resource
import com.example.cleanarchcrypto.data.remote.dto.toCoin
import com.example.cleanarchcrypto.domain.model.Coin
import com.example.cleanarchcrypto.domain.use_case.get_coins.GetCoinsUseCase
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinsUseCase
import com.example.cleanarchcrypto.utils.CommonObject
import com.example.cleanarchcrypto.utils.MainDispatcherRule
import io.mockk.coEvery
import io.mockk.coVerify
import io.mockk.mockk
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
import org.junit.Assert.assertEquals
import org.junit.*
import org.junit.Assert.assertTrue
@ExperimentalCoroutinesApi
class CoinListViewModelTest {
@ExperimentalCoroutinesApi
@get:Rule
val mainDispatcherRule = MainDispatcherRule()
private lateinit var viewModel: CoinListViewModel
private lateinit var mockGetCoinsUseCase: GetCoinsUseCase
@Before
fun setUp() {
mockGetCoinsUseCase = mockk()
}
@Test
fun `given GetCoinsUseCase should returns success with empty list`() =
runTest {
// Given
val flowQuestions = flowOf(Resource.Success<List<Coin>>(emptyList()))
coEvery { mockGetCoinsUseCase() } returns flowQuestions
// When
viewModel = CoinListViewModel(mockGetCoinsUseCase)
// Then
val state = viewModel.state.value
assertEquals(emptyList<Coin>(), state.coins)
assertEquals(false, state.isLoading)
assertTrue(state.error.isEmpty())
coVerify(exactly = 1) { mockGetCoinsUseCase() }
}
@Test
fun `given GetCoinsUseCase should returns success with list of coins`() =
runTest {
// Given
val mockCoins = CommonObject.mockCoinList.map { it -> it.toCoin() }
val flowQuestions = flowOf(Resource.Success<List<Coin>>(mockCoins))
coEvery { mockGetCoinsUseCase.invoke() } returns flowQuestions
// When
viewModel = CoinListViewModel(mockGetCoinsUseCase)
// Then
val state = viewModel.state.value
assertEquals(mockCoins, state.coins)
assertEquals(false, state.isLoading)
assertTrue(state.error.isEmpty())
coVerify(exactly = 1) { mockGetCoinsUseCase() }
}
@Test
fun `given GetCoinsUseCase should returns loading with loading state`() =
runTest{
// Given
val flowQuestions = flowOf(Resource.Loading<List<Coin>>())
coEvery { mockGetCoinsUseCase.invoke() } returns flowQuestions
viewModel = CoinListViewModel(mockGetCoinsUseCase)
// Then
val state = viewModel.state.value
assertEquals(emptyList<Coin>(), state.coins)
assertEquals(true, state.isLoading)
assertTrue(state.error.isEmpty())
coVerify(exactly = 1) { mockGetCoinsUseCase() }
}
@Test
fun `given GetCoinsUseCase should returns error with error message`() =
runTest {
// Given
val errorMsg = "data error"
val flowQuestions = flowOf(Resource.Error<List<Coin>>(errorMsg))
coEvery { mockGetCoinsUseCase.invoke() } returns flowQuestions
// When
viewModel = CoinListViewModel(mockGetCoinsUseCase)
// Then
val state = viewModel.state.value
assertEquals(errorMsg, state.error)
assertEquals(emptyList<Coin>(), state.coins)
assertEquals(false, state.isLoading)
coVerify(exactly = 1) { mockGetCoinsUseCase() }
}
}
| CleanArchJetpackCompose/app/src/test/java/com/example/cleanarchcrypto/presentation/coin_list/CoinListViewModelTest.kt | 2909790715 |
package com.example.cleanarchcrypto.presentation.coin_detail
import androidx.lifecycle.SavedStateHandle
import com.example.cleanarchcrypto.common.Resource
import com.example.cleanarchcrypto.data.remote.dto.toCoinDetail
import com.example.cleanarchcrypto.domain.model.CoinDetail
import com.example.cleanarchcrypto.domain.use_case.get_coin.GetCoinUseCase
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinUseCase
import com.example.cleanarchcrypto.utils.CommonObject
import com.example.cleanarchcrypto.utils.MainDispatcherRule
import io.mockk.coEvery
import io.mockk.coVerify
import io.mockk.mockk
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.runTest
import org.junit.Assert.*
import org.junit.Before
import org.junit.Rule
import org.junit.Test
@ExperimentalCoroutinesApi
class CoinDetailViewModelTest {
@ExperimentalCoroutinesApi
@get:Rule
val mainDispatcherRule = MainDispatcherRule()
private lateinit var savedStateHandle: SavedStateHandle
private lateinit var viewModel: CoinDetailViewModel
private lateinit var mockGetCoinUseCase: GetCoinUseCase
@Before
fun setUp() {
mockGetCoinUseCase = mockk()
savedStateHandle = mockk<SavedStateHandle>(relaxed = true)
}
@Test
fun `given GetCoinUseCase should returns loading with loading state`() =
runTest(StandardTestDispatcher()) {
// Given
val coinId = "sample_id"
val flowQuestions =
flowOf(Resource.Loading<CoinDetail>())
coEvery { savedStateHandle.get<String>(any()) } returns coinId
coEvery { mockGetCoinUseCase(any()) } returns flowQuestions
// When
viewModel = CoinDetailViewModel(mockGetCoinUseCase, savedStateHandle)
// Then
val state = viewModel.state.value
assertEquals(null, state.coin)
assertEquals(true, state.isLoading)
assertTrue(state.error.isEmpty())
coVerify(exactly = 1) { mockGetCoinUseCase(any()) }
}
@Test
fun `given GetCoinUseCase should returns success Coin Detail `() =
runTest {
// Given
val mockCoinDetail = CommonObject.mockCoinDetail.toCoinDetail()
val coinId = "sample_id"
val flowQuestions =
flowOf(Resource.Success<CoinDetail>(mockCoinDetail))
coEvery { savedStateHandle.get<String>(any()) } returns coinId
coEvery { mockGetCoinUseCase(any()) } returns flowQuestions
// When
viewModel = CoinDetailViewModel(mockGetCoinUseCase, savedStateHandle)
// Then
val state = viewModel.state.value
assertEquals(mockCoinDetail.coinId, state.coin?.coinId ?: "")
assertEquals(mockCoinDetail, state.coin)
assertEquals(false, state.isLoading)
assertTrue(state.error.isEmpty())
coVerify(exactly = 1) { mockGetCoinUseCase(any()) }
}
@Test
fun `given GetCoinsUseCase should returns error with error message`() =
runTest(StandardTestDispatcher()) {
// Given
val errorMsg = "data error"
val coinId = "sample_id"
val flowQuestions =
flowOf(Resource.Error<CoinDetail>(errorMsg))
coEvery { savedStateHandle.get<String>(any()) } returns coinId
coEvery { mockGetCoinUseCase(any()) } returns flowQuestions
// When
viewModel = CoinDetailViewModel(mockGetCoinUseCase, savedStateHandle)
// Then
val state = viewModel.state.value
assertEquals(null, state.coin?.coinId)
assertEquals(false, state.isLoading)
assertEquals(errorMsg, state.error)
coVerify(exactly = 1) { mockGetCoinUseCase(any()) }
}
} | CleanArchJetpackCompose/app/src/test/java/com/example/cleanarchcrypto/presentation/coin_detail/CoinDetailViewModelTest.kt | 1480894938 |
package com.example.cleanarchcrypto.di
import com.example.cleanarchcrypto.common.Constants
import com.example.cleanarchcrypto.data.remote.CoinPaprikaApi
import com.example.cleanarchcrypto.data.repository.CoinRepositoryImpl
import com.example.cleanarchcrypto.domain.repository.CoinRepository
import com.example.cleanarchcrypto.domain.use_case.get_coin.GetCoinUseCase
import com.example.cleanarchcrypto.domain.use_case.get_coins.GetCoinsUseCase
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinUseCase
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinsUseCase
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
@Provides
@Singleton
fun providePaprikaApi(): CoinPaprikaApi {
return Retrofit.Builder().baseUrl(Constants.BASE_URL)
.addConverterFactory(GsonConverterFactory.create()).build()
.create(CoinPaprikaApi::class.java)
}
@Provides
@Singleton
fun provideCoinRepository(api: CoinPaprikaApi): CoinRepository {
return CoinRepositoryImpl(api)
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/di/AppModule.kt | 2056891721 |
package com.example.cleanarchcrypto.common
object Constants {
const val BASE_URL = "https://api.coinpaprika.com/"
const val PARAM_COIN_ID = "coinId"
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/common/Constant.kt | 2744108946 |
package com.example.cleanarchcrypto.common
sealed class Resource<T>(val data: T? = null, val message: String? = null) {
class Success<T>(data: T) : Resource<T>(data)
class Error<T>(message: String, data: T? = null) : Resource<T>(data,message)
class Loading<T>(data: T? = null) : Resource<T>(data)
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/common/Resource.kt | 2047098471 |
package com.example.cleanarchcrypto.data.repository
import com.example.cleanarchcrypto.data.remote.CoinPaprikaApi
import com.example.cleanarchcrypto.data.remote.dto.CoinDetailDto
import com.example.cleanarchcrypto.data.remote.dto.CoinDto
import com.example.cleanarchcrypto.domain.repository.CoinRepository
import javax.inject.Inject
class CoinRepositoryImpl @Inject constructor(
private val api: CoinPaprikaApi
) : CoinRepository {
override suspend fun getCoins(): List<CoinDto> {
return api.getCoins()
}
override suspend fun getCoinById(coinId: String): CoinDetailDto {
return api.getCoinById(coinId)
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/repository/CoinRepositoryImpl.kt | 736817033 |
package com.example.cleanarchcrypto.data.remote.dto
import com.google.gson.annotations.SerializedName
data class Stats(
val contributors: Int,
val followers: Int,
val stars: Int,
val subscribers: Int
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/remote/dto/Stats.kt | 877054373 |
package com.example.cleanarchcrypto.data.remote.dto
data class TeamMember(
val id: String,
val name: String,
val position: String
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/remote/dto/TeamMember.kt | 2139997088 |
package com.example.cleanarchcrypto.data.remote.dto
import com.google.gson.annotations.SerializedName
data class Tag(
@SerializedName("coin_counter")
val coinCounter: Int,
@SerializedName("ico_counter")
val icoCounter: Int,
val id: String,
val name: String
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/remote/dto/Tag.kt | 2588801372 |
package com.example.cleanarchcrypto.data.remote.dto
import com.example.cleanarchcrypto.domain.model.Coin
import com.google.gson.annotations.SerializedName
data class CoinDto(
val id: String,
@SerializedName("is_active")
val isActive: Boolean,
@SerializedName("is_new")
val isNew: Boolean,
val name: String,
val rank: Int,
val symbol: String,
val type: String
)
fun CoinDto.toCoin(): Coin {
return Coin(
id = id,
isActive = isActive,
name = name,
rank = rank,
symbol = symbol
)
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/remote/dto/CoinDto.kt | 1398242394 |
package com.example.cleanarchcrypto.data.remote.dto
import com.google.gson.annotations.SerializedName
data class LinksExtended(
val stats: Stats,
val type: String,
val url: String
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/remote/dto/LinkExtended.kt | 75455450 |
package com.example.cleanarchcrypto.data.remote.dto
import com.google.gson.annotations.SerializedName
data class Links(
val explorer: List<String>,
val facebook: List<String>,
val reddit: List<String>,
@SerializedName("source_code")
val sourceCode: List<String>,
val website: List<String>,
val youtube: List<String>
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/remote/dto/Links.kt | 914332740 |
package com.example.cleanarchcrypto.data.remote.dto
import com.example.cleanarchcrypto.domain.model.CoinDetail
import com.google.gson.annotations.SerializedName
data class CoinDetailDto(
val description: String,
@SerializedName("development_status")
val developmentStatus: String,
@SerializedName("first_data_at")
val firstDataAt: String,
@SerializedName("hardware_wallet")
val hardwareWallet: Boolean,
@SerializedName("hash_algorithm")
val hashAlgorithm: String,
val id: String,
@SerializedName("is_active")
val isActive: Boolean,
@SerializedName("is_new")
val isNew: Boolean,
@SerializedName("last_data_at")
val lastDataAt: String,
val links: Links,
@SerializedName("links_extended")
val linksExtended: List<LinksExtended>,
val message: String,
val name: String,
@SerializedName("open_source")
val openSource: Boolean,
@SerializedName("org_structure")
val orgStructure: String,
@SerializedName("proof_type")
val proofType: String,
val rank: Int,
@SerializedName("started_at")
val startedAt: String,
val symbol: String,
val tags: List<Tag>,
val team: List<TeamMember>,
val type: String,
val whitepaper: Whitepaper
)
fun CoinDetailDto.toCoinDetail(): CoinDetail {
return CoinDetail(
coinId = id,
name = name,
description = description,
symbol = symbol,
rank = rank,
isActive = isActive,
tags = tags.map { it.name },
team = team
)
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/remote/dto/CoinDetailDto.kt | 2310180301 |
package com.example.cleanarchcrypto.data.remote.dto
import com.google.gson.annotations.SerializedName
data class Whitepaper(
val link: String,
val thumbnail: String
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/remote/dto/Whitepaper.kt | 2915598346 |
package com.example.cleanarchcrypto.data.remote
import com.example.cleanarchcrypto.data.remote.dto.CoinDetailDto
import com.example.cleanarchcrypto.data.remote.dto.CoinDto
import retrofit2.http.GET
import retrofit2.http.Path
interface CoinPaprikaApi {
@GET("v1/coins")
suspend fun getCoins() : List<CoinDto>
@GET("v1/coins/{coinId}")
suspend fun getCoinById(@Path("coinId") coinId:String):CoinDetailDto
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/data/remote/CoinPaprikaApi.kt | 2044798397 |
package com.example.cleanarchcrypto.domain.repository
import com.example.cleanarchcrypto.data.remote.dto.CoinDetailDto
import com.example.cleanarchcrypto.data.remote.dto.CoinDto
interface CoinRepository {
suspend fun getCoins():List<CoinDto>
suspend fun getCoinById(coinId:String): CoinDetailDto
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/domain/repository/CoinRepository.kt | 686712747 |
package com.example.cleanarchcrypto.domain.use_case.get_coin
import com.example.cleanarchcrypto.common.Resource
import com.example.cleanarchcrypto.data.remote.dto.toCoinDetail
import com.example.cleanarchcrypto.domain.model.CoinDetail
import com.example.cleanarchcrypto.domain.repository.CoinRepository
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinUseCase
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import retrofit2.HttpException
import java.io.IOException
import javax.inject.Inject
class GetCoinUseCase @Inject constructor(
private val repository: CoinRepository
) : IGetCoinUseCase {
override operator fun invoke(coinId: String): Flow<Resource<CoinDetail>> = flow {
try {
emit(Resource.Loading<CoinDetail>())
val coin = repository.getCoinById(coinId).toCoinDetail()
emit(Resource.Success<CoinDetail>(coin))
} catch (e: HttpException) {
emit(Resource.Error<CoinDetail>(e.localizedMessage ?: "An unexpected error occured"))
} catch (e: IOException) {
emit(Resource.Error<CoinDetail>("Couldn't reach server. Check your internet connection."))
}
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/domain/use_case/get_coin/GetCoinUseCase.kt | 2428017100 |
package com.example.cleanarchcrypto.domain.use_case.get_coins
import com.example.cleanarchcrypto.common.Resource
import com.example.cleanarchcrypto.data.remote.dto.toCoin
import com.example.cleanarchcrypto.domain.model.Coin
import com.example.cleanarchcrypto.domain.repository.CoinRepository
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinsUseCase
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import retrofit2.HttpException
import java.io.IOException
import javax.inject.Inject
class GetCoinsUseCase @Inject constructor(
private val repository: CoinRepository
) : IGetCoinsUseCase {
override operator fun invoke(): Flow<Resource<List<Coin>>> = flow {
try {
emit(Resource.Loading<List<Coin>>())
val coins = repository.getCoins().map { it.toCoin() }
emit(Resource.Success<List<Coin>>(coins))
} catch (e: HttpException) {
emit(Resource.Error<List<Coin>>(e.localizedMessage ?: "An unexpected error occured"))
} catch (e: IOException) {
emit(Resource.Error<List<Coin>>("Couldn't reach server. Check your internet connection."))
}
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/domain/use_case/get_coins/GetCoinsUseCase.kt | 518561876 |
package com.example.cleanarchcrypto.domain.use_case.interfaces
import com.example.cleanarchcrypto.common.Resource
import com.example.cleanarchcrypto.domain.model.Coin
import com.example.cleanarchcrypto.domain.model.CoinDetail
import kotlinx.coroutines.flow.Flow
interface IGetCoinsUseCase {
operator fun invoke(): Flow<Resource<List<Coin>>>
}
interface IGetCoinUseCase {
operator fun invoke(coinId: String): Flow<Resource<CoinDetail>>
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/domain/use_case/interfaces/CoinUseCaseInterface.kt | 249332901 |
package com.example.cleanarchcrypto.domain.model
import com.google.gson.annotations.SerializedName
data class Coin(
val id: String,
val isActive: Boolean,
val name: String,
val rank: Int,
val symbol: String,
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/domain/model/Coin.kt | 618007623 |
package com.example.cleanarchcrypto.domain.model
import com.example.cleanarchcrypto.data.remote.dto.TeamMember
data class CoinDetail(
val coinId: String,
val name: String,
val description: String,
val symbol: String,
val rank: Int,
val isActive: Boolean,
val tags: List<String>,
val team: List<TeamMember>
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/domain/model/CoinDetail.kt | 2974811415 |
package com.example.cleanarchcrypto.presentation
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.ui.Modifier
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.example.cleanarchcrypto.presentation.coin_detail.components.CoinDetailScreen
import com.example.cleanarchcrypto.presentation.coin_list.components.CoinListScreen
import com.example.cleanarchcrypto.presentation.theme.CleanArchCryptoTheme
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
CleanArchCryptoTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
val navController = rememberNavController()
NavHost(
navController = navController,
startDestination = Screen.CoinListScreen.route
) {
composable(route = Screen.CoinListScreen.route) {
CoinListScreen(navController)
}
composable(route = Screen.CoinDetailScreen.route + "/{coinId}") {
CoinDetailScreen()
}
}
}
}
}
}
}
| CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/MainActivity.kt | 1425184231 |
package com.example.cleanarchcrypto.presentation.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/theme/Color.kt | 2815782184 |
package com.example.cleanarchcrypto.presentation.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun CleanArchCryptoTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/theme/Theme.kt | 2221323185 |
package com.example.cleanarchcrypto.presentation.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/theme/Type.kt | 381998472 |
package com.example.cleanarchcrypto.presentation.coin_list
import com.example.cleanarchcrypto.domain.model.Coin
data class CoinListState(
val isLoading:Boolean = false,
val coins:List<Coin> = emptyList(),
val error:String = ""
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/coin_list/CoinListState.kt | 3072330781 |
package com.example.cleanarchcrypto.presentation.coin_list.components
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavController
import com.example.cleanarchcrypto.domain.model.Coin
import com.example.cleanarchcrypto.presentation.Screen
import com.example.cleanarchcrypto.presentation.coin_list.CoinListViewModel
@Composable
fun CoinListScreen(
navController: NavController,
viewModel: CoinListViewModel = hiltViewModel()
) {
val state = viewModel.state.value
Box(
modifier = Modifier
.fillMaxSize()
) {
LazyColumn(modifier = Modifier.fillMaxSize().testTag("lazy")) {
items(state.coins) { coin ->
CoinListItem(coin = coin, onItemClick = {
navController.navigate(Screen.CoinDetailScreen.route + "/${coin.id}")
})
}
}
if (state.error.isNotBlank()) {
Text(
text = state.error,
color = MaterialTheme.colorScheme.error,
textAlign = TextAlign.Center,
modifier = Modifier
.fillMaxSize()
.padding(horizontal = 20.dp)
.align(Alignment.Center)
)
}
if (state.isLoading) {
CircularProgressIndicator(modifier = Modifier.align(Alignment.Center).testTag("cpi"))
}
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/coin_list/components/CoinListScreen.kt | 2998101560 |
package com.example.cleanarchcrypto.presentation.coin_list.components
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment.Companion.CenterVertically
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontStyle
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import com.example.cleanarchcrypto.domain.model.Coin
@Composable
fun CoinListItem(coin: Coin, onItemClick: (Coin) -> Unit) {
Row(
modifier = Modifier
.fillMaxWidth()
.clickable { onItemClick(coin) }
.padding(20.dp),
horizontalArrangement = Arrangement.SpaceBetween
) {
Text(
text = "${coin.rank}. ${coin.name} (${coin.symbol})",
style = MaterialTheme.typography.bodyLarge,
overflow = TextOverflow.Ellipsis
)
Text(
text = if (coin.isActive) "active" else "inactive",
color = if (coin.isActive) Color.Green else Color.Red,
fontStyle = FontStyle.Italic,
textAlign = TextAlign.End,
style = MaterialTheme.typography.bodyMedium,
modifier = Modifier.align(CenterVertically)
)
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/coin_list/components/CoinListItem.kt | 808418554 |
package com.example.cleanarchcrypto.presentation.coin_list
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.cleanarchcrypto.common.Resource
import com.example.cleanarchcrypto.domain.model.Coin
import com.example.cleanarchcrypto.domain.use_case.get_coins.GetCoinsUseCase
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinsUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class CoinListViewModel @Inject constructor(private val getCoinsUseCase: GetCoinsUseCase) :
ViewModel() {
private val _state = mutableStateOf(CoinListState())
val state: State<CoinListState> = _state
init {
getCoins()
}
private fun getCoins() {
viewModelScope.launch {
try {
getCoinsUseCase().collect { result ->
handleCoinsResult(result)
}
} catch (e: Exception) {
handleError("An unexpected error happened")
}
}
}
private fun handleCoinsResult(result: Resource<List<Coin>>) {
when (result) {
is Resource.Success -> handleSuccess(result.data ?: emptyList())
is Resource.Error -> handleError(result.message ?: "An unexpected error happened")
is Resource.Loading -> handleLoading()
}
}
private fun handleSuccess(coins: List<Coin>) {
_state.value = CoinListState(coins = coins)
}
private fun handleError(errorMessage: String) {
_state.value = CoinListState(error = errorMessage)
}
private fun handleLoading() {
_state.value = CoinListState(isLoading = true)
}
}
| CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/coin_list/CoinListViewModel.kt | 2644998681 |
package com.example.cleanarchcrypto.presentation
sealed class Screen(val route: String) {
object CoinListScreen : Screen("coin_list_screen")
object CoinDetailScreen : Screen("coin_detail_screen")
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/Screen.kt | 2586849633 |
package com.example.cleanarchcrypto.presentation.coin_detail
import com.example.cleanarchcrypto.domain.model.CoinDetail
data class CoinDetailState(
val isLoading: Boolean = false,
val coin: CoinDetail? = null,
val error: String = ""
) | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/coin_detail/CoinDetailState.kt | 699120050 |
package com.example.cleanarchcrypto.presentation.coin_detail
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.cleanarchcrypto.common.Resource
import com.example.cleanarchcrypto.domain.use_case.get_coin.GetCoinUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import androidx.compose.runtime.State
import androidx.lifecycle.SavedStateHandle
import com.example.cleanarchcrypto.common.Constants
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinUseCase
import javax.inject.Inject
@HiltViewModel
class CoinDetailViewModel @Inject constructor(
private val getCoinUseCase: GetCoinUseCase,
savedStateHandle: SavedStateHandle
) : ViewModel() {
private val _state = mutableStateOf(CoinDetailState())
val state: State<CoinDetailState> = _state
init {
savedStateHandle.get<String>(Constants.PARAM_COIN_ID)?.let { coinId ->
getCoin(coinId)
}
}
private fun getCoin(coinId: String) {
getCoinUseCase(coinId).onEach { result ->
when (result) {
is Resource.Success -> {
_state.value = CoinDetailState(coin = result.data)
}
is Resource.Error -> {
_state.value = CoinDetailState(
error = result.message ?: "An unexpected error occured"
)
}
is Resource.Loading -> {
_state.value = CoinDetailState(isLoading = true)
}
}
}.launchIn(viewModelScope)
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/coin_detail/CoinDetailViewModel.kt | 4039729708 |
package com.example.cleanarchcrypto.presentation.coin_detail.components
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontStyle
import androidx.compose.ui.unit.dp
import com.example.cleanarchcrypto.data.remote.dto.TeamMember
@Composable
fun TeamListItem(teamMember: TeamMember, modifier: Modifier = Modifier) {
Column(
modifier = modifier,
verticalArrangement = Arrangement.Center
) {
Text(text = teamMember.name, style = MaterialTheme.typography.headlineSmall)
Spacer(modifier = Modifier.height(4.dp))
Text(
text = teamMember.position,
style = MaterialTheme.typography.bodyMedium,
fontStyle = FontStyle.Italic
)
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/coin_detail/components/TeamList.kt | 1007292518 |
package com.example.cleanarchcrypto.presentation.coin_detail.components
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Divider
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Alignment.Companion.CenterVertically
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.text.font.FontStyle
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import com.example.cleanarchcrypto.presentation.coin_detail.CoinDetailViewModel
import com.google.accompanist.flowlayout.FlowRow as Fl
@Composable
fun CoinDetailScreen(
viewModel: CoinDetailViewModel = hiltViewModel()
) {
val state = viewModel.state.value
Box(modifier = Modifier.fillMaxSize()) {
state.coin?.let { coin ->
LazyColumn(
modifier = Modifier.fillMaxSize().testTag("lazydetail"),
contentPadding = PaddingValues(20.dp)
) {
item {
Row(
modifier = Modifier.fillMaxWidth().testTag("coin_detail_title"),
horizontalArrangement = Arrangement.SpaceBetween
) {
Text(
text = "${coin.rank}. ${coin.name} (${coin.symbol})",
style = MaterialTheme.typography.headlineMedium,
modifier = Modifier.weight(8f)
)
Text(
text = if(coin.isActive) "active" else "inactive",
color = if(coin.isActive) Color.Green else Color.Red,
fontStyle = FontStyle.Italic,
textAlign = TextAlign.End,
modifier = Modifier
.align(CenterVertically)
.weight(2f)
)
}
Spacer(modifier = Modifier.height(15.dp))
Text(
text = coin.description,
style = MaterialTheme.typography.bodyMedium
)
Spacer(modifier = Modifier.height(15.dp))
Text(
text = "Tags",
style = MaterialTheme.typography.headlineSmall
)
Spacer(modifier = Modifier.height(15.dp))
Fl(
mainAxisSpacing = 10.dp,
crossAxisSpacing = 10.dp,
modifier = Modifier.fillMaxWidth()
) {
coin.tags.forEach { tag ->
CoinTag(tag = tag)
}
}
Spacer(modifier = Modifier.height(15.dp))
Text(
text = "Team members",
style = MaterialTheme.typography.headlineSmall
)
Spacer(modifier = Modifier.height(15.dp))
}
items(coin.team) { teamMember ->
TeamListItem(
teamMember = teamMember,
modifier = Modifier
.fillMaxWidth()
.padding(10.dp)
)
Divider()
}
}
}
if(state.error.isNotBlank()) {
Text(
text = state.error,
color = MaterialTheme.colorScheme.error,
textAlign = TextAlign.Center,
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 20.dp)
.align(Alignment.Center)
)
}
if(state.isLoading) {
CircularProgressIndicator(modifier = Modifier.align(Alignment.Center))
}
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/coin_detail/components/CoinDetailScreen.kt | 3263384893 |
package com.example.cleanarchcrypto.presentation.coin_detail.components
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
@Composable
fun CoinTag(
tag: String
) {
Box(
modifier = Modifier
.border(
width = 1.dp, color = MaterialTheme.colorScheme.primary,
shape = RoundedCornerShape(100.dp)
)
.padding(10.dp)
) {
Text(
text = tag,
color = MaterialTheme.colorScheme.primary, textAlign = TextAlign.Center,
style = MaterialTheme.typography.bodyMedium
)
}
} | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/presentation/coin_detail/components/CoinTag.kt | 162859962 |
package com.example.cleanarchcrypto
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class CoinApplication : Application() | CleanArchJetpackCompose/app/src/main/java/com/example/cleanarchcrypto/CoinApplication.kt | 3606663143 |
package com.freshbell.myspringproject
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class MySpringProjectApplicationTests {
@Test
fun contextLoads() {
}
}
| FRESHBELL_SPRING_BOOT/src/test/kotlin/com/freshbell/myspringproject/MySpringProjectApplicationTests.kt | 2738069190 |
package com.freshbell.myspringproject.global.config
class SecurityConfig {
} | FRESHBELL_SPRING_BOOT/src/main/kotlin/com/freshbell/myspringproject/global/config/SecurityConfig.kt | 3571639379 |
package com.freshbell.myspringproject
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class MySpringProjectApplication
fun main(args: Array<String>) {
runApplication<MySpringProjectApplication>(*args)
}
| FRESHBELL_SPRING_BOOT/src/main/kotlin/com/freshbell/myspringproject/MySpringProjectApplication.kt | 1716759625 |
package com.example.geminiapp
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.geminiapp", appContext.packageName)
}
} | GeminiApp/app/src/androidTest/java/com/example/geminiapp/ExampleInstrumentedTest.kt | 703960006 |
package com.example.geminiapp
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)
}
} | GeminiApp/app/src/test/java/com/example/geminiapp/ExampleUnitTest.kt | 1598807593 |
package com.example.geminiapp.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | GeminiApp/app/src/main/java/com/example/geminiapp/ui/theme/Color.kt | 3617941929 |
package com.example.geminiapp.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun GeminiAppTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | GeminiApp/app/src/main/java/com/example/geminiapp/ui/theme/Theme.kt | 428011042 |
package com.example.geminiapp.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | GeminiApp/app/src/main/java/com/example/geminiapp/ui/theme/Type.kt | 1939566042 |
package com.example.geminiapp
class GeminiState {
fun copy(isLoading: Boolean = false, userInput: String = "", response: String = ""): GeminiState {
val newState = GeminiState()
newState.isLoading = isLoading
newState.userInput = userInput
newState.response = response
return newState
}
var userInput: String = ""
var isLoading: Boolean = false
var response: String = ""
}
| GeminiApp/app/src/main/java/com/example/geminiapp/GeminiState.kt | 923895778 |
package com.example.geminiapp
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.activity.result.IntentSenderRequest
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.tooling.preview.Preview
import androidx.core.content.ContextCompat.getString
import androidx.credentials.CustomCredential
import androidx.credentials.GetCredentialRequest
import androidx.credentials.GetCredentialResponse
import androidx.credentials.PasswordCredential
import androidx.credentials.PublicKeyCredential
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.viewmodel.compose.viewModel
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.example.geminiapp.chatComposables.ChatScreen
import com.example.geminiapp.presentation.EmailSignInClient
import com.example.geminiapp.presentation.GoogleAuthUIClient
import com.example.geminiapp.presentation.SignInScreen
import com.example.geminiapp.presentation.SignInViewModel
import com.example.geminiapp.presentation.SignUpScreen
import com.example.geminiapp.ui.theme.GeminiAppTheme
import com.google.ai.client.generativeai.GenerativeModel
import com.google.android.gms.auth.api.identity.BeginSignInRequest
import com.google.android.gms.auth.api.identity.Identity
import com.google.android.gms.auth.api.signin.GoogleSignIn
import com.google.android.gms.auth.api.signin.GoogleSignInOptions
import com.google.android.gms.common.api.ApiException
import com.google.android.libraries.identity.googleid.GetGoogleIdOption
import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential
import com.google.android.libraries.identity.googleid.GoogleIdTokenParsingException
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.GoogleAuthProvider
import com.google.firebase.auth.ktx.auth
import com.google.firebase.ktx.Firebase
import kotlinx.coroutines.launch
import kotlinx.coroutines.tasks.await
import java.util.concurrent.CancellationException
class MainActivity : ComponentActivity() {
private val googleAuthClient by lazy{
GoogleAuthUIClient(
context = applicationContext,
oneTapClient = Identity.getSignInClient(applicationContext)
)
}
private val emailSignInClient = EmailSignInClient()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val generativeModel = GenerativeModel(
apiKey = BuildConfig.API_KEY,
modelName = "gemini-pro"
)
val auth = Firebase.auth
var startDestination = "sign_in"
if(auth.currentUser != null){
startDestination = Screen.Chats.route
}
setContent {
GeminiAppTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
//GeminiScreen(viewModel = viewModel)
val navController = rememberNavController()
NavHost(navController = navController, startDestination = startDestination){
composable("sign_in"){
val viewModel = viewModel<SignInViewModel>()
val state by viewModel.state.collectAsStateWithLifecycle()
val launcher = rememberLauncherForActivityResult(
contract = ActivityResultContracts.StartIntentSenderForResult(),
onResult = {result->
if(result.resultCode == RESULT_OK){
lifecycleScope.launch {
val signInResult = googleAuthClient.signInWithIntent(
intent = result.data ?: return@launch
)
viewModel.onSignInResult(signInResult)
if(viewModel.state.value.isSignInSuccessful){
navController.navigate(Screen.Chats.route)
}
}
}
}
)
LaunchedEffect(key1 = state.isSignInSuccessful){
if(state.isSignInSuccessful){
Toast.makeText(applicationContext, "SignIn Success", Toast.LENGTH_LONG).show()
}
}
SignInScreen(
state = state,
onGoogleSignInClicked = {
lifecycleScope.launch {
val signInIntent = googleAuthClient.signIn()
launcher.launch(
IntentSenderRequest.Builder(
signInIntent ?: return@launch
).build()
)
}
},
onSignInClicked = {email, password ->
emailSignInClient.signIn(email, password, onSuccess = {result->
viewModel.onSignInResult(result)
if(viewModel.state.value.isSignInSuccessful){
if(auth.currentUser != null){
Log.d("check", "signInResult ${auth.currentUser?.uid}")
navController.navigate(Screen.Chats.route)
}
}
},
onFailure = {
val e = it?.message
Toast.makeText(applicationContext, "SignIn Fail: $e", Toast.LENGTH_LONG).show()
})
},
onSignUpClicked = {
Log.d("check", "wtf")
navController.navigate(Screen.SignUp.route)
}
)
}
composable("sign_up"){
SignUpScreen(navController = navController, onButtonClicked = { email, username, password->
emailSignInClient.signUp(email, username, password, onSuccess = {result->
navController.navigate(Screen.Chats.route)
}, onFailure = {
val e = it?.message
Toast.makeText(applicationContext, "SignIn Fail: $e", Toast.LENGTH_LONG).show()
})
})
}
composable(
Screen.Chats.route
){
var userViewModel = UserViewModel()
if(auth.currentUser != null){
Log.d("check", "launching chats screen ${auth.currentUser!!.uid}")
userViewModel.setCurrentUser(auth.currentUser!!.uid)
}
ChatsScreen(navController = navController, userViewModel = userViewModel, onSignOut = {
Log.d("check", "Sign Out")
navController.navigate("sign_in")
try {
auth.signOut()
}catch (e: Exception){
e.printStackTrace()
if (e is CancellationException) throw e
}
})
}
composable(
Screen.Chat.route+"/{chatId}",
arguments = listOf(
navArgument("chatId") {
type = NavType.StringType
}
)
){
val chatId = it.arguments?.getString("chatId")
val userId = auth.currentUser?.uid
ChatScreen(navController = navController, model = generativeModel, chatId = chatId!!, userId = userId!!)
}
}
}
}
}
}
}
| GeminiApp/app/src/main/java/com/example/geminiapp/MainActivity.kt | 2795588086 |
import androidx.compose.animation.core.MutableTransitionState
import androidx.compose.animation.core.updateTransition
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.lerp
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.foundation.lazy.items
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.withStyle
import kotlinx.coroutines.launch
@Composable
fun ResponseComposable(response: List<String>) {
val coroutineScope = rememberCoroutineScope()
val transitionState = remember { MutableTransitionState(0) }
transitionState.targetState = response.size
LazyColumn {
items(response) { chunk ->
val transition = updateTransition(transitionState.targetState, label = "")
val alpha = if (transitionState.targetState == response.size) 1f else 0f
val color = lerp(Color.Transparent, Color.Unspecified, alpha)
Text(
buildAnnotatedString {
withStyle(style = SpanStyle(color = color)) {
append(chunk)
}
}
)
}
}
// Trigger the animation when a new chunk is added
coroutineScope.launch {
transitionState.targetState = response.size
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/chatComposables/ResponseComposable.kt | 1875144807 |
package com.example.geminiapp.chatComposables
import android.annotation.SuppressLint
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
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.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material.icons.filled.Send
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.material3.TextFieldDefaults
import androidx.compose.material3.surfaceColorAtElevation
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.focus.onFocusChanged
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.navigation.NavController
import com.example.geminiapp.FirebaseManager
import com.example.geminiapp.GeminiViewModel
import com.example.geminiapp.GeminiViewModelFactory
import com.google.ai.client.generativeai.GenerativeModel
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ChatScreen(navController: NavController, model: GenerativeModel, chatId: String, userId: String) {
val viewModel = GeminiViewModelFactory(model, chatId, userId).create(GeminiViewModel::class.java)
var isInputFocused by remember { mutableStateOf(false) }
val firebaseManager = FirebaseManager()
var topic by remember {
mutableStateOf("")
}
firebaseManager.retrieveTopic(chatId, userId) {
topic = it
}
Scaffold(bottomBar = {ChatBottomBar(
onInputFocused = { isInputFocused = it },
onSendClicked = { viewModel.onClick(it) }
)},
topBar = {
Row(
verticalAlignment = Alignment.CenterVertically
){
Button(onClick = { navController.popBackStack() }) {
Icon(imageVector = Icons.AutoMirrored.Filled.ArrowBack, contentDescription = null)
}
Spacer(modifier = Modifier.size(4.dp))
Text(topic,modifier = Modifier
.weight(1f)
.padding(end = 8.dp),
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
}
},
content = {
ChatContent(modifier = Modifier
.fillMaxSize()
.padding(bottom = 68.dp, top = 56.dp), viewModel = viewModel)
}
)
// Column {
// Text("Enter your request:")
// TextField(
// value = userInput,
// onValueChange = { userInput = it },
// label = { Text("Request") }
// )
// Button(onClick = {
// // Make your API call here using userInput
// viewModel.onClick(userInput)
// }) {
// Text("Send")
// }
// if(viewModel.state.isLoading){
// Text("Loading...")
// } else {
// Text("Response:")
// Text(response)
// }
// }
}
@Composable
fun ChatBottomBar(onSendClicked: (String) -> Unit,
onInputFocused: (Boolean) -> Unit) {
Row(
modifier = Modifier
.fillMaxWidth()
.height(68.dp)
.background(MaterialTheme.colorScheme.surface)
.padding(4.dp),
verticalAlignment = Alignment.CenterVertically
, horizontalArrangement = Arrangement.Start
) {
ChatMessageInput(
onSendClicked = onSendClicked,
onInputFocused = onInputFocused
)
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ChatMessageInput(onSendClicked: (String) -> Unit,
onInputFocused: (Boolean) -> Unit) {
var messageText by remember { mutableStateOf("") }
Row(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colorScheme.surface),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.SpaceBetween
) {
TextField(
value = messageText,
onValueChange = { messageText = it },
modifier = Modifier
.fillMaxWidth(0.85f)
.clip(MaterialTheme.shapes.medium)
.background(MaterialTheme.colorScheme.background)
.onFocusChanged { onInputFocused(it.isFocused) },
placeholder = { Text("Type a message...", modifier = Modifier.fillMaxSize(), style = MaterialTheme.typography.bodyLarge) },
keyboardOptions = KeyboardOptions.Default.copy(
imeAction = ImeAction.Send,
keyboardType = KeyboardType.Text
),
keyboardActions = KeyboardActions(
onSend = {
onSendClicked(messageText)
messageText = ""
}
),
colors = TextFieldDefaults.colors(
focusedContainerColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp),
unfocusedContainerColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp),
focusedIndicatorColor = Color.Transparent,
unfocusedIndicatorColor = Color.Transparent,
)
)
Spacer(modifier = Modifier.width(8.dp))
Icon(
imageVector = Icons.Default.Send,
contentDescription = null,
modifier = Modifier
.size(40.dp)
.clickable {
onSendClicked(messageText)
messageText = ""
}
.padding(4.dp),
tint = MaterialTheme.colorScheme.primary
)
}
}
| GeminiApp/app/src/main/java/com/example/geminiapp/chatComposables/ChatScreen.kt | 367457704 |
package com.example.geminiapp.chatComposables
import android.util.Log
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Shape
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import com.example.geminiapp.Message
import com.google.ai.client.generativeai.type.Content
import com.google.ai.client.generativeai.type.asTextOrNull
@Composable
fun ChatItem(message: Message) {
val alignment = if (message.role == "user") {
Arrangement.End
} else {
Arrangement.Start
}
val bubbleColor = if (message.role == "user") {
MaterialTheme.colorScheme.primaryContainer
} else {
MaterialTheme.colorScheme.secondaryContainer
}
val textColor = if (message.role == "user") {
MaterialTheme.colorScheme.onPrimaryContainer
} else {
MaterialTheme.colorScheme.onSecondaryContainer
}
Row(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
horizontalArrangement = alignment
){
Card(
modifier = Modifier
.clip(MaterialTheme.shapes.medium)
.background(bubbleColor)
.padding(8.dp)
){
if (message.role == "model"){
var processedText by remember { mutableStateOf<AnnotatedString?>(null) }
if (processedText == null) {
processedText = buildAnnotatedString {
val boldIndices = mutableListOf<Int>()
var previousCharacterIndex = -1
var nextCharacterIndex = 1
var indexCount = 0
val input = message.messageText
input.forEachIndexed { index, char ->
when (char) {
'*' -> {
if(previousCharacterIndex>=0 && nextCharacterIndex<input.length){
if(input[previousCharacterIndex] == '*' ||
input[nextCharacterIndex] == '*'){
if(boldIndices.isEmpty()){
boldIndices.add(indexCount)
}
if(boldIndices.last() != indexCount){
boldIndices.add(indexCount)
}
previousCharacterIndex++
nextCharacterIndex++
} else {
append("\u2022")
indexCount++
previousCharacterIndex++
nextCharacterIndex++
}
} else if(nextCharacterIndex<input.length){
if(input[nextCharacterIndex] == '*'){
if(boldIndices.isEmpty()){
boldIndices.add(indexCount)
}
if(boldIndices.last() != indexCount){
boldIndices.add(indexCount)
}
previousCharacterIndex++
nextCharacterIndex++
} else {
append("\u2022")
indexCount++
previousCharacterIndex++
nextCharacterIndex++
}
} else if (previousCharacterIndex>0){
if(input[previousCharacterIndex] == '*'){
if(boldIndices.isEmpty()){
boldIndices.add(indexCount)
}
if(boldIndices.last() != indexCount){
boldIndices.add(indexCount)
}
previousCharacterIndex++
nextCharacterIndex++
} else {
append("\u2022")
indexCount++
previousCharacterIndex++
nextCharacterIndex++
}
}
}
else -> {
append(char.toString())
indexCount++
previousCharacterIndex++
nextCharacterIndex++
}
}
}
for (i in boldIndices.indices step 2) {
addStyle(style = SpanStyle(fontWeight = FontWeight.Bold), start = boldIndices[i], end = boldIndices[i + 1])
}
}
}
Column(modifier = Modifier.background(bubbleColor)) {
Text(
text = processedText!!,
color = textColor
)
}
} else {
Column(modifier = Modifier.background(bubbleColor)) {
Text(
text = message.messageText,
color = textColor
)
}
}
}
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/chatComposables/ChatItem.kt | 494956124 |
package com.example.geminiapp.chatComposables
import ResponseComposable
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.example.geminiapp.FirebaseManager
import com.example.geminiapp.GeminiViewModel
import com.example.geminiapp.Message
import com.google.ai.client.generativeai.type.Content
@Composable
fun ChatContent(modifier: Modifier, viewModel: GeminiViewModel){
var messages by remember { mutableStateOf(emptyList<Message>()) }
val firebaseManager = FirebaseManager()
LaunchedEffect(Unit) {
firebaseManager.retrieveMessagesListener(viewModel.chatId, viewModel.userId) { retrievedMessages ->
messages = retrievedMessages
}
}
LazyColumn(
modifier = modifier,
contentPadding = PaddingValues(16.dp),
) {
items(messages) { it ->
ChatItem(message = it)
Spacer(modifier = Modifier.height(4.dp))
}
}
//ResponseComposable(response = viewModel.state.response)
} | GeminiApp/app/src/main/java/com/example/geminiapp/chatComposables/ChatContent.kt | 1669428885 |
package com.example.geminiapp
data class Chat(
val topic: String?,
val chatId: String?
)
| GeminiApp/app/src/main/java/com/example/geminiapp/Chat.kt | 80992763 |
package com.example.geminiapp
import android.util.Log
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ValueEventListener
class FirebaseManager {
private val database = FirebaseDatabase.getInstance()
private val chatsRef = database.getReference("chats")
fun createChat(userId: String, onSuccess: (String) -> Unit, onError: (Exception) -> Unit){
Log.d("check", "FirebaseManager.createChat: userId $userId and chatsRef $chatsRef")
chatsRef.child(userId).addListenerForSingleValueEvent(object: ValueEventListener{
override fun onDataChange(snapshot: DataSnapshot) {
if (!snapshot.exists()) {
chatsRef.child(userId).setValue(true)
}
val userChats = chatsRef.child(userId)
val chatId = userChats.push().key
val chatMap = mapOf(
"topic" to "New Chat",
)
userChats.child(chatId!!).setValue(chatMap).addOnCompleteListener { task->
if (task.isSuccessful) {
Log.d("check", "FirebaseManager.createChat: chatId $chatId")
onSuccess(chatId)
} else {
onError(Exception("Chat creation failed"))
}
}
}
override fun onCancelled(error: DatabaseError) {
onError(Exception("Error creating chat: ${error.message}"))
}
})
}
fun retrieveChats(userId: String, callback: (List<Chat>?) -> Unit){
val userChats = chatsRef.child(userId)
userChats.addValueEventListener(object : ValueEventListener{
override fun onDataChange(snapshot: DataSnapshot) {
val chatList = mutableListOf<Chat>()
if (!snapshot.exists()) {
userChats.child(userId).setValue(true)
}
for (chatSnapshot in snapshot.children) {
if(chatSnapshot.hasChild("topic")){
val chatId = chatSnapshot.key.orEmpty()
val topic = chatSnapshot.child("topic").getValue(String::class.java).orEmpty()
chatList.add(Chat(topic = topic, chatId = chatId))
}
}
callback(chatList)
}
override fun onCancelled(error: DatabaseError) {
callback(null)
}
})
}
fun sendMessage(sender: String, message: String, chatId: String, userId: String){
val chatRef = chatsRef.child(userId).child(chatId)
chatRef.child("messages").addListenerForSingleValueEvent(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
if (!snapshot.exists()) {
chatRef.child("messages").setValue(true)
}
val messagesRef = chatRef.child("messages")
val messageId = messagesRef.push().key
val messageMap = mapOf(
"role" to sender,
"messageText" to message,
)
messagesRef.child(messageId!!).setValue(messageMap)
}
override fun onCancelled(error: DatabaseError) {
// Handle error
}
})
}
fun retrieveMessagesAtOnce(chatId: String, userId: String,callback: (List<Message>) -> Unit) {
val messagesRef = chatsRef.child(userId).child(chatId).child("messages")
messagesRef.addListenerForSingleValueEvent(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
val messages = mutableListOf<Message>()
for (messageSnapshot in snapshot.children) {
val message = messageSnapshot.getValue(Message::class.java)
Log.d("check", "retrieveMessagesAtOnce: "+messageSnapshot.key+" "+message?.role+" "+message?.messageText)
messages.add(message!!)
}
callback(messages)
}
override fun onCancelled(error: DatabaseError) {
// Handle error
}
})
}
fun retrieveMessagesListener(chatId: String, userId: String,callback: (List<Message>) -> Unit) {
val messagesRef = chatsRef.child(userId).child(chatId).child("messages")
messagesRef.addValueEventListener(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
val messages = mutableListOf<Message>()
for (messageSnapshot in snapshot.children) {
val message = messageSnapshot.getValue(Message::class.java)
Log.d("check", "retrieveMessagesListener: "+messageSnapshot.key+" "+message?.role+" "+message?.messageText)
messages.add(message!!)
}
callback(messages)
}
override fun onCancelled(error: DatabaseError) {
// Handle error
}
})
}
fun updateTopic(chatId: String, userId: String, topic:String, callback:(Boolean)->Unit){
val topicRef = chatsRef.child(userId).child(chatId).child("topic")
val c = topicRef.setValue(topic)
c.addOnCompleteListener {
if(it.isSuccessful){
callback(true)
} else {
callback(false)
}
}
}
fun deleteChat(chatId: String, userId: String, callback: (Boolean) -> Unit){
val task = chatsRef.child(userId).child(chatId).removeValue()
task.addOnCompleteListener {
if(it.isSuccessful){
callback(true)
} else {
callback(false)
}
}
}
fun retrieveTopic(chatId: String, userId: String,callback: (String) -> Unit){
chatsRef.child(userId).child(chatId).addListenerForSingleValueEvent(object: ValueEventListener{
override fun onDataChange(snapshot: DataSnapshot) {
val topic = snapshot.child("topic").getValue(String::class.java).orEmpty()
callback(topic)
}
override fun onCancelled(error: DatabaseError) {
callback("Fail")
}
})
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/FirebaseManager.kt | 1976004676 |
package com.example.geminiapp
import android.util.Log
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch
class UserViewModel: ViewModel() {
private val _currentUser = mutableStateOf<String?>(null)
val currentUser: State<String?> = _currentUser
private val _chats = MutableStateFlow<List<Chat>>(emptyList())
val chats: StateFlow<List<Chat>> get() = _chats
fun setCurrentUser(user: String?) {
_currentUser.value = user
}
fun setChats(callback: (Boolean) -> Unit) {
viewModelScope.launch {
val firebaseManager = FirebaseManager()
currentUser.value?.let {
firebaseManager.retrieveChats(it){ retrievedChats->
if (retrievedChats != null) {
_chats.value = retrievedChats.reversed()
Log.d("check", "chats are retrieved: ${currentUser.value}, ${_chats.value.size}")
callback(true)
} else {
callback(false)
Log.d("check", "Error Chats")
}
}
}
}
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/UserViewModel.kt | 43930580 |
package com.example.geminiapp
import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.appcompat.app.AppCompatActivity
class AuthenticateActivity: AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent { MakeItSoApp() }
}
private fun MakeItSoApp() {
TODO("Not yet implemented")
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/AuthenticateActivity.kt | 2596267980 |
package com.example.geminiapp
sealed class Screen(val route: String){
object Chat: Screen("chat")
object Chats: Screen("chats")
object SignUp: Screen("sign_up")
fun withArgs(vararg args: String): String{
return buildString{
append(route)
args.forEach {
append("/$it")
}
}
}
}
| GeminiApp/app/src/main/java/com/example/geminiapp/Screen.kt | 1740634691 |
package com.example.geminiapp
import android.util.Log
import android.widget.Toast
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.surfaceColorAtElevation
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.currentRecomposeScope
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.platform.LocalContext
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.navigation.NavController
import androidx.navigation.NavHostController
import com.example.geminiapp.presentation.GoogleAuthUIClient
import com.google.firebase.auth.ktx.auth
import com.google.firebase.ktx.Firebase
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
@Composable
fun ChatsScreen(navController: NavController, userViewModel: UserViewModel,
onSignOut: ()->Unit){
val userId = Firebase.auth.currentUser?.uid
var chatsLoaded by remember {
mutableStateOf(false)
}
Log.d("check", "chatsLoaded $chatsLoaded")
LaunchedEffect(Unit){
userViewModel.setChats(){
chatsLoaded = it
}
}
val chats by userViewModel.chats.collectAsState()
if(chatsLoaded){
Log.d("check", "user viewmodel ${userViewModel.chats.value.size}")
Column {
Row(
modifier = Modifier.padding(16.dp)
) {
Box(modifier = Modifier.fillMaxWidth(.8f)){
ChatEntry(navController = navController, chat = null, userId = userId)
}
Spacer(modifier = Modifier.size(4.dp))
Button(onClick = {
onSignOut()
}) {
Icon(imageVector = Icons.Default.MoreVert, contentDescription = null)
}
}
if(chats.isEmpty()){
Text(text = "No chats yet\nStart chatting by pressing New Chat", fontWeight = FontWeight.Bold, textAlign = TextAlign.Center)
}
LazyColumn(
modifier = Modifier
.fillMaxSize()
.padding(16.dp),
) {
items(chats) { chat ->
ChatEntry(navController = navController, chat = chat, userId = userId)
Spacer(modifier = Modifier.height(8.dp))
}
}
}
} else {
Text("Loading")
}
}
@Composable
fun ChatEntry(navController: NavController, chat: Chat?, userId: String?){
val context = LocalContext.current
val firebaseManager = FirebaseManager()
Row(
modifier = Modifier
.fillMaxWidth()
.clip(MaterialTheme.shapes.medium)
.background(MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp))
.clickable {
if (chat != null) {
Log.d("check", "chat is not null ${chat.chatId}")
navController.navigate(Screen.Chat.withArgs(chat.chatId!!))
} else {
Log.d("check", "chat is null")
createChatAndNavigate(navController, userId)
}
}
.padding(8.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.SpaceBetween
){
Text(text = chat?.topic?:"Start a New Chat", modifier = Modifier
.weight(1f)
.padding(end = 8.dp),
maxLines = 1,
overflow = TextOverflow.Ellipsis)
if(chat != null){
Button(onClick = { firebaseManager.deleteChat(chatId = chat.chatId!!, userId = userId!!) {
if (it) {
Log.d("check", "Chat delete succesfull")
} else {
Log.d("check", "Chat delete failed")
}
}
}) {
Icon(imageVector = Icons.Default.Delete,contentDescription = null)
}
}
}
}
fun createChatAndNavigate(navController: NavController, userId: String?){
val firebaseManager = FirebaseManager()
if (userId != null) {
firebaseManager.createChat(userId, {chatId->
navController.navigate(Screen.Chat.withArgs(chatId))
}, { e -> Log.d("check", "createChatAndNavigate: $e")
})
} else {
Log.d("check", "current user is null")
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/ChatsScreen.kt | 3523919418 |
package com.example.geminiapp
import android.util.Log
import android.widget.Toast
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.State
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.ai.client.generativeai.Chat
import com.google.ai.client.generativeai.GenerativeModel
import com.google.ai.client.generativeai.type.Content
import com.google.ai.client.generativeai.type.asTextOrNull
import com.google.ai.client.generativeai.type.content
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch
class GeminiViewModel(model: GenerativeModel, chatId: String, userId: String): ViewModel() {
val model = model
val chatId = chatId
val userId = userId
private val firebaseManager = FirebaseManager()
var state by mutableStateOf(GeminiState())
var history = mutableListOf<Content>()
lateinit var chat : Chat
private val _topic = MutableStateFlow<String>("")
val topic: StateFlow<String> get() = _topic
init {
firebaseManager.retrieveMessagesAtOnce(chatId = chatId, userId = userId) { retrievedMessages ->
retrievedMessages.map {
history.add(content(role = it.role) { text(it.messageText) })
}
chat = model.startChat(history = history)
}
firebaseManager.retrieveTopic(chatId = chatId, userId = userId){
if(it == "fail"){
updateTopic("Fail")
Log.d("check", "topic retrieval failed")
} else {
updateTopic(it)
Log.d("check", "topic retrieval ${topic.value}")
}
}
}
private fun updateTopic(topic: String){
_topic.value = topic
}
fun onClick(prompt: String){
if(state.userInput ==null || state.isLoading){
return
}
viewModelScope.launch(Dispatchers.IO) {
state = state.copy(isLoading = true)
try {
if(history.isEmpty()){
val topic = model.generateContent("Generate one short sentence topic for this chat: $prompt").text.toString()
firebaseManager.updateTopic(chatId, userId, topic) { res ->
if (res) {
Log.d("check", "Topic update successful")
} else {
Log.d("check", "Topic update failed")
}
}
}
firebaseManager.sendMessage("user", prompt, chatId, userId)
val response = chat.sendMessage(prompt).text.toString()
Log.d("check", "response: $response")
firebaseManager.sendMessage("model", response, chatId, userId)
} catch (e: Exception) {
Log.e("GeminiViewModel", "Error: ${e.message}")
} finally {
state = state.copy(isLoading = false)
}
}
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/GeminiViewModel.kt | 1272484879 |
package com.example.geminiapp
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import com.google.ai.client.generativeai.GenerativeModel
class GeminiViewModelFactory(private val model: GenerativeModel, private val chatId:String, private val userId:String) : ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
if (modelClass.isAssignableFrom(GeminiViewModel::class.java)) {
return GeminiViewModel(model, chatId, userId) as T
}
throw IllegalArgumentException("Unknown ViewModel class")
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/GeminiViewModelFactory.kt | 3610513620 |
package com.example.geminiapp
data class Message(
val role: String,
val messageText: String
){
constructor() : this("", "")
}
| GeminiApp/app/src/main/java/com/example/geminiapp/Message.kt | 623135954 |
package com.example.geminiapp.presentation
import android.content.Context
import android.content.Intent
import android.content.IntentSender
import android.util.Log
import com.example.geminiapp.R
import com.google.android.gms.auth.api.identity.BeginSignInRequest
import com.google.android.gms.auth.api.identity.BeginSignInRequest.GoogleIdTokenRequestOptions
import com.google.android.gms.auth.api.identity.SignInClient
import com.google.firebase.auth.GoogleAuthProvider
import com.google.firebase.auth.ktx.auth
import com.google.firebase.ktx.Firebase
import kotlinx.coroutines.tasks.await
import java.util.concurrent.CancellationException
class GoogleAuthUIClient(private val context: Context,
private val oneTapClient: SignInClient) {
private val auth = Firebase.auth
suspend fun signIn(): IntentSender?{
val result = try {
oneTapClient.beginSignIn(
beginSignInRequest()
).await()
} catch (e: Exception){
e.printStackTrace()
Log.d("check", "signIn")
if (e is CancellationException) throw e
null
}
return result?.pendingIntent?.intentSender
}
suspend fun signInWithIntent(intent: Intent): SignInResult{
val credential = oneTapClient.getSignInCredentialFromIntent(intent)
val googleIdToken = credential.googleIdToken
val googleCredentials = GoogleAuthProvider.getCredential(googleIdToken, null)
return try{
val user = auth.signInWithCredential(googleCredentials).await().user
SignInResult(data = user?.run {
UserData(
userId = uid,
username = displayName,
profilePictureId = photoUrl?.toString()
)
}, errorMessage = null)
}catch (e: Exception){
e.printStackTrace()
Log.d("check", "signInWithIntent")
if (e is CancellationException) throw e
SignInResult(data = null, errorMessage = e.message)
}
}
suspend fun signOut(){
try {
oneTapClient.signOut().await()
auth.signOut()
}catch (e: Exception){
e.printStackTrace()
if (e is CancellationException) throw e
}
}
fun getSignedInUser(): UserData? = auth.currentUser?.run{
UserData(
userId = uid,
username = displayName,
profilePictureId = photoUrl?.toString())
}
private fun beginSignInRequest(): BeginSignInRequest{
Log.d("check", "beginSignInRequest: ${context.getString(R.string.oauth)}")
return BeginSignInRequest.Builder()
.setGoogleIdTokenRequestOptions(
GoogleIdTokenRequestOptions.builder()
.setSupported(true)
.setFilterByAuthorizedAccounts(false)
.setServerClientId(context.getString(R.string.oauth))
.build()
)
.setAutoSelectEnabled(true)
.build()
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/presentation/GoogleAuthUIClient.kt | 2131576483 |
package com.example.geminiapp.presentation
import android.widget.Toast
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material.icons.filled.MailOutline
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import androidx.navigation.NavController
import androidx.navigation.NavHostController
@Composable
fun SignUpScreen(
navController: NavController,
onButtonClicked: (String, String, String) -> Unit
){
var email by remember {
mutableStateOf("")
}
var username by remember {
mutableStateOf("")
}
var password by remember {
mutableStateOf("")
}
var confirmPassword by remember {
mutableStateOf("")
}
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
){
Button(onClick = { navController.popBackStack() }) {
Icon(imageVector = Icons.AutoMirrored.Filled.ArrowBack, contentDescription = null)
}
OutlinedTextField(
value = email,
onValueChange = { email = it },
label = { Text("Email") },
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
keyboardOptions = KeyboardOptions.Default.copy(
keyboardType = KeyboardType.Email
),
leadingIcon = {
Icon(Icons.Default.MailOutline, contentDescription = null)
}
)
OutlinedTextField(
value = username,
onValueChange = { username = it },
label = { Text("Username") },
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
keyboardOptions = KeyboardOptions.Default.copy(
keyboardType = KeyboardType.Email
),
leadingIcon = {
Icon(Icons.Default.MailOutline, contentDescription = null)
}
)
OutlinedTextField(
value = password,
onValueChange = { password = it },
label = { Text("Password") },
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
keyboardOptions = KeyboardOptions.Default.copy(
keyboardType = KeyboardType.Password
),
visualTransformation = PasswordVisualTransformation(),
leadingIcon = {
Icon(Icons.Default.Lock, contentDescription = null)
}
)
OutlinedTextField(
value = confirmPassword,
onValueChange = { confirmPassword = it },
label = { Text("Confirm Password") },
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
keyboardOptions = KeyboardOptions.Default.copy(
keyboardType = KeyboardType.Password
),
visualTransformation = PasswordVisualTransformation(),
leadingIcon = {
Icon(Icons.Default.Lock, contentDescription = null)
}
)
Button(onClick = {
if(password!=confirmPassword){
Toast.makeText(navController.context, "Passwords do not match", Toast.LENGTH_SHORT).show()
return@Button
}
onButtonClicked(email, username, password)
}) {
Text(text = "Sign Up")
}
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/presentation/SignUpScreen.kt | 3552505829 |
package com.example.geminiapp.presentation
data class SignInResult(
val data:UserData?,
val errorMessage: String?
)
data class UserData(
val userId: String,
val username: String?,
val profilePictureId: String?
)
| GeminiApp/app/src/main/java/com/example/geminiapp/presentation/SignInResult.kt | 1613623263 |
package com.example.geminiapp.presentation
data class SignInState(
val isSignInSuccessful: Boolean = false,
val signInError: String? = null
)
| GeminiApp/app/src/main/java/com/example/geminiapp/presentation/SignInState.kt | 752221439 |
package com.example.geminiapp.presentation
import androidx.lifecycle.ViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
class SignInViewModel: ViewModel() {
private val _state = MutableStateFlow(SignInState())
val state = _state.asStateFlow()
fun onSignInResult(result: SignInResult){
_state.update {
it.copy(
isSignInSuccessful = result.data != null,
signInError = result.errorMessage
)
}
}
fun resetState(){
_state.update { SignInState() }
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/presentation/SignInViewModel.kt | 198071119 |
package com.example.geminiapp.presentation
import android.app.Activity
import android.content.Context
import android.util.Log
import com.google.firebase.auth.FirebaseUser
import com.google.firebase.auth.UserProfileChangeRequest
import com.google.firebase.auth.ktx.auth
import com.google.firebase.ktx.Firebase
class EmailSignInClient {
private val auth = Firebase.auth
fun signIn(email: String, password: String, onSuccess: (SignInResult)->Unit, onFailure: (Exception?)->Unit){
auth.signInWithEmailAndPassword(email, password)
.addOnCompleteListener { task ->
if (task.isSuccessful) {
Log.d("check", "signInWithEmail:success")
val user = auth.currentUser
val res = SignInResult(data = user?.run {
UserData(
userId = uid,
username = displayName,
profilePictureId = photoUrl?.toString()
)
}, errorMessage = null)
onSuccess(res)
} else {
Log.w("check", "signInWithEmail:failure", task.exception)
onFailure(task.exception)
}
}
}
fun signUp(email: String, username: String, password: String, onSuccess: (SignInResult)->Unit, onFailure: (Exception?)->Unit){
auth.createUserWithEmailAndPassword(email, password)
.addOnCompleteListener { task ->
if (task.isSuccessful) {
Log.d("check", "createUserWithEmail:success")
val user = auth.currentUser
val profileUpdates = UserProfileChangeRequest.Builder()
.setDisplayName(username)
.build()
user?.updateProfile(profileUpdates)
?.addOnCompleteListener { task ->
if (task.isSuccessful) {
val res = SignInResult(data = user?.run {
UserData(
userId = uid,
username = displayName,
profilePictureId = photoUrl?.toString()
)
}, errorMessage = null)
onSuccess(res)
} else {
onFailure(task.exception)
}
}
} else {
Log.w("check", "createUserWithEmail:failure", task.exception)
onFailure(task.exception)
}
}
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/presentation/EmailSignInClient.kt | 4281444122 |
package com.example.geminiapp.presentation
import android.util.Log
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.padding
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material.icons.filled.MailOutline
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
@Composable
fun SignInScreen(
state: SignInState,
onGoogleSignInClicked: () -> Unit,
onSignInClicked: (String, String) -> Unit,
onSignUpClicked: () -> Unit
)
{
val context = LocalContext.current
var email by remember {
mutableStateOf("")
}
var password by remember {
mutableStateOf("")
}
LaunchedEffect(key1 = state.signInError){
state.signInError?.let {
Log.d("check", it)
}
}
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp),
) {
OutlinedTextField(
value = email,
onValueChange = { email = it },
label = { Text("Email") },
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
keyboardOptions = KeyboardOptions.Default.copy(
keyboardType = KeyboardType.Email
),
leadingIcon = {
Icon(Icons.Default.MailOutline, contentDescription = null)
}
)
OutlinedTextField(
value = password,
onValueChange = { password = it },
label = { Text("Password") },
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
keyboardOptions = KeyboardOptions.Default.copy(
keyboardType = KeyboardType.Password
),
visualTransformation = PasswordVisualTransformation(),
leadingIcon = {
Icon(Icons.Default.Lock, contentDescription = null)
}
)
Row {
Button(onClick = { onSignInClicked(email, password)}) {
Text(text = "Sign in")
}
Button(onClick = { onSignUpClicked() }) {
Text(text = "Sign Up")
}
}
Button(onClick = onGoogleSignInClicked) {
Text(text = "Sign In with Google")
}
}
} | GeminiApp/app/src/main/java/com/example/geminiapp/presentation/SignInScreen.kt | 865204065 |
package com.example.tugaschapter2
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.tugaschapter2", appContext.packageName)
}
} | 24001116-SYNRGY-7-muk-calculator-ch2/app/src/androidTest/java/com/example/tugaschapter2/ExampleInstrumentedTest.kt | 1392581416 |
package com.example.tugaschapter2
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)
}
} | 24001116-SYNRGY-7-muk-calculator-ch2/app/src/test/java/com/example/tugaschapter2/ExampleUnitTest.kt | 1052814906 |
package com.example.tugaschapter2.ui
import androidx.lifecycle.ViewModel
import com.example.tugaschapter2.repository.CalculationImpl
import com.example.tugaschapter2.common.calculate
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
class MainViewModel : ViewModel() {
private val _tipAmount = MutableStateFlow(0.0)
val tipAmount: StateFlow<Double> = _tipAmount
fun calculateTip(costOfService: Double, tipPercentage: Double, roundUp: Boolean) {
val tipAmount = costOfService.calculate(CalculationImpl(), tipPercentage, roundUp)
_tipAmount.value = tipAmount
}
} | 24001116-SYNRGY-7-muk-calculator-ch2/app/src/main/java/com/example/tugaschapter2/ui/MainViewModel.kt | 749138936 |
package com.example.tugaschapter2.ui
import android.os.Bundle
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import com.example.tugaschapter2.R
import com.example.tugaschapter2.databinding.ActivityMainBinding
import com.example.tugaschapter2.common.costOfService
import com.example.tugaschapter2.common.roundUp
import com.example.tugaschapter2.common.tipPercentage
import kotlinx.coroutines.launch
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
private val viewModel: MainViewModel by viewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
bindView()
bindObserver()
}
private fun bindView() {
binding.imageView.setImageResource(R.drawable.opm)
intercationButtonClickUI()
interactionEditTextRealtimeUI()
interactionSwitchRealtimeUI()
interactionRadioGroupRealtimeUI()
}
private fun bindObserver() {
lifecycleScope.launch {
viewModel.tipAmount.collect { tipAmount ->
binding.tipResult.text = "Tip Amount: $tipAmount"
}
}
}
private fun intercationButtonClickUI() {
binding.btnCalculate.setOnClickListener {
val costOfService = binding.costOfService.text.toString().toDoubleOrNull() ?: 0.0
val roundUp = binding.roundUpSwitch.isChecked
val tipPercentage = when (binding.tipOptions.checkedRadioButtonId) {
binding.optionThirtyPercent.id -> 0.30
binding.optionTwentyfivePercent.id -> 0.25
binding.optionTwentyPercent.id -> 0.20
binding.optionFifteenPercent.id -> 0.15
binding.optionTenPercent.id -> 0.10
else -> 0.0
}
viewModel.calculateTip(costOfService, tipPercentage, roundUp)
}
}
private fun interactionEditTextRealtimeUI() {
binding.costOfService.costOfService(binding) { costOfService, tipPercentage, roundUp ->
viewModel.calculateTip(costOfService, tipPercentage, roundUp)
}
}
private fun interactionSwitchRealtimeUI() {
binding.roundUpSwitch.roundUp(binding) { costOfService, tipPercentage, roundUp ->
viewModel.calculateTip(costOfService, tipPercentage, roundUp)
}
}
private fun interactionRadioGroupRealtimeUI() {
binding.tipOptions.tipPercentage(binding) { costOfService, tipPercentage, roundUp ->
viewModel.calculateTip(costOfService, tipPercentage, roundUp)
}
}
}
| 24001116-SYNRGY-7-muk-calculator-ch2/app/src/main/java/com/example/tugaschapter2/ui/MainActivity.kt | 1360018790 |
package com.example.tugaschapter2.repository
import kotlin.math.ceil
class CalculationImpl : Calculation {
override fun calculateTip(
costOfService: Double,
tipPercentage: Double,
roundUp: Boolean
): Double {
return calculate(costOfService, tipPercentage, roundUp)
}
private fun calculate(costOfService: Double, tipPercentage: Double, roundUp: Boolean): Double {
var tipAmount = costOfService * tipPercentage
if (roundUp) {
tipAmount = ceil(tipAmount)
}
return tipAmount
}
} | 24001116-SYNRGY-7-muk-calculator-ch2/app/src/main/java/com/example/tugaschapter2/repository/CalculationImpl.kt | 1885879720 |
package com.example.tugaschapter2.repository
interface Calculation {
fun calculateTip(costOfService: Double, tipPercentage: Double, roundUp: Boolean): Double {
return 0.0
}
} | 24001116-SYNRGY-7-muk-calculator-ch2/app/src/main/java/com/example/tugaschapter2/repository/Calculation.kt | 1926663722 |
package com.example.tugaschapter2.common
import android.text.Editable
import android.text.TextWatcher
import android.widget.EditText
import android.widget.RadioGroup
import android.widget.Switch
import com.example.tugaschapter2.databinding.ActivityMainBinding
fun EditText.costOfService(
binding: ActivityMainBinding,
listener: (costOfService: Double, tipPercentage: Double, roundUp: Boolean) -> Unit
) {
this.addTextChangedListener(object : TextWatcher {
override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
val costOfService = s.toString().toDoubleOrNull() ?: 0.0
val roundUp = binding.roundUpSwitch.isChecked
val tipPercentage = when (binding.tipOptions.checkedRadioButtonId) {
binding.optionThirtyPercent.id -> 0.30
binding.optionTwentyfivePercent.id -> 0.25
binding.optionTwentyPercent.id -> 0.20
binding.optionFifteenPercent.id -> 0.15
binding.optionTenPercent.id -> 0.10
else -> 0.0
}
listener.invoke(costOfService, tipPercentage, roundUp)
}
override fun afterTextChanged(s: Editable?) {}
})
}
fun Switch.roundUp(
binding: ActivityMainBinding,
listener: (costOfService: Double, tipPercentage: Double, roundUp: Boolean) -> Unit
) {
this.setOnCheckedChangeListener { _, roundUp ->
val costOfService = binding.costOfService.text.toString().toDoubleOrNull() ?: 0.0
val tipPercentage = when (binding.tipOptions.checkedRadioButtonId) {
binding.optionThirtyPercent.id -> 0.30
binding.optionTwentyfivePercent.id -> 0.25
binding.optionTwentyPercent.id -> 0.20
binding.optionFifteenPercent.id -> 0.15
binding.optionTenPercent.id -> 0.10
else -> 0.0
}
listener.invoke(costOfService, tipPercentage, roundUp)
}
}
fun RadioGroup.tipPercentage(
binding: ActivityMainBinding,
listener: (costOfService: Double, tipPercentage: Double, roundUp: Boolean) -> Unit
) {
this.setOnCheckedChangeListener { _, checkedId ->
val costOfService = binding.costOfService.text.toString().toDoubleOrNull() ?: 0.0
val roundUp = binding.roundUpSwitch.isChecked
val tipPercentage = when (checkedId) {
binding.optionThirtyPercent.id -> 0.30
binding.optionTwentyfivePercent.id -> 0.25
binding.optionTwentyPercent.id -> 0.20
binding.optionFifteenPercent.id -> 0.15
binding.optionTenPercent.id -> 0.10
else -> 0.0
}
listener.invoke(costOfService, tipPercentage, roundUp)
}
}
| 24001116-SYNRGY-7-muk-calculator-ch2/app/src/main/java/com/example/tugaschapter2/common/CostOfServiceExtensions.kt | 2956699285 |
package com.example.tugaschapter2.common
import com.example.tugaschapter2.repository.Calculation
fun Double.calculate(calculation: Calculation, tipPercentage: Double, roundUp: Boolean): Double {
return calculation.calculateTip(this, tipPercentage, roundUp)
} | 24001116-SYNRGY-7-muk-calculator-ch2/app/src/main/java/com/example/tugaschapter2/common/CalculationExtensions.kt | 122463563 |
package mohammad.toriq.mymovies
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("mohammad.toriq.mymovies", appContext.packageName)
}
} | my_movies_jetpack_compose/app/src/androidTest/java/mohammad/toriq/mymovies/ExampleInstrumentedTest.kt | 133439570 |
package mohammad.toriq.mymovies
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)
}
} | my_movies_jetpack_compose/app/src/test/java/mohammad/toriq/mymovies/ExampleUnitTest.kt | 3418043477 |
package mohammad.toriq.mymovies
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
/***
* Created By Mohammad Toriq on 30/11/2023
*/
@HiltAndroidApp
class MyApplication : Application(){
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/MyApplication.kt | 2694159470 |
package mohammad.toriq.mymovies.di
import com.google.gson.GsonBuilder
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import mohammad.toriq.mymovies.data.source.remote.RequestInterceptor
import mohammad.toriq.mymovies.data.source.remote.dto.APIService
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import javax.inject.Singleton
/***
* Created By Mohammad Toriq on 29/11/2023
*/
@Module
@InstallIn(SingletonComponent::class)
class NetworkModule {
private val interceptor = run {
val httpLoggingInterceptor = HttpLoggingInterceptor()
httpLoggingInterceptor.apply {
httpLoggingInterceptor.level = HttpLoggingInterceptor.Level.BODY
}
}
@Provides
@Singleton
fun provideOkHttpClient() =
OkHttpClient.Builder().addInterceptor(RequestInterceptor()).addInterceptor(interceptor)
.build()
@Singleton
@Provides
fun provideRetrofitService(okHttpClient: OkHttpClient): APIService {
val gson = GsonBuilder().setLenient().create()
return Retrofit.Builder()
.baseUrl(APIService.BASE_URL)
.addConverterFactory(GsonConverterFactory.create(gson))
.client(okHttpClient)
.build()
.create(APIService::class.java)
}
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/di/NetworkModule.kt | 3678709471 |
package mohammad.toriq.mymovies.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import mohammad.toriq.mymovies.data.repository.RepositoryImpl
import mohammad.toriq.mymovies.domain.repository.Repository
import mohammad.toriq.mymovies.data.source.remote.dto.APIService
import javax.inject.Singleton
/***
* Created By Mohammad Toriq on 29/11/2023
*/
@Module
@InstallIn(SingletonComponent::class)
class Module {
@Provides
@Singleton
fun provideRepositoryImpl(
apiService: APIService,
): Repository = RepositoryImpl(apiService)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/di/Module.kt | 3204325163 |
package mohammad.toriq.mymovies.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import mohammad.toriq.mymovies.domain.repository.Repository
import mohammad.toriq.mymovies.domain.usecase.GetDetailMovieUseCase
import mohammad.toriq.mymovies.domain.usecase.GetDiscoverMoviesUseCase
import mohammad.toriq.mymovies.domain.usecase.GetGenresUseCase
import mohammad.toriq.mymovies.domain.usecase.GetMovieReviewsUseCase
import mohammad.toriq.mymovies.domain.usecase.GetMovieVideosUseCase
import mohammad.toriq.mymovies.domain.usecase.GetMoviesUseCase
import javax.inject.Singleton
/***
* Created By Mohammad Toriq on 29/11/2023
*/
@Module
@InstallIn(SingletonComponent::class)
class UseCaseModule {
@Provides
@Singleton
fun provideGetMoviesUseCase(repository: Repository): GetMoviesUseCase =
GetMoviesUseCase(repository)
@Provides
@Singleton
fun provideGetDiscoverMoviesUseCase(repository: Repository): GetDiscoverMoviesUseCase =
GetDiscoverMoviesUseCase(repository)
@Provides
@Singleton
fun provideGetGenresUseCase(repository: Repository): GetGenresUseCase =
GetGenresUseCase(repository)
@Provides
@Singleton
fun provideGetDetailMovieUseCase(repository: Repository): GetDetailMovieUseCase =
GetDetailMovieUseCase(repository)
@Provides
@Singleton
fun provideGetMovieReviewsUseCase(repository: Repository): GetMovieReviewsUseCase =
GetMovieReviewsUseCase(repository)
@Provides
@Singleton
fun provideGetMovieVideosUseCase(repository: Repository): GetMovieVideosUseCase =
GetMovieVideosUseCase(repository)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/di/UseCaseModule.kt | 4003071237 |
package mohammad.toriq.mymovies.util
import androidx.compose.foundation.interaction.Interaction
import androidx.compose.foundation.interaction.MutableInteractionSource
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.emptyFlow
/***
* Created By Mohammad Toriq on 02/12/2023
*/
class NoRippleInteractionSource : MutableInteractionSource {
override val interactions: Flow<Interaction> = emptyFlow()
override suspend fun emit(interaction: Interaction) {}
override fun tryEmit(interaction: Interaction) = true
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/util/NoRippleInteractionSource.kt | 964474404 |
package mohammad.toriq.mymovies.util
import java.text.ParseException
import java.text.SimpleDateFormat
import java.util.Locale
import java.util.TimeZone
/***
* Created By Mohammad Toriq on 01/12/2023
*/
class Util {
companion object{
fun convertDate(
dateInput: String?,
inFormat: String?,
outFormat: String?,
isLocal: Boolean = false
): String {
var tmp = ""
val locale = Locale("in")
val origin =
SimpleDateFormat(inFormat, Locale.getDefault())
origin.timeZone = TimeZone.getTimeZone("UTC")
if (isLocal) {
origin.timeZone = TimeZone.getDefault()
}
val result = SimpleDateFormat(outFormat, locale)
result.timeZone = TimeZone.getDefault()
try {
tmp = result.format(origin.parse(dateInput))
} catch (e: ParseException) {
e.printStackTrace()
}
return tmp
}
fun getShowTime(time: Int /** in minute**/): String {
var showTime = ""
var hour = time/ 60
var minute = time % 60
var hourText = hour.toString()
var minuteText = minute.toString()
showTime = hourText+" Hour "+minuteText+" Minute"
return showTime
}
}
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/util/Util.kt | 2629014264 |
package mohammad.toriq.mymovies.util
/***
* Created By Mohammad Toriq on 01/12/2023
*/
class Constants {
companion object{
val DATE_OUT_FORMAT_DEF0 = "yyyy-MM-dd'T'HH:mm:ss'Z'"
val DATE_OUT_FORMAT_DEF1 = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
val DATE_OUT_FORMAT_DEF2 = "yyyy-MM-dd"
val DATE_OUT_FORMAT_DEF3 = "MMM dd, yyyy"
val DATE_OUT_FORMAT_DEF4 = "dd MMMM yyyy"
}
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/util/Constants.kt | 1012503836 |
package mohammad.toriq.mymovies.data.repository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import mohammad.toriq.mymovies.domain.repository.Repository
import mohammad.toriq.mymovies.data.source.remote.Resource
import mohammad.toriq.mymovies.data.source.remote.dto.APIService
import mohammad.toriq.mymovies.models.Genres
import mohammad.toriq.mymovies.models.Movie
import mohammad.toriq.mymovies.models.Movies
import mohammad.toriq.mymovies.models.Reviews
import mohammad.toriq.mymovies.models.Videos
import mohammad.toriq.mymovies.models.toGenres
import mohammad.toriq.mymovies.models.toMovie
import mohammad.toriq.mymovies.models.toMovies
import mohammad.toriq.mymovies.models.toReviews
import mohammad.toriq.mymovies.models.toVideos
import retrofit2.HttpException
import java.io.IOException
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class RepositoryImpl constructor(
private val apiService: APIService
) : Repository
{
override fun getMovies(category:String, language:String): Flow<Resource<Movies>> = flow {
emit(Resource.Loading())
try {
emit(Resource.Success(getMoviesFromAPI(category,language)))
} catch (e: HttpException) {
emit(
Resource.Error(
message = "Oops, something went wrong!"
)
)
} catch (e: IOException) {
emit(
Resource.Error(
message = "Couldn't reach server, check your internet connection."
)
)
}
}
private suspend fun getMoviesFromAPI(category:String, language:String): Movies {
val remoteMovies = apiService.getMovies(
category = category,
language = language,)
return remoteMovies.toMovies()
}
override fun getDiscoverMovies(page: Int, withGenres : String?, language:String):Flow<Resource<Movies>> = flow {
emit(Resource.Loading())
try {
emit(Resource.Success(getDiscoverMoviesFromAPI(page,withGenres,language)))
} catch (e: HttpException) {
emit(
Resource.Error(
message = "Oops, something went wrong!"
)
)
} catch (e: IOException) {
emit(
Resource.Error(
message = "Couldn't reach server, check your internet connection."
)
)
}
}
private suspend fun getDiscoverMoviesFromAPI(page: Int, withGenres : String?, language:String): Movies {
val remoteMovies = apiService.getDiscoverMovies(
page = page,
withGenres = withGenres,
language = language,)
return remoteMovies.toMovies()
}
override fun getGenres(language:String):Flow<Resource<Genres>> = flow {
emit(Resource.Loading())
try {
emit(Resource.Success(getGenresFromAPI(language)))
} catch (e: HttpException) {
emit(
Resource.Error(
message = "Oops, something went wrong!"
)
)
} catch (e: IOException) {
emit(
Resource.Error(
message = "Couldn't reach server, check your internet connection."
)
)
}
}
private suspend fun getGenresFromAPI(language:String): Genres {
val remoteGenres = apiService.getGenres(
// token = "bearer "+APIService.TOKEN,
// language = language,
)
return remoteGenres.toGenres()
}
override fun getDetailMovie(id:Long):Flow<Resource<Movie>> = flow {
emit(Resource.Loading())
try {
emit(Resource.Success(getDetailMovieFromAPI(id)))
} catch (e: HttpException) {
emit(
Resource.Error(
message = "Oops, something went wrong!"
)
)
} catch (e: IOException) {
emit(
Resource.Error(
message = "Couldn't reach server, check your internet connection."
)
)
}
}
private suspend fun getDetailMovieFromAPI(id:Long): Movie {
val remoteMovie = apiService.getDetailMovie(
id = id)
return remoteMovie.toMovie()
}
override fun getMovieReviews(id:Long,page:Int):Flow<Resource<Reviews>> = flow {
emit(Resource.Loading())
try {
emit(Resource.Success(getMovieReviewsFromAPI(id,page)))
} catch (e: HttpException) {
emit(
Resource.Error(
message = "Oops, something went wrong!"
)
)
} catch (e: IOException) {
emit(
Resource.Error(
message = "Couldn't reach server, check your internet connection."
)
)
}
}
private suspend fun getMovieReviewsFromAPI(id:Long,page:Int): Reviews {
val remoteReviews = apiService.getMovieReviews(
id = id,
page = page,)
return remoteReviews.toReviews()
}
override fun getMovieVideos(id:Long):Flow<Resource<Videos>> = flow {
emit(Resource.Loading())
try {
emit(Resource.Success(getMovieVideosFromAPI(id)))
} catch (e: HttpException) {
emit(
Resource.Error(
message = "Oops, something went wrong!"
)
)
} catch (e: IOException) {
emit(
Resource.Error(
message = "Couldn't reach server, check your internet connection."
)
)
}
}
private suspend fun getMovieVideosFromAPI(id:Long): Videos {
val remoteVideos = apiService.getMovieVideos(
id = id,)
return remoteVideos.toVideos()
}
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/repository/RepositoryImpl.kt | 3291199438 |
package mohammad.toriq.mymovies.models
import com.google.gson.annotations.SerializedName
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class GenresDto (
@SerializedName("genres")
var genres : List<GenreDto> = listOf(),
)
fun GenresDto.toGenres(): Genres {
return Genres(
genres = genres.map { it.toGenre() }.toList(),
)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/dto/GenresDto.kt | 4200292003 |
package mohammad.toriq.mymovies.models
import com.google.gson.annotations.SerializedName
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class GenreDto (
@SerializedName("id")
var id: Long = 0,
@SerializedName("name")
var name: String? = null,
)
fun GenreDto.toGenre(): Genre {
return Genre(
id = id,
name = name,
)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/dto/GenreDto.kt | 3241830374 |
package mohammad.toriq.mymovies.models
import com.google.gson.annotations.SerializedName
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class ReviewDto (
@SerializedName("id")
var id: String? = null,
@SerializedName("author")
var author: String? = null,
@SerializedName("author_details")
var authorDetails: AuthorDto,
@SerializedName("content")
var content: String? = null,
@SerializedName("created_at")
var createdAt: String? = null,
@SerializedName("updated_at")
var updatedAt: String? = null,
@SerializedName("url")
var url: String? = null,
)
fun ReviewDto.toReview(): Review {
return Review(
id = id,
author = author,
authorDetails = authorDetails.toAuthor(),
content = content,
createdAt = createdAt,
updatedAt = updatedAt,
url = url,
)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/dto/ReviewDto.kt | 229159040 |
package mohammad.toriq.mymovies.models
import com.google.gson.annotations.SerializedName
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class VideosDto (
@SerializedName("results")
var videos: List<VideoDto> = listOf(),
)
fun VideosDto.toVideos(): Videos {
return Videos(
videos = videos.map { it.toVideo() }.toList(),
)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/dto/VideosDto.kt | 2021144250 |
package mohammad.toriq.mymovies.models
import com.google.gson.annotations.SerializedName
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class MovieDto (
@SerializedName("id")
var id: Long = 0,
@SerializedName("title")
var title: String? = null,
@SerializedName("overview")
var desc: String? = null,
@SerializedName("original_title")
var originalTitle: String? = null,
@SerializedName("popularity")
var popularity: Double = 0.0,
@SerializedName("backdrop_path")
var imageUrlBackDrop: String? = null,
@SerializedName("poster_path")
var imageUrl: String? = null,
@SerializedName("vote_average")
var voteAverage: Float = 0f,
@SerializedName("vote_count")
var voteCount: Long = 0,
@SerializedName("release_date")
var releaseDate: String? = null,
@SerializedName("runtime")
var runtime: Int = 0,
@SerializedName("budget")
var budget: Long = 0,
@SerializedName("genres")
var genres: List<GenreDto> = listOf(),
@SerializedName("homepage")
var homepage: String? = null,
@SerializedName("status")
var status: String? = null,
)
fun MovieDto.toMovie(): Movie {
return Movie(
id = id,
title = title,
desc = desc,
originalTitle = originalTitle,
popularity = popularity,
imageUrlBackDrop = imageUrlBackDrop,
imageUrl = imageUrl,
voteAverage = voteAverage,
voteCount = voteCount,
releaseDate = releaseDate,
runtime = runtime,
budget = budget,
genres = genres.map { it.toGenre() }.toList(),
homepage = homepage,
status = status,
)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/dto/MovieDto.kt | 3998441026 |
package mohammad.toriq.mymovies.models
import com.google.gson.annotations.SerializedName
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class ReviewsDto (
@SerializedName("page")
var page: Long = 0,
@SerializedName("results")
var reviews: List<ReviewDto> = listOf(),
@SerializedName("total_pages")
var totalPages: Long = 0,
@SerializedName("total_results")
var totalResults: Long = 0,
)
fun ReviewsDto.toReviews(): Reviews {
return Reviews(
page = page,
reviews = reviews.map { it.toReview() }.toList(),
totalPages = totalPages,
totalResults = totalResults,
)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/dto/ReviewsDto.kt | 1015016273 |
package mohammad.toriq.mymovies.models
import com.google.gson.annotations.SerializedName
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class AuthorDto(
@SerializedName("name")
var name: String? = null,
@SerializedName("username")
var username: String? = null,
@SerializedName("avatar_path")
var avatarPath: String? = null,
@SerializedName("rating")
var rating: Double? = null,
)
fun AuthorDto.toAuthor(): Author {
return Author(
name = name,
username = username,
avatarPath = avatarPath,
rating = rating,
)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/dto/AuthorDto.kt | 815978468 |
package mohammad.toriq.mymovies.models
import com.google.gson.annotations.SerializedName
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class VideoDto (
@SerializedName("iso_639_1")
var iso_639_1: String? = null,
@SerializedName("iso_3166_1")
var iso_3166_1: String? = null,
@SerializedName("name")
var name: String? = null,
@SerializedName("key")
var key: String? = null,
@SerializedName("site")
var site: String? = null,
@SerializedName("size")
var size: Int = 0,
@SerializedName("type")
var type: String? = null,
@SerializedName("official")
var official: Boolean? = null,
@SerializedName("published_at")
var publishedAt: String? = null,
@SerializedName("id")
var id: String? = null,
)
fun VideoDto.toVideo(): Video {
return Video(
iso_639_1 = iso_639_1,
iso_3166_1 = iso_3166_1,
name = name,
key = key,
site = site,
size = size,
type = type,
official = official,
publishedAt = publishedAt,
id = id,
)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/dto/VideoDto.kt | 3826239011 |
package mohammad.toriq.mymovies.models
import com.google.gson.annotations.SerializedName
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class MoviesDto (
@SerializedName("page")
var page: Long = 0,
@SerializedName("results")
var movies: List<MovieDto> = listOf(),
@SerializedName("total_pages")
var totalPages: Long = 0,
@SerializedName("total_results")
var totalResults: Long = 0,
)
fun MoviesDto.toMovies(): Movies {
return Movies(
page = page,
movies = movies.map { it.toMovie() }.toList(),
totalPages = totalPages,
totalResults = totalResults,
)
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/dto/MoviesDto.kt | 991574221 |
package mohammad.toriq.mymovies.data.source.remote
import mohammad.toriq.mymovies.data.source.remote.dto.APIService
import okhttp3.Interceptor
import okhttp3.Response
/***
* Created By Mohammad Toriq on 30/11/2023
*/
class RequestInterceptor : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response {
val originalRequest = chain.request()
val newUrl = originalRequest.url
.newBuilder()
.build()
val request = originalRequest.newBuilder()
.url(newUrl)
.addHeader("Authorization","bearer "+APIService.TOKEN)
.build()
return chain.proceed(request)
}
} | my_movies_jetpack_compose/app/src/main/java/mohammad/toriq/mymovies/data/source/RequestInterceptor.kt | 402602819 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.