content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
class JVMPlatform: Platform {
override val name: String = "Java ${System.getProperty("java.version")}"
}
actual fun getPlatform(): Platform = JVMPlatform() | Chat-Sample-Ktor-Compose-Multiplatform/shared/src/jvmMain/kotlin/Platform.jvm.kt | 1652497929 |
class WasmPlatform: Platform {
override val name: String = "Web with Kotlin/Wasm"
}
actual fun getPlatform(): Platform = WasmPlatform() | Chat-Sample-Ktor-Compose-Multiplatform/shared/src/wasmJsMain/kotlin/Platform.wasmJs.kt | 1905791012 |
import android.os.Build
class AndroidPlatform : Platform {
override val name: String = "Android ${Build.VERSION.SDK_INT}"
}
actual fun getPlatform(): Platform = AndroidPlatform() | Chat-Sample-Ktor-Compose-Multiplatform/shared/src/androidMain/kotlin/Platform.android.kt | 3472575554 |
package ui.viewmodel
import ui.viewmodel.login.LoginViewModel
/**
* An instance of the login ViewModel.
*/
internal val loginViewModel by lazy { LoginViewModel() } | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/iosMain/kotlin/ui/viewmodel/ViewModelInstances.kt | 2360619959 |
package ui.viewmodel.login
import data.model.User
import networking.login.LoginApiImpl
/**
* A ViewModel designed to handle user login.
*/
internal actual class LoginViewModel : LoginViewModelContract {
/**
* Handles user login.
*/
private val loginApiImpl = LoginApiImpl()
/**
* Logs the user in and returns a JWT.
*
* @param username The username of the user to be logged in
* @param password The password of the user to be logged in
*
* @return The user's JWT.
*/
override suspend fun login(username: String, password: String): io.ktor.client.statement.HttpResponse =
loginApiImpl.login(User(username, password))
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/iosMain/kotlin/ui/viewmodel/login/LoginViewModel.kt | 546586114 |
import androidx.compose.ui.window.ComposeUIViewController
import ui.viewmodel.loginViewModel
fun MainViewController() = ComposeUIViewController { App(loginViewModel = loginViewModel) } | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/iosMain/kotlin/MainViewController.kt | 3426323453 |
package ui.viewmodel.login
import io.ktor.client.statement.*
/**
* A contract any login ViewModel implementation must satisfy.
*/
internal interface LoginViewModelContract {
/**
* Logs the user in and returns a JWT.
*
* @param username The username of the user to be logged in
* @param password The password of the user to be logged in
*
* @return The user's JWT.
*/
suspend fun login(username: String, password: String): HttpResponse
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/ui/viewmodel/login/LoginViewModelContract.kt | 1736844834 |
package ui.viewmodel.login
/**
* A ViewModel designed to handle user login.
*/
internal expect class LoginViewModel: LoginViewModelContract | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/ui/viewmodel/login/LoginViewModel.kt | 1584171337 |
package ui.login
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import chatsample.composeapp.generated.resources.Res
import chatsample.composeapp.generated.resources.compose_multiplatform
import kotlinx.coroutines.launch
import networking.deserializeBody
import networking.model.JwtToken
import org.jetbrains.compose.resources.ExperimentalResourceApi
import org.jetbrains.compose.resources.painterResource
import ui.viewmodel.login.LoginViewModel
/**
* Contains the login screen.
*
* @param loginViewModel The ViewModel responsible for logging in Users.
* @param modifier The modifier used for styling the composable.
*/
@OptIn(ExperimentalResourceApi::class)
@Composable
internal fun LoginScreen(
loginViewModel: LoginViewModel,
modifier: Modifier = Modifier,
onSuccessfulLogin: (token: String) -> Unit,
) {
val coroutineScope = rememberCoroutineScope()
val username = "Username"
val password = "Password"
var title by remember {
mutableStateOf("")
}
var usernameTextFieldValue by rememberSaveable {
mutableStateOf("")
}
var passwordTextFieldValue by rememberSaveable {
mutableStateOf("")
}
Column(
modifier = modifier,
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
Image(
modifier = Modifier.sizeIn(
maxWidth = 250.dp,
maxHeight = 250.dp
),
painter = painterResource(Res.drawable.compose_multiplatform),
contentDescription = null
)
Text(text = title)
Spacer(
modifier = Modifier.fillMaxWidth()
.height(12.dp)
)
LoginTextField(
value = usernameTextFieldValue,
label = username,
placeholder = username,
) { usernameInput ->
usernameTextFieldValue = usernameInput
}
LoginTextField(
value = passwordTextFieldValue,
label = password,
placeholder = password
) { passwordInput ->
passwordTextFieldValue = passwordInput
}
Spacer(
modifier = Modifier.fillMaxWidth()
.height(25.dp)
)
Button(
onClick = {
coroutineScope.launch {
val response = loginViewModel.login(usernameTextFieldValue, passwordTextFieldValue)
val result = response.deserializeBody<JwtToken>()
if (result.isSuccess) {
onSuccessfulLogin(result.getOrThrow().token)
} else {
result.exceptionOrNull()?.run {
title = this.message ?: this.cause.toString()
}
}
}
}
) {
Text(
text = "LOGIN",
style = MaterialTheme.typography.button
)
}
}
}
/**
* A stylized TextField used for the login screen.
*
* @param value The input text to be shown in the text field
* @param onValueChange The callback that is triggered when the input service updates the text.
* An updated text comes as a parameter of the callback
*/
@Composable
private fun LoginTextField(
value: String,
label: String,
placeholder: String,
onValueChange: (String) -> Unit,
) {
OutlinedTextField(
value = value,
onValueChange = onValueChange,
colors = TextFieldDefaults.textFieldColors(
backgroundColor = MaterialTheme.colors.background
),
label = {
Text(text = label)
},
placeholder = {
Text(text = placeholder)
}
)
}
| Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/ui/login/LoginScreen.kt | 2192816239 |
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material.MaterialTheme
import androidx.compose.runtime.*
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.Modifier
import org.jetbrains.compose.ui.tooling.preview.Preview
import ui.login.LoginScreen
import ui.viewmodel.login.LoginViewModel
/**
* The share UI entry point for the app
*
* @param loginViewModel The ViewModel responsible for logging in Users.
*/
@Composable
@Preview
internal fun App(loginViewModel: LoginViewModel) {
// This is not at all an acceptable practice, done purely out of convenience
// Please never do this in a production app.
var token by rememberSaveable {
mutableStateOf("")
}
var isChatVisible by remember {
mutableStateOf(false)
}
if (!isChatVisible) {
LoginScreen(
loginViewModel = loginViewModel,
modifier = Modifier.fillMaxSize()
.background(
color = MaterialTheme.colors.background
)
) {
token = it
isChatVisible = true
}
} else {
//TODO()
}
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/App.kt | 652540607 |
package networking
import io.ktor.client.call.*
import io.ktor.client.statement.*
import io.ktor.http.*
/**
* A convenience method used to deserialize an HttpResponse body.
*
* @receiver Ktor's HttpResponse.
*
* @return The deserialized body wrapped in Kotlin's result class if the attempt to deserialize was
* successful, a [Throwable] wrapped in a result otherwise
*/
internal suspend inline fun <reified T> HttpResponse.deserializeBody(): Result<T> {
return try {
if (this.status == HttpStatusCode.OK) {
val deserializedBody = this.body<T>()
Result.success(deserializedBody)
} else {
Result.failure(Throwable(message = this.status.description))
}
} catch (exception: Exception) {
Result.failure(exception)
}
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/networking/Extensions.kt | 971466557 |
package networking.resources
import io.ktor.resources.*
import kotlinx.serialization.Serializable
@Serializable
@Resource("/")
class ServerResources {
@Serializable
@Resource("login")
class Login
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/networking/resources/ServerResources.kt | 2144490162 |
package networking
import SERVER_HOST
import SERVER_PORT
import io.ktor.client.*
import io.ktor.client.plugins.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.plugins.resources.*
import io.ktor.serialization.kotlinx.json.*
/**
* The HttpClient used for network calls.
*/
val httpClient by lazy(::createHttpClient)
/**
* Creates and sets up an HttpClient.
*
* @return An instance of the HttpClient.
*/
private fun createHttpClient(): HttpClient = HttpClient {
install(Resources)
install(DefaultRequest) {
url("http://$SERVER_HOST:$SERVER_PORT")
}
install(ContentNegotiation) {
json()
}
}
| Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/networking/HttpClient.kt | 2140685037 |
package networking.model
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
/**
* Represents a successful login response containing the user's JWT.
*
* @property token The user's JWT.
*/
@Serializable
data class JwtToken(
@SerialName("token")
val token: String
) | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/networking/model/JwtToken.kt | 2880345956 |
package networking.login
import data.model.User
import io.ktor.client.plugins.resources.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import networking.httpClient
import networking.resources.ServerResources
/**
* An API dedicated to the user login process.
*/
internal interface LoginApi {
/**
* Logs the user in and returns a JWT.
*
* @param user The user to be logged in
*
* @return The user's JWT.
*/
suspend fun login(user: User): HttpResponse
}
/**
* A concrete class used to log users in.
* The implementation class for [LoginApi].
*/
internal class LoginApiImpl : LoginApi {
/**
* Logs the user in and returns a JWT.
*
* @param user The user to be logged in
*
* @return The user's JWT.
*/
override suspend fun login(user: User): HttpResponse =
httpClient.post(resource = ServerResources.Login()) {
contentType(ContentType.Application.Json)
setBody(user)
}.call.response
}
| Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/networking/login/LoginApi.kt | 957200705 |
package data.model
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
/**
* Represents a user's login information.
*
* @property username The username a user uses to log-in.
* @property password The password the user uses to log-in.
*/
@Serializable
internal data class User(
@SerialName("username")
val username: String,
@SerialName("password")
val password: String,
) | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/commonMain/kotlin/data/model/User.kt | 1005498066 |
package ui.viewmodel
import ui.viewmodel.login.LoginViewModel
/**
* An instance of the login ViewModel.
*/
internal val loginViewModel by lazy { LoginViewModel() } | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/desktopMain/kotlin/ui/viewmodel/ViewModelInstances.kt | 2360619959 |
package ui.viewmodel.login
import data.model.User
import io.ktor.client.statement.*
import networking.login.LoginApiImpl
/**
* A ViewModel designed to handle user login.
*/
internal actual class LoginViewModel : LoginViewModelContract {
/**
* Handles user login.
*/
private val loginApiImpl = LoginApiImpl()
/**
* Logs the user in and returns a JWT.
*
* @param username The username of the user to be logged in
* @param password The password of the user to be logged in
*
* @return The user's JWT.
*/
override suspend fun login(username: String, password: String): HttpResponse =
loginApiImpl.login(User(username, password))
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/desktopMain/kotlin/ui/viewmodel/login/LoginViewModel.kt | 3931415851 |
import androidx.compose.ui.window.Window
import androidx.compose.ui.window.application
import ui.viewmodel.loginViewModel
fun main() = application {
Window(onCloseRequest = ::exitApplication, title = "ChatSample") {
App(loginViewModel = loginViewModel)
}
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/desktopMain/kotlin/main.kt | 1756366717 |
package ui.viewmodel
import ui.viewmodel.login.LoginViewModel
/**
* An instance of the login ViewModel.
*/
internal val loginViewModel by lazy { LoginViewModel() } | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/wasmJsMain/kotlin/ui/viewmodel/ViewModelInstances.kt | 2360619959 |
package ui.viewmodel.login
import data.model.User
import io.ktor.client.statement.*
import networking.login.LoginApiImpl
/**
* A ViewModel designed to handle user login.
*/
internal actual class LoginViewModel : LoginViewModelContract {
/**
* Handles user login.
*/
private val loginApiImpl = LoginApiImpl()
/**
* Logs the user in and returns a JWT.
*
* @param username The username of the user to be logged in
* @param password The password of the user to be logged in
*
* @return The user's JWT.
*/
override suspend fun login(username: String, password: String): HttpResponse =
loginApiImpl.login(User(username, password))
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/wasmJsMain/kotlin/ui/viewmodel/login/LoginViewModel.kt | 815702232 |
import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.window.CanvasBasedWindow
import ui.viewmodel.loginViewModel
@OptIn(ExperimentalComposeUiApi::class)
fun main() {
CanvasBasedWindow(canvasElementId = "ComposeTarget") {
App(loginViewModel = loginViewModel)
}
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/wasmJsMain/kotlin/main.kt | 811973051 |
package ui.viewmodel.login
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import data.model.User
import io.ktor.client.statement.*
import networking.login.LoginApiImpl
/**
* A ViewModel designed to handle user login.
*/
internal actual class LoginViewModel : ViewModel(), LoginViewModelContract {
/**
* Handles user login.
*/
private val loginApiImpl = LoginApiImpl()
/**
* Logs the user in and returns a JWT.
*
* @param username The username of the user to be logged in
* @param password The password of the user to be logged in
*
* @return The user's JWT.
*/
override suspend fun login(username: String, password: String): HttpResponse =
loginApiImpl.login(User(username, password))
companion object {
val factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
LoginViewModel()
}
}
}
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/androidMain/kotlin/ui/viewmodel/login/LoginViewModel.android.kt | 1121660370 |
package hr.marintolic.chatsample
import App
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import ui.viewmodel.login.LoginViewModel
class MainActivity : ComponentActivity() {
private val loginViewModel by viewModels<LoginViewModel> { LoginViewModel.factory }
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
App(loginViewModel = loginViewModel)
}
}
} | Chat-Sample-Ktor-Compose-Multiplatform/composeApp/src/androidMain/kotlin/hr/marintolic/chatsample/MainActivity.kt | 919126086 |
package feature
import org.springframework.boot.autoconfigure.SpringBootApplication
@SpringBootApplication(
scanBasePackages = [
"global.search.pretask.app",
"global.search.pretask.api",
"global.search.pretask.domain",
"global.search.pretask.service",
"global.search.pretask.persistence",
"feature"
],
)
class FeatureTestApplication
| search-project/app/src/test/kotlin/feature/FeatureTestApplication.kt | 3159748022 |
package feature
import com.fasterxml.jackson.databind.ObjectMapper
import global.search.pretask.api.kakao.KakaoApi
import global.search.pretask.api.naver.NaverApi
import global.search.pretask.persistence.redis.SearchKeywordRedisRepository
import io.mockk.mockk
import jakarta.persistence.EntityManager
import jakarta.persistence.PersistenceContext
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Import
import org.springframework.context.annotation.Primary
import org.springframework.test.context.ActiveProfiles
import org.springframework.test.web.servlet.MockMvc
import org.springframework.transaction.annotation.Transactional
@SpringBootTest(
properties = [
"spring.jpa.show-sql=true",
],
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT
)
@ActiveProfiles("featuretest")
@AutoConfigureTestDatabase
@AutoConfigureMockMvc
@Transactional
@Import(FeatureTest.Companion.MockkServiceConfiguration::class)
abstract class FeatureTest {
@Autowired
lateinit var mockMvc: MockMvc
@Autowired
lateinit var objectMapper: ObjectMapper
@PersistenceContext
lateinit var em: EntityManager
companion object {
@TestConfiguration
class MockkServiceConfiguration {
@Bean
@Primary
fun kakaoApi() = mockk<KakaoApi>()
@Bean
@Primary
fun naverApi() = mockk<NaverApi>()
@Bean
@Primary
fun searchKeywordRedisRepository() = mockk<SearchKeywordRedisRepository>()
}
}
} | search-project/app/src/test/kotlin/feature/FeatureTest.kt | 2583124767 |
package feature.feature
import feature.FeatureTest
import global.search.pretask.api.kakao.KakaoApi
import global.search.pretask.api.naver.NaverApi
import global.search.pretask.domain.model.external.kakao.transfer.response.Document
import global.search.pretask.domain.model.external.kakao.transfer.response.KakaoBlogSearchResponse
import global.search.pretask.domain.model.external.kakao.transfer.response.Meta
import global.search.pretask.domain.model.external.naver.transfer.response.Item
import global.search.pretask.domain.model.external.naver.transfer.response.NaverBlogSearchResponse
import global.search.pretask.persistence.redis.SearchKeywordRedisRepository
import io.mockk.every
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
import reactor.core.publisher.Mono
class SearchFeatureTest: FeatureTest() {
private val baseUrl = "/v1/search"
@Autowired
lateinit var kakaoApi: KakaoApi
@Autowired
lateinit var naverApi: NaverApi
@Autowired
lateinit var searchKeywordRedisRepository: SearchKeywordRedisRepository
@Nested
@DisplayName("์กฐํ ํ
์คํธ")
inner class SearchTest {
@Test
@DisplayName("๋ธ๋ก๊ทธ ์กฐํ ์คํจ - query ํ์๊ฐ ์์ ๊ฒฝ์ฐ")
fun searchBlogFailTestByInavlidRequest() {
// When & Then
mockMvc.perform(get("$baseUrl/blog"))
.andExpect(status().isBadRequest)
}
@Test
@DisplayName("๋ธ๋ก๊ทธ ์กฐํ ์คํจ - enum type ๋ถ์ผ์น")
fun searchBlogFailTestByInavlidRequest2() {
// When & Then
mockMvc.perform(get("$baseUrl/blog")
.queryParam("query", "test")
.queryParam("sort", "invalid-value") // enum type ๋ถ์ผ์น
)
.andExpect(status().isBadRequest)
}
@Test
@DisplayName("๋ธ๋ก๊ทธ ์กฐํ - by ์นด์นด์ค")
fun searchBlogTestByKakao() {
// Given
val response = this.makeKakaoResponse()
val jsonStr = objectMapper.writeValueAsString(response)
every { kakaoApi.searchBlog(any(), any(), any(), any()) } returns Mono.just(jsonStr)
every { searchKeywordRedisRepository.save(any(), any()) } returnsArgument 0
every { searchKeywordRedisRepository.increaseCount(any()) } returnsArgument 0
// When & Then
mockMvc.perform(get("$baseUrl/blog").queryParam("query", "test"))
.andExpect(status().isOk)
.andExpect(jsonPath("$.payload.contents[0].title").value("test-title"))
}
@Test
@DisplayName("๋ธ๋ก๊ทธ ์กฐํ - by ๋ค์ด๋ฒ")
fun searchBlogTestByNaver() {
// Given
val response = this.makeNaverResponse()
val jsonStr = objectMapper.writeValueAsString(response)
// kakao exception ๊ฐ์ ๋ฐ์ ํ์ฌ Naver API ํธ์ถ
every { kakaoApi.searchBlog(any(), any(), any(), any()) } returns Mono.error { Exception() }
every { naverApi.searchBlog(any(), any(), any(), any()) } returns Mono.just(jsonStr)
every { searchKeywordRedisRepository.save(any(), any()) } returnsArgument 0
every { searchKeywordRedisRepository.increaseCount(any()) } returnsArgument 0
// When & Then
mockMvc.perform(get("$baseUrl/blog").queryParam("query", "test"))
.andExpect(status().isOk)
.andExpect(jsonPath("$.payload.contents[0].title").value("test-title-n"))
}
@Test
@DisplayName("๋ธ๋ก๊ทธ ์กฐํ ์คํจ - naver & kakao api ํธ์ถ ์๋ฌ")
fun searchBlogFailTestByExternalApiCallError() {
// kakao exception ๊ฐ์ ๋ฐ์ ํ์ฌ Naver API ํธ์ถ
every { kakaoApi.searchBlog(any(), any(), any(), any()) } returns Mono.error { Exception() }
every { naverApi.searchBlog(any(), any(), any(), any()) } returns Mono.error { Exception() }
every { searchKeywordRedisRepository.save(any(), any()) } returnsArgument 0
every { searchKeywordRedisRepository.increaseCount(any()) } returnsArgument 0
// When & Then
mockMvc.perform(get("$baseUrl/blog").queryParam("query", "test"))
.andExpect(status().is5xxServerError)
}
@Test
@DisplayName("์ธ๊ธฐ ๊ฒ์์ด ์กฐํ")
fun getPopularKeywordTest() {
// Given
val mockkResult = listOf("test1" to "6.0", "test2" to "4.0", "test3" to "2.0")
every { searchKeywordRedisRepository.getRankKeyword(any(), any()) } returns mockkResult
// When & Then
mockMvc.perform(get("$baseUrl/popular-keyword"))
.andExpect(status().isOk)
.andExpect(jsonPath("$.payload[0].keyword").value("test1"))
.andExpect(jsonPath("$.payload[1].keyword").value("test2"))
}
private fun makeKakaoResponse(): KakaoBlogSearchResponse {
val document = Document(
blogname = "test-blogname",
contents = "test-contents",
datetime = "2023-12-14T11:24:00.000+09:00",
thumbnail = "test-thumbnail",
title = "test-title",
url = "https://blog.test"
)
val meta = Meta(isEnd = false, pageableCount = 100, totalCount = 200)
return KakaoBlogSearchResponse(documents = listOf(document), meta = meta)
}
private fun makeNaverResponse(): NaverBlogSearchResponse {
return NaverBlogSearchResponse(
lastBuildDate = "Thu, 21 Dec 2023 22:54:52 +0900",
total = 100,
start = 1,
display = 10,
items = listOf(
Item(
title = "test-title-n",
link = "https://blog.test",
description = "test-description",
bloggername = "test-bloggername",
bloggerlink = "https://blog.test",
postdate = "20231214"
)
)
)
}
}
} | search-project/app/src/test/kotlin/feature/feature/SearchFeatureTest.kt | 3962063823 |
package global.search.pretask.app.config.database
import global.search.pretask.persistence.config.PersistenceConfig
import org.springframework.boot.autoconfigure.domain.EntityScan
import org.springframework.context.annotation.Configuration
import org.springframework.data.jpa.repository.config.EnableJpaRepositories
@Configuration
@EntityScan(basePackages = ["global.search.pretask.domain"])
@EnableJpaRepositories(basePackages = ["global.search.pretask.persistence"])
class JpaConfiguration: PersistenceConfig() {} | search-project/app/src/main/kotlin/global/search/pretask/app/config/database/JpaConfiguration.kt | 1978310935 |
package global.search.pretask.app.config
import org.springframework.boot.convert.ApplicationConversionService
import org.springframework.context.annotation.Configuration
import org.springframework.format.FormatterRegistry
import org.springframework.web.servlet.config.annotation.EnableWebMvc
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
@EnableWebMvc
@Configuration
class WebMvcConfig : WebMvcConfigurer {
override fun addFormatters(registry: FormatterRegistry) {
ApplicationConversionService.configure(registry)
}
} | search-project/app/src/main/kotlin/global/search/pretask/app/config/WebMvcConfig.kt | 2336789293 |
package global.search.pretask.app.config
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.connection.RedisConnectionFactory
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.core.StringRedisTemplate
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories
import org.springframework.data.redis.serializer.StringRedisSerializer
@Configuration
@EnableRedisRepositories(basePackages = ["global.search.pretask.persistence.redis"])
class RedisConfig(
@Value("\${spring.cache.redis.host}")
private var host: String,
@Value("\${spring.cache.redis.port}")
private var port: String
) {
@Bean
fun redisConnectionFactory(): RedisConnectionFactory? {
return LettuceConnectionFactory(host, port.toInt())
}
@Bean
fun redisTemplate(): RedisTemplate<*, *>? {
val redisTemplate = RedisTemplate<ByteArray, ByteArray>()
redisTemplate.connectionFactory = redisConnectionFactory()
redisTemplate.keySerializer = StringRedisSerializer()
redisTemplate.valueSerializer = StringRedisSerializer()
return redisTemplate
}
@Bean("searchKeywordRedisTemplate")
fun stringRedisTemplate(): StringRedisTemplate? {
val stringRedisTemplate = StringRedisTemplate()
stringRedisTemplate.keySerializer = StringRedisSerializer()
stringRedisTemplate.valueSerializer = StringRedisSerializer()
stringRedisTemplate.connectionFactory = redisConnectionFactory()
return stringRedisTemplate
}
}
| search-project/app/src/main/kotlin/global/search/pretask/app/config/RedisConfig.kt | 1332182256 |
package global.search.pretask.app.config
import io.swagger.v3.oas.annotations.OpenAPIDefinition
import io.swagger.v3.oas.annotations.info.Info
import io.swagger.v3.oas.models.OpenAPI
import io.swagger.v3.oas.models.servers.Server
import org.springdoc.core.models.GroupedOpenApi
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@OpenAPIDefinition(
info = Info(
title = "search-pretask api service",
version = "v1",
description = "swagger api interface"
)
)
@Configuration
class OpenApiConfig {
@Bean
fun openAPI(@Value("\${server.servlet.context-path}") contextPath: String): OpenAPI {
return OpenAPI()
.addServersItem(Server().url(contextPath))
}
@Bean
fun openApi(): GroupedOpenApi? {
val path: Array<String> = arrayOf("/v1/**")
return GroupedOpenApi.builder()
.group("service-api")
.pathsToMatch(*path)
.build()
}
} | search-project/app/src/main/kotlin/global/search/pretask/app/config/OpenApiConfig.kt | 3027351642 |
package global.search.pretask.app.config
import io.netty.channel.ChannelOption
import io.netty.handler.timeout.ReadTimeoutHandler
import io.netty.handler.timeout.WriteTimeoutHandler
import io.netty.resolver.DefaultAddressResolverGroup
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.http.client.reactive.ReactorClientHttpConnector
import org.springframework.http.client.reactive.ReactorResourceFactory
import org.springframework.web.reactive.function.client.WebClient
import reactor.netty.http.client.HttpClient
import java.time.Duration
@Configuration
class WebClientConfig {
@Bean
fun resourceFactory() = ReactorResourceFactory().apply {
isUseGlobalResources = false // (1)
}
@Bean
fun webClient(builder: WebClient.Builder): WebClient {
val httpClient = HttpClient.create()
.resolver(DefaultAddressResolverGroup.INSTANCE)
.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000)
.responseTimeout(Duration.ofMillis(5000))
.doOnConnected { conn -> conn
.addHandlerLast(ReadTimeoutHandler(5))
.addHandlerLast(WriteTimeoutHandler(5))
}
return builder.codecs {
it.defaultCodecs().maxInMemorySize(1024 * 1024 * 4)
}.clientConnector(ReactorClientHttpConnector(httpClient)).build()
}
} | search-project/app/src/main/kotlin/global/search/pretask/app/config/WebClientConfig.kt | 432376664 |
package global.search.pretask.app.facade
import global.search.pretask.domain.model.common.transfer.response.PagingMetaInfo
import global.search.pretask.domain.model.common.transfer.response.PagingResponse
import global.search.pretask.domain.model.search.entity.SearchKeyword
import global.search.pretask.domain.model.search.transfer.request.BlogSearchRequest
import global.search.pretask.domain.model.search.transfer.request.KeywordSearchRequest
import global.search.pretask.domain.model.search.transfer.response.BlogSearchResponse
import global.search.pretask.domain.model.search.transfer.response.KeywordSearchResponse
import global.search.pretask.service.search.SearchService
import org.springframework.data.domain.PageImpl
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
@Service
class SearchFacadeService(
private val searchService: SearchService,
) {
@Transactional(propagation = Propagation.REQUIRED)
fun searchBlog(
blogSearchRequest: BlogSearchRequest
): PagingResponse<BlogSearchResponse> {
val resultPage: PageImpl<BlogSearchResponse> = searchService.searchBlog(blogSearchRequest)
return PagingResponse.of(contents = resultPage.content, meta = PagingMetaInfo.pageToMeta(resultPage))
}
@Transactional(readOnly = true)
fun getPopularSearchKeyword(): List<Map<String, String>> {
val result: List<Pair<String, String>> = searchService.getRankKeyword(
start = 0,
end = 9 // ๋ฌธ์ ์ max 10๊ฐ
)
return result.map { (keyword, count) ->
mapOf("keyword" to keyword, "count" to count.toDouble().toLong().toString()) // score ์ ์๋ก ์นํ
}
}
@Transactional(readOnly = true)
fun getSearchKeywordList(keywordSearchRequest: KeywordSearchRequest): PagingResponse<KeywordSearchResponse> {
val resultPage: PageImpl<SearchKeyword> = searchService.getSearchKeywordList(keywordSearchRequest)
val contents = resultPage.content.map { KeywordSearchResponse(keyword = it.keyword, count = it.count) }
return PagingResponse.of(contents = contents, meta = PagingMetaInfo.pageToMeta(resultPage))
}
} | search-project/app/src/main/kotlin/global/search/pretask/app/facade/SearchFacadeService.kt | 3677323453 |
package global.search.pretask.app.controller.v1.impl
import global.search.pretask.app.facade.SearchFacadeService
import global.search.pretask.domain.model.common.transfer.response.HttpResponse
import global.search.pretask.domain.model.common.transfer.response.PagingResponse
import global.search.pretask.domain.model.search.transfer.request.BlogSearchRequest
import global.search.pretask.domain.model.search.transfer.request.KeywordSearchRequest
import global.search.pretask.domain.model.search.transfer.response.BlogSearchResponse
import global.search.pretask.domain.model.search.transfer.response.KeywordSearchResponse
import org.springdoc.core.annotations.ParameterObject
import org.springframework.data.domain.Pageable
import org.springframework.data.web.PageableDefault
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController
@RestController
@RequestMapping("/v1/search")
class SearchControllerImpl(
private val searchFacadeService: SearchFacadeService,
) {
@GetMapping("/blog")
fun searchBlog(
@ParameterObject blogSearchRequest: BlogSearchRequest
): ResponseEntity<HttpResponse<PagingResponse<BlogSearchResponse>>> {
val response = searchFacadeService.searchBlog(blogSearchRequest)
return ResponseEntity.ok().body(HttpResponse.ofSuccess(response))
}
@GetMapping("/popular-keyword")
fun getPopularSearchKeyword(): ResponseEntity<HttpResponse<List<Map<String, String>>>> {
val response = searchFacadeService.getPopularSearchKeyword()
return ResponseEntity.ok().body(HttpResponse.ofSuccess(response))
}
@GetMapping("/keyword-list")
fun getSearchKeywordList(
@RequestParam(required = false) keyword: String?,
@ParameterObject @PageableDefault(size = 10, page = 0) pageable: Pageable,
): ResponseEntity<HttpResponse<PagingResponse<KeywordSearchResponse>>> {
val keywordSearchRequest = KeywordSearchRequest(keyword = keyword, pageable = pageable)
val response = searchFacadeService.getSearchKeywordList(keywordSearchRequest)
return ResponseEntity.ok().body(HttpResponse.ofSuccess(response))
}
} | search-project/app/src/main/kotlin/global/search/pretask/app/controller/v1/impl/SearchControllerImpl.kt | 2240699751 |
package global.search.pretask.app
import jakarta.annotation.PostConstruct
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.scheduling.annotation.EnableAsync
import java.time.ZoneOffset
import java.util.*
@SpringBootApplication(
scanBasePackages = [
"global.search.pretask.app",
"global.search.pretask.domain",
"global.search.pretask.service",
"global.search.pretask.persistence",
"global.search.pretask.api",
]
)
class AppApplication {
@PostConstruct
fun init() {
// timezone - UTC๋ก ํ์ฌ ์ค์
TimeZone.setDefault(TimeZone.getTimeZone(ZoneOffset.UTC.id))
}
}
fun main(args: Array<String>) {
runApplication<AppApplication>(*args)
}
| search-project/app/src/main/kotlin/global/search/pretask/app/AppApplication.kt | 3025097560 |
package global.search.pretask.app.exception
import global.search.pretask.domain.model.common.transfer.response.ErrorMessage
import global.search.pretask.domain.model.common.transfer.response.HttpResponse
import global.search.pretask.domain.model.exception.HttpException
import global.search.pretask.domain.model.exception.type.ErrorMessageType
import org.slf4j.LoggerFactory
import org.springframework.http.HttpStatus
import org.springframework.http.MediaType
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.MethodArgumentNotValidException
import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.RestControllerAdvice
@RestControllerAdvice
class GlobalExceptionHandler {
@ExceptionHandler(HttpException::class)
fun handleHttpException(e: HttpException): ResponseEntity<HttpResponse<Any?>> {
return ResponseEntity
.status(e.statusCode)
.contentType(MediaType.APPLICATION_JSON)
.body(HttpResponse.ofFail(ErrorMessage(e.code, e.message)))
}
@ExceptionHandler(MethodArgumentNotValidException::class)
fun handleMethodArgumentNotValidException(e: MethodArgumentNotValidException): ResponseEntity<HttpResponse<Any?>> {
val error = ErrorMessage(
code = ErrorMessageType.INVALID_REQUEST.code,
message = e.bindingResult.fieldError?.defaultMessage ?: ErrorMessageType.INVALID_REQUEST.message
)
return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.contentType(MediaType.APPLICATION_JSON)
.body(HttpResponse.ofFail(error))
}
@ExceptionHandler(Throwable::class)
fun handleThrowable(cause: Throwable?): ResponseEntity<*>? {
val error = ErrorMessage(
code = ErrorMessageType.INTERNAL_SERVER_ERROR.code,
message = ErrorMessageType.INTERNAL_SERVER_ERROR.message
)
return ResponseEntity
.status(HttpStatus.INTERNAL_SERVER_ERROR)
.contentType(MediaType.APPLICATION_JSON)
.body(HttpResponse.ofFail(error))
}
companion object {
private val logger = LoggerFactory.getLogger(this::class.java)
}
}
| search-project/app/src/main/kotlin/global/search/pretask/app/exception/GlobalExceptionHandler.kt | 833254019 |
package global.search.pretask.common.utils
import java.time.Instant
import java.time.LocalDateTime
import java.time.ZoneId
import java.time.format.DateTimeFormatter
object DateUtils {
private const val YYYYMMDD_FORMAT = "yyyyMMdd"
fun to(str: String): String {
val instant = Instant.parse(str)
val localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault())
val formatter = DateTimeFormatter.ofPattern(YYYYMMDD_FORMAT)
return localDateTime.format(formatter)
}
} | search-project/common/src/main/kotlin/global/search/pretask/common/utils/DateUtils.kt | 1875001832 |
package global.search.pretask.persistence.config
import com.querydsl.jpa.impl.JPAQueryFactory
import jakarta.persistence.EntityManager
import jakarta.persistence.PersistenceContext
import org.springframework.context.annotation.Bean
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
import javax.sql.DataSource
open class PersistenceConfig {
@PersistenceContext
lateinit var em: EntityManager
@Bean
open fun jpaQueryFactory(): JPAQueryFactory {
return JPAQueryFactory(em)
}
@Bean
open fun namedJdbcTemplate(ds: DataSource): NamedParameterJdbcTemplate {
return NamedParameterJdbcTemplate(ds)
}
} | search-project/persistence/src/main/kotlin/global/search/pretask/persistence/config/PersistenceConfig.kt | 3364993227 |
package global.search.pretask.persistence.redis.impl
import global.search.pretask.persistence.redis.SearchKeywordRedisRepository
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.core.ZSetOperations
import org.springframework.stereotype.Repository
@Repository
class SearchKeywordRedisRepositoryImpl(
@Qualifier("searchKeywordRedisTemplate")
private val redisTemplate: RedisTemplate<String, String>
): SearchKeywordRedisRepository {
override fun save(keyword: String, count: Long) {
val opsForZSet = redisTemplate.opsForZSet()
try {
opsForZSet.add(KEYWORD_COUNT_PREFIX, keyword, count.toDouble())
} catch (ex: Exception) {
logger.error(ex.message, ex)
}
}
override fun increaseCount(keyword: String) {
val opsForZSet = redisTemplate.opsForZSet()
try {
opsForZSet.incrementScore(KEYWORD_COUNT_PREFIX, keyword, 1.0)
} catch (ex: Exception) {
logger.error(ex.message, ex)
}
}
override fun getRankKeyword(start: Long, end: Long): List<Pair<String, String>> {
val opsForZSet = redisTemplate.opsForZSet()
var result = emptyList<Pair<String, String>>()
try {
val resultSet: MutableSet<ZSetOperations.TypedTuple<String>>? = opsForZSet.reverseRangeWithScores(KEYWORD_COUNT_PREFIX, start, end)
result = resultSet?.map { typedTuple ->
typedTuple.value!! to typedTuple.score.toString() }!!
} catch (ex: Exception) {
logger.error(ex.message, ex)
}
return result
}
companion object {
const val KEYWORD_COUNT_PREFIX = "keyword:count:"
private val logger = LoggerFactory.getLogger(this::class.java)
}
} | search-project/persistence/src/main/kotlin/global/search/pretask/persistence/redis/impl/SearchKeywordRedisRepositoryImpl.kt | 4233166006 |
package global.search.pretask.persistence.redis
interface SearchKeywordRedisRepository {
fun save(keyword: String, count: Long)
fun increaseCount(keyword: String)
fun getRankKeyword(start: Long, end: Long): List<Pair<String, String>>
} | search-project/persistence/src/main/kotlin/global/search/pretask/persistence/redis/SearchKeywordRedisRepository.kt | 1535135788 |
package global.search.pretask.persistence.jpa.impl
import com.querydsl.core.types.dsl.BooleanExpression
import com.querydsl.jpa.impl.JPAQuery
import com.querydsl.jpa.impl.JPAQueryFactory
import global.search.pretask.domain.model.search.entity.QSearchKeyword
import global.search.pretask.domain.model.search.entity.SearchKeyword
import global.search.pretask.domain.model.search.transfer.request.KeywordSearchRequest
import global.search.pretask.persistence.jpa.custom.SearchKeywordRepositoryCustom
import org.springframework.data.domain.PageImpl
import org.springframework.stereotype.Repository
@Repository
class SearchKeywordRepositoryImpl(
private val jpaQueryFactory: JPAQueryFactory
): SearchKeywordRepositoryCustom {
private val qSearchKeyword: QSearchKeyword = QSearchKeyword.searchKeyword
override fun findSearchKeywordList(keywordSearchRequest: KeywordSearchRequest): PageImpl<SearchKeyword> {
val query = this.makeWhereQuery(keywordSearchRequest)
val pagedQuery = query.clone()
.select(qSearchKeyword)
.orderBy(qSearchKeyword.id.desc())
.offset(keywordSearchRequest.pageable.offset)
.limit(keywordSearchRequest.pageable.pageSize.toLong())
val content = pagedQuery.clone()
.fetch()
val count = query.clone()
.select(qSearchKeyword.count())
.fetchFirst()
return PageImpl(content, keywordSearchRequest.pageable, count)
}
private fun makeWhereQuery(keywordSearchRequest: KeywordSearchRequest): JPAQuery<*> {
return jpaQueryFactory.from(qSearchKeyword)
.apply {
where(
isEqAppGroupId(keywordSearchRequest.keyword),
)
}
}
private fun isEqAppGroupId(keyword: String?): BooleanExpression? {
if (keyword.isNullOrBlank()) {
return null
}
return qSearchKeyword.keyword.contains(keyword)
}
} | search-project/persistence/src/main/kotlin/global/search/pretask/persistence/jpa/impl/SearchKeywordRepositoryImpl.kt | 3012233657 |
package global.search.pretask.persistence.jpa
import global.search.pretask.domain.model.search.entity.SearchKeyword
import global.search.pretask.persistence.jpa.custom.SearchKeywordRepositoryCustom
import org.springframework.data.jpa.repository.JpaRepository
interface SearchKeywordRepository: JpaRepository<SearchKeyword, Long>, SearchKeywordRepositoryCustom {
fun findByKeyword(keyword: String): SearchKeyword?
} | search-project/persistence/src/main/kotlin/global/search/pretask/persistence/jpa/SearchKeywordRepository.kt | 1067180941 |
package global.search.pretask.persistence.jpa.custom
import global.search.pretask.domain.model.search.entity.SearchKeyword
import global.search.pretask.domain.model.search.transfer.request.KeywordSearchRequest
import org.springframework.data.domain.PageImpl
interface SearchKeywordRepositoryCustom {
fun findSearchKeywordList(keywordSearchRequest: KeywordSearchRequest): PageImpl<SearchKeyword>
} | search-project/persistence/src/main/kotlin/global/search/pretask/persistence/jpa/custom/SearchKeywordRepositoryCustom.kt | 2013544400 |
package global.search.pretask.api.naver.impl
import global.search.pretask.api.naver.NaverApi
import org.springframework.beans.factory.annotation.Value
import org.springframework.http.HttpMethod
import org.springframework.stereotype.Service
import org.springframework.web.reactive.function.client.WebClient
import reactor.core.publisher.Mono
@Service
class NaverApiImpl(
private val webClient: WebClient,
@Value("\${app.naver.api.domain}")
private val domain: String,
@Value("\${app.naver.api.client-id}")
private val clientId: String,
@Value("\${app.naver.api.client-secret}")
private val clientSecret: String,
): NaverApi {
override fun searchBlog(query: String, sort: String, display: Int, start: Int): Mono<String> {
val sort = when (sort) {
"accuracy" -> "sim"
"recency" -> "date"
else -> "sim" // default
}
return webClient.mutate().baseUrl(domain).build()
.method(HttpMethod.GET)
.uri { uriBuilder ->
uriBuilder
.queryParam("query", query)
.queryParam("sort", sort)
.queryParam("display", display)
.queryParam("start", start)
.build()
}
.header(CLIENT_ID_HEADER, clientId)
.header(CLIENT_SECRET_HEADER, clientSecret)
.retrieve()
.bodyToMono(String::class.java)
}
companion object {
const val CLIENT_ID_HEADER = "X-Naver-Client-Id"
const val CLIENT_SECRET_HEADER = "X-Naver-Client-Secret"
}
} | search-project/api/src/main/kotlin/global/search/pretask/api/naver/impl/NaverApiImpl.kt | 264844031 |
package global.search.pretask.api.naver
import reactor.core.publisher.Mono
interface NaverApi {
fun searchBlog(query: String, sort: String, display: Int, start: Int): Mono<String>
} | search-project/api/src/main/kotlin/global/search/pretask/api/naver/NaverApi.kt | 567604772 |
package global.search.pretask.api.kakao.impl
import global.search.pretask.api.kakao.KakaoApi
import org.springframework.beans.factory.annotation.Value
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpMethod
import org.springframework.stereotype.Service
import org.springframework.web.reactive.function.client.WebClient
import reactor.core.publisher.Mono
@Service
class KakaoApiImpl(
private val webClient: WebClient,
@Value("\${app.kakao.api.domain}")
private val domain: String,
@Value("\${app.kakao.api.api-key}")
private val apiKey: String,
): KakaoApi {
override fun searchBlog(query: String, sort: String, page: Int, size: Int): Mono<String> {
return webClient.mutate().baseUrl(domain).build()
.method(HttpMethod.GET)
.uri { uriBuilder ->
uriBuilder
.queryParam("query", query)
.queryParam("sort", sort)
.queryParam("page", page)
.queryParam("size", size)
.build()
}
.header(HttpHeaders.AUTHORIZATION, AUTHORIZATION_PREFIX + apiKey)
.retrieve()
.bodyToMono(String::class.java)
}
companion object {
const val AUTHORIZATION_PREFIX = "KakaoAK "
}
} | search-project/api/src/main/kotlin/global/search/pretask/api/kakao/impl/KakaoApiImpl.kt | 2255521640 |
package global.search.pretask.api.kakao
import reactor.core.publisher.Mono
interface KakaoApi {
fun searchBlog(query: String, sort: String, page: Int, size: Int): Mono<String>
} | search-project/api/src/main/kotlin/global/search/pretask/api/kakao/KakaoApi.kt | 1071940899 |
package global.search.pretask.service.search.impl
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue
import global.search.pretask.api.kakao.KakaoApi
import global.search.pretask.api.naver.NaverApi
import global.search.pretask.common.utils.DateUtils
import global.search.pretask.domain.model.exception.HttpException
import global.search.pretask.domain.model.exception.type.ErrorMessageType
import global.search.pretask.domain.model.external.kakao.transfer.response.KakaoBlogSearchResponse
import global.search.pretask.domain.model.external.naver.transfer.response.NaverBlogSearchResponse
import global.search.pretask.domain.model.search.entity.SearchKeyword
import global.search.pretask.domain.model.search.transfer.request.BlogSearchRequest
import global.search.pretask.domain.model.search.transfer.request.KeywordSearchRequest
import global.search.pretask.domain.model.search.transfer.response.BlogSearchResponse
import global.search.pretask.persistence.jpa.SearchKeywordRepository
import global.search.pretask.persistence.redis.SearchKeywordRedisRepository
import global.search.pretask.service.search.SearchService
import org.slf4j.LoggerFactory
import org.springframework.data.domain.PageImpl
import org.springframework.data.domain.PageRequest
import org.springframework.stereotype.Service
@Service
class SearchServiceImpl(
private val kakaoApi: KakaoApi,
private val naverApi: NaverApi,
private val objectMapper: ObjectMapper,
private val searchKeywordRepository: SearchKeywordRepository,
private val searchKeywordRedisRepository: SearchKeywordRedisRepository
): SearchService {
override fun searchBlog(
blogSearchRequest: BlogSearchRequest
): PageImpl<BlogSearchResponse> {
// ํ์ฌ๋ kakao & naver 2๊ฐ๋ง ์ฌ์ฉํ์ง๋ง ์ถํ ๋ค๋ฅธ API ์ถ๊ฐ ๋ ์ Boolean ๋ง๊ณ ๋ค๋ฅธ ๊ฒ์ผ๋ก ํ์ฉ
var isKakaoApi: Boolean = true
var jsonStr: String? = null
try {
jsonStr = kakaoApi.searchBlog(
query = blogSearchRequest.query,
sort = blogSearchRequest.sort!!.code.lowercase(),
page = blogSearchRequest.page!!,
size = blogSearchRequest.size!!
).doOnError { e ->
logger.error(e.message, e)
throw HttpException(ErrorMessageType.KAKAOAPI_ERROR)
}.block()
} catch (e: HttpException) {
if (e.code == ErrorMessageType.KAKAOAPI_ERROR.code) {
isKakaoApi = false
}
}
if (!isKakaoApi) {
jsonStr = naverApi.searchBlog(
query = blogSearchRequest.query,
sort = blogSearchRequest.sort!!.code.lowercase(),
start = blogSearchRequest.page!!,
display = blogSearchRequest.size!!
).doOnError { e ->
logger.error(e.message, e)
throw HttpException(ErrorMessageType.EXTERNALAPI_ERROR)
}.block()
}
val result: PageImpl<BlogSearchResponse> = when {
isKakaoApi -> {
this.convertKakaoResponseToPageImpl(
objectMapper.readValue<KakaoBlogSearchResponse>(jsonStr!!),
blogSearchRequest.page!!,
blogSearchRequest.size!!
)
}
else -> {
this.convertNaverResponseToPageImpl(
objectMapper.readValue<NaverBlogSearchResponse>(jsonStr!!)
)
}
}
// ๊ฒ์์ด ์ ์ฅ
this.recordSearchKeyword(blogSearchRequest.query)
return result
}
override fun recordSearchKeyword(keyword: String): SearchKeyword {
val searchKeyword = this.getSearchKeyword(keyword)
if (searchKeyword != null) {
searchKeyword.count += 1
return searchKeywordRepository.save(searchKeyword).also {
searchKeywordRedisRepository.increaseCount(keyword)
}
} else {
return searchKeywordRepository.save(SearchKeyword(keyword = keyword, count = 1L)).also {
searchKeywordRedisRepository.save(keyword, 1L)
}
}
}
override fun getSearchKeyword(keyword: String): SearchKeyword? {
return searchKeywordRepository.findByKeyword(keyword)
}
override fun getRankKeyword(start: Long, end: Long): List<Pair<String, String>> {
return searchKeywordRedisRepository.getRankKeyword(start, end)
}
override fun getSearchKeywordList(keywordSearchRequest: KeywordSearchRequest): PageImpl<SearchKeyword> {
return searchKeywordRepository.findSearchKeywordList(keywordSearchRequest)
}
private fun convertKakaoResponseToPageImpl(
kakaoResponse: KakaoBlogSearchResponse,
page: Int,
size: Int
): PageImpl<BlogSearchResponse> {
val meta = kakaoResponse.meta
val pageable = PageRequest.of(page, size)
return PageImpl(
kakaoResponse.documents.map {
BlogSearchResponse(
title = it.title,
url = it.url,
blogname = it.blogname,
datetime = DateUtils.to(it.datetime),
summary = it.contents,
)
}, pageable, meta.pageableCount.toLong())
}
private fun convertNaverResponseToPageImpl(
naverResponse: NaverBlogSearchResponse,
): PageImpl<BlogSearchResponse> {
val pageable = PageRequest.of(naverResponse.start, naverResponse.display)
return PageImpl(
naverResponse.items.map {
BlogSearchResponse(
title = it.title,
url = it.bloggerlink,
blogname = it.bloggername,
datetime = it.postdate,
summary = it.description,
)
}, pageable, naverResponse.total.toLong())
}
companion object {
val logger = LoggerFactory.getLogger(this::class.java)
}
} | search-project/service/src/main/kotlin/global/search/pretask/service/search/impl/SearchServiceImpl.kt | 2352905223 |
package global.search.pretask.service.search
import global.search.pretask.domain.model.search.entity.SearchKeyword
import global.search.pretask.domain.model.search.transfer.request.BlogSearchRequest
import global.search.pretask.domain.model.search.transfer.request.KeywordSearchRequest
import global.search.pretask.domain.model.search.transfer.response.BlogSearchResponse
import org.springframework.data.domain.PageImpl
interface SearchService {
fun searchBlog(blogSearchRequest: BlogSearchRequest): PageImpl<BlogSearchResponse>
fun recordSearchKeyword(keyword: String): SearchKeyword
fun getSearchKeyword(keyword: String): SearchKeyword?
fun getRankKeyword(start: Long, end: Long): List<Pair<String, String>>
fun getSearchKeywordList(keywordSearchRequest: KeywordSearchRequest): PageImpl<SearchKeyword>
} | search-project/service/src/main/kotlin/global/search/pretask/service/search/SearchService.kt | 671665081 |
package global.search.pretask.domain.model.search.entity
import global.search.pretask.domain.model.BaseEntity
import jakarta.persistence.*
import org.hibernate.annotations.Comment
@Entity
@Table(
name = "search_keyword",
indexes = [
Index(name = "uidx_sk_keyword", columnList = "keyword", unique = true),
]
)
@Comment("search keyword table")
class SearchKeyword(
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
var id: Long = 0L,
@Column(name = "keyword", nullable = false)
var keyword: String,
@Column(name = "count", nullable = false)
var count: Long,
): BaseEntity() | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/search/entity/SearchKeyword.kt | 3222905926 |
package global.search.pretask.domain.model.search.transfer.response
data class KeywordSearchResponse(
val keyword: String,
val count: Long,
)
| search-project/domain/src/main/kotlin/global/search/pretask/domain/model/search/transfer/response/KeywordSearchResponse.kt | 4284683260 |
package global.search.pretask.domain.model.search.transfer.response
import com.fasterxml.jackson.annotation.JsonProperty
data class BlogSearchResponse(
@JsonProperty("title")
val title: String,
@JsonProperty("url")
val url: String,
@JsonProperty("blogname")
val blogname: String,
@JsonProperty("datetime")
val datetime: String, // yyyyMMdd
@JsonProperty("summary")
val summary: String,
)
| search-project/domain/src/main/kotlin/global/search/pretask/domain/model/search/transfer/response/BlogSearchResponse.kt | 3979995256 |
package global.search.pretask.domain.model.search.transfer.request
import global.search.pretask.domain.model.search.type.SortType
import io.swagger.v3.oas.annotations.media.Schema
import jakarta.validation.constraints.NotBlank
@Schema(description = "๋ธ๋ก๊ทธ ๊ฒ์ ์์ฒญ ๊ฐ์ฒด", enumAsRef = true)
data class BlogSearchRequest(
@NotBlank
val query: String,
@Schema(description = "์ ๋ ฌ ํ์
", enumAsRef = true)
val sort: SortType? = SortType.ACCURACY,
val page: Int? = 1,
val size: Int? = 10,
) | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/search/transfer/request/BlogSearchRequest.kt | 1275502369 |
package global.search.pretask.domain.model.search.transfer.request
import org.springframework.data.domain.Pageable
data class KeywordSearchRequest(
val keyword: String? = null,
/** ํ์ด์ง **/
val pageable: Pageable,
)
| search-project/domain/src/main/kotlin/global/search/pretask/domain/model/search/transfer/request/KeywordSearchRequest.kt | 2587762259 |
package global.search.pretask.domain.model.search.type
import io.swagger.v3.oas.annotations.media.Schema
enum class SortType(
val code: String
) {
@Schema(description = "์ ํ๋์")
ACCURACY("ACCURACY"),
@Schema(description = "์ต์ ์")
RECENCY("RECENCY");
companion object {
operator fun invoke(code: String) = valueOf(code.uppercase())
}
} | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/search/type/SortType.kt | 248370919 |
package global.search.pretask.domain.model
import jakarta.persistence.Column
import jakarta.persistence.MappedSuperclass
import org.hibernate.annotations.CreationTimestamp
import org.hibernate.annotations.UpdateTimestamp
import java.time.Instant
@MappedSuperclass
abstract class BaseEntity {
@CreationTimestamp
@Column(name = "created_at", nullable = false)
var createdAt: Instant = Instant.now()
@UpdateTimestamp
@Column(name = "updated_at", nullable = false)
var updatedAt: Instant = Instant.now()
} | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/BaseEntity.kt | 2551071180 |
package global.search.pretask.domain.model.common.transfer.response
import io.swagger.v3.oas.annotations.media.Schema
import org.springframework.data.domain.PageImpl
@Schema(description = "ํ์ด์ง ๋ฉํ ์ ๋ณด")
data class PagingMetaInfo(
@Schema(description = "ํ์ด์ง ๋น ๋ฟ๋ ค์ค ์์ดํ
๊ฐฏ์ ")
val itemsPerPage: Int,
@Schema(description = "๊ฒ์๋ ์ ์ฒด ๋ฆฌ์คํธ count")
val totalItems: Int,
@Schema(description = "ํ์ฌ ํ์ด์ง")
val currentPage: Int,
@Schema(description = "๊ฒ์๋ ์ ์ฒด ๋ฆฌ์คํธ ํ์ด์ง ์ฌ์ด์ฆ")
val totalPages: Int,
) {
companion object {
/**
* page ๊ฐ์ฒด๋ฅผ PagingMetaInfo๋ก ๋ณํ
*/
fun <T> pageToMeta(pageImpl: PageImpl<T>) = PagingMetaInfo(
itemsPerPage = pageImpl.size,
totalItems = pageImpl.totalElements.toInt(),
currentPage = pageImpl.pageable.pageNumber,
totalPages = pageImpl.totalPages,
)
}
} | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/common/transfer/response/PagingMetaInfo.kt | 2224595821 |
package global.search.pretask.domain.model.common.transfer.response
import io.swagger.v3.oas.annotations.media.Schema
@Schema(description = "์๋ฌ response")
data class ErrorMessage(
@Schema(description = "์๋ฌ ์ฝ๋")
val code: Int,
@Schema(description = "์๋ฌ ๋ฉ์ธ์ง")
val message: String
) | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/common/transfer/response/ErrorMessage.kt | 1251646952 |
package global.search.pretask.domain.model.common.transfer.response
import io.swagger.v3.oas.annotations.media.Schema
@Schema(description = "Http Response ํ์ด์ง์ฉ ๊ฐ์ฒด")
data class PagingResponse<T>(
val contents: List<T>,
val meta: PagingMetaInfo,
) {
companion object {
@JvmStatic
fun <T> of(contents: List<T>, meta: PagingMetaInfo) = PagingResponse(contents = contents, meta = meta)
}
} | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/common/transfer/response/PagingResponse.kt | 870414901 |
package global.search.pretask.domain.model.common.transfer.response
import io.swagger.v3.oas.annotations.media.Schema
@Schema(description = "๊ณตํต HttpResponse ๊ฐ์ฒด")
data class HttpResponse<T>(
@Schema(description = "์๋ฌ๋ฐ์ ํ์ ๋์ ํํ๊ฐ์ฒด")
val error: ErrorMessage?,
@Schema(description = "์์ฒญ ์ฑ๊ณต์์ ์๋ต ๋ณธ๋ฌธ")
val payload: T
) {
companion object {
@JvmStatic
fun <T> ofSuccess(payload: T) = HttpResponse(error = null, payload = payload)
@JvmStatic
fun <T> ofSuccess(payload: PagingResponse<T>) = HttpResponse(error = null, payload = payload)
@JvmStatic
fun ofFail(error: ErrorMessage) = HttpResponse<Any?>(error = error, payload = null)
}
} | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/common/transfer/response/HttpResponse.kt | 4154334511 |
package global.search.pretask.domain.model.common.constant
class CommonConst {
companion object {
/** response code ๊ด๋ จ ์์ **/
const val SUCCESS_OK: String = "SUCCESS_OK"
const val INVALID_PARAMETER: String = "INVALID_PARAMETER"
const val AUTHORIZATION_FAILED: String = "AUTHORIZATION_FAILED"
const val RESOURCE_NOT_FOUND: String = "RESOURCE_NOT_FOUND"
const val UNEXPECTED_ERROR: String = "UNEXPECTED_ERROR"
const val CREATED: String = "CREATED"
const val CONFLICT: String = "CONFLICT"
}
} | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/common/constant/CommonConst.kt | 3835659482 |
package global.search.pretask.domain.model.external.naver.transfer.response
data class Item(
val title: String,
val link: String,
val description: String,
val bloggername: String,
val bloggerlink: String,
val postdate: String
) | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/external/naver/transfer/response/Item.kt | 2041400752 |
package global.search.pretask.domain.model.external.naver.transfer.response
data class NaverBlogSearchResponse(
val items: List<Item>,
val lastBuildDate: String,
val start: Int,
val display: Int,
val total: Int
) | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/external/naver/transfer/response/NaverBlogSearchResponse.kt | 4153718164 |
package global.search.pretask.domain.model.external.kakao.transfer.response
import com.fasterxml.jackson.annotation.JsonProperty
data class Document(
@JsonProperty("blogname")
val blogname: String,
@JsonProperty("contents")
val contents: String,
@JsonProperty("datetime")
val datetime: String,
@JsonProperty("thumbnail")
val thumbnail: String,
@JsonProperty("title")
val title: String,
@JsonProperty("url")
val url: String
)
| search-project/domain/src/main/kotlin/global/search/pretask/domain/model/external/kakao/transfer/response/Document.kt | 1546659963 |
package global.search.pretask.domain.model.external.kakao.transfer.response
import com.fasterxml.jackson.annotation.JsonProperty
data class Meta(
@JsonProperty("is_end")
val isEnd: Boolean,
@JsonProperty("pageable_count")
val pageableCount: Int,
@JsonProperty("total_count")
val totalCount: Int
)
| search-project/domain/src/main/kotlin/global/search/pretask/domain/model/external/kakao/transfer/response/Meta.kt | 1084943085 |
package global.search.pretask.domain.model.external.kakao.transfer.response
data class KakaoBlogSearchResponse(
val documents: List<Document>,
val meta: Meta
) | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/external/kakao/transfer/response/KakaoBlogSearchResponse.kt | 1284291879 |
package global.search.pretask.domain.model.exception.type
import org.springframework.http.HttpStatus
/**
* ์๋ฌ ๋ฉ์ธ์ง ์ฝ๋ ๋ฐ ํ์
์ ์
*/
enum class ErrorMessageType(
val code: Int,
val message: String,
val status: HttpStatus
) {
INTERNAL_SERVER_ERROR(1000, "Internal Server Error", HttpStatus.INTERNAL_SERVER_ERROR),
INVALID_REQUEST(1001, "Invalid Request", HttpStatus.BAD_REQUEST),
// external-api ๊ด๋ จ
EXTERNALAPI_ERROR(10000, "External API Call Error", HttpStatus.INTERNAL_SERVER_ERROR),
KAKAOAPI_ERROR(10001, "Kakao API Error", HttpStatus.INTERNAL_SERVER_ERROR),
// NAVERAPI_ERROR(10002, "Naver API Error", HttpStatus.INTERNAL_SERVER_ERROR),
} | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/exception/type/ErrorMessageType.kt | 3366771370 |
package global.search.pretask.domain.model.exception
import global.search.pretask.domain.model.exception.type.ErrorMessageType
import org.springframework.http.HttpStatus
import org.springframework.web.client.HttpStatusCodeException
class HttpException(
val code: Int,
val statusCode: HttpStatus,
override val message: String,
): HttpStatusCodeException(statusCode, message) {
constructor(errorType: ErrorMessageType, message: String = errorType.message): this(
code = errorType.code,
message = message,
statusCode = errorType.status
)
override fun toString(): String {
return "${statusCode}:E-${code}:${message}"
}
} | search-project/domain/src/main/kotlin/global/search/pretask/domain/model/exception/HttpException.kt | 32457084 |
package dev.sajidali.tvguide
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import dev.sajidali.demo.databinding.ActivityMainBinding
import dev.sajidali.guide.GuideView
import dev.sajidali.guide.data.Channel
import dev.sajidali.guide.data.DataProvider
import dev.sajidali.guide.data.Event
import java.util.concurrent.TimeUnit
import kotlin.random.Random
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
private val provider = object : DataProvider {
val events = HashMap<Int, List<Event>>()
val channels = (0..300).map { position ->
Channel(position, "Channel $position", "").also {
generateEvents(position)
}
}
private fun generateEvents(channel: Int) {
var startTime = System.currentTimeMillis() - TimeUnit.HOURS.toMillis(1)
events[channel] = (0..50).map {
val endTime =
Random.nextLong(startTime, startTime + TimeUnit.HOURS.toMillis(2))
Event(
it,
"Event $it",
"Description of event $it",
startTime,
endTime
).also {
startTime = endTime
}
}
}
override fun channelAt(position: Int): Channel {
return channels[position]
}
override fun eventsOfChannel(position: Int): Collection<Event> {
return events[position] ?: emptyList()
}
override fun eventOfChannelAt(channel: Int, position: Int): Event? {
return events[channel]?.get(position)
}
override fun size(): Int {
return 50
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
binding.guideView.apply {
setDataProvider(provider)
setEPGClickListener(object : GuideView.ClickListener {
override fun onChannelClicked(position: Int, channel: Channel?) {
// Handle channel click
Toast.makeText(
this@MainActivity,
"Channel ${channel?.title} clicked",
Toast.LENGTH_SHORT
).show()
}
override fun onEventSelected(channel: Channel?, program: Event?) {
// Handle event selection
binding.txtChannel.text = channel?.title
binding.txtEvent.text = program?.title
}
override fun onEventClicked(
channelPosition: Int,
programPosition: Int,
channel: Channel?,
program: Event?
) {
// Handle event click
Toast.makeText(
this@MainActivity,
"Event ${program?.title} clicked",
Toast.LENGTH_SHORT
).show()
}
override fun onEventLongClicked(
channelPosition: Int,
programPosition: Int,
channel: Channel?,
program: Event?
) {
// Handle event long click
Toast.makeText(
this@MainActivity,
"Event ${program?.title} long clicked",
Toast.LENGTH_SHORT
).show()
}
})
}
}
} | TV-Guide/app/src/main/java/dev/sajidali/tvguide/MainActivity.kt | 3420598883 |
package dev.sajidali.guide
import android.content.Context
import android.content.res.TypedArray
import android.graphics.drawable.ColorDrawable
import android.graphics.drawable.ColorStateListDrawable
import android.graphics.drawable.Drawable
import android.util.TypedValue
import androidx.core.content.res.getDrawableOrThrow
import dev.sajidali.guide.data.DataProvider
import org.joda.time.DateTimeZone
import org.joda.time.LocalDate
import org.joda.time.format.DateTimeFormat
fun Context.getThemedAttribute(id: Int): Int {
val tv = TypedValue()
theme.resolveAttribute(id, tv, true)
return tv.data
}
fun Long.formatToPattern(pattern: String): String {
return DateTimeFormat.forPattern(pattern).print(this)
}
fun Long.formatToPattern(pattern: String, timezone: String): String {
return DateTimeFormat.forPattern(pattern).withZone(DateTimeZone.forID(timezone)).print(this)
}
fun TypedArray.getColorOrDrawable(index: Int, default: Int = -1): Drawable? {
return try {
getDrawableOrThrow(index)
} catch (e: Throwable) {
ColorDrawable(getColor(index, default))
}
}
fun Long.toDayName(): String {
val date = LocalDate(this)
return date.dayOfWeek().asShortText + " " + date.dayOfMonth + "/" + date.monthOfYear
}
val <T> Collection<T>?.itemCount
get() = this?.size ?: 0
val DataProvider?.itemCount
get() = this?.size() ?: 0
val now: Long
get() = System.currentTimeMillis() | TV-Guide/tvguide/src/main/java/dev/sajidali/guide/Extensions.kt | 3980947145 |
package dev.sajidali.guide
import android.os.Parcelable
import android.view.View
/**
* Created by MVRM on 19/04/2017.
*/
class EPGState(superState: Parcelable) : View.BaseSavedState(superState) {
var currentEvent: Int = -1
}
| TV-Guide/tvguide/src/main/java/dev/sajidali/guide/EPGState.kt | 2093155740 |
package dev.sajidali.guide
import android.content.Context
import android.content.res.ColorStateList
import android.graphics.*
import android.graphics.drawable.ColorDrawable
import android.graphics.drawable.Drawable
import android.os.Parcelable
import android.util.AttributeSet
import android.view.GestureDetector
import android.view.KeyEvent
import android.view.MotionEvent
import android.view.ViewGroup
import android.widget.Scroller
import androidx.core.content.ContextCompat
import androidx.core.content.withStyledAttributes
import dev.sajidali.guide.data.Channel
import dev.sajidali.guide.data.DataProvider
import dev.sajidali.guide.data.Event
import org.joda.time.LocalDateTime
import java.util.concurrent.TimeUnit
import kotlin.math.*
class GuideView : ViewGroup {
constructor(context: Context) : super(context) {
init()
}
constructor(context: Context, attrs: AttributeSet? = null) : super(context, attrs) {
init(attrs)
}
constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = -1) : super(
context, attrs, defStyleAttr
) {
init(attrs, defStyleAttr)
}
constructor(
context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = -1, defStyleRes: Int = -1
) : super(
context, attrs, defStyleAttr, defStyleRes
) {
init(attrs, defStyleAttr, defStyleRes)
}
private var eventLayoutTextSize: Int
private var eventLayoutTextColor: ColorStateList?
private var dataProvider: DataProvider? = null
private var timeFormat: String = "HH:mm"
private val mClipRect: Rect
private val mDrawingRect: Rect
private val mMeasuringRect: Rect
private val mPaint: Paint
private val mScroller: Scroller
private val mGestureDetector: GestureDetector
private var mChannelLayoutMargin: Int
private var mChannelLayoutPadding: Int
private var mChannelLayoutHeight: Int
private var mChannelLayoutWidth: Int
private var mSelectedRowScale: Float = 1f
private var mChannelRowBackground: Drawable?
private var mEventBackground: Drawable?
private var mTimeBarLineWidth: Int
private var mTimeBarLineColor: Int
private var mTimeBarHeight: Int
private var mTimeBarTextSize: Int
private var mTimebarBackground: Drawable?
private var mHoursInViewPort: Long
private var mDaysBack: Long
private var mDaysForward: Long
private var mTimeSpacing: Long
private var screenWidth = 0
private var screenHeight = 0
private var mClickListener: ClickListener? = null
private var mMaxHorizontalScroll: Int = 0
private var mMaxVerticalScroll: Int = 0
private var mMillisPerPixel: Long = 0
private var mTimeOffset: Long = 0
private var mTimeLowerBoundary: Long = 0
private var mTimeUpperBoundary: Long = 0
private val loadThreshold: Int
get() {
val x = measuredHeight * 2
return mMaxVerticalScroll - x
}
override fun onScrollChanged(l: Int, t: Int, oldl: Int, oldt: Int) {
super.onScrollChanged(l, t, oldl, oldt)
// if (t > loadThreshold) {
// pagingDataDiffer.refresh()
// }
}
private var selectedEventPos: Int = -1
private var selectedChannelPos = 0
private val currentChannel: Channel?
get() {
return dataProvider?.let { provider ->
if (selectedChannelPos in 0 until provider.size()) {
provider.channelAt(selectedChannelPos)
} else null
}
}
private val selectedEvent: Event?
get() = dataProvider?.eventOfChannelAt(selectedChannelPos, selectedEventPos)
private var isEventHandled: Boolean = false
private var waitForLongClick: Boolean = false
private var isLongPressed = false
private val channelAreaWidth: Int
get() = mChannelLayoutWidth + mChannelLayoutPadding + mChannelLayoutMargin
private val programAreaWidth: Int
get() = width - channelAreaWidth
private val firstVisibleChannelPosition: Int
get() {
val y = scrollY + mTimeBarHeight
var position =
(y - mChannelLayoutMargin) / (mChannelLayoutHeight + mChannelLayoutMargin)
if (position < 0) {
position = 0
}
return position
}
private// Add one extra row if we don't fill screen with current..
val lastVisibleChannelPosition: Int
get() {
val y = scrollY
val totalChannelCount = dataProvider?.size() ?: 0
val screenHeight = height
var position =
(y + screenHeight + mTimeBarHeight - mChannelLayoutMargin) / (mChannelLayoutHeight + mChannelLayoutMargin)
if (position > totalChannelCount - 1) {
position = totalChannelCount - 1
}
return if (y + screenHeight > position * mChannelLayoutHeight && position < totalChannelCount - 1) position + 1 else position
}
private val xPositionStart: Int
get() = getXFrom(System.currentTimeMillis() - mHoursInViewPort / 2)
init {
setWillNotDraw(false)
mDrawingRect = Rect()
mClipRect = Rect()
mMeasuringRect = Rect()
mPaint = Paint(Paint.ANTI_ALIAS_FLAG)
mPaint.strokeWidth = 0.5f
mGestureDetector = GestureDetector(context, OnGestureListener())
// Adding some friction that makes the epg less flappy.
mScroller = Scroller(context)
mScroller.setFriction(0.2f)
mChannelLayoutMargin = resources.getDimensionPixelSize(R.dimen.gv_channel_layout_margin)
mChannelLayoutPadding = resources.getDimensionPixelSize(R.dimen.gv_channel_layout_padding)
mChannelLayoutHeight = resources.getDimensionPixelSize(R.dimen.gv_channel_layout_height)
mChannelLayoutWidth = resources.getDimensionPixelSize(R.dimen.gv_channel_layout_width)
mChannelRowBackground =
ContextCompat.getDrawable(context, R.drawable.channel_row_background)
mEventBackground = ContextCompat.getDrawable(context, R.drawable.event_background)
eventLayoutTextColor = ColorStateList(
arrayOf(intArrayOf(android.R.attr.state_focused), intArrayOf()), intArrayOf(
context.getThemedAttribute(android.R.attr.colorAccent),
context.getThemedAttribute(android.R.attr.textColorPrimary)
)
)
eventLayoutTextSize = resources.getDimensionPixelSize(R.dimen.gv_event_layout_text)
mTimeBarHeight = resources.getDimensionPixelSize(R.dimen.gv_time_bar_height)
mTimeBarTextSize = resources.getDimensionPixelSize(R.dimen.gv_time_bar_text)
mTimeBarLineWidth = resources.getDimensionPixelSize(R.dimen.gv_time_bar_line_width)
mTimeBarLineColor = context.getThemedAttribute(android.R.attr.colorAccent)
mTimebarBackground = ColorDrawable(Color.TRANSPARENT)
mHoursInViewPort = TimeUnit.HOURS.toMillis(1) + TimeUnit.MINUTES.toMillis(30)
mDaysBack = TimeUnit.MINUTES.toMillis(30)
mDaysForward = TimeUnit.DAYS.toMillis(1)
mTimeSpacing = TimeUnit.MINUTES.toMillis(30)
screenDimenInitialization()
}
private fun channelHeight(isSelected: Boolean): Int {
return if (isSelected) (mChannelLayoutHeight * mSelectedRowScale).toInt() else mChannelLayoutHeight
}
private fun screenDimenInitialization() {
screenWidth = resources.displayMetrics.widthPixels
screenHeight = resources.displayMetrics.heightPixels
if (screenWidth < screenHeight) {
screenWidth = screenHeight
screenHeight = resources.displayMetrics.widthPixels
}
}
private fun init(attrs: AttributeSet? = null, defStyleAttr: Int = 0, defStyleRes: Int = 0) {
context.withStyledAttributes(attrs, R.styleable.GuideView, defStyleAttr, defStyleRes) {
mChannelLayoutMargin = getDimensionPixelSize(
R.styleable.GuideView_gv_ChannelMargin,
resources.getDimensionPixelSize(R.dimen.gv_channel_layout_margin)
)
mChannelLayoutPadding = getDimensionPixelSize(
R.styleable.GuideView_gv_ChannelPadding,
resources.getDimensionPixelSize(R.dimen.gv_channel_layout_padding)
)
mChannelLayoutHeight = getDimensionPixelSize(
R.styleable.GuideView_gv_ChannelHeight,
resources.getDimensionPixelSize(R.dimen.gv_channel_layout_height)
)
mSelectedRowScale =
getFloat(R.styleable.GuideView_gv_SelectedRowScale, mSelectedRowScale)
mChannelLayoutWidth = getDimensionPixelSize(
R.styleable.GuideView_gv_ChannelWidth,
resources.getDimensionPixelSize(R.dimen.gv_channel_layout_width)
)
mChannelRowBackground =
getDrawable(R.styleable.GuideView_gv_ChannelBackground) ?: mChannelRowBackground
mEventBackground =
getDrawable(R.styleable.GuideView_gv_EventBackground) ?: mEventBackground
eventLayoutTextColor =
getColorStateList(R.styleable.GuideView_gv_EventTextColor) ?: eventLayoutTextColor
eventLayoutTextSize = getDimensionPixelSize(
R.styleable.GuideView_gv_EventTextSize,
resources.getDimensionPixelSize(R.dimen.gv_event_layout_text)
)
mTimeBarHeight = getDimensionPixelSize(
R.styleable.GuideView_gv_TimebarHeight,
resources.getDimensionPixelSize(R.dimen.gv_time_bar_height)
)
mTimeBarTextSize = getDimensionPixelSize(
R.styleable.GuideView_gv_TimebarTextSize,
resources.getDimensionPixelSize(R.dimen.gv_time_bar_text)
)
mTimeBarLineWidth = getDimensionPixelSize(
R.styleable.GuideView_gv_TimeLineWidth,
resources.getDimensionPixelSize(R.dimen.gv_time_bar_line_width)
)
mTimeBarLineColor = getColor(R.styleable.GuideView_gv_TimeLineColor, mTimeBarLineColor)
mTimebarBackground =
getColorOrDrawable(R.styleable.GuideView_gv_TimebarBackground, Color.TRANSPARENT)
?: mTimebarBackground
mHoursInViewPort =
TimeUnit.HOURS.toMillis(getInt(R.styleable.GuideView_gv_HoursToShow, 2).toLong())
mTimeSpacing = TimeUnit.MINUTES.toMillis(
getInt(
R.styleable.GuideView_gv_TimeSpacingInMinutes, 30
).toLong()
)
}
screenDimenInitialization()
}
fun setDataProvider(provider: DataProvider) {
this.dataProvider = provider
dataProvider?.onDataUpdated {
recalculateAndRedraw(this.selectedEventPos, false)
}
}
public override fun onSaveInstanceState(): Parcelable {
val superState = super.onSaveInstanceState()
val epgState = EPGState(superState!!)
epgState.currentEvent = this.selectedEventPos
return epgState
}
public override fun onRestoreInstanceState(state: Parcelable) {
if (state !is EPGState) {
super.onRestoreInstanceState(state)
return
}
super.onRestoreInstanceState(state.superState)
this.selectedEventPos = state.currentEvent
}
override fun onDraw(canvas: Canvas) {
if ((dataProvider?.size() ?: 0) > 0) {
mTimeLowerBoundary = getTimeFrom(scrollX)
mTimeUpperBoundary = getTimeFrom(scrollX + width)
val drawingRect = mDrawingRect
drawingRect.left = scrollX
drawingRect.top = scrollY
drawingRect.right = drawingRect.left + width
drawingRect.bottom = drawingRect.top + height
drawChannelListItems(canvas, drawingRect)
drawEvents(canvas, drawingRect)
drawTimebar(canvas, drawingRect)
drawTimeLine(canvas, drawingRect)
//drawResetButton(canvas, drawingRect);
// If scroller is scrolling/animating do scroll. This applies when doing a fling.
if (mScroller.computeScrollOffset()) {
scrollTo(mScroller.finalX, mScroller.finalY)
}
}
}
override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
super.onSizeChanged(w, h, oldw, oldh)
recalculateAndRedraw(this.selectedEventPos, false)
}
override fun onTouchEvent(event: MotionEvent): Boolean {
return mGestureDetector.onTouchEvent(event)
}
override fun dispatchGenericMotionEvent(event: MotionEvent): Boolean {
//return mGame.handleMotionEvent(event);
return false
}
override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {}
private fun drawTimebar(canvas: Canvas, drawingRect: Rect) {
drawingRect.left = scrollX
drawingRect.top = scrollY
drawingRect.right = drawingRect.left + width
drawingRect.bottom = drawingRect.top + mTimeBarHeight
mTimebarBackground?.let {
it.bounds = drawingRect
it.draw(canvas)
}
drawingRect.left = scrollX + mChannelLayoutWidth + mChannelLayoutMargin
drawingRect.top = scrollY
drawingRect.right = drawingRect.left + width
drawingRect.bottom = drawingRect.top + mTimeBarHeight
mClipRect.left = scrollX + mChannelLayoutWidth + mChannelLayoutMargin
mClipRect.top = scrollY
mClipRect.right = scrollX + width
mClipRect.bottom = mClipRect.top + mTimeBarHeight
canvas.save()
canvas.clipRect(mClipRect)
// // Background
// drawStrokedRectangle(canvas, drawingRect)
// Time stamps
mPaint.color = eventLayoutTextColor?.defaultColor ?: Color.WHITE
mPaint.textSize = mTimeBarTextSize.toFloat()
for (i in 0 until mHoursInViewPort / mTimeSpacing) {
// Get time and round to nearest half hour
val time =
mTimeSpacing * ((mTimeLowerBoundary + mTimeSpacing * i + mTimeSpacing / 2) / mTimeSpacing)
canvas.drawText(
time.formatToPattern(timeFormat),
getXFrom(time).toFloat(),
(drawingRect.top + ((drawingRect.bottom - drawingRect.top) / 2 + mTimeBarTextSize / 2)).toFloat(),
mPaint
)
}
canvas.restore()
drawTimebarDayIndicator(canvas, drawingRect)
// drawTimebarBottomStroke(canvas, drawingRect)
}
fun setTimeFormat(format: String) {
this.timeFormat = format
redraw()
}
private fun drawTimebarDayIndicator(canvas: Canvas, drawingRect: Rect) {
drawingRect.left = scrollX
drawingRect.top = scrollY
drawingRect.right = drawingRect.left + mChannelLayoutWidth
drawingRect.bottom = drawingRect.top + mTimeBarHeight
//
mPaint.style = Paint.Style.FILL
// mPaint.color = mEpgTimebarBackColor
// canvas.drawRect(drawingRect, mPaint)
// Background
// drawStrokedRectangle(canvas, drawingRect)
// Text
mPaint.color = eventLayoutTextColor?.defaultColor ?: Color.WHITE
mPaint.textSize = mTimeBarTextSize.toFloat()
mPaint.textAlign = Paint.Align.CENTER
canvas.drawText(
mTimeLowerBoundary.toDayName(),
(drawingRect.left + (drawingRect.right - drawingRect.left) / 2).toFloat(),
(drawingRect.top + ((drawingRect.bottom - drawingRect.top) / 2 + mTimeBarTextSize / 2)).toFloat(),
mPaint
)
mPaint.textAlign = Paint.Align.LEFT
}
private fun drawTimeLine(canvas: Canvas, drawingRect: Rect) {
val now = System.currentTimeMillis()
if (shouldDrawTimeLine(now)) {
drawingRect.left = getXFrom(now)
drawingRect.top = scrollY
drawingRect.right = drawingRect.left + mTimeBarLineWidth
drawingRect.bottom = drawingRect.top + height
mPaint.color = mTimeBarLineColor
canvas.drawRect(drawingRect, mPaint)
}
}
private fun drawEvents(canvas: Canvas, drawingRect: Rect) {
val firstPos = firstVisibleChannelPosition
val lastPos = lastVisibleChannelPosition
for (channelPos in firstPos..lastPos) {
// Set clip rectangle
mClipRect.left = scrollX + mChannelLayoutWidth + mChannelLayoutMargin
mClipRect.top = getTopFrom(channelPos)
mClipRect.right = scrollX + width
mClipRect.bottom = mClipRect.top + channelHeight(selectedChannelPos == channelPos)
canvas.save()
canvas.clipRect(mClipRect)
// Draw each event
var foundFirst = false
val epgEvents = dataProvider?.eventsOfChannel(channelPos)
epgEvents?.takeIf { it.isNotEmpty() }?.let { events ->
for ((index, event) in events.withIndex()) {
if (isEventVisible(event.start, event.end)) {
drawEvent(canvas, channelPos, index, drawingRect)
foundFirst = true
} else if (foundFirst) {
break
}
}
}
canvas.restore()
}
}
private fun drawEvent(
canvas: Canvas, channelPosition: Int, eventPosition: Int, drawingRect: Rect
) {
val event = dataProvider?.eventOfChannelAt(channelPosition, eventPosition) ?: return
setEventDrawingRectangle(
channelPosition, event.start, event.end, drawingRect
)
if (drawingRect.left < scrollX + channelAreaWidth) {
drawingRect.left = scrollX + channelAreaWidth
}
// Background
if (channelPosition == selectedChannelPos && selectedEventPos != -1 && eventPosition == selectedEventPos) {
mEventBackground?.let {
it.state = intArrayOf(android.R.attr.state_focused)
it.bounds = drawingRect
it.draw(canvas)
}
} else if (event.isCurrent) {
mEventBackground?.let {
it.state = intArrayOf(android.R.attr.state_selected)
it.bounds = drawingRect
it.draw(canvas)
}
} else {
mEventBackground?.let {
it.state = intArrayOf()
it.bounds = drawingRect
it.draw(canvas)
}
}
// mPaint.style = Paint.Style.STROKE
// mPaint.strokeWidth = 0.3f
mPaint.color = Color.LTGRAY
// canvas.drawRect(drawingRect, mPaint)
mPaint.style = Paint.Style.FILL
// Add left and right inner padding
drawingRect.left += mChannelLayoutPadding + 16
drawingRect.right -= mChannelLayoutPadding
// Text
mPaint.color =
if (channelPosition == selectedChannelPos && selectedEventPos != -1 && eventPosition == selectedEventPos) {
eventLayoutTextColor?.getColorForState(
intArrayOf(android.R.attr.state_focused), eventLayoutTextColor!!.defaultColor
) ?: Color.WHITE
} else if (event.isCurrent) {
eventLayoutTextColor?.getColorForState(
intArrayOf(android.R.attr.state_selected), eventLayoutTextColor!!.defaultColor
) ?: Color.WHITE
} else {
eventLayoutTextColor?.defaultColor ?: Color.WHITE
}
mPaint.textSize =
eventLayoutTextSize * if (channelPosition == selectedChannelPos) mSelectedRowScale else 1f
// Move drawing.top so text will be centered (text is drawn bottom>up)
mPaint.getTextBounds(event.title, 0, event.title.length, mMeasuringRect)
drawingRect.top += (drawingRect.bottom - drawingRect.top) / 2 + mMeasuringRect.height() / 2
var title = event.title
title = title.substring(
0, mPaint.breakText(title, true, (drawingRect.right - drawingRect.left).toFloat(), null)
)
canvas.drawText(title, drawingRect.left.toFloat(), drawingRect.top.toFloat(), mPaint)
}
private fun isEventCurrent(event: Event?): Boolean {
event ?: return false
val now = System.currentTimeMillis()
return event.start <= now && event.end >= now
}
private fun isEventCurrent(eventPosition: Int): Boolean {
val event = selectedEvent ?: return false
return isEventCurrent(event)
}
private fun setEventDrawingRectangle(
channelPosition: Int, start: Long, end: Long, drawingRect: Rect
) {
drawingRect.left = getXFrom(start)
drawingRect.top = getTopFrom(channelPosition)
drawingRect.right = getXFrom(end) - mChannelLayoutMargin
drawingRect.bottom = drawingRect.top + channelHeight(selectedChannelPos == channelPosition)
}
private fun drawChannelListItems(canvas: Canvas, drawingRect: Rect) {
// Background
mMeasuringRect.left = scrollX
mMeasuringRect.top = scrollY
mMeasuringRect.right = drawingRect.left + mChannelLayoutWidth
mMeasuringRect.bottom = mMeasuringRect.top + height
// mPaint.color = Color.LTGRAY
// mPaint.strokeWidth = 1f
// mPaint.style = Paint.Style.STROKE
// canvas.drawRect(mMeasuringRect, mPaint)
// mPaint.style = Paint.Style.FILL
val firstPos = firstVisibleChannelPosition
val lastPos = lastVisibleChannelPosition
for (pos in firstPos..lastPos) {
drawChannelItem(canvas, pos, drawingRect)
}
}
private fun drawChannelItem(canvas: Canvas, position: Int, drawingRect: Rect) {
//Draw Full Row Background
drawingRect.left = scrollX
drawingRect.top = getTopFrom(position)
drawingRect.right = drawingRect.left + programAreaWidth + mChannelLayoutWidth
drawingRect.bottom = drawingRect.top + channelHeight(selectedChannelPos == position)
if (selectedChannelPos == position) {
mChannelRowBackground?.let {
it.state = intArrayOf(android.R.attr.state_focused)
it.bounds = drawingRect
it.draw(canvas)
}
} else {
mChannelRowBackground?.let {
it.state = intArrayOf()
it.bounds = drawingRect
it.draw(canvas)
}
}
drawingRect.left = scrollX
drawingRect.right = drawingRect.left + mChannelLayoutWidth
drawingRect.left += 16
//Draw Channel Name
mPaint.color = if (selectedChannelPos == position) {
eventLayoutTextColor?.getColorForState(
intArrayOf(android.R.attr.state_focused), eventLayoutTextColor!!.defaultColor
) ?: Color.WHITE
} else {
eventLayoutTextColor?.defaultColor ?: Color.WHITE
}
mPaint.textSize =
eventLayoutTextSize * if (position == selectedChannelPos) mSelectedRowScale else 1f
var title = dataProvider?.channelAt(position)?.title ?: ""
// Move drawing.top so text will be centered (text is drawn bottom>up)
mPaint.getTextBounds(title, 0, title.length, mMeasuringRect)
drawingRect.top += (drawingRect.bottom - drawingRect.top) / 2 + mMeasuringRect.height() / 2
title = title.substring(
0, mPaint.breakText(title, true, (drawingRect.right - drawingRect.left).toFloat(), null)
)
canvas.drawText(title ?: "", drawingRect.left.toFloat(), drawingRect.top.toFloat(), mPaint)
}
private fun drawStrokedRectangle(canvas: Canvas, drawingRect: Rect) {
mPaint.strokeWidth = 0.3f
mPaint.color = Color.WHITE
mPaint.style = Paint.Style.STROKE
canvas.drawRect(drawingRect, mPaint)
mPaint.style = Paint.Style.FILL
}
private fun shouldDrawTimeLine(now: Long): Boolean {
return now in mTimeLowerBoundary until mTimeUpperBoundary
}
fun isTimelineVisible(): Boolean {
return System.currentTimeMillis() in mTimeLowerBoundary until mTimeUpperBoundary
}
private fun isEventVisible(start: Long, end: Long): Boolean {
return (start in mTimeLowerBoundary..mTimeUpperBoundary || end in mTimeLowerBoundary..mTimeUpperBoundary || start <= mTimeLowerBoundary && end >= mTimeUpperBoundary)
}
private fun calculatedBaseLine(): Long {
return LocalDateTime.now().toDateTime().minusMillis(mDaysBack.toInt()).millis
}
private fun calculateMaxHorizontalScroll() {
mMaxHorizontalScroll =
((mDaysBack + mDaysForward - mHoursInViewPort) / mMillisPerPixel).toInt()
}
private fun calculateMaxVerticalScroll() {
val maxVerticalScroll =
getTopFrom((dataProvider?.size() ?: 0) - 2) + mChannelLayoutHeight + channelHeight(true)
mMaxVerticalScroll = if (maxVerticalScroll < height) 0 else maxVerticalScroll - height
}
private fun getXFrom(time: Long): Int {
return (((time - mTimeOffset) / mMillisPerPixel).toInt() + mChannelLayoutMargin + mChannelLayoutWidth)
}
private fun getTopFrom(position: Int): Int {
return if (position <= selectedChannelPos)
(position * (mChannelLayoutHeight + mChannelLayoutMargin) + mTimeBarHeight)
else {
((position - 1) * (mChannelLayoutHeight + mChannelLayoutMargin) + mTimeBarHeight + channelHeight(
true
))
}
}
private fun getTimeFrom(x: Int): Long {
return x * mMillisPerPixel + mTimeOffset
}
private fun calculateMillisPerPixel(): Long {
return (mHoursInViewPort / (measuredWidth - mChannelLayoutWidth - mChannelLayoutMargin))
}
private fun resetBoundaries() {
mMillisPerPixel = calculateMillisPerPixel()
mTimeOffset = calculatedBaseLine()
mTimeLowerBoundary = getTimeFrom(0)
mTimeUpperBoundary = getTimeFrom(width)
}
private fun calculateChannelsHitArea(): Rect {
mMeasuringRect.top = mTimeBarHeight
val visibleChannelsHeight =
(dataProvider?.size() ?: 0) * (mChannelLayoutHeight + mChannelLayoutMargin)
mMeasuringRect.bottom =
if (visibleChannelsHeight < height) visibleChannelsHeight else height
mMeasuringRect.left = 0
mMeasuringRect.right = mChannelLayoutWidth
return mMeasuringRect
}
private fun calculateProgramsHitArea(): Rect {
mMeasuringRect.top = mTimeBarHeight
val visibleChannelsHeight =
dataProvider.itemCount * (mChannelLayoutHeight + mChannelLayoutMargin)
mMeasuringRect.bottom =
if (visibleChannelsHeight < height) visibleChannelsHeight else height
mMeasuringRect.left = mChannelLayoutWidth
mMeasuringRect.right = width
return mMeasuringRect
}
private fun getChannelPosition(y: Int): Int {
var y1 = y
y1 -= mTimeBarHeight
val channelPosition = (y1) / (mChannelLayoutHeight + mChannelLayoutMargin)
return if (dataProvider.itemCount == 0) -1 else channelPosition
}
private fun getProgramPosition(channelPosition: Int, time: Long): Int {
val events = dataProvider?.eventsOfChannel(channelPosition) ?: return 0
// for ((index, event) in events.withIndex()) {
// if (event.start <= time && event.end >= time) {
// return index
// }
// }
return events.indexOfFirst { event ->
event.start <= time && event.end >= time
}
// for (eventPos in 0 until events.size) {
// val event = events.getOrNull(eventPos) ?: continue
//
// if (event.startTimestamp <= time && event.stopTimestamp >= time) {
// return eventPos
// }
// }
// return 0
}
private fun getProgramAtTime(channelPosition: Int, time: Long): Event? {
return dataProvider?.eventsOfChannel(channelPosition)?.find { event ->
event.start <= time && event.end >= time
}
//
//
// for (() in 0 until events.size) {
// val event = events.getOrNull(eventPos) ?: continue
//
// if (event.startTimestamp <= time && event.stopTimestamp >= time) {
// return event
// }
// }
// return null
}
fun gotoNow() {
var dT: Long
var dX = 0
var dY = 0
// calculate optimal Y position
val minYVisible =
scrollY // is 0 when scrolled completely to top (first channel fully visible)
val maxYVisible = minYVisible + height
val currentChannelTop =
mTimeBarHeight + selectedChannelPos * (mChannelLayoutHeight + mChannelLayoutMargin)
val currentChannelBottom = currentChannelTop + mChannelLayoutHeight
if (currentChannelTop < minYVisible) {
dY = currentChannelTop - minYVisible - mTimeBarHeight
} else if (currentChannelBottom > maxYVisible) {
dY = currentChannelBottom - maxYVisible
}
// calculate optimal X position
mTimeLowerBoundary = getTimeFrom(scrollX)
mTimeUpperBoundary = getTimeFrom(scrollX + programAreaWidth)
val centerPosition = mTimeLowerBoundary + (mTimeUpperBoundary - mTimeLowerBoundary) / 2
if (now > centerPosition) {
//we need to scroll the grid to the left
dT = (centerPosition - now) * -1
dX = if (mMillisPerPixel > 0) (dT / mMillisPerPixel).toFloat().roundToInt() else 0
}
if (now < centerPosition) {
//we need to scroll the grid to the right
dT = now - centerPosition
dX = (dT / mMillisPerPixel).toFloat().roundToInt()
}
if (scrollX + dX < 0) {
dX = 0 - scrollX
}
if (scrollY + dY < 0) {
dY = 0 - scrollY
}
if (scrollX + dX > mMaxHorizontalScroll) {
dX = mMaxHorizontalScroll - scrollX
}
if (scrollY + dY > mMaxVerticalScroll) {
dY = mMaxVerticalScroll - scrollY
}
if (dX != 0 || dY != 0) {
mScroller.startScroll(scrollX, scrollY, dX, dY, 0)
}
}
/**
* Add click listener to the EPG.
*
* @param epgClickListener to add.
*/
fun setEPGClickListener(clickListener: ClickListener) {
mClickListener = clickListener
}
fun updateSelection(channel: Int, selectedEvent: Int = -1) {
selectedChannelPos = channel
this.selectedEventPos = selectedEvent
recalculateAndRedraw(selectedEvent, withAnimation = false)
}
// fun updateSelection(channel: Channel) {
//
// val position = data?.indexOfFirst { it.streamId == channel.streamId } ?: -1
// if (position > 0) {
// updateSelection(position, null)
// }
// }
/**
* This will recalculate boundaries, maximal scroll and scroll to start position which is current time.
* To be used on device rotation etc since the device height and width will change.
*
* @param withAnimation true if scroll to current position should be animated.
*/
fun recalculateAndRedraw(selectedEvent: Int, withAnimation: Boolean) {
var selectedEvent2 = selectedEvent
if (dataProvider.itemCount > 0) {
resetBoundaries()
calculateMaxVerticalScroll()
calculateMaxHorizontalScroll()
//Select initial event
if (selectedEvent2 == -1) {
selectedEvent2 = this.selectedEventPos
}
if (selectedEvent2 != -1) {
selectEvent(selectedEvent2, withAnimation)
} else {
selectedEvent2 = getProgramPosition(0, now)
selectEvent(selectedEvent2, withAnimation)
if (selectedEvent2 == -1) {
gotoNow()
}
}
redraw()
} else {
redraw()
}
}
/**
* Does a invalidate() and requestLayout() which causes a redraw of screen.
*/
fun redraw() {
invalidate()
requestLayout()
}
fun selectEvent(epgEvent: Int, withAnimation: Boolean) {
this.selectedEventPos = epgEvent
optimizeVisibility()
notifyListener()
//redraw to get the coloring of the selected event
redraw()
}
fun selectCurrentEvent() {
dataProvider?.eventsOfChannel(selectedChannelPos)
?.indexOfFirst { it.start <= now && it.end >= now }?.let { selectEvent(it, false) }
}
fun notifyListener() {
mClickListener?.onEventSelected(currentChannel, selectedEvent)
}
var justGotFocus = false
override fun onFocusChanged(gainFocus: Boolean, direction: Int, previouslyFocusedRect: Rect?) {
super.onFocusChanged(gainFocus, direction, previouslyFocusedRect)
if (gainFocus) {
justGotFocus = true
}
}
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
if (handleNavigationEvent(event) || handleClickEvent(event)) {
return true
}
return super.dispatchKeyEvent(event)
}
override fun onKeyLongPress(keyCode: Int, event: KeyEvent): Boolean {
mTimeLowerBoundary = getTimeFrom(scrollX)
mTimeUpperBoundary = getTimeFrom(scrollX + width)
if (event.keyCode == KeyEvent.KEYCODE_DPAD_CENTER || event.keyCode == KeyEvent.KEYCODE_ENTER) {
mClickListener?.onEventLongClicked(
selectedChannelPos, 0, currentChannel, this.selectedEvent
)
}
//notifyListener()
redraw()
isEventHandled = true
waitForLongClick = false
return true
}
private fun handleNavigationEvent(event: KeyEvent): Boolean {
if (event.action != KeyEvent.ACTION_DOWN) return false
var rv = false
mTimeLowerBoundary = getTimeFrom(scrollX)
mTimeUpperBoundary = getTimeFrom(scrollX + programAreaWidth)
when (event.keyCode) {
KeyEvent.KEYCODE_DPAD_RIGHT -> {
if ((selectedEvent?.end ?: 0) > mTimeUpperBoundary) {
moveMinutesForward(30)
} else {
showNextEvent()
}
rv = true
}
KeyEvent.KEYCODE_DPAD_LEFT -> {
rv = when {
!isBackMoveable() -> if ((selectedEvent?.start
?: 0) > mTimeLowerBoundary
) showPreviousEvent() else false
(selectedEvent?.start?.plus(TimeUnit.MINUTES.toMillis(30))
?: 0) < mTimeLowerBoundary -> {
moveMinutesBack(30)
true
}
else -> {
showPreviousEvent()
}
}
}
KeyEvent.KEYCODE_DPAD_UP -> {
rv = prevChannel()
}
KeyEvent.KEYCODE_DPAD_DOWN -> {
rv = nextChannel()
}
}
notifyListener()
redraw()
return rv
}
private fun handleClickEvent(event: KeyEvent): Boolean {
if (event.keyCode == KeyEvent.KEYCODE_DPAD_CENTER || event.keyCode == KeyEvent.KEYCODE_ENTER) {
if (event.action == KeyEvent.ACTION_UP) {
if (isLongPressed) {
isLongPressed = false
} else {
mClickListener?.onChannelClicked(
selectedChannelPos, currentChannel
)
}
} else {
if (event.isLongPress) {
isLongPressed = true
mClickListener?.onEventLongClicked(
selectedChannelPos, 0, currentChannel, this.selectedEvent
)
}
}
return true
}
return false
}
fun isBackMoveable(): Boolean {
val dT30 = TimeUnit.MINUTES.toMillis(30)
val dX = round(dT30 / mMillisPerPixel.toFloat()).toInt()
return scrollX - dX > 0
}
fun nextChannel(shouldCallListener: Boolean = false): Boolean {
val current = Pair(selectedChannelPos, selectedEventPos)
val new = findEventBelow(selectedChannelPos)
if (current.first == new.first && current.second == new.second) {
return false
}
new.run {
selectedChannelPos = first
selectedEventPos = second
optimizeVisibility()
if (shouldCallListener) {
mClickListener?.onChannelClicked(
selectedChannelPos, currentChannel
)
}
}
return true
}
fun prevChannel(shouldCallListener: Boolean = false): Boolean {
val current = Pair(selectedChannelPos, selectedEventPos)
val new = findEventAbove(selectedChannelPos)
if (current.first == new.first && current.second == new.second) {
return false
}
new.run {
selectedChannelPos = first
selectedEventPos = second
optimizeVisibility()
if (shouldCallListener) {
mClickListener?.onChannelClicked(
selectedChannelPos, currentChannel
)
}
}
return true
}
private fun findNextEvent(): Int {
val programs = dataProvider?.eventsOfChannel(selectedChannelPos) ?: return -1
val nextPos = selectedEventPos + 1
if (nextPos >= programs.size) {
return selectedEventPos
}
return nextPos
}
private fun findPreviousEvent(): Int {
val prevPos = selectedEventPos - 1
if (prevPos < 0) {
return -1
}
return prevPos
}
private fun findEventAbove(channel: Int): Pair<Int, Int> {
val previous = channel - 1
if (previous < 0) return Pair(selectedChannelPos, selectedEventPos)
val current = this.selectedEvent ?: return Pair(selectedChannelPos, selectedEventPos)
val lowerBoundary = max(mTimeLowerBoundary, current.start)
val upperBoundary = min(mTimeUpperBoundary, current.end)
val eventMiddleTime = (lowerBoundary + upperBoundary) / 2
val event = getProgramPosition(previous, eventMiddleTime)
return if (event != -1) {
Pair(previous, event)
} else {
Pair(previous, -1)
}
}
private fun findEventBelow(channel: Int): Pair<Int, Int> {
val next = channel + 1
if (next >= dataProvider.itemCount) return Pair(selectedChannelPos, selectedEventPos)
val current = this.selectedEvent ?: return Pair(selectedChannelPos, selectedEventPos)
val lowerBoundary = max(mTimeLowerBoundary, current.start)
val upperBoundary = min(mTimeUpperBoundary, current.end)
val eventMiddleTime = (lowerBoundary + upperBoundary) / 2
val event = getProgramPosition(next, eventMiddleTime)
return if (event != -1) {
Pair(next, event)
} else {
Pair(next, -1)
}
}
private fun showNextEvent() {
mTimeLowerBoundary = getTimeFrom(scrollX)
mTimeUpperBoundary = getTimeFrom(scrollX + programAreaWidth)
val nextEvent = findNextEvent()
if (nextEvent != -1) {
this.selectedEventPos = nextEvent
var dX: Int
var dT: Long
val currentStart = selectedEvent?.start ?: 0
dT = currentStart - mTimeLowerBoundary
dX = round(dT / mMillisPerPixel.toFloat()).toInt()
if (scrollX + dX < 0) {
dX = 0 - scrollX
}
if (scrollX + dX > mMaxHorizontalScroll) {
dX = mMaxHorizontalScroll - scrollX
}
mScroller.startScroll(scrollX, scrollY, dX, 0, 600)
}
}
private fun showPreviousEvent(): Boolean {
mTimeLowerBoundary = getTimeFrom(scrollX)
mTimeUpperBoundary = getTimeFrom(scrollX + programAreaWidth)
val prevEvent = findPreviousEvent()
return if (prevEvent != -1) {
this.selectedEventPos = prevEvent
var dX: Int
var dT: Long
val currentStart = selectedEvent?.start ?: 0
dT = currentStart - mTimeLowerBoundary
if (dT < 0 && abs(dT) > TimeUnit.MINUTES.toMillis(30)) {
dT = -TimeUnit.MINUTES.toMillis(30)
}
dX = round(dT / mMillisPerPixel.toFloat()).toInt()
if (scrollX + dX < 0) {
dX = 0 - scrollX
}
if (scrollX + dX > mMaxHorizontalScroll) {
dX = mMaxHorizontalScroll - scrollX
}
mScroller.startScroll(scrollX, scrollY, dX, 0, 600)
true
} else false
}
private fun moveMinutesBack(minutes: Long) {
mTimeLowerBoundary = getTimeFrom(scrollX)
mTimeUpperBoundary = getTimeFrom(scrollX + programAreaWidth)
val dT = -TimeUnit.MINUTES.toMillis(minutes)
var dX = round(dT / mMillisPerPixel.toFloat()).toInt()
if (scrollX + dX < 0) {
dX = 0 - scrollX
}
if (scrollX + dX > mMaxHorizontalScroll) {
dX = mMaxHorizontalScroll - scrollX
}
mScroller.startScroll(scrollX, scrollY, dX, 0, 200)
}
private fun moveMinutesForward(minutes: Long) {
mTimeLowerBoundary = getTimeFrom(scrollX)
mTimeUpperBoundary = getTimeFrom(scrollX + programAreaWidth)
val dT = TimeUnit.MINUTES.toMillis(minutes)
var dX = round(dT / mMillisPerPixel.toFloat()).toInt()
if (scrollX + dX < 0) {
dX = 0 - scrollX
}
if (scrollX + dX > mMaxHorizontalScroll) {
dX = mMaxHorizontalScroll - scrollX
}
mScroller.startScroll(scrollX, scrollY, dX, 0, 200)
}
fun optimizeVisibility(vertical: Boolean = true, isTouched: Boolean = false) {
var dT: Long
var dX = 0
var dY = 0
// calculate optimal Y position
if (vertical) {
val minYVisible =
scrollY // is 0 when scrolled completely to top (first channel fully visible)
val currentChannelTop =
selectedChannelPos * (mChannelLayoutHeight + mChannelLayoutMargin)
val bottomPos = minYVisible + height - mChannelLayoutHeight
dY = currentChannelTop - minYVisible
if (isTouched) {
dY = 0
if (currentChannelTop > bottomPos) dY =
bottomPos - currentChannelTop + mTimeBarHeight
else if (currentChannelTop - (mChannelLayoutHeight + mChannelLayoutMargin) < minYVisible) dY =
currentChannelTop - minYVisible - mTimeBarHeight
}
}
if (dX != 0 || dY != 0) {
mScroller.startScroll(scrollX, scrollY, dX, dY, 200)
}
}
private fun startScroll(dX: Int, withAnimation: Boolean) {
var newDx = 0
if (dX < 0) {
newDx = 0 - scrollX
}
if (scrollX + dX > mMaxHorizontalScroll) {
newDx = mMaxHorizontalScroll - scrollX
}
// if (dX != 0) {
// val upperTime = now + TimeUnit.DAYS.toMillis(1)
// val lowerTime = now - TimeUnit.MINUTES.toMillis(30)
// var time = getTimeFrom(scrollX + dX)
// if (time < lowerTime) {
// time = lowerTime
// } else if (time > upperTime) {
// time = upperTime
// }
// newDx = getXFrom(time) - scrollX
// }
if (newDx != 0) {
mScroller.startScroll(scrollX, scrollY, newDx, 0, if (withAnimation) 400 else 0)
}
}
/*
*It will return dX from Now as per given time only if it is in time boundary Otherwise it will return respective time boundary
*
*
*/
fun getDxFromNow(time: Long): Int {
return (time / mMillisPerPixel).toInt()
}
private inner class OnGestureListener : GestureDetector.SimpleOnGestureListener() {
override fun onSingleTapUp(e: MotionEvent): Boolean {
// This is absolute coordinate on screen not taking scroll into account.
val x = e.x.toInt()
val y = e.y.toInt()
// Adding scroll to clicked coordinate
val scrollX = scrollX + x
val scrollY = scrollY + y
// requestFocus()
val channelPosition = getChannelPosition(scrollY)
if (channelPosition != -1 && mClickListener != null) {
selectedChannelPos = channelPosition
if (calculateChannelsHitArea().contains(x, y)) {
// Channel area is clicked
mClickListener!!.onChannelClicked(
channelPosition, currentChannel
)
val lowerBoundary = max(
mTimeLowerBoundary, selectedEvent?.start ?: now
)
val upperBoundary = Math.min(
mTimeUpperBoundary, selectedEvent?.end ?: now
)
val eventMiddleTime = (lowerBoundary + upperBoundary) / 2
selectedEventPos = getProgramPosition(selectedChannelPos, eventMiddleTime)
if (selectedEventPos == -1) {
gotoNow()
} else {
optimizeVisibility(isTouched = true)
}
notifyListener()
} else if (calculateProgramsHitArea().contains(x, y)) {
// Event area is clicked
val programPosition = getProgramPosition(
channelPosition,
getTimeFrom(getScrollX() + x - calculateProgramsHitArea().left)
)
if (programPosition != -1) {
selectedEventPos = programPosition
if (selectedEventPos == -1) {
gotoNow()
} else {
optimizeVisibility(isTouched = true)
}
notifyListener()
mClickListener?.onEventClicked(
channelPosition,
programPosition,
currentChannel,
dataProvider?.eventOfChannelAt(selectedChannelPos, programPosition)
)
}
}
redraw()
}
return true
}
override fun onLongPress(e: MotionEvent) {
// This is absolute coordinate on screen not taking scroll into account.
val x = e.x.toInt()
val y = e.y.toInt()
// Adding scroll to clicked coordinate
val scrollX = scrollX + x
val scrollY = scrollY + y
val channelPosition = getChannelPosition(scrollY)
if (channelPosition != -1 && mClickListener != null) {
selectedChannelPos = channelPosition
if (calculateChannelsHitArea().contains(x, y)) {
// Channel area is clicked
mClickListener!!.onChannelClicked(
channelPosition, currentChannel
)
val lowerBoundary = max(
mTimeLowerBoundary, selectedEvent?.start ?: 0
)
val upperBoundary = min(
mTimeUpperBoundary, selectedEvent?.end ?: 0
)
val eventMiddleTime = (lowerBoundary + upperBoundary) / 2
selectedEventPos = getProgramPosition(selectedChannelPos, eventMiddleTime)
if (selectedEventPos == -1) {
gotoNow()
} else {
optimizeVisibility(isTouched = true)
}
notifyListener()
} else if (calculateProgramsHitArea().contains(x, y)) {
// Event area is clicked
val programPosition = getProgramPosition(
channelPosition,
getTimeFrom(getScrollX() + x - calculateProgramsHitArea().left)
)
if (programPosition != -1) {
selectedEventPos = programPosition
if (selectedEventPos != -1) {
optimizeVisibility(isTouched = true)
mClickListener?.onEventLongClicked(
selectedChannelPos, programPosition, currentChannel, selectedEvent
)
}
notifyListener()
}
}
redraw()
}
}
override fun onScroll(
e1: MotionEvent?, e2: MotionEvent, distanceX: Float, distanceY: Float
): Boolean {
var dx = distanceX.toInt()
var dy = distanceY.toInt()
val x = scrollX
val y = scrollY
// Avoid over scrolling
if (x + dx < 0) {
dx = 0 - x
}
if (y + dy < 0) {
dy = 0 - y
}
if (x + dx > mMaxHorizontalScroll) {
dx = mMaxHorizontalScroll - x
}
if (y + dy > mMaxVerticalScroll) {
dy = mMaxVerticalScroll - y
}
scrollBy(dx, dy)
return true
}
override fun onFling(e1: MotionEvent?, e2: MotionEvent, vX: Float, vY: Float): Boolean {
mScroller.fling(
scrollX,
scrollY,
-vX.toInt(),
-vY.toInt(),
0,
mMaxHorizontalScroll,
0,
mMaxVerticalScroll
)
redraw()
return true
}
override fun onDown(e: MotionEvent): Boolean {
if (!mScroller.isFinished) {
mScroller.forceFinished(true)
return true
}
return true
}
}
interface ClickListener {
fun onChannelClicked(position: Int, channel: Channel?)
fun onEventSelected(channel: Channel?, program: Event?)
fun onEventClicked(
channelPosition: Int, programPosition: Int, channel: Channel?, program: Event?
)
fun onEventLongClicked(
channelPosition: Int, programPosition: Int, channel: Channel?, program: Event?
)
}
} | TV-Guide/tvguide/src/main/java/dev/sajidali/guide/GuideView.kt | 397639568 |
package dev.sajidali.guide.data
interface DataProvider {
fun onDataUpdated(block: () -> Unit)
fun channelAt(position: Int): Channel?
fun eventsOfChannel(position: Int): Collection<Event>
fun eventOfChannelAt(channel: Int, position: Int): Event?
fun size(): Int
} | TV-Guide/tvguide/src/main/java/dev/sajidali/guide/data/DataProvider.kt | 3763047823 |
package dev.sajidali.guide.data
import dev.sajidali.guide.now
data class Event(
val id: Int,
val title: String,
val description: String,
val start: Long,
val end: Long
) {
val isCurrent: Boolean
get() = now in start..end
}
| TV-Guide/tvguide/src/main/java/dev/sajidali/guide/data/Event.kt | 2391513023 |
package dev.sajidali.guide.data
data class Channel(val id: Int, val title: String, val icon: String) | TV-Guide/tvguide/src/main/java/dev/sajidali/guide/data/Channel.kt | 802520671 |
package com.example.planit_mobile
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.planit_mobile", appContext.packageName)
}
} | planit-mobile/app/src/androidTest/java/com/example/planit_mobile/ExampleInstrumentedTest.kt | 1582758370 |
package com.example.planit_mobile.screens
class GuestScreenTests {
} | planit-mobile/app/src/androidTest/java/com/example/planit_mobile/screens/GuestScreenTests.kt | 995315653 |
package com.example.planit_mobile.screens
class ProfileScreenTests {
} | planit-mobile/app/src/androidTest/java/com/example/planit_mobile/screens/ProfileScreenTests.kt | 828578895 |
package com.example.planit_mobile.screens
class LoginScreenTests {
} | planit-mobile/app/src/androidTest/java/com/example/planit_mobile/screens/LoginScreenTests.kt | 1431002582 |
package com.example.planit_mobile.screens
class RegisterScreenTests {
} | planit-mobile/app/src/androidTest/java/com/example/planit_mobile/screens/RegisterScreenTests.kt | 596852785 |
package com.example.planit_mobile
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)
}
} | planit-mobile/app/src/test/java/com/example/planit_mobile/ExampleUnitTest.kt | 2722684002 |
package com.example.planit_mobile.ui.screens.home
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.myapplication.sessionStorage.SessionDataStore
import com.example.planit_mobile.services.UserService
import com.example.planit_mobile.services.utils.launchAndAuthenticateRequest
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
class HomeViewModel(
private val service: UserService,
private val sessionStorage: SessionDataStore
) : ViewModel() {
companion object {
fun factory(service: UserService, sessionStorage: SessionDataStore) = viewModelFactory {
initializer { HomeViewModel(service, sessionStorage) }
}
}
private val logStateFlow: MutableStateFlow<Boolean> = MutableStateFlow(true)
val logState: Flow<Boolean>
get() = logStateFlow.asStateFlow()
fun logout() {
viewModelScope.launch { sessionStorage.clearSession() }
launchAndAuthenticateRequest(
request = { userAccessToken, userRefreshToken, _ ->
service.logout(userAccessToken, userRefreshToken)
},
onSuccess = { _, _, _, _ ->
logStateFlow.value = false
},
onFailure = {},
sessionStorage = sessionStorage
)
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/home/HomeViewModel.kt | 3368647647 |
package com.example.planit_mobile.ui.screens.home
import android.app.Activity
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.collectAsState
import androidx.compose.ui.Modifier
import androidx.lifecycle.lifecycleScope
import com.example.planit_mobile.PlanItDependencyProvider
import com.example.planit_mobile.ui.screens.auth.guest.GuestActivity
import com.example.planit_mobile.ui.screens.profile.UserProfileActivity
import com.example.planit_mobile.ui.screens.searchEvent.SearchEventActivity
import com.example.planit_mobile.ui.theme.PlanitMobileTheme
import kotlinx.coroutines.launch
/**
* The application's home activity.
*/
class HomeActivity : ComponentActivity() {
private val dependencies by lazy { application as PlanItDependencyProvider }
private val viewModel by viewModels<HomeViewModel> {
HomeViewModel.factory(dependencies.userService, dependencies.sessionStorage)
}
companion object {
fun navigateTo(origin: Activity) {
val intent = Intent(origin, HomeActivity::class.java)
origin.startActivity(intent)
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycleScope.launch {
viewModel.logState.collect {
if (!it) {
GuestActivity.navigateTo(this@HomeActivity)
}
}
}
setContent {
PlanitMobileTheme {
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background,
) {
HomeScreen(
onLogoutRequested = { viewModel.logout() },
onProfileRequested = { UserProfileActivity.navigateTo(this) },
onHomeRequested = { navigateTo(this) },
onEventsRequested = { SearchEventActivity.navigateTo(this) }
)
}
}
}
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/home/HomeActivity.kt | 1553637160 |
package com.example.planit_mobile.ui.screens.home
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import com.example.planit_mobile.ui.screens.common.BotBar
import com.example.planit_mobile.ui.screens.common.NavigationHandlers
@Composable
fun HomeScreen(
onLogoutRequested: () -> Unit,
onProfileRequested: () -> Unit,
onHomeRequested: () -> Unit,
onEventsRequested: () -> Unit,
) {
Scaffold(
modifier = Modifier
.fillMaxSize(),
bottomBar = {
BotBar(navigation =
NavigationHandlers(
onProfileRequested = onProfileRequested,
onHomeRequested = onHomeRequested,
onEventsRequested = onEventsRequested
)
)
},
) {
BackgroundBox(
it,
onLogoutRequested
)
}
}
@Composable
fun BackgroundBox(
it: PaddingValues,
onLogoutRequested: () -> Unit,
) {
Box(
modifier = Modifier.fillMaxSize(),
)
{
Column(
modifier = Modifier
.fillMaxWidth()
.fillMaxHeight()
.padding(it),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
) {
Row {
}
Column {
Button(
onClick = onLogoutRequested,
content = { Text("Logout") },
)
}
}
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/home/HomeScreen.kt | 2954521614 |
package com.example.planit_mobile.ui.screens.searchEvent
import androidx.compose.animation.AnimatedContent
import androidx.compose.animation.animateContentSize
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.KeyboardArrowUp
import androidx.compose.material.icons.filled.Search
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Tab
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.graphics.Color
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.planit_mobile.R
import com.example.planit_mobile.ui.screens.common.BotBar
import com.example.planit_mobile.ui.screens.common.NavigationHandlers
@Composable
fun SearchEventScreen(
onProfileRequested: () -> Unit,
onHomeRequested: () -> Unit,
onEventsRequested: () -> Unit,
onSearch: (String) -> Unit
) {
var isExpanded by remember { mutableStateOf(false) }
Scaffold(
modifier = Modifier
.fillMaxSize(),
bottomBar = {
BotBar(
navigation =
NavigationHandlers(
onProfileRequested = onProfileRequested,
onHomeRequested = onHomeRequested,
onEventsRequested = onEventsRequested
)
)
},
) {
Box(modifier = Modifier
.padding(it)
.padding(vertical = 20.dp)) {
if(!isExpanded) {
Text(
text = "What are you looking for?",
color = Color.White,
fontSize = 20.sp,
modifier = Modifier.padding(10.dp)
)
}
SearchBarAnimation(
onSearch = onSearch,
isExpanded = isExpanded,
setExpanded = { isExpanded = !isExpanded }
)
if (!isExpanded) FilterSettings()
}
Box(modifier = Modifier.padding(vertical = 100.dp)){
val categories = listOf("All", "Sports and Outdoor", "Entertainment", "Culture", "Education", "Charity")
var selectedCategory by remember { mutableStateOf(categories[0]) }
LazyRow {
items(categories) { category ->
Tab(
text = { Text(text = category, color = Color.White) },
selected = selectedCategory == category,
onClick = { selectedCategory = category }
)
}
}
}
}
}
@Composable
fun SearchBarAnimation(
onSearch: (String) -> Unit,
isExpanded: Boolean,
setExpanded: () -> Unit
) {
var searchText by remember { mutableStateOf("") }
Box( modifier = Modifier .fillMaxWidth().padding(horizontal = 35.dp), contentAlignment = Alignment.CenterEnd) {
AnimatedContent(
targetState = isExpanded, label = ""
) { targetState ->
if (targetState) {
val textLimitExceeded = searchText.length > 20
val limitedText = if (textLimitExceeded) searchText.substring(0, 20) else searchText
BasicTextField(
value = limitedText,
onValueChange = { searchText = it },
textStyle = TextStyle(color = Color.White),
modifier = Modifier
.animateContentSize()
.background(Color.Transparent)
.width(400.dp)
.height(50.dp)
.border(
width = 1.dp,
color = Color.White,
shape = RoundedCornerShape(15.dp)
)
.padding(vertical = 14.dp, horizontal = 20.dp),
singleLine = true,
cursorBrush = SolidColor(Color.White)
)
}
}
if (isExpanded) {
IconButton(onClick = {
setExpanded()
}) {
Icon(
Icons.Default.KeyboardArrowUp,
contentDescription = "Return",
tint = Color.White
)
}
}
if(!isExpanded) {
IconButton(onClick = setExpanded) {
Icon(
Icons.Default.Search,
contentDescription = "Search",
tint = Color.White
)
}
}
}
}
@Composable
fun FilterSettings(){
Row(
modifier = Modifier
.fillMaxWidth(),
horizontalArrangement = Arrangement.End
) {
IconButton(onClick = { /*TODO*/ }) {
Icon(
painter = painterResource(id = R.drawable.baseline_filter_alt_24),
contentDescription = "Filter",
tint = Color.White
)
}
}
}
@Preview
@Composable
fun SearchEventScreenPreview() {
SearchEventScreen(
onProfileRequested = { },
onHomeRequested = { },
onEventsRequested = { },
onSearch = { }
)
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/searchEvent/SearchEventScreen.kt | 679672812 |
package com.example.planit_mobile.ui.screens.searchEvent
import android.app.Activity
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.collectAsState
import androidx.compose.ui.Modifier
import androidx.lifecycle.lifecycleScope
import com.example.planit_mobile.PlanItDependencyProvider
import com.example.planit_mobile.ui.screens.common.Idle
import com.example.planit_mobile.ui.screens.common.getOrNull
import com.example.planit_mobile.ui.screens.common.idle
import com.example.planit_mobile.ui.screens.home.HomeActivity
import com.example.planit_mobile.ui.theme.PlanitMobileTheme
import kotlinx.coroutines.launch
class SearchEventActivity : ComponentActivity() {
private val dependencies by lazy { application as PlanItDependencyProvider }
private val viewModel by viewModels<SearchEventViewModel> {
SearchEventViewModel.factory(dependencies.eventService, dependencies.sessionStorage)
}
companion object {
fun navigateTo(origin: Activity) {
val intent = Intent(origin, SearchEventActivity::class.java)
origin.startActivity(intent)
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
PlanitMobileTheme {
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
SearchEventScreen(
onProfileRequested = { navigateTo(this) },
onHomeRequested = { HomeActivity.navigateTo(this) },
onEventsRequested = { navigateTo(this) },
onSearch = { searchQuery ->
viewModel.search(searchQuery)
},
)
}
}
}
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/searchEvent/SearchEventActivity.kt | 3054654258 |
package com.example.planit_mobile.ui.screens.searchEvent
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.myapplication.sessionStorage.SessionDataStore
import com.example.planit_mobile.domain.User
import com.example.planit_mobile.services.EventService
import com.example.planit_mobile.services.UserService
import com.example.planit_mobile.services.utils.launchAndRequest
import com.example.planit_mobile.ui.screens.common.LoadState
import com.example.planit_mobile.ui.screens.common.idle
import com.example.planit_mobile.ui.screens.common.loaded
import com.example.planit_mobile.ui.screens.common.loading
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
class SearchEventViewModel(
private val service: EventService,
private val sessionStorage: SessionDataStore
) : ViewModel() {
companion object {
fun factory(service: EventService, sessionStorage: SessionDataStore) = viewModelFactory {
initializer { SearchEventViewModel(service, sessionStorage) }
}
}
private val loadStateFlow : MutableStateFlow<LoadState<User>> = MutableStateFlow(idle())
val loadState: Flow<LoadState<User>>
get() = loadStateFlow.asStateFlow()
fun search(query: String) {
}
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/searchEvent/SearchEventViewModel.kt | 1072453023 |
package com.example.planit_mobile.ui.screens.auth.register
import android.app.Activity
import android.content.Intent
import android.os.Bundle
import android.widget.CheckBox
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.collectAsState
import androidx.compose.ui.Modifier
import androidx.lifecycle.lifecycleScope
import com.example.planit_mobile.PlanItDependencyProvider
import com.example.planit_mobile.R
import com.example.planit_mobile.ui.screens.auth.Success
import com.example.planit_mobile.ui.screens.home.HomeActivity
import com.example.planit_mobile.ui.theme.PlanitMobileTheme
import kotlinx.coroutines.launch
import com.example.planit_mobile.ui.screens.common.Error
import com.example.planit_mobile.ui.screens.common.ErrorPopup
class RegisterActivity : ComponentActivity() {
private val dependencies by lazy { application as PlanItDependencyProvider }
private val viewModel by viewModels<RegisterViewModel> {
RegisterViewModel.factory(dependencies.userService, dependencies.sessionStorage)
}
companion object {
fun navigateTo(origin: Activity) {
val intent = Intent(origin, RegisterActivity::class.java)
origin.startActivity(intent)
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycleScope.launch {
viewModel.loadState.collect {
if (it is Step3State) {
HomeActivity.navigateTo(this@RegisterActivity)
}
}
}
setContent {
val errorMessage = viewModel.errorState.collectAsState(initial = Error("")).value.message
PlanitMobileTheme {
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
RegisterScreen(
onRegister = { username, name, email, password ->
viewModel.register(username, name, email, password)
},
onEdit = { name, interests, description ->
viewModel.editUser(name, interests, description)
},
onBackRequested = { finish() },
showError = errorMessage != ""
)
ErrorPopup(
showDialog = errorMessage != "",
errorMessage = errorMessage) {
viewModel.dismissError()
}
}
}
}
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/register/RegisterActivity.kt | 3678504191 |
package com.example.planit_mobile.ui.screens.auth.register
import com.example.planit_mobile.ui.screens.common.LoadState
sealed class RegisterState : LoadState<Nothing>()
data object Step1State : RegisterState()
data object Step2State : RegisterState()
data object Step3State: RegisterState()
fun step1(): Step1State = Step1State
fun step2(): Step2State = Step2State
fun step3(): Step3State = Step3State | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/register/RegisterStates.kt | 1669763126 |
package com.example.planit_mobile.ui.screens.auth.register
data class UserInfo(
val id: Int,
val name: String,
val username: String,
val password: String,
val description: String,
val email: String,
val interests: String
)
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/register/UserInfo.kt | 404766176 |
package com.example.planit_mobile.ui.screens.auth.register
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.myapplication.sessionStorage.SessionDataStore
import com.example.planit_mobile.services.UserService
import com.example.planit_mobile.services.utils.launchAndAuthenticateRequest
import com.example.planit_mobile.services.utils.launchAndRequest
import com.example.planit_mobile.ui.screens.common.LoadState
import com.example.planit_mobile.ui.screens.common.errorMessage
import com.example.planit_mobile.ui.screens.common.idle
import com.example.planit_mobile.ui.screens.common.loading
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import com.example.planit_mobile.ui.screens.common.Error
class RegisterViewModel(
private val userService: UserService,
private val sessionStorage: SessionDataStore,
) : ViewModel() {
companion object {
fun factory(userService: UserService, sessionStorage: SessionDataStore) = viewModelFactory {
initializer { RegisterViewModel(userService, sessionStorage) }
}
}
private val loadStateFlow: MutableStateFlow<LoadState<Int>> = MutableStateFlow(idle())
private val errorStateFlow: MutableStateFlow<Error> = MutableStateFlow(Error(""))
val loadState: Flow<LoadState<Int>>
get() = loadStateFlow.asStateFlow()
val errorState: Flow<Error>
get() = errorStateFlow.asStateFlow()
fun register(username: String, name: String, email: String, password: String) {
loadStateFlow.value = loading()
launchAndRequest(
request = { userService.register(username, name, email, password) },
onSuccess = {
sessionStorage.setSession(
accessToken = it.accessToken,
refreshToken = it.refreshToken,
userID = it.id,
)
loadStateFlow.value = step1()
},
onFailure = { errorStateFlow.value = errorMessage(it.message.toString()) }
)
}
fun editUser(name: String, interests: String, description: String) {
launchAndAuthenticateRequest(
request = { _, _, userId ->
userService.editUser(userId, name, interests.split(","), description)
},
onSuccess = { _, _, _, _ ->
loadStateFlow.value = step3()
},
onFailure = { errorStateFlow.value = errorMessage(it.message.toString()) },
sessionStorage = sessionStorage
)
}
fun dismissError() {
errorStateFlow.value = Error("")
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/register/RegisterViewModel.kt | 1991473699 |
package com.example.planit_mobile.ui.screens.auth.register
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material.icons.filled.Email
import androidx.compose.material.icons.filled.Face
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material3.Button
import androidx.compose.material3.Checkbox
import androidx.compose.material3.CheckboxDefaults
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.graphics.Color
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.planit_mobile.ui.screens.common.Title
import com.example.planit_mobile.ui.screens.common.TextField
@Composable
fun RegisterScreen(
onRegister: (String, String, String, String) -> Unit,
onEdit: (String, String, String) -> Unit,
onBackRequested: () -> Unit,
showError: Boolean
) {
var steps by remember { mutableStateOf<RegisterState>(Step1State) }
var userInfo by remember { mutableStateOf(
UserInfo(0, "", "", "", "", "", ""))
}
if (showError) steps = Step1State
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier
.fillMaxSize()
.padding(top = 200.dp),
) {
when (steps) {
Step1State -> {
Step1(
userInfo = userInfo,
setUserInfo = { userInfo = it },
onRegister = onRegister,
onNext = { steps = Step2State },
)
}
Step2State -> {
Step2(setInterests = { newInterest ->
userInfo = userInfo.copy(interests = if (userInfo.interests.isEmpty()) {
newInterest
} else {
"${userInfo.interests}, $newInterest"
})
}, setStep = { steps = it})
}
Step3State -> {
Step3(
userInfo = userInfo,
setDescription = {userInfo = userInfo.copy(description = it)},
onEdit = onEdit
)
}
}
}
}
@Composable
fun Step1(
userInfo: UserInfo,
setUserInfo: (UserInfo) -> Unit,
onRegister: (String, String, String, String) -> Unit,
onNext: () -> Unit
) {
Title(text = "Join us!", Color.White, 30.sp)
TextField(
text = userInfo.username,
onTextChange = {setUserInfo(userInfo.copy(username = it))},
label = "Username",
leadingIcon = Icons.Default.Face,
singleLine = true,
maxLength = 20,
padding = 12.dp
)
TextField(
text = userInfo.name,
onTextChange = {setUserInfo(userInfo.copy(name = it))},
label = "Name",
leadingIcon = Icons.Default.Face,
singleLine = true,
maxLength = 20,
padding = 12.dp
)
TextField(
text = userInfo.email,
onTextChange = {setUserInfo(userInfo.copy(email = it))},
label = "Email",
leadingIcon = Icons.Default.Email,
singleLine = true,
maxLength = 30,
padding = 0.dp
)
TextField(
text = userInfo.password,
onTextChange = {setUserInfo(userInfo.copy(password = it))},
label = "Password",
leadingIcon = Icons.Default.Lock,
singleLine = true,
visualTransformation = PasswordVisualTransformation(),
maxLength = 30,
padding = 0.dp
)
Button(
onClick = {
onRegister(userInfo.username, userInfo.name, userInfo.email, userInfo.password)
onNext()
},
content = { Text("Next") },
)
}
@Composable
fun Step2(setInterests: (String) -> Unit, setStep: (RegisterState) -> Unit) {
val interests = listOf("Sports and Outdoor", "Culture", "Education", "Entertainment", "Charity")
Title(text = "What are you interested in?", Color.White, 30.sp)
Column {
for (interest in interests) {
var checked by remember { mutableStateOf(false) }
Row(
modifier = Modifier.padding(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Checkbox(
checked = checked,
onCheckedChange = { setInterests(interest); checked = it },
colors = CheckboxDefaults.colors(
checkmarkColor = Color.White,
checkedColor = Color.White,
uncheckedColor = Color.White
)
)
Text(text = interest, color = Color.White, fontSize = 15.sp)
}
}
}
Button(
onClick = {
setStep(Step3State)
},
content = { Text("Next") },
)
}
@Composable
fun Step3(
userInfo: UserInfo,
setDescription: (String) -> Unit,
onEdit: (String, String, String) -> Unit
) {
Title(text = "Almost there!", Color.White, 30.sp)
TextField(
text = userInfo.description,
onTextChange = setDescription,
label = "Tell us about yourself...",
leadingIcon = Icons.Default.Edit,
singleLine = false,
maxLength = 200,
padding = 10.dp
)
Button(
onClick = {
onEdit(userInfo.name, userInfo.interests, userInfo.description)
},
content = { Text("Finish") },
)
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/register/RegisterScreen.kt | 2728438961 |
package com.example.planit_mobile.ui.screens.auth.guest
import androidx.compose.foundation.text.ClickableText
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
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.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.unit.dp
import com.example.planit_mobile.R
@Composable
fun GuestScreen(
onLoginRequested: () -> Unit,
onRegisterRequested: () -> Unit,
) {
Box(
contentAlignment = Alignment.TopCenter,
modifier = Modifier
.fillMaxSize()
.padding(top = 100.dp)
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally
) {
Image(
painter = painterResource(id = R.drawable.logo_removedbg),
contentDescription = "PlanIt Logo"
)
Text(
text = "Welcome to PlanIt!",
style = MaterialTheme.typography.headlineLarge,
color = Color.White
)
Spacer(modifier = Modifier.height(16.dp))
Button(
onClick = onRegisterRequested,
colors = ButtonDefaults.buttonColors(
containerColor = Color.White,
contentColor = Color.Black
)
) {
Text("Create an account")
}
Spacer(modifier = Modifier.height(8.dp))
ClickableText(
text = AnnotatedString("Already have an account? Login here."),
onClick = {
onLoginRequested()
},
style = TextStyle(
color = Color.White
)
)
}
}
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/guest/GuestScreen.kt | 2644501190 |
package com.example.planit_mobile.ui.screens.auth.guest
import android.app.Activity
import android.content.Intent
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.compose.ui.graphics.Color
import com.example.planit_mobile.PlanItDependencyProvider
import com.example.planit_mobile.ui.screens.auth.login.LoginActivity
import com.example.planit_mobile.ui.screens.auth.register.RegisterActivity
import com.example.planit_mobile.ui.theme.PlanitMobileTheme
/**
* The application's home activity.
*/
class GuestActivity : ComponentActivity() {
private val dependencies by lazy { application as PlanItDependencyProvider }
companion object {
fun navigateTo(origin: Activity) {
val intent = Intent(origin, GuestActivity::class.java)
origin.startActivity(intent)
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
PlanitMobileTheme {
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
GuestScreen(
onLoginRequested = { LoginActivity.navigateTo(this) },
onRegisterRequested = { RegisterActivity.navigateTo(this) }
)
}
}
}
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/guest/GuestActivity.kt | 4244754348 |
package com.example.planit_mobile.ui.screens.auth
import com.example.planit_mobile.ui.screens.common.LoadState
sealed class AuthState<out T> : LoadState<T>()
data object Success : AuthState<Nothing>()
fun succeeded(): Success = Success
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/AuthState.kt | 57510689 |
package com.example.planit_mobile.ui.screens.auth.login
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.myapplication.sessionStorage.SessionDataStore
import com.example.planit_mobile.services.UserService
import com.example.planit_mobile.services.utils.launchAndRequest
import com.example.planit_mobile.ui.screens.auth.succeeded
import com.example.planit_mobile.ui.screens.common.Error
import com.example.planit_mobile.ui.screens.common.LoadState
import com.example.planit_mobile.ui.screens.common.errorMessage
import com.example.planit_mobile.ui.screens.common.idle
import com.example.planit_mobile.ui.screens.common.loading
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
class LoginViewModel(
private val userService: UserService,
private val sessionStorage: SessionDataStore,
) : ViewModel() {
companion object {
fun factory(userService: UserService, sessionStorage: SessionDataStore) = viewModelFactory {
initializer { LoginViewModel(userService, sessionStorage) }
}
}
private val loadStateFlow: MutableStateFlow<LoadState<String>> = MutableStateFlow(idle())
private val errorStateFlow: MutableStateFlow<Error> = MutableStateFlow(Error(""))
val loadState: Flow<LoadState<String>>
get() = loadStateFlow.asStateFlow()
val errorState: Flow<Error>
get() = errorStateFlow.asStateFlow()
fun login(emailOrName: String, password: String) {
loadStateFlow.value = loading()
launchAndRequest(
request = { userService.login(emailOrName, password) },
onSuccess = {
sessionStorage.setSession(
accessToken = it.accessToken,
refreshToken = it.refreshToken,
userID = it.id,
)
loadStateFlow.value = succeeded()
},
onFailure = {errorStateFlow.value = errorMessage(it.message.toString()) }
)
}
fun dismissError() {
errorStateFlow.value = Error("")
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/login/LoginViewModel.kt | 1119349824 |
package com.example.planit_mobile.ui.screens.auth.login
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Email
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material3.Button
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.graphics.Color
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.planit_mobile.ui.screens.common.TextField
import com.example.planit_mobile.ui.screens.common.Title
@Composable
fun LoginScreen(
onLogin: (String, String) -> Unit,
onBackRequested: () -> Unit,
) {
var emailOrName by remember { mutableStateOf("") }
var password by remember { mutableStateOf("") }
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier
.fillMaxSize()
.padding(top = 250.dp),
) {
Title(text = "Who are you?", Color.White, 30.sp)
TextField(
text = emailOrName,
onTextChange = { emailOrName = it },
label = "Email Or username",
leadingIcon = Icons.Default.Email,
singleLine = true,
maxLength = 30,
padding = 20.dp
)
TextField(
text = password,
onTextChange = { password = it },
label = "Password",
leadingIcon = Icons.Default.Lock,
singleLine = true,
visualTransformation = PasswordVisualTransformation(),
maxLength = 30,
padding = 5.dp
)
Button(
onClick = { onLogin(emailOrName, password)},
content = { Text("Login") },
)
}
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/login/LoginScreen.kt | 3700553081 |
package com.example.planit_mobile.ui.screens.auth.login
import android.app.Activity
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.collectAsState
import androidx.compose.ui.Modifier
import androidx.lifecycle.lifecycleScope
import com.example.planit_mobile.PlanItDependencyProvider
import com.example.planit_mobile.ui.screens.auth.Success
import com.example.planit_mobile.ui.screens.common.Error
import com.example.planit_mobile.ui.screens.common.ErrorPopup
import com.example.planit_mobile.ui.screens.home.HomeActivity
import com.example.planit_mobile.ui.theme.PlanitMobileTheme
import kotlinx.coroutines.launch
class LoginActivity : ComponentActivity() {
private val dependencies by lazy { application as PlanItDependencyProvider }
private val viewModel by viewModels<LoginViewModel> {
LoginViewModel.factory(dependencies.userService, dependencies.sessionStorage)
}
companion object {
fun navigateTo(origin: Activity) {
val intent = Intent(origin, LoginActivity::class.java)
origin.startActivity(intent)
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycleScope.launch {
viewModel.loadState.collect {
if (it is Success) HomeActivity.navigateTo(this@LoginActivity)
}
}
setContent {
val errorMessage = viewModel.errorState.collectAsState(initial = Error("")).value.message
PlanitMobileTheme {
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
LoginScreen(
onLogin = { email, password ->
viewModel.login(email, password)
},
onBackRequested = { finish() },
)
ErrorPopup(
showDialog = errorMessage != "",
errorMessage = errorMessage) {
viewModel.dismissError()
}
}
}
}
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/auth/login/LoginActivity.kt | 3197511177 |
package com.example.planit_mobile.ui.screens.common
import android.util.Log
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.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults.topAppBarColors
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import com.example.planit_mobile.R
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun BotBar(navigation: NavigationHandlers = NavigationHandlers()) {
TopAppBar(
title = {
Box(
modifier = Modifier
.fillMaxSize()
.padding(start = 30.dp, top = 40.dp),
) {
}
},
actions = {
Row(
horizontalArrangement = Arrangement.SpaceBetween,
modifier = Modifier.fillMaxSize(),
verticalAlignment = Alignment.CenterVertically
) {
if (navigation.onEventsRequested != null) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier.padding(horizontal = 15.dp)
) {
IconButton(
onClick = navigation.onEventsRequested,
modifier = Modifier.size(30.dp)
) {
Icon(
painter = painterResource(id = R.drawable.binoculars_icon),
contentDescription = stringResource(id = R.string.bot_bar_navigate_to_events),
tint = Color.White
)
}
Text(
text = "Events",
color = Color.White
)
}
}
if (navigation.onHomeRequested != null) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier.padding(horizontal = 15.dp)
) {
IconButton(
onClick = navigation.onHomeRequested,
modifier = Modifier.size(30.dp)
) {
Icon(
painter = painterResource(id = R.drawable.home_icon),
contentDescription = stringResource(id = R.string.bot_bar_navigate_to_home),
tint = Color.White,
)
}
Text(
text = "Home",
color = Color.White
)
}
}
if (navigation.onProfileRequested != null) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier.padding(horizontal = 15.dp)
) {
IconButton(
onClick = navigation.onProfileRequested,
modifier = Modifier.size(30.dp)
) {
Icon(
painter = painterResource(id = R.drawable.profile_icon),
contentDescription = stringResource(id = R.string.bot_bar_navigate_to_profile),
tint = Color.White,
)
}
Text(
text = "Profile",
color = Color.White
)
}
}
}
},
colors = topAppBarColors(containerColor = Color(24, 38, 44, 255)),
modifier = Modifier.height(85.dp)
)
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/common/BotBar.kt | 1187815462 |
package com.example.planit_mobile.ui.screens.common
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.TextUnit
@Composable
fun Title(text: String, color: Color, fontSize: TextUnit) {
Text(
text = text,
fontSize = fontSize,
color = color,
)
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/common/Title.kt | 3029062673 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.