content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package cn.llonvne.gojudge.api
import de.jensklingenberg.ktorfit.Ktorfit
import de.jensklingenberg.ktorfit.http.GET
import de.jensklingenberg.ktorfit.http.Headers
import io.ktor.client.*
import kotlinx.serialization.Serializable
interface JudgeServerApi {
@Headers("Content-Type:Application/Json")
@GET("/info")
suspend fun info(): JudgeServerInfo
companion object {
fun get(baseUrl: String, httpClient: HttpClient): JudgeServerApi {
return object : JudgeServerApi {
private val ktorfit = Ktorfit.Builder()
.baseUrl(baseUrl)
.httpClient(httpClient)
.build()
val api = ktorfit.create<JudgeServerApi>()
override suspend fun info(): JudgeServerInfo {
return api.info()
}
}
}
}
}
@Serializable
data class JudgeServerInfo(
val name: String,
val host: String,
val port: String,
val cpuCoresCount: Int,
val cpuUsage: Double,
val memoryUsage: Int,
val isOnline: Boolean
) | OnlineJudge/go-judge-api/src/commonMain/kotlin/cn/llonvne/gojudge/api/JudgeServerApi.kt | 3009582852 |
package cn.llonvne.gojudge.api
import cn.llonvne.gojudge.internal.GoJudgeClient
interface Task<I, R> {
suspend fun run(input: I, service: GoJudgeClient): R
}
| OnlineJudge/go-judge-api/src/commonMain/kotlin/cn/llonvne/gojudge/api/Task.kt | 2664287237 |
package cn.llonvne.gojudge.api
import kotlin.time.Duration.Companion.seconds
enum class UserJudgePermission(val costTokenPer: Int) {
Normal(100), Vip(10), Admin(0), Unregister(TOTAL_TOKEN_IN_DURATION)
}
const val TOTAL_TOKEN_IN_DURATION = 1000
const val KEY_IN_QUERY = "type"
val FALL_BACK_PERMISSION = UserJudgePermission.Unregister
val JUDGE_TOKEN_REFILL_DURATION = 60.seconds
| OnlineJudge/go-judge-api/src/commonMain/kotlin/cn/llonvne/gojudge/api/UserJudgePermission.kt | 13978636 |
package levi.lin.gemini.android
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("levi.lin.gemini.android", appContext.packageName)
}
} | GeminiAndroid/app/src/androidTest/java/levi/lin/gemini/android/ExampleInstrumentedTest.kt | 38378087 |
package levi.lin.gemini.android
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)
}
} | GeminiAndroid/app/src/test/java/levi/lin/gemini/android/ExampleUnitTest.kt | 4155016054 |
package levi.lin.gemini.android.viewmodel
import android.graphics.Bitmap
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.ai.client.generativeai.GenerativeModel
import com.google.ai.client.generativeai.type.Content
import com.google.ai.client.generativeai.type.asTextOrNull
import com.google.ai.client.generativeai.type.content
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import levi.lin.gemini.android.BuildConfig
import levi.lin.gemini.android.model.MessageItem
import levi.lin.gemini.android.model.MessageType
import levi.lin.gemini.android.state.MessageState
import java.util.Locale
class GeminiViewModel(
private var generativeModel: GenerativeModel
) : ViewModel() {
private val _selectedImageList = MutableStateFlow<List<Bitmap>>(emptyList())
val selectedImageList: StateFlow<List<Bitmap>> = _selectedImageList.asStateFlow()
private val _selectedImageCount = MutableStateFlow(value = 0)
val selectedImageCount: StateFlow<Int> = _selectedImageCount.asStateFlow()
private val _generativeModelFlow = MutableSharedFlow<GenerativeModel>()
val generativeModelFlow: SharedFlow<GenerativeModel> = _generativeModelFlow.asSharedFlow()
private val _scrollToLatestMessageEvent = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
val scrollToLatestMessageEvent: SharedFlow<Unit> = _scrollToLatestMessageEvent.asSharedFlow()
// Chat with Gemini
private var chat = generativeModel.startChat(history = emptyList())
private val _messageState: MutableStateFlow<MessageState> =
MutableStateFlow(
MessageState(
chat.history.map { content ->
MessageItem(
text = content.parts.first().asTextOrNull() ?: "",
type = if (content.role == "user") MessageType.User else MessageType.Gemini,
isPending = false
)
}
)
)
val messageState: StateFlow<MessageState> = _messageState.asStateFlow()
fun sendMessage(inputMessage: String) {
val deviceLanguage = Locale.getDefault().displayLanguage
val imageList = selectedImageList.value
val displayMessage = when {
imageList.isNotEmpty() && inputMessage.isNotBlank() -> "$inputMessage\n\uD83D\uDDBC\uFE0F ：${_selectedImageCount.value}"
imageList.isNotEmpty() -> "\uD83D\uDDBC\uFE0F ：${_selectedImageCount.value}"
else -> inputMessage
}
val prompt = if (imageList.isNotEmpty() && inputMessage.isBlank()) {
"Describe all the images provided."
} else {
"$inputMessage (respond in $deviceLanguage)"
}
val inputContent = content(role = "user") {
if (imageList.isNotEmpty()) {
imageList.forEach { image ->
image(image = image)
}
}
text(text = prompt)
}
// User's message
val inputMessageItem = MessageItem(
text = displayMessage.trim(),
type = MessageType.User,
isPending = true
)
_messageState.value.addMessage(message = inputMessageItem)
viewModelScope.launch {
try {
val response = if (imageList.isNotEmpty()) {
generativeModel.generateContent(inputContent)
} else {
chat.sendMessage(prompt = inputContent)
}
_messageState.value.replaceLastMessage()
response.text?.let { outputContent ->
_messageState.value.addMessage(
message = MessageItem(
text = outputContent.trim(),
type = MessageType.Gemini,
isPending = false
)
)
}
} catch (e: Exception) {
_messageState.value.replaceLastMessage()
_messageState.value.addMessage(
message = MessageItem(
text = e.localizedMessage ?: "",
type = MessageType.Error,
isPending = false
)
)
}
_messageState.value.updateMessagePendingStatus(messageId = inputMessageItem.id, isPending = false)
_scrollToLatestMessageEvent.emit(Unit)
}
}
fun setImageList(imageList: List<Bitmap>) {
_selectedImageList.value = imageList
}
fun setImageCount(count: Int) {
_selectedImageCount.value = count
}
fun clearImageList() {
_selectedImageList.value = emptyList()
_selectedImageCount.value = 0
}
suspend fun updateGenerativeModel(targetModelName: String) {
if (generativeModel.modelName != targetModelName) {
val currentHistory = getCurrentHistory()
generativeModel = GenerativeModel(
modelName = targetModelName,
apiKey = BuildConfig.apiKey
)
restartChatWithHistory(currentHistory)
_generativeModelFlow.emit(generativeModel)
}
}
private fun getCurrentHistory(): List<Content> {
return _messageState.value.messageItems.map { messageItem ->
content(role = if (messageItem.type == MessageType.User) "user" else "model") {
text(messageItem.text)
}
}
}
private fun restartChatWithHistory(history: List<Content>) {
chat = generativeModel.startChat(history = history)
}
} | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/viewmodel/GeminiViewModel.kt | 2654786970 |
package levi.lin.gemini.android.ui.theme
import androidx.compose.ui.graphics.Color
val Blue80 = Color(0xFF3E85F7)
val BlueGrey80 = Color(0xFF6673ED)
val LightBlue80 = Color(0xFF73A0FF)
val Blue40 = Color(0xFF87B5FF)
val BlueGrey40 = Color(0xFF8793FF)
val LightBlue40 = Color(0xFFAECBFF)
val LightGray = Color(0xFFFAFAFA)
val LightMediumGray = Color(0xFFD1CFCF)
val MediumGray = Color(0xFFACA9A9)
val MediumDarkGray = Color(0xFF6F6C6C)
val DarkGray = Color(0xFF3D3C3C)
val LightOrange = Color(0xFFF1AC47)
val Orange = Color(0xFFFF9800)
val DarkOrange = Color(0xFF533201)
val LightRed = Color(0xFFFF3939)
val LightGreen = Color(0xFF9CFF39) | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/ui/theme/Color.kt | 46676128 |
package levi.lin.gemini.android.ui.theme
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalContext
private val DarkColorScheme = darkColorScheme(
primary = Blue80,
secondary = BlueGrey80,
tertiary = LightBlue80
)
private val LightColorScheme = lightColorScheme(
primary = Blue40,
secondary = BlueGrey40,
tertiary = LightBlue40
)
@Composable
fun GeminiAndroidTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/ui/theme/Theme.kt | 3383196311 |
package levi.lin.gemini.android.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
) | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/ui/theme/Type.kt | 954192905 |
package levi.lin.gemini.android.ui.view
import android.graphics.Bitmap
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.material3.Scaffold
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalFocusManager
import androidx.lifecycle.viewmodel.compose.viewModel
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import levi.lin.gemini.android.viewmodel.GeminiViewModel
import levi.lin.gemini.android.state.MessageState
import levi.lin.gemini.android.ui.view.component.InputBar
import levi.lin.gemini.android.ui.view.component.MessageList
@Composable
internal fun GeminiScreenContainer(
geminiViewModel: GeminiViewModel = viewModel(),
onImageSelected: () -> Unit = {}
) {
val messageState by geminiViewModel.messageState.collectAsState()
val selectedImageList by geminiViewModel.selectedImageList.collectAsState()
val selectedImageCount by geminiViewModel.selectedImageCount.collectAsState()
val listState = rememberLazyListState()
val coroutineScope = rememberCoroutineScope()
LaunchedEffect(selectedImageList) {
val targetModelName =
if (selectedImageList.isNotEmpty()) "gemini-pro-vision" else "gemini-pro"
geminiViewModel.updateGenerativeModel(targetModelName = targetModelName)
}
LaunchedEffect(Unit) {
geminiViewModel.scrollToLatestMessageEvent.collect {
coroutineScope.launch {
listState.animateScrollToItem(index = messageState.messageItems.size - 1)
}
}
}
GeminiScreen(
coroutineScope = coroutineScope,
messageState = messageState,
listState = listState,
selectedImageBitmapList = selectedImageList,
selectedImageCount = selectedImageCount,
onButtonClicked = { inputText ->
geminiViewModel.sendMessage(inputText)
},
onImageSelected = onImageSelected,
onClearImage = {
geminiViewModel.clearImageList()
}
)
}
@Composable
fun GeminiScreen(
coroutineScope: CoroutineScope,
messageState: MessageState,
listState: LazyListState,
selectedImageBitmapList: List<Bitmap?> = emptyList(),
selectedImageCount: Int = 0,
onButtonClicked: (String) -> Unit = {},
onImageSelected: () -> Unit = {},
onClearImage: () -> Unit = {}
) {
var inputText by remember { mutableStateOf(value = "") }
val focusManager = LocalFocusManager.current
Scaffold(
modifier = Modifier
.imePadding()
.pointerInput(Unit) {
detectTapGestures(
onTap = {
focusManager.clearFocus()
}
)
},
bottomBar = {
InputBar(
inputText = inputText,
selectedImageBitmapList = selectedImageBitmapList,
selectedImageCount = selectedImageCount,
onTextChange = { text ->
inputText = text
},
onButtonClicked = onButtonClicked,
onImageSelected = onImageSelected,
onClearImage = onClearImage,
onResetScroll = {
coroutineScope.launch {
listState.scrollToItem(index = messageState.messageItems.size - 1)
}
}
)
}
) { innerPadding ->
MessageList(
messages = messageState.messageItems,
listState = listState,
innerPadding = innerPadding
)
}
} | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/ui/view/GeminiScreen.kt | 2010087873 |
package levi.lin.gemini.android.ui.view.component
import android.graphics.Bitmap
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.Send
import androidx.compose.material.icons.filled.AddCircle
import androidx.compose.material.icons.filled.Clear
import androidx.compose.material.icons.filled.Close
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.RectangleShape
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import levi.lin.gemini.android.R
@Composable
fun InputBar(
inputText: String,
selectedImageBitmapList: List<Bitmap?>,
selectedImageCount: Int,
onTextChange: (String) -> Unit,
onButtonClicked: (String) -> Unit,
onImageSelected: () -> Unit,
onClearImage: () -> Unit,
onResetScroll: () -> Unit
) {
val keyboardController = LocalSoftwareKeyboardController.current
Row(
modifier = Modifier
.background(color = MaterialTheme.colorScheme.primary)
.fillMaxWidth()
.padding(all = 10.dp),
verticalAlignment = Alignment.CenterVertically
) {
TextField(
value = inputText,
onValueChange = onTextChange,
modifier = Modifier.weight(1f),
label = { Text(text = stringResource(id = R.string.gemini_input_label)) },
placeholder = { Text(text = stringResource(id = R.string.gemini_input_hint)) },
trailingIcon = {
if (inputText.isNotEmpty()) {
IconButton(onClick = {
onTextChange("")
}) {
Icon(
imageVector = Icons.Filled.Clear,
contentDescription = "Clear"
)
}
}
}
)
Spacer(modifier = Modifier.weight(0.05f))
Box(
modifier = Modifier
.size(48.dp)
.clip(RectangleShape),
contentAlignment = Alignment.TopEnd
) {
IconButton(
modifier = Modifier
.size(48.dp)
.align(Alignment.BottomStart),
onClick = { onImageSelected() }
) {
if (selectedImageBitmapList.isNotEmpty()) {
selectedImageBitmapList.first()?.let { image ->
Image(
bitmap = image.asImageBitmap(),
modifier = Modifier.fillMaxSize(),
contentDescription = "Selected Image",
contentScale = ContentScale.Crop
)
}
if (selectedImageCount > 1) {
Box(
modifier = Modifier
.size(24.dp)
.clip(CircleShape)
.background(MaterialTheme.colorScheme.primary),
contentAlignment = Alignment.Center
) {
val fontSize = when (selectedImageCount.toString().length) {
1 -> 10.sp
2 -> 8.sp
else -> 6.sp
}
Text(
text = selectedImageCount.toString(),
color = MaterialTheme.colorScheme.onPrimary,
fontSize = fontSize,
fontWeight = FontWeight.Bold,
textAlign = TextAlign.Center
)
}
}
} else {
Icon(
imageVector = Icons.Default.AddCircle,
contentDescription = "Select Image",
tint = MaterialTheme.colorScheme.onPrimary
)
}
}
if (selectedImageBitmapList.isNotEmpty()) {
IconButton(
onClick = { onClearImage() },
modifier = Modifier
.clip(CircleShape)
.size(15.dp)
.background(Color.Gray)
.align(Alignment.TopEnd),
) {
Icon(
imageVector = Icons.Default.Close,
contentDescription = "Clear Images",
tint = Color.White
)
}
}
}
Spacer(modifier = Modifier.weight(0.01f))
IconButton(
onClick = {
onButtonClicked(inputText)
keyboardController?.hide()
onResetScroll()
},
modifier = Modifier
.weight(0.2f)
.aspectRatio(ratio = 1f)
) {
Icon(
imageVector = Icons.AutoMirrored.Filled.Send,
contentDescription = "Send",
tint = MaterialTheme.colorScheme.onPrimary
)
}
}
} | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/ui/view/component/InputBar.kt | 2496000998 |
package levi.lin.gemini.android.ui.view.component
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.selection.SelectionContainer
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import levi.lin.gemini.android.model.MessageItem
import levi.lin.gemini.android.model.MessageType
@Composable
fun MessageList(
messages: List<MessageItem>,
listState: LazyListState,
innerPadding: PaddingValues
) {
Column(modifier = Modifier.padding(innerPadding)) {
LazyColumn(
state = listState
) {
items(messages) { message ->
MessageBubble(messageItem = message)
}
}
}
}
@Composable
fun MessageBubble(
messageItem: MessageItem
) {
val isGeminiMessage = messageItem.type == MessageType.Gemini
val backgroundColor = when (messageItem.type) {
MessageType.User -> MaterialTheme.colorScheme.primaryContainer
MessageType.Gemini -> MaterialTheme.colorScheme.secondaryContainer
MessageType.Error -> MaterialTheme.colorScheme.errorContainer
}
val bubbleShape = if (isGeminiMessage) {
RoundedCornerShape(topStart = 4.dp, topEnd = 20.dp, bottomStart = 20.dp, bottomEnd = 20.dp)
} else {
RoundedCornerShape(topStart = 20.dp, topEnd = 4.dp, bottomStart = 20.dp, bottomEnd = 20.dp)
}
val horizontalAlignment = if (isGeminiMessage) {
Alignment.Start
} else {
Alignment.End
}
Column(
horizontalAlignment = horizontalAlignment,
modifier = Modifier
.padding(horizontal = 8.dp, vertical = 4.dp)
.fillMaxWidth()
) {
Text(
text = messageItem.type.name,
style = MaterialTheme.typography.bodySmall,
modifier = Modifier.padding(bottom = 4.dp)
)
Row {
if (messageItem.isPending) {
CircularProgressIndicator(
modifier = Modifier
.align(alignment = Alignment.CenterVertically)
.padding(all = 8.dp)
)
}
BoxWithConstraints {
Card(
colors = CardDefaults.cardColors(containerColor = backgroundColor),
shape = bubbleShape,
modifier = Modifier.widthIn(min = 0.dp, max = maxWidth * 0.9f)
) {
SelectionContainer {
Text(
text = messageItem.text,
modifier = Modifier.padding(16.dp)
)
}
}
}
}
}
} | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/ui/view/component/MessageBubble.kt | 2767442547 |
package levi.lin.gemini.android
import android.app.Activity
import android.content.Intent
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.net.Uri
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.ui.Modifier
import androidx.lifecycle.lifecycleScope
import com.google.ai.client.generativeai.GenerativeModel
import kotlinx.coroutines.launch
import levi.lin.gemini.android.ui.view.GeminiScreenContainer
import levi.lin.gemini.android.ui.theme.GeminiAndroidTheme
import levi.lin.gemini.android.viewmodel.GeminiViewModel
import java.io.IOException
class MainActivity : ComponentActivity() {
// Gemini AI Model
private lateinit var generativeModel: GenerativeModel
private lateinit var viewModel: GeminiViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// init Gemini AI Model
generativeModel = GenerativeModel(
modelName = "gemini-pro",
apiKey = BuildConfig.apiKey
)
viewModel = GeminiViewModel(generativeModel = generativeModel)
// update Gemini AI Model
lifecycleScope.launch {
viewModel.generativeModelFlow.collect { targetGenerativeModel ->
generativeModel = targetGenerativeModel
}
}
// init UI
setContent {
GeminiAndroidTheme {
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background,
) {
GeminiScreenContainer(
geminiViewModel = viewModel,
onImageSelected = { selectImage() }
)
}
}
}
}
private val selectImageResult =
registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
if (result.resultCode == Activity.RESULT_OK) {
val imageBitmaps = result.data?.let { intent ->
extractBitmapsFromIntent(intent = intent)
}.orEmpty()
viewModel.clearImageList()
viewModel.setImageCount(count = imageBitmaps.size)
viewModel.setImageList(imageList = imageBitmaps)
}
}
private fun extractBitmapsFromIntent(intent: Intent): List<Bitmap> {
return intent.clipData?.let { clipData ->
(0 until clipData.itemCount).mapNotNull { index ->
getBitmapFromUri(uri = clipData.getItemAt(index).uri)
}
} ?: intent.data?.let { uri ->
listOfNotNull(getBitmapFromUri(uri = uri))
}.orEmpty()
}
private fun getBitmapFromUri(uri: Uri): Bitmap? {
return try {
contentResolver.openInputStream(uri)?.use { inputStream ->
BitmapFactory.decodeStream(inputStream)
}
} catch (e: IOException) {
null
}
}
private fun selectImage() {
val intent = Intent(Intent.ACTION_PICK)
intent.type = "image/*"
intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
selectImageResult.launch(intent)
}
} | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/MainActivity.kt | 1298376255 |
package levi.lin.gemini.android.state
import androidx.compose.runtime.toMutableStateList
import levi.lin.gemini.android.model.MessageItem
class MessageState(
messageList: List<MessageItem> = emptyList()
) {
private val _messageItems: MutableList<MessageItem> = messageList.toMutableStateList()
val messageItems: List<MessageItem> = _messageItems
fun addMessage(message: MessageItem) {
_messageItems.add(element = message)
}
fun replaceLastMessage() {
val lastMessage = _messageItems.lastOrNull()
lastMessage?.let {
val newMessage = lastMessage.apply {
isPending = false
}
_messageItems.removeLast()
_messageItems.add(newMessage)
}
}
fun updateMessagePendingStatus(messageId: String, isPending: Boolean) {
val index = _messageItems.indexOfFirst { messageItem ->
messageItem.id == messageId
}
if (index != -1) {
val message = _messageItems[index].copy(isPending = isPending)
_messageItems[index] = message
}
}
} | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/state/MessageState.kt | 2997405357 |
package levi.lin.gemini.android.model
import java.util.UUID
data class MessageItem(
val id: String = UUID.randomUUID().toString(),
var text: String = "",
val type: MessageType = MessageType.User,
var isPending: Boolean = false
) | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/model/MessageItem.kt | 1379750310 |
package levi.lin.gemini.android.model
enum class MessageType {
User,
Gemini,
Error
} | GeminiAndroid/app/src/main/java/levi/lin/gemini/android/model/MessageType.kt | 732286241 |
package com.cerebus.contentprovidersample
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.cerebus.contentprovidersample", appContext.packageName)
}
} | ContentProviderSample/app/src/androidTest/java/com/cerebus/contentprovidersample/ExampleInstrumentedTest.kt | 3260506834 |
package com.cerebus.contentprovidersample
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)
}
} | ContentProviderSample/app/src/test/java/com/cerebus/contentprovidersample/ExampleUnitTest.kt | 2147874656 |
package com.cerebus.contentprovidersample
import android.annotation.SuppressLint
import android.content.ContentValues
import android.content.Context
import android.database.Cursor
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
import android.os.Handler
import android.util.Log
class DbHelper(context: Context, thread: CustomThreadWorker?, val mainHandler: Handler?, val showName: () -> Unit, val showDeleteName: () -> Unit) : SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {
constructor(context: Context) : this(context, null, null, {}, {})
private val customHandler = object : CustomHandler(thread?.looper) {
override fun onReceiveMessage(message: CustomMessage) {
Log.d(DATABASE_NAME, message.desc)
}
}
companion object {
const val DATABASE_NAME = "MyDatabase.db"
const val DATABASE_VERSION = 1
const val TABLE_NAME = "ExampleTable"
const val COLUMN_ID = "id"
private const val COLUMN_NAME = "name"
}
override fun onCreate(db: SQLiteDatabase?) {
val createTableSql = ("CREATE TABLE IF NOT EXISTS $TABLE_NAME ($COLUMN_ID INTEGER PRIMARY KEY, $COLUMN_NAME TEXT)")
db?.execSQL(createTableSql)
}
/** Dummy realisation **/
override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
db?.execSQL("DROP TABLE IF EXISTS $TABLE_NAME")
onCreate(db)
}
fun addData(name: String) {
val db = this.writableDatabase
val values = ContentValues()
Log.d(DATABASE_NAME, "data $name was added")
values.put(COLUMN_NAME, name)
db.insert(TABLE_NAME, null, values)
db.close()
}
fun addDataAsync(name: String) {
customHandler.post(CustomMessage(customHandler, {
addData(name)
mainHandler!!.post { showName.invoke() }
}, "Custom handler received message ADD $name"))
}
fun deleteDataAsync(name: String) {
customHandler.post(CustomMessage(customHandler, {
deleteData(name)
mainHandler!!.post { showDeleteName.invoke() }
}, "Custom handler received message DELETE $name"))
}
fun makeQuery(query: String): Cursor {
val db = this.readableDatabase
return db.rawQuery(query, null)
}
@SuppressLint("Range")
fun getData(): ArrayList<String> {
val data = ArrayList<String>()
val db = this.readableDatabase
val query = "SELECT * FROM $TABLE_NAME"
val cursor = db.rawQuery(query, null)
if (cursor.moveToFirst()) {
do {
val name = cursor.getString(cursor.getColumnIndex(COLUMN_NAME))
data.add(name)
} while (cursor.moveToNext())
}
cursor.close()
db.close()
return data
}
fun closeCursor(cursor: Cursor) {
cursor.close()
this.readableDatabase.close()
}
fun deleteData(name: String) {
val db = this.writableDatabase
Log.d(DATABASE_NAME, "data $name was deleted")
db.delete(TABLE_NAME, "$COLUMN_NAME = ?", arrayOf(name))
db.close()
}
} | ContentProviderSample/app/src/main/java/com/cerebus/contentprovidersample/DbHelper.kt | 545723156 |
package com.cerebus.contentprovidersample
import android.app.Activity
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.os.Message
import android.util.Log
import android.view.View
import android.view.inputmethod.InputMethodManager
import android.widget.Button
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
private lateinit var nameEditText: EditText
private lateinit var nameTextView: TextView
private lateinit var saveButton: Button
private lateinit var deleteButton: Button
private val dbThread = CustomThreadWorker()
private val mainHandler = Handler(Looper.getMainLooper())
private lateinit var dbHelper: DbHelper
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
nameTextView = findViewById(R.id.nameTextView)
nameEditText = findViewById(R.id.nameEditText)
saveButton = findViewById(R.id.saveButton)
deleteButton = findViewById(R.id.deleteButton)
dbThread.start()
dbHelper = initDbHelper()
setClickListeners()
}
private fun setClickListeners() {
saveButton.setOnClickListener {
if (nameEditText.text.isNotEmpty()) dbHelper.addDataAsync(nameEditText.text.toString())
hideKeyboard(this)
}
deleteButton.setOnClickListener {
if (nameEditText.text.isNotEmpty()) dbHelper.deleteDataAsync(nameEditText.text.toString())
}
}
fun initDbHelper(): DbHelper {
return DbHelper(this, dbThread, mainHandler, showName = {
nameTextView.text = nameEditText.text.toString() + " added asynchronously"
Log.d("MainActivity", "showName")
}, showDeleteName = {
nameTextView.text = nameEditText.text.toString() + " deleted asynchronously"
Log.d("MainActivity", "deleteName")
})
}
}
fun hideKeyboard(activity: Activity) {
val imm = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
//Find the currently focused view, so we can grab the correct window token from it.
var view = activity.currentFocus
//If no view currently has focus, create a new one, just so we can grab a window token from it
if (view == null) {
view = View(activity)
}
imm.hideSoftInputFromWindow(view.windowToken, 0)
}
| ContentProviderSample/app/src/main/java/com/cerebus/contentprovidersample/MainActivity.kt | 2324674306 |
package com.cerebus.contentprovidersample
import android.content.ContentProvider
import android.content.ContentUris
import android.content.ContentValues
import android.content.Context
import android.content.UriMatcher
import android.database.Cursor
import android.database.SQLException
import android.net.Uri
import com.cerebus.contentprovidersample.DbHelper.Companion.TABLE_NAME
import java.lang.IllegalArgumentException
class MyContentProvider : ContentProvider() {
private lateinit var dbHelper: DbHelper
private val uriMatcher = UriMatcher(UriMatcher.NO_MATCH).apply {
addURI(AUTHORITY, DbHelper.TABLE_NAME, NAMES)
addURI(AUTHORITY, DbHelper.TABLE_NAME, NAMES_ID)
}
override fun onCreate(): Boolean {
val context: Context = context ?: return false
dbHelper = DbHelper(context)
return true
}
override fun query(
uri: Uri,
projection: Array<out String>?,
selection: String?,
selectionArgs: Array<out String>?,
sortOrder: String?
): Cursor? {
val cursor: Cursor?
val db = dbHelper.readableDatabase
when(uriMatcher.match(uri)) {
NAMES -> cursor = db.query(TABLE_NAME, projection, selection, selectionArgs, null, null, sortOrder)
NAMES_ID -> {
val id = uri.lastPathSegment
val newSelection = "${DbHelper.COLUMN_ID}=$id"
cursor = db.query(TABLE_NAME, projection, newSelection, selectionArgs, null, null, sortOrder)
}
else -> {
db.close()
throw IllegalArgumentException("Unknowm URI; $uri")
}
}
return cursor
}
override fun getType(uri: Uri): String =
when(uriMatcher.match(uri)) {
NAMES -> ALL
NAMES_ID -> ONE_NAME
else -> throw IllegalArgumentException("Unknown URI type or uri: $uri")
}
override fun insert(uri: Uri, values: ContentValues?): Uri? {
val db = dbHelper.writableDatabase
val rowId = db.insert(TABLE_NAME, null, values)
if (rowId > 0) {
val rowUri = ContentUris.withAppendedId(CONTENT_URI, rowId)
//???
db.close()
return rowUri
}
throw SQLException("Failed to insert row into $uri")
}
override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int {
TODO("Not yet implemented")
}
override fun update(
uri: Uri,
values: ContentValues?,
selection: String?,
selectionArgs: Array<out String>?
): Int {
TODO("Not yet implemented")
}
companion object {
private const val AUTHORITY = "com.cerebus.contentprovidersample.MyContentProvider"
private const val NAMES = 1
private const val NAMES_ID = 2
private const val ALL = "com.android.cursor.dir/com.cerebus.names"
private const val ONE_NAME = "com.android.cursor.item/com.cerebus.names"
val CONTENT_URI: Uri = Uri.parse("content://${AUTHORITY}/${DbHelper.TABLE_NAME}")
}
} | ContentProviderSample/app/src/main/java/com/cerebus/contentprovidersample/MyContentProvider.kt | 2263922084 |
package com.cerebus.contentprovidersample
import java.util.concurrent.BlockingQueue
import java.util.concurrent.LinkedBlockingQueue
class CustomThreadWorker : Thread() {
val looper = Looper(this)
override fun run() {
looper.loop()
}
}
class Looper(private val thread: Thread) {
private val messageQueue: BlockingQueue<CustomMessage> = LinkedBlockingQueue()
fun loop() {
while (!thread.isInterrupted) {
try {
val task = messageQueue.take()
task?.runnable?.run()
task.handler.onReceiveMessage(task)
} catch (e: InterruptedException) {
e.printStackTrace()
}
}
}
fun addMessage(message: CustomMessage) {
messageQueue.put(message)
}
}
class CustomMessage(val handler: CustomHandler, val runnable: Runnable? = null, val desc: String)
abstract class CustomHandler(val looper: Looper?) {
abstract fun onReceiveMessage(message: CustomMessage)
fun post(message: CustomMessage) {
looper?.addMessage(message)
}
} | ContentProviderSample/app/src/main/java/com/cerebus/contentprovidersample/ThreadWorker.kt | 2026897877 |
package com.cerebus.contentprovidersample
import android.content.ContentProvider
import android.content.ContentUris
import android.content.ContentValues
import android.content.Context
import android.content.UriMatcher
import android.database.Cursor
import android.database.SQLException
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
import android.net.Uri
class BooksProvider : ContentProvider() {
private lateinit var database: SQLiteDatabase
companion object {
private const val DATABASE_NAME = "books.db"
private const val DATABASE_VERSION = 1
private const val TABLE_NAME = "books"
private const val AUTHORITY = "com.example.booksprovider"
val CONTENT_URI: Uri = Uri.parse("content://$AUTHORITY/$TABLE_NAME")
private const val CONTENT_TYPE = "vnd.android.cursor.dir/vnd.example.books"
private const val CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.example.books"
private const val BOOKS = 1
private const val BOOK_ID = 2
private val sUriMatcher = UriMatcher(UriMatcher.NO_MATCH).apply {
addURI(AUTHORITY, TABLE_NAME, BOOKS)
addURI(AUTHORITY, "$TABLE_NAME/#", BOOK_ID)
}
}
private class DatabaseHelper(context: Context) : SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {
override fun onCreate(db: SQLiteDatabase) {
db.execSQL("CREATE TABLE $TABLE_NAME (" +
"_id INTEGER PRIMARY KEY AUTOINCREMENT, " +
"title TEXT NOT NULL, " +
"author TEXT NOT NULL);")
}
override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
db.execSQL("DROP TABLE IF EXISTS $TABLE_NAME")
onCreate(db)
}
}
override fun onCreate(): Boolean {
val context: Context = context ?: return false
val dbHelper = DatabaseHelper(context)
database = dbHelper.writableDatabase
return database != null
}
override fun query(uri: Uri, projection: Array<String>?, selection: String?, selectionArgs: Array<String>?, sortOrder: String?): Cursor? {
val cursor: Cursor?
when (sUriMatcher.match(uri)) {
BOOKS -> cursor = database.query(TABLE_NAME, projection, selection, selectionArgs, null, null, sortOrder)
BOOK_ID -> {
val id = uri.lastPathSegment
val newSelection = "_id=$id"
cursor = database.query(TABLE_NAME, projection, newSelection, selectionArgs, null, null, sortOrder)
}
else -> throw IllegalArgumentException("Unknown URI: $uri")
}
cursor?.setNotificationUri(context!!.contentResolver, uri)
return cursor
}
override fun getType(uri: Uri): String? {
return when (sUriMatcher.match(uri)) {
BOOKS -> CONTENT_TYPE
BOOK_ID -> CONTENT_ITEM_TYPE
else -> throw IllegalArgumentException("Unknown URI: $uri")
}
}
override fun insert(uri: Uri, values: ContentValues?): Uri? {
val rowId = database.insert(TABLE_NAME, null, values)
if (rowId > 0) {
val rowUri = ContentUris.withAppendedId(CONTENT_URI, rowId)
context!!.contentResolver.notifyChange(rowUri, null)
return rowUri
}
throw SQLException("Failed to insert row into $uri")
}
override fun delete(uri: Uri, selection: String?, selectionArgs: Array<String>?): Int {
val count: Int
when (sUriMatcher.match(uri)) {
BOOKS -> count = database.delete(TABLE_NAME, selection, selectionArgs)
BOOK_ID -> {
val id = uri.lastPathSegment
val newSelection = "_id=$id" + (if (!selection.isNullOrEmpty()) " AND ($selection)" else "")
count = database.delete(TABLE_NAME, newSelection, selectionArgs)
}
else -> throw IllegalArgumentException("Unknown URI $uri")
}
context!!.contentResolver.notifyChange(uri, null)
return count
}
override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array<String>?): Int {
val count: Int
when (sUriMatcher.match(uri)) {
BOOKS -> count = database.update(TABLE_NAME, values, selection, selectionArgs)
BOOK_ID -> {
val id = uri.lastPathSegment
val newSelection = "_id=$id" + (if (!selection.isNullOrEmpty()) " AND ($selection)" else "")
count = database.update(TABLE_NAME, values, newSelection, selectionArgs)
}
else -> throw IllegalArgumentException("Unknown URI $uri")
}
context!!.contentResolver.notifyChange(uri, null)
return count
}
}
| ContentProviderSample/app/src/main/java/com/cerebus/contentprovidersample/tmp.kt | 876004051 |
package com.github.cesar1287.cstv
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.github.cesar1287.cstv", appContext.packageName)
}
} | cstv-android-app/app/src/androidTest/java/com/github/cesar1287/cstv/ExampleInstrumentedTest.kt | 2065278204 |
package com.github.cesar1287.cstv
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)
}
} | cstv-android-app/app/src/test/java/com/github/cesar1287/cstv/ExampleUnitTest.kt | 1038368666 |
package com.github.cesar1287.cstv
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.github.cesar1287.cstv.databinding.ActivityMainBinding
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
private val binding: ActivityMainBinding by lazy {
ActivityMainBinding.inflate(layoutInflater)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/MainActivity.kt | 1290005203 |
package com.github.cesar1287.cstv.di
import com.github.cesar1287.cstv.BuildConfig
import com.github.cesar1287.cstv.api.AuthInterceptor
import com.github.cesar1287.cstv.api.PandaScoreApi
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit
@Module
@InstallIn(SingletonComponent::class)
class ApiModule {
@Provides
fun provideRetrofitClient(): Retrofit =
Retrofit.Builder()
.baseUrl(BuildConfig.BASE_URL)
.client(getInterceptorClient())
.addConverterFactory(GsonConverterFactory.create())
.build()
@Provides
fun providePandaScoreApi(
pandaScoreRetrofitClient: Retrofit
): PandaScoreApi = pandaScoreRetrofitClient.create(PandaScoreApi::class.java)
private fun getInterceptorClient(): OkHttpClient {
val loggingInterceptor = HttpLoggingInterceptor()
if (BuildConfig.DEBUG) {
loggingInterceptor.level = HttpLoggingInterceptor.Level.BODY
}
val interceptor = OkHttpClient.Builder()
.connectTimeout(60, TimeUnit.SECONDS)
.readTimeout(60, TimeUnit.SECONDS)
.writeTimeout(60, TimeUnit.SECONDS)
.addInterceptor(loggingInterceptor)
.addInterceptor(AuthInterceptor())
return interceptor.build()
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/di/ApiModule.kt | 4001723437 |
package com.github.cesar1287.cstv.di
import com.github.cesar1287.cstv.features.home.data.HomeRepository
import com.github.cesar1287.cstv.features.home.data.HomeRepositoryImpl
import com.github.cesar1287.cstv.features.matchdetail.data.MatchDetailRepository
import com.github.cesar1287.cstv.features.matchdetail.data.MatchDetailRepositoryImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.android.components.ViewModelComponent
@Module
@InstallIn(ViewModelComponent::class)
abstract class RepositoryModule {
@Binds
abstract fun bindMatchDetailRepository(
matchDetailRepository: MatchDetailRepositoryImpl
): MatchDetailRepository
@Binds
abstract fun bindHomeRepository(
homeRepository: HomeRepositoryImpl
): HomeRepository
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/di/RepositoryModule.kt | 4060759900 |
package com.github.cesar1287.cstv.di
import com.github.cesar1287.cstv.features.home.domain.HomeUseCase
import com.github.cesar1287.cstv.features.home.domain.HomeUseCaseImpl
import com.github.cesar1287.cstv.features.matchdetail.domain.MatchDetailUseCase
import com.github.cesar1287.cstv.features.matchdetail.domain.MatchDetailUseCaseImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.android.components.ViewModelComponent
@Module
@InstallIn(ViewModelComponent::class)
abstract class UseCaseModule {
@Binds
abstract fun bindMatchDetailUseCase(
matchDetailUseCase: MatchDetailUseCaseImpl
): MatchDetailUseCase
@Binds
abstract fun bindHomeUseCase(
homeUseCase: HomeUseCaseImpl
): HomeUseCase
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/di/UseCaseModule.kt | 3977086039 |
package com.github.cesar1287.cstv.features.home.data
import androidx.paging.PagingSource
import androidx.paging.PagingState
import com.github.cesar1287.cstv.api.PandaScoreApi
import com.github.cesar1287.cstv.extensions.getRangeApiDate
import com.github.cesar1287.cstv.model.api.MatchStatus
import com.github.cesar1287.cstv.model.api.toUIModel
import com.github.cesar1287.cstv.model.vo.MatchVO
import com.github.cesar1287.cstv.utils.Constants.Companion.API_KEY_QUERY_BEGIN_AT
import com.github.cesar1287.cstv.utils.Constants.Companion.API_KEY_QUERY_STATUS
import retrofit2.HttpException
import java.io.IOException
import java.util.Calendar
import javax.inject.Inject
class HomePagingSource @Inject constructor(
private val pandaScoreApi: PandaScoreApi
): PagingSource<Int, MatchVO>() {
private val range = getApiDatesRange()
override suspend fun load(
params: LoadParams<Int>
): LoadResult<Int, MatchVO> {
return try {
// Start refresh at page 1 if undefined.
val nextPageNumber = params.key ?: 1
val response = pandaScoreApi.getMatches(
nextPageNumber,
sort = "$API_KEY_QUERY_STATUS,$API_KEY_QUERY_BEGIN_AT",
range = "${range.first},${range.second}"
)
if (response.isSuccessful) {
LoadResult.Page(
data = response.body()
?.filter {
it.status != MatchStatus.POSTPONED
}
?.map {
it.toUIModel()
} ?: listOf(),
prevKey = null, // Only paging forward.
nextKey = nextPageNumber + 1
)
}
else {
LoadResult.Error(UnknownError())
}
} catch (e: IOException) {
// IOException for network failures.
LoadResult.Error(e)
} catch (e: HttpException) {
// HttpException for any non-2xx HTTP status codes.
LoadResult.Error(e)
}
}
override fun getRefreshKey(state: PagingState<Int, MatchVO>): Int? {
// Try to find the page key of the closest page to anchorPosition from
// either the prevKey or the nextKey; you need to handle nullability
// here.
// * prevKey == null -> anchorPage is the first page.
// * nextKey == null -> anchorPage is the last page.
// * both prevKey and nextKey are null -> anchorPage is the
// initial page, so return null.
return state.anchorPosition?.let { anchorPosition ->
val anchorPage = state.closestPageToPosition(anchorPosition)
anchorPage?.prevKey?.plus(1) ?: anchorPage?.nextKey?.minus(1)
}
}
/*
* We can use `rangeOfMonths` as a remote config to have a better personalized way to get faster
* answers from backend, based on user usage, if the overall user never see more than 4/5 pages
* isn't necessary get a range of matches between 1 year.
* */
private fun getApiDatesRange(
rangeOfMonths: Int? = null
): Pair<String, String> {
val currentDate = Calendar.getInstance()
val initialDate = Calendar.getInstance()
initialDate.add(Calendar.MONTH, (rangeOfMonths ?: 12))
val firstDate = initialDate.time.getRangeApiDate()
val secondDate = currentDate.time.getRangeApiDate()
return Pair(secondDate, firstDate)
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/home/data/HomePagingSource.kt | 3590651897 |
package com.github.cesar1287.cstv.features.home.data
import androidx.paging.Pager
import androidx.paging.PagingConfig
import androidx.paging.PagingData
import com.github.cesar1287.cstv.api.PandaScoreApi
import com.github.cesar1287.cstv.model.vo.MatchVO
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
interface HomeRepository {
fun getMatches(): Flow<PagingData<MatchVO>>
}
class HomeRepositoryImpl @Inject constructor(
private val pandaScoreApi: PandaScoreApi
): HomeRepository {
override fun getMatches(): Flow<PagingData<MatchVO>> {
return Pager(
// Configure how data is loaded by passing additional properties to
// PagingConfig, such as prefetchDistance.
PagingConfig(pageSize = 20)
) {
HomePagingSource(
pandaScoreApi = pandaScoreApi
)
}.flow
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/home/data/HomeRepository.kt | 3758402535 |
package com.github.cesar1287.cstv.features.home.domain
import androidx.paging.PagingData
import com.github.cesar1287.cstv.features.home.data.HomeRepository
import com.github.cesar1287.cstv.model.vo.MatchVO
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
interface HomeUseCase {
fun getMatches(): Flow<PagingData<MatchVO>>
}
class HomeUseCaseImpl @Inject constructor(
private val homeRepository: HomeRepository
): HomeUseCase {
override fun getMatches() =
homeRepository.getMatches()
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/home/domain/HomeUseCase.kt | 908576605 |
package com.github.cesar1287.cstv.features.home.presentation
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.paging.cachedIn
import com.github.cesar1287.cstv.features.home.domain.HomeUseCase
import com.github.cesar1287.cstv.model.exception.UnknownErrorException
import dagger.hilt.android.lifecycle.HiltViewModel
import retrofit2.HttpException
import java.io.IOException
import java.lang.ref.WeakReference
import javax.inject.Inject
@HiltViewModel
class HomeViewModel @Inject constructor(
homeUseCase: HomeUseCase
) : ViewModel() {
interface Delegate {
fun onUserWithoutInternetError()
fun onApiError()
fun onUnknownError()
}
var delegate: WeakReference<Delegate?> = WeakReference<Delegate?>(null)
fun handleError(error: Throwable) {
when(error) {
is HttpException -> delegate.get()?.onApiError()
is IOException -> delegate.get()?.onUserWithoutInternetError()
is UnknownErrorException -> delegate.get()?.onUnknownError()
}
}
val matches = homeUseCase.getMatches().cachedIn(viewModelScope)
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/home/presentation/HomeViewModel.kt | 168367336 |
package com.github.cesar1287.cstv.features.home.presentation
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.core.content.ContextCompat
import androidx.core.view.isVisible
import androidx.paging.PagingDataAdapter
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import com.github.cesar1287.cstv.R
import com.github.cesar1287.cstv.databinding.MatchItemBinding
import com.github.cesar1287.cstv.extensions.datePretty
import com.github.cesar1287.cstv.model.api.MatchStatus
import com.github.cesar1287.cstv.model.vo.MatchVO
class HomeAdapter(
private val onMatchClicked: (MatchVO?) -> Unit
) : PagingDataAdapter<MatchVO, HomeViewHolder>(MatchItemComparator()) {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): HomeViewHolder {
return HomeViewHolder(
MatchItemBinding.inflate(
LayoutInflater.from(parent.context), parent, false
)
)
}
override fun onBindViewHolder(holder: HomeViewHolder, position: Int) {
holder.bind(getItem(position), onMatchClicked)
}
}
class HomeViewHolder(
private val binding: MatchItemBinding
) : RecyclerView.ViewHolder(binding.root) {
fun bind(
matchVO: MatchVO?,
onMatchClicked: (MatchVO?) -> Unit
) {
with(binding) {
tvMatchLeagueSeries.text = matchVO?.nameLeagueSerie
tvMatchTeamA.text = matchVO?.nameTeamA
?: itemView.context.getString(R.string.match_item_tdb_team)
tvMatchTeamB.text = matchVO?.nameTeamB
?: itemView.context.getString(R.string.match_item_tdb_team)
Glide
.with(itemView.context)
.load(matchVO?.logoTeamA)
.error(R.drawable.no_logo)
.into(ivMatchTeamA)
Glide
.with(itemView.context)
.load(matchVO?.logoTeamB)
.error(R.drawable.no_logo)
.into(ivMatchTeamB)
Glide
.with(itemView.context)
.load(matchVO?.logoLeague)
.error(R.drawable.no_logo)
.into(ivMatchLeagueSeries)
vgMatchCardContainer.setOnClickListener {
onMatchClicked(matchVO)
}
val datePretty = itemView.context.datePretty(matchVO?.status, matchVO?.beginAt)
tvMatchTime.text = datePretty
when(matchVO?.status) {
MatchStatus.RUNNING -> {
tvMatchTime.backgroundTintList = ContextCompat.getColorStateList(
itemView.context,
R.color.live_now
)
}
MatchStatus.FINISHED,
MatchStatus.NOT_STARTED,
MatchStatus.STATUS_NOT_PLAYED -> {
tvMatchTime.backgroundTintList = ContextCompat.getColorStateList(
itemView.context,
R.color.not_live
)
}
else -> {
tvMatchTime.isVisible = false
}
}
}
}
}
class MatchItemComparator : DiffUtil.ItemCallback<MatchVO>() {
override fun areItemsTheSame(oldItem: MatchVO, newItem: MatchVO): Boolean {
// Id is unique.
return oldItem.id == newItem.id
}
override fun areContentsTheSame(oldItem: MatchVO, newItem: MatchVO): Boolean {
return oldItem.serieId == newItem.serieId
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/home/presentation/HomeAdapter.kt | 1132591460 |
package com.github.cesar1287.cstv.features.home.presentation
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.view.isVisible
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.lifecycleScope
import androidx.navigation.fragment.findNavController
import androidx.paging.LoadState
import androidx.recyclerview.widget.LinearLayoutManager
import com.github.cesar1287.cstv.R
import com.github.cesar1287.cstv.databinding.FragmentHomeBinding
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
import java.lang.ref.WeakReference
@AndroidEntryPoint
class HomeFragment : Fragment(), HomeViewModel.Delegate {
private val viewModel: HomeViewModel by viewModels()
private val homeAdapter: HomeAdapter by lazy {
HomeAdapter { onMatchClicked ->
onMatchClicked?.let {
findNavController().navigate(
HomeFragmentDirections.actionHomeFragmentToMatchDetailFragment(it)
)
}
}
}
private val binding: FragmentHomeBinding by lazy {
FragmentHomeBinding.inflate(layoutInflater)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel.delegate = WeakReference(this)
setupView()
viewLifecycleOwner.lifecycleScope.launch {
homeAdapter.loadStateFlow.collectLatest {
when (val loadState = it.refresh) {
is LoadState.Loading -> {
with(binding) {
pbHomeLoading.isVisible = true
rvHomeMatches.isVisible = false
tvHomeTitle.isVisible = false
tvErrorTitle.isVisible = false
btErrorTryAgain.isVisible = false
}
}
is LoadState.NotLoading -> {
with(binding) {
swRefreshMatches.isRefreshing = false
pbHomeLoading.isVisible = false
rvHomeMatches.isVisible = true
tvHomeTitle.isVisible = true
tvErrorTitle.isVisible = false
btErrorTryAgain.isVisible = false
}
}
is LoadState.Error -> {
viewModel.handleError(loadState.error)
}
}
}
}
viewLifecycleOwner.lifecycleScope.launch {
viewModel.matches.collectLatest { pagingData ->
homeAdapter.submitData(pagingData)
}
}
}
override fun onUserWithoutInternetError() {
setupErrorView(
customMessage = getString(R.string.error_no_connection)
)
}
override fun onApiError() {
setupErrorView()
}
override fun onUnknownError() {
setupErrorView()
}
private fun setupErrorView(
customMessage: String = getString(R.string.error_default)
) {
with(binding) {
pbHomeLoading.isVisible = false
tvHomeTitle.isVisible = false
rvHomeMatches.isVisible = false
tvErrorTitle.isVisible = true
tvErrorTitle.text = customMessage
btErrorTryAgain.isVisible = true
}
}
private fun setupView() {
with(binding) {
rvHomeMatches.apply {
adapter = homeAdapter
layoutManager = LinearLayoutManager(context)
}
btErrorTryAgain.setOnClickListener {
homeAdapter.refresh()
}
swRefreshMatches.setOnRefreshListener {
homeAdapter.refresh()
}
}
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/home/presentation/HomeFragment.kt | 802964938 |
package com.github.cesar1287.cstv.features.splash
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.navigation.fragment.findNavController
import com.github.cesar1287.cstv.databinding.FragmentSplashBinding
class SplashFragment : Fragment() {
private val binding: FragmentSplashBinding by lazy {
FragmentSplashBinding.inflate(layoutInflater)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
Handler(Looper.getMainLooper()).postDelayed({
findNavController().navigate(
SplashFragmentDirections.actionSplashFragmentToHomeFragment()
)
}, 2_000L)
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/splash/SplashFragment.kt | 2410548631 |
package com.github.cesar1287.cstv.features.matchdetail.data
import com.github.cesar1287.cstv.api.PandaScoreApi
import com.github.cesar1287.cstv.base.BaseRepository
import com.github.cesar1287.cstv.model.api.TeamsResponse
import com.github.cesar1287.cstv.model.api.toUIModel
import com.github.cesar1287.cstv.model.vo.TeamsVO
import com.github.cesar1287.cstv.utils.ResponseApi
import javax.inject.Inject
interface MatchDetailRepository {
suspend fun getTeams(teams: String): ResponseApi
}
class MatchDetailRepositoryImpl @Inject constructor(
private val pandaScoreApi: PandaScoreApi
) : MatchDetailRepository, BaseRepository() {
override suspend fun getTeams(teams: String): ResponseApi {
val response = safeApiCall {
pandaScoreApi.getTeams(teams)
}
return when (response) {
is ResponseApi.Success -> {
val teamsResponse = response.data as? TeamsResponse
response.data = teamsResponse?.toUIModel() ?: TeamsVO(
teamA = null,
teamB = null,
noTeamsResponse = true,
firstTeamId = 0,
secondTeamId = 0
)
response
}
is ResponseApi.Error -> response
}
}
}
| cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/matchdetail/data/MatchDetailRepository.kt | 2811594517 |
package com.github.cesar1287.cstv.features.matchdetail.domain
import com.github.cesar1287.cstv.features.matchdetail.data.MatchDetailRepository
import com.github.cesar1287.cstv.utils.ResponseApi
import javax.inject.Inject
interface MatchDetailUseCase {
suspend fun getTeams(teamAId: Int, teamBId: Int): ResponseApi
}
class MatchDetailUseCaseImpl @Inject constructor(
private val matchDetailRepository: MatchDetailRepository
) : MatchDetailUseCase {
override suspend fun getTeams(teamAId: Int, teamBId: Int) =
matchDetailRepository.getTeams("$teamBId,$teamAId")
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/matchdetail/domain/MatchDetailUseCase.kt | 921907184 |
package com.github.cesar1287.cstv.features.matchdetail.presentation
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import com.github.cesar1287.cstv.R
import com.github.cesar1287.cstv.databinding.TeamBItemBinding
import com.github.cesar1287.cstv.model.vo.PlayerVO
class TeamBAdapter :
ListAdapter<PlayerVO, TeamBAdapter.TeamBViewHolder>(PlayerVO.DIFF_CALLBACK) {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): TeamBViewHolder {
val binding = TeamBItemBinding
.inflate(LayoutInflater.from(parent.context), parent, false)
return TeamBViewHolder(binding)
}
override fun onBindViewHolder(holder: TeamBViewHolder, position: Int) {
holder.bind(getItem(position))
}
class TeamBViewHolder(
private val binding: TeamBItemBinding
) : RecyclerView.ViewHolder(binding.root) {
fun bind(
player: PlayerVO?
) = with(binding) {
player?.let {
tvTeamPlayerName.text = player.fullName
tvTeamPlayerNickname.text = player.nickName
Glide.with(itemView.context)
.load(player.imageUrl)
.error(R.drawable.no_logo)
.into(ivTeamPlayerFrame)
}
}
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/matchdetail/presentation/TeamBAdapter.kt | 3998656276 |
package com.github.cesar1287.cstv.features.matchdetail.presentation
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import com.github.cesar1287.cstv.R
import com.github.cesar1287.cstv.databinding.TeamAItemBinding
import com.github.cesar1287.cstv.model.vo.PlayerVO
class TeamAAdapter :
ListAdapter<PlayerVO, TeamAAdapter.TeamAViewHolder>(PlayerVO.DIFF_CALLBACK) {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): TeamAViewHolder {
val binding = TeamAItemBinding
.inflate(LayoutInflater.from(parent.context), parent, false)
return TeamAViewHolder(binding)
}
override fun onBindViewHolder(holder: TeamAViewHolder, position: Int) {
holder.bind(getItem(position))
}
class TeamAViewHolder(
private val binding: TeamAItemBinding
) : RecyclerView.ViewHolder(binding.root) {
fun bind(
player: PlayerVO?
) = with(binding) {
player?.let {
tvTeamPlayerName.text = player.fullName
tvTeamPlayerNickname.text = player.nickName
Glide.with(itemView.context)
.load(player.imageUrl)
.error(R.drawable.no_logo)
.into(ivTeamPlayerFrame)
}
}
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/matchdetail/presentation/TeamAAdapter.kt | 1080361558 |
package com.github.cesar1287.cstv.features.matchdetail.presentation
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.viewModelScope
import com.github.cesar1287.cstv.base.BaseViewModel
import com.github.cesar1287.cstv.features.matchdetail.domain.MatchDetailUseCase
import com.github.cesar1287.cstv.model.vo.TeamsVO
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class MatchDetailViewModel @Inject constructor(
private val matchDetailUseCase: MatchDetailUseCase
) : BaseViewModel() {
private val _onTeamsLoaded: MutableLiveData<TeamsVO?> = MutableLiveData()
val onTeamsLoaded: LiveData<TeamsVO?>
get() = _onTeamsLoaded
fun getTeams(teamAId: Int, teamBId: Int) {
viewModelScope.launch {
callApi(
call = suspend { matchDetailUseCase.getTeams(teamAId, teamBId) },
onSuccess = {
val data = it as? TeamsVO
_onTeamsLoaded.postValue(data)
}
)
}
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/matchdetail/presentation/MatchDetailViewModel.kt | 2558707251 |
package com.github.cesar1287.cstv.features.matchdetail.presentation
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.view.isVisible
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.MutableLiveData
import androidx.navigation.fragment.findNavController
import androidx.navigation.fragment.navArgs
import androidx.recyclerview.widget.LinearLayoutManager
import com.bumptech.glide.Glide
import com.github.cesar1287.cstv.R
import com.github.cesar1287.cstv.databinding.FragmentMatchDetailBinding
import com.github.cesar1287.cstv.extensions.datePretty
import com.github.cesar1287.cstv.model.vo.MatchVO
import com.github.cesar1287.cstv.utils.Command
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class MatchDetailFragment : Fragment() {
private val command: MutableLiveData<Command> = MutableLiveData()
private val binding: FragmentMatchDetailBinding by lazy {
FragmentMatchDetailBinding.inflate(layoutInflater)
}
private val args by navArgs<MatchDetailFragmentArgs>()
private val match: MatchVO by lazy {
args.match
}
private val viewModel: MatchDetailViewModel by viewModels()
private val teamAAdapter by lazy {
TeamAAdapter()
}
private val teamBAdapter by lazy {
TeamBAdapter()
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel.command = command
viewModel.getTeams(match.teamAId, match.teamBId)
setupView()
setupObservables()
}
private fun setupObservables() {
viewModel.onTeamsLoaded.observe(viewLifecycleOwner) {
with(binding) {
if (it?.noTeamsResponse == false) {
rvMatchDetailTeamA.isVisible = true
rvMatchDetailTeamB.isVisible = true
if (match.teamAId == it.firstTeamId) {
teamAAdapter.submitList(it.teamA)
} else {
teamAAdapter.submitList(it.teamB)
}
if (match.teamBId == it.secondTeamId) {
teamBAdapter.submitList(it.teamB)
} else {
teamBAdapter.submitList(it.teamA)
}
}
}
}
viewModel.command.observe(viewLifecycleOwner) {
when (it) {
is Command.Loading -> {
binding.pbMatchDetailPlayer.isVisible = it.value
}
is Command.Error -> {
with(binding) {
gpErrorContent.isVisible = true
pbMatchDetailPlayer.isVisible = false
rvMatchDetailTeamA.isVisible = false
rvMatchDetailTeamB.isVisible = false
}
}
}
}
}
private fun setupView() {
with(binding) {
tvMatchDetailLeagueSeries.text = match.nameLeagueSerie
tvMatchDetailHour.text = context?.datePretty(match.status, match.beginAt)
tvMatchTeamA.text = match.nameTeamA
tvMatchTeamB.text = match.nameTeamB
context?.let { contextNonNull ->
Glide.with(contextNonNull)
.load(match.logoTeamA)
.error(R.drawable.no_logo)
.into(ivMatchTeamA)
Glide.with(contextNonNull)
.load(match.logoTeamB)
.error(R.drawable.no_logo)
.into(ivMatchTeamB)
}
ivMatchDetailBack.setOnClickListener {
findNavController().popBackStack()
}
rvMatchDetailTeamA.apply {
adapter = teamAAdapter
layoutManager = LinearLayoutManager(context)
}
rvMatchDetailTeamB.apply {
adapter = teamBAdapter
layoutManager = LinearLayoutManager(context)
}
btMatchDetailErrorPlayers.setOnClickListener {
viewModel.getTeams(match.teamAId, match.teamBId)
gpErrorContent.isVisible = false
pbMatchDetailPlayer.isVisible = true
rvMatchDetailTeamA.isVisible = false
rvMatchDetailTeamB.isVisible = false
}
}
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/features/matchdetail/presentation/MatchDetailFragment.kt | 3647927716 |
package com.github.cesar1287.cstv.utils
sealed class Command {
class Loading(val value: Boolean): Command()
class Error(val error: Int? = null): Command()
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/utils/Command.kt | 2655422471 |
package com.github.cesar1287.cstv.utils
sealed class ResponseApi {
class Success(var data: Any?) : ResponseApi()
class Error(val message: Int? = null) : ResponseApi()
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/utils/ResponseApi.kt | 4038078081 |
package com.github.cesar1287.cstv.utils
class Constants {
companion object {
const val API_KEY_AUTHORIZATION = "Authorization"
const val API_KEY_BEARER = "Bearer"
const val API_KEY_QUERY_STATUS = "-status"
const val API_KEY_QUERY_BEGIN_AT = "-begin_at"
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/utils/Constants.kt | 2148407585 |
package com.github.cesar1287.cstv.extensions
import android.text.format.DateFormat
import android.text.format.DateUtils.isToday
import java.text.SimpleDateFormat
import java.util.Calendar
import java.util.Date
import java.util.Locale
import java.util.TimeZone
private const val ISO8601_DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss'Z'"
private const val UTC_TIME_ZONE = "UTC"
private const val MATCH_CARD_DATE_FORMAT = "dd.MM HH:mm"
private const val MATCH_CARD_DATE_FORMAT_HOUR_ONLY = "HH:mm"
private const val DAY_OF_WEEK_NAME = "EEE"
private const val RANGE_API_DATE_FORMAT = "yyyy-MM-dd"
fun String.getPrettyDate(): Pair<Boolean, String> {
//UTC Date - Default
val utcSimpleDateFormat = SimpleDateFormat(ISO8601_DATE_FORMAT, Locale.getDefault())
utcSimpleDateFormat.timeZone = TimeZone.getTimeZone(UTC_TIME_ZONE)
val userDate = utcSimpleDateFormat.parse(this)
val matchCardSimpleDateFormat = SimpleDateFormat(MATCH_CARD_DATE_FORMAT, Locale.getDefault())
val matchCardHourOnlySimpleDateFormat =
SimpleDateFormat(MATCH_CARD_DATE_FORMAT_HOUR_ONLY, Locale.getDefault())
if (userDate == null) {
return Pair(false, "")
}
return if (isToday(userDate.time)) {
Pair(true, matchCardHourOnlySimpleDateFormat.format(userDate))
} else if (isThisWeek(userDate)) {
Pair(
false,
"${
DateFormat.format(
DAY_OF_WEEK_NAME,
userDate
)
}, ${matchCardHourOnlySimpleDateFormat.format(userDate)}"
)
} else {
Pair(
false,
matchCardSimpleDateFormat.format(userDate)
)
}
}
private fun isThisWeek(userDate: Date?): Boolean {
return userDate?.let {
val currentDayCalendar = Calendar.getInstance()
val userDateCalendar = Calendar.getInstance()
userDateCalendar.time = userDate
currentDayCalendar.get(Calendar.WEEK_OF_YEAR) ==
userDateCalendar.get(Calendar.WEEK_OF_YEAR)
} ?: false
}
fun Date.getRangeApiDate(): String {
val simpleDateFormat = SimpleDateFormat(RANGE_API_DATE_FORMAT, Locale.getDefault())
return simpleDateFormat.format(this)
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/extensions/DateExtension.kt | 3283676409 |
package com.github.cesar1287.cstv.extensions
import android.content.Context
import com.github.cesar1287.cstv.R
import com.github.cesar1287.cstv.model.api.MatchStatus
fun Context.datePretty(status: MatchStatus?, date: String?): String {
return when(status) {
MatchStatus.RUNNING -> this.getString(R.string.match_item_live_now_label)
MatchStatus.FINISHED -> this.getString(R.string.match_item_finished_label)
MatchStatus.NOT_STARTED,
MatchStatus.STATUS_NOT_PLAYED -> {
val matchTime = date?.getPrettyDate()
if (matchTime?.first == true) {
this.getString(
R.string.match_item_today_match_label,
matchTime.second
)
}
else {
matchTime?.second ?: ""
}
}
else -> ""
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/extensions/ContextExtension.kt | 3439208604 |
package com.github.cesar1287.cstv.model.vo
import android.os.Parcelable
import androidx.recyclerview.widget.DiffUtil
import kotlinx.parcelize.Parcelize
@Parcelize
data class PlayerVO(
val id: Int,
val imageUrl: String?,
val fullName: String?,
val nickName: String?
) : Parcelable {
companion object {
var DIFF_CALLBACK: DiffUtil.ItemCallback<PlayerVO> =
object : DiffUtil.ItemCallback<PlayerVO>() {
override fun areItemsTheSame(oldItem: PlayerVO, newItem: PlayerVO): Boolean {
return oldItem.id == newItem.id
}
override fun areContentsTheSame(oldItem: PlayerVO, newItem: PlayerVO): Boolean {
return oldItem.imageUrl == newItem.imageUrl
}
}
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/vo/PlayerVO.kt | 1963650219 |
package com.github.cesar1287.cstv.model.vo
import android.os.Parcelable
import com.github.cesar1287.cstv.model.api.MatchStatus
import kotlinx.parcelize.Parcelize
@Parcelize
data class MatchVO(
val id: Int,
val serieId: Int,
val teamAId: Int,
val nameTeamA: String?,
val logoTeamA: String?,
val teamBId: Int,
val nameTeamB: String?,
val logoTeamB: String?,
val nameLeagueSerie: String?,
val logoLeague: String?,
val status: MatchStatus?,
val beginAt: String?
): Parcelable | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/vo/MatchVO.kt | 3854381381 |
package com.github.cesar1287.cstv.model.vo
import android.os.Parcelable
import com.github.cesar1287.cstv.model.api.Player
import kotlinx.parcelize.Parcelize
@Parcelize
data class TeamsVO(
val teamA: List<PlayerVO>?,
val teamB: List<PlayerVO>?,
val noTeamsResponse: Boolean,
val firstTeamId: Int?,
val secondTeamId: Int?
) : Parcelable | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/vo/TeamsVO.kt | 4135760070 |
package com.github.cesar1287.cstv.model.api
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class Serie(
@SerializedName("full_name")
val fullName: String,
val id: Int,
): Parcelable | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/api/Serie.kt | 516186901 |
package com.github.cesar1287.cstv.model.api
import android.os.Parcelable
import androidx.recyclerview.widget.DiffUtil
import com.github.cesar1287.cstv.model.vo.PlayerVO
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class Player(
val age: Int,
val birthday: String?,
@SerializedName("first_name")
val firstName: String?,
val id: Int,
@SerializedName("image_url")
val imageUrl: String?,
@SerializedName("last_name")
val lastName: String?,
val name: String,
val nationality: String,
val slug: String
) : Parcelable
fun Player.toUIModel(): PlayerVO {
return PlayerVO(
id = this.id,
fullName = "${this.firstName ?: ""} ${this.lastName ?: ""}",
nickName = this.name,
imageUrl = this.imageUrl
)
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/api/Player.kt | 1542730300 |
package com.github.cesar1287.cstv.model.api
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class OpponentInfo(
val acronym: String,
val id: Int,
@SerializedName("image_url")
val imageUrl: String,
val name: String
) : Parcelable | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/api/OpponentInfo.kt | 3308325712 |
package com.github.cesar1287.cstv.model.api
import com.github.cesar1287.cstv.model.vo.TeamsVO
class TeamsResponse : ArrayList<TeamsResponseItem>()
fun TeamsResponse.toUIModel(): TeamsVO {
return TeamsVO(
teamA = this.firstOrNull()?.players?.map { it.toUIModel() },
teamB = this.lastOrNull()?.players?.map { it.toUIModel() },
noTeamsResponse = this.firstOrNull()?.players?.isEmpty() == true &&
this.lastOrNull()?.players?.isEmpty() == true,
firstTeamId = this.firstOrNull()?.id,
secondTeamId = this.lastOrNull()?.id
)
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/api/TeamsResponse.kt | 1572336937 |
package com.github.cesar1287.cstv.model.api
import android.os.Parcelable
import kotlinx.parcelize.Parcelize
@Parcelize
data class TeamsResponseItem(
val id: Int,
val players: List<Player>
): Parcelable | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/api/TeamsResponseItem.kt | 2699614476 |
package com.github.cesar1287.cstv.model.api
import android.os.Parcelable
import com.github.cesar1287.cstv.model.vo.MatchVO
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class MatchesResponseItem(
val id: Int,
val league: League,
@SerializedName("league_id")
val leagueId: Int,
val name: String,
val opponents: List<Opponent>,
val serie: Serie,
@SerializedName("serie_id")
val serieId: Int,
val status: MatchStatus,
@SerializedName("begin_at")
val beginAt: String,
) : Parcelable
fun MatchesResponseItem.toUIModel(): MatchVO {
val teamA = this.opponents.firstOrNull()?.opponent
val teamB = this.opponents.lastOrNull()?.opponent
return MatchVO(
id = this.id,
serieId = this.serieId,
teamAId = teamA?.id ?: 0,
nameTeamA = teamA?.name,
logoTeamA = teamA?.imageUrl ?: "",
teamBId = teamB?.id ?: 0,
nameTeamB = teamB?.name,
logoTeamB = teamB?.imageUrl ?: "",
nameLeagueSerie = "${league.name} - ${serie.fullName}",
logoLeague = league.imageUrl,
status = this.status,
beginAt = this.beginAt
)
}
enum class MatchStatus {
@SerializedName("finished")
FINISHED,
@SerializedName("not_started")
NOT_STARTED,
@SerializedName("running")
RUNNING,
@SerializedName("not_played")
STATUS_NOT_PLAYED,
@SerializedName("postponed")
POSTPONED
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/api/MatchesResponseItem.kt | 926767732 |
package com.github.cesar1287.cstv.model.api
class MatchesResponse : ArrayList<MatchesResponseItem>() | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/api/MatchesResponse.kt | 960903599 |
package com.github.cesar1287.cstv.model.api
import android.os.Parcelable
import kotlinx.parcelize.Parcelize
@Parcelize
data class Opponent(
val opponent: OpponentInfo,
val type: String
): Parcelable | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/api/Opponent.kt | 1175852472 |
package com.github.cesar1287.cstv.model.api
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class League(
val id: Int,
@SerializedName("image_url")
val imageUrl: String,
val name: String,
): Parcelable | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/api/League.kt | 2922477872 |
package com.github.cesar1287.cstv.model.exception
class UnknownErrorException : Throwable() | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/model/exception/UnknownErrorException.kt | 914581106 |
package com.github.cesar1287.cstv.api
import com.github.cesar1287.cstv.BuildConfig
import com.github.cesar1287.cstv.utils.Constants.Companion.API_KEY_AUTHORIZATION
import com.github.cesar1287.cstv.utils.Constants.Companion.API_KEY_BEARER
import okhttp3.Interceptor
import okhttp3.Response
class AuthInterceptor : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request().newBuilder()
.addHeader(API_KEY_AUTHORIZATION, "$API_KEY_BEARER ${BuildConfig.API_TOKEN}")
.build()
return chain.proceed(request)
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/api/AuthInterceptor.kt | 1607768856 |
package com.github.cesar1287.cstv.api
import com.github.cesar1287.cstv.model.api.MatchesResponse
import com.github.cesar1287.cstv.model.api.TeamsResponse
import retrofit2.Response
import retrofit2.http.GET
import retrofit2.http.Query
interface PandaScoreApi {
@GET("csgo/matches")
suspend fun getMatches(
@Query("page") page: Int,
@Query("per_page") perPage: Int = 20,
@Query("range[begin_at]") range: String,
@Query("sort") sort: String
): Response<MatchesResponse>
@GET("csgo/teams")
suspend fun getTeams(
@Query("filter[id]") teams: String,
): Response<TeamsResponse>
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/api/PandaScoreApi.kt | 3903552636 |
package com.github.cesar1287.cstv
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class MainApplication: Application() | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/MainApplication.kt | 3243143344 |
package com.github.cesar1287.cstv.base
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import com.github.cesar1287.cstv.utils.Command
import com.github.cesar1287.cstv.utils.ResponseApi
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
open class BaseViewModel : ViewModel() {
lateinit var command: MutableLiveData<Command>
suspend fun <T> T.callApi(
call: suspend () -> ResponseApi,
onSuccess: (Any?) -> Unit,
onError: (() -> Unit?)? = null
) {
command.postValue(Command.Loading(true))
when (val response = call.invoke()) {
is ResponseApi.Success -> {
command.postValue(Command.Loading(false))
onSuccess(response.data)
}
is ResponseApi.Error -> {
command.postValue(Command.Loading(false))
onError?.let {
withContext(Dispatchers.Main) { onError.invoke() }
} ?: run {
command.postValue(Command.Error(response.message))
}
}
}
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/base/BaseViewModel.kt | 689052019 |
package com.github.cesar1287.cstv.base
import com.github.cesar1287.cstv.R
import com.github.cesar1287.cstv.utils.ResponseApi
import retrofit2.Response
open class BaseRepository {
suspend fun <T : Any> safeApiCall(call: suspend () -> Response<T>) = safeApiResult(call)
private suspend fun <T : Any> safeApiResult(call: suspend () -> Response<T>): ResponseApi {
return try {
val response = call.invoke()
if (response.isSuccessful) {
ResponseApi.Success(response.body())
} else {
ResponseApi.Error(R.string.error_default)
}
} catch (error: Exception) {
ResponseApi.Error(R.string.error_default)
}
}
} | cstv-android-app/app/src/main/java/com/github/cesar1287/cstv/base/BaseRepository.kt | 2545493323 |
package com.application.machinetestmobulous
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.application.machinetestmobulous", appContext.packageName)
}
} | MachineTestMobulous/app/src/androidTest/java/com/application/machinetestmobulous/ExampleInstrumentedTest.kt | 2340987763 |
package com.application.machinetestmobulous
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)
}
} | MachineTestMobulous/app/src/test/java/com/application/machinetestmobulous/ExampleUnitTest.kt | 1359442959 |
package com.application.machinetestmobulous.Fragments
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.application.machinetestmobulous.R
class ColorsFragment : Fragment() {
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?,
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_colors, container, false)
}
} | MachineTestMobulous/app/src/main/java/com/application/machinetestmobulous/Fragments/ColorsFragment.kt | 722007041 |
package com.application.machinetestmobulous.Fragments
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.application.machinetestmobulous.Adapters.MarkersAdapter
import com.application.machinetestmobulous.R
import com.application.machinetestmobulous.databinding.FragmentMarkersBinding
class MarkersFragment : Fragment() {
private val binding by lazy {
FragmentMarkersBinding.inflate(layoutInflater)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?,
): View? {
binding.rvMarkers.adapter = MarkersAdapter()
return binding.root
}
} | MachineTestMobulous/app/src/main/java/com/application/machinetestmobulous/Fragments/MarkersFragment.kt | 985441783 |
package com.application.machinetestmobulous.Fragments
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import com.application.machinetestmobulous.databinding.FragmentMapBinding
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.OnMapReadyCallback
import com.google.android.gms.maps.SupportMapFragment
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.model.MarkerOptions
class MapFragment : Fragment(),OnMapReadyCallback {
private lateinit var googleMap: GoogleMap
private val binding by lazy {
FragmentMapBinding.inflate(layoutInflater)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?,
): View?
{
setMapOnFragment()
return binding.root
}
private fun setMapOnFragment() {
val mapFragment = activity?.supportFragmentManager?.findFragmentById(com.application.machinetestmobulous.R.id.fragMap) as SupportMapFragment?
mapFragment?.getMapAsync(this)
googleMap.setOnMapClickListener {
Log.d("DATA----->", "onMapClick: $it")
// val location = Location("Test")
// location.latitude = it.latitude
// location.longitude = it.longitude
// location.time = Date().time
//
//// txtinfo.setText(location.toString())
//
// val newLatLng = LatLng(location.latitude, location.longitude)
//
// val markerOptions = MarkerOptions()
// .position(newLatLng)
// .title(newLatLng.toString())
//
// googleMap.addMarker(markerOptions)
val marker = MarkerOptions().position(LatLng(it.latitude, it.longitude))
.title("New Marker")
googleMap.addMarker(marker)
}
}
override fun onMapReady(map: GoogleMap)
{
googleMap = map
}
} | MachineTestMobulous/app/src/main/java/com/application/machinetestmobulous/Fragments/MapFragment.kt | 635786692 |
package com.application.machinetestmobulous.Adapters
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.databinding.DataBindingUtil
import androidx.recyclerview.widget.RecyclerView
import com.application.machinetestmobulous.R
import com.application.machinetestmobulous.databinding.LayoutMarkerItemBinding
class MarkersAdapter: RecyclerView.Adapter<MarkersAdapter.MarkersViewHolder>()
{
class MarkersViewHolder(val binding:LayoutMarkerItemBinding):RecyclerView.ViewHolder(binding.root)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MarkersViewHolder {
return MarkersViewHolder(DataBindingUtil.inflate(LayoutInflater.from(parent.context), R.layout.layout_marker_item,parent,false))
}
override fun getItemCount(): Int {
return 4;
}
override fun onBindViewHolder(holder: MarkersViewHolder, position: Int) {
}
} | MachineTestMobulous/app/src/main/java/com/application/machinetestmobulous/Adapters/MarkersAdapter.kt | 1816537465 |
package com.application.machinetestmobulous.RoomDb
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import com.application.machinetestmobulous.model.Marker
@Database(entities = [Marker::class], version = 1)
abstract class MyDatabase: RoomDatabase() {
abstract fun getRoomDao(): RoomDao
companion object {
private const val DATABASE_NAME = "MyRoomDatabase"
@Volatile
private var INSTANCE: MyDatabase? = null
fun getInstance(context: Context):MyDatabase {
return INSTANCE ?: synchronized(this) {
val instance = Room.databaseBuilder(
context.applicationContext,
MyDatabase::class.java,
DATABASE_NAME
).build()
INSTANCE = instance
instance
}
}
}
} | MachineTestMobulous/app/src/main/java/com/application/machinetestmobulous/RoomDb/MyDatabase.kt | 2992344253 |
package com.application.machinetestmobulous.RoomDb
import androidx.lifecycle.LiveData
import androidx.room.Dao
import androidx.room.Query
import com.application.machinetestmobulous.model.Marker
@Dao
interface RoomDao
{
@Query("SELECT * FROM markers")
fun getMarkers(): LiveData<List<Marker>>
@Query("DELETE FROM markers WHERE id = :markerId")
suspend fun removeFromCart(markerId: Int)
} | MachineTestMobulous/app/src/main/java/com/application/machinetestmobulous/RoomDb/RoomDao.kt | 3828737762 |
package com.application.machinetestmobulous.model
import androidx.room.Entity
@Entity("markers")
data class Marker(val id:Int,val name:String)
| MachineTestMobulous/app/src/main/java/com/application/machinetestmobulous/model/Marker.kt | 1708557246 |
package com.application.machinetestmobulous.Activities
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import com.application.machinetestmobulous.R
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
Handler(Looper.getMainLooper()).postDelayed(Runnable {
startActivity(Intent(this,HomeActivity::class.java))
},500)
}
} | MachineTestMobulous/app/src/main/java/com/application/machinetestmobulous/Activities/MainActivity.kt | 1664320827 |
package com.application.machinetestmobulous.Activities
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.fragment.app.Fragment
import com.application.machinetestmobulous.Fragments.ColorsFragment
import com.application.machinetestmobulous.Fragments.MapFragment
import com.application.machinetestmobulous.Fragments.MarkersFragment
import com.application.machinetestmobulous.R
import com.application.machinetestmobulous.databinding.ActivityHomeBinding
class HomeActivity : AppCompatActivity()
{
private val binding by lazy {
ActivityHomeBinding.inflate(layoutInflater)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
replaceFragment(MapFragment())
binding.bottomNavigation?.setOnItemSelectedListener { item ->
when (item.itemId) {
R.id.nav_home -> {
replaceFragment(MapFragment())
}
R.id.nav_markers->
{
replaceFragment(MarkersFragment())
}
R.id.nav_colors->{
replaceFragment(ColorsFragment())
}
}
return@setOnItemSelectedListener true
}
}
private fun replaceFragment(replaceFragment: Fragment) {
val fragmentTransaction = supportFragmentManager.beginTransaction()
fragmentTransaction.replace(R.id.flContainer, replaceFragment)
fragmentTransaction.commit()
}
} | MachineTestMobulous/app/src/main/java/com/application/machinetestmobulous/Activities/HomeActivity.kt | 1733521602 |
package com.isanz.inmomarket
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.isanz.inmomarket", appContext.packageName)
}
} | InmoMarket/app/src/androidTest/java/com/isanz/inmomarket/ExampleInstrumentedTest.kt | 2810311024 |
package com.isanz.inmomarket
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)
}
} | InmoMarket/app/src/test/java/com/isanz/inmomarket/ExampleUnitTest.kt | 584754798 |
package com.isanz.inmomarket.ui.settings
import android.content.Context
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.navigation.fragment.findNavController
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.FragmentSettingsBinding
class SettingsFragment : Fragment() {
private lateinit var mBinding: FragmentSettingsBinding
private lateinit var mViewModel: SettingsViewModel
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
): View {
mBinding = FragmentSettingsBinding.inflate(layoutInflater)
mViewModel = SettingsViewModel()
setUpView()
return mBinding.root
}
private fun setUpView() {
retrieveSettings()
setUpButtons()
}
private fun retrieveSettings() {
// Retrieve the value from SharedPreferences
val sharedPref = requireActivity().getSharedPreferences("settings_preferences", Context.MODE_PRIVATE)
val biometricLogin = sharedPref.getBoolean("biometricLogin", false)
val allowUbication = sharedPref.getBoolean("allowUbication", false)
mBinding.sBiometricalLogin.isChecked = biometricLogin
mBinding.sAllowUbication.isChecked = allowUbication
}
private fun setUpButtons() {
mBinding.sBiometricalLogin .setOnCheckedChangeListener { _, isChecked ->
// Save the value in SharedPreferences
val sharedPref =
requireActivity().getSharedPreferences("settings_preferences", Context.MODE_PRIVATE)
with(sharedPref.edit()) {
putBoolean("biometricLogin", isChecked)
apply()
}
}
mBinding.ibBack.setOnClickListener {
this.findNavController().navigate(R.id.action_navigation_settings_to_navigation_profile,)
}
mBinding.btnCloseAccount.setOnClickListener{
mViewModel.closeAccount()
}
mBinding.sAllowUbication.setOnClickListener{
// Save the value in SharedPreferences
val sharedPref =
requireActivity().getSharedPreferences("settings_preferences", Context.MODE_PRIVATE)
with(sharedPref.edit()) {
putBoolean("allowUbication", mBinding.sAllowUbication.isChecked)
apply()
}
}
mBinding.btnChangePassword.setOnClickListener {
InmoMarket.getAuth().currentUser?.let {
InmoMarket.getAuth().sendPasswordResetEmail(it.email!!)
}
Toast.makeText(requireContext(), "Email sent", Toast.LENGTH_SHORT).show()
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/settings/SettingsFragment.kt | 3182556443 |
package com.isanz.inmomarket.ui.settings
import androidx.lifecycle.ViewModel
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.ValueEventListener
import com.google.firebase.database.ktx.database
import com.google.firebase.ktx.Firebase
import com.isanz.inmomarket.InmoMarket
class SettingsViewModel : ViewModel() {
private val db = InmoMarket.getDb()
private val rd = Firebase.database
fun closeAccount() {
val userId = InmoMarket.getAuth().currentUser!!.uid
// Delete user from Firebase Authentication
InmoMarket.getAuth().currentUser!!.delete()
// Delete user from Firestore
db.collection("users").document(userId).delete()
db.collection("properties").whereEqualTo("userId", userId).get().addOnSuccessListener {
for (document in it.documents) {
document.reference.delete()
}
}
// Delete all chats where the user is a member in Realtime Database
val chatRef = rd.getReference("chats")
chatRef.addListenerForSingleValueEvent(object : ValueEventListener {
override fun onDataChange(dataSnapshot: DataSnapshot) {
for (chatSnapshot in dataSnapshot.children) {
val membersId = chatSnapshot.child("membersId").value as List<*>
if (membersId.contains(userId)) {
// Delete the chat
chatSnapshot.ref.removeValue()
// Delete all messages from the chat in Realtime Database
val chatId = chatSnapshot.key
val messageRef = rd.getReference("chatMessages/$chatId")
messageRef.removeValue()
}
}
}
override fun onCancelled(databaseError: DatabaseError) {
// Handle error
}
})
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/settings/SettingsViewModel.kt | 2939781559 |
package com.isanz.inmomarket.ui.home
import android.content.ContentValues.TAG
import android.util.Log
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.firebase.firestore.FirebaseFirestore
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.utils.entities.Property
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
class HomeViewModel : ViewModel() {
private val _listParcelas = MutableLiveData<List<Property>>()
val listParcelas: LiveData<List<Property>> = _listParcelas
private val db = FirebaseFirestore.getInstance()
init {
viewModelScope.launch {
try {
listenForParcelasUpdates()
} catch (e: Exception) {
Log.w(TAG, "Listen failed.", e)
}
}
}
private suspend fun listenForParcelasUpdates() = withContext(Dispatchers.IO) {
db.collection("properties").addSnapshotListener { snapshot, e ->
if (e != null) {
Log.w(TAG, "Listen failed.", e)
return@addSnapshotListener
}
if (snapshot != null) {
val properties = mutableListOf<Property>()
val currentUserId = InmoMarket.getAuth().currentUser!!.uid
for (document in snapshot.documents) {
if (document.exists()) {
val property = document.toObject(Property::class.java)
property?.id = document.id
if (property?.userId != currentUserId) {
property?.let { properties.add(it) }
}
}
}
_listParcelas.postValue(properties)
} else {
Log.d(TAG, "Current data: null")
}
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/home/HomeViewModel.kt | 3825207290 |
package com.isanz.inmomarket.ui.home
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.fragment.findNavController
import androidx.recyclerview.widget.LinearLayoutManager
import com.google.android.gms.ads.AdRequest
import com.google.android.gms.ads.MobileAds
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.FragmentHomeBinding
import com.isanz.inmomarket.rv.propertyItem.PropertyItemListAdapter
import com.isanz.inmomarket.utils.interfaces.OnItemClickListener
class HomeFragment : Fragment(), OnItemClickListener {
private var _binding: FragmentHomeBinding? = null
private val binding get() = _binding!!
private val homeViewModel: HomeViewModel by lazy {
ViewModelProvider(this)[HomeViewModel::class.java]
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
): View {
_binding = FragmentHomeBinding.inflate(inflater, container, false)
setUpView()
return binding.root
}
private fun setUpView() {
MobileAds.initialize(requireContext()) {}
val adRequest = AdRequest.Builder().build()
binding.adView.loadAd(adRequest)
setupRecyclerView(homeViewModel)
}
private fun setupRecyclerView(homeViewModel: HomeViewModel) {
// Initialize the RecyclerView adapter
val adapter = PropertyItemListAdapter(this)
binding.rvHome.adapter = adapter
// Set the LayoutManager
binding.rvHome.layoutManager = LinearLayoutManager(context)
// Observe the data from the ViewModel
homeViewModel.listParcelas.observe(viewLifecycleOwner) { parcelas ->
// Update the adapter with the new list of Parcela objects
adapter.submitList(parcelas)
if (parcelas.isEmpty()) {
binding.emptyTextView.visibility = View.VISIBLE
} else {
binding.emptyTextView.visibility = View.GONE
}
binding.progressBar.visibility = View.GONE
}
}
override fun onItemClicked(propertyId: String) {
val bundle = Bundle().apply {
putString("propertyId", propertyId)
}
this.findNavController().navigate(R.id.action_navigation_home_to_propertyFragment, bundle)
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/home/HomeFragment.kt | 95791146 |
package com.isanz.inmomarket.ui.portal
import androidx.lifecycle.ViewModel
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.utils.Constants
import kotlinx.coroutines.tasks.await
import java.lang.Exception
class PortalViewModel : ViewModel() {
suspend fun getImageRandom(): String {
val url = try {
val listResult = InmoMarket.getStorage().reference.child("images/portal/")
.listAll()
.await()
val images = listResult.items
val image = images.random()
val downloadUrl = image.downloadUrl.await()
downloadUrl.toString()
} catch (e: Exception) {
Constants.LOGIN_IMAGE
}
return url
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/portal/PortalViewModel.kt | 3750099091 |
package com.isanz.inmomarket.ui.portal.register
import android.app.Activity
import android.content.ContentValues.TAG
import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.widget.ImageView
import android.widget.Toast
import androidx.activity.enableEdgeToEdge
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.net.toUri
import androidx.lifecycle.lifecycleScope
import com.bumptech.glide.Glide
import com.google.android.gms.auth.api.signin.GoogleSignIn
import com.google.android.gms.auth.api.signin.GoogleSignInOptions
import com.google.android.gms.common.api.ApiException
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.FirebaseUser
import com.google.firebase.auth.GoogleAuthProvider
import com.google.firebase.auth.UserProfileChangeRequest
import com.google.firebase.firestore.FirebaseFirestore
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.MainActivity
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.ActivityRegisterBinding
import com.isanz.inmomarket.ui.portal.PortalViewModel
import com.isanz.inmomarket.ui.portal.login.LoginActivity
import com.isanz.inmomarket.utils.Constants
import kotlinx.coroutines.launch
class RegisterActivity : AppCompatActivity() {
private lateinit var auth: FirebaseAuth
private lateinit var mBinding: ActivityRegisterBinding
private lateinit var startForResult: ActivityResultLauncher<Intent>
private lateinit var db: FirebaseFirestore
private lateinit var viewModel: PortalViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
mBinding = ActivityRegisterBinding.inflate(layoutInflater)
setContentView(mBinding.root)
db = InmoMarket.getDb()
auth = InmoMarket.getAuth()
viewModel = PortalViewModel()
startForResult =
registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
if (result.resultCode == Activity.RESULT_OK) {
val task = GoogleSignIn.getSignedInAccountFromIntent(result.data)
try {
val account = task.getResult(ApiException::class.java)!!
firebaseAuthWithGoogle(account.idToken!!)
} catch (e: ApiException) {
Log.w(TAG, "Google sign in failed", e)
}
}
}
setUpButtons()
}
private fun setUpButtons() {
setContentView(mBinding.root)
// Register Button
mBinding.btnRegister.setOnClickListener {
val email = mBinding.tieEmail.text.toString()
val password = mBinding.tiePassword.text.toString()
createUserWithEmail(email, password)
}
mBinding.btnSignInGoogle.setOnClickListener {
registerGoogle()
}
mBinding.flAlreadyHaveAccount.setOnClickListener {
goToLogin()
}
lifecycleScope.launch {
setImage(mBinding.ivLogo)
}
}
private fun registerGoogle() {
val signInIntent = GoogleSignIn.getClient(
this,
GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestIdToken(getString(R.string.default_web_client_id)).requestEmail().build()
).signInIntent
startForResult.launch(signInIntent)
}
private fun firebaseAuthWithGoogle(idToken: String) {
val credential = GoogleAuthProvider.getCredential(idToken, null)
auth.signInWithCredential(credential).addOnCompleteListener(this) { task ->
if (task.isSuccessful) {
val user = auth.currentUser
val profileUpdates = UserProfileChangeRequest.Builder()
.setDisplayName(user!!.email.toString().split("@")[0].substring(0, 8)).build()
user.updateProfile(profileUpdates).addOnCompleteListener { taskProf ->
if (taskProf.isSuccessful) {
saveUserToFirestore(user)
goToMain(user)
}
}
} else {
Toast.makeText(baseContext, "Authentication failed.", Toast.LENGTH_SHORT).show()
}
}
}
private fun createUserWithEmail(email: String, password: String) {
val result = checkFields(email, password)
// com.isanz.inmomarket.utils.retrofit.com.isanz.inmomarket.utils.retrofit.Result must be true, if not send to Log the error message and set to false
if (result.second.not()) {
return
} else {
auth.createUserWithEmailAndPassword(email, password)
.addOnCompleteListener(this) { task ->
if (task.isSuccessful) {
// Sign in success, update UI change activity
val user = auth.currentUser
val username = user!!.email.toString().split("@")[0]
val displayName = if (username.length >= 8) username.substring(0, 8) else username
val profileUpdates = UserProfileChangeRequest.Builder()
.setPhotoUri(Constants.DEFAULT_IMAGE.toUri())
.setDisplayName(displayName)
.build()
user.updateProfile(profileUpdates).addOnCompleteListener { taskUpdate ->
if (taskUpdate.isSuccessful) {
saveUserToFirestore(user)
goToMain(user)
}
}
} else {
// If sign in fails, display a message to the user.
// Display error message
Toast.makeText(
baseContext,
"Authentication failed.",
Toast.LENGTH_SHORT,
).show()
}
}
}
}
private fun checkFields(email: String, password: String): Pair<String, Boolean> {
// Check if the email is empty
if (email.isEmpty()) {
mBinding.tieEmail.error = "Email is required"
return "Email is empty" to false
}
// Check if the email is valid
if (!android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches()) {
mBinding.tieEmail.error = "Email is not valid address"
return "Email is not valid $email" to false
}
// Check if the password is empty
if (password.isEmpty()) {
mBinding.tiePassword.error = "Password is required"
return "Password is empty" to false
}
// Check if the password is less than 6 characters
if (password.length < 6) {
mBinding.tiePassword.error = "Password must be at least 6 characters"
return "Password is less than 6 characters" to false
}
// Check if the password has at least one digit
if (!password.matches(".*\\d.*".toRegex())) {
mBinding.tiePassword.error = "Password must have at least one digit"
return "Password must have at least one digit" to false
}
// Check if the password has at least one special character
if (!password.matches(".*[!@#\$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?].*".toRegex())) {
mBinding.tiePassword.error = "Password must have at least one special character"
return "Password must have at least one special character" to false
}
return "User created successfully" to true
}
private fun saveUserToFirestore(user: FirebaseUser?) {
user?.let {
val userMap = hashMapOf(
"email" to user.email,
"displayName" to user.displayName ,
"photoUrl" to user.photoUrl
)
db.collection("users").document(user.uid).set(userMap)
}
}
private fun goToMain(user: FirebaseUser?) {
user?.let {
// Start the new activity (MainActivity)
val intent = Intent(this, MainActivity::class.java)
startActivity(intent)
// End the current activity (LoginActivity)
finish()
}
}
@Suppress("DEPRECATION")
private fun goToLogin() {
val intent = Intent(this, LoginActivity::class.java)
startActivity(intent)
overridePendingTransition(R.anim.slide_out_right, R.anim.slide_in_left)
finish()
}
private suspend fun setImage(view: ImageView) {
Glide.with(this).load(viewModel.getImageRandom()).centerCrop().into(view)
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/portal/register/RegisterActivity.kt | 1909632299 |
package com.isanz.inmomarket.ui.portal.login
import android.app.Activity
import android.content.ContentValues.TAG
import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.widget.ImageView
import android.widget.Toast
import androidx.activity.enableEdgeToEdge
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.biometric.BiometricPrompt
import androidx.core.content.ContextCompat
import androidx.lifecycle.lifecycleScope
import com.bumptech.glide.Glide
import com.google.android.gms.auth.api.signin.GoogleSignIn
import com.google.android.gms.auth.api.signin.GoogleSignInOptions
import com.google.android.gms.common.api.ApiException
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.FirebaseUser
import com.google.firebase.auth.GoogleAuthProvider
import com.google.firebase.auth.UserProfileChangeRequest
import com.google.firebase.firestore.FirebaseFirestore
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.MainActivity
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.ActivityLoginBinding
import com.isanz.inmomarket.ui.portal.PortalViewModel
import com.isanz.inmomarket.ui.portal.register.RegisterActivity
import kotlinx.coroutines.launch
class LoginActivity : AppCompatActivity() {
private lateinit var auth: FirebaseAuth
private lateinit var mBinding: ActivityLoginBinding
private lateinit var startForResult: ActivityResultLauncher<Intent>
private lateinit var db: FirebaseFirestore
private lateinit var viewModel: PortalViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
mBinding = ActivityLoginBinding.inflate(layoutInflater)
setContentView(mBinding.root)
viewModel = PortalViewModel()
this.auth = InmoMarket.getAuth()
this.db = FirebaseFirestore.getInstance()
val sharedPref = this.getSharedPreferences("settings_preferences", Context.MODE_PRIVATE)
if (sharedPref.getBoolean("biometricLogin", false)) {
showBiometricPrompt()
}
startForResult =
registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
if (result.resultCode == Activity.RESULT_OK) {
val task = GoogleSignIn.getSignedInAccountFromIntent(result.data)
try {
val account = task.getResult(ApiException::class.java)!!
firebaseAuthWithGoogle(account.idToken!!)
} catch (e: ApiException) {
Log.w(TAG, "Google sign in failed", e)
}
}
}
setUpButtons()
}
private fun setUpButtons() {
setContentView(mBinding.root)
// Register Button
mBinding.btnRegister.setOnClickListener {
val email = mBinding.tieEmail.text.toString()
val password = mBinding.tiePassword.text.toString()
signInUserWithEmail(email, password)
}
mBinding.btnSignInGoogle.setOnClickListener {
signInGoogle()
}
mBinding.flAlreadyHaveAccount.setOnClickListener {
goToRegister()
}
lifecycleScope.launch {
setImage(mBinding.ivLogo)
}
}
private fun showBiometricPrompt() {
val promptInfo = BiometricPrompt.PromptInfo.Builder().setTitle("Biometric login")
.setSubtitle("Log in using your biometric credential")
.setNegativeButtonText("Use account password").build()
val biometricPrompt = BiometricPrompt(this,
ContextCompat.getMainExecutor(this),
object : BiometricPrompt.AuthenticationCallback() {
override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
super.onAuthenticationError(errorCode, errString)
Toast.makeText(
applicationContext, "Authentication error: $errString", Toast.LENGTH_SHORT
).show()
}
override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
super.onAuthenticationSucceeded(result)
val currentUser = FirebaseAuth.getInstance().currentUser
if (currentUser != null) {
// User is signed in
Toast.makeText(
applicationContext, "Authentication succeeded!", Toast.LENGTH_SHORT
).show()
goToMain(currentUser)
} else {
// No user is signed in
Toast.makeText(
applicationContext,
"No user is currently logged in. Please log in first.",
Toast.LENGTH_SHORT
).show()
}
}
override fun onAuthenticationFailed() {
super.onAuthenticationFailed()
Toast.makeText(applicationContext, "Authentication failed", Toast.LENGTH_SHORT)
.show()
}
})
biometricPrompt.authenticate(promptInfo)
}
private fun signInGoogle() {
val signInIntent = GoogleSignIn.getClient(
this,
GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestIdToken(getString(R.string.default_web_client_id)).requestEmail().build()
).signInIntent
startForResult.launch(signInIntent)
}
private fun firebaseAuthWithGoogle(idToken: String) {
val credential = GoogleAuthProvider.getCredential(idToken, null)
auth.signInWithCredential(credential).addOnCompleteListener(this) { task ->
if (task.isSuccessful) {
val user = auth.currentUser
val profileUpdates = UserProfileChangeRequest.Builder()
.setDisplayName(user!!.email.toString().split("@")[0].substring(0, 8)).build()
user.updateProfile(profileUpdates).addOnCompleteListener { taskProf ->
if (taskProf.isSuccessful) {
saveUserToFirestore(user)
goToMain(user)
}
}
} else {
Toast.makeText(baseContext, "Authentication failed.", Toast.LENGTH_SHORT).show()
}
}
}
private fun signInUserWithEmail(email: String, password: String) {
val result = checkFields(email, password)
// com.isanz.inmomarket.utils.retrofit.com.isanz.inmomarket.utils.retrofit.Result must be true, if not send to Log the error message and set to false
if (result.second.not()) {
return
} else {
auth.signInWithEmailAndPassword(email, password).addOnCompleteListener(this) { task ->
if (task.isSuccessful) {
// Sign in success, update UI change activity
val user = auth.currentUser
goToMain(user)
} else {
// If sign in fails, display a message to the user.
// Display error message
Toast.makeText(
baseContext,
"Authentication failed.",
Toast.LENGTH_SHORT,
).show()
}
}
}
}
private fun checkFields(email: String, password: String): Pair<String, Boolean> {
// Check if the email is empty
if (email.isEmpty()) {
mBinding.tieEmail.error = "Email is required"
return "Email is empty" to false
}
// Check if the email is valid
if (!android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches()) {
mBinding.tieEmail.error = "Email is not valid address"
return "Email is not valid $email" to false
}
// Check if the password is empty
if (password.isEmpty()) {
mBinding.tiePassword.error = "Password is required"
return "Password is empty" to false
}
// Check if the password is less than 6 characters
if (password.length < 6) {
mBinding.tiePassword.error = "Password must be at least 6 characters"
return "Password is less than 6 characters" to false
}
// Check if the password has at least one digit
if (!password.matches(".*\\d.*".toRegex())) {
mBinding.tiePassword.error = "Password must have at least one digit"
return "Password must have at least one digit" to false
}
// Check if the password has at least one special character
if (!password.matches(".*[!@#\$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?].*".toRegex())) {
mBinding.tiePassword.error = "Password must have at least one special character"
return "Password must have at least one special character" to false
}
return "User created successfully" to true
}
private fun saveUserToFirestore(user: FirebaseUser?) {
user?.let {
val userMap = hashMapOf(
"email" to user.email,
"displayName" to user.displayName,
"photoUrl" to user.photoUrl
)
db.collection("users").document(user.uid).set(userMap)
}
}
private fun goToMain(user: FirebaseUser?) {
user?.let {
it.reload().addOnCompleteListener { task ->
if (task.isSuccessful) {
// User's data was successfully reloaded, the account exists in Firebase
// Start the new activity (MainActivity)
val intent = Intent(this, MainActivity::class.java)
startActivity(intent)
// End the current activity (LoginActivity)
finish()
} else {
// An error occurred while reloading the user's data, the account may not exist in Firebase
Toast.makeText(
applicationContext,
"An error occurred. Please log in again.",
Toast.LENGTH_SHORT
).show()
}
}
}
}
@Suppress("DEPRECATION")
private fun goToRegister() {
val intent = Intent(this, RegisterActivity::class.java)
startActivity(intent)
overridePendingTransition(R.anim.slide_in_left, R.anim.slide_out_right)
finish()
}
private suspend fun setImage(view: ImageView) {
Glide.with(this).load(viewModel.getImageRandom()).centerCrop().into(view)
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/portal/login/LoginActivity.kt | 396625793 |
package com.isanz.inmomarket.ui.chat
import android.os.Build
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.annotation.RequiresApi
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import androidx.navigation.fragment.findNavController
import androidx.recyclerview.widget.LinearLayoutManager
import com.bumptech.glide.Glide
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.FragmentChatBinding
import com.isanz.inmomarket.rv.chatItem.ChatListAdapter
import kotlinx.coroutines.launch
import kotlinx.coroutines.plus
class ChatFragment : Fragment() {
private lateinit var mBinding: FragmentChatBinding
private lateinit var viewModel: ChatViewModel
private lateinit var idChat: String
private lateinit var recipientId: String
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
idChat = requireArguments().getString("idChat")!!
recipientId = InmoMarket.getAuth().currentUser?.uid!!
viewModel = ChatViewModel()
}
@RequiresApi(Build.VERSION_CODES.O)
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
): View {
// Inflate the layout for this fragment
mBinding = FragmentChatBinding.inflate(inflater, container, false)
setUpView()
return mBinding.root
}
@RequiresApi(Build.VERSION_CODES.O)
private fun setUpView() {
lifecycleScope.launch {
val users = viewModel.getUsersInConversation(idChat).await()
val otherUser = users.find { it.uid != recipientId }
mBinding.tvNameChat.text = otherUser?.displayName
otherUser?.photoUrl?.let { loadImage(it) }
}
setUpButtons()
setUpRecyclerView()
}
private fun setUpRecyclerView() {
val adapter = ChatListAdapter()
val layoutManager = LinearLayoutManager(context)
mBinding.recyclerView.layoutManager = layoutManager
mBinding.recyclerView.adapter = adapter
viewModel.messageList.observe(viewLifecycleOwner) { messages ->
adapter.submitList(messages) {
// Scroll to the last position after the list has been updated
mBinding.recyclerView.scrollToPosition(0)
}
}
viewModel.retrieveMessages(idChat)
}
private fun loadImage(imageUri: String){
Glide.with(this)
.load(imageUri)
.circleCrop()
.into(mBinding.ivProfileChat)
}
@RequiresApi(Build.VERSION_CODES.O)
private fun setUpButtons() {
mBinding.fabSendMessage.setOnClickListener {
val text = mBinding.tieMessage.text.toString()
viewModel.sendMessage(text, idChat, recipientId)
mBinding.tieMessage.text?.clear()
}
mBinding.ibBack.setOnClickListener {
findNavController().navigate(R.id.action_navigation_chat_to_navigation_messages)
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/chat/ChatFragment.kt | 4014960477 |
package com.isanz.inmomarket.ui.chat
import android.content.ContentValues.TAG
import android.os.Build
import android.util.Log
import androidx.annotation.RequiresApi
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ValueEventListener
import com.google.firebase.database.ktx.database
import com.google.firebase.firestore.ktx.firestore
import com.google.firebase.ktx.Firebase
import com.isanz.inmomarket.utils.entities.Chat
import com.isanz.inmomarket.utils.entities.Message
import com.isanz.inmomarket.utils.entities.User
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.tasks.await
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlin.coroutines.suspendCoroutine
class ChatViewModel : ViewModel() {
private val database: FirebaseDatabase = Firebase.database
private val _messageList = MutableLiveData<List<Message>>()
val messageList: LiveData<List<Message>> get() = _messageList
@RequiresApi(Build.VERSION_CODES.O)
fun sendMessage(text: String, chatId: String, senderId: String) {
val current = LocalDateTime.now()
val dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd")
val timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss")
val message = Message(
message = text,
senderId = senderId,
messageDate = current.format(dateFormatter),
messageTime = current.format(timeFormatter)
)
database.getReference("chatMessages").child(chatId).push().setValue(message)
}
fun getUsersInConversation(chatId: String): Deferred<List<User>> {
return CoroutineScope(Dispatchers.IO).async {
try {
val chatRef = FirebaseDatabase.getInstance().getReference("chats").child(chatId)
val chatSnapshot = suspendCoroutine { continuation ->
chatRef.addListenerForSingleValueEvent(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
continuation.resume(snapshot)
}
override fun onCancelled(error: DatabaseError) {
continuation.resumeWithException(error.toException())
}
})
}
val chat = chatSnapshot.getValue(Chat::class.java)
val deferreds = chat?.membersId?.map { id ->
async {
val userDocument = Firebase.firestore.collection("users").document(id).get().await()
userDocument.toObject(User::class.java)?.also { user ->
user.uid = id
}
}
}
deferreds?.awaitAll()?.filterNotNull() ?: emptyList()
} catch (e: Exception) {
Log.e(TAG, "Error getting users in conversation", e)
emptyList()
}
}
}
fun retrieveMessages(chatId: String) {
val messageRef = database.getReference("chatMessages").child(chatId)
val messageListener = object : ValueEventListener {
override fun onDataChange(dataSnapshot: DataSnapshot) {
val tempList = mutableListOf<Message>()
for (messageSnapshot in dataSnapshot.children) {
val message = messageSnapshot.getValue(Message::class.java)
if (message != null) {
tempList.add(message)
}
}
_messageList.value = tempList
}
override fun onCancelled(databaseError: DatabaseError) {
Log.w(TAG, "loadMessage:onCancelled", databaseError.toException())
}
}
messageRef.addValueEventListener(messageListener)
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/chat/ChatViewModel.kt | 764419512 |
package com.isanz.inmomarket.ui.property
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.animation.AnimationUtils
import android.widget.ImageView
import android.widget.LinearLayout
import androidx.core.content.ContextCompat
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import androidx.navigation.fragment.findNavController
import androidx.viewpager2.widget.ViewPager2
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.FragmentPropertyBinding
import com.isanz.inmomarket.rv.CarouselAdapter
import com.isanz.inmomarket.rv.extraItem.ExtraListAdapter
import com.isanz.inmomarket.utils.entities.Property
import kotlinx.coroutines.launch
class PropertyFragment : Fragment() {
private var propertyId: String? = null
private lateinit var viewModel: PropertyViewModel
private var mBinding: FragmentPropertyBinding? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
propertyId = arguments?.getString("propertyId")
viewModel = PropertyViewModel()
}
private fun setUpButtons(property: Property) {
mBinding?.btnChat?.setOnClickListener {
viewModel.addChat(InmoMarket.getAuth().currentUser!!.uid, property.userId) { chatId ->
val bundle = Bundle().apply {
putString("idChat", chatId)
}
this.findNavController().navigate(R.id.action_navigation_property_to_chatFragment, bundle)
}
}
val updateFavoriteIcon: (Boolean) -> Unit = { isFavorite ->
if (isFavorite) {
mBinding?.ibFavorite?.setImageResource(R.drawable.ic_favorite)
} else {
mBinding?.ibFavorite?.setImageResource(R.drawable.ic_favorite_border)
}
}
// Call the getIfFavorite function from the ViewModel
viewModel.getIfFavorite(property, updateFavoriteIcon)
// Load the animation
val rotateAnimation = AnimationUtils.loadAnimation(mBinding?.ibFavorite?.context, R.anim.rotate)
mBinding?.ibFavorite?.setOnClickListener {
// Start the animation
it.startAnimation(rotateAnimation)
viewModel.alterFavorite(property, updateFavoriteIcon)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
): View {
mBinding = FragmentPropertyBinding.inflate(layoutInflater)
val binding = mBinding // Introduce a local read-only variable
val extraAdapter = ExtraListAdapter("PropertyFragment")
binding?.rvExtras?.adapter = extraAdapter
return binding?.root ?: View(context)
}
private suspend fun setUp(propertyId: String?) {
val property = viewModel.retrieveProperty(propertyId!!)
val binding = mBinding // Introduce a local read-only variable
if (property != null && binding != null) { // Check if binding is not null
binding.tvProperty.text = property.tittle
binding.tvDescription.text = property.description
binding.tvAddress.text = property.location
"Price: ${property.price} €".also { binding.tvPrice.text = it }
val imageList = property.listImagesUri
val adapter = CarouselAdapter(imageList)
mBinding?.vpProperty?.adapter = adapter
setupIndicators(imageList.size)
mBinding?.vpProperty?.registerOnPageChangeCallback(object : ViewPager2.OnPageChangeCallback() {
override fun onPageSelected(position: Int) {
super.onPageSelected(position)
setCurrentIndicator(position)
}
})
// Load extra rv
loadExtras(property)
setUpButtons(property)
binding.progressBar.visibility = View.GONE
}
}
private fun setupIndicators(count: Int) {
mBinding?.indicatorLayout?.removeAllViews() // Clear existing indicators
val indicators = arrayOfNulls<ImageView>(count)
val layoutParams: LinearLayout.LayoutParams = LinearLayout.LayoutParams(
ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT
)
layoutParams.setMargins(8, 0, 8, 0)
for (i in indicators.indices) {
indicators[i] = ImageView(context)
indicators[i]?.let {
it.setImageDrawable(
ContextCompat.getDrawable(
requireContext(),
R.drawable.ic_outline_circle
)
)
it.layoutParams = layoutParams
mBinding?.indicatorLayout?.addView(it)
}
}
}
private fun setCurrentIndicator(index: Int) {
val childCount = mBinding?.indicatorLayout?.childCount
for (i in 0 until childCount!!) {
val imageView = mBinding?.indicatorLayout?.getChildAt(i) as ImageView
if (i == index) {
imageView.setImageDrawable(
ContextCompat.getDrawable(
requireContext(),
R.drawable.ic_circle
)
)
} else {
imageView.setImageDrawable(
ContextCompat.getDrawable(
requireContext(),
R.drawable.ic_outline_circle
)
)
}
}
}
private fun loadExtras(property: Property?) {
// Get the adapter from the RecyclerView
val extraAdapter = mBinding?.rvExtras?.adapter as ExtraListAdapter
// Convert the Map to a List of Pairs and submit it to the adapter
property?.extras?.let { extras ->
val extrasList = extras.toList()
extraAdapter.submitList(extrasList)
}
}
override fun onResume() {
super.onResume()
lifecycleScope.launch {
setUp(propertyId)
}
}
override fun onDetach() {
super.onDetach()
mBinding = null // Nullify your view binding
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/property/PropertyFragment.kt | 2956235553 |
package com.isanz.inmomarket.ui.property
import android.util.Log
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ValueEventListener
import com.google.firebase.database.ktx.database
import com.google.firebase.firestore.FieldValue
import com.google.firebase.firestore.FirebaseFirestore
import com.google.firebase.ktx.Firebase
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.utils.entities.Chat
import com.isanz.inmomarket.utils.entities.Property
import kotlinx.coroutines.launch
import kotlinx.coroutines.tasks.await
class PropertyViewModel : ViewModel() {
private val db = FirebaseFirestore.getInstance()
private val database: FirebaseDatabase = Firebase.database
private val user = InmoMarket.getAuth().currentUser
fun getIfFavorite(property: Property, callback: (Boolean) -> Unit) {
val docRef = db.collection("properties").document(property.id!!)
docRef.get().addOnSuccessListener { document ->
val favorites = document.get("favorites") as? List<*>
if (favorites != null && favorites.contains(user!!.uid)) {
callback(true)
} else {
callback(false)
}
}
}
fun alterFavorite(property: Property, updateFavoriteIcon: (Boolean) -> Unit) {
viewModelScope.launch {
val docRef = db.collection("properties").document(property.id!!)
docRef.get().addOnSuccessListener { document ->
val favorites = document.get("favorites") as? List<*>
if (favorites != null && favorites.contains(user!!.uid)) {
// Optimistically update the UI
updateFavoriteIcon(false)
// If the user's ID is already in the favorites array, remove it
docRef.update("favorites", FieldValue.arrayRemove(user.uid))
.addOnFailureListener {
// If the update fails, revert the UI change
updateFavoriteIcon(true)
}
} else {
// Optimistically update the UI
updateFavoriteIcon(true)
// If the user's ID is not in the favorites array, add it
docRef.update("favorites", FieldValue.arrayUnion(user!!.uid))
.addOnFailureListener {
// If the update fails, revert the UI change
updateFavoriteIcon(false)
}
}
}
}
}
suspend fun retrieveProperty(propertyId: String): Property? {
return try {
val document = db.collection("properties").document(propertyId).get().await()
if (document.exists()) {
val property = document.toObject(Property::class.java)
property?.id = document.id
property
} else {
null
}
} catch (e: Exception) {
Log.e("com.isanz.inmomarket.ui.property.PropertyViewModel", "Error retrieving property", e)
null
}
}
fun addChat(senderId: String, recipientId: String, callback: (String) -> Unit) {
val chatRef = database.getReference("chats")
chatRef.addListenerForSingleValueEvent(object : ValueEventListener {
override fun onDataChange(dataSnapshot: DataSnapshot) {
var chatId: String? = null
for (snapshot in dataSnapshot.children) {
val chat = snapshot.getValue(Chat::class.java)
if (chat?.membersId?.containsAll(listOf(senderId, recipientId)) == true ||
chat?.membersId?.containsAll(listOf(recipientId, senderId)) == true) {
chatId = snapshot.key
break
}
}
if (chatId == null) {
chatId = chatRef.push().key!!
chatRef.child(chatId).setValue(Chat(chatId = chatId, membersId = mutableListOf(senderId, recipientId)))
}
callback(chatId)
}
override fun onCancelled(databaseError: DatabaseError) {
Log.e("ChatViewModel", "Error adding chat", databaseError.toException())
}
})
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/property/PropertyViewModel.kt | 2261854682 |
package com.isanz.inmomarket.ui.search
import android.content.ContentValues.TAG
import android.util.Log
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.utils.Constants
import com.isanz.inmomarket.utils.retrofit.GeocodingResponse
import com.isanz.inmomarket.utils.retrofit.GeocodingService
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.util.Collections
class SearchViewModel : ViewModel() {
private val db = InmoMarket.getDb()
private val retrofit = Retrofit.Builder().baseUrl("https://maps.googleapis.com/")
.addConverterFactory(GsonConverterFactory.create()).build()
private val geocodingService = retrofit.create(GeocodingService::class.java)
private fun getAllAdresses(): LiveData<List<Pair<String, String>>> {
val addressesLiveData = MutableLiveData<List<Pair<String, String>>>()
val currentUserId = InmoMarket.getAuth().currentUser!!.uid
db.collection("properties").get().addOnSuccessListener { result ->
val addressesList = result.documents.mapNotNull { document ->
val userId = document.getString("userId") // replace "userId" with the actual field name in your Firestore documents
val location = document.getString("location") // replace "location" with the actual field name in your Firestore documents
if (userId != currentUserId && location != null) Pair(document.id, location) else null
}
addressesLiveData.value = addressesList
}.addOnFailureListener { exception ->
Log.w(TAG, "Error getting documents.", exception)
}
return addressesLiveData
}
fun getLatAndLong(): LiveData<List<Triple<String, Double, Double>>> {
val locationsLiveData = MutableLiveData<List<Triple<String, Double, Double>>>()
val locationsList = Collections.synchronizedList(ArrayList<Triple<String, Double, Double>>())
getAllAdresses().observeForever { addresses ->
addresses?.forEach { (id, address) ->
geocodingService.getLatLng(address, Constants.API_GOOGLE)
.enqueue(object : Callback<GeocodingResponse> {
override fun onResponse(
call: Call<GeocodingResponse>, response: Response<GeocodingResponse>
) {
if (response.isSuccessful) {
val geocodingResponse = response.body()
val location = geocodingResponse?.results?.get(0)?.geometry?.location
if (location != null) {
locationsList.add(Triple(id, location.lat, location.lng))
locationsLiveData.value = locationsList
}
}
}
override fun onFailure(call: Call<GeocodingResponse>, t: Throwable) {
Log.w(TAG, "Error getting location for address $address.", t)
}
})
}
}
return locationsLiveData
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/search/SearchViewModel.kt | 3157786591 |
package com.isanz.inmomarket.ui.search
import android.Manifest
import android.annotation.SuppressLint
import android.content.Context
import android.content.pm.PackageManager
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.core.app.ActivityCompat
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.fragment.findNavController
import com.google.android.gms.location.FusedLocationProviderClient
import com.google.android.gms.location.LocationServices
import com.google.android.gms.maps.CameraUpdateFactory
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.OnMapReadyCallback
import com.google.android.gms.maps.SupportMapFragment
import com.google.android.gms.maps.model.BitmapDescriptorFactory
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.model.MarkerOptions
import com.isanz.inmomarket.R
import com.isanz.inmomarket.utils.Constants
@Suppress("DEPRECATION")
class SearchFragment : Fragment(), OnMapReadyCallback {
private lateinit var mMap: GoogleMap
private lateinit var fusedLocationClient: FusedLocationProviderClient
private lateinit var searchViewModel: SearchViewModel
private var allowUbication: Boolean = false
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
val view = inflater.inflate(R.layout.fragment_search, container, false)
// ViewModel
searchViewModel = ViewModelProvider(this)[SearchViewModel::class.java]
val mapFragment = childFragmentManager.findFragmentById(R.id.map) as SupportMapFragment
mapFragment.getMapAsync(this)
// Initialize fusedLocationClient
fusedLocationClient = LocationServices.getFusedLocationProviderClient(requireActivity())
// Retrieve the value from SharedPreferences
val sharedPref =
requireActivity().getSharedPreferences("settings_preferences", Context.MODE_PRIVATE)
allowUbication = sharedPref.getBoolean("allowUbication", false)
return view
}
override fun onMapReady(googleMap: GoogleMap) {
mMap = googleMap
if (ActivityCompat.checkSelfPermission(
requireContext(), Manifest.permission.ACCESS_FINE_LOCATION
) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(
requireContext(), Manifest.permission.ACCESS_COARSE_LOCATION
) != PackageManager.PERMISSION_GRANTED
) {
requestPermissions(
arrayOf(
Manifest.permission.ACCESS_FINE_LOCATION,
Manifest.permission.ACCESS_COARSE_LOCATION
), Constants.LOCATION_PERMISSION_REQUEST_CODE
)
return
}
enableUserLocation()
}
@Deprecated("Deprecated in Java")
override fun onRequestPermissionsResult(
requestCode: Int, permissions: Array<String>, grantResults: IntArray
) {
if (requestCode == Constants.LOCATION_PERMISSION_REQUEST_CODE) {
if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// Permission was granted, enable user location
enableUserLocation()
} else {
// Permission was denied. Disable the functionality that depends on this permission.
Toast.makeText(requireContext(), "Permission denied", Toast.LENGTH_SHORT).show()
}
}
}
@SuppressLint("MissingPermission") // Cuando lleguemos ya sabremos si tenemos permisos o no
private fun enableUserLocation() {
if (allowUbication) {
mMap.isMyLocationEnabled = true
mMap.isMyLocationEnabled = true
fusedLocationClient.lastLocation.addOnSuccessListener { location ->
if (location != null) {
val currentLatLng = LatLng(location.latitude, location.longitude)
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(currentLatLng, 15f))
searchViewModel.getLatAndLong().observe(viewLifecycleOwner) { locations ->
locations?.forEach { latLongIdPairs ->
val markerLatLng = LatLng(latLongIdPairs.second, latLongIdPairs.third)
val customMarker = BitmapDescriptorFactory.fromBitmap(resizeBitmap())
val marker = mMap.addMarker(
MarkerOptions().position(markerLatLng).icon(customMarker)
)
marker?.tag =
latLongIdPairs.first // You can set any object as a tag to identify the marker when it's clicked
}
}
}
}
} else {
Toast.makeText(requireContext(), "Ubication not allowed", Toast.LENGTH_SHORT).show()
}
mMap.setOnMarkerClickListener { marker ->
// Create a bundle to pass the property ID
val args = Bundle()
args.putString("propertyId", marker.tag as String)
// Navigate to the MiniPropertyFragment
findNavController().navigate(R.id.navigation_mini_property, args)
false // Return false to make the camera move to the marker and an info window to appear
}
}
private fun resizeBitmap(): Bitmap {
val imageBitmap = BitmapFactory.decodeResource(resources, R.drawable.house)
return Bitmap.createScaledBitmap(imageBitmap, 100, 100, false)
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/search/SearchFragment.kt | 2135765647 |
package com.isanz.inmomarket.ui.add
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.firebase.firestore.FirebaseFirestore
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.utils.entities.Property
import kotlinx.coroutines.launch
import kotlinx.coroutines.tasks.await
class AddViewModel : ViewModel() {
private val db = FirebaseFirestore.getInstance()
fun save(
tittle: String,
description: String,
location: String,
images: List<String>,
extras: HashMap<String, Int>,
price: Double,
squareMeters: Double
): String {
var result = ""
val property = Property(
tittle = tittle,
description = description,
location = location,
userId = InmoMarket.getAuth().currentUser?.uid ?: "",
listImagesUri = images,
extras = extras,
price = price,
squareMeters = squareMeters
)
viewModelScope.launch {
try {
db.collection("properties").add(property).addOnSuccessListener {
result = "com.isanz.inmomarket.utils.entities.Property added successfully"
}.await().id
} catch (e: Exception) {
result = "An error occurred"
e.message ?: "An error occurred"
}
}
return result
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/add/AddViewModel.kt | 1848470866 |
package com.isanz.inmomarket.ui.add
import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.core.content.ContextCompat
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.google.android.libraries.places.api.Places
import com.google.android.libraries.places.api.model.Place
import com.google.android.libraries.places.widget.Autocomplete
import com.google.android.libraries.places.widget.model.AutocompleteActivityMode
import com.google.firebase.firestore.FirebaseFirestore
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.FragmentAddBinding
import com.isanz.inmomarket.rv.imageItem.ImageListAdapter
import com.isanz.inmomarket.utils.Constants
import java.util.UUID
@Suppress("DEPRECATION")
class AddFragment : Fragment() {
private lateinit var mBinding: FragmentAddBinding
private lateinit var db: FirebaseFirestore
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
): View {
mBinding = FragmentAddBinding.inflate(inflater, container, false)
val root: View = mBinding.root
db = InmoMarket.getDb()
// Initialize the RecyclerView adapter
val adapter = ImageListAdapter()
mBinding.rvImages.adapter = adapter
if (!Places.isInitialized()) {
Places.initialize(requireContext(), Constants.API_GOOGLE)
}
mBinding.tieAddress.setOnClickListener {
val fields = listOf(Place.Field.ID, Place.Field.NAME, Place.Field.ADDRESS)
val intent = Autocomplete.IntentBuilder(AutocompleteActivityMode.OVERLAY, fields)
.build(requireContext())
startActivityForResult(intent, Constants.REQUEST_CODE_AUTOCOMPLETE)
}
setUpButtons()
setUpDrawables()
return root
}
private fun setUpDrawables() {
val drawableBath = ContextCompat.getDrawable(requireContext(), R.drawable.ic_bathroom)
val drawableRooms = ContextCompat.getDrawable(requireContext(), R.drawable.ic_bedroom)
val drawableMeters = ContextCompat.getDrawable(requireContext(), R.drawable.ic_square_foot)
val drawableFloor = ContextCompat.getDrawable(requireContext(), R.drawable.ic_house_siding)
val drawablePrice = ContextCompat.getDrawable(requireContext(), R.drawable.ic_euro_symbol)
mBinding.tieBats.setCompoundDrawablesWithIntrinsicBounds(null, null, drawableBath, null)
mBinding.tieRooms.setCompoundDrawablesWithIntrinsicBounds(null, null, drawableRooms, null)
mBinding.tieSquareMeters.setCompoundDrawablesWithIntrinsicBounds(
null, null, drawableMeters, null
)
mBinding.tieFloors.setCompoundDrawablesWithIntrinsicBounds(null, null, drawableFloor, null)
mBinding.tiePrice.setCompoundDrawablesWithIntrinsicBounds(null, null, drawablePrice, null)
}
private fun setUpButtons() {
mBinding.btnLoadImages.setOnClickListener {
loadImages()
}
mBinding.btnSave.setOnClickListener {
save(addViewModel = ViewModelProvider(this)[AddViewModel::class.java])
}
}
private fun save(addViewModel: AddViewModel) {
val tittle = mBinding.tieTittle.text.toString()
val description = mBinding.tieDescription.text.toString()
val location = mBinding.tieAddress.text.toString()
val baths = mBinding.tieBats.text.toString().toIntOrNull() ?: 0
val rooms = mBinding.tieRooms.text.toString().toIntOrNull() ?: 0
val squareMeters = mBinding.tieSquareMeters.text.toString().toIntOrNull() ?: 0
val floors = mBinding.tieFloors.text.toString().toIntOrNull() ?: 0
val price = mBinding.tiePrice.text.toString().toIntOrNull() ?: 0
if (validateFields(tittle, description, location, baths, rooms)) {
mBinding.view.visibility = View.VISIBLE
mBinding.progressBar.visibility = View.VISIBLE
val adapter = (mBinding.rvImages.adapter as? ImageListAdapter)
val listImagesUri = adapter?.currentList?.map { it } ?: emptyList()
val images = mutableListOf<String>()
for (uri in listImagesUri) {
val imageName = UUID.randomUUID().toString()
val ref =
InmoMarket.getStorage().reference.child("images/${InmoMarket.getAuth().currentUser!!.uid}/$imageName")
val extras = hashMapOf(
"rooms" to rooms,
"baths" to baths,
"squareMeters" to squareMeters,
"floors" to floors
)
ref.putFile(Uri.parse(uri)).addOnSuccessListener {
ref.downloadUrl.addOnSuccessListener {
images.add(it.toString())
if (images.size == listImagesUri.size) {
addViewModel.save(
tittle,
description,
location,
images,
extras,
price.toDouble(),
squareMeters.toDouble()
)
updateUI()
}
}
}
}
}
}
private fun validateFields(
tittle: String, description: String, location: String, baths: Int, rooms: Int
): Boolean {
if (tittle.isEmpty()) {
mBinding.tieTittle.error = getString(R.string.tittle_is_required)
return false
}
if (tittle.length < 5) {
mBinding.tieTittle.error = getString(R.string.tittle_must_be_at_least_5_characters)
return false
}
if (description.isEmpty()) {
mBinding.tieDescription.error = getString(R.string.description_is_required)
return false
}
if (description.length < 20) {
mBinding.tieDescription.error = getString(R.string.description_least_20)
return false
}
if (location.isEmpty()) {
mBinding.tieAddress.error = getString(R.string.location_is_required)
return false
}
if (baths == 0) {
mBinding.tieBats.error = getString(R.string.baths_is_required)
return false
}
if (rooms == 0) {
mBinding.tieRooms.error = getString(R.string.rooms_is_required)
return false
}
val adapter = (mBinding.rvImages.adapter as? ImageListAdapter)
val listImagesUri = adapter?.currentList?.map { it } ?: emptyList()
if (listImagesUri.size < 3) {
Toast.makeText(context, getString(R.string.images_3), Toast.LENGTH_SHORT).show()
return false
}
return true
}
private fun updateUI() {
mBinding.tieTittle.text?.clear()
mBinding.tieDescription.text?.clear()
mBinding.tieAddress.text?.clear()
mBinding.tieBats.text?.clear()
mBinding.tieRooms.text?.clear()
(mBinding.rvImages.adapter as? ImageListAdapter)?.submitList(emptyList())
mBinding.rvImages.visibility = View.GONE
mBinding.view.visibility = View.GONE
mBinding.progressBar.visibility = View.GONE
}
private fun loadImages() {
val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
addCategory(Intent.CATEGORY_OPENABLE)
type = "image/*"
putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
}
startActivityForResult(intent, Constants.REQUEST_CODE_PICK_IMAGES)
}
@Deprecated("Deprecated in Java")
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
if (requestCode == Constants.REQUEST_CODE_PICK_IMAGES && resultCode == Activity.RESULT_OK) {
val clipData = data?.clipData
val imageUris = mutableListOf<String>()
if (clipData != null) {
// Multiple images were selected
for (i in 0 until clipData.itemCount) {
val uri = clipData.getItemAt(i).uri
imageUris.add(uri.toString())
}
} else {
// Single image was selected
val uri = data?.data
if (uri != null) {
imageUris.add(uri.toString())
}
}
// Load the images into the RecyclerView
val adapter = (mBinding.rvImages.adapter as? ImageListAdapter)
adapter?.submitList(imageUris)
mBinding.rvImages.visibility = View.VISIBLE
} else if (requestCode == Constants.REQUEST_CODE_AUTOCOMPLETE && resultCode == Activity.RESULT_OK) {
val place = Autocomplete.getPlaceFromIntent(data!!)
mBinding.tieAddress.setText(place.address)
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/add/AddFragment.kt | 4289433424 |
package com.isanz.inmomarket.ui.profile.tabs.favorites
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.navigation.fragment.findNavController
import androidx.recyclerview.widget.LinearLayoutManager
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.FragmentFavoritesProfileBinding
import com.isanz.inmomarket.rv.propertyItem.PropertyItemListAdapter
import com.isanz.inmomarket.utils.interfaces.OnItemClickListener
class FavoritesProfileFragment : Fragment(), OnItemClickListener {
private lateinit var mBinging: FragmentFavoritesProfileBinding
private lateinit var favoritesProfileViewModel: FavoritesProfileViewModel
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
// Inflate the layout for this fragment
mBinging = FragmentFavoritesProfileBinding.inflate(inflater, container, false)
favoritesProfileViewModel = FavoritesProfileViewModel()
setupRecyclerView()
return mBinging.root
}
override fun onResume() {
super.onResume()
setupRecyclerView()
}
override fun onItemClicked(propertyId: String) {
val bundle = Bundle().apply {
putString("propertyId", propertyId)
}
this.findNavController().navigate(R.id.action_navigation_profile_to_navigation_property, bundle)
}
private fun setupRecyclerView() {
val adapter = PropertyItemListAdapter(this)
mBinging.favoritesRecyclerView.adapter = adapter
// Set the LayoutManager
mBinging.favoritesRecyclerView.layoutManager = LinearLayoutManager(context)
// Observe the data from the ViewModel
favoritesProfileViewModel.listFavorites.observe(viewLifecycleOwner) { parcelas ->
// Update the adapter with the new list of Parcela objects
adapter.submitList(parcelas)
if (parcelas.isEmpty()) {
mBinging.emptyTextView.visibility = View.VISIBLE
} else {
mBinging.emptyTextView.visibility = View.GONE
}
mBinging.favoritesProgressBar.visibility = View.GONE
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/profile/tabs/favorites/FavoritesProfileFragment.kt | 1803276556 |
package com.isanz.inmomarket.ui.profile.tabs.favorites
import android.content.ContentValues
import android.util.Log
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.utils.entities.Property
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
class FavoritesProfileViewModel : ViewModel() {
val db = InmoMarket.getDb()
private val _listfavorites = MutableLiveData<MutableList<Property>>()
val listFavorites: LiveData<MutableList<Property>> = _listfavorites
init {
viewModelScope.launch {
try {
listenForFavorites()
} catch (e: Exception) {
Log.w(ContentValues.TAG, "Listen failed.", e)
}
}
}
private suspend fun listenForFavorites() = withContext(Dispatchers.IO) {
db.collection("properties").addSnapshotListener { snapshot, e ->
if (e != null) {
Log.w(ContentValues.TAG, "Listen failed.", e)
return@addSnapshotListener
}
if (snapshot != null) {
val properties = mutableListOf<Property>()
val currentUserId = InmoMarket.getAuth().currentUser!!.uid
for (document in snapshot.documents) {
if (document.exists()) {
val property = document.toObject(Property::class.java)
property?.id = document.id
if (property?.favorites!!.contains(currentUserId)) {
property.let { properties.add(it) }
}
}
}
_listfavorites.postValue(properties)
}
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/profile/tabs/favorites/FavoritesProfileViewModel.kt | 3168049312 |
package com.isanz.inmomarket.ui.profile.tabs.uploads
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.navigation.fragment.findNavController
import androidx.recyclerview.widget.LinearLayoutManager
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.FragmentFavoritesProfileBinding
import com.isanz.inmomarket.databinding.FragmentYourUploadsProfileBinding
import com.isanz.inmomarket.rv.propertyItem.PropertyItemListAdapter
import com.isanz.inmomarket.ui.profile.tabs.favorites.FavoritesProfileViewModel
import com.isanz.inmomarket.utils.interfaces.OnItemClickListener
class YourUploadsProfileFragment : Fragment(), OnItemClickListener {
private lateinit var mBinging: FragmentYourUploadsProfileBinding
private lateinit var favoritesProfileViewModel: YourUploadsProfileViewModel
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
// Inflate the layout for this fragment
mBinging = FragmentYourUploadsProfileBinding.inflate(inflater, container, false)
favoritesProfileViewModel = YourUploadsProfileViewModel()
return mBinging.root
}
override fun onResume() {
super.onResume()
setupRecyclerView()
}
override fun onItemClicked(propertyId: String) {
val bundle = Bundle().apply {
putString("propertyId", propertyId)
}
this.findNavController().navigate(R.id.action_navigation_profile_to_navigation_property, bundle)
}
private fun setupRecyclerView() {
val adapter = PropertyItemListAdapter(this)
mBinging.favoritesRecyclerView.adapter = adapter
adapter.attachToRecyclerView(mBinging.favoritesRecyclerView)
// Set the LayoutManager
mBinging.favoritesRecyclerView.layoutManager = LinearLayoutManager(context)
// Observe the data from the ViewModel
favoritesProfileViewModel.listParcelas.observe(viewLifecycleOwner) { parcelas ->
// Update the adapter with the new list of Parcela objects
adapter.submitList(parcelas)
Log.i("FavoritesProfileFragment", "Parcelas: $parcelas")
if (parcelas.isEmpty()) {
mBinging.emptyTextView.visibility = View.VISIBLE
} else {
mBinging.emptyTextView.visibility = View.GONE
}
mBinging.favoritesProgressBar.visibility = View.GONE
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/profile/tabs/uploads/YourUploadsProfileFragment.kt | 3846921699 |
package com.isanz.inmomarket.ui.profile.tabs.uploads
import android.content.ContentValues
import android.util.Log
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.firebase.firestore.FirebaseFirestore
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.utils.entities.Property
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
class YourUploadsProfileViewModel : ViewModel() {
private val _listParcelas = MutableLiveData<List<Property>>()
val listParcelas: LiveData<List<Property>> = _listParcelas
private val db = FirebaseFirestore.getInstance()
init {
viewModelScope.launch {
try {
listenForParcelasUpdates()
} catch (e: Exception) {
Log.w(ContentValues.TAG, "Listen failed.", e)
}
}
}
private suspend fun listenForParcelasUpdates() = withContext(Dispatchers.IO) {
db.collection("properties").addSnapshotListener { snapshot, e ->
if (e != null) {
Log.w(ContentValues.TAG, "Listen failed.", e)
return@addSnapshotListener
}
if (snapshot != null) {
val properties = mutableListOf<Property>()
val currentUserId = InmoMarket.getAuth().currentUser!!.uid
for (document in snapshot.documents) {
if (document.exists()) {
val property = document.toObject(Property::class.java)
property?.id = document.id
if (property?.userId == currentUserId) {
property.let { properties.add(it) }
}
}
}
_listParcelas.postValue(properties)
} else {
Log.d(ContentValues.TAG, "Current data: null")
}
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/profile/tabs/uploads/YourUploadsProfileViewModel.kt | 3185099870 |
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentActivity
import androidx.viewpager2.adapter.FragmentStateAdapter
import com.isanz.inmomarket.ui.profile.tabs.favorites.FavoritesProfileFragment
import com.isanz.inmomarket.ui.profile.tabs.uploads.YourUploadsProfileFragment
class ViewPagerAdapter(fragmentActivity: FragmentActivity) : FragmentStateAdapter(fragmentActivity) {
override fun getItemCount(): Int {
// Return the total number of tabs
return 2
}
override fun createFragment(position: Int): Fragment {
// Return a new instance of the Fragment for the given position
return when (position) {
0 -> FavoritesProfileFragment() // Replace with your actual Fragment class
1 -> YourUploadsProfileFragment() // Replace with your actual Fragment class
else -> throw IllegalStateException("Invalid position")
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/profile/ViewPagerAdapter.kt | 2130168582 |
package com.isanz.inmomarket.ui.profile
import android.net.Uri
import androidx.lifecycle.ViewModel
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.firestore.FirebaseFirestore
import com.google.firebase.storage.FirebaseStorage
import com.isanz.inmomarket.InmoMarket
import com.isanz.inmomarket.utils.entities.User
import kotlinx.coroutines.tasks.await
class ProfileViewModel : ViewModel() {
private val db = InmoMarket.getDb()
suspend fun retrieveProfile(): User {
val user =
db.collection("users").document(InmoMarket.getAuth().currentUser!!.uid).get().await()
return user.toObject(User::class.java)!!
}
fun updateUserProfilePhoto(imageUri: Uri) {
val userId = FirebaseAuth.getInstance().currentUser?.uid ?: return
val storageRef = FirebaseStorage.getInstance().getReference("/images/$userId")
storageRef.putFile(imageUri).addOnSuccessListener {
storageRef.downloadUrl.addOnSuccessListener { uri ->
val db = FirebaseFirestore.getInstance()
db.collection("users").document(userId).update("photoUrl", uri.toString())
}
}
}
fun signOut(): Boolean {
return try {
InmoMarket.getAuth().signOut()
true
} catch (e: Exception) {
false
}
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/profile/ProfileViewModel.kt | 2356427419 |
package com.isanz.inmomarket.ui.profile
import ViewPagerAdapter
import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import androidx.core.view.GravityCompat
import androidx.drawerlayout.widget.DrawerLayout
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.lifecycleScope
import androidx.navigation.fragment.findNavController
import com.bumptech.glide.Glide
import com.google.android.material.navigation.NavigationView
import com.google.android.material.tabs.TabLayoutMediator
import com.isanz.inmomarket.R
import com.isanz.inmomarket.databinding.FragmentProfileBinding
import com.isanz.inmomarket.ui.portal.login.LoginActivity
import com.isanz.inmomarket.utils.Constants
import kotlinx.coroutines.launch
class ProfileFragment : Fragment() {
private lateinit var mBinding: FragmentProfileBinding
private lateinit var navView: NavigationView
private lateinit var drawerLayout: DrawerLayout
private val profileViewModel: ProfileViewModel by lazy {
ViewModelProvider(this)[ProfileViewModel::class.java]
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
): View {
mBinding = FragmentProfileBinding.inflate(inflater, container, false)
lifecycleScope.launch {
setUpView()
}
setUpDrawer()
setUpTabs()
setUpButtons()
return mBinding.root
}
private fun setUpButtons() {
mBinding.profileLayout.ivProfile.setOnClickListener {
val intent = Intent(Intent.ACTION_PICK)
intent.type = "image/*"
startActivityForResult(intent, Constants.REQUEST_CODE_PICK_IMAGES)
}
}
@Deprecated("Deprecated in Java")
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
if (requestCode == Constants.REQUEST_CODE_PICK_IMAGES && resultCode == Activity.RESULT_OK && data != null) {
val imageUri = data.data
loadImage(mBinding.profileLayout.ivProfile, imageUri.toString())
if (imageUri != null) {
profileViewModel.updateUserProfilePhoto(imageUri)
}
}
}
private fun setUpTabs() {
val tabLayout = mBinding.profileLayout.tabLayout
val viewPager = mBinding.profileLayout.viewPager
val adapter = ViewPagerAdapter(requireActivity())
viewPager.adapter = adapter
TabLayoutMediator(tabLayout, viewPager) { tab, position ->
when (position) {
0 -> tab.text = getString(R.string.tab_favorites)
1 -> tab.text = getString(R.string.tab_your_uploads)
else -> throw IllegalStateException("Invalid position")
}
}.attach()
}
private fun setUpDrawer() {
mBinding.profileLayout.ibDrawer.setOnClickListener {
mBinding.drawerLayout.openDrawer(GravityCompat.START)
}
navView.setNavigationItemSelectedListener {
when (it.itemId) {
R.id.nav_logout -> {
if (profileViewModel.signOut()) {
val intent = Intent(activity, LoginActivity::class.java)
startActivity(intent)
activity?.finish()
}
}
R.id.nav_about -> {
val url = "https://github.com/Zenin0/InmoMarket" // replace with your URL
val intent = Intent(Intent.ACTION_VIEW)
intent.data = Uri.parse(url)
startActivity(intent)
}
R.id.nav_settings -> {
this.findNavController()
.navigate(R.id.action_navigation_profile_to_settingsFragment)
}
R.id.nav_share -> {
val sendIntent: Intent = Intent().apply {
action = Intent.ACTION_SEND
putExtra(Intent.EXTRA_TEXT, "https://github.com/Zenin0/InmoMarket")
type = "text/plain"
}
val shareIntent = Intent.createChooser(sendIntent, null)
startActivity(shareIntent)
}
}
drawerLayout.closeDrawer(GravityCompat.START)
true
}
}
private suspend fun setUpView() {
navView = mBinding.navView
drawerLayout = mBinding.drawerLayout
val user = profileViewModel.retrieveProfile()
loadImage(mBinding.profileLayout.ivProfile, user.photoUrl!!)
mBinding.profileLayout.tvName.text = user.displayName
}
private fun loadImage(view: ImageView, url: String) {
Glide.with(view.context).load(url).circleCrop().into(view)
}
} | InmoMarket/app/src/main/java/com/isanz/inmomarket/ui/profile/ProfileFragment.kt | 1338305126 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.