content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
class Mesa {
} | 1dam-restaurante-poo-lnarote777/Restaurante/src/main/kotlin/Mesa.kt | 2429108309 |
fun main() {
// Inicialización de mesas
val mesas = listOf(
Mesa(numero = 1, capacidad = 4),
Mesa(numero = 2, capacidad = 2),
Mesa(numero = 3, capacidad = 6)
)
// Inicialización del sistema de gestión de restaurante
val sistema = SistemaGestionRestaurante(mesas)
// Creación de platos
val plato1 = Plato("Hamburguesa", 9.99, 8, mutableListOf("carne", "huevo", "queso", "pan", "tomate"))
val plato2 = Plato("Ensalada", 7.99, 5, mutableListOf("lechuga", "tomate", "zanahoria", "maíz"))
val plato3 = Plato("Tortilla", 5.99, 10, mutableListOf("huevo", "patata"))
val plato4 = Plato("Serranito", 6.00, 4, mutableListOf("carne", "pimiento", "pan", "jamón serrano"))
val plato5 = Plato("Spagetti carbonara", 6.00, 12, mutableListOf("huevo", "pasta", "bacon", "nata"))
val plato6 = Plato("Rissotto setas", 6.00, 12, mutableListOf("arroz", "setas", "gambas", "nata"))
// Agregar ingredientes
plato1.agregarIngrediente("salsa")
plato2.agregarIngrediente("atún")
//Simular el registro de comensales a una mesa
mesas[0].ocuparMesa() // Ocupar mesa 1
// Creación de pedidos
val pedido1 = Pedido()
pedido1.agregarPlato(plato1)
pedido1.agregarPlato(plato2)
pedido1.agregarPlato(plato3)
pedido1.agregarPlato(plato4)
println("***** Pedido ${pedido1.numero} *****")
println(pedido1)
// Simulación del proceso de los pedidos
sistema.realizarPedido(1, pedido1)
println("***** Mesa ${mesas[0].numero} *****")
println(mesas[0])
//Simular el registro de comensales a una mesa
mesas[1].ocuparMesa() // Ocupar mesa 2
//Crear otro pedido
val pedido2 = Pedido()
pedido2.agregarPlato(plato2)
pedido2.agregarPlato(plato3)
pedido2.agregarPlato(plato4)
// Simulación del proceso de los pedidos
sistema.realizarPedido(2, pedido2)
//Crear un segundo pedido para la mesa 2
val pedido3 = Pedido()
pedido3.agregarPlato(plato5)
pedido3.agregarPlato(plato6)
// Simulación del proceso de los pedidos
sistema.realizarPedido(2, pedido3)
println("***** Mesa ${mesas[1].numero} *****")
println(mesas[1])
// Cerrar pedidos y liberar mesas
sistema.cerrarPedido(1)
sistema.cerrarMesa(1)
sistema.cerrarPedido(2)
sistema.cerrarMesa(2)
// Buscar platos y contar pedidos
val platosPedidos = sistema.buscarPlatos() ?: listOf()
if (platosPedidos.isNotEmpty()) {
println("Platos pedidos: ${platosPedidos.joinToString()}")
}
else {
println("No existen platos.")
}
val contPlato = sistema.contarPlato("Ensalada") ?: 0
println("El plato 'Ensalada' fue pedido $contPlato " +
"${if (contPlato == 1) "vez" else "veces" }.")
val platosMasPedidos = sistema.buscarPlatoMasPedido()
if (platosMasPedidos != null) {
println("${if (platosMasPedidos.size == 1)
"El plato más pedido es " else "Los platos más pedidos son "} " +
"${platosMasPedidos.joinToString()}.")
}
else {
println("No existen platos.")
}
} | 1dam-restaurante-poo-lnarote777/Restaurante/src/main/kotlin/Main.kt | 3178698949 |
class SistemaGestionRestaurante(private val mesas: List<Mesa>) {
fun realizarPedido(numeroMesa: Int, pedido: Pedido) {
//TODO desarrollar este método...
}
fun cerrarPedido(numeroMesa: Int, numeroPedido: Int? = null) {
//TODO desarrollar este método...
}
fun cerrarMesa(numeroMesa: Int) {
//TODO desarrollar este método...
}
fun buscarPlatos(): List<String>? {
val platos = mesas.flatMap { it.pedidos }.flatMap { it.platos }.map { it.nombre }
return platos.ifEmpty { null }
}
fun contarPlato(nombre: String): Int? {
val count = mesas.flatMap { it.pedidos }
.flatMap { it.platos }
.count { it.nombre == nombre }
return if (count > 0) count else null
}
fun buscarPlatoMasPedido(): List<String>? {
val platoCounts = mesas.flatMap { it.pedidos }
.flatMap { it.platos }
.groupingBy { it.nombre }
.eachCount()
val maxCount = platoCounts.maxByOrNull { it.value }?.value
return maxCount?.let { max -> platoCounts.filter { it.value == max }.keys.toList() }
}
} | 1dam-restaurante-poo-lnarote777/Restaurante/src/main/kotlin/SistemaGestionRestaurante.kt | 957403360 |
class Plato(nombre: String, precio: Double, tiempoPreparacion: Int, ingredientes:
MutableList<String> ) {
val nombre = nombre
val precio = precio
val tiempoPreparacion = tiempoPreparacion
val ingredientes = ingredientes
init {
require(nombre.isNotBlank()){"El nombre del plato no puede estar vacío."}
require(precio > 0){"El precio no puede se negativo."}
require(tiempoPreparacion > 1) {"El tiempo de preparación no puede ser tan bajo."}
require(ingredientes.isNotEmpty()){"No puede haber un ingrediente vacío."}
}
fun agregarIngrediente(ingrediente:String){
ingredientes.add(ingrediente)
}
override fun toString(): String {
return "${this.nombre} (${this.tiempoPreparacion} min.) -> ${this.precio}€ (${this.ingredientes.joinToString(", ")})"
}
} | 1dam-restaurante-poo-lnarote777/Restaurante/src/main/kotlin/Plato.kt | 2878610798 |
package dev.proptit.messenger
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("dev.proptit.messenger", appContext.packageName)
}
} | P_Messager/app/src/androidTest/java/dev/proptit/messenger/ExampleInstrumentedTest.kt | 4242979326 |
package dev.proptit.messenger
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)
}
} | P_Messager/app/src/test/java/dev/proptit/messenger/ExampleUnitTest.kt | 701771230 |
package dev.proptit.messenger
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class MyApp : Application() | P_Messager/app/src/main/java/dev/proptit/messenger/MyApp.kt | 776285533 |
package dev.proptit.messenger.di
import android.content.Context
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import dev.proptit.messenger.setup.PrefManager
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
@Provides
@Singleton
fun providePrefManager(context: Context): PrefManager {
return PrefManager(context)
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/di/AppModule.kt | 2465330180 |
package dev.proptit.messenger.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import dev.proptit.messenger.data.maper.ContactMapper
import dev.proptit.messenger.data.maper.MessageMapper
import dev.proptit.messenger.data.remote.NetworkManager
import dev.proptit.messenger.data.remote.service.ContactService
import dev.proptit.messenger.data.remote.service.MessageService
import dev.proptit.messenger.domain.repository.ContactRepository
import dev.proptit.messenger.domain.repository.MessageRepository
import dev.proptit.messenger.setup.PrefManager
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
@Provides
@Singleton
fun provideRetrofit(): Retrofit {
return Retrofit.Builder()
.baseUrl("https://f2dc-104-28-222-75.ngrok-free.app/")
.addConverterFactory(GsonConverterFactory.create())
.build()
}
@Provides
@Singleton
fun provideContactService(retrofit: Retrofit): ContactService {
return retrofit.create(ContactService::class.java)
}
@Provides
@Singleton
fun provideMessageService(retrofit: Retrofit): MessageService {
return retrofit.create(MessageService::class.java)
}
@Provides
@Singleton
fun provideContactMapper(): ContactMapper {
return ContactMapper
}
@Provides
@Singleton
fun provideMessageMapper(): MessageMapper {
return MessageMapper
}
@Provides
@Singleton
fun provideNetworkManager(
contactService: ContactService,
contactRepository: ContactRepository,
messageService: MessageService,
messageRepository: MessageRepository,
contactMapper : ContactMapper,
messageMapper : MessageMapper,
prefManager: PrefManager
): NetworkManager {
return NetworkManager(
contactService,
contactRepository,
messageService,
messageRepository,
contactMapper,
messageMapper,
prefManager
)
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/di/NetworkModule.kt | 79245925 |
package dev.proptit.messenger.di
import android.content.Context
import androidx.room.Room
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import dev.proptit.messenger.data.local.AppDatabase
import dev.proptit.messenger.data.local.dao.ContactDao
import dev.proptit.messenger.data.local.dao.MessageDao
import dev.proptit.messenger.data.repository.ContactRepositoryImpl
import dev.proptit.messenger.data.repository.MessageRepositoryImpl
import dev.proptit.messenger.domain.repository.ContactRepository
import dev.proptit.messenger.domain.repository.MessageRepository
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object DatabaseModule {
@Provides
@Singleton
fun provideContext(@ApplicationContext context: Context): Context {
return context
}
@Provides
@Singleton
fun provideDatabase(context: Context): AppDatabase {
return Room.databaseBuilder(context, AppDatabase::class.java, "app_database")
.build()
}
@Provides
@Singleton
fun provideContactDao(database: AppDatabase) = database.contactDao()
@Provides
@Singleton
fun provideMessageDao(database: AppDatabase) = database.messageDao()
@Provides
@Singleton
fun provideContactRepository(contactDao: ContactDao): ContactRepository {
return ContactRepositoryImpl(contactDao)
}
@Provides
@Singleton
fun provideMessageRepository(messageDao: MessageDao): MessageRepository {
return MessageRepositoryImpl(messageDao)
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/di/DatabaseModule.kt | 298906372 |
package dev.proptit.messenger.setup
import android.content.Context
class PrefManager(private val context: Context) {
fun get(key: String, defaultValue: String): String {
val sharedPreferences =
context.getSharedPreferences(Keys.SHARED_PREF_NAME, Context.MODE_PRIVATE)
return sharedPreferences.getString(key, defaultValue) ?: defaultValue
}
fun put(key: String, value: String) {
val sharedPreferences =
context.getSharedPreferences(Keys.SHARED_PREF_NAME, Context.MODE_PRIVATE)
val editor = sharedPreferences.edit()
editor.putString(key, value)
editor.apply()
}
fun get(key: String, defaultValue: Boolean): Boolean {
val sharedPreferences =
context.getSharedPreferences(Keys.SHARED_PREF_NAME, Context.MODE_PRIVATE)
return sharedPreferences.getBoolean(key, defaultValue)
}
fun put(key: String, value: Boolean) {
val sharedPreferences =
context.getSharedPreferences(Keys.SHARED_PREF_NAME, Context.MODE_PRIVATE)
val editor = sharedPreferences.edit()
editor.putBoolean(key, value)
editor.apply()
}
fun get(key: String, defaultValue: Int): Int {
val sharedPreferences =
context.getSharedPreferences(Keys.SHARED_PREF_NAME, Context.MODE_PRIVATE)
return sharedPreferences.getInt(key, defaultValue)
}
fun put(key: String, value: Int) {
val sharedPreferences =
context.getSharedPreferences(Keys.SHARED_PREF_NAME, Context.MODE_PRIVATE)
val editor = sharedPreferences.edit()
editor.putInt(key, value)
editor.apply()
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/setup/PrefManager.kt | 2256544689 |
package dev.proptit.messenger.setup
object Keys {
const val MY_ACCOUNT_ID = "my_account_id"
const val SHARED_PREF_NAME = "messenger"
} | P_Messager/app/src/main/java/dev/proptit/messenger/setup/Keys.kt | 4104517940 |
package dev.proptit.messenger.data.repository
import dev.proptit.messenger.data.local.dao.ContactDao
import dev.proptit.messenger.data.local.entity.ContactEntity
import dev.proptit.messenger.data.maper.ContactMapper
import dev.proptit.messenger.domain.model.Contact
import dev.proptit.messenger.domain.repository.ContactRepository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.withContext
import javax.inject.Inject
class ContactRepositoryImpl @Inject constructor(
private val contactDao: ContactDao
) : ContactRepository {
override fun getAllContact(): Flow<List<Contact>> {
return contactDao.getAllContact().map { allContacts ->
allContacts.map { ContactMapper.getContactFromContactEntity(it) }
}
}
override suspend fun getContactByUserId(myId: Int): Flow<List<Contact>> {
return withContext(Dispatchers.IO) {
contactDao.getContactByUserId(myId).map { allContacts ->
allContacts.map { ContactMapper.getContactFromContactEntity(it) }
}
}
}
override suspend fun addContact(contact: Contact): Long {
return withContext(Dispatchers.IO) {
contactDao.addContact(ContactMapper.getContactEntityFromContact(contact))
}
}
override suspend fun addListContact(contacts: List<ContactEntity>) {
return withContext(Dispatchers.IO) {
contactDao.addListContact(contacts)
}
}
override suspend fun getById(id: Int): Contact {
return withContext(Dispatchers.IO) {
ContactMapper.getContactFromContactEntity(contactDao.getById(id))
}
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/data/repository/ContactRepositoryImpl.kt | 4120676138 |
package dev.proptit.messenger.data.repository
import dev.proptit.messenger.data.local.dao.MessageDao
import dev.proptit.messenger.data.local.entity.MessageEntity
import dev.proptit.messenger.data.maper.MessageMapper
import dev.proptit.messenger.domain.model.Message
import dev.proptit.messenger.domain.repository.MessageRepository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.withContext
import javax.inject.Inject
class MessageRepositoryImpl @Inject constructor(private val messageDao: MessageDao) :
MessageRepository {
override suspend fun addMessage(message: Message): Long {
return withContext(Dispatchers.IO) {
messageDao.addMessage(MessageMapper.getMessageEntityFromMessage(message))
}
}
override suspend fun addListMessage(messages: List<MessageEntity>) {
return withContext(Dispatchers.IO) {
messageDao.addListMessage(messages)
}
}
override suspend fun getMessageByContactId(id: Int, myId: Int): Flow<List<Message>> {
return withContext(Dispatchers.IO) {
messageDao.getMessageByContactId(id, myId).map { allMessages ->
allMessages.map { MessageMapper.getMessageFromMessageEntity(it) }
}
}
}
override suspend fun getAllMessages(): Flow<List<Message>> {
return withContext(Dispatchers.IO) {
messageDao.getAllMessages().map { allMessages ->
allMessages.map { MessageMapper.getMessageFromMessageEntity(it) }
}
}
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/data/repository/MessageRepositoryImpl.kt | 2746421015 |
package dev.proptit.messenger.data.local.entity
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity(tableName = "contact")
data class ContactEntity(
@PrimaryKey(autoGenerate = true)
val id: Int,
val name: String,
val avatar: String,
)
| P_Messager/app/src/main/java/dev/proptit/messenger/data/local/entity/ContactEntity.kt | 2505038622 |
package dev.proptit.messenger.data.local.entity
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity(tableName = "message")
data class MessageEntity(
@PrimaryKey(autoGenerate = true)
val id: Int = 0,
val message: String,
val idSendContact: Int,
val idReceiveContact: Int,
val time: Long = System.currentTimeMillis(),
)
| P_Messager/app/src/main/java/dev/proptit/messenger/data/local/entity/MessageEntity.kt | 2862758927 |
package dev.proptit.messenger.data.local.dao
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import dev.proptit.messenger.data.local.entity.MessageEntity
import kotlinx.coroutines.flow.Flow
@Dao
interface MessageDao {
@Insert(entity = MessageEntity::class, onConflict = OnConflictStrategy.REPLACE)
suspend fun addMessage(message: MessageEntity): Long
@Insert(entity = MessageEntity::class, onConflict = OnConflictStrategy.REPLACE)
suspend fun addListMessage(messages: List<MessageEntity>)
@Query("select * from message where (idSendContact = :myId AND idReceiveContact = :id) OR (idReceiveContact = :myId AND idSendContact = :id)")
fun getMessageByContactId(id: Int, myId: Int): Flow<List<MessageEntity>>
@Query("select * from message")
fun getAllMessages(): Flow<List<MessageEntity>>
} | P_Messager/app/src/main/java/dev/proptit/messenger/data/local/dao/MessageDao.kt | 601778426 |
package dev.proptit.messenger.data.local.dao
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import dev.proptit.messenger.data.local.entity.ContactEntity
import kotlinx.coroutines.flow.Flow
@Dao
interface ContactDao {
@Query("SELECT * FROM contact")
fun getAllContact(): Flow<List<ContactEntity>>
@Query("SELECT DISTINCT c.* FROM contact c INNER JOIN message m ON c.id = m.idSendContact OR c.id = m.idReceiveContact WHERE (m.idSendContact = :myId OR m.idReceiveContact = :myId) AND c.id != :myId")
fun getContactByUserId(myId: Int): Flow<List<ContactEntity>>
@Insert(entity = ContactEntity::class, onConflict = OnConflictStrategy.REPLACE)
suspend fun addContact(contact: ContactEntity): Long
@Insert(entity = ContactEntity::class, onConflict = OnConflictStrategy.REPLACE)
suspend fun addListContact(contacts: List<ContactEntity>)
@Query("SELECT * FROM contact WHERE id = :id")
suspend fun getById(id: Int): ContactEntity
} | P_Messager/app/src/main/java/dev/proptit/messenger/data/local/dao/ContactDao.kt | 2479588363 |
package dev.proptit.messenger.data.local
import androidx.room.Database
import androidx.room.RoomDatabase
import dev.proptit.messenger.data.local.dao.ContactDao
import dev.proptit.messenger.data.local.dao.MessageDao
import dev.proptit.messenger.data.local.entity.ContactEntity
import dev.proptit.messenger.data.local.entity.MessageEntity
@Database(
entities = [ContactEntity::class, MessageEntity::class],
version = 1,
exportSchema = false
)
abstract class AppDatabase : RoomDatabase() {
abstract fun messageDao(): MessageDao
abstract fun contactDao(): ContactDao
} | P_Messager/app/src/main/java/dev/proptit/messenger/data/local/AppDatabase.kt | 3065663705 |
package dev.proptit.messenger.data.maper
import dev.proptit.messenger.data.local.entity.MessageEntity
import dev.proptit.messenger.data.remote.dto.MessageOutputDto
import dev.proptit.messenger.domain.model.Message
object MessageMapper {
fun getListMessageEntityFromListMessageOutputDto(messageOutputDto: List<MessageOutputDto>?): List<MessageEntity> {
val messages = mutableListOf<MessageEntity>()
messageOutputDto?.forEach {
messages.add(
MessageEntity(
id = it.id,
idSendContact = it.idSendContact,
idReceiveContact = it.idReceiveContact,
message = it.message,
time = it.time
)
)
}
return messages
}
fun getMessageEntityFromMessage(message: Message): MessageEntity {
return MessageEntity(
id = message.id,
idSendContact = message.idSendContact,
idReceiveContact = message.idReceiveContact,
message = message.message,
time = message.time
)
}
fun getMessageFromMessageEntity(messageEntity: MessageEntity): Message {
return Message(
id = messageEntity.id,
idSendContact = messageEntity.idSendContact,
idReceiveContact = messageEntity.idReceiveContact,
message = messageEntity.message,
time = messageEntity.time
)
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/data/maper/MessageMapper.kt | 3789536898 |
package dev.proptit.messenger.data.maper
import dev.proptit.messenger.data.local.entity.ContactEntity
import dev.proptit.messenger.data.remote.dto.ContactOutputDto
import dev.proptit.messenger.domain.model.Contact
object ContactMapper {
fun getListContactEntityFromListContactOutputDto(contactOutputDto: List<ContactOutputDto>?): List<ContactEntity> {
val contacts = mutableListOf<ContactEntity>()
contactOutputDto?.forEach {
contacts.add(
ContactEntity(
it.id,
it.name,
it.avatar,
)
)
}
return contacts
}
fun getContactEntityFromContact( contact: Contact): ContactEntity {
return ContactEntity(
contact.id,
contact.name,
contact.avatar,
)
}
fun getContactFromContactEntity(contactEntity: ContactEntity): Contact {
return Contact(
contactEntity.id,
contactEntity.name,
contactEntity.avatar,
)
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/data/maper/ContactMapper.kt | 934922338 |
package dev.proptit.messenger.data.remote.dto
import com.google.gson.annotations.SerializedName
data class MessageOutputDto(
@SerializedName("id")
var id: Int = 0,
@SerializedName("message")
var message: String = "",
@SerializedName("idSendContact")
var idSendContact: Int = 0,
@SerializedName("idReceiveContact")
var idReceiveContact: Int = 0,
@SerializedName("time")
var time: Long = 0,
)
| P_Messager/app/src/main/java/dev/proptit/messenger/data/remote/dto/MessageOutputDto.kt | 120240720 |
package dev.proptit.messenger.data.remote.dto
import com.google.gson.annotations.SerializedName
data class ContactRegisterInputDto(
@SerializedName("name")
val name: String = "",
@SerializedName("avatar")
val avatar: String = "",
@SerializedName("username")
val username: String = "",
@SerializedName("password")
val password: String = "",
)
| P_Messager/app/src/main/java/dev/proptit/messenger/data/remote/dto/ContactRegisterInputDto.kt | 2663427587 |
package dev.proptit.messenger.data.remote.dto
import com.google.gson.annotations.SerializedName
data class ContactOutputDto(
@SerializedName("id")
var id: Int = 0,
@SerializedName("name")
var name: String = "",
@SerializedName("avatar")
var avatar: String = "",
) | P_Messager/app/src/main/java/dev/proptit/messenger/data/remote/dto/ContactOutputDto.kt | 2553698463 |
package dev.proptit.messenger.data.remote.dto
import com.google.gson.annotations.SerializedName
data class ContactLoginInputDto(
@SerializedName("username")
val username: String = "",
@SerializedName("password")
val password: String = ""
)
| P_Messager/app/src/main/java/dev/proptit/messenger/data/remote/dto/ContactLoginInputDto.kt | 1281277870 |
package dev.proptit.messenger.data.remote.dto
import com.google.gson.annotations.SerializedName
data class MessageCreateInputDto(
@SerializedName("message")
val message: String = "",
@SerializedName("idSendContact")
val idSendContact: Int = 0,
@SerializedName("idReceiveContact")
val idReceiveContact: Int = 0,
@SerializedName("time")
val time: Long = 0
)
| P_Messager/app/src/main/java/dev/proptit/messenger/data/remote/dto/MessageCreateInputDto.kt | 1361510059 |
package dev.proptit.messenger.data.remote
import dev.proptit.messenger.data.maper.ContactMapper
import dev.proptit.messenger.data.maper.MessageMapper
import dev.proptit.messenger.data.remote.dto.ContactOutputDto
import dev.proptit.messenger.data.remote.dto.MessageOutputDto
import dev.proptit.messenger.data.remote.service.ContactService
import dev.proptit.messenger.data.remote.service.MessageService
import dev.proptit.messenger.domain.repository.ContactRepository
import dev.proptit.messenger.domain.repository.MessageRepository
import dev.proptit.messenger.setup.Keys
import dev.proptit.messenger.setup.PrefManager
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import javax.inject.Inject
class NetworkManager @Inject constructor(
private val contactService: ContactService,
private val contactRepository: ContactRepository,
private val messageService: MessageService,
private val messageRepository: MessageRepository,
private val contactMapper: ContactMapper,
private val messageMapper: MessageMapper,
private val prefManager: PrefManager
) {
private var job: Job? = null
fun register() {
job = CoroutineScope(Dispatchers.IO).launch {
while (true) {
delay(2000)
updateContact()
updateMessage()
}
}
}
private fun updateContact() {
val call =
contactService.getAllContact()
call.enqueue(object : Callback<List<ContactOutputDto>> {
override fun onResponse(
call: Call<List<ContactOutputDto>>,
response: Response<List<ContactOutputDto>>
) {
if (response.isSuccessful) {
val contacts = response.body()
CoroutineScope(Dispatchers.IO).launch {
contactRepository.addListContact(
contactMapper.getListContactEntityFromListContactOutputDto(contacts)
)
}
}
}
override fun onFailure(call: Call<List<ContactOutputDto>>, t: Throwable) {
}
})
}
private fun updateMessage() {
val call =
messageService.findAllMessageWithContactId(prefManager.get(Keys.MY_ACCOUNT_ID, -1))
call.enqueue(object : Callback<List<MessageOutputDto>> {
override fun onResponse(
call: Call<List<MessageOutputDto>>,
response: Response<List<MessageOutputDto>>
) {
if (response.isSuccessful) {
val messages = response.body()
CoroutineScope(Dispatchers.IO).launch {
messageRepository.addListMessage(
messageMapper.getListMessageEntityFromListMessageOutputDto(messages)
)
}
}
}
override fun onFailure(call: Call<List<MessageOutputDto>>, t: Throwable) {
}
})
}
fun unregister() {
job?.cancel()
job = null
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/data/remote/NetworkManager.kt | 2149475631 |
package dev.proptit.messenger.data.remote.service
import dev.proptit.messenger.data.remote.dto.MessageCreateInputDto
import dev.proptit.messenger.data.remote.dto.MessageOutputDto
import retrofit2.Call
import retrofit2.http.Body
import retrofit2.http.GET
import retrofit2.http.POST
import retrofit2.http.Path
interface MessageService {
@POST("api/message/create")
fun createMessage(@Body message: MessageCreateInputDto): Call<MessageOutputDto>
@GET("api/message/{idContact}")
fun findAllMessageWithContactId(@Path("idContact") idContact: Int): Call<List<MessageOutputDto>>
} | P_Messager/app/src/main/java/dev/proptit/messenger/data/remote/service/MessageService.kt | 3443130958 |
package dev.proptit.messenger.data.remote.service
import dev.proptit.messenger.data.remote.dto.ContactLoginInputDto
import dev.proptit.messenger.data.remote.dto.ContactOutputDto
import dev.proptit.messenger.data.remote.dto.ContactRegisterInputDto
import retrofit2.Call
import retrofit2.http.Body
import retrofit2.http.GET
import retrofit2.http.POST
import retrofit2.http.Path
interface ContactService {
@POST("api/contact/register")
fun register(@Body data: ContactRegisterInputDto): Call<Int>
@POST("api/contact/login")
fun login(@Body data: ContactLoginInputDto): Call<Int>
@GET("api/contact/get_contact_with_user/{idContact}")
fun findAllContactWithContactId(@Path("idContact") idContact: Int): Call<List<ContactOutputDto>>
@GET("api/contact")
fun getAllContact(): Call<List<ContactOutputDto>>
}
| P_Messager/app/src/main/java/dev/proptit/messenger/data/remote/service/ContactService.kt | 1039487437 |
package dev.proptit.messenger.domain.repository
import dev.proptit.messenger.data.local.entity.ContactEntity
import dev.proptit.messenger.domain.model.Contact
import kotlinx.coroutines.flow.Flow
interface ContactRepository {
fun getAllContact(): Flow<List<Contact>>
suspend fun getContactByUserId(myId: Int): Flow<List<Contact>>
suspend fun addContact(contact: Contact): Long
suspend fun addListContact(contacts: List<ContactEntity>)
suspend fun getById(id: Int): Contact
} | P_Messager/app/src/main/java/dev/proptit/messenger/domain/repository/ContactRepository.kt | 2066767323 |
package dev.proptit.messenger.domain.repository
import dev.proptit.messenger.data.local.entity.MessageEntity
import dev.proptit.messenger.domain.model.Message
import kotlinx.coroutines.flow.Flow
interface MessageRepository {
suspend fun addMessage(message: Message): Long
suspend fun addListMessage(messages: List<MessageEntity>)
suspend fun getMessageByContactId(id: Int, myId: Int): Flow<List<Message>>
suspend fun getAllMessages(): Flow<List<Message>>
} | P_Messager/app/src/main/java/dev/proptit/messenger/domain/repository/MessageRepository.kt | 429051444 |
package dev.proptit.messenger.domain.model
data class Contact(
val id: Int,
val name: String,
val avatar: String,
)
| P_Messager/app/src/main/java/dev/proptit/messenger/domain/model/Contact.kt | 3218838995 |
package dev.proptit.messenger.domain.model
data class Message(
val id: Int = 0,
val message: String,
val idSendContact: Int,
val idReceiveContact: Int,
val time: Long = System.currentTimeMillis(),
)
| P_Messager/app/src/main/java/dev/proptit/messenger/domain/model/Message.kt | 3779310907 |
package dev.proptit.messenger.presentation
import android.util.Log
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import dev.proptit.messenger.data.remote.dto.MessageCreateInputDto
import dev.proptit.messenger.data.remote.dto.MessageOutputDto
import dev.proptit.messenger.data.remote.service.MessageService
import dev.proptit.messenger.domain.model.Contact
import dev.proptit.messenger.domain.model.Message
import dev.proptit.messenger.domain.repository.ContactRepository
import dev.proptit.messenger.domain.repository.MessageRepository
import dev.proptit.messenger.setup.Keys
import dev.proptit.messenger.setup.PrefManager
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import javax.inject.Inject
@HiltViewModel
class MainViewModel @Inject constructor(
private val contactRepository: ContactRepository,
private val messageRepository: MessageRepository,
private val messageService: MessageService,
private val prefManager: PrefManager
) : ViewModel() {
private val _allContacts = MutableStateFlow<List<Contact>>(listOf())
val allContacts = _allContacts.asStateFlow()
private val _people = MutableStateFlow<List<Contact>>(listOf())
val people = _people.asStateFlow()
private val _contact = MutableStateFlow(Contact(0, "", ""))
val contact = _contact.asStateFlow()
private val _allMessage = MutableStateFlow<List<Message>>(listOf())
val allMessages = _allMessage.asStateFlow()
private var job: Job? = null
init {
viewModelScope.launch {
contactRepository.getContactByUserId(prefManager.get(Keys.MY_ACCOUNT_ID, -1))
.collect { list ->
_allContacts.update { list }
}
}
viewModelScope.launch {
contactRepository.getAllContact()
.collect { list ->
_people.update {
list.filter {
it.id != prefManager.get(
Keys.MY_ACCOUNT_ID,
-1
)
}
}
}
}
}
fun sendMessage(message: String, idSendContact: Int, idReceiveContact: Int) {
val call = messageService.createMessage(
MessageCreateInputDto(
message,
idSendContact,
idReceiveContact
)
)
call.enqueue(object : Callback<MessageOutputDto> {
override fun onResponse(
call: Call<MessageOutputDto>,
response: Response<MessageOutputDto>
) {
if (response.isSuccessful) {
Log.d("TAG", "onResponse: ${response.body()}")
}
}
override fun onFailure(call: Call<MessageOutputDto>, t: Throwable) {
Log.d("TAG", "onFailure: ${t.message}")
}
})
}
fun setContact(myId: Int, id: Int) {
job?.cancel()
viewModelScope.launch {
_contact.update {
getContactById(id)
}
}
_allMessage.update { listOf() }
job = viewModelScope.launch {
messageRepository.getMessageByContactId(myId, id).collect { list ->
_allMessage.update { list }
}
}
}
private fun getContactById(id: Int): Contact {
return _people.value.find { it.id == id } ?: Contact(0, "", "")
}
}
| P_Messager/app/src/main/java/dev/proptit/messenger/presentation/MainViewModel.kt | 1722109194 |
package dev.proptit.messenger.presentation.splash
import android.annotation.SuppressLint
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.lifecycle.lifecycleScope
import dagger.hilt.android.AndroidEntryPoint
import dev.proptit.messenger.databinding.ActivitySplashBinding
import dev.proptit.messenger.presentation.MainActivity
import dev.proptit.messenger.presentation.login.LoginActivity
import dev.proptit.messenger.setup.Keys
import dev.proptit.messenger.setup.PrefManager
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import javax.inject.Inject
@SuppressLint("CustomSplashScreen")
@AndroidEntryPoint
class SplashActivity : ComponentActivity() {
private lateinit var binding: ActivitySplashBinding
@Inject
lateinit var prefManager: PrefManager
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivitySplashBinding.inflate(layoutInflater)
setContentView(binding.root)
lifecycleScope.launch {
delay(2000)
if (prefManager.get(Keys.MY_ACCOUNT_ID, -1) == -1) {
startActivity(Intent(this@SplashActivity, LoginActivity::class.java))
} else {
startActivity(Intent(this@SplashActivity, MainActivity::class.java))
}
finish()
}
}
}
| P_Messager/app/src/main/java/dev/proptit/messenger/presentation/splash/SplashActivity.kt | 460374386 |
package dev.proptit.messenger.presentation
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.navigation.NavController
import androidx.navigation.findNavController
import androidx.navigation.ui.setupWithNavController
import com.google.android.material.bottomnavigation.BottomNavigationView
import dagger.hilt.android.AndroidEntryPoint
import dev.proptit.messenger.R
import dev.proptit.messenger.data.remote.NetworkManager
import dev.proptit.messenger.databinding.ActivityMainBinding
import javax.inject.Inject
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
private lateinit var mainBinding: ActivityMainBinding
private lateinit var navigationView: BottomNavigationView
private lateinit var navController: NavController
@Inject
lateinit var networkManager: NetworkManager
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
networkManager.register()
mainBinding = ActivityMainBinding.inflate(layoutInflater)
setContentView(mainBinding.root)
setupBottomNav()
}
private fun setupBottomNav() {
navigationView = mainBinding.bottomNav
navController = findNavController(R.id.navHostFragment)
navigationView.setupWithNavController(navController)
navController.addOnDestinationChangedListener { _, destination, _ ->
when (destination.id) {
R.id.chatFragment -> navigationView.visibility = BottomNavigationView.GONE
else -> navigationView.visibility = BottomNavigationView.VISIBLE
}
}
}
override fun onDestroy() {
super.onDestroy()
networkManager.unregister()
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/MainActivity.kt | 157014423 |
package dev.proptit.messenger.presentation.discover
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import dagger.hilt.android.AndroidEntryPoint
import dev.proptit.messenger.databinding.FragmentDiscoverBinding
@AndroidEntryPoint
class DiscoverFragment : Fragment() {
private var _binding: FragmentDiscoverBinding? = null
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentDiscoverBinding.inflate(inflater, container, false)
return binding.root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/discover/DiscoverFragment.kt | 1747058597 |
package dev.proptit.messenger.presentation.chat
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.widget.addTextChangedListener
import androidx.fragment.app.Fragment
import androidx.fragment.app.activityViewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.navigation.Navigation
import com.bumptech.glide.Glide
import dagger.hilt.android.AndroidEntryPoint
import dev.proptit.messenger.R
import dev.proptit.messenger.databinding.FragmentChatBinding
import dev.proptit.messenger.presentation.MainViewModel
import dev.proptit.messenger.presentation.adapters.MessageAdapter
import dev.proptit.messenger.setup.Keys
import dev.proptit.messenger.setup.PrefManager
import kotlinx.coroutines.launch
import javax.inject.Inject
@AndroidEntryPoint
class ChatFragment : Fragment() {
@Inject
lateinit var prefManager: PrefManager
private var _binding: FragmentChatBinding? = null
private val binding get() = _binding!!
private var messageAdapter: MessageAdapter? = null
private val chatViewModel: MainViewModel by activityViewModels()
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentChatBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
showContactData()
setupAdapter()
observeData()
setupOnclick()
}
private fun setupAdapter() {
messageAdapter = MessageAdapter(prefManager.get(Keys.MY_ACCOUNT_ID, -1))
binding.chatRecyclerView.adapter = messageAdapter
}
private fun observeData() {
lifecycleScope.launch {
viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
chatViewModel.allMessages.collect {
messageAdapter?.submitList(it)
}
}
}
}
private fun setupOnclick() {
binding.apply {
// back to chats fragment
iconBack.setOnClickListener {
Navigation.findNavController(requireView())
.navigate(R.id.action_chatFragment_to_chatsFragment)
}
// on text change
edtMessage.addTextChangedListener {
if (it.isNullOrBlank()) {
actionsContainer.visibility = View.VISIBLE
btnExpand.visibility = View.GONE
btnLike.visibility = View.VISIBLE
btnSend.visibility = View.GONE
} else {
actionsContainer.visibility = View.GONE
btnExpand.visibility = View.VISIBLE
btnLike.visibility = View.GONE
btnSend.visibility = View.VISIBLE
}
}
// send message
btnSend.setOnClickListener {
chatViewModel.sendMessage(
message = edtMessage.text.toString(),
idSendContact = prefManager.get(Keys.MY_ACCOUNT_ID, -1),
idReceiveContact = chatViewModel.contact.value.id
)
// Log.d("ChatFragment", "message: $message")
edtMessage.text?.clear()
}
}
}
private fun showContactData() {
val contact = chatViewModel.contact.value
binding.name.text = contact.name
Glide.with(binding.root).load(contact.avatar)
.placeholder(R.drawable.image_placeholder)
.error(R.drawable.image_load_error)
.into(binding.imageAvatar)
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/chat/ChatFragment.kt | 2649354576 |
package dev.proptit.messenger.presentation.adapters
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import dev.proptit.messenger.databinding.ItemMessageBinding
import dev.proptit.messenger.domain.model.Message
class MessageAdapter(private val myId: Int) : ListAdapter<Message,MessageAdapter.MessageViewHolder>(MessageDiffUtil()) {
inner class MessageViewHolder(private val binding: ItemMessageBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind(message: Message) {
binding.apply {
if (message.idSendContact == myId) {
myMessageContainer.visibility = View.VISIBLE
contactMessageContainer.visibility = View.GONE
myMessage.text = message.message
} else {
myMessageContainer.visibility = View.GONE
contactMessageContainer.visibility = View.VISIBLE
contactMessage.text = message.message
}
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MessageViewHolder {
return MessageViewHolder(
ItemMessageBinding.inflate(
LayoutInflater.from(parent.context),
parent,
false
)
)
}
override fun onBindViewHolder(holder: MessageViewHolder, position: Int) {
holder.bind(getItem(position))
}
class MessageDiffUtil : DiffUtil.ItemCallback<Message>() {
override fun areItemsTheSame(oldItem: Message, newItem: Message): Boolean {
return oldItem.id == newItem.id
}
override fun areContentsTheSame(oldItem: Message, newItem: Message): Boolean {
return oldItem == newItem
}
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/adapters/MessageAdapter.kt | 3173870663 |
package dev.proptit.messenger.presentation.adapters
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import dev.proptit.messenger.R
import dev.proptit.messenger.databinding.ItemOnlineContactBinding
import dev.proptit.messenger.domain.model.Contact
class OnlineContactAdapter :
ListAdapter<Contact, OnlineContactAdapter.ContactViewHolder>(OnlineContactDiffUtil()) {
var onItemClick: (idReceive: Int) -> Unit = {}
inner class ContactViewHolder(private val binding: ItemOnlineContactBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind(contact: Contact) {
binding.apply {
Glide.with(binding.root).load(contact.avatar)
.placeholder(R.drawable.image_placeholder)
.error(R.drawable.image_load_error)
.into(binding.avtContact)
nameContact.text = contact.name
root.setOnClickListener {
onItemClick(contact.id)
}
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ContactViewHolder {
return ContactViewHolder(
ItemOnlineContactBinding.inflate(
LayoutInflater.from(parent.context),
parent,
false
)
)
}
override fun onBindViewHolder(holder: ContactViewHolder, position: Int) {
holder.bind(getItem(position))
}
class OnlineContactDiffUtil : DiffUtil.ItemCallback<Contact>() {
override fun areItemsTheSame(oldItem: Contact, newItem: Contact): Boolean {
return oldItem.id == newItem.id
}
override fun areContentsTheSame(oldItem: Contact, newItem: Contact): Boolean {
return oldItem == newItem
}
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/adapters/OnlineContactAdapter.kt | 830928149 |
package dev.proptit.messenger.presentation.adapters
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import dev.proptit.messenger.R
import dev.proptit.messenger.databinding.ItemChatBinding
import dev.proptit.messenger.domain.model.Contact
class ChatsAdapter :
ListAdapter<Contact, ChatsAdapter.ChatViewHolder>(ChatDiffUtil()) {
var onContactClick: (idReceive: Int) -> Unit = {}
inner class ChatViewHolder(private val binding: ItemChatBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind(contact: Contact) {
binding.apply {
name.text = contact.name
Glide.with(binding.root).load(contact.avatar)
.placeholder(R.drawable.image_placeholder)
.error(R.drawable.image_load_error)
.into(binding.imageAvatar)
root.setOnClickListener {
onContactClick(contact.id)
}
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ChatViewHolder {
return ChatViewHolder(
ItemChatBinding.inflate(
LayoutInflater.from(parent.context),
parent,
false
)
)
}
override fun onBindViewHolder(holder: ChatViewHolder, position: Int) {
holder.bind(getItem(position))
}
class ChatDiffUtil : DiffUtil.ItemCallback<Contact>() {
override fun areItemsTheSame(oldItem: Contact, newItem: Contact): Boolean {
return oldItem.id == newItem.id
}
override fun areContentsTheSame(oldItem: Contact, newItem: Contact): Boolean {
return oldItem == newItem
}
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/adapters/ChatsAdapter.kt | 1215825399 |
package dev.proptit.messenger.presentation.adapters
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import dev.proptit.messenger.R
import dev.proptit.messenger.databinding.ItemContactBinding
import dev.proptit.messenger.domain.model.Contact
class PeopleAdapter : ListAdapter<Contact, PeopleAdapter.ContactViewHolder>(ContactDiffUtil()) {
var onContactClick: (idReceive: Int) -> Unit = {}
inner class ContactViewHolder(private val binding: ItemContactBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind(contact: Contact) {
Glide.with(binding.root).load(contact.avatar)
.placeholder(R.drawable.image_placeholder)
.error(R.drawable.image_load_error)
.into(binding.imageAvatar)
binding.name.text = contact.name
binding.root.setOnClickListener {
onContactClick(contact.id)
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ContactViewHolder {
return ContactViewHolder(
ItemContactBinding.inflate(
LayoutInflater.from(parent.context),
parent,
false
)
)
}
override fun onBindViewHolder(holder: ContactViewHolder, position: Int) {
holder.bind(getItem(position))
}
class ContactDiffUtil : DiffUtil.ItemCallback<Contact>() {
override fun areItemsTheSame(oldItem: Contact, newItem: Contact): Boolean {
return oldItem.id == newItem.id
}
override fun areContentsTheSame(oldItem: Contact, newItem: Contact): Boolean {
return oldItem == newItem
}
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/adapters/PeopleAdapter.kt | 4033664750 |
package dev.proptit.messenger.presentation.people
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.fragment.app.activityViewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.navigation.fragment.findNavController
import dagger.hilt.android.AndroidEntryPoint
import dev.proptit.messenger.R
import dev.proptit.messenger.databinding.FragmentPeopleBinding
import dev.proptit.messenger.presentation.MainViewModel
import dev.proptit.messenger.presentation.adapters.PeopleAdapter
import dev.proptit.messenger.setup.Keys
import dev.proptit.messenger.setup.PrefManager
import kotlinx.coroutines.launch
import javax.inject.Inject
@AndroidEntryPoint
class PeopleFragment : Fragment() {
private var _binding: FragmentPeopleBinding? = null
private val binding get() = _binding!!
@Inject
lateinit var prefManager: PrefManager
private val peopleAdapter: PeopleAdapter by lazy {
PeopleAdapter()
}
private val peopleViewModel: MainViewModel by activityViewModels()
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentPeopleBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
setupAdapter()
observeData()
}
private fun observeData() {
lifecycleScope.launch {
viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
peopleViewModel.allContacts.collect {
peopleAdapter.submitList(it)
}
}
}
}
private fun setupAdapter() {
peopleAdapter.onContactClick = {
peopleViewModel.setContact(
prefManager.get(Keys.MY_ACCOUNT_ID, -1),
it
)
findNavController().navigate(R.id.action_peopleFragment_to_chatFragment)
}
binding.recyclerViewContact.adapter = peopleAdapter
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/people/PeopleFragment.kt | 579073371 |
package dev.proptit.messenger.presentation.chats
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.fragment.app.activityViewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.navigation.fragment.findNavController
import dagger.hilt.android.AndroidEntryPoint
import dev.proptit.messenger.R
import dev.proptit.messenger.databinding.FragmentChatsBinding
import dev.proptit.messenger.presentation.MainViewModel
import dev.proptit.messenger.presentation.adapters.ChatsAdapter
import dev.proptit.messenger.presentation.adapters.OnlineContactAdapter
import dev.proptit.messenger.setup.Keys
import dev.proptit.messenger.setup.PrefManager
import kotlinx.coroutines.launch
import javax.inject.Inject
@AndroidEntryPoint
class ChatsFragment : Fragment() {
private var _binding: FragmentChatsBinding? = null
private val binding get() = _binding!!
@Inject
lateinit var prefManager: PrefManager
private val chatsViewModel: MainViewModel by activityViewModels()
private val chatsAdapter: ChatsAdapter by lazy {
ChatsAdapter()
}
private val onlineContactAdapter: OnlineContactAdapter by lazy {
OnlineContactAdapter()
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentChatsBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
setupAdapter()
observeData()
}
private fun observeData() {
lifecycleScope.launch {
viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
chatsViewModel.allContacts.collect {
chatsAdapter.submitList(it)
onlineContactAdapter.submitList(it)
}
}
}
}
private fun setupAdapter() {
chatsAdapter.onContactClick = {
chatsViewModel.setContact(prefManager.get(Keys.MY_ACCOUNT_ID, -1), it)
findNavController().navigate(R.id.action_chatsFragment_to_chatFragment)
}
binding.recyclerView.adapter = chatsAdapter
onlineContactAdapter.onItemClick = {
chatsViewModel.setContact(prefManager.get(Keys.MY_ACCOUNT_ID, -1), it)
findNavController().navigate(R.id.action_chatsFragment_to_chatFragment)
}
binding.recyclerViewOlContact.adapter = onlineContactAdapter
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/chats/ChatsFragment.kt | 2948068500 |
package dev.proptit.messenger.presentation.login
import android.content.Intent
import android.content.res.ColorStateList
import android.graphics.Color
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.content.ContextCompat
import androidx.core.widget.addTextChangedListener
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.fragment.findNavController
import com.google.android.material.textfield.TextInputEditText
import com.google.android.material.textfield.TextInputLayout
import dagger.hilt.android.AndroidEntryPoint
import dev.proptit.messenger.R
import dev.proptit.messenger.databinding.FragmentLoginBinding
import dev.proptit.messenger.presentation.MainActivity
import dev.proptit.messenger.setup.Keys
import dev.proptit.messenger.setup.PrefManager
import javax.inject.Inject
@AndroidEntryPoint
class LoginFragment : Fragment() {
private var _binding: FragmentLoginBinding? = null
private val binding get() = _binding!!
private lateinit var loginViewModel: LoginViewModel
@Inject
lateinit var prefManager: PrefManager
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentLoginBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
loginViewModel = ViewModelProvider(this)[LoginViewModel::class.java]
setupTextChangeListener()
setOnclick()
}
private fun setOnclick() {
binding.apply {
// handle click to register
btnRegister.setOnClickListener {
findNavController().navigate(
R.id.action_loginFragment_to_registerFragment
)
}
// handle click to login
btnLogin.setOnClickListener {
binding.apply {
val username = usernameInput.text.toString()
if (username.isEmpty()) {
handleError(
usernameInputLayout,
usernameInput,
getString(R.string.username_empty)
)
return@setOnClickListener
}
val password = passwordInput.text.toString()
if (password.isEmpty()) {
handleError(
passwordInputLayout,
passwordInput,
getString(R.string.password_empty)
)
return@setOnClickListener
}
loginViewModel.login(
username,
password,
onSuccess = {
prefManager.put(Keys.MY_ACCOUNT_ID, it)
startActivity(Intent(requireContext(), MainActivity::class.java))
},
onError = {
binding.tvDescription.text = getString(R.string.not_exist_account)
}
)
}
}
}
}
private fun setupTextChangeListener() {
binding.apply {
usernameInput.addTextChangedListener(onTextChanged = { _, _, _, _ ->
clearError(binding.usernameInputLayout, binding.usernameInput)
})
passwordInput.addTextChangedListener(onTextChanged = { _, _, _, _ ->
clearError(binding.passwordInputLayout, binding.passwordInput)
})
}
}
private fun clearError(textInputLayout: TextInputLayout, textInputEditText: TextInputEditText) {
textInputLayout.setBackgroundResource(R.drawable.bg_rounded_edt)
textInputEditText.setHintTextColor(
ColorStateList.valueOf(
ContextCompat.getColor(
requireContext(),
R.color.hint_text_color
)
)
)
binding.tvDescription.text = ""
}
private fun handleError(
textInputLayout: TextInputLayout,
textInputEditText: TextInputEditText,
description: String
) {
textInputEditText.setHintTextColor(ColorStateList.valueOf(Color.RED))
textInputLayout.setBackgroundResource(R.drawable.bg_error_rounded_edt)
binding.tvDescription.text = description
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/login/LoginFragment.kt | 1106073274 |
package dev.proptit.messenger.presentation.login
import android.util.Log
import androidx.lifecycle.ViewModel
import dagger.hilt.android.lifecycle.HiltViewModel
import dev.proptit.messenger.data.remote.dto.ContactLoginInputDto
import dev.proptit.messenger.data.remote.dto.ContactRegisterInputDto
import dev.proptit.messenger.data.remote.service.ContactService
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import javax.inject.Inject
@HiltViewModel
class LoginViewModel @Inject constructor(
private val contactService: ContactService
) : ViewModel() {
fun login(
username: String,
password: String,
onSuccess: (Int) -> Unit,
onError: () -> Unit
) {
val contact = ContactLoginInputDto(username, password)
val call = contactService.login(contact)
call.enqueue(object : Callback<Int> {
override fun onResponse(call: Call<Int>, response: Response<Int>) {
if (response.isSuccessful) {
val id = response.body()
if (id != null) {
onSuccess(id)
Log.d("LoginViewModel", "onResponse: $id")
} else {
onError()
Log.d("LoginViewModel", "onResponse: null")
}
} else {
onError()
Log.d("LoginViewModel", "onResponse: error")
}
}
override fun onFailure(call: Call<Int>, t: Throwable) {
onError()
Log.d("LoginViewModel", "onFailure: $t")
}
})
}
fun register(
name: String,
username: String,
password: String,
onSuccess: (Int) -> Unit,
onError: () -> Unit
){
val contact = ContactRegisterInputDto(name, "", username, password)
val call = contactService.register(contact)
call.enqueue(object : Callback<Int> {
override fun onResponse(call: Call<Int>, response: Response<Int>) {
if (response.isSuccessful) {
val id = response.body()
if (id != null) {
Log.d("LoginViewModel", "onResponse: $id")
onSuccess(id)
} else {
Log.d("LoginViewModel", "onResponse: null")
onError()
}
} else {
Log.d("LoginViewModel", "onResponse: ${response.code()}")
onError()
}
}
override fun onFailure(call: Call<Int>, t: Throwable) {
Log.d("LoginViewModel", "onFailure: $t")
onError()
}
})
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/login/LoginViewModel.kt | 2476327612 |
package dev.proptit.messenger.presentation.login
import android.content.Intent
import android.content.res.ColorStateList
import android.graphics.Color
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.content.ContextCompat
import androidx.core.widget.addTextChangedListener
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.google.android.material.textfield.TextInputEditText
import com.google.android.material.textfield.TextInputLayout
import dagger.hilt.android.AndroidEntryPoint
import dev.proptit.messenger.R
import dev.proptit.messenger.databinding.FragmentRegisterBinding
import dev.proptit.messenger.presentation.MainActivity
import dev.proptit.messenger.setup.Keys
import dev.proptit.messenger.setup.PrefManager
import javax.inject.Inject
@AndroidEntryPoint
class RegisterFragment : Fragment() {
private var _binding: FragmentRegisterBinding? = null
private val binding get() = _binding!!
private lateinit var loginViewModel: LoginViewModel
@Inject
lateinit var prefManager: PrefManager
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentRegisterBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
loginViewModel = ViewModelProvider(this)[LoginViewModel::class.java]
setupTextChangeListener()
handleOnclickRegister()
}
private fun handleOnclickRegister() {
binding.btnRegister.setOnClickListener {
binding.apply {
val name = nameInput.text.toString()
if (name.isEmpty()) {
handleError(nameInputLayout, nameInput, getString(R.string.name_empty))
return@setOnClickListener
}
val userName = usernameInput.text.toString()
if (userName.isEmpty()) {
handleError(
usernameInputLayout,
usernameInput,
getString(R.string.username_empty)
)
return@setOnClickListener
}
val password = passwordInput.text.toString()
if (password.isEmpty()) {
handleError(
passwordInputLayout,
passwordInput,
getString(R.string.password_empty)
)
return@setOnClickListener
} else if (password.length < 6) {
handleError(
passwordInputLayout,
passwordInput,
getString(R.string.short_password)
)
return@setOnClickListener
}
val confirmPassword = cfPasswordInput.text.toString()
if (confirmPassword.isEmpty()) {
handleError(
cfPasswordInputLayout,
cfPasswordInput,
getString(R.string.cf_password_empty)
)
return@setOnClickListener
} else if (confirmPassword != password) {
handleError(
cfPasswordInputLayout,
cfPasswordInput,
getString(R.string.cf_password_error)
)
return@setOnClickListener
}
loginViewModel.register(name, userName, password, {
prefManager.put(Keys.MY_ACCOUNT_ID, it)
startActivity(Intent(requireContext(), MainActivity::class.java))
}, {
binding.tvDescription.apply {
text = getString(R.string.register_failed)
setTextColor(Color.RED)
}
})
}
}
}
private fun handleError(
textInputLayout: TextInputLayout,
textInputEditText: TextInputEditText,
description: String
) {
textInputEditText.apply {
error = ""
setHintTextColor(ColorStateList.valueOf(Color.RED))
}
textInputLayout.setBackgroundResource(R.drawable.bg_error_rounded_edt)
binding.tvDescription.apply {
text = description
setTextColor(Color.RED)
}
}
private fun setupTextChangeListener() {
binding.apply {
nameInput.addTextChangedListener(onTextChanged = { _, _, _, _ ->
clearError(binding.nameInputLayout, binding.nameInput)
})
usernameInput.addTextChangedListener(onTextChanged = { _, _, _, _ ->
clearError(binding.usernameInputLayout, binding.usernameInput)
})
passwordInput.addTextChangedListener(onTextChanged = { _, _, _, _ ->
clearError(binding.passwordInputLayout, binding.passwordInput)
})
cfPasswordInput.addTextChangedListener(onTextChanged = { _, _, _, _ ->
clearError(binding.cfPasswordInputLayout, binding.cfPasswordInput)
})
}
}
private fun clearError(textInputLayout: TextInputLayout, textInputEditText: TextInputEditText) {
textInputLayout.setBackgroundResource(R.drawable.bg_rounded_edt)
textInputEditText.setHintTextColor(
ColorStateList.valueOf(
ContextCompat.getColor(
requireContext(),
R.color.hint_text_color
)
)
)
binding.tvDescription.apply {
text = getText(R.string.password_description)
setTextColor(Color.BLACK)
}
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/login/RegisterFragment.kt | 3213700260 |
package dev.proptit.messenger.presentation.login
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.navigation.NavController
import androidx.navigation.NavHost
import dagger.hilt.android.AndroidEntryPoint
import dev.proptit.messenger.R
import dev.proptit.messenger.databinding.ActivityLoginBinding
@AndroidEntryPoint
class LoginActivity : AppCompatActivity() {
private val binding: ActivityLoginBinding by lazy {
ActivityLoginBinding.inflate(layoutInflater)
}
private lateinit var navController: NavController
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
setupBottomNav()
}
private fun setupBottomNav() {
val navHostFragment =
supportFragmentManager.findFragmentById(R.id.fragment_container) as NavHost
navController = navHostFragment.navController
}
} | P_Messager/app/src/main/java/dev/proptit/messenger/presentation/login/LoginActivity.kt | 1083907059 |
package dev.bolanos.grpc
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class GrpcApplicationTests {
@Test
fun contextLoads() {
}
}
| hello-grpc/src/test/kotlin/dev/bolanos/grpc/GrpcApplicationTests.kt | 285958424 |
package dev.bolanos.grpc
import io.grpc.ServerBuilder
import dev.bolanos.v1.common.Person
import dev.bolanos.v1.common.Context
import dev.bolanos.grpc.services.BankService
import dev.bolanos.grpc.services.DomainService
import dev.bolanos.v3.common.Television
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class GrpcApplication
fun main(args: Array<String>) {
runApplication<GrpcApplication>(*args)
var context = Context.newBuilder().setPerson(Person.newBuilder().build()).build()
var television = Television.newBuilder().setIsFlat(true).build()
val server = ServerBuilder.forPort(6565)
.addService(BankService())
.build()
server.start()
server.awaitTermination()
}
| hello-grpc/src/main/kotlin/dev/bolanos/grpc/GrpcApplication.kt | 1236800844 |
package dev.bolanos.grpc.services
//import dev.bolanos.v1.common.Address
import dev.bolanos.v1.common.Context
import dev.bolanos.v1.common.Domain
import org.springframework.stereotype.Service
@Service
class DomainService {
fun getDomain():Domain = Domain.newBuilder()
.setFoo(1)
.setBar("2")
.setBaz("3")
// .setAddress(Address.newBuilder().setCity("SF").setStreet("sansome").setPostbox(94104).build())
.setContext(Context.newBuilder().setZab("1").setBaz("2").build())
.build()
} | hello-grpc/src/main/kotlin/dev/bolanos/grpc/services/DomainService.kt | 2729308464 |
package dev.bolanos.grpc.services
import io.grpc.stub.StreamObserver
import dev.bolanos.v1.common.Balance
import dev.bolanos.v1.services.BalanceAddRequest
import dev.bolanos.v1.services.BalanceCheckRequest
import dev.bolanos.v1.services.BalanceDeductRequest
import dev.bolanos.v1.services.BankServiceGrpc
class BankService : BankServiceGrpc.BankServiceImplBase() {
private val database = AccountDatabase()
override fun getBalance(request: BalanceCheckRequest?, responseObserver: StreamObserver<Balance>?) {
val account = request?.accountNumber ?: -1
responseObserver?.onNext(database.get_balance(account))
responseObserver?.onCompleted()
}
override fun addBalance(request: BalanceAddRequest?, responseObserver: StreamObserver<Balance>?) {
val account = request?.accountNumber ?: -1
val amount = request?.amount ?: 0
val balance = database.add_balance(account, amount)
responseObserver?.onNext(balance)
responseObserver?.onCompleted()
}
override fun deductBalance(request: BalanceDeductRequest?, responseObserver: StreamObserver<Balance>?) {
val account = request?.accountNumber ?: -1
val amount = request?.amount ?: 0
val balance = database.deduct_balance(account, amount);
responseObserver?.onNext(balance)
responseObserver?.onCompleted()
}
} | hello-grpc/src/main/kotlin/dev/bolanos/grpc/services/BankService.kt | 2446705339 |
package dev.bolanos.grpc.services
import dev.bolanos.v1.common.Balance
class AccountDatabase {
private val database: MutableMap<Int, Int> = (1..100).associateWith {
it*100
} as MutableMap<Int, Int>
fun get_balance(account: Int): Balance {
val balance = database[account]
if (balance != null) {
return Balance.newBuilder().setAccount(account).setAmount(balance).build()
}
throw Exception("Balance not found for account $account")
}
fun add_balance(account: Int, amount:Int): Balance {
val balance = database[account]
if (balance != null) {
val newBalance = balance + amount
database[account] = newBalance
return Balance.newBuilder()
.setAccount(account)
.setAmount(newBalance)
.build()
}
throw Exception("Balance not found for account $account")
}
fun deduct_balance(account: Int, amount:Int): Balance {
val balance = database[account]
if (balance != null) {
val newBalance = balance - amount
if(amount >= 0){
database[account] = newBalance
return Balance.newBuilder()
.setAccount(account)
.setAmount(newBalance)
.build()
}
throw Exception("Balance not enough")
}
throw Exception("Balance not found for account $account")
}
} | hello-grpc/src/main/kotlin/dev/bolanos/grpc/services/AccountDatabase.kt | 2365799398 |
package com.example.weatherapp
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.weatherapp", appContext.packageName)
}
} | Assessment-04-MAD/Weather App/app/src/androidTest/java/com/example/weatherapp/ExampleInstrumentedTest.kt | 2646554615 |
package com.example.weatherapp
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)
}
} | Assessment-04-MAD/Weather App/app/src/test/java/com/example/weatherapp/ExampleUnitTest.kt | 1074146430 |
package com.example.weatherapp.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | Assessment-04-MAD/Weather App/app/src/main/java/com/example/weatherapp/ui/theme/Color.kt | 1126046537 |
package com.example.weatherapp.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun WeatherAppTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | Assessment-04-MAD/Weather App/app/src/main/java/com/example/weatherapp/ui/theme/Theme.kt | 2458874510 |
package com.example.weatherapp.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | Assessment-04-MAD/Weather App/app/src/main/java/com/example/weatherapp/ui/theme/Type.kt | 3796718707 |
package com.example.weatherapp
import android.os.Bundle
import androidx.activity.ComponentActivity
class OtherCities : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_othercities)
}
}
| Assessment-04-MAD/Weather App/app/src/main/java/com/example/weatherapp/OtherCities.kt | 1410440472 |
package com.example.weatherapp
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.example.weatherapp.ui.theme.WeatherAppTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
} | Assessment-04-MAD/Weather App/app/src/main/java/com/example/weatherapp/MainActivity.kt | 4217060698 |
package com.example.weatherapp
import android.os.Bundle
import androidx.activity.ComponentActivity
class Forecast : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_forecast)
}
} | Assessment-04-MAD/Weather App/app/src/main/java/com/example/weatherapp/Forecast.kt | 2562461796 |
package com.example.weatherapp
import android.os.Bundle
import androidx.activity.ComponentActivity
class OtherCityForecast : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_otherforecast)
}
} | Assessment-04-MAD/Weather App/app/src/main/java/com/example/weatherapp/OtherCityForecast.kt | 2731491448 |
package com.eipsaferoad.owl
import android.os.VibrationEffect
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import com.eipsaferoad.owl.models.Alarm
import com.eipsaferoad.owl.models.SoundAlarm
import com.eipsaferoad.owl.models.VibrationAlarm
import org.junit.Assert.assertEquals
import org.junit.Test
class OwlTest {
@Test
fun testAddition() {
// Arrange
val number1 = 1
val number2 = 1
// Act
val sum = number1 + number2
// Assert
assertEquals(2, sum)
}
@Test
fun testVibrationAlarm() {
val alarm = VibrationAlarm(3, 0)
assertEquals(alarm.max, 3)
assertEquals(alarm.min, 0)
assertEquals(alarm.actual, 0.0f)
var res = alarm.updateAlarm()
assertEquals(res, VibrationEffect.EFFECT_HEAVY_CLICK)
assertEquals(alarm.actual, 1.0f)
res = alarm.updateAlarm(false)
assertEquals(res, VibrationEffect.EFFECT_TICK)
assertEquals(alarm.actual, 0.0f)
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
alarm.updateAlarm()
res = alarm.updateAlarm()
assertEquals(res, VibrationEffect.DEFAULT_AMPLITUDE)
}
}
| wearOsApp/app/src/test/java/com/eipsaferoad/owl/OwlTest.kt | 212160401 |
package com.eipsaferoad.owl
import android.annotation.SuppressLint
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.content.pm.PackageManager
import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.os.VibrationEffect
import android.os.Vibrator
import android.os.VibratorManager
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.annotation.RequiresApi
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Devices
import androidx.compose.ui.tooling.preview.Preview
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
import androidx.wear.ambient.AmbientLifecycleObserver
import androidx.wear.ambient.AmbientModeSupport
import androidx.wear.ambient.AmbientModeSupport.AmbientCallback
import androidx.wear.compose.material.MaterialTheme
import androidx.wear.compose.material.TimeText
import androidx.wear.compose.navigation.SwipeDismissableNavHost
import androidx.wear.compose.navigation.composable
import androidx.wear.compose.navigation.rememberSwipeDismissableNavController
import com.eipsaferoad.owl.api.Request
import com.eipsaferoad.owl.core.Authentication
import com.eipsaferoad.owl.heartRate.HeartRateService
import com.eipsaferoad.owl.models.Alarm
import com.eipsaferoad.owl.models.SoundAlarm
import com.eipsaferoad.owl.models.VibrationAlarm
import com.eipsaferoad.owl.presentation.PagesEnum
import com.eipsaferoad.owl.presentation.alarm.Alarm
import com.eipsaferoad.owl.presentation.home.Home
import com.eipsaferoad.owl.presentation.login.Login
import com.eipsaferoad.owl.presentation.settings.Settings
import com.eipsaferoad.owl.presentation.theme.OwlTheme
import com.eipsaferoad.owl.utils.KeysEnum
import com.eipsaferoad.owl.utils.LocalStorage
import com.eipsaferoad.owl.utils.ReadEnvVar
import com.eipsaferoad.owl.utils.initAlarms
import com.google.android.gms.wearable.CapabilityClient
import com.google.android.gms.wearable.CapabilityInfo
import com.google.android.gms.wearable.DataClient
import com.google.android.gms.wearable.DataEventBuffer
import com.google.android.gms.wearable.MessageClient
import com.google.android.gms.wearable.MessageEvent
import com.google.android.gms.wearable.Wearable
import okhttp3.FormBody
import okhttp3.Headers
class MainActivity : ComponentActivity(),
AmbientModeSupport.AmbientCallbackProvider,
DataClient.OnDataChangedListener,
MessageClient.OnMessageReceivedListener,
CapabilityClient.OnCapabilityChangedListener {
private lateinit var mVibrator: Vibrator
private lateinit var vibrationEffectSingle: VibrationEffect
private var bpm: MutableState<String> = mutableStateOf("0")
private var alarms: MutableState<Alarm> = mutableStateOf(Alarm(VibrationAlarm(), SoundAlarm(1, 0), false))
private var accessToken: MutableState<String?> = mutableStateOf(null)
private var url: MutableState<String> = mutableStateOf("")
private var activityContext: Context? = null
private val ambientCallback = object : AmbientLifecycleObserver.AmbientLifecycleCallback {
override fun onEnterAmbient(ambientDetails: AmbientLifecycleObserver.AmbientDetails) {
}
override fun onExitAmbient() {
}
override fun onUpdateAmbient() {
}
}
private val ambientObserver = AmbientLifecycleObserver(this, ambientCallback)
@RequiresApi(Build.VERSION_CODES.S)
override fun onCreate(savedInstanceState: Bundle?) {
installSplashScreen()
super.onCreate(savedInstanceState)
val filter = IntentFilter()
lifecycle.addObserver(ambientObserver)
activityContext = this
checkPermission(android.Manifest.permission.BODY_SENSORS, 100)
checkPermission(android.Manifest.permission.VIBRATE, 100);
filter.addAction("updateHR")
registerReceiver(broadcastReceiver, filter)
setTheme(android.R.style.Theme_DeviceDefault)
initVibration()
url.value = ReadEnvVar.readEnvVar(this, ReadEnvVar.EnvVar.API_URL)
initAlarms(this, alarms)
setContent {
WearApp(this, bpm, alarms, url.value, { token -> accessToken.value = token }, mVibrator, vibrationEffectSingle)
}
}
override fun onPause() {
super.onPause()
Intent(this, HeartRateService::class.java).also { intent ->
startService(intent);
}
Toast.makeText(this, "Streaming will continue in the background", Toast.LENGTH_LONG).show();
try {
Wearable.getDataClient(activityContext!!).removeListener(this)
Wearable.getMessageClient(activityContext!!).removeListener(this)
Wearable.getCapabilityClient(activityContext!!).removeListener(this)
} catch (e: Exception) {
e.printStackTrace()
}
}
override fun onResume() {
super.onResume()
try {
Wearable.getDataClient(activityContext!!).addListener(this)
Wearable.getMessageClient(activityContext!!).addListener(this)
Wearable.getCapabilityClient(activityContext!!)
.addListener(this, Uri.parse("wear://"), CapabilityClient.FILTER_REACHABLE)
} catch (e: Exception) {
e.printStackTrace()
}
}
override fun getAmbientCallback(): AmbientCallback = MyAmbientCallback()
private inner class MyAmbientCallback : AmbientCallback() {
override fun onEnterAmbient(ambientDetails: Bundle) {
super.onEnterAmbient(ambientDetails)
}
override fun onUpdateAmbient() {
super.onUpdateAmbient()
}
override fun onExitAmbient() {
super.onExitAmbient()
}
}
override fun onStart() {
super.onStart();
Intent(this, HeartRateService::class.java).also { intent ->
startService(intent);
}
}
override fun onDataChanged(p0: DataEventBuffer) {
}
override fun onCapabilityChanged(p0: CapabilityInfo) {
}
override fun onMessageReceived(p0: MessageEvent) {
}
private fun checkPermission(permission: String, requestCode: Int) {
if (ContextCompat.checkSelfPermission(this@MainActivity, permission)
== PackageManager.PERMISSION_DENIED
) {
ActivityCompat.requestPermissions(this@MainActivity, arrayOf(permission), requestCode)
}
}
private fun initVibration() {
if (ContextCompat.checkSelfPermission(this, android.Manifest.permission.VIBRATE) == PackageManager.PERMISSION_GRANTED) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
val vibratorManager = getSystemService(VIBRATOR_MANAGER_SERVICE) as VibratorManager
mVibrator = vibratorManager.getVibrator(vibratorManager.vibratorIds[0])
} else {
mVibrator = getSystemService(VIBRATOR_SERVICE) as Vibrator
}
vibrationEffectSingle = VibrationEffect.createOneShot(500, VibrationEffect.EFFECT_HEAVY_CLICK)
}
}
private var broadcastReceiver = object : BroadcastReceiver() {
@SuppressLint("SetTextI18n")
override fun onReceive(context: Context?, intent: Intent?) {
val newBpm: Any = intent?.extras?.get("bpm") ?: return;
bpm.value = newBpm.toString()
if (!accessToken.value.isNullOrEmpty()) {
val formBody = FormBody.Builder()
.add("heartRate", bpm.value)
.build()
val headers = Headers.Builder()
.add("Authorization", "Bearer ${accessToken.value}")
.build()
Request.makeRequest("${url.value}/api/heart-rate", headers, formBody) {}
}
}
}
}
@Composable
fun WearApp(context: Context, currentHeartRate: MutableState<String>, alarms: MutableState<Alarm>, apiUrl: String, setAccessToken: (token: String) -> Unit, mVibrator: Vibrator, vibrationEffectSingle: VibrationEffect) {
val navController = rememberSwipeDismissableNavController()
val email = LocalStorage.getData(context, KeysEnum.EMAIL.value);
val password = LocalStorage.getData(context, KeysEnum.PASSWORD.value);
if (email != null && password != null) {
Authentication.login(context, apiUrl = apiUrl, email = email, password = password, navController = navController , setAccessToken = setAccessToken)
}
OwlTheme {
SwipeDismissableNavHost(
navController = navController,
startDestination = PagesEnum.LOGIN.value
) {
composable(PagesEnum.HOME.value) {
Box(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colors.background),
contentAlignment = Alignment.Center
) {
TimeText()
Home(currentHeartRate, context, navController, alarms)
}
}
composable(PagesEnum.LOGIN.value) {
Box(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colors.background),
contentAlignment = Alignment.Center
) {
TimeText()
Login(context, apiUrl, navController, setAccessToken)
}
}
composable(PagesEnum.SETTINGS.value) {
Box(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colors.background),
contentAlignment = Alignment.Center
) {
TimeText()
Settings(context, alarms, mVibrator)
}
}
composable(PagesEnum.ALARM.value) {
Box(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colors.background),
contentAlignment = Alignment.Center
) {
TimeText()
Alarm(currentHeartRate.value, context, navController)
}
}
}
}
}
@Preview(device = Devices.WEAR_OS_SMALL_ROUND, showSystemUi = true)
@Composable
fun DefaultPreview() {
/*var bpm: MutableState<String> = mutableStateOf("0")
var alarms: MutableState<Alarm> = mutableStateOf(Alarm(AlarmType(0, 100), AlarmType(0, 100), false))*/
/*WearApp(LocalContext.current , bpm, alarms, "", {})*/
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/MainActivity.kt | 1975866326 |
package com.eipsaferoad.owl.core
import android.content.Context
import androidx.navigation.NavHostController
import com.eipsaferoad.owl.api.Request
import com.eipsaferoad.owl.presentation.PagesEnum
import com.eipsaferoad.owl.utils.KeysEnum
import com.eipsaferoad.owl.utils.LocalStorage
import okhttp3.FormBody
import okhttp3.Headers
class Authentication {
companion object {
fun login(
context: Context,
isNew: Boolean = false,
apiUrl: String,
email: String,
password: String,
navController: NavHostController,
setAccessToken: (token: String) -> Unit
) {
val headers = Headers.Builder()
.build()
val formBody = FormBody.Builder()
.add("email", email)
.add("password", password)
.build()
Request.makeRequest(
"$apiUrl/api/auth/login",
headers,
formBody
) { dto ->
run {
val data = dto.getJSONObject("data")
setAccessToken(data.getString("token"))
if (isNew) {
LocalStorage.setData(context, KeysEnum.EMAIL.value, email)
LocalStorage.setData(context, KeysEnum.PASSWORD.value, password)
}
navController.navigate(PagesEnum.HOME.value)
}
}
}
}
} | wearOsApp/app/src/main/java/com/eipsaferoad/owl/core/Authentication.kt | 3356267111 |
package com.eipsaferoad.owl.utils
import android.content.Context
import androidx.compose.runtime.MutableState
import com.eipsaferoad.owl.models.Alarm
fun initAlarms(context: Context, alarms: MutableState<Alarm>) {
val vibration = LocalStorage.getData(context, KeysEnum.ALARM_VIBRATION.value)
val sound = LocalStorage.getData(context, KeysEnum.ALARM_SOUND.value)
val activate = LocalStorage.getData(context, KeysEnum.ALARM_ACTIVATE.value)
if (activate != null) {
alarms.value.isAlarmActivate = activate == "1"
}
if (!vibration.isNullOrEmpty()) {
alarms.value.vibration.decompress(vibration)
}
if (!sound.isNullOrEmpty()) {
alarms.value.sound.decompress(sound)
}
} | wearOsApp/app/src/main/java/com/eipsaferoad/owl/utils/initAlarms.kt | 445608346 |
package com.eipsaferoad.owl.utils
import android.content.Context
import android.util.Log
import com.eipsaferoad.owl.R
class ReadEnvVar {
enum class EnvVar(val str: String) {
API_URL("API_URL")
}
companion object {
fun readEnvVar(context: Context, name: EnvVar): String {
if (vars.containsKey(name))
return vars[name].toString()
val data = context.resources.getString(R.string.api_url)
vars[name] = data
return data
}
private val vars: MutableMap<EnvVar, String> = mutableMapOf()
}
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/utils/ReadEnvVar.kt | 1977211213 |
package com.eipsaferoad.owl.utils
import android.content.Context
import android.media.MediaPlayer
fun soundPlayer(context: Context, volume: Float = 1.0f, loop: Boolean = false, fileId: Int) {
val mediaPlayer = MediaPlayer.create(context, fileId).apply { isLooping = loop }
mediaPlayer.setVolume(volume, volume)
mediaPlayer.start()
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/utils/SoundPlayer.kt | 3159164502 |
package com.eipsaferoad.owl.utils
import android.content.Context
enum class KeysEnum(val value: String) {
ALARM_VIBRATION("alarm_vibration"),
ALARM_SOUND("alarm_sound"),
ALARM_ACTIVATE("alarm_activate"),
EMAIL("email"),
PASSWORD("password")
}
class LocalStorage {
companion object {
fun setData(context: Context, key: String, value: String) {
val sharedPref = context.getSharedPreferences("PREF_NAME", Context.MODE_PRIVATE) ?: return
with (sharedPref.edit()) {
putString(key, value)
apply()
}
}
fun getData(context: Context, key: String): String? {
val sharedPref = context.getSharedPreferences("PREF_NAME", Context.MODE_PRIVATE) ?: return null
return sharedPref.getString(key, "")
}
fun deleteData(context: Context, key: String) {
val sharedPref = context.getSharedPreferences("PREF_NAME", Context.MODE_PRIVATE) ?: return
with (sharedPref.edit()) {
remove(key)
apply()
}
}
}
} | wearOsApp/app/src/main/java/com/eipsaferoad/owl/utils/LocalStorage.kt | 2540495437 |
package com.eipsaferoad.owl.models
import android.os.VibrationEffect
class VibrationAlarm(
max: Int = 3,
min: Int = 0,
actual: Float = 0f,
isActivate: Boolean = false,
) : AlarmType(max, min, actual, isActivate) {
private val vibrationLevels: Array<Int> = arrayOf(
VibrationEffect.EFFECT_TICK,
VibrationEffect.EFFECT_HEAVY_CLICK,
VibrationEffect.DEFAULT_AMPLITUDE,
VibrationEffect.DEFAULT_AMPLITUDE
)
override fun updateAlarm(bigger: Boolean): Int {
if (bigger && actual < max) {
actual += 1
} else if (!bigger && actual > min) {
actual -= 1
}
return vibrationLevels[actual.toInt()]
}
} | wearOsApp/app/src/main/java/com/eipsaferoad/owl/models/VibrationAlarm.kt | 3641589178 |
package com.eipsaferoad.owl.models
class SoundAlarm(
max: Int = 3,
min: Int = 0,
actual: Float = 1.0f,
isActivate: Boolean = false,
) : AlarmType(max, min, actual, isActivate) {
override fun updateAlarm(bigger: Boolean): Int {
if (bigger && actual < max.toFloat()) {
actual += 0.2f
} else if (!bigger && actual > min.toFloat()) {
actual -= 0.2f
}
return 0
}
} | wearOsApp/app/src/main/java/com/eipsaferoad/owl/models/SoundAlarm.kt | 2491913094 |
package com.eipsaferoad.owl.models
open class AlarmType(
public var max: Int,
public var min: Int,
public var actual: Float = 0f,
public var isActivate: Boolean = false
) {
open fun updateAlarm(bigger: Boolean = true): Int {
if (bigger && actual < max) {
actual += 10
} else if (!bigger && actual > min) {
actual -= 10
}
return 0
}
fun compress(): String {
return if (isActivate) "1$actual" else "0$actual"
}
fun decompress(compressStr: String) {
isActivate = (compressStr[0] == '1')
actual = compressStr.substring(1).toFloat()
}
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/models/AlarmType.kt | 3364224971 |
package com.eipsaferoad.owl.models
class Alarm(public var vibration: AlarmType, public var sound: AlarmType, public var isAlarmActivate: Boolean) {
} | wearOsApp/app/src/main/java/com/eipsaferoad/owl/models/Alarm.kt | 2612095473 |
package com.eipsaferoad.owl.api
import android.util.Log
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import okhttp3.FormBody
import okhttp3.Headers
import okhttp3.OkHttpClient
import okhttp3.Request
import org.json.JSONException
import org.json.JSONObject
class Request {
companion object {
private fun post(url: String, headers: Headers, body: FormBody): String {
val client = OkHttpClient()
val request = Request.Builder()
.url(url)
.post(body)
.headers(headers)
.build()
try {
val response = client.newCall(request).execute()
if (!response.isSuccessful) {
throw Exception("Error: Request failed with code ${response.code}")
}
return response.body!!.string()
} catch (e: Exception) {
throw e
}
}
fun makeRequest(url: String, headers: Headers, body: FormBody, callback: (dto: JSONObject) -> Unit) {
CoroutineScope(Dispatchers.Main).launch {
try {
val response = withContext(Dispatchers.IO) {
post(url, headers, body)
}
withContext(Dispatchers.Main) {
try {
callback(JSONObject(response))
} catch (e: JSONException) {
Log.e("API CALL", "Error parsing JSON: $e")
}
}
} catch (e: Exception) {
Log.e("API CALL", "Error api call in: $e")
}
}
}
}
} | wearOsApp/app/src/main/java/com/eipsaferoad/owl/api/Request.kt | 1123114045 |
package com.eipsaferoad.owl.heartRate
import android.annotation.SuppressLint
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.app.Service
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.hardware.Sensor
import android.hardware.SensorEvent
import android.hardware.SensorEventListener2
import android.hardware.SensorManager
import android.os.Build
import android.os.IBinder
import android.os.PowerManager
import androidx.core.app.NotificationCompat
import com.eipsaferoad.owl.MainActivity
/*import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.FirebaseUser
import com.google.firebase.auth.ktx.auth
import com.google.firebase.database.ktx.database
import com.google.firebase.ktx.Firebase*/
import kotlin.math.roundToInt
class HeartRateService : Service(), SensorEventListener2 {
private final var STOP_ACTION = "STOP_ACTION";
private lateinit var mSensorManager : SensorManager;
private lateinit var mHeartRateSensor: Sensor;
private lateinit var wakeLock : PowerManager.WakeLock;
private val broadcastReceiver: BroadcastReceiver = object : BroadcastReceiver() {
override fun onReceive(context: Context?, intent: Intent) {
if(intent.action == STOP_ACTION){
stopSelf();
android.os.Process.killProcess(android.os.Process.myPid());
}
}
}
override fun onCreate() {
super.onCreate()
var intentFilter = IntentFilter();
intentFilter.addAction(STOP_ACTION);
registerReceiver(broadcastReceiver, intentFilter);
mSensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
mHeartRateSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_HEART_RATE)!!;
wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).run{
newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "HeartWear::BackgroundStreaming").apply{
acquire();
}
}
}
override fun onDestroy() {
super.onDestroy()
unregisterReceiver(broadcastReceiver);
mSensorManager.unregisterListener(this);
wakeLock.release();
}
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
createNotificationChannel();
var notificationIntent = Intent(this, MainActivity::class.java);
val pendingIntent = PendingIntent.getActivity(
this,
0, notificationIntent, PendingIntent.FLAG_IMMUTABLE
)
val stopIntent = Intent();
stopIntent.action = STOP_ACTION;
var pendingIntentStopAction = PendingIntent.getBroadcast(this, 12345, stopIntent, PendingIntent.FLAG_IMMUTABLE);
val notification = NotificationCompat.Builder(this, "hrservice")
.setContentTitle("HeartWear")
.setContentText("Streaming heart rate in the background...")
.addAction(android.R.drawable.ic_menu_close_clear_cancel, "Stop", pendingIntentStopAction)
.addAction(android.R.drawable.ic_menu_close_clear_cancel, "Stop", pendingIntentStopAction)
.setContentIntent(pendingIntent)
.build();
startForeground(1, notification)
mHeartRateSensor?.also { heartRate ->
mSensorManager.registerListener(this, heartRate, SensorManager.SENSOR_DELAY_NORMAL)
}
return START_NOT_STICKY;
}
override fun onBind(intent: Intent?): IBinder? {
return null
}
private fun createNotificationChannel(){
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
val serviceChannel = NotificationChannel(
"hrservice",
"HeartWear Background Service",
NotificationManager.IMPORTANCE_LOW
)
val manager =
getSystemService(NotificationManager::class.java)
manager.createNotificationChannel(serviceChannel)
}
}
override fun onAccuracyChanged(p0: Sensor?, p1: Int) {
}
override fun onFlushCompleted(p0: Sensor?) {
}
private var oldRoundedHeartRate : Int = 0;
@SuppressLint("SetTextI18n")
override fun onSensorChanged(p0: SensorEvent?) {
var heartRate: Float? = p0?.values?.get(0) ?: return;
var roundedHeartRate = (heartRate!!).roundToInt();
if(roundedHeartRate == oldRoundedHeartRate) return;
var updateHRIntent = Intent();
updateHRIntent.action = "updateHR";
updateHRIntent.putExtra("bpm", roundedHeartRate);
this.sendBroadcast(updateHRIntent);
}
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/heartRate/HeartRateService.kt | 2889887656 |
package com.eipsaferoad.owl.presentation.settings
import android.content.Context
import android.os.Build
import android.os.VibrationEffect
import android.os.Vibrator
import androidx.annotation.RequiresApi
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.tooling.preview.Devices
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.wear.compose.material.Button
import androidx.wear.compose.material.ButtonDefaults
import androidx.wear.compose.material.Switch
import androidx.wear.compose.material.SwitchDefaults
import androidx.wear.compose.material.Text
import com.eipsaferoad.owl.R
import com.eipsaferoad.owl.models.Alarm
import com.eipsaferoad.owl.utils.KeysEnum
import com.eipsaferoad.owl.utils.LocalStorage
import com.eipsaferoad.owl.utils.soundPlayer
@Composable
fun Settings(context: Context, alarms: MutableState<Alarm>, mVibrator: Vibrator) {
LazyColumn(
modifier = Modifier
.padding(top = 40.dp, bottom = 40.dp)
.fillMaxSize(),
verticalArrangement = Arrangement.spacedBy(10.dp),
horizontalAlignment = Alignment.CenterHorizontally
) {
item { AlarmButton(alarms, context) }
item { VibrationButton(alarms, mVibrator, context) }
item { SoundButton(alarms, context) }
}
}
@Composable
fun AlarmButton(alarms: MutableState<Alarm>, context: Context) {
var isAlarmActivate by remember { mutableStateOf(alarms.value.isAlarmActivate) }
DisposableEffect(isAlarmActivate) {
onDispose {
val compress = if (alarms.value.isAlarmActivate) "1" else "0"
LocalStorage.setData(context, KeysEnum.ALARM_ACTIVATE.value, compress)
}
}
Button(
modifier = Modifier
.width(200.dp)
.height(40.dp),
shape = RoundedCornerShape(10),
colors = ButtonDefaults.buttonColors(backgroundColor = MaterialTheme.colorScheme.primary),
onClick = { alarms.value.isAlarmActivate = !alarms.value.isAlarmActivate }
) {
Row(
modifier = Modifier.padding(10.dp),
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = "Activate Alarm",
modifier = Modifier.weight(1f)
)
Switch(
colors = SwitchDefaults.colors(
checkedThumbColor = Color(0xFF00275B),
checkedTrackColor = Color(0xFF00275B),
uncheckedThumbColor = Color(0xFF00275B),
uncheckedTrackColor = Color(0xFF8D9497)
),
checked = isAlarmActivate,
onCheckedChange = {
alarms.value.isAlarmActivate = it; isAlarmActivate = it
}
)
}
}
}
@Composable
fun VibrationButton(alarms: MutableState<Alarm>, mVibrator: Vibrator, context: Context) {
var isVibrationSelected by remember { mutableStateOf(false) }
var isSoundSelected by remember { mutableStateOf(false) }
var isVibrationActivate by remember { mutableStateOf(alarms.value.vibration.isActivate) }
var vibrationVal by remember { mutableStateOf(alarms.value.vibration.actual) }
var vibrationEffectSingle by remember {
mutableStateOf(VibrationEffect.createOneShot(500, VibrationEffect.DEFAULT_AMPLITUDE))
}
DisposableEffect(isVibrationActivate, vibrationVal) {
onDispose {
val str = alarms.value.vibration.compress()
LocalStorage.setData(context, KeysEnum.ALARM_VIBRATION.value, str)
}
}
Button(
modifier = Modifier
.width(200.dp)
.height(if (isVibrationSelected) 80.dp else 40.dp),
shape = RoundedCornerShape(10),
colors = ButtonDefaults.buttonColors(backgroundColor = MaterialTheme.colorScheme.primary),
onClick = {
isVibrationSelected = !isVibrationSelected
if (isSoundSelected) {
isSoundSelected = false
}
}
) {
Column(
modifier = Modifier
.fillMaxSize()
.padding(top = if (isVibrationSelected) 0.dp else 10.dp, bottom = 10.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.SpaceAround
) {
Row(
modifier = Modifier
.padding(start = 10.dp, end = 10.dp)
.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween
) {
Text(
text = "Vibration",
)
if (isVibrationSelected) {
Switch(
colors = SwitchDefaults.colors(
checkedThumbColor = Color(0xFF00275B),
checkedTrackColor = Color(0xFF00275B),
uncheckedThumbColor = Color(0xFF00275B),
uncheckedTrackColor = Color(0xFF8D9497)
),
checked = isVibrationActivate,
onCheckedChange = {
alarms.value.vibration.isActivate = it; isVibrationActivate = it
}
)
}
}
if (isVibrationSelected) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(start = 10.dp, end = 10.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.SpaceBetween
) {
Text(
text = "-",
modifier = Modifier
.clickable {
vibrationEffectSingle = VibrationEffect.createOneShot(500, alarms.value.vibration.updateAlarm(false))
if (vibrationVal > alarms.value.vibration.min.toFloat()) {
vibrationVal -= 1
}
mVibrator.vibrate(vibrationEffectSingle)
}
)
Box(
modifier = Modifier
.width(150.dp)
.height(5.dp)
.clip(RoundedCornerShape(8.dp))
) {
LinearProgressIndicator(
progress = vibrationVal / (alarms.value.vibration.max - alarms.value.vibration.min),
modifier = Modifier
.height(5.dp),
color = MaterialTheme.colorScheme.secondary
)
}
Text(
text = "+",
modifier = Modifier
.clickable {
vibrationEffectSingle = VibrationEffect.createOneShot(500, alarms.value.vibration.updateAlarm())
if (vibrationVal < alarms.value.vibration.max.toFloat()) {
vibrationVal += 1
}
mVibrator.vibrate(vibrationEffectSingle)
}
)
}
}
}
}
}
@Composable
fun SoundButton(alarms: MutableState<Alarm>, context: Context) {
var isSoundActivate by remember { mutableStateOf(alarms.value.sound.isActivate) }
var soundVal by remember { mutableStateOf(alarms.value.sound.actual) }
var isVibrationSelected by remember { mutableStateOf(false) }
var isSoundSelected by remember { mutableStateOf(false) }
DisposableEffect(isSoundActivate, soundVal) {
onDispose {
val str = alarms.value.sound.compress()
LocalStorage.setData(context, KeysEnum.ALARM_SOUND.value, str)
}
}
Button(
modifier = Modifier
.width(200.dp)
.height(if (isSoundSelected) 80.dp else 40.dp),
shape = RoundedCornerShape(10),
colors = ButtonDefaults.buttonColors(backgroundColor = MaterialTheme.colorScheme.primary),
onClick = {
isSoundSelected = !isSoundSelected
if (isVibrationSelected) {
isVibrationSelected = false
}
}
) {
Column(
modifier = Modifier
.fillMaxSize()
.padding(top = if (isSoundSelected) 0.dp else 10.dp, bottom = 10.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.SpaceAround
) {
Row(
modifier = Modifier
.padding(start = 10.dp, end = 10.dp)
.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween
) {
Text(
text = "Sound",
)
if (isSoundSelected) {
Switch(
colors = SwitchDefaults.colors(
checkedThumbColor = Color(0xFF00275B),
checkedTrackColor = Color(0xFF00275B),
uncheckedThumbColor = Color(0xFF00275B),
uncheckedTrackColor = Color(0xFF8D9497)
),
checked = isSoundActivate,
onCheckedChange = {
alarms.value.sound.isActivate = it; isSoundActivate = it
}
)
}
}
if (isSoundSelected) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(start = 10.dp, end = 10.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.SpaceBetween
) {
Text(
text = "-",
modifier = Modifier.clickable {
alarms.value.sound.updateAlarm(false)
if (soundVal > alarms.value.sound.min) {
soundVal -= 0.2f
}
soundPlayer(context, soundVal, fileId = R.raw.default_alarm)
}
)
Box(
modifier = Modifier
.width(150.dp)
.height(5.dp)
.clip(RoundedCornerShape(8.dp))
) {
LinearProgressIndicator(
progress = soundVal / (alarms.value.sound.max - alarms.value.sound.min),
modifier = Modifier
.height(5.dp),
color = MaterialTheme.colorScheme.secondary
)
}
Text(
text = "+",
modifier = Modifier
.clickable {
alarms.value.sound.updateAlarm()
if (soundVal < alarms.value.sound.max.toFloat()) {
soundVal += 0.2f
}
soundPlayer(context, soundVal, fileId = R.raw.default_alarm)
}
)
}
}
}
}
}
@RequiresApi(Build.VERSION_CODES.S)
@Composable
@Preview(device = Devices.WEAR_OS_LARGE_ROUND, showSystemUi = true)
@Preview(device = Devices.WEAR_OS_SMALL_ROUND, showSystemUi = true)
fun PreviewSettings() {
/*var alarms: MutableState<Alarm> = mutableStateOf(Alarm(AlarmType(0, 100), AlarmType(0, 100), false))
val vibratorManager = getSystemService(ComponentActivity.VIBRATOR_MANAGER_SERVICE) as VibratorManager
var mVibrator: Vibrator = vibratorManager.getVibrator(vibratorManager.vibratorIds[0])
OwlTheme {
Settings(LocalContext.current, alarms = alarms, mVibrator = mVibrator)
}*/
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/presentation/settings/Settings.kt | 881033660 |
package com.eipsaferoad.owl.presentation.home
import android.content.Context
import androidx.compose.animation.core.RepeatMode
import androidx.compose.animation.core.animateFloat
import androidx.compose.animation.core.infiniteRepeatable
import androidx.compose.animation.core.rememberInfiniteTransition
import androidx.compose.animation.core.tween
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.rounded.Clear
import androidx.compose.material.icons.rounded.Favorite
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Devices
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.navigation.NavHostController
import androidx.wear.compose.material.Button
import androidx.wear.compose.material.ButtonDefaults
import androidx.wear.compose.material.Icon
import androidx.wear.compose.material.Text
import androidx.wear.compose.navigation.rememberSwipeDismissableNavController
import com.eipsaferoad.owl.models.Alarm
import com.eipsaferoad.owl.models.SoundAlarm
import com.eipsaferoad.owl.models.VibrationAlarm
import com.eipsaferoad.owl.presentation.PagesEnum
import com.eipsaferoad.owl.presentation.theme.OwlTheme
import com.eipsaferoad.owl.utils.KeysEnum
import com.eipsaferoad.owl.utils.LocalStorage
@Composable
fun Home(currentHeartRate: MutableState<String>, context: Context, navController: NavHostController, alarms: MutableState<Alarm>) {
if (alarms.value.isAlarmActivate && currentHeartRate.value.toInt() < 50 && currentHeartRate.value.toInt() != 0) {
Alarm(currentHeartRate)
} else {
NoAlarm(currentHeartRate.value, context, navController)
}
}
@Composable
fun NoAlarm(currentHeartRate: String, context: Context, navController: NavHostController) {
Column(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
LazyColumn(
modifier = Modifier.height(200.dp),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
item {
Column(
modifier = Modifier.padding(bottom = 100.dp, top = 70.dp),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Icon(
imageVector = Icons.Rounded.Favorite,
contentDescription = "Favorite Icon",
tint = Color.Red
)
Text(
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center,
fontWeight = FontWeight.Bold,
color = Color.White,
text = currentHeartRate,
fontSize = 40.sp
)
}
}
item {
Buttons(context = context, navController = navController)
}
}
}
}
@Composable
fun Buttons(context: Context, navController: NavHostController) {
Column(
modifier = Modifier.padding(bottom = 40.dp),
verticalArrangement = Arrangement.spacedBy(10.dp)
) {
Button(
modifier = Modifier
.width(150.dp),
shape = RoundedCornerShape(10),
colors = ButtonDefaults.buttonColors(backgroundColor = MaterialTheme.colorScheme.primary),
onClick = {
navController.navigate(PagesEnum.SETTINGS.value)
}
) {
Text(
fontSize = 30.sp,
text = "ALARM",
)
}
Button(
modifier = Modifier.width(150.dp),
shape = RoundedCornerShape(10),
colors = ButtonDefaults.buttonColors(backgroundColor = MaterialTheme.colorScheme.tertiary),
onClick = {
LocalStorage.deleteData(context, KeysEnum.EMAIL.value)
LocalStorage.deleteData(context, KeysEnum.PASSWORD.value)
navController.navigate(PagesEnum.LOGIN.value)
}
) {
Text(
fontSize = 17.sp,
text = "DISCONNECTION",
)
}
}
}
@Composable
fun MultiColorBorderCircularColumn(
borderColors: List<Color>,
content: @Composable () -> Unit
) {
val transition = rememberInfiniteTransition(label = "")
val rotation by transition.animateFloat(
initialValue = 0f,
targetValue = 360f,
animationSpec = infiniteRepeatable(
animation = tween(durationMillis = 5000),
repeatMode = RepeatMode.Restart
), label = ""
)
Surface(
modifier = Modifier
.fillMaxSize()
.border(
width = 5.dp,
color = Color.Transparent,
shape = CircleShape
)
.graphicsLayer(
rotationZ = rotation
),
contentColor = Color.White
) {
Box(
modifier = Modifier
.fillMaxSize()
.border(
width = 7.dp,
brush = borderBrushMultiColor(borderColors),
shape = CircleShape
)
.background(MaterialTheme.colorScheme.background)
) {
content()
}
}
}
@Composable
fun borderBrushMultiColor(colors: List<Color>): Brush {
return Brush.linearGradient(
colors = colors,
)
}
@Composable
fun Alarm(currentHeartRate: MutableState<String>) {
Box(
modifier = Modifier.fillMaxSize(),
contentAlignment = Alignment.Center
) {
MultiColorBorderCircularColumn(
borderColors = listOf(
MaterialTheme.colorScheme.secondary,
Color.Transparent,
MaterialTheme.colorScheme.secondary,
)
) {}
Column(
modifier = Modifier
.padding(30.dp)
.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally,
) {
Column(
modifier = Modifier
.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Text(
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.error,
text = currentHeartRate.value,
fontSize = 20.sp
)
Text(
modifier = Modifier
.fillMaxWidth()
.padding(bottom = 20.dp),
textAlign = TextAlign.Center,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.secondary,
text = "SOS",
fontSize = 30.sp
)
Button(
colors = ButtonDefaults.buttonColors(
backgroundColor = MaterialTheme.colorScheme.secondary,
),
onClick = {
currentHeartRate.value = "100"
}
) {
CircleIcon(icon = Icons.Rounded.Clear, tint = MaterialTheme.colorScheme.surface)
}
}
}
}
}
@Composable
fun CircleIcon(icon: ImageVector, tint: Color) {
Box(
modifier = Modifier
.size(50.dp)
.background(color = MaterialTheme.colorScheme.secondary, shape = CircleShape) // Background circle
) {
Icon(
modifier = Modifier
.align(Alignment.Center)
.size(100.dp),
tint = tint,
imageVector = icon,
contentDescription = "Icon description"
)
}
}
@Composable
@Preview(device = Devices.WEAR_OS_LARGE_ROUND, showSystemUi = true)
fun PreviewHome() {
val bpm: MutableState<String> = mutableStateOf("0")
val alarms: MutableState<Alarm> = mutableStateOf(Alarm(VibrationAlarm(), SoundAlarm(1, 0), false))
val navController = rememberSwipeDismissableNavController()
OwlTheme {
Home(bpm, LocalContext.current, navController, alarms)
}
}
@Composable
@Preview
fun PreviewButtons() {
val navController = rememberSwipeDismissableNavController()
OwlTheme {
Buttons(LocalContext.current, navController)
}
}
@Composable
@Preview(device = Devices.WEAR_OS_LARGE_ROUND, showSystemUi = true)
fun PreviewAlarm() {
val bpm: MutableState<String> = mutableStateOf("0")
OwlTheme {
Alarm(currentHeartRate = bpm)
}
}
@Composable
@Preview(device = Devices.WEAR_OS_LARGE_ROUND, showSystemUi = true)
fun PreviewNoAlarm() {
val navController = rememberSwipeDismissableNavController()
OwlTheme {
NoAlarm(currentHeartRate = "42", LocalContext.current, navController)
}
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/presentation/home/Home.kt | 2409832758 |
package com.eipsaferoad.owl.presentation.components
import android.app.RemoteInput
import android.content.Intent
import android.os.Bundle
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.text.ClickableText
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.drawBehind
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.tooling.preview.Preview
import androidx.wear.input.RemoteInputIntentHelper
import com.eipsaferoad.owl.presentation.theme.OwlTheme
@Composable
fun TextInput(
placeholder: String,
value: String?,
onChange: (value: String) -> Unit,
) {
val launcher =
rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) {
it.data?.let { data ->
val results: Bundle = RemoteInput.getResultsFromIntent(data)
val newValue: CharSequence? = results.getCharSequence(placeholder)
onChange(newValue as String)
}
}
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier
.drawBehind {
val strokeWidth = 1 * density
val y = size.height - strokeWidth / 2
drawLine(
Color.LightGray,
Offset(0f, y),
Offset(size.width, y),
strokeWidth
)
}
) {
ClickableText(
text = buildAnnotatedString {
withStyle(style = SpanStyle(color = Color.White)) {
// Set the desired text color here
append(if (value == null || value.isEmpty()) placeholder else value)
}
},
onClick = {
val intent: Intent = RemoteInputIntentHelper.createActionRemoteInputIntent();
val remoteInputs: List<RemoteInput> = listOf(
RemoteInput.Builder(placeholder)
.setLabel(placeholder)
.build()
)
RemoteInputIntentHelper.putRemoteInputsExtra(intent, remoteInputs)
launcher.launch(intent)
}
)
}
}
@Composable
@Preview
fun PreviewTextInput() {
OwlTheme {
Box(
) {
TextInput(placeholder = "placeholder", value = "", onChange = {})
}
}
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/presentation/components/TextInput.kt | 3292644871 |
package com.eipsaferoad.owl.presentation.theme
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
val md_theme_light_primary = Color(0xFF00ACEE)
val md_theme_light_onPrimary = Color(0xFFFFFFFF)
val md_theme_light_primaryContainer = Color(0xFFFFDDB3)
val md_theme_light_onPrimaryContainer = Color(0xFF291800)
val md_theme_light_secondary = Color(0xFFFFDE59)
val md_theme_light_onSecondary = Color(0xFFFFFFFF)
val md_theme_light_secondaryContainer = Color(0xFFFBDEBC)
val md_theme_light_onSecondaryContainer = Color(0xFF271904)
val md_theme_light_tertiary = Color(0xFF8D9497)
val md_theme_light_onTertiary = Color(0xFFFFFFFF)
val md_theme_light_tertiaryContainer = Color(0xFFD4EABB)
val md_theme_light_onTertiaryContainer = Color(0xFF102004)
val md_theme_light_error = Color(0xFFFC0404)
val md_theme_light_errorContainer = Color(0xFFFFDAD6)
val md_theme_light_onError = Color(0xFFFFFFFF)
val md_theme_light_onErrorContainer = Color(0xFF410002)
val md_theme_light_background = Color(0xFF000000)
val md_theme_light_onBackground = Color(0xFF1F1B16)
val md_theme_light_surface = Color(0xFF00275B)
val md_theme_light_onSurface = Color(0xFF1F1B16)
val md_theme_light_surfaceVariant = Color(0xFFF0E0CF)
val md_theme_light_onSurfaceVariant = Color(0xFF4F4539)
val md_theme_light_outline = Color(0xFF817567)
val md_theme_light_inverseOnSurface = Color(0xFFF9EFE7)
val md_theme_light_inverseSurface = Color(0xFF34302A)
val md_theme_light_inversePrimary = Color(0xFFFFB951)
val md_theme_light_surfaceTint = Color(0xFF825500)
val md_theme_light_outlineVariant = Color(0xFFD3C4B4)
val md_theme_light_scrim = Color(0xFF000000)
val md_theme_dark_primary = Color(0xFF00ACEE)
val md_theme_dark_onPrimary = Color(0xFF452B00)
val md_theme_dark_primaryContainer = Color(0xFF633F00)
val md_theme_dark_onPrimaryContainer = Color(0xFFFFDDB3)
val md_theme_dark_secondary = Color(0xFFFFDE59)
val md_theme_dark_onSecondary = Color(0xFF3E2D16)
val md_theme_dark_secondaryContainer = Color(0xFF56442A)
val md_theme_dark_onSecondaryContainer = Color(0xFFFBDEBC)
val md_theme_dark_tertiary = Color(0xFF8D9497)
val md_theme_dark_onTertiary = Color(0xFF243515)
val md_theme_dark_tertiaryContainer = Color(0xFF3A4C2A)
val md_theme_dark_onTertiaryContainer = Color(0xFFD4EABB)
val md_theme_dark_error = Color(0xFFFC0404)
val md_theme_dark_errorContainer = Color(0xFF93000A)
val md_theme_dark_onError = Color(0xFF690005)
val md_theme_dark_onErrorContainer = Color(0xFFFFDAD6)
val md_theme_dark_background = Color(0xFF000000)
val md_theme_dark_onBackground = Color(0xFFEAE1D9)
val md_theme_dark_surface = Color(0xFF00275B)
val md_theme_dark_onSurface = Color(0xFFEAE1D9)
val md_theme_dark_surfaceVariant = Color(0xFF4F4539)
val md_theme_dark_onSurfaceVariant = Color(0xFFD3C4B4)
val md_theme_dark_outline = Color(0xFF9C8F80)
val md_theme_dark_inverseOnSurface = Color(0xFF1F1B16)
val md_theme_dark_inverseSurface = Color(0xFFEAE1D9)
val md_theme_dark_inversePrimary = Color(0xFF825500)
val md_theme_dark_surfaceTint = Color(0xFFFFB951)
val md_theme_dark_outlineVariant = Color(0xFF4F4539)
val md_theme_dark_scrim = Color(0xFF000000)
private val LightColors = lightColorScheme(
primary = md_theme_light_primary,
onPrimary = md_theme_light_onPrimary,
primaryContainer = md_theme_light_primaryContainer,
onPrimaryContainer = md_theme_light_onPrimaryContainer,
secondary = md_theme_light_secondary,
onSecondary = md_theme_light_onSecondary,
secondaryContainer = md_theme_light_secondaryContainer,
onSecondaryContainer = md_theme_light_onSecondaryContainer,
tertiary = md_theme_light_tertiary,
onTertiary = md_theme_light_onTertiary,
tertiaryContainer = md_theme_light_tertiaryContainer,
onTertiaryContainer = md_theme_light_onTertiaryContainer,
error = md_theme_light_error,
errorContainer = md_theme_light_errorContainer,
onError = md_theme_light_onError,
onErrorContainer = md_theme_light_onErrorContainer,
background = md_theme_light_background,
onBackground = md_theme_light_onBackground,
surface = md_theme_light_surface,
onSurface = md_theme_light_onSurface,
surfaceVariant = md_theme_light_surfaceVariant,
onSurfaceVariant = md_theme_light_onSurfaceVariant,
outline = md_theme_light_outline,
inverseOnSurface = md_theme_light_inverseOnSurface,
inverseSurface = md_theme_light_inverseSurface,
inversePrimary = md_theme_light_inversePrimary,
surfaceTint = md_theme_light_surfaceTint,
outlineVariant = md_theme_light_outlineVariant,
scrim = md_theme_light_scrim,
)
private val DarkColors = darkColorScheme(
primary = md_theme_dark_primary,
onPrimary = md_theme_dark_onPrimary,
primaryContainer = md_theme_dark_primaryContainer,
onPrimaryContainer = md_theme_dark_onPrimaryContainer,
secondary = md_theme_dark_secondary,
onSecondary = md_theme_dark_onSecondary,
secondaryContainer = md_theme_dark_secondaryContainer,
onSecondaryContainer = md_theme_dark_onSecondaryContainer,
tertiary = md_theme_dark_tertiary,
onTertiary = md_theme_dark_onTertiary,
tertiaryContainer = md_theme_dark_tertiaryContainer,
onTertiaryContainer = md_theme_dark_onTertiaryContainer,
error = md_theme_dark_error,
errorContainer = md_theme_dark_errorContainer,
onError = md_theme_dark_onError,
onErrorContainer = md_theme_dark_onErrorContainer,
background = md_theme_dark_background,
onBackground = md_theme_dark_onBackground,
surface = md_theme_dark_surface,
onSurface = md_theme_dark_onSurface,
surfaceVariant = md_theme_dark_surfaceVariant,
onSurfaceVariant = md_theme_dark_onSurfaceVariant,
outline = md_theme_dark_outline,
inverseOnSurface = md_theme_dark_inverseOnSurface,
inverseSurface = md_theme_dark_inverseSurface,
inversePrimary = md_theme_dark_inversePrimary,
surfaceTint = md_theme_dark_surfaceTint,
outlineVariant = md_theme_dark_outlineVariant,
scrim = md_theme_dark_scrim,
)
@Composable
fun OwlTheme(
useDarkTheme: Boolean = isSystemInDarkTheme(),
content: @Composable () -> Unit
) {
val colors = if (!useDarkTheme) {
LightColors
} else {
DarkColors
}
/**
* Empty theme to customize for your app.
* See: https://developer.android.com/jetpack/compose/designsystems/custom
*/
MaterialTheme(
colorScheme = colors,
content = content
)
} | wearOsApp/app/src/main/java/com/eipsaferoad/owl/presentation/theme/Theme.kt | 3801544166 |
package com.eipsaferoad.owl.presentation
import androidx.compose.runtime.Composable
enum class PagesEnum(val value: String) {
LOGIN("login"),
HOME("home"),
SETTINGS("settings"),
ALARM("alarm")
}
typealias ComposableFun = @Composable () -> Unit
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/presentation/Page.kt | 2811738624 |
package com.eipsaferoad.owl.presentation.alarm
import android.content.Context
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.rounded.Favorite
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.sp
import androidx.navigation.NavHostController
import androidx.wear.compose.material.Icon
import androidx.wear.compose.material.Text
import androidx.wear.compose.navigation.rememberSwipeDismissableNavController
import com.eipsaferoad.owl.presentation.theme.OwlTheme
@Composable
fun Alarm(currentHeartRate: String, context: Context, navController: NavHostController) {
Column(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Icon(
imageVector = Icons.Rounded.Favorite,
contentDescription = "Favorite Icon",
tint = Color.Red
)
Text(
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center,
fontWeight = FontWeight.Bold,
color = Color.White,
text = currentHeartRate,
fontSize = 40.sp
)
}
}
@Composable
@Preview
fun PreviewAlarm() {
val navController = rememberSwipeDismissableNavController()
OwlTheme {
Alarm(currentHeartRate = "42", LocalContext.current, navController)
}
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/presentation/alarm/Alarm.kt | 3328779510 |
package com.eipsaferoad.owl.presentation.login
import android.content.Context
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.runtime.Composable
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.navigation.NavHostController
import androidx.wear.compose.material.Button
import androidx.wear.compose.material.Text
import com.eipsaferoad.owl.api.Request
import com.eipsaferoad.owl.core.Authentication
import com.eipsaferoad.owl.presentation.PagesEnum
import com.eipsaferoad.owl.presentation.components.TextInput
import com.eipsaferoad.owl.presentation.theme.OwlTheme
import com.eipsaferoad.owl.utils.LocalStorage
import okhttp3.FormBody
import okhttp3.Headers
@Composable
fun Login(context: Context, apiUrl: String, navController: NavHostController, setAccessToken: (token: String) -> Unit) {
val email = remember { mutableStateOf("") }
val password = remember { mutableStateOf("") }
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
TextInput(placeholder = "Email", value = email.value, onChange = { value -> email.value = value })
TextInput(placeholder = "Password", value = '.'.toString().repeat(password.value.length), onChange = { value -> password.value = value })
Button(
modifier = Modifier
.width(100.dp)
.padding(top = 10.dp),
onClick = {
Authentication.login(context = context, isNew = true, apiUrl = apiUrl, email = email.value, password = password.value, navController, setAccessToken)
}
) {
Text(text = "login")
}
}
}
@Composable
@Preview
fun PreviewLogin() {
OwlTheme {
Box(
) {
/*Login(apiUrl = "", changePage = {}, setAccessToken = {})*/
}
}
}
| wearOsApp/app/src/main/java/com/eipsaferoad/owl/presentation/login/Login.kt | 3457644691 |
enum class Language(val languageCode: String,val path:String) {
ZH("zh","\\values-zh\\strings.xml"),
EN("en","\\values-en\\strings.xml"),
ES("es","\\values-es\\strings.xml"),
IN("in","\\values-in\\strings.xml"),
TH("th","\\values-th\\strings.xml"),
VI("vi","\\values-vi\\strings.xml"),
} | AndroidStringXmlToCsv/src/main/kotlin/Language.kt | 203495274 |
data class TransLateData(
val stringId: String,
var zhValue: String = "",
var enValue: String = "",
var esValue: String = "",
var inValue: String = "",
var thValue: String = "",
var viValue: String = "",
)
| AndroidStringXmlToCsv/src/main/kotlin/TransLateData.kt | 1510821959 |
import androidx.compose.desktop.ui.tooling.preview.Preview
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.material.Button
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Window
import androidx.compose.ui.window.application
import com.github.doyaaaaaken.kotlincsv.dsl.csvWriter
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import java.awt.FileDialog
import java.awt.Frame
import java.io.File
import javax.xml.parsers.DocumentBuilderFactory
@Composable
@Preview
fun App() {
var xmlPath = remember { mutableStateOf("") }
val scope = rememberCoroutineScope()
val transLateDataList = mutableListOf<TransLateData>()
MaterialTheme {
Column {
Row {
Column(modifier = Modifier.weight(1f)) {
FilePicker("选择 res 目录", scope, xmlPath)
Text("选中的目录: ${xmlPath.value}", modifier = Modifier.padding(start = 12.dp))
}
}
Button(onClick = {
val path = "C:\\Users\\chenlijin\\my\\SystemSetting\\app\\src\\main\\res"
Language.entries.forEach {
extractedTranslate(xmlPath.value, transLateDataList, it)
}
val csvData = mutableListOf(
listOf("stringId", "中文", "英文", "西班牙语", "印度", "泰国", "越南"),
)
csvData.addAll(transLateDataList.map { data ->
listOf(
data.stringId,
data.zhValue,
data.enValue,
data.esValue,
data.inValue,
data.thValue,
data.viValue
)
})
csvWriter().writeAll(csvData, "translateData.csv")
}, modifier = Modifier.padding(16.dp)) {
Text("开始解析")
}
}
}
}
private fun extractedTranslate(basePath: String, transLateDataList: MutableList<TransLateData>, language: Language) {
val document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse("$basePath${language.path}")
val root = document.documentElement
val children = root.childNodes
for (i in 0 until children.length) {
if (children.item(i).childNodes.length > 0) {
val node = children.item(i).childNodes.item(0)
val key = children.item(i).attributes.getNamedItem("name").textContent
val value = node.textContent
if (transLateDataList.any { it.stringId == key }) {
val entity = transLateDataList.first { it.stringId == key }
when (language) {
Language.ZH -> entity.zhValue = value
Language.EN -> entity.enValue = value
Language.ES -> entity.esValue = value
Language.IN -> entity.inValue = value
Language.TH -> entity.thValue = value
Language.VI -> entity.viValue = value
}
} else {
when (language) {
Language.ZH -> transLateDataList.add(TransLateData(key, zhValue = value))
Language.EN -> transLateDataList.add(TransLateData(key, enValue = value))
Language.ES -> transLateDataList.add(TransLateData(key, esValue = value))
Language.IN -> transLateDataList.add(TransLateData(key, inValue = value))
Language.TH -> transLateDataList.add(TransLateData(key, thValue = value))
Language.VI -> transLateDataList.add(TransLateData(key, viValue = value))
}
}
}
}
}
fun main() = application {
Window(onCloseRequest = ::exitApplication) {
App()
}
}
@Composable
@Preview
fun FilePicker(text: String, scope: CoroutineScope, meiTuanFilePath: MutableState<String>) {
var fileDialog: FileDialog? = null
Column(modifier = Modifier.padding(16.dp)) {
Button(onClick = {
scope.launch {
fileDialog = FileDialog(Frame(), text, FileDialog.LOAD)
fileDialog?.isVisible = true
fileDialog?.let {
meiTuanFilePath.value = File(it.directory).parent
}
}
}) {
Text("选择文件")
}
}
}
| AndroidStringXmlToCsv/src/main/kotlin/Main.kt | 611615879 |
package com.davidm.sweetbankapp
import android.app.Application
import android.content.Context
import androidx.test.runner.AndroidJUnitRunner
class CustomRunner : AndroidJUnitRunner() {
@Throws(Exception::class)
override fun newApplication(
cl: ClassLoader?,
className: String?,
context: Context?
): Application? {
return super.newApplication(
cl,
SweetBank::class.java.name,
context
)
}
} | BankApp/app/src/androidTest/java/com/davidm/sweetbankapp/CustomRunner.kt | 4009782270 |
package com.davidm.sweetbankapp
import androidx.lifecycle.ViewModelProvider
import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.IdlingRegistry
import androidx.test.espresso.action.ViewActions
import androidx.test.espresso.action.ViewActions.*
import androidx.test.espresso.matcher.ViewMatchers.withId
import androidx.test.rule.ActivityTestRule
import com.davidm.network.BASE_URL
import com.davidm.payees.entities.Payee
import com.davidm.payees.entities.defaultAccount
import com.davidm.payees.network.PayeesApi
import com.davidm.payees.repository.PayeesRepository
import com.davidm.payees.ui.PayeesViewModel
import com.davidm.ui.HomepageActivity
import dagger.android.AndroidInjection
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import retrofit2.Retrofit
import javax.inject.Inject
class HomepageActivityTest {
@get:Rule
val mActivityTestRule: ActivityTestRule<HomepageActivity> = ActivityTestRule<HomepageActivity>(
HomepageActivity::class.java
)
@Before
fun setup() {
AndroidInjection.inject(mActivityTestRule.activity)
mActivityTestRule.activity
.supportFragmentManager.beginTransaction()
}
@Test
fun launchAndCreateAPayee() {
onView(withId(R.id.navigation_payees)).perform(click())
val x :PayeesApi = Retrofit.Builder()
.baseUrl(BASE_URL)
.build()
.create(PayeesApi::class.java)
PayeesViewModel(PayeesRepository(x)).getPayees()
onView(withId(R.id.fab)).perform(click())
onView(withId(R.id.createButton)).perform(click())
onView(withId(R.id.payeeNameEditText)).perform(
typeText("Antonio La Trippa's Account"),
closeSoftKeyboard()
)
onView(withId(R.id.createButton)).perform(click())
onView(withId(R.id.businessNameEditText)).perform(
typeText("BusinessName"),
closeSoftKeyboard()
)
}
}
| BankApp/app/src/androidTest/java/com/davidm/sweetbankapp/HomepageActivityTest.kt | 1078093729 |
package com.davidm.sweetbankapp
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)
}
}
| BankApp/app/src/test/java/com/davidm/sweetbankapp/ExampleUnitTest.kt | 564419619 |
package com.davidm.sweetbankapp
import android.app.Application
import com.davidm.account.repository.accountRepositoryModule
import com.davidm.account.repository.userRepositoryModule
import com.davidm.dashboardModule
import com.davidm.network.di.baseNetworkModule
import com.davidm.repository.transactionsRepositoryModule
import com.davidm.sweetbankapp.di.viewModelModule
import org.koin.android.ext.koin.androidContext
import org.koin.core.context.startKoin
class SweetBank : Application() {
override fun onCreate() {
super.onCreate()
startKoin {
androidContext(this@SweetBank)
modules(
dashboardModule, viewModelModule, userRepositoryModule, baseNetworkModule,
accountRepositoryModule, transactionsRepositoryModule
)
}
}
} | BankApp/app/src/main/java/com/davidm/sweetbankapp/SweetBank.kt | 986822236 |
package com.davidm.sweetbankapp.di
import com.davidm.ui.DashboardViewModel
import org.koin.android.viewmodel.dsl.viewModel
import org.koin.dsl.module
val viewModelModule = module {
viewModel {
DashboardViewModel(get(), get(), get())
}
} | BankApp/app/src/main/java/com/davidm/sweetbankapp/di/ViewmodelModuleX.kt | 3751358679 |
package com.davidm.payees
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.davidm.payees.test", appContext.packageName)
}
}
| BankApp/payees/src/androidTest/java/com/davidm/payees/ExampleInstrumentedTest.kt | 696500214 |
package com.davidm.payees
import com.davidm.payees.entities.Payee
import com.davidm.payees.entities.PayeeAccount
import com.davidm.payees.entities.PayeeType
import com.davidm.payees.entities.defaultAccount
import com.davidm.payees.utils.PayeeProfileInfoConverter
import com.davidm.payees.utils.PayeesLocalMapper
import junit.framework.Assert.assertEquals
import org.junit.Test
class PayeeProfileTest {
private val payee =
Payee(
listOf(defaultAccount),
"businessName",
"1990-12-12",
"firstName",
"lastName",
null,
"payeeName",
PayeeType.BUSINESS,
"qwe",
"123123123"
)
private val infoConverter: PayeeProfileInfoConverter = PayeeProfileInfoConverter()
private val localMapper: PayeesLocalMapper = PayeesLocalMapper()
@Test
fun `test payee profile`() {
val localPayeeList = localMapper.convertPayee(payee)
val profileInfoList = infoConverter.generateList(localPayeeList)
assertEquals(profileInfoList.size, 4)
assertEquals(profileInfoList[0].text, localPayeeList.firstAndLastName)
assertEquals(profileInfoList[0].icon, R.drawable.ic_person_black_24dp)
assertEquals(profileInfoList[1].text, localPayeeList.phoneNumber)
assertEquals(profileInfoList[1].icon, R.drawable.ic_phone_black_24dp)
assertEquals(profileInfoList[2].text, localPayeeList.dateOfBirth)
assertEquals(profileInfoList[2].icon, R.drawable.ic_perm_contact_calendar_black_24dp)
assertEquals(profileInfoList[2].text, localPayeeList.businessName)
assertEquals(profileInfoList[2].icon, R.drawable.ic_work_black_24dp)
}
} | BankApp/payees/src/test/java/com/davidm/payees/PayeeProfileTest.kt | 4181646104 |
package com.davidm.payees
import androidx.arch.core.executor.testing.InstantTaskExecutorRule
import com.davidm.payees.entities.Payee
import com.davidm.payees.entities.PayeeAccount
import com.davidm.payees.entities.PayeeType
import com.davidm.payees.entities.Payees
import com.davidm.payees.network.PayeesApi
import com.davidm.payees.repository.PayeesRepository
import io.mockk.coEvery
import io.mockk.coVerify
import io.mockk.mockk
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.runBlocking
import org.hamcrest.CoreMatchers.any
import org.junit.Assert.assertEquals
import org.junit.Before
import org.junit.Rule
import org.junit.Test
class RepositoryTest {
@get:Rule
val instantExecutorRule = InstantTaskExecutorRule()
private val payeeAccount = PayeeAccount("", "", null, null, null, null, null)
private val payee =
Payee(listOf(payeeAccount), null, null, null, null, null, "", PayeeType.BUSINESS, "", "")
private val api = mockk<PayeesApi>() {
coEvery { getPayees() } returns Payees(listOf(payee))
}
lateinit var repository: PayeesRepository
@Before
fun setUp() {
repository = PayeesRepository(api)
}
@ExperimentalCoroutinesApi
@Test
fun `test payeesApi coroutine retrieve`() = runBlocking {
val result = repository.retrievePayees()
assertEquals(result, listOf(payee))
}
} | BankApp/payees/src/test/java/com/davidm/payees/RepositoryTest.kt | 3249814564 |
package com.davidm.payees.utils
import com.davidm.payees.R
import com.davidm.payees.entities.Payee
import com.davidm.payees.entities.PayeeAccount
import com.davidm.payees.entities.PayeeType
import org.junit.Assert.*
import org.junit.Test
class PayeesLocalMapperTest {
private val payeeAccount = PayeeAccount("", "", null, null, null, null, null)
private val payee =
Payee(listOf(payeeAccount), null, null, null, null, null, "", PayeeType.BUSINESS, "", "")
private val payeeMapper = PayeesLocalMapper()
@Test
fun `test business payee conversion with everything as empty or null`() {
val mappedPayee = payeeMapper.convertPayee(payee)
assertEquals(mappedPayee.numberOfAccounts, "1 account")
assertEquals(mappedPayee.firstAndLastName, "Name not specified")
assertEquals(mappedPayee.initials, "")
assertEquals(mappedPayee.accountTypeIcon, R.drawable.ic_work_black_24dp)
}
} | BankApp/payees/src/test/java/com/davidm/payees/utils/PayeesLocalMapperTest.kt | 3627757028 |
package com.davidm.payees.ui
import androidx.recyclerview.widget.RecyclerView
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import com.davidm.payees.R
import com.davidm.payees.entities.PayeeAccount
import com.davidm.payees.utils.PayeesLocalMapper
import kotlinx.android.synthetic.main.payee_profile_account_item.view.*
class PayeeProfileAccountAdapter(
val data: List<PayeeAccount>
) : RecyclerView.Adapter<PayeeProfileAccountAdapter.ViewHolder>() {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val view = LayoutInflater.from(parent.context)
.inflate(R.layout.payee_profile_account_item, parent, false)
return ViewHolder(view)
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
val item = data[position]
holder.number.text = (position + 1).toString()
holder.accountId.text = item.accountIdentifier
holder.description.text = item.description
holder.bankId.text = item.bankIdentifier
if (item.defaultAccount !== null && item.defaultAccount) {
holder.defaultBadge.visibility = View.VISIBLE
} else {
holder.defaultBadge.visibility = View.INVISIBLE
}
}
override fun getItemCount(): Int = data.size
inner class ViewHolder(mView: View) : RecyclerView.ViewHolder(mView) {
val number: TextView = mView.account_number
val accountId: TextView = mView.accountIdentifier
val description: TextView = mView.description
val bankId: TextView = mView.bankIdentifier
val defaultBadge: TextView = mView.defaultBadge
}
}
| BankApp/payees/src/main/java/com/davidm/payees/ui/PayeeProfileAccountAdapter.kt | 3072945873 |
package com.davidm.payees.ui
import android.os.Bundle
import android.util.Log
import android.view.MenuItem
import androidx.appcompat.app.AppCompatActivity
import androidx.recyclerview.widget.DividerItemDecoration
import androidx.recyclerview.widget.RecyclerView
import com.davidm.payees.R
import com.davidm.payees.utils.CollapsingBarListener
import com.davidm.payees.utils.PayeeProfileInfoConverter
import com.davidm.payees.utils.PayeesLocalMapper
import com.google.android.material.appbar.AppBarLayout
import kotlinx.android.synthetic.main.activity_payee_profile.*
class PayeeProfileActivity : AppCompatActivity() {
private lateinit var payeeProfileInfoAdapter: PayeeProfileInfoAdapter
private lateinit var payeeProfileAccountAdapter: PayeeProfileAccountAdapter
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_payee_profile)
setSupportActionBar(toolbar)
supportActionBar?.setDisplayHomeAsUpEnabled(true)
supportActionBar?.setDisplayShowHomeEnabled(true)
val payee = intent.extras?.getParcelable<PayeesLocalMapper.LocalPayee>("profileData")
app_bar.addOnOffsetChangedListener(object: CollapsingBarListener() {
override fun onStateChanged(appBarLayout: AppBarLayout?, state: State?) {
when(state){
State.COLLAPSED -> toolbar_layout.title = payee?.payeeName
State.EXPANDED -> toolbar_layout.title = "${payee?.payeeName?.take(12)}..."
else -> null
}
}
})
val infoRecyclerView = findViewById<RecyclerView>(R.id.profile_info_list)
infoRecyclerView.addItemDecoration(
DividerItemDecoration(
this,
DividerItemDecoration.VERTICAL
)
)
val accountRecyclerView = findViewById<RecyclerView>(R.id.profile_accounts_list)
accountRecyclerView.addItemDecoration(
DividerItemDecoration(
this,
DividerItemDecoration.VERTICAL
)
)
if (payee !== null) {
supportActionBar?.title = payee.payeeName
val listOfValues = PayeeProfileInfoConverter().generateList(payee)
payeeProfileInfoAdapter = PayeeProfileInfoAdapter(listOfValues)
infoRecyclerView.adapter = payeeProfileInfoAdapter
payeeProfileAccountAdapter = PayeeProfileAccountAdapter(payee.accounts)
accountRecyclerView.adapter = payeeProfileAccountAdapter
}
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
onBackPressed()
return true
}
}
| BankApp/payees/src/main/java/com/davidm/payees/ui/PayeeProfileActivity.kt | 723503855 |
package com.davidm.payees.ui
import android.app.Dialog
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.davidm.payees.R
import com.google.android.material.bottomsheet.BottomSheetBehavior
import com.google.android.material.bottomsheet.BottomSheetDialog
import com.google.android.material.bottomsheet.BottomSheetDialogFragment
class PayeeCreationFragment : BottomSheetDialogFragment() {
private lateinit var viewModel: PayeesViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
return inflater.inflate(R.layout.payee_creation_fragment, container, false)
}
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
super.onCreateDialog(savedInstanceState)
val dialog: BottomSheetDialog =
super.onCreateDialog(savedInstanceState) as BottomSheetDialog
dialog.behavior.state = BottomSheetBehavior.STATE_EXPANDED
return dialog
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
//
// viewModel =
// ViewModelProvider(
// activity!!.viewModelStore,
// viewModelFactory
// ).get(PayeesViewModel::class.java)
//
//
// val map: Map<TextInputLayout, TextInputEditText> =
// mapOf(
// Pair(payeeNameInputLayout, payeeNameEditText),
// Pair(businessNameInputLayout, businessNameEditText)
// )
//
// createButton.setOnClickListener {
// searchAndSetErrorsOnForm(map)
// if (isFormValid(map)) {
//
// // we create a payee with the form's texts and some default values
// val payeeToBeCreated = Payee(
// listOf(defaultAccount),
// businessNameEditText.text.toString(),
// "1990-01-01",
// firstNameEditText.text.toString(),
// lastNameEditText.text.toString(),
// null,
// payeeNameEditText.text.toString(),
// PayeeType.BUSINESS,
// "0",
// phoneNumberEditText.text.toString()
// )
//
// viewModel.createPayee(payeeToBeCreated)
//
// showSnackBarAndRefreshList()
// }
//
// }
//
}
//
// private fun showSnackBarAndRefreshList() {
// viewModel.creationResponseLiveData.observe(viewLifecycleOwner, Observer {
// if ((activity?.window?.decorView?.rootView !== null)) {
// if (it.errors.isNullOrEmpty() && it.success) {
// Snackbar.make(
// activity?.window?.decorView?.rootView!!,
// "Success! The Payee has been created",
// Snackbar.LENGTH_LONG
// ).show()
//
// viewModel.getPayees()
//
// } else {
// Snackbar.make(
// activity?.window?.decorView?.rootView!!,
// "There was an error: ${it.errors?.get(0)?.error} , ${it.errors?.get(
// 0
// )?.error_description}",
// Snackbar.LENGTH_LONG
// ).show()
// }
// }
// dismiss()
// })
// }
}
| BankApp/payees/src/main/java/com/davidm/payees/ui/PayeeCreationFragment.kt | 1593549238 |
package com.davidm.payees.ui
import androidx.recyclerview.widget.RecyclerView
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.TextView
import com.davidm.payees.R
import com.davidm.payees.utils.PayeeProfileInfoConverter
import kotlinx.android.synthetic.main.payee_profile_info_item.view.*
class PayeeProfileInfoAdapter(
val data: List<PayeeProfileInfoConverter.PayeeProfileInfo>
) : RecyclerView.Adapter<PayeeProfileInfoAdapter.ViewHolder>() {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val view = LayoutInflater.from(parent.context)
.inflate(R.layout.payee_profile_info_item, parent, false)
return ViewHolder(view)
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
val item = data[position]
holder.textView.text = item.text.capitalize()
holder.imageView.setImageResource(item.icon)
}
override fun getItemCount(): Int = data.size
inner class ViewHolder(mView: View) : RecyclerView.ViewHolder(mView) {
val textView: TextView = mView.payeeInfoText
val imageView: ImageView = mView.payeeInfoIcon
}
}
| BankApp/payees/src/main/java/com/davidm/payees/ui/PayeeProfileInfoAdapter.kt | 197026291 |
package com.davidm.payees.ui
import android.util.Log
import androidx.lifecycle.*
import androidx.test.espresso.idling.CountingIdlingResource
import com.davidm.payees.entities.ErrorMessage
import com.davidm.payees.entities.Payee
import com.davidm.payees.entities.PayeeCreationResponse
import com.davidm.payees.entities.defaultError
import com.davidm.payees.repository.PayeesRepository
import com.davidm.payees.utils.PayeesLocalMapper
import com.davidm.payees.utils.launchIdling
import com.squareup.moshi.Moshi
import kotlinx.coroutines.*
import okhttp3.ResponseBody
import retrofit2.Response
import java.lang.Exception
class PayeesViewModel constructor(
private val payeesRepository: PayeesRepository
) : ViewModel() {
private val coroutineScope = CoroutineScope(Job() + Dispatchers.Main)
var payeesLiveData = MutableLiveData<List<PayeesLocalMapper.LocalPayee>>()
val creationResponseLiveData = MutableLiveData<PayeeCreationResponse>()
val mapper = PayeesLocalMapper()
init {
getPayees()
}
fun getPayees() {
coroutineScope.launchIdling {
val result = withContext(Dispatchers.IO) {
try {
payeesRepository.retrievePayees()
} catch (e: Exception) {
Log.e("network_error", e.message!!)
emptyList<Payee>()
}
}
payeesLiveData.postValue(result.map { mapper.convertPayee(it) })
}
}
fun createPayee(payee: Payee) {
coroutineScope.launch {
val result = withContext(Dispatchers.IO) {
try {
payeesRepository.createPayee(payee)
} catch (e: Exception) {
Log.e("network_error", e.message!!)
PayeeCreationResponse(
null,
listOf(defaultError),
null,
false
)
}
}
creationResponseLiveData.postValue(result)
}
}
}
| BankApp/payees/src/main/java/com/davidm/payees/ui/PayeesViewModel.kt | 2774468524 |
package com.davidm.payees.ui
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import com.davidm.payees.R
class PayeesFragment : Fragment() {
private lateinit var viewModel: PayeesViewModel
private lateinit var payeeListAdapter: PayeeListAdapter
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.payees_fragment, container, false)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
}
} | BankApp/payees/src/main/java/com/davidm/payees/ui/PayeesFragment.kt | 1894385081 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.