content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.example.vviiblue.horoscapp.data.network.response
import com.example.vviiblue.horoscapp.domain.model.PredictionModel
import com.google.gson.annotations.SerializedName
//@SerializedName("date") no se ofusca, entonces si se ofusca la app, entonces retrofit hara el match con lo que esta en el @SerializedName
/** Por norma general, para testear una operacion, debe estar en los mismos directorios en el directorio "test" porque es una operacion de capa domain entonces es un test unitario
* entonces para no estar recreando todos los directorios para hacer el test de "PredictionResponse"
* lo mejor es posicionar el mouse sobre la operacion "PredictionResponse" y precionar CTRL+SHIFT+T
* por ultimo dar en crear test, crear*/
data class PredictionResponse (
@SerializedName("date") val date: String,
@SerializedName("horoscope") val horoscope: String,
@SerializedName("sign") val sign: String,
){ // toDomain() es una funcion , que solo funcionara para el tipo de valor "PredictionResponse"
/**
*
* Esto es necesario, para que los modelos de datos no se compartan entre capas, de esta manera lo que se mandara a
* la capa Domain sera un modelo de datos que pertenece a Domain
* Esta es una buena practica,
* Para la capa de data esta bien que el modelo sea "PredictionResponse"
*pero lara la capa de domain se podria llamar "PredictionModel"
* Esta operacion simplemente toma lo que obtuvo la capa de data, lo transforma a un modelo de domain paraque el retorn sea valido a la capa domain
*
* Dicho lo anterior, se realiza el Mappeo ,que no es mas que una funcion que convierte el modelo de datos de un sitio(capa)
* en el modelo de datos de otro sitio(domain), a eso se le llama Mappear
* */
fun toDomain(): PredictionModel{
return PredictionModel(
horoscope = horoscope,
sign = sign
)
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/data/network/response/PredictionResponse.kt | 2754172713 |
package com.example.vviiblue.horoscapp.data.network
import com.example.vviiblue.horoscapp.BuildConfig.BASE_URL
import com.example.vviiblue.horoscapp.data.RepositoryImpl
import com.example.vviiblue.horoscapp.data.core.interceptors.AuthInterceptor
import com.example.vviiblue.horoscapp.domain.Repository
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import javax.inject.Singleton
/** clase para inyectar un servicio/libreria
* para que esto sea un Modulo real de Dager Hilt, se le debe agregar la annotation "@Module"
* se debe agregar otra annotation para definir el alcance que tendra el modulo "@InstallIn()", si quiero
* que todo el mundo pueda inyectarse esto, se deberia poner "@InstallIn(SingletonComponent::class)" */
@Module
@InstallIn(SingletonComponent::class)
class NetworkModule {
/** Ninguna de estas operaciones "provide" las invoco yo, las utiliza dagger hilt*/
/** Como necestio proveerme de Retrofit,
* entonces hago lo siguiente (Esto se aplica a cualquier otra libreria o servicio)
* Esto permite inyectar el objeto retrofit donde me de la gana*/
@Provides
@Singleton //para que se cree una sola vez el objeto retrofit, el resto de llamadas devolvera el objeto ya creado
fun provideRetrofit(okHttpClient: OkHttpClient):Retrofit{ //Devuelvo una instancia del objeto Retrofit
return Retrofit.Builder()
.baseUrl(BASE_URL) // la baseUrl de la api a la que voy a consutar
.client(okHttpClient) //El cliente es el "OkHttpClient","OkHttpClient" es la libreria que es parte de las llamadas a internet que permite meter Interceptors y mas cosas...
.addConverterFactory(GsonConverterFactory.create())//para convertir los objetos
.build()
}
/** Los Interceptor se meten dentro de la definicion de Retrofit, mas concretamente en su "OkHttpClient"
* para ellos como "OkHttpClient" es una "libreria", se define un proveedor, que devuelva el OkHttpClient */
@Provides
@Singleton
fun provideOkHttpClient(authInterceptor: AuthInterceptor):OkHttpClient{
//Defino el "Interceptor" a meter en el "OkHttpClient",este es el caso del Interceptor agregado por librria"HttpLoggingInterceptor"
/** tiene varios niveles de log, dependiendo en "level" sera la cantidad de informacion, la informacion se mostrara en LogCat terminal */
val interceptor = HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY)
/** "authInterceptor" es el "Interceptor" creado de "forma manual" por mi, que tambien se lo agregare al "OkHttpClient" */
return OkHttpClient
.Builder()
.addInterceptor(interceptor)
.addInterceptor(authInterceptor)
.build()
}
/** Se crea un interfaz ejecutablee de HoroscopeApiService, para inyectar Retrofit en la operacion (ya tengo un provide que
* que me devuelve un Retrofit "provideRetrofit()")
* con "provideHoroscopeApiService" Dagger HIlt sabra que existe un provide que prove HoroscopeApiService,
* por lo que sera posible inyectar "HoroscopeApiService" en una operacion*/
@Provides
fun provideHoroscopeApiService(retrofit: Retrofit): HoroscopeApiService {
return retrofit.create(HoroscopeApiService::class.java)
}
/** **************PASOS A SEGUIRIA DAGGER HILT*********************** */
/**
* 0) Inyecto el "HoroscopeApiService" en la impelemtacion del repositorio "RepositoryImpl" ->"RepositoryImpl @Inject constructor(private val apiService: HoroscopeApiService)"
* 1) Cuando se llame a "HoroscopeApiService", Dagger va a intentar invocar "provideHoroscopeApiService(retrofit: Retrofit)" para proveer de forma automatica el "HoroscopeApiService"
* 2) Dagger se da cuenta que necestia pasar por parametro un objeto "Retrofit", se va a la clase Retrofit y
* se fija si tiene "@Inject constructor()", claramente no porque es una clase de libreria, entonces pasa a fijarse si
* hay alguna operacion que proveea un "objeto Retrofit" en el modulo (clase con annotation @Module)
* 3) Dagger en el Modulo se fija si existe algun provide(@Provide) que devuelva un objeto "Retrofit"?, si "provideRetrofit()"
* 4) Dagger crea el objeto Retrofit usando la operacion "provideRetrofit()" y
* ahora si pasa el Retrofit a "provideHoroscopeApiService" y se crea y devuelve "HoroscopeApiService" para ser inyectado en "RepositoryImpl"
*5) Fin....
* */
@Provides
fun provideRepository(apiService: HoroscopeApiService): Repository {
return RepositoryImpl(apiService)
}
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/data/network/NetworkModule.kt | 1179347256 |
package com.example.vviiblue.horoscapp.data.network
import com.example.vviiblue.horoscapp.data.network.response.PredictionResponse
import retrofit2.http.GET
import retrofit2.http.Path
interface HoroscopeApiService {
@GET("/{sign}") // {sign} sera el nombre del signo del cual queremos saber la prediccion, {sign} tiene que hacer match con @Path("sign"), tienen que estar exactamente igual escritos
suspend fun getHoroscope(@Path("sign") sign:String): PredictionResponse // PredictionResponse: es el modelo que contendra la respuesta en la capa "data"
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/data/network/HoroscopeApiService.kt | 1401639055 |
package com.example.vviiblue.horoscapp.data
import android.util.Log
import com.example.vviiblue.horoscapp.data.network.HoroscopeApiService
import com.example.vviiblue.horoscapp.domain.Repository
import com.example.vviiblue.horoscapp.domain.model.PredictionModel
import javax.inject.Inject
/** para poder inyectar la clase y utilizar la clase y asi realizar la consulta a la aip, se debe agregar
* la annotation de DaggerHit "@Inject constructor()", en este caso, se le pasa un parametro */
/** Para inyectar librerias, se debe crear Modulos(Objetos de Dagger Hilt)
* en el Modulo se agregan los provider necesarios para que Dagger conozca como inyectar "HoroscopeApiService"*/
class RepositoryImpl @Inject constructor(private val apiService: HoroscopeApiService) : Repository {
override suspend fun getPrediction(singoDelZodiaco: String): PredictionModel? {
// Llamar Retrofit, hago la peticion a la api usando Retrofit
/** runCatching: Es una manera de ejecutar tareas dentro de una especie de "try-catch",
* se utiliza para ejecutar un bloque de código y
* capturar cualquier excepción que pueda ocurrir durante su ejecución */
runCatching {
/** Realizo la llamada a internet */
apiService.getHoroscope(singoDelZodiaco)
}
.onSuccess { // Si la consulta a la api retorno 200
return it.toDomain()
}
.onFailure { //Si la consulta a la api fallo
Log.i("Error consulta getPrediction ", "Ha ocurrido un error ${it.message}")
}
return null
}
}
| Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/data/RepositoryImpl.kt | 3514258430 |
package com.example.vviiblue.horoscapp.domain
import com.example.vviiblue.horoscapp.domain.model.PredictionModel
/** Cuando el ViewModel le solicite informacion al domain("El horoscopo de Geminis"), pero las capas "domain" y "data"
* no deberian "hablar"/tener una comunicacion directa para mantener la "cleanArquitecture", no deberian tener nada en comun */
/** Entonces, para devolverle la informacion que necesita el ViewModel, se realiza atravez de una interfaz*/
/** El repository sera la interfaz que brinde la COMUNICACION entre la capa de Data y la capa de Domain */
/** la implementacion estara en la capa de data "RepositoryImpl" (seria algo asi como un aplicar Proxy)*/
/** de esta forma se pueden hacer proyectos modulares, una capa en un lugar y otra en totalmente otro lugar*/
interface Repository {
suspend fun getPrediction(sign:String): PredictionModel?
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/domain/Repository.kt | 3638599487 |
package com.example.vviiblue.horoscapp.domain.model
data class PredictionModel (
val horoscope: String,
val sign: String
) | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/domain/model/PredictionModel.kt | 3205497798 |
package com.example.vviiblue.horoscapp.domain.model
enum class HoroscopeModel {
Aries,
Taurus,
Gemini,
Cancer,
Leo,
Virgo,
Libra,
Scorpio,
Sagittarius,
Capricorn,
Aquarius,
Pisces
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/domain/model/HoroscopeModel.kt | 378698163 |
package com.example.vviiblue.horoscapp.domain.model
import com.example.vviiblue.horoscapp.R
/** lo hago con un sealed , porque se que la cantidad de objetos van a ser solo estos horoscopos
* por ultimo al hacerlo asi, obligo que cuando se invoque este modelo se tengan que pasar la referencia de el nombre y de la imagen para devolver ese objeto
* entonces en vez de tener que crear un objeto generico HoroscopeInfo y pasarle la imagen y titulo, solo llamo a Aries por ejemplo y se que tendra su imagen y su nombre referenciados de forma correcta
* las selead class son utiles cuando es para algo que es limitado, que es fijo por ejemplo los colores del arco iris
* */
sealed class HoroscopeInfo(val img:Int, val name:Int){
data object Aries: HoroscopeInfo(R.drawable.aries, R.string.aries) /** tip*: data object es lo mismo que object, pero da la informacion mas clara al momento de depurar */
data object Taurus: HoroscopeInfo(R.drawable.tauro, R.string.taurus)
data object Gemini: HoroscopeInfo(R.drawable.geminis, R.string.gemini)
data object Cancer: HoroscopeInfo(R.drawable.cancer, R.string.cancer)
data object Leo: HoroscopeInfo(R.drawable.leo, R.string.leo)
data object Virgo: HoroscopeInfo(R.drawable.virgo, R.string.virgo)
data object Libra: HoroscopeInfo(R.drawable.libra, R.string.libra)
data object Scorpio: HoroscopeInfo(R.drawable.escorpio, R.string.scorpio)
data object Sagittarius: HoroscopeInfo(R.drawable.sagitario, R.string.sagittarius)
data object Capricorn: HoroscopeInfo(R.drawable.capricornio, R.string.capricorn)
data object Aquarius: HoroscopeInfo(R.drawable.aquario, R.string.aquarius)
data object Pisces: HoroscopeInfo(R.drawable.piscis, R.string.pisces)
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/domain/model/HoroscopeInfo.kt | 1722871671 |
package com.example.vviiblue.horoscapp.domain.usecase
import com.example.vviiblue.horoscapp.domain.Repository
import javax.inject.Inject
/** En la capa de dominio (es la logica de negocio, si la app exisitiera en anroid y ios,
* ambas app deberian tener la misma informacion en sus casos de uso con syntaxis diferente),
* los casos de usos son clases que tienen una unica responsabilidad
* en este caso la unica responsabilidad es obtener las preducciones*/
/** los casos de uso pueden nombrarse como "elnombre" , "elnombre+UseCase" , "elnombre+Interactor" */
/** Se tuvo que agregar "provideRepository" para poder inyectar "Repository" , ya que Dagger Hilt no sabra como devolver "Repository"
* recordar que:
* -para las librerias ,
* -clases que no se puedan acceder (privada) o
* -las interfaces(el caso de "Repository")
* hay que proveer desde el Modulo definido ("NetworkModule")
* */
class GetPredictionUseCase @Inject constructor(private val repository: Repository) {
/** La palabra clave "operator" se utiliza para sobrecargar operadores, en este caso la funcion "invoke" y
* sobrecargo el operador "invoke" para que reciba por parametro un string
* entonces al definir la opracion de esta manera, no tengo que ponerle un nombre a la operacion, sino
* que basta con poner el nombre del caso de uso y pasarle por parametro el signo del zodiaco
* en el viewModel se invoca la consulta de la prediccion a la capa de negocio de la forma siguiente
* "getPredictionUseCase(sign.name)" nada mas, no hay una operacion con un nombre determinado, "que se podria", simplemente con el "invoke" no es necesario*/
suspend operator fun invoke(sign:String) = repository.getPrediction(sign)
} | Horoscope/app/src/main/java/com/example/vviiblue/horoscapp/domain/usecase/GetPredictionUseCase.kt | 877878360 |
package com.example.trendmuch
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.trendmuch", appContext.packageName)
}
} | Hot-Takes/app/src/androidTest/java/com/example/trendmuch/ExampleInstrumentedTest.kt | 216843607 |
package com.example.trendmuch
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)
}
} | Hot-Takes/app/src/test/java/com/example/trendmuch/ExampleUnitTest.kt | 2842004354 |
package com.example.trendmuch
import android.util.Log
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.trendmuch.Articles
import kotlinx.coroutines.launch
class MainViewModel : ViewModel() {
var movieListResponse:List<Articles> by mutableStateOf(listOf())
var errorMessage: String by mutableStateOf("")
fun getMovieList() {
viewModelScope.launch {
val apiService = ApiService.getInstance()
try {
val movieList = apiService.getMovies()
movieListResponse = movieList.articles
}
catch (e: Exception) {
errorMessage = e.message.toString()
}
}
}
} | Hot-Takes/app/src/main/java/com/example/trendmuch/MainViewModel.kt | 2522957984 |
package com.example.trendmuch.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) | Hot-Takes/app/src/main/java/com/example/trendmuch/ui/theme/Color.kt | 927574519 |
package com.example.trendmuch.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 TrendMuchTheme(
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
)
} | Hot-Takes/app/src/main/java/com/example/trendmuch/ui/theme/Theme.kt | 4062506654 |
package com.example.trendmuch.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
)
*/
) | Hot-Takes/app/src/main/java/com/example/trendmuch/ui/theme/Type.kt | 3367270199 |
package com.example.trendmuch
import com.google.gson.annotations.SerializedName
data class Articles (
@SerializedName("source" ) var source : Source? = Source(),
@SerializedName("author" ) var author : String? = null,
@SerializedName("title" ) var title : String? = null,
@SerializedName("description" ) var description : String? = null,
@SerializedName("url" ) var url : String? = null,
@SerializedName("urlToImage" ) var urlToImage : String? = null,
@SerializedName("publishedAt" ) var publishedAt : String? = null,
@SerializedName("content" ) var content : String? = null
) | Hot-Takes/app/src/main/java/com/example/trendmuch/Articles.kt | 2070364007 |
package com.example.trendmuch
data class Movie(val name: String,
val imageUrl: String,
val desc: String,
val category: String)
| Hot-Takes/app/src/main/java/com/example/trendmuch/Model.kt | 1215541512 |
package com.example.trendmuch
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
@Database(entities = [User::class], version = 1)
abstract class UserDatabase : RoomDatabase() {
abstract fun userDao(): UserDao
companion object {
@Volatile
private var instance: UserDatabase? = null
fun getDatabase(context: Context): UserDatabase {
return instance ?: synchronized(this) {
val newInstance = Room.databaseBuilder(
context.applicationContext,
UserDatabase::class.java,
"user_database"
).build()
instance = newInstance
newInstance
}
}
}
} | Hot-Takes/app/src/main/java/com/example/trendmuch/UserDatabase.kt | 4293808270 |
package com.example.trendmuch
import android.content.Context
import android.content.Intent
import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
import android.os.Bundle
import android.util.Log
import android.widget.TextView
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.selection.selectable
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.modifier.modifierLocalConsumer
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.viewinterop.AndroidView
import androidx.core.text.HtmlCompat
import coil.compose.rememberImagePainter
import coil.size.Scale
import coil.transform.CircleCropTransformation
import com.example.trendmuch.Articles
import com.example.trendmuch.ui.theme.TrendMuchTheme
class Mainpage : ComponentActivity() {
val mainViewModel by viewModels<MainViewModel>()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
TrendMuchTheme() {
// A surface container using the 'background' color from the theme
Surface(color = MaterialTheme.colorScheme.background) {
Column() {
Text(text = "Latest NEWS", fontSize = 32.sp, modifier = Modifier.fillMaxWidth(), textAlign = TextAlign.Center)
MovieList(applicationContext, movieList = mainViewModel.movieListResponse)
mainViewModel.getMovieList()
}
}
}
}
}
}
@Composable
fun MovieList(context: Context, movieList: List<Articles>) {
var selectedIndex by remember { mutableStateOf(-1) }
LazyColumn {
itemsIndexed(items = movieList) {
index, item ->
MovieItem(context,movie = item, index, selectedIndex) { i ->
selectedIndex = i
}
}
}
}
@Composable
fun MovieItem(context: Context) {
val movie = Articles(
Source("coco"),
"",
" articl"
)
MovieItem(context,movie = movie, 0, 0) { i ->
Log.i("wertytest123abc", "MovieItem: "
+i)
}
}
@Composable
fun MovieItem(context: Context, movie: Articles, index: Int, selectedIndex: Int,
onClick: (Int) -> Unit) {
val backgroundColor =
if (index == selectedIndex) Color.Black else Color.White
Card(
modifier = Modifier
.padding(8.dp, 4.dp)
.fillMaxSize()
.selectable(true, true, null,
onClick = {
Log.i("test123abc", "MovieItem: $index/n$selectedIndex")
})
.clickable { onClick(index) }
.height(180.dp), shape = RoundedCornerShape(8.dp), elevation = CardDefaults.cardElevation(
defaultElevation = 4.dp
)
) {
Surface(color = Color.Cyan) {
Row(
Modifier
.padding(4.dp)
.fillMaxSize()
)
{
Image(
painter = rememberImagePainter(
data = movie.urlToImage,
builder = {
scale(Scale.FILL)
placeholder(R.drawable.placeholder)
transformations(CircleCropTransformation())
}
),
contentDescription = movie.description,
modifier = Modifier
.fillMaxHeight()
.weight(0.3f)
)
Column(
verticalArrangement = Arrangement.Center,
modifier = Modifier
.padding(4.dp)
.fillMaxHeight()
.weight(0.8f)
.background(Color(0xFF4dab33))
.padding(20.dp)
.selectable(true, true, null,
onClick = {
Log.i("test123abc", "MovieItem: $index/n${movie.description}")
context.startActivity(
Intent(context, DisplayNews::class.java)
.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
.putExtra("desk", movie.description.toString())
.putExtra("urlToImage", movie.urlToImage)
.putExtra("title", movie.title)
)
})
) {
Text(
text = movie.title.toString(),
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.Bold,
color = Color.White
)
HtmlText(html = movie.description.toString())
}
}
}
}
@Composable
fun HtmlText(html: String, modifier: Modifier = Modifier) {
AndroidView(
modifier = modifier
.fillMaxSize()
.size(30.dp),
factory = { context -> TextView(context) },
update = { it.text = HtmlCompat.fromHtml(html, HtmlCompat.FROM_HTML_MODE_COMPACT) }
)
}
} | Hot-Takes/app/src/main/java/com/example/trendmuch/Mainpage.kt | 3617996625 |
package com.example.trendmuch
import com.google.gson.annotations.SerializedName
data class News (
@SerializedName("status" ) var status : String? = null,
@SerializedName("totalResults" ) var totalResults : Int? = null,
@SerializedName("articles" ) var articles : ArrayList<Articles> = arrayListOf()
)
| Hot-Takes/app/src/main/java/com/example/trendmuch/News.kt | 987654339 |
package com.example.trendmuch
import com.google.gson.annotations.SerializedName
data class Source (
@SerializedName("id" ) var id : String? = null,
@SerializedName("name" ) var name : String? = null
)
| Hot-Takes/app/src/main/java/com/example/trendmuch/Source.kt | 2025832219 |
package com.example.trendmuch
import androidx.room.*
@Dao
interface UserDao {
@Query("SELECT * FROM user_table WHERE email = :email")
suspend fun getUserByEmail(email: String): User?
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertUser(user: User)
@Update
suspend fun updateUser(user: User)
@Delete
suspend fun deleteUser(user: User)
} | Hot-Takes/app/src/main/java/com/example/trendmuch/UserDao.kt | 459454160 |
package com.example.trendmuch
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity(tableName = "user_table")
data class User(
@PrimaryKey(autoGenerate = true) val id: Int?,
@ColumnInfo(name = "first_name") val firstName: String?,
@ColumnInfo(name = "last_name") val lastName: String?,
@ColumnInfo(name = "email") val email: String?,
@ColumnInfo(name = "password") val password: String?,
)
| Hot-Takes/app/src/main/java/com/example/trendmuch/User.kt | 3143486087 |
package com.example.trendmuch
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.GET
interface ApiService {
//@GET("movielist.json")
@GET("top-headlines?country=us&category=business&apiKey=684cb893caf7425abeffad82ac1d0f4e")
///@GET("search?q=chatgpt")
suspend fun getMovies() :News
companion object {
var apiService: ApiService? = null
fun getInstance() : ApiService {
if (apiService == null) {
apiService = Retrofit.Builder()
// .baseUrl("https://howtodoandroid.com/apis/")
.baseUrl("https://newsapi.org/v2/")
//.baseUrl("https://podcast-episodes.p.rapidapi.com/")
.addConverterFactory(GsonConverterFactory.create())
.build().create(ApiService::class.java)
}
return apiService!!
}
}
} | Hot-Takes/app/src/main/java/com/example/trendmuch/ApiService.kt | 1592871546 |
package com.example.trendmuch
import android.content.Context
import android.content.Intent
import android.graphics.drawable.Icon
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.*
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material.icons.filled.Person
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Divider
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.TextField
import androidx.compose.material3.TextFieldDefaults
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.content.ContextCompat
import androidx.core.content.ContextCompat.startActivity
import com.example.trendmuch.ui.theme.TrendMuchTheme
class LoginActivity : ComponentActivity() {
private lateinit var databaseHelper: UserDatabaseHelper
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
databaseHelper = UserDatabaseHelper(this)
setContent {
LoginScreen(this, databaseHelper)
}
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun LoginScreen(context: Context, databaseHelper: UserDatabaseHelper) {
var username by remember { mutableStateOf("") }
var password by remember { mutableStateOf("") }
var error by remember { mutableStateOf("") }
Column(
Modifier
.fillMaxHeight()
.fillMaxWidth()
.padding(28.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center)
{
Image(
painter = painterResource(id = R.drawable.news),
contentDescription = "")
Spacer(modifier = Modifier.height(10.dp))
Row {
Divider(color = Color.LightGray, thickness = 2.dp, modifier = Modifier
.width(155.dp)
.padding(top = 20.dp, end = 20.dp))
Text(text = "Login",
color = Color(0xFF6495ED),
fontWeight = FontWeight.Bold,
fontSize = 24.sp,style = MaterialTheme.typography.displayMedium)
Divider(color = Color.LightGray, thickness = 2.dp, modifier = Modifier
.width(155.dp)
.padding(top = 20.dp, start = 20.dp))
}
Spacer(modifier = Modifier.height(10.dp))
TextField(
value = username,
onValueChange = { username = it },
leadingIcon = {
Icon(
imageVector = Icons.Default.Person,
contentDescription = "personIcon",
tint = Color(0xFF6495ED)
)
},
placeholder = {
Text(
text = "username",
color = Color.Black
)
},
colors = TextFieldDefaults.textFieldColors(
containerColor = Color.Transparent
)
)
Spacer(modifier = Modifier.height(20.dp))
TextField(
value = password,
onValueChange = { password = it },
leadingIcon = {
Icon(
imageVector = Icons.Default.Lock,
contentDescription = "lockIcon",
tint = Color(0xFF6495ED)
)
},
placeholder = { Text(text = "password", color = Color.Black) },
visualTransformation = PasswordVisualTransformation(),
colors = TextFieldDefaults.textFieldColors(containerColor = Color.Transparent)
)
Spacer(modifier = Modifier.height(12.dp))
if (error.isNotEmpty()) {
Text(
text = error,
color = MaterialTheme.colorScheme.error,
modifier = Modifier.padding(vertical = 16.dp)
)
}
Button(
onClick = {
if (username.isNotEmpty() && password.isNotEmpty()) {
val user = databaseHelper.getUserByUsername(username)
if (user != null && user.password == password) {
error = "Successfully log in"
context.startActivity(
Intent(
context,
Mainpage::class.java
)
)
//onLoginSuccess()
} else {
error = "Invalid username or password"
}
} else {
error = "Please fill all fields"
}
},
shape = RoundedCornerShape(20.dp),
colors = ButtonDefaults.buttonColors(containerColor = Color(0xFF77a2ef)),
modifier = Modifier.width(200.dp)
.padding(top = 16.dp)
) {
Text(text = "Log In", fontWeight = FontWeight.Bold)
}
Row(modifier = Modifier.fillMaxWidth()) {
TextButton(onClick = {
context.startActivity(
Intent(
context,
RegistrationActivity::class.java
))})
{ Text(text = "Sign up",
color = Color.Black
)}
Spacer(modifier = Modifier.width(100.dp))
TextButton(onClick = { /* Do something! */ })
{ Text(text = "Forgot password ?",
color = Color.Black
)}
}
}
}
private fun startMainPage(context: Context) {
val intent = Intent(context, Mainpage::class.java)
ContextCompat.startActivity(context, intent, null)
} | Hot-Takes/app/src/main/java/com/example/trendmuch/LoginActivity.kt | 2776342519 |
package com.example.trendmuch
import android.annotation.SuppressLint
import android.content.ContentValues
import android.content.Context
import android.database.Cursor
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
class UserDatabaseHelper(context: Context) :
SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {
companion object {
private const val DATABASE_VERSION = 1
private const val DATABASE_NAME = "UserDatabase.db"
private const val TABLE_NAME = "user_table"
private const val COLUMN_ID = "id"
private const val COLUMN_FIRST_NAME = "first_name"
private const val COLUMN_LAST_NAME = "last_name"
private const val COLUMN_EMAIL = "email"
private const val COLUMN_PASSWORD = "password"
}
override fun onCreate(db: SQLiteDatabase?) {
val createTable = "CREATE TABLE $TABLE_NAME (" +
"$COLUMN_ID INTEGER PRIMARY KEY AUTOINCREMENT, " +
"$COLUMN_FIRST_NAME TEXT, " +
"$COLUMN_LAST_NAME TEXT, " +
"$COLUMN_EMAIL TEXT, " +
"$COLUMN_PASSWORD TEXT" +
")"
db?.execSQL(createTable)
}
override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
db?.execSQL("DROP TABLE IF EXISTS $TABLE_NAME")
onCreate(db)
}
fun insertUser(user: User) {
val db = writableDatabase
val values = ContentValues()
values.put(COLUMN_FIRST_NAME, user.firstName)
values.put(COLUMN_LAST_NAME, user.lastName)
values.put(COLUMN_EMAIL, user.email)
values.put(COLUMN_PASSWORD, user.password)
db.insert(TABLE_NAME, null, values)
db.close()
}
@SuppressLint("Range")
fun getUserByUsername(username: String): User? {
val db = readableDatabase
val cursor: Cursor = db.rawQuery("SELECT * FROM $TABLE_NAME WHERE $COLUMN_FIRST_NAME = ?", arrayOf(username))
var user: User? = null
if (cursor.moveToFirst()) {
user = User(
id = cursor.getInt(cursor.getColumnIndex(COLUMN_ID)),
firstName = cursor.getString(cursor.getColumnIndex(COLUMN_FIRST_NAME)),
lastName = cursor.getString(cursor.getColumnIndex(COLUMN_LAST_NAME)),
email = cursor.getString(cursor.getColumnIndex(COLUMN_EMAIL)),
password = cursor.getString(cursor.getColumnIndex(COLUMN_PASSWORD)),
)
}
cursor.close()
db.close()
return user
}
@SuppressLint("Range")
fun getUserById(id: Int): User? {
val db = readableDatabase
val cursor: Cursor = db.rawQuery("SELECT * FROM $TABLE_NAME WHERE $COLUMN_ID = ?", arrayOf(id.toString()))
var user: User? = null
if (cursor.moveToFirst()) {
user = User(
id = cursor.getInt(cursor.getColumnIndex(COLUMN_ID)),
firstName = cursor.getString(cursor.getColumnIndex(COLUMN_FIRST_NAME)),
lastName = cursor.getString(cursor.getColumnIndex(COLUMN_LAST_NAME)),
email = cursor.getString(cursor.getColumnIndex(COLUMN_EMAIL)),
password = cursor.getString(cursor.getColumnIndex(COLUMN_PASSWORD)),
)
}
cursor.close()
db.close()
return user
}
@SuppressLint("Range")
fun getAllUsers(): List<User> {
val users = mutableListOf<User>()
val db = readableDatabase
val cursor: Cursor = db.rawQuery("SELECT * FROM $TABLE_NAME", null)
if (cursor.moveToFirst()) {
do {
val user = User(
id = cursor.getInt(cursor.getColumnIndex(COLUMN_ID)),
firstName = cursor.getString(cursor.getColumnIndex(COLUMN_FIRST_NAME)),
lastName = cursor.getString(cursor.getColumnIndex(COLUMN_LAST_NAME)),
email = cursor.getString(cursor.getColumnIndex(COLUMN_EMAIL)),
password = cursor.getString(cursor.getColumnIndex(COLUMN_PASSWORD)),
)
users.add(user)
} while (cursor.moveToNext())
}
cursor.close()
db.close()
return users
}
} | Hot-Takes/app/src/main/java/com/example/trendmuch/UserDatabaseHelper.kt | 2252371835 |
package com.example.trendmuch
import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.widget.TextView
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.paint
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.viewinterop.AndroidView
import androidx.core.text.HtmlCompat
import coil.compose.rememberAsyncImagePainter
import coil.compose.rememberImagePainter
import com.example.trendmuch.ui.theme.TrendMuchTheme
class DisplayNews : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
TrendMuchTheme() {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier
.fillMaxSize()
.border(border = BorderStroke(width = 5.dp, SolidColor(Color.Black)), shape = RoundedCornerShape(20.dp)),
color = MaterialTheme.colorScheme.background
) {
var desk = getIntent().getStringExtra("desk")
var title = getIntent().getStringExtra("title")
var uriImage = getIntent().getStringExtra("urlToImage")
Log.i("test123abc", "MovieItem: $desk")
Column(
Modifier
.background(Color(0xFF22d478))
.padding(20.dp), horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.Center) {
Text(text = ""+title, fontSize = 24.sp, color = Color.Black, fontWeight = FontWeight.Bold)
HtmlText(html = desk.toString())
/* AsyncImage(
model = "https://example.com/image.jpg",
contentDescription = "Translated description of what the image contains"
)*/
Image(
painter = rememberAsyncImagePainter(uriImage),
contentDescription = "My content description",
)
}
// Greeting(desk.toString())
}
}
}
}
}
@Composable
fun Greeting(name: String) {
// Text(text = "Hello $name!")
}
@Preview(showBackground = true)
@Composable
fun DefaultPreview() {
TrendMuchTheme() {
Greeting("Android")
}
}
@Composable
fun HtmlText(html: String, modifier: Modifier = Modifier) {
AndroidView(
modifier = modifier,
factory = { context -> TextView(context) },
update = { it.text = HtmlCompat.fromHtml(html, HtmlCompat.FROM_HTML_MODE_COMPACT) }
)
} | Hot-Takes/app/src/main/java/com/example/trendmuch/DisplayNews.kt | 3672308815 |
package com.example.trendmuch
import android.content.Context
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.*
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Email
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material.icons.filled.Person
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Divider
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.TextField
import androidx.compose.material3.TextFieldDefaults
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.content.ContextCompat
import com.example.trendmuch.ui.theme.TrendMuchTheme
class RegistrationActivity : ComponentActivity() {
private lateinit var databaseHelper: UserDatabaseHelper
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
databaseHelper = UserDatabaseHelper(this)
setContent {
RegistrationScreen(this,databaseHelper)
}
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun RegistrationScreen(context: Context, databaseHelper: UserDatabaseHelper) {
var username by remember { mutableStateOf("") }
var password by remember { mutableStateOf("") }
var email by remember { mutableStateOf("") }
var error by remember { mutableStateOf("") }
Column(
Modifier
.background(Color.White)
.fillMaxHeight()
.fillMaxWidth(),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center)
{
Row {
Text(
text = "Sign Up",
color = Color(0xFF6495ED),
fontWeight = FontWeight.Bold,
fontSize = 24.sp, style = MaterialTheme.typography.displayMedium ,
)
Divider(
color = Color.LightGray, thickness = 2.dp, modifier = Modifier
.width(250.dp)
.padding(top = 20.dp, start = 10.dp, end = 70.dp)
)
}
Image(
painter = painterResource(id = R.drawable.sign_up),
contentDescription = "",
modifier = Modifier.height(270.dp)
)
TextField(
value = username,
onValueChange = { username = it },
leadingIcon = {
Icon(
imageVector = Icons.Default.Person,
contentDescription = "personIcon",
tint = Color(0xFF6495ED)
)
},
placeholder = {
Text(
text = "username",
color = Color.Black
)
},
colors = TextFieldDefaults.textFieldColors(
containerColor = Color.Transparent
)
)
Spacer(modifier = Modifier.height(8.dp))
TextField(
value = password,
onValueChange = { password = it },
leadingIcon = {
Icon(
imageVector = Icons.Default.Lock,
contentDescription = "lockIcon",
tint = Color(0xFF6495ED)
)
},
placeholder = { Text(text = "password", color = Color.Black) },
visualTransformation = PasswordVisualTransformation(),
colors = TextFieldDefaults.textFieldColors(containerColor = Color.Transparent)
)
Spacer(modifier = Modifier.height(16.dp))
TextField(
value = email,
onValueChange = { email = it },
leadingIcon = {
Icon(
imageVector = Icons.Default.Email,
contentDescription = "emailIcon",
tint = Color(0xFF6495ED)
)
},
placeholder = { Text(text = "email", color = Color.Black) },
colors = TextFieldDefaults.textFieldColors(containerColor = Color.Transparent)
)
Spacer(modifier = Modifier.height(8.dp))
if (error.isNotEmpty()) {
Text(
text = error,
color = MaterialTheme.colorScheme.error,
modifier = Modifier.padding(vertical = 16.dp)
)
}
Button(
onClick = {
if (username.isNotEmpty() && password.isNotEmpty() && email.isNotEmpty()) {
val user = User(
id = null,
firstName = username,
lastName = null,
email = email,
password = password
)
databaseHelper.insertUser(user)
error = "User registered successfully"
// Start LoginActivity using the current context
context.startActivity(
Intent(
context,
LoginActivity::class.java
)
)
} else {
error = "Please fill all fields"
}
},
shape = RoundedCornerShape(20.dp),
colors = ButtonDefaults.buttonColors(containerColor = Color(0xFF77a2ef)),
modifier = Modifier.width(200.dp)
.padding(top = 16.dp)
) {
Text(text = "Register", fontWeight = FontWeight.Bold)
}
Row(
modifier = Modifier.padding(30.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.Center
) {
Text(text = "Have an account?")
TextButton(onClick = {
context.startActivity(
Intent(
context,
LoginActivity::class.java
)
)
}) {
Text(text = "Log in",
fontWeight = FontWeight.Bold,
color = Color(0xFF4285F4),
style = MaterialTheme.typography.displayMedium ,
)}
}
}
}
private fun startLoginActivity(context: Context) {
val intent = Intent(context, LoginActivity::class.java)
ContextCompat.startActivity(context, intent, null)
} | Hot-Takes/app/src/main/java/com/example/trendmuch/RegistrationActivity.kt | 3491533217 |
/*
* Copyright (C) 2023 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.happybirthday.ui.theme
import androidx.compose.ui.graphics.Color
val light_primary = Color(0xFFD0BCFF)
val light_secondary = Color(0xFFCCC2DC)
val light_tertiary = Color(0xFFEFB8C8)
val dark_primary = Color(0xFF6650a4)
val dark_secondary = Color(0xFF625b71)
val dark_tertiary = Color(0xFF7D5260)
| Ativ-Kot-img/app/src/main/java/com/example/happybirthday/ui/theme/Color.kt | 3593561967 |
/*
* Copyright (C) 2023 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.happybirthday.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 = dark_primary,
secondary = dark_secondary,
tertiary = dark_tertiary
)
private val LightColorScheme = lightColorScheme(
primary = light_primary,
secondary = light_secondary,
tertiary = light_tertiary
)
@Composable
fun HappyBirthdayTheme(
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
)
}
| Ativ-Kot-img/app/src/main/java/com/example/happybirthday/ui/theme/Theme.kt | 3207257769 |
/*
* Copyright (C) 2023 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.happybirthday.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
)
)
| Ativ-Kot-img/app/src/main/java/com/example/happybirthday/ui/theme/Type.kt | 1904458271 |
/*
* Copyright (C) 2023 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.happybirthday
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.Image
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.padding
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.happybirthday.ui.theme.HappyBirthdayTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
HappyBirthdayTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
GreetingImage(
stringResource(R.string.happy_birthday_text),
stringResource(R.string.signature_text)
)
}
}
}
}
}
@Composable
fun GreetingText(message: String, from: String, modifier: Modifier = Modifier) {
// Create a column so that texts don't overlap
Column(
verticalArrangement = Arrangement.Center,
modifier = modifier
) {
Text(
text = message,
fontSize = 50.sp,
lineHeight = 116.sp,
textAlign = TextAlign.Center,
modifier = Modifier.padding(top = 16.dp)
)
Text(
text = from,
fontSize = 36.sp,
modifier = Modifier
.padding(top = 16.dp)
.padding(end = 16.dp)
.align(alignment = Alignment.End)
)
}
}
@Composable
fun GreetingImage(message: String, from: String, modifier: Modifier = Modifier) {
// Create a box to overlap image and texts
Box(modifier) {
Image(
painter = painterResource(id = R.drawable.tec),
contentDescription = null,
contentScale = ContentScale.Crop,
alpha = 0.5F
)
GreetingText(
message = message,
from = from,
modifier = Modifier
.fillMaxSize()
.padding(8.dp)
)
}
}
@Preview(showBackground = false)
@Composable
private fun BirthdayCardPreview() {
HappyBirthdayTheme {
GreetingImage(
stringResource(R.string.happy_birthday_text),
stringResource(R.string.signature_text)
)
}
}
| Ativ-Kot-img/app/src/main/java/com/example/happybirthday/MainActivity.kt | 3356167258 |
package com.example.restaurantapp
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.restaurantapp", appContext.packageName)
}
} | RestaurantMobileApp/app/src/androidTest/java/com/example/restaurantapp/ExampleInstrumentedTest.kt | 3364654707 |
package com.example.restaurantapp
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)
}
} | RestaurantMobileApp/app/src/test/java/com/example/restaurantapp/ExampleUnitTest.kt | 307775544 |
package com.example.restaurantapp.ui.screens
import android.util.Log
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.restaurantapp.RestaurantApplication
import com.example.restaurantapp.data.AuthContext
import com.example.restaurantapp.data.RestaurantRepository
import com.example.restaurantapp.model.Order
import com.example.restaurantapp.model.Table
import kotlinx.coroutines.launch
import okhttp3.ResponseBody
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
interface OrderState {
object Success: OrderState
object Loading : OrderState
object Error : OrderState
}
class OrderViewModel(private val repository: RestaurantRepository): ViewModel(){
private lateinit var cart: List<Int>
private var chosenTable: Table? = null
var orderState: OrderState by mutableStateOf(OrderState.Loading)
private set
fun setCart(new_cart: List<Int>){
cart = new_cart
}
fun getCart(): List<Int> {
return cart
}
fun setTable(new_table: Table){
chosenTable = new_table
}
fun getTable(): Table? {
return chosenTable
}
fun sendOrder(){
var new_order = Order (
dishModelsId = getCart(),
tableModelId = getTable()?.id ?: -1,
identityUserId = AuthContext.getUser().id
)
viewModelScope.launch {
try{
var call = repository.sendOrder("Bearer "+AuthContext.getUser().token, new_order)
call.enqueue(object: Callback<ResponseBody> {
override fun onResponse(
call: Call<ResponseBody>,
response: Response<ResponseBody>
) {
if(response.isSuccessful) {
Log.d("orderResponse", response.body()?.string() ?: "noresponse")
orderState = OrderState.Success
}else{
Log.d("orderResponseErr", response.toString())
orderState = OrderState.Error
}
}
override fun onFailure(
call: Call<ResponseBody>,
t: Throwable
) {
Log.d("orderResponseF", t.message ?: "null throwable")
orderState = OrderState.Error
}
})
} catch(e:Exception){
Log.d("OrderError", e.message.toString())
}
}
}
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
val application = (this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY] as RestaurantApplication)
val restaurantRepository = application.container.restaurantRepository
OrderViewModel(repository = restaurantRepository)
}
}
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/OrderViewModel.kt | 2792850399 |
package com.example.restaurantapp.ui.screens
import android.util.Log
import androidx.compose.foundation.Image
import androidx.compose.foundation.horizontalScroll
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import com.example.restaurantapp.R
import com.example.restaurantapp.model.Table
@Composable
fun TableChoiceScreen(
tablesState: TablesState = TablesState.Loading,
infrastructureState: InfrastructureState = InfrastructureState.Loading,
viewModel: TableChoiceViewModel,
onTableChosen: () -> Unit,
orderViewModel: OrderViewModel
) {
when (infrastructureState) {
is InfrastructureState.Loading -> Text(stringResource(R.string.loading))
is InfrastructureState.Error -> Text(stringResource(R.string.error))
is InfrastructureState.receivedInfrastructure ->
Column(
modifier = Modifier
.verticalScroll(rememberScrollState())
.horizontalScroll(rememberScrollState())
){
when (tablesState) {
is TablesState.Loading -> Text(stringResource(R.string.loading))
is TablesState.Error -> Text(stringResource(R.string.error))
is TablesState.receivedTables ->
Column {
Text(
text ="Choose Your Table",
style = MaterialTheme.typography.headlineLarge,
)
var rows = infrastructureState.infrastructure.numberOfRows
var columns = infrastructureState.infrastructure.numberOfColumns
var tables = tablesState.tables
repeat(rows){rowIndex ->
Row(){
repeat(columns){ columnIndex ->
for (table in tables) {
if(rowIndex == table.gridRow && columnIndex == table.gridColumn){
TableSpot(
table = table,
viewModel = viewModel,
onTableChosen = {onTableChosen()},
orderViewModel = orderViewModel
)
}
}
}
}
}
}
}
}
}
}
@Composable
fun TableSpot(
table: Table,
viewModel: TableChoiceViewModel,
onTableChosen: () -> Unit = {},
orderViewModel: OrderViewModel
){
Card(){
Box{
if(table.isAvailable){
Image(painter = painterResource(id = R.drawable.available_table),
stringResource(R.string.an_available_table_description))
}else{
Image(painter = painterResource(id = R.drawable.unavailable_table),
stringResource(R.string.an_unavailable_table_description))
}
}
Text("Number of seats: ${table.numberOfSeats}")
if (!table.isAvailable) Text(stringResource(R.string.table_unavailable))
Button(
onClick = {
viewModel.chosenTableId = table.id
orderViewModel.setTable(table)
Log.d("chosenTable:", table.id.toString())
onTableChosen()
},
enabled = table.isAvailable
){
Text(stringResource(R.string.choose_button))
}
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/TableChoiceScreen.kt | 2317629460 |
package com.example.restaurantapp.ui.screens
import android.util.Log
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.restaurantapp.RestaurantApplication
import com.example.restaurantapp.data.AuthContext
import com.example.restaurantapp.data.RestaurantRepository
import com.example.restaurantapp.model.LoginParams
import com.example.restaurantapp.model.User
import kotlinx.coroutines.launch
import okhttp3.ResponseBody
import org.json.JSONObject
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
interface LoginState {
object Init : LoginState
object Success : LoginState
object Loading : LoginState
data class Error(val errorMessage:String = "") : LoginState
}
class LoginViewModel(val repository: RestaurantRepository): ViewModel() {
var loginState: LoginState by mutableStateOf(LoginState.Loading)
private set
fun loginUser(params: LoginParams){
viewModelScope.launch {
try {
var call = repository.loginUser(params)
call.enqueue(object: Callback<ResponseBody>{
override fun onFailure(call: Call<ResponseBody>, t: Throwable) {
Log.d("LoginResponseT", t.message ?: "null throwable")
loginState = LoginState.Error("An error has occured. Try again")
}
override fun onResponse(
call: Call<ResponseBody>,
response: Response<ResponseBody>
) {
if(!response.isSuccessful) {
Log.d("responseE", response.body().toString())
if(response.code() == 401){
loginState = LoginState.Error("Wrong username or password")
}else{
loginState = LoginState.Error("An error has occured")
}
}else{
var jsonString = response.body()?.string()
val json = JSONObject(jsonString)
val token = json.getString("token")
val id = json.getString("userId")
Log.d("responseS", token)
AuthContext.setUser(User(id,token))
loginState = LoginState.Success
}
}
})
} catch(e:Exception){
Log.d("LoginError", e.message.toString())
}
}
}
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
val application = (this[APPLICATION_KEY] as RestaurantApplication)
val restaurantRepository = application.container.restaurantRepository
LoginViewModel(repository = restaurantRepository)
}
}
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/LoginViewModel.kt | 2301690564 |
package com.example.restaurantapp.ui.screens
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.restaurantapp.R
import com.example.restaurantapp.model.LoginParams
import com.example.restaurantapp.ui.theme.RestaurantAppTheme
@Composable
fun LogInScreen(
loginState: LoginState = LoginState.Init,
onGoToRegister: () -> Unit = {},
onLogin: (params: LoginParams) -> Unit = {},
onGoToHome: () -> Unit = {},
modifier: Modifier = Modifier
) {
var isLoginError by rememberSaveable { mutableStateOf(false) }
var isUsernameError by rememberSaveable { mutableStateOf(false) }
var isPasswordError by rememberSaveable { mutableStateOf(false) }
var loginErrorMessage by rememberSaveable { mutableStateOf("error") }
when(loginState){
is LoginState.Success -> onGoToHome()
is LoginState.Error -> {
isLoginError = true
loginErrorMessage = loginState.errorMessage
}
}
var username by remember {mutableStateOf("")}
var password by remember { mutableStateOf("")}
fun validateUsername(){
isUsernameError = username.isEmpty()
}
fun validatePassword(){
isPasswordError = password.isEmpty()
}
fun validateCredentials(){
validateUsername()
validatePassword()
}
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
Text(
text = stringResource(R.string.login),
fontSize = 30.sp
)
Spacer(modifier = Modifier.size(8.dp))
OutlinedTextField(
value = username,
onValueChange = {
username = it
validateUsername()
},
label = { Text(stringResource(R.string.username)) },
supportingText = {
if (isUsernameError){
Text(text = stringResource(R.string.empty_username_error), color = MaterialTheme.colorScheme.error)
}
},
keyboardActions = KeyboardActions{validateUsername()}
)
OutlinedTextField(
value = password,
onValueChange = {
password = it
validatePassword()
},
label = { Text(stringResource(R.string.password)) },
supportingText = {
if(isPasswordError) {
Text(text = stringResource(R.string.empty_password_error), color = MaterialTheme.colorScheme.error)
}
},
keyboardActions = KeyboardActions{validatePassword()},
visualTransformation = PasswordVisualTransformation(),
)
if(isLoginError){
Text(
text = loginErrorMessage,
color = MaterialTheme.colorScheme.error
)
}
Spacer(modifier = Modifier.size(8.dp))
Button(onClick = {
validateCredentials()
if(!isUsernameError && !isPasswordError){
var params = LoginParams(username, password)
onLogin(params)
}
}) {
Text(
text = stringResource(R.string.login)
)
}
Button(onClick = { onGoToRegister() }) {
Text(
text = stringResource(R.string.goToRegister)
)
}
}
}
@Preview
@Composable
fun LogInScreenPreview(
){
RestaurantAppTheme {
LogInScreen()
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/LogInScreen.kt | 1013848241 |
package com.example.restaurantapp.ui.screens
import android.util.Log
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.restaurantapp.RestaurantApplication
import com.example.restaurantapp.data.RestaurantRepository
import com.example.restaurantapp.model.RegisterParams
import kotlinx.coroutines.launch
import okhttp3.ResponseBody
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
class RegisterViewModel(val repository: RestaurantRepository):ViewModel() {
fun registerUser(params: RegisterParams){
viewModelScope.launch {
try{
var call = repository.registerUser(params)
call.enqueue(object: Callback<ResponseBody> {
override fun onResponse(
call: Call<ResponseBody>,
response: Response<ResponseBody>
) {
if(response.isSuccessful) {
Log.d("responseS", response.body()?.string() ?: "noresponse")
}else{
Log.d("responseE", response.toString())
}
}
override fun onFailure(
call: Call<ResponseBody>,
t: Throwable
) {
Log.d("GetResponseT", t.message ?: "null throwable")
}
})
} catch(e:Exception){
Log.d("RegisterError", e.message.toString())
}
}
}
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
val application = (this[APPLICATION_KEY] as RestaurantApplication)
val restaurantRepository = application.container.restaurantRepository
RegisterViewModel(repository = restaurantRepository)
}
}
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/RegisterViewModel.kt | 1886424440 |
package com.example.restaurantapp.ui.screens
import android.util.Log
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.defaultMinSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import com.example.restaurantapp.R
import com.example.restaurantapp.model.Dish
var fakeDishes = listOf(
Dish(0,"pierogtgi","string", 1, true),
Dish(1,"kapusniak","string", 2, true),
Dish(2,"spaghetti","string", 3, true),
Dish(3,"pelmeni","string", 2, false),
Dish(4,"nalesniki","string string string string string string string string string string string string string string string string string string string ", 1, true),
Dish(5,"rosol","string", 4, true),
Dish(6,"pierogi","string", 1, true),
Dish(7,"kapusniak","string", 2, true),
Dish(8,"spaghetti","string", 3, true),
Dish(9,"pelmeni","string", 2, false),
Dish(10,"nalesniki","string", 1, true),
Dish(11,"rosol","string", 4, true),
)
@Composable
fun FoodChoiceScreen(
foodState: FoodState,
onGoToTableChoice: () -> Unit = {},
onReturn: () -> Unit = {},
viewModel: FoodChoiceViewModel,
orderViewModel: OrderViewModel
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier
.verticalScroll(rememberScrollState())
.widthIn(max = 350.dp)
) {
Text(
text ="Choose Your Dishes",
style = MaterialTheme.typography.headlineLarge,
)
when (foodState) {
is FoodState.Loading -> Text(stringResource(R.string.loading))
is FoodState.Error -> Text(stringResource(R.string.error))
is FoodState.receivedDishes -> Column {
foodState.dishes.forEach { dish ->
Card(
modifier = Modifier
.padding(4.dp)
.wrapContentHeight()
.defaultMinSize(350.dp, 100.dp)
.widthIn(max = 350.dp)
) {
Text(
dish.name,
modifier = Modifier
.padding(8.dp)
)
Text(dish.description)
Text(dish.availability.toString())
Text(dish.price.toString())
Row(
verticalAlignment = Alignment.CenterVertically
){
var amount: String by remember{mutableStateOf(viewModel.cart.count{it == dish.id}.toString())}
Button(onClick = {
viewModel.removeDishFromCart(dish.id)
amount = viewModel.cart.count{it == dish.id}.toString()
Log.d("cart:", viewModel.cart.toString())
}) {
Text(text = "-")
}
Text(
modifier = Modifier.padding(16.dp),
text = amount
)
Button(onClick = {
viewModel.addDishToCart(dish.id)
amount = viewModel.cart.count{it == dish.id}.toString()
Log.d("cart:", viewModel.cart.toString())
}) {
Text(text = "+")
}
}
}
}
}
}
Button(onClick = {
orderViewModel.setCart(viewModel.cart)
onGoToTableChoice()
}) {
Text(text = stringResource(R.string.goToTableChoiceButton))
}
Button(onClick = {onReturn()}) {
Text(text = stringResource(R.string.return_button))
}
}
}
| RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/FoodChoiceScreen.kt | 3411184280 |
package com.example.restaurantapp.ui.screens
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.widthIn
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import com.example.restaurantapp.R
@Composable
fun HomeScreen(
onGoToOrder : () -> Unit = {},
onGoToUserOrders : () -> Unit = {}
){
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
modifier = Modifier
.widthIn(max = 350.dp)
){
Text(
text = "Welcome to the Restaurant!",
style = MaterialTheme.typography.headlineLarge,
modifier = Modifier
.padding(10.dp, 0.dp, 10.dp, 100.dp),
textAlign = TextAlign.Center
)
Button(onClick = {onGoToOrder()}){
Text(stringResource(R.string.order_food_button))
}
Button(onClick = {onGoToUserOrders()}){
Text(stringResource(R.string.my_orders_button))
}
Button(onClick = {}){
Text(stringResource(R.string.log_out_button))
}
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/HomeScreen.kt | 3808657726 |
package com.example.restaurantapp.ui.screens
import android.util.Log
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.restaurantapp.RestaurantApplication
import com.example.restaurantapp.data.AuthContext
import com.example.restaurantapp.data.RestaurantRepository
import com.example.restaurantapp.model.Order
import com.example.restaurantapp.model.ReceivedOrder
import kotlinx.coroutines.launch
import okhttp3.ResponseBody
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
interface UserOrdersState{
data class receivedOrders(val orders: List<ReceivedOrder>): UserOrdersState
object Loading: UserOrdersState
object Error: UserOrdersState
}
class UserOrdersViewModel(private val repository: RestaurantRepository) : ViewModel() {
var userOrdersState: UserOrdersState by mutableStateOf(UserOrdersState.Loading)
private set
init {
getOrders()
}
fun getOrders(){
viewModelScope.launch {
Log.d("order_init", "init")
try {
userOrdersState = UserOrdersState.receivedOrders(repository.getOrders(AuthContext.getUser().id, "Bearer "+AuthContext.getUser().token))
}catch (e:Exception){
userOrdersState = UserOrdersState.Error
Log.d("dishException", e.toString())
}
}
}
/*
fun cancelOrder(orderId: Int){
viewModelScope.launch {
try {
var call = repository.cancelOrder(orderId, "Bearer "+AuthContext.getUser().token)
call.enqueue(object: Callback<ResponseBody>{
override fun onFailure(call: Call<ResponseBody>, t: Throwable) {
Log.d("order_deleteThrowable", t.message.toString())
}
override fun onResponse(
call: Call<ResponseBody>,
response: Response<ResponseBody>
) {
if(!response.isSuccessful){
Log.d("order_delete", "error")
}else{
Log.d("order_delete", "order deleted")
}
}
})
}catch (e:Exception){
Log.d("order_deleteException", e.toString())
}
}
}
*/
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
val application = (this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY] as RestaurantApplication)
val restaurantRepository = application.container.restaurantRepository
UserOrdersViewModel(repository = restaurantRepository)
}
}
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/UserOrdersViewModel.kt | 4259188942 |
package com.example.restaurantapp.ui.screens
import android.util.Log
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.restaurantapp.RestaurantApplication
import com.example.restaurantapp.data.RestaurantRepository
import com.example.restaurantapp.model.Dish
import kotlinx.coroutines.launch
interface FoodState {
data class receivedDishes(val dishes: List<Dish>) : FoodState
object Loading : FoodState
object Error : FoodState
}
class FoodChoiceViewModel(private val repository: RestaurantRepository): ViewModel() {
var foodState: FoodState by mutableStateOf(FoodState.Loading)
private set
var cart = mutableListOf<Int>()
init {
getDishes()
}
fun getDishes(){
viewModelScope.launch {
Log.d("order_init", "init")
foodState = FoodState.Loading
try {
foodState = FoodState.receivedDishes(repository.getDishes())
}catch (e:Exception){
foodState = FoodState.Error
Log.d("dishException", e.toString())
}
}
}
fun addDishToCart(dishID: Int){
cart.add(dishID)
}
fun removeDishFromCart(dishID: Int){
cart.remove(dishID)
}
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
val application = (this[APPLICATION_KEY] as RestaurantApplication)
val restaurantRepository = application.container.restaurantRepository
FoodChoiceViewModel(repository = restaurantRepository)
}
}
}
}
| RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/FoodChoiceViewModel.kt | 3715052644 |
package com.example.restaurantapp.ui.screens
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.res.stringResource
import com.example.restaurantapp.R
@Composable
fun FinalizeOrderScreen(
onGoToHome: () -> Unit = {},
orderViewModel: OrderViewModel,
orderState: OrderState
){
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
){
Column(){
orderViewModel.getCart()
}
Card(){
orderViewModel.getTable().toString()
}
Button(
onClick = { orderViewModel.sendOrder() },
enabled = orderState != OrderState.Success
) {
Text(text = stringResource(R.string.finalize_order_button))
}
if(orderState == OrderState.Error){
Text(text = stringResource(R.string.something_went_wrong_error))
}
Button(onClick = { onGoToHome() }) {
Text(text = stringResource(R.string.return_home_button))
}
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/FinalizeOrderScreen.kt | 2416816267 |
package com.example.restaurantapp.ui.screens
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.defaultMinSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role.Companion.Button
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import com.example.restaurantapp.R
@Composable
fun UserOrdersScreen(
userOrdersState: UserOrdersState,
onCancelOrder: () -> Unit = {},
viewModel: UserOrdersViewModel
){
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier
.verticalScroll(rememberScrollState())
){
when(userOrdersState){
is UserOrdersState.Loading -> Text(stringResource(R.string.loading))
is UserOrdersState.Error -> Text(stringResource(R.string.error))
is UserOrdersState.receivedOrders ->
Column(
modifier = Modifier
.widthIn(max = 350.dp)
) {
Text(
text = stringResource(R.string.your_orders_heading),
modifier = Modifier
.fillMaxWidth(),
style = MaterialTheme.typography.headlineLarge,
)
var orders = userOrdersState.orders
for (order in orders) {
Card (
modifier = Modifier
.padding(4.dp)
.wrapContentHeight()
.defaultMinSize(350.dp, 100.dp)
.widthIn(max = 350.dp)
){
Text(stringResource(R.string.dishes) +order.dishModels.toString())
Text(stringResource(R.string.table_number) +order.tableModelId)
Text(stringResource(R.string.table) +order.tableModel.toString())
Text(stringResource(R.string.status) +order.status)
Text(stringResource(R.string.price) +order.price)
/*
if(order.status == 2){
Button(onClick = { viewModel.cancelOrder(order.id) }) {
Text("Cancel Order")
}
}
*/
}
}
}
}
}
}
| RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/UserOrdersScreen.kt | 3111333289 |
package com.example.restaurantapp.ui.screens
import android.util.Log
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.size
import androidx.compose.material3.Button
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.runtime.getValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.restaurantapp.R
import com.example.restaurantapp.model.RegisterParams
@Composable
fun RegisterScreen (
onGoToLogin: () -> Unit = {},
onRegister: (RegisterParams) -> Unit = {}
){
var username by remember { mutableStateOf("")}
var email by remember { mutableStateOf("")}
var password by remember { mutableStateOf("")}
var age by remember { mutableStateOf("")}
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
){
Text(
text = stringResource(R.string.register),
fontSize = 30.sp
)
Spacer(modifier = Modifier.size(8.dp))
OutlinedTextField(
value = username,
onValueChange = {username = it},
label = { Text(text = stringResource(R.string.username))})
OutlinedTextField(
value = email,
onValueChange = {email = it},
label = { Text(text = stringResource(R.string.email))})
OutlinedTextField(
value = password,
visualTransformation = PasswordVisualTransformation(),
onValueChange = {password = it},
label = { Text(text = stringResource(R.string.password))})
OutlinedTextField(
value = age,
onValueChange = {age = it},
label = { Text(text = stringResource(R.string.age))})
Spacer(modifier = Modifier.size(8.dp))
Button(onClick = {
var params = RegisterParams(username, email, password, age)
onRegister(params)
}) {
Text(text = stringResource(R.string.register))
}
Button(onClick = {onGoToLogin()}){
Text(
text = stringResource(R.string.goToLogin)
)
}
}
}
@Preview
@Composable
fun RegisterPreview(){
RegisterScreen()
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/RegisterScreen.kt | 2759149146 |
package com.example.restaurantapp.ui.screens
import android.util.Log
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.restaurantapp.RestaurantApplication
import com.example.restaurantapp.data.RestaurantRepository
import com.example.restaurantapp.model.Infrastructure
import com.example.restaurantapp.model.Table
import kotlinx.coroutines.launch
interface TablesState {
data class receivedTables(val tables: List<Table>): TablesState
object Loading : TablesState
object Error : TablesState
}
interface InfrastructureState {
data class receivedInfrastructure(val infrastructure: Infrastructure): InfrastructureState
object Loading : InfrastructureState
object Error : InfrastructureState
}
class TableChoiceViewModel(val repository: RestaurantRepository): ViewModel() {
var tablesState: TablesState by mutableStateOf(TablesState.Loading)
private set
var infrastructureState: InfrastructureState by mutableStateOf(InfrastructureState.Loading)
private set
var chosenTableId: Int? = null
init {
getInfrastrucutre()
getTables()
}
fun getTables(){
viewModelScope.launch {
Log.d("table_init", "init")
try{
tablesState = TablesState.receivedTables(repository.getTables())
}catch (e:Exception){
tablesState = TablesState.Error
Log.d("TableException", e.toString())
}
}
}
fun getInfrastrucutre(){
viewModelScope.launch {
try {
infrastructureState = InfrastructureState.receivedInfrastructure(repository.getInfrastructure())
}catch (e:Exception){
}
}
}
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
val application = (this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY] as RestaurantApplication)
val restaurantRepository = application.container.restaurantRepository
TableChoiceViewModel(repository = restaurantRepository)
}
}
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/screens/TableChoiceViewModel.kt | 1763208031 |
package com.example.restaurantapp.ui
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.navigation
import androidx.navigation.compose.rememberNavController
import com.example.restaurantapp.model.LoginParams
import com.example.restaurantapp.model.RegisterParams
import com.example.restaurantapp.ui.screens.FinalizeOrderScreen
import com.example.restaurantapp.ui.screens.FoodChoiceScreen
import com.example.restaurantapp.ui.screens.FoodChoiceViewModel
import com.example.restaurantapp.ui.screens.HomeScreen
import com.example.restaurantapp.ui.screens.LogInScreen
import com.example.restaurantapp.ui.screens.LoginViewModel
import com.example.restaurantapp.ui.screens.OrderViewModel
import com.example.restaurantapp.ui.screens.RegisterScreen
import com.example.restaurantapp.ui.screens.RegisterViewModel
import com.example.restaurantapp.ui.screens.TableChoiceScreen
import com.example.restaurantapp.ui.screens.TableChoiceViewModel
import com.example.restaurantapp.ui.screens.UserOrdersScreen
import com.example.restaurantapp.ui.screens.UserOrdersViewModel
enum class RestaurantScreen {
Login,
Register,
Home,
Order,
FoodChoice,
TableChoice,
FinalizeOrder,
UserOrders
}
@Composable
fun RestaurantApp(
navController: NavHostController = rememberNavController()
){
val orderViewModel : OrderViewModel = viewModel(factory = OrderViewModel.Factory)
Surface {
NavHost(
navController = navController,
startDestination = RestaurantScreen.Login.name
){
composable(route = RestaurantScreen.Login.name){
val viewModel : LoginViewModel = viewModel(factory = LoginViewModel.Factory)
LogInScreen(
loginState = viewModel.loginState,
onGoToRegister = {
navController.navigate(RestaurantScreen.Register.name)
},
onGoToHome = {
navController.navigate((RestaurantScreen.Home.name))
},
onLogin = {
params: LoginParams ->
viewModel.loginUser(params)
}
)
}
composable(route = RestaurantScreen.Register.name){
val viewModel : RegisterViewModel = viewModel(factory = RegisterViewModel.Factory)
RegisterScreen(
onGoToLogin = {
navController.navigate(RestaurantScreen.Login.name)
},
onRegister = {
params: RegisterParams ->
viewModel.registerUser(params)
}
)
}
composable(route = RestaurantScreen.Home.name){
HomeScreen(
onGoToOrder = {
navController.navigate(RestaurantScreen.Order.name)
},
onGoToUserOrders = {
navController.navigate(RestaurantScreen.UserOrders.name)
}
)
}
navigation(
startDestination = RestaurantScreen.FoodChoice.name,
route = RestaurantScreen.Order.name
){
composable(route = RestaurantScreen.FoodChoice.name){
val viewmodel : FoodChoiceViewModel = viewModel(factory = FoodChoiceViewModel.Factory)
FoodChoiceScreen(
foodState = viewmodel.foodState,
onGoToTableChoice = {
navController.navigate(RestaurantScreen.TableChoice.name)
},
onReturn = {
navController.navigate(RestaurantScreen.Home.name)
},
viewModel = viewmodel,
orderViewModel = orderViewModel
)
}
composable(route = RestaurantScreen.TableChoice.name){
val viewmodel: TableChoiceViewModel = viewModel(factory = TableChoiceViewModel.Factory)
TableChoiceScreen(
tablesState = viewmodel.tablesState,
infrastructureState = viewmodel.infrastructureState,
viewModel = viewmodel,
onTableChosen = {
navController.navigate(RestaurantScreen.FinalizeOrder.name)
},
orderViewModel = orderViewModel
)
}
composable(route = RestaurantScreen.FinalizeOrder.name){
FinalizeOrderScreen(orderState = orderViewModel.orderState, orderViewModel = orderViewModel)
}
}
composable(route = RestaurantScreen.UserOrders.name){
val viewmodel: UserOrdersViewModel = viewModel(factory = UserOrdersViewModel.Factory)
UserOrdersScreen(userOrdersState = viewmodel.userOrdersState, viewModel = viewmodel)
}
}
}
}
| RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/RestaurantApp.kt | 3264043552 |
package com.example.restaurantapp.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) | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/theme/Color.kt | 147546932 |
package com.example.restaurantapp.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 RestaurantAppTheme(
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
)
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/theme/Theme.kt | 1743074809 |
package com.example.restaurantapp.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
)
*/
) | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/ui/theme/Type.kt | 1495188198 |
package com.example.restaurantapp
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.Surface
import androidx.compose.ui.Modifier
import com.example.restaurantapp.ui.RestaurantApp
import com.example.restaurantapp.ui.theme.RestaurantAppTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
RestaurantAppTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
) {
RestaurantApp()
}
}
}
}
}
| RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/MainActivity.kt | 4288607761 |
package com.example.restaurantapp.network
import com.example.restaurantapp.data.AuthContext
import com.example.restaurantapp.model.Dish
import com.example.restaurantapp.model.Infrastructure
import com.example.restaurantapp.model.LoginParams
import com.example.restaurantapp.model.Order
import com.example.restaurantapp.model.ReceivedOrder
import com.example.restaurantapp.model.RegisterParams
import com.example.restaurantapp.model.Table
import okhttp3.ResponseBody
import retrofit2.Call
import retrofit2.http.Body
import retrofit2.http.DELETE
import retrofit2.http.GET
import retrofit2.http.Header
import retrofit2.http.Headers
import retrofit2.http.POST
import retrofit2.http.Path
interface RestaurantApiService {
@Headers("Content-Type:application/json")
@POST("register-user")
//make this work with suspend modifier
fun registerUser(@Body body: RegisterParams): Call<ResponseBody>
@Headers("Content-Type:application/json")
@POST("login-user")
fun loginUser(@Body body: LoginParams): Call<ResponseBody>
@GET("api/dish")
suspend fun getDishes(): List<Dish>
@GET("api/table")
suspend fun getTables(): List<Table>
@GET("api/table/get-infrastructure")
suspend fun getInfrastructure(): Infrastructure
@POST("api/order")
fun sendOrder(@Header("Authorization") token: String, @Body body: Order): Call<ResponseBody>
@GET("GetAllUserOrders/{userId}")
//fun getOrders(@Path("userId") userId: String, @Header("Authorization") token: String): Call<ResponseBody>
suspend fun getOrders(@Path("userId") userId: String, @Header("Authorization") token: String): List<ReceivedOrder>
@DELETE("/api/Dish/{orderId}")
fun cancelOrder(@Path("orderId") orderId: Int, @Header("Authorization") token:String): Call<ResponseBody>
}
| RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/network/RestaurantApiService.kt | 4088811969 |
package com.example.restaurantapp
import android.app.Application
import com.example.restaurantapp.data.AppContainer
import com.example.restaurantapp.data.DefaultAppContainer
class RestaurantApplication: Application() {
lateinit var container: AppContainer
override fun onCreate() {
super.onCreate()
container = DefaultAppContainer()
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/RestaurantApplication.kt | 3198321960 |
package com.example.restaurantapp.model
data class RegisterParams(
val username: String,
val email: String,
val password: String,
val age: String,
)
data class LoginParams(
val username: String,
val password: String
)
data class User(
val id: String,
val token: String
)
data class Dish(
val id: Int,
val name: String,
val description: String,
val price: Int,
val availability: Boolean
)
data class Infrastructure(
val numberOfRows: Int,
val numberOfColumns: Int
)
data class Table(
val id: Int,
val isAvailable: Boolean,
val numberOfSeats: Int,
val gridRow: Int,
val gridColumn: Int
)
data class Order(
//val price: Int,
val tableModelId: Int,
val dishModelsId: List<Int>,
val identityUserId: String
)
data class ReceivedOrder(
val id: Int,
val status: Int,
val price: Int,
val tableModelId: Int,
val tableModel: ReceivedTable,
val dishModels: List<Any>,
val identityUserId: String,
val identityUserModel: Any
)
data class ReceivedTable(
val id: Int,
val isAvailable: Boolean,
val numberOfSeats: Int,
val gridRow: Int,
val gridColumn: Int,
val orderModels: Any,
val reservations: Any
) | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/model/Models.kt | 1493400495 |
package com.example.restaurantapp.data
import com.example.restaurantapp.model.User
object AuthContext {
private lateinit var user: User
fun setUser(new_user: User){
user = new_user
}
fun getUser(): User{
return user
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/data/AuthContext.kt | 1160340992 |
package com.example.restaurantapp.data
import com.example.restaurantapp.model.Dish
import com.example.restaurantapp.model.Infrastructure
import com.example.restaurantapp.model.LoginParams
import com.example.restaurantapp.model.Order
import com.example.restaurantapp.model.ReceivedOrder
import com.example.restaurantapp.model.RegisterParams
import com.example.restaurantapp.model.Table
import com.example.restaurantapp.network.RestaurantApiService
import okhttp3.ResponseBody
import retrofit2.Call
class RestaurantRepository (private val restaurantApiService: RestaurantApiService){
suspend fun registerUser(body: RegisterParams): Call<ResponseBody>{
return restaurantApiService.registerUser(body)
}
suspend fun loginUser(body: LoginParams): Call<ResponseBody>{
return restaurantApiService.loginUser(body)
}
suspend fun getDishes(): List<Dish>{
return restaurantApiService.getDishes()
}
suspend fun getTables(): List<Table>{
return restaurantApiService.getTables()
}
suspend fun getInfrastructure(): Infrastructure {
return restaurantApiService.getInfrastructure()
}
fun sendOrder(token:String, body: Order): Call<ResponseBody>{
return restaurantApiService.sendOrder(token, body)
}
suspend fun getOrders(userId: String, token:String): List<ReceivedOrder>/*Call<ResponseBody>*/{
return restaurantApiService.getOrders(userId, token)
}
fun cancelOrder(orderId: Int, token: String): Call<ResponseBody>{
return restaurantApiService.cancelOrder(orderId, token)
}
} | RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/data/RestaurantRepository.kt | 1557277297 |
package com.example.restaurantapp.data
import com.example.restaurantapp.network.RestaurantApiService
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
interface AppContainer {
val restaurantRepository: RestaurantRepository
}
class DefaultAppContainer: AppContainer{
private val BASE_URL = "https://restaurantapi20240224142603.azurewebsites.net/"
fun createRetrofit(): Retrofit {
var interceptor = HttpLoggingInterceptor();
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
var client: OkHttpClient = OkHttpClient.Builder().addInterceptor(interceptor).build();
return Retrofit
.Builder()
.addConverterFactory(GsonConverterFactory.create())
.baseUrl(BASE_URL)
.client(client)
.build()
}
fun createApiService(
retrofit: Retrofit
): RestaurantApiService {
return retrofit
.create(RestaurantApiService::class.java)
}
override val restaurantRepository: RestaurantRepository by lazy {
RestaurantRepository(createApiService(createRetrofit()))
}
}
| RestaurantMobileApp/app/src/main/java/com/example/restaurantapp/data/AppContainer.kt | 1105137982 |
package com.example.project1dicegame
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.project1dicegame", appContext.packageName)
}
} | Dice-Game-Kotlin/app/src/androidTest/java/com/example/project1dicegame/ExampleInstrumentedTest.kt | 1540610871 |
package com.example.project1dicegame
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)
}
} | Dice-Game-Kotlin/app/src/test/java/com/example/project1dicegame/ExampleUnitTest.kt | 3166244596 |
package com.example.project1dicegame
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.appcompat.app.AlertDialog
import com.example.project1dicegame.databinding.ActivityMainBinding
import kotlin.random.Random
// Main activity of the app, inheriting from AppCompatActivity.
class MainActivity : AppCompatActivity() {
// Late-initialize the binding object for activity_main.xml.
private lateinit var binding: ActivityMainBinding
private lateinit var player1: Player
private lateinit var player2: Player
private lateinit var currentPlayer: Player
private var shouldRollAgain = false
private var doublePointsNextRoll = false
private var jackpot = 5
private var lastDiceRollResult: Int = 0
var correctAnswer: Int = 0
// Called when the activity is starting.
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
player1 = Player("Player 1")
player2 = Player("Player 2")
currentPlayer = player1 // Start with player 1
// Update the UI to show the current player's turn as soon as the app starts
binding.tvCurrentPlayer.text = "${currentPlayer.name}"
binding.tvJackpotTotal.text = "$jackpot"
binding.tvPlayer1Total.text = "0"
binding.tvPlayer2Total.text = "0"
// Set an onClickListener to the button, calling rollDice() when clicked.
binding.btnRoll.setOnClickListener {
binding.tvUserNotification.text = null
rollDice()
binding.etUserAnswer.text = null
//In the event player rolls a 5
if (lastDiceRollResult == 5){
binding.tvEquation.text = null
binding.tvUserNotification.text = "${currentPlayer.name}'s turn now! Roll Dice to continue."
}
}
//OnClickListener to the enter button calling validateAnswer() when clicked
binding.btnEnter.setOnClickListener {
val userAnswer = binding.etUserAnswer.text.toString().toIntOrNull()
userNotifications(userAnswer) // Pass the user's answer for notification
}
}
//Function to roll dice
private fun rollDice() {
val dice = Dice(6)
lastDiceRollResult = dice.diceRoll() // Roll the dice and store the result
// Handle the action based on the dice roll
when (lastDiceRollResult) {
1 -> generateAdditionProblem()
2 -> generateSubtractionProblem()
3, 6 -> generateMultiplicationProblem()
4 -> {
// Flag that a reroll is needed for double points
shouldRollAgain = true
doublePointsNextRoll = true
binding.tvEquation.text = null
binding.tvUserNotification.text = "${currentPlayer.name} rolls a 4, roll again for double points!"
}
5 -> switchTurns()
}
//when expression to determine the drawable based on the dice roll
val drawableResource = when (lastDiceRollResult) {
1 -> R.drawable.perspective_dice_six_faces_one
2 -> R.drawable.perspective_dice_six_faces_two
3 -> R.drawable.perspective_dice_six_faces_three
4 -> R.drawable.perspective_dice_six_faces_four
5 -> R.drawable.perspective_dice_six_faces_five
else -> R.drawable.dice_six // Default case for 6 and any other unexpected value
}
// Update the ImageView (dice) with the chosen drawable
binding.imageview.setImageResource(drawableResource)
}
//Function which generates an addition problem
private fun generateAdditionProblem(): String {
// Generating two random numbers from 0 and 99
val number1 = Random.nextInt(0, 99)
val number2 = Random.nextInt(0, 99)
// Storing the correct answer
correctAnswer = number1 + number2
// Create an addition problem with these numbers
val problem = "$number1 + $number2"
binding.tvEquation.text = problem
return problem
}
//Function which generates a subtraction problem
private fun generateSubtractionProblem(): String {
// Generating two random numbers from 0 and 99
val number1 = Random.nextInt(0, 99)
val number2 = Random.nextInt(0, 99)
// Storing the correct answer
correctAnswer = number1 - number2
// Create a subtraction problem with these numbers
val problem = "$number1 - $number2"
binding.tvEquation.text = problem
return problem
}
//Function which generates a multiplication problem
private fun generateMultiplicationProblem(): String{
// Generating two random numbers from 0 and 99
val number1 = Random.nextInt(0, 20)
val number2 = Random.nextInt(0, 20)
correctAnswer = number1 * number2
// Create a multiplication problem with these numbers
val problem = "$number1 X $number2"
binding.tvEquation.text = problem
return problem
}
//Function to manage jackpot and player scores
private fun manageJackpotAndScores(userAnswer: Int?) {
if (shouldRollAgain) {
if (lastDiceRollResult == 5) {
// Handles losing a turn if the player rolls a 5 after rolling a 4
shouldRollAgain = false
doublePointsNextRoll = false
return
} else if (doublePointsNextRoll) {
// Check if the re-roll was due to a prior roll of 4 and handle double points
if (userAnswer == correctAnswer) {
when (lastDiceRollResult) {
6 -> {
currentPlayer.score += (2 * jackpot)
resetJackpot()
}
3 -> { currentPlayer.score += 6 }
2 -> { currentPlayer.score += 4 }
else -> currentPlayer.score += 2 // Award double points for correct answer
}
} else {
// Handles incorrect answer when double points are expected
when (lastDiceRollResult) {
// If the user rolls a 6 after rolling a 4 and answers incorrectly
6 -> { jackpot += ((2 * jackpot)) }
// If the user rolls a 3 after rolling a 4 and answers incorrectly
3 -> { jackpot += 6 }
// If the user rolls a 2 after rolling a 4 and answers incorrectly
2 -> { jackpot += 4 }
// Default case for incorrect answers when expecting double points
else -> { jackpot += 2 }
}
}
shouldRollAgain = false
doublePointsNextRoll = false
}
} else {
// Normal flow for handling dice rolls and answers
if (userAnswer == correctAnswer) {
if (lastDiceRollResult == 6) {
currentPlayer.score += jackpot //Player receives jackpot points
resetJackpot()
} else {
when (lastDiceRollResult) {
3 -> { currentPlayer.score += 3 }
2 -> { currentPlayer.score += 2 }
else -> currentPlayer.score += 1
}
}
} else {
// Increases the jackpot for incorrect answers or attempts at the jackpot question
if (lastDiceRollResult == 6) {
jackpot *= 2 //Jackpot doubles
} else {
jackpot += when (lastDiceRollResult) {
3 -> 3 //Jackpot increase by 3
2 -> 2 //Jackpot increase by 2
else -> 1 //Jackpot increase by 1
}
}
}
}
// Checking if win condition is met
checkWinConditionAndUpdateUI()
}
//Function to display notification to user
private fun userNotifications(userAnswer: Int?) {
// Early return if userAnswer is null
if (userAnswer == null) {
binding.tvUserNotification.text = "Enter a number."
return
}
// Determining the notification based on game conditions and user answer
val notificationMessage = when {
shouldRollAgain && lastDiceRollResult == 5 -> "Correct! Jackpot won."
doublePointsNextRoll && userAnswer == correctAnswer && lastDiceRollResult == 6 -> "Double Jackpot points gained!!"
doublePointsNextRoll && userAnswer == correctAnswer -> "Correct! Double points awarded."
doublePointsNextRoll -> "Incorrect. No points awarded."
userAnswer == correctAnswer -> "Correct!"
else -> "Incorrect!"
}
// Sets the notification text
binding.tvUserNotification.text = notificationMessage
// After displaying the notification, manage the jackpot and scores
manageJackpotAndScores(userAnswer)
}
//Function that switches turns between players
private fun switchTurns() {
currentPlayer = if (currentPlayer == player1) player2 else player1
// Updates UI to show current player's turn
binding.tvCurrentPlayer.text = "${currentPlayer.name}"
}
//Function to check whether or not a user has won the game
private fun checkWinConditionAndUpdateUI() {
// Check for win condition after updating the score
if(currentPlayer.score >= 20){
showWinDialog() // Prompts user if they want to reset the game or not
}
updatePlayerScoresUI() // Update the UI with the new scores
binding.tvJackpotTotal.text = "$jackpot" // Update the jackpot display
if (!shouldRollAgain) {
switchTurns()
}
}
//Function used to reset game
private fun resetGame(){
player1.score = 0
player2.score = 0
currentPlayer = player1
shouldRollAgain = false
doublePointsNextRoll = false
binding.tvPlayer1Total.text = "0"
binding.tvPlayer2Total.text = "0"
binding.tvJackpotTotal.text = "5"
binding.tvUserNotification.text = ""
binding.tvEquation.text = ""
binding.etUserAnswer.text = null
}
// Function to reset jackpot to initial value 5
private fun resetJackpot() { jackpot = 5 }
//Function to update the scores of the players in the UI
private fun updatePlayerScoresUI() {
binding.tvPlayer1Total.text = "${player1.score}"
binding.tvPlayer2Total.text = "${player2.score}"
}
//Dialog function to prompt user upon winning whether they want to try again or not
private fun showWinDialog() {
val dialogBuilder = AlertDialog.Builder(this)
dialogBuilder.setMessage("Congratulations, ${currentPlayer.name} wins! Would you like to play again?")
.setCancelable(false)
.setPositiveButton("Yes") { dialog, id -> resetGame() }
.setNegativeButton("No") { dialog, id ->
dialog.dismiss()
finish() // Close the current activity and exit the app gracefully
}
val alert = dialogBuilder.create()
alert.setTitle("Game Over")
alert.show()
}
}
class Player(val name: String) { var score: Int = 0 }
// Class representing a dice with a given number of sides.
class Dice(private val numSides: Int) {
// Function to roll the dice and return a random number within its range.
fun diceRoll(): Int {
return (1..numSides).random() // Return a random number between 1 and numSides.
}
} | Dice-Game-Kotlin/app/src/main/java/com/example/project1dicegame/MainActivity.kt | 1904981178 |
package edu.temple.superbrowser
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("edu.temple.myapplication", appContext.packageName)
}
} | assignment8/app/src/androidTest/java/edu/temple/superbrowser/ExampleInstrumentedTest.kt | 1825680140 |
package edu.temple.superbrowser
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)
}
} | assignment8/app/src/test/java/edu/temple/superbrowser/ExampleUnitTest.kt | 3893800404 |
package edu.temple.superbrowser
interface DataInterface {
fun addPage()
fun pageChange(title: String)
} | assignment8/app/src/main/java/edu/temple/superbrowser/DataInterface.kt | 1523159717 |
package edu.temple.superbrowser
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageButton
class BrowserControlFragment : Fragment() {
private lateinit var pageButton : ImageButton
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_browser_control, container, false)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
pageButton = view.findViewById(R.id.imageButton)
pageButton.setOnClickListener{
activity?.run{
if(this is DataInterface)
(this as DataInterface).addPage()
}
}
}
companion object {
@JvmStatic
fun newInstance(param1: String, param2: String) =
BrowserControlFragment().apply {
arguments = Bundle().apply {
}
}
}
} | assignment8/app/src/main/java/edu/temple/superbrowser/BrowserControlFragment.kt | 2245222859 |
package edu.temple.superbrowser
import android.annotation.SuppressLint
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.webkit.WebView
import android.webkit.WebViewClient
import android.widget.EditText
import android.widget.ImageButton
import androidx.viewpager2.widget.ViewPager2
class PageViewerFragment : Fragment(){
private lateinit var webView: WebView
private lateinit var goButton: ImageButton
private lateinit var bkButton: ImageButton
private lateinit var fwdButton: ImageButton
private lateinit var urlEditText: EditText
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
return inflater.inflate(R.layout.fragment_page_viewer, container, false).apply {
webView = findViewById(R.id.webView)
goButton = findViewById(R.id.goButton)
bkButton = findViewById(R.id.bkButton)
fwdButton = findViewById(R.id.fwdButton)
urlEditText = findViewById(R.id.urlEditText)
}
}
@SuppressLint("SetJavaScriptEnabled")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
// Enable Javascript for proper functioning websites
webView.settings.javaScriptEnabled = true;
// Provision WebViewClient implementation that retrieves current page URL
webView.webViewClient = object: WebViewClient () {
override fun onPageFinished(view: WebView?, url: String?) {
super.onPageFinished(view, url)
url?.run {
urlEditText.setText(this)
activity?.run{
if(this is DataInterface)
(this as DataInterface).pageChange(webView.title.toString())
}
}
}
}
// Restore previous web state if present
savedInstanceState?.run {
webView.restoreState(this)
}
goButton.setOnClickListener {
urlEditText.setText(cleanUrl(urlEditText.text.toString()))
webView.loadUrl(urlEditText.text.toString())
}
bkButton.setOnClickListener {
webView.goBack()
}
fwdButton.setOnClickListener {
webView.goForward()
}
}
// Helper function to format malformed URLs
private fun cleanUrl(url: String) : String {
return if (url.startsWith("http"))
url
else
"https://$url"
}
override fun onSaveInstanceState(outState: Bundle) {
super.onSaveInstanceState(outState)
// Store current web state
webView.saveState(outState)
}
} | assignment8/app/src/main/java/edu/temple/superbrowser/PageViewerFragment.kt | 4224479353 |
package edu.temple.superbrowser
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.provider.Browser
import android.util.Log
import android.view.WindowManager
import androidx.annotation.Px
import androidx.fragment.app.Fragment
import androidx.viewpager2.adapter.FragmentStateAdapter
import androidx.viewpager2.widget.ViewPager2
class BrowserActivity : AppCompatActivity(), DataInterface {
private var numFragments = 1
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
val viewPager2 = findViewById<ViewPager2>(R.id.page_display)
viewPager2.adapter = object: FragmentStateAdapter(this){
override fun getItemCount(): Int {
return numFragments
}
override fun createFragment(position: Int): Fragment {
return PageViewerFragment()
}
}
viewPager2.registerOnPageChangeCallback(object: ViewPager2.OnPageChangeCallback(){
override fun onPageScrolled(
position: Int,
positionOffset: Float,
positionOffsetPixels: Int
) {
super.onPageScrolled(position, positionOffset, positionOffsetPixels)
setTitle("SuperBrowser - " + position)
}
} )
supportFragmentManager
.beginTransaction()
.add(R.id.browser_control, BrowserControlFragment())
.commit()
// Ensure browser page isn't added twice
}
override fun pageChange(title: String) {
setTitle("SuperBrowser - " + title)
}
override fun addPage() {
numFragments++
val viewPager2 = findViewById<ViewPager2>(R.id.page_display)
(viewPager2.adapter as FragmentStateAdapter).notifyDataSetChanged()
viewPager2.setCurrentItem(numFragments -1, true)
}
} | assignment8/app/src/main/java/edu/temple/superbrowser/BrowserActivity.kt | 1096317571 |
package com.example.myapplication
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.myapplication", appContext.packageName)
}
} | RecordingTest/app/src/androidTest/java/com/example/myapplication/ExampleInstrumentedTest.kt | 1188990709 |
package com.example.myapplication
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)
}
} | RecordingTest/app/src/test/java/com/example/myapplication/ExampleUnitTest.kt | 2019423820 |
package com.example.myapplication
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import com.example.myapplication.ui.theme.UiState
class MediaViewModel(private val myMediaRecorder: MyMediaRecorder) : ViewModel() {
private val _uiState = mutableStateOf(
UiState(
recordList = emptyList(),
isRecording = false
)
)
val uiState: State<UiState> = _uiState
fun onClickRecordingOrStopButton() {
val recording = _uiState.value.isRecording
when (recording) {
true -> myMediaRecorder.stopRecording()
false -> myMediaRecorder.startRecording()
}
_uiState.value = _uiState.value.copy(
isRecording = !recording
)
}
fun onClickPlayingButton() {
myMediaRecorder.startPlaying()
}
} | RecordingTest/app/src/main/java/com/example/myapplication/MediaViewModel.kt | 3227391028 |
package com.example.myapplication.ui.theme
import android.net.Uri
data class UiState(
val recordList: List<Uri>,
val isRecording: Boolean
) | RecordingTest/app/src/main/java/com/example/myapplication/ui/theme/UiState.kt | 3649784031 |
package com.example.myapplication.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) | RecordingTest/app/src/main/java/com/example/myapplication/ui/theme/Color.kt | 2513741509 |
package com.example.myapplication.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 MyApplicationTheme(
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
)
} | RecordingTest/app/src/main/java/com/example/myapplication/ui/theme/Theme.kt | 196007232 |
package com.example.myapplication.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
)
*/
) | RecordingTest/app/src/main/java/com/example/myapplication/ui/theme/Type.kt | 3481532690 |
package com.example.myapplication
import android.app.Application
import android.os.Build
import androidx.annotation.RequiresApi
import org.koin.android.ext.koin.androidContext
import org.koin.android.ext.koin.androidLogger
import org.koin.core.context.GlobalContext.startKoin
class App : Application() {
@RequiresApi(Build.VERSION_CODES.S)
override fun onCreate() {
super.onCreate()
startKoin {
androidLogger()
androidContext(this@App)
modules(appModule)
}
}
} | RecordingTest/app/src/main/java/com/example/myapplication/App.kt | 1933576942 |
package com.example.myapplication
import android.Manifest
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.activity.result.contract.ActivityResultContracts
import androidx.annotation.RequiresApi
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.platform.LocalContext
import androidx.core.content.ContextCompat
import com.example.myapplication.ui.theme.MyApplicationTheme
class MainActivity : ComponentActivity() {
@RequiresApi(Build.VERSION_CODES.S)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MyApplicationTheme {
Surface(color = MaterialTheme.colorScheme.background) {
RecordAndPlayUIWithPermissionCheck()
}
}
}
}
}
@RequiresApi(Build.VERSION_CODES.S)
@Composable
fun RecordAndPlayUIWithPermissionCheck() {
val context = LocalContext.current
var permissionToRecordAccepted by remember {
mutableStateOf(
ContextCompat.checkSelfPermission(
context,
Manifest.permission.RECORD_AUDIO
) == PackageManager.PERMISSION_GRANTED
)
}
val requestPermissionLauncher = rememberLauncherForActivityResult(
contract = ActivityResultContracts.RequestPermission(),
onResult = { isGranted: Boolean ->
permissionToRecordAccepted = isGranted
}
)
LaunchedEffect(Unit) {
if (!permissionToRecordAccepted) {
requestPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
}
}
if (permissionToRecordAccepted) {
RecordAndPlayUI()
} else {
Text("錄音權限未授予")
}
} | RecordingTest/app/src/main/java/com/example/myapplication/MainActivity.kt | 3734924057 |
package com.example.myapplication
import android.os.Build
import androidx.annotation.RequiresApi
import org.koin.android.ext.koin.androidApplication
import org.koin.androidx.viewmodel.dsl.viewModel
import org.koin.dsl.module
@RequiresApi(Build.VERSION_CODES.S)
val appModule = module {
single<MyMediaRecorder> {
MyMediaRecorderImpl(
context = androidApplication()
)
}
viewModel {
MediaViewModel(get())
}
} | RecordingTest/app/src/main/java/com/example/myapplication/AppModule.kt | 23237900 |
package com.example.myapplication
interface MyMediaRecorder {
fun startRecording()
fun stopRecording()
fun startPlaying()
fun cancelRecording()
} | RecordingTest/app/src/main/java/com/example/myapplication/MyMediaRecorder.kt | 4191327055 |
package com.example.myapplication
import android.Manifest
import android.content.pm.PackageManager
import android.os.Build
import android.widget.Toast
import androidx.annotation.RequiresApi
import androidx.compose.foundation.layout.Row
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.platform.LocalContext
import androidx.core.content.ContextCompat
import org.koin.androidx.compose.koinViewModel
@RequiresApi(Build.VERSION_CODES.S)
@Composable
fun RecordAndPlayUI() {
val viewModel: MediaViewModel = koinViewModel()
val state by viewModel.uiState
val context = LocalContext.current
Row {
Button(onClick = {
if (ContextCompat.checkSelfPermission(
context,
Manifest.permission.RECORD_AUDIO
) != PackageManager.PERMISSION_GRANTED
) {
Toast.makeText(context, "需要錄音權限", Toast.LENGTH_SHORT).show()
} else {
viewModel.onClickRecordingOrStopButton()
}
}) {
Text(if (state.isRecording) "停止錄音" else "開始錄音")
}
Button(onClick = viewModel::onClickPlayingButton) {
Text("播放錄音")
}
}
}
| RecordingTest/app/src/main/java/com/example/myapplication/RecordAndPlayUI.kt | 1699580773 |
package com.example.myapplication
import android.content.ContentValues
import android.content.Context
import android.media.MediaPlayer
import android.media.MediaRecorder
import android.net.Uri
import android.os.Build
import android.os.Environment
import android.os.ParcelFileDescriptor
import android.provider.MediaStore
import android.util.Log
import androidx.annotation.RequiresApi
import java.io.IOException
class MyMediaRecorderImpl(private val context: Context) : MyMediaRecorder {
@RequiresApi(Build.VERSION_CODES.S)
private val myMediaRecorder = MediaRecorder(context)
private var fileDescriptor: ParcelFileDescriptor? = null
private val mediaPlayer = MediaPlayer()
private var uri: Uri? = null
@RequiresApi(Build.VERSION_CODES.S)
override fun startRecording() {
fileDescriptor = context.contentResolver.openFileDescriptor(createAudioFile(context), "w")
myMediaRecorder.apply {
reset()
setAudioSource(MediaRecorder.AudioSource.MIC)
setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP)
setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB)
setOutputFile(fileDescriptor?.fileDescriptor)
try {
prepare()
start()
} catch (e: IOException) {
Log.e("LinLi", "startRecording error! ",e )
}
}
}
@RequiresApi(Build.VERSION_CODES.S)
override fun stopRecording() {
myMediaRecorder.apply {
stop()
reset()
}
fileDescriptor?.close()
fileDescriptor = null
}
@RequiresApi(Build.VERSION_CODES.S)
override fun startPlaying() {
try {
mediaPlayer.apply {
reset()
uri?.let {
setDataSource(context, it)
prepare()
start()
}
}
} catch (e: IOException) {
Log.e("LinLi", "startPlaying error! ",e )
}
}
@RequiresApi(Build.VERSION_CODES.S)
override fun cancelRecording() {
myMediaRecorder.reset()
fileDescriptor?.close()
fileDescriptor = null
}
private fun createAudioFile(context: Context): Uri {
val contentValues = ContentValues().apply {
put(MediaStore.MediaColumns.DISPLAY_NAME, "錄音_${System.currentTimeMillis()}.3gp")
put(MediaStore.MediaColumns.MIME_TYPE, "audio/3gpp")
put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_MUSIC)
}
uri = context.contentResolver.insert(
MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
contentValues
)!!
return uri as Uri
}
} | RecordingTest/app/src/main/java/com/example/myapplication/MyMediaRecorderImpl.kt | 3082562056 |
package com.ivanbarbosa.polygoncraft
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.ivanbarbosa.polygoncraft", appContext.packageName)
}
} | PolygonCraft/app/src/androidTest/java/com/ivanbarbosa/polygoncraft/ExampleInstrumentedTest.kt | 1541440866 |
package com.ivanbarbosa.polygoncraft.home
import androidx.arch.core.executor.testing.InstantTaskExecutorRule
import androidx.lifecycle.Observer
import com.ivanbarbosa.polygoncraft.R
import com.ivanbarbosa.polygoncraft.data.PolygonRepository
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
import com.ivanbarbosa.polygoncraft.desing.FakeDataDesign
import com.ivanbarbosa.polygoncraft.ui.home.HomeViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.TestScope
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.setMain
import org.junit.After
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.Mockito.verify
import org.mockito.Mockito.`when`
import org.mockito.MockitoAnnotations
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.home
* Create by Ivan Barbosa on 8/02/2024 at 3:47 a.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
@ExperimentalCoroutinesApi
class HomeViewModelTest {
@get:Rule
val instantTaskExecutorRule = InstantTaskExecutorRule()
private val testDispatcher = UnconfinedTestDispatcher()
private val testScope = TestScope(testDispatcher)
@Mock
private lateinit var repository: PolygonRepository
@Mock
private lateinit var observer: Observer<List<Polygon>>
@Mock
private lateinit var snackbarObserver: Observer<Int>
@Mock
private lateinit var selectedPolygonObserver: Observer<Polygon?>
private lateinit var viewModel: HomeViewModel
@Before
fun setup() {
MockitoAnnotations.openMocks(this)
Dispatchers.setMain(testDispatcher)
viewModel = HomeViewModel(repository)
requireNotNull(viewModel.getResult().hasObservers())
requireNotNull(viewModel.getSnackbarMsg().hasObservers())
requireNotNull(viewModel.getSelectedPolygon().hasObservers())
viewModel.getResult().observeForever(observer)
viewModel.getSnackbarMsg().observeForever(snackbarObserver)
viewModel.getSelectedPolygon().observeForever(selectedPolygonObserver)
}
@After
fun tearDown() {
Dispatchers.resetMain()
}
@Test
fun `test getPolygons success`() = testScope.runTest {
val fakePolygons = FakeDataHome.generateFakePolygonsList(5)
`when`(repository.getPolygons()).thenReturn(fakePolygons)
viewModel.getPolygons()
verify(observer).onChanged(fakePolygons)
verify(snackbarObserver, Mockito.never()).onChanged(Mockito.anyInt())
}
@Test
fun `test getPolygons empty result`() {
testScope.runTest {
`when`(repository.getPolygons()).thenReturn(emptyList())
viewModel.getPolygons()
verify(observer).onChanged(emptyList<Polygon>())
verify(snackbarObserver).onChanged(R.string.main_error_empty_polygons)
}
}
@Test
fun `test getPolygons error`() {
testScope.runTest {
`when`(repository.getPolygons()).thenThrow(RuntimeException("Test exception"))
viewModel.getPolygons()
verify(snackbarObserver).onChanged(R.string.error_server)
}
}
@Test
fun `test getPolygonByName success`() {
testScope.runTest {
val fakePolygon = FakeDataDesign.generateFakePolygons()
val polygonName = "TestPolygon"
`when`(repository.getPolygonByName(polygonName)).thenReturn(fakePolygon)
viewModel.getPolygonByName(polygonName)
verify(selectedPolygonObserver).onChanged(fakePolygon)
}
}
@Test
fun `test getPolygonByName failure`() {
testScope.runTest {
val polygonName = "NonexistentPolygon"
`when`(repository.getPolygonByName(polygonName)).thenReturn(null)
viewModel.getPolygonByName(polygonName)
verify(selectedPolygonObserver).onChanged(null)
}
}
}
| PolygonCraft/app/src/test/java/com/ivanbarbosa/polygoncraft/home/HomeViewModelTest.kt | 3304469959 |
package com.ivanbarbosa.polygoncraft.home
import com.ivanbarbosa.polygoncraft.data.entities.Point
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.home
* Create by Ivan Barbosa on 8/02/2024 at 3:51 a.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
object FakeDataHome {
fun generateFakePolygonsList(size: Int): List<Polygon> {
val fakePolygons = mutableListOf<Polygon>()
repeat(size) { index ->
val fakeName = "Polygon $index"
val fakePoints = generateFakePointsList((Math.random() * 15).toInt())
fakePolygons.add(Polygon(fakeName, fakePoints.toMutableList()))
}
return fakePolygons
}
private fun generateFakePointsList(size: Int): List<Point> {
val fakePoints = mutableListOf<Point>()
repeat(size) {
val fakeX = Math.random() * 2
val fakeY = Math.random() * 2
fakePoints.add(Point(fakeX, fakeY))
}
return fakePoints
}
} | PolygonCraft/app/src/test/java/com/ivanbarbosa/polygoncraft/home/FakeDataHome.kt | 2556046195 |
package com.ivanbarbosa.polygoncraft.desing
import androidx.arch.core.executor.testing.InstantTaskExecutorRule
import androidx.lifecycle.Observer
import com.ivanbarbosa.polygoncraft.data.PolygonRepository
import com.ivanbarbosa.polygoncraft.ui.desing.DesignViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.TestScope
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.setMain
import org.junit.After
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.Mockito.verify
import org.mockito.MockitoAnnotations
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.desing
* Create by Ivan Barbosa on 8/02/2024 at 8:12 a. m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
@ExperimentalCoroutinesApi
class DesignViewModelTest {
@get:Rule
val instantTaskExecutorRule = InstantTaskExecutorRule()
private val testDispatcher = UnconfinedTestDispatcher()
private val testScope = TestScope(testDispatcher)
@Mock
private lateinit var repository: PolygonRepository
@Mock
private lateinit var observer: Observer<Boolean>
private lateinit var viewModel: DesignViewModel
@Before
fun setup() {
MockitoAnnotations.openMocks(this)
Dispatchers.setMain(testDispatcher)
viewModel = DesignViewModel(repository)
viewModel.polygonSaved.observeForever(observer)
}
@After
fun tearDown() {
Dispatchers.resetMain()
}
@Test
fun `test savePolygon success`() = testScope.runTest {
val fakePolygon = FakeDataDesign.generateFakePolygons()
Mockito.`when`(repository.savePolygonWithPoints(fakePolygon)).thenReturn(true)
viewModel.savePolygon(fakePolygon)
verify(repository).savePolygonWithPoints(fakePolygon)
verify(observer).onChanged(true)
}
@Test
fun `test savePolygon failure`() = testScope.runTest {
val fakePolygon = FakeDataDesign.generateFakePolygons()
val errorMessage = "Test exception"
Mockito.`when`(repository.savePolygonWithPoints(fakePolygon))
.thenThrow(RuntimeException(errorMessage))
viewModel.savePolygon(fakePolygon)
verify(observer).onChanged(false)
}
}
| PolygonCraft/app/src/test/java/com/ivanbarbosa/polygoncraft/desing/DesignViewModelTest.kt | 3008957571 |
package com.ivanbarbosa.polygoncraft.desing
import com.ivanbarbosa.polygoncraft.data.entities.Point
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.desing
* Create by Ivan Barbosa on 8/02/2024 at 8:15 a. m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
object FakeDataDesign {
fun generateFakePolygons(): Polygon {
val fakeName = "Polygon66"
val fakePoints = generateFakePointsList((Math.random() * 15).toInt())
return Polygon(fakeName, fakePoints.toMutableList())
}
private fun generateFakePointsList(size: Int): List<Point> {
val fakePoints = mutableListOf<Point>()
repeat(size) {
val fakeX = Math.random() * 2
val fakeY = Math.random() * 2
fakePoints.add(Point(fakeX, fakeY))
}
return fakePoints
}
} | PolygonCraft/app/src/test/java/com/ivanbarbosa/polygoncraft/desing/FakeDataDesign.kt | 2675529960 |
package com.ivanbarbosa.polygoncraft.ui.home
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.ivanbarbosa.polygoncraft.R
import com.ivanbarbosa.polygoncraft.data.PolygonRepository
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import javax.inject.Inject
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.ui.home
* Create by Ivan Barbosa on 6/02/2024 at 12:17 p.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
@HiltViewModel
class HomeViewModel @Inject constructor(private val repository: PolygonRepository) : ViewModel() {
private val result = MutableLiveData<List<Polygon>>()
private val snackbarMsg = MutableLiveData<Int>()
private val loaded = MutableLiveData<Boolean>()
private val selectedPolygon = MutableLiveData<Polygon?>()
fun getResult(): LiveData<List<Polygon>> = result
fun getSnackbarMsg(): LiveData<Int> = snackbarMsg
fun isLoaded(): LiveData<Boolean> = loaded
fun getSelectedPolygon(): LiveData<Polygon?> = selectedPolygon
fun getPolygons() {
viewModelScope.launch {
try {
loaded.value = false
val result = repository.getPolygons()
[email protected] = result
if (result.isEmpty()) {
snackbarMsg.value = R.string.main_error_empty_polygons
}
} catch (e: Exception) {
snackbarMsg.value = R.string.error_server
} finally {
loaded.value = true
}
}
}
fun getPolygonByName(name: String) {
viewModelScope.launch {
try {
val result = repository.getPolygonByName(name)
selectedPolygon.value = result
} catch (e: Exception) {
e.printStackTrace()
}
}
}
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/ui/home/HomeViewModel.kt | 268573487 |
package com.ivanbarbosa.polygoncraft.ui.home
import android.content.Intent
import android.os.Bundle
import android.text.InputType
import android.view.View
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.recyclerview.widget.GridLayoutManager
import com.google.android.material.snackbar.Snackbar
import com.ivanbarbosa.polygoncraft.R
import com.ivanbarbosa.polygoncraft.data.entities.Point
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
import com.ivanbarbosa.polygoncraft.databinding.ActivityHomeBinding
import com.ivanbarbosa.polygoncraft.ui.desing.DesignActivity
import com.ivanbarbosa.polygoncraft.ui.dialogs.PolygonDialog
import com.ivanbarbosa.polygoncraft.ui.home.adapters.HomeAdapter
import com.ivanbarbosa.polygoncraft.ui.home.adapters.onClickListeners.OnClickListenerHome
import com.ivanbarbosa.polygoncraft.utils.Constants
import com.ivanbarbosa.polygoncraft.utils.Scale
import com.ivanbarbosa.polygoncraft.utils.SharedPreferencesManager.getName
import com.ivanbarbosa.polygoncraft.utils.SharedPreferencesManager.removeName
import com.ivanbarbosa.polygoncraft.utils.calculateCoordinates
import com.ivanbarbosa.polygoncraft.utils.getStringArray
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class HomeActivity : AppCompatActivity(), OnClickListenerHome, PolygonDialog.DialogCallback {
private lateinit var binding: ActivityHomeBinding
private lateinit var homeAdapter: HomeAdapter
private lateinit var gridLayout: GridLayoutManager
private val viewModel: HomeViewModel by viewModels()
private lateinit var polygon: Polygon
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityHomeBinding.inflate(layoutInflater)
setContentView(binding.root)
setUpRecycler()
setUpViewModel()
setUpButton()
upSharedPreferences()
}
override fun onStart() {
super.onStart()
requestArtist()
}
private fun setUpRecycler() {
homeAdapter = HomeAdapter(mutableListOf(), this@HomeActivity)
gridLayout = GridLayoutManager(this, 1)
binding.recyclerHome.apply {
setHasFixedSize(true)
layoutManager = gridLayout
adapter = [email protected]
}
}
private fun setUpViewModel() {
viewModel.getResult().observe(this) { polygon ->
homeAdapter.addPolygons(polygon)
binding.progressbar.visibility = View.VISIBLE
}
viewModel.isLoaded().observe(this) { isLoaded ->
binding.progressbar.visibility = if (!isLoaded) View.VISIBLE else View.GONE
}
viewModel.getSnackbarMsg().observe(this) { msgErr ->
Snackbar.make(binding.root, msgErr, Snackbar.LENGTH_LONG).show()
}
}
private fun setUpButton() {
binding.btnCreatePolygon.setOnClickListener {
showDialog(
true,
InputType.TYPE_CLASS_NUMBER,
getString(R.string.title_dialog_create_polygon),
getString(R.string.hint_et_sides)
)
}
}
private fun upSharedPreferences() {
if (!getName(applicationContext).isNullOrEmpty()) {
setUpObserverByName()
viewModel.getPolygonByName(getName(applicationContext)!!)
}
}
private fun requestArtist() {
viewModel.getPolygons()
}
private fun showDialog(
requiredEditText: Boolean,
inputType: Int?,
title: String,
hintEditText: String?
) {
val dialog = PolygonDialog(
context = this,
requiredEditText = requiredEditText,
requiredSpinner = true,
title = title,
inputType = inputType,
hintEditText = hintEditText,
descriptionSpinner = getString(R.string.description_sniper_create_polygon),
optionsSpinner = getStringArray(R.array.scale_options)
)
dialog.showDialog(this)
}
private fun setUpObserverByName() {
viewModel.getSelectedPolygon().observe(this) {
if (it != null) {
removeName(applicationContext)
startDesignActivity(it)
}
}
}
private fun startDesignActivity(polygon: Polygon) {
val intent = Intent(this, DesignActivity::class.java)
intent.putExtra(Constants.OBJECT_POLYGON, polygon)
startActivity(intent)
}
override fun onPositiveButtonClick(contentEditText: String?, selectedScale: String) {
if (contentEditText == null) {
val scale = Scale.valueOf(selectedScale).value
startDesignActivity(Polygon(polygon.name, polygon.points, scale))
} else if (contentEditText.isEmpty() || contentEditText.toInt() <= 2) {
Snackbar.make(
binding.root,
getString(R.string.message_invalid_number_of_sides), Snackbar.LENGTH_SHORT
).show()
} else {
val scale = Scale.valueOf(selectedScale).value
val pointsList = mutableListOf<Point>()
pointsList.calculateCoordinates(contentEditText.toInt())
startDesignActivity(Polygon("", pointsList, scale))
}
}
override fun onCancelButtonClick() {
// Negative Button
}
override fun onClick(polygon: Polygon) {
this.polygon = polygon
showDialog(
false,
null,
getString(R.string.title_selected_scale),
null
)
}
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/ui/home/HomeActivity.kt | 2016193927 |
package com.ivanbarbosa.polygoncraft.ui.home.adapters.onClickListeners
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.ui.home.adapters.onClickListeners
* Create by Ivan Barbosa on 5/02/2024 at 7:29 p.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
fun interface OnClickListenerHome {
fun onClick(polygon: Polygon)
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/ui/home/adapters/onClickListeners/OnClickListenerHome.kt | 3598821501 |
package com.ivanbarbosa.polygoncraft.ui.home.adapters
import android.content.Context
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import com.ivanbarbosa.polygoncraft.R
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
import com.ivanbarbosa.polygoncraft.databinding.ItemPolygonBinding
import com.ivanbarbosa.polygoncraft.ui.home.adapters.onClickListeners.OnClickListenerHome
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.ui.home.adapters
* Create by Ivan Barbosa on 5/02/2024 at 7:24 p.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
class HomeAdapter(
private var polygons: MutableList<Polygon>,
private val listener: OnClickListenerHome
) : RecyclerView.Adapter<HomeAdapter.ViewHolder>() {
constructor(
context: Context,
polygons: MutableList<Polygon>,
listener: OnClickListenerHome
) : this(polygons, listener) {
this.context = context
}
private lateinit var context: Context
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
return ViewHolder(
LayoutInflater.from(parent.context).inflate(R.layout.item_polygon, parent, false)
)
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
val polygon = polygons[position]
holder.bind(polygon)
}
override fun getItemCount(): Int = polygons.size
fun addPolygons(newPolygons: List<Polygon>) {
val startingPosition = this.polygons.size
this.polygons = newPolygons.toMutableList()
notifyItemRangeInserted(startingPosition, newPolygons.size)
}
fun updatePolygon(updatedPolygon: Polygon) {
val position = this.polygons.indexOf(updatedPolygon)
this.polygons[position] = updatedPolygon
notifyItemChanged(position)
}
inner class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
private val binding = ItemPolygonBinding.bind(view)
fun bind(polygon: Polygon) {
binding.namePolygon.text = polygon.name
binding.descriptionPolygon.text = polygon.points.size.toString()
binding.root.setOnClickListener { listener.onClick(polygon) }
}
}
}
| PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/ui/home/adapters/HomeAdapter.kt | 866241928 |
package com.ivanbarbosa.polygoncraft.ui.desing
import android.os.Build
import android.os.Bundle
import android.text.InputType
import android.widget.Toast
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import com.google.android.material.floatingactionbutton.FloatingActionButton
import com.google.android.material.snackbar.Snackbar
import com.ivanbarbosa.polygoncraft.R
import com.ivanbarbosa.polygoncraft.data.entities.Point
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
import com.ivanbarbosa.polygoncraft.databinding.ActivityDesingBinding
import com.ivanbarbosa.polygoncraft.ui.desing.canvas.CanvasDrawPolygon
import com.ivanbarbosa.polygoncraft.ui.dialogs.PolygonDialog
import com.ivanbarbosa.polygoncraft.utils.Constants
import com.ivanbarbosa.polygoncraft.utils.SharedPreferencesManager.removeName
import com.ivanbarbosa.polygoncraft.utils.SharedPreferencesManager.saveName
import com.ivanbarbosa.polygoncraft.utils.calculateScalePoint
import com.ivanbarbosa.polygoncraft.utils.investScalePoint
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class DesignActivity : AppCompatActivity(), PolygonDialog.DialogCallback {
private lateinit var binding: ActivityDesingBinding
private lateinit var canvasView: CanvasDrawPolygon
private val viewModel: DesignViewModel by viewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityDesingBinding.inflate(layoutInflater)
setContentView(binding.root)
canvasView = binding.canvasView
init()
setUpButton()
}
private fun init() {
val polygon = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
intent.getParcelableExtra(Constants.OBJECT_POLYGON, Polygon::class.java)
} else {
intent.getParcelableExtra(Constants.OBJECT_POLYGON)
}
if (polygon != null) {
val pointsList = mutableListOf<Point>()
pointsList.calculateScalePoint(polygon.points, polygon.scale)
drawPolygon(Polygon(polygon.name, pointsList, polygon.scale))
}
}
private fun setUpButton() {
val fabSave: FloatingActionButton = binding.fabSave
fabSave.setOnClickListener {
showDialog()
}
}
private fun setUpObserver() {
viewModel.polygonSaved.observe(this) { saved ->
if (saved) {
Toast.makeText(
this,
getString(R.string.message_saved_polygon),
Toast.LENGTH_SHORT
).show()
finish()
} else {
showSnackbar(getString(R.string.message_error_saving_polygon))
removeName(applicationContext)
}
}
}
private fun showDialog() {
val dialog = PolygonDialog(
context = this,
requiredEditText = true,
requiredSpinner = false,
title = getString(R.string.save_polygon),
inputType = InputType.TYPE_CLASS_TEXT,
hintEditText = getString(R.string.text_polygon_name),
descriptionSpinner = null,
optionsSpinner = null
)
dialog.showDialog(this)
}
private fun drawPolygon(polygon: Polygon) {
canvasView.drawPolygon(polygon)
}
override fun onPositiveButtonClick(contentEditText: String?, selectedScale: String) {
if (contentEditText.isNullOrEmpty()) {
showSnackbar(getString(R.string.message_name_polygon_empty))
return
}
val polygon = canvasView.getPolygon()
val pointsList = mutableListOf<Point>()
if (polygon != null) {
pointsList.investScalePoint(polygon.points, polygon.scale)
viewModel.savePolygon(Polygon(contentEditText, pointsList, polygon.scale))
setUpObserver()
removeName(applicationContext)
saveName(applicationContext, contentEditText)
} else {
showSnackbar(getString(R.string.message_polygon_empty))
}
}
override fun onCancelButtonClick() {
// NegativeButton
}
private fun showSnackbar(message: String) {
Snackbar.make(binding.root, message, Snackbar.LENGTH_SHORT).show()
}
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/ui/desing/DesignActivity.kt | 2291719122 |
package com.ivanbarbosa.polygoncraft.ui.desing.canvas
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.Paint
import com.ivanbarbosa.polygoncraft.data.entities.Point
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
import com.ivanbarbosa.polygoncraft.utils.CanvasUtils
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.utils
* Create by Ivan Barbosa on 7/02/2024 at 5:49 p. m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
class CanvasPainter(private val canvasUtils: CanvasUtils) {
private val paintCircle = Paint().apply {
color = Color.RED
strokeWidth = 5f
style = Paint.Style.STROKE
isAntiAlias = true
}
private val paintGrid = Paint().apply {
color = Color.GRAY
strokeWidth = 2f
}
private val paintLine = Paint().apply {
color = Color.BLUE
strokeWidth = 5f
style = Paint.Style.STROKE
isAntiAlias = true
}
private val scaleInY: Float
get() = canvasUtils.scaleInY()
private val scaleInX: Float
get() = canvasUtils.scaleInX()
fun drawPolygon(polygon: Polygon, canvas: Canvas) {
val points = polygon.points
points.forEachIndexed { index, point ->
val adjustedX = point.x * canvas.width * scaleInX
val adjustedY = canvas.height - (point.y * canvas.height * scaleInY)
if (index < points.size - 1) {
drawLineBetweenPoints(point, points[index + 1], canvas)
} else if (index == points.size - 1 && points.size > 1) {
drawLineBetweenPoints(point, points[0], canvas)
}
drawCircleAtPoint(adjustedX.toFloat(), adjustedY.toFloat(), canvas)
}
}
private fun drawLineBetweenPoints(start: Point, end: Point, canvas: Canvas) {
val adjustedStartX = start.x * canvas.width * scaleInX
val adjustedStartY = canvas.height - (start.y * canvas.height * scaleInY)
val adjustedEndX = end.x * canvas.width * scaleInX
val adjustedEndY = canvas.height - (end.y * canvas.height * scaleInY)
canvas.drawLine(
adjustedStartX.toFloat(), adjustedStartY.toFloat(),
adjustedEndX.toFloat(), adjustedEndY.toFloat(),
paintLine
)
}
private fun drawCircleAtPoint(x: Float, y: Float, canvas: Canvas) {
canvas.drawCircle(x, y, 50f, paintCircle)
}
fun drawGrid(canvas: Canvas) {
val cellSize = 54
val width = canvas.width
val height = canvas.height
for (i in 0..height step cellSize) {
canvas.drawLine(0f, i.toFloat(), width.toFloat(), i.toFloat(), paintGrid)
}
for (i in 0..width step cellSize) {
canvas.drawLine(i.toFloat(), 0f, i.toFloat(), height.toFloat(), paintGrid)
}
}
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/ui/desing/canvas/CanvasPainter.kt | 1367895237 |
package com.ivanbarbosa.polygoncraft.ui.desing.canvas
import android.content.Context
import android.graphics.Canvas
import android.util.AttributeSet
import android.view.MotionEvent
import android.view.View
import com.ivanbarbosa.polygoncraft.data.entities.Point
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
import com.ivanbarbosa.polygoncraft.utils.CanvasUtils
import kotlin.math.pow
import kotlin.math.sqrt
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.ui.desing
* Create by Ivan Barbosa on 7/02/2024 at 2:35 p.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
class CanvasDrawPolygon(context: Context, attrs: AttributeSet) : View(context, attrs) {
private var polygon: Polygon? = null
private val canvasUtils = CanvasUtils(context)
private val painter = CanvasPainter(canvasUtils)
private var movingCircleIndex: Int = -1
private var lastTouchX: Float = 0f
private var lastTouchY: Float = 0f
private val touchTolerance = 60f
private val scaleInY: Float
get() = canvasUtils.scaleInY()
private val scaleInX: Float
get() = canvasUtils.scaleInX()
override fun onDraw(canvas: Canvas) {
super.onDraw(canvas)
painter.drawGrid(canvas)
polygon?.let { painter.drawPolygon(it, canvas) }
}
override fun onTouchEvent(event: MotionEvent): Boolean {
val x = event.x
val y = event.y
when (event.action) {
MotionEvent.ACTION_DOWN -> handleTouchDown(x, y)
MotionEvent.ACTION_MOVE -> handleTouchMove(x, y)
MotionEvent.ACTION_UP -> handleTouchUp()
}
return true
}
private fun handleTouchDown(x: Float, y: Float) {
polygon?.let { polygon ->
for ((index, point) in polygon.points.withIndex()) {
val adjustedX = point.x * width * scaleInX
val adjustedY = height - (point.y * height) * scaleInY
val distance = calculateDistance(x, y, adjustedX.toFloat(), adjustedY.toFloat())
if (distance < touchTolerance) {
movingCircleIndex = index
lastTouchX = x
lastTouchY = y
invalidate()
break
}
}
}
}
private fun handleTouchMove(x: Float, y: Float) {
if (movingCircleIndex != -1) {
val deltaX = x - lastTouchX
val deltaY = y - lastTouchY
polygon?.let { polygon ->
val movedPoint = polygon.points[movingCircleIndex]
val newX = movedPoint.x + deltaX / width
val newY = movedPoint.y - deltaY / height
polygon.points[movingCircleIndex] = Point(newX, newY)
lastTouchX = x
lastTouchY = y
invalidate()
}
}
}
private fun handleTouchUp() {
movingCircleIndex = -1
}
private fun calculateDistance(x1: Float, y1: Float, x2: Float, y2: Float): Double {
return sqrt((x1 - x2).pow(2).toDouble() + (y1 - y2).pow(2))
}
fun drawPolygon(polygon: Polygon) {
this.polygon = polygon
invalidate()
}
fun getPolygon(): Polygon? {
return polygon
}
}
| PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/ui/desing/canvas/CanvasDrawPolygon.kt | 2127288487 |
package com.ivanbarbosa.polygoncraft.ui.desing
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.ivanbarbosa.polygoncraft.data.PolygonRepository
import com.ivanbarbosa.polygoncraft.data.entities.Polygon
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import javax.inject.Inject
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.ui.desing
* Create by Ivan Barbosa on 8/02/2024 at 1:47 a.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
@HiltViewModel
class DesignViewModel @Inject constructor(private val repository: PolygonRepository) : ViewModel() {
private val resultPolygonSaved = MutableLiveData<Boolean>()
val polygonSaved: LiveData<Boolean> get() = resultPolygonSaved
fun savePolygon(polygon: Polygon) {
viewModelScope.launch {
try {
val result = repository.savePolygonWithPoints(polygon)
resultPolygonSaved.value = result
} catch (e: Exception) {
resultPolygonSaved.value = false
}
}
}
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/ui/desing/DesignViewModel.kt | 154245256 |
package com.ivanbarbosa.polygoncraft.ui.dialogs
import android.content.Context
import android.view.LayoutInflater
import android.view.View
import android.widget.ArrayAdapter
import androidx.appcompat.app.AlertDialog
import androidx.core.view.isVisible
import com.ivanbarbosa.polygoncraft.databinding.DialogPolygonLayoutBinding
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.ui.home
* Create by Ivan Barbosa on 7/02/2024 at 11:32 a.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
class PolygonDialog(
private val context: Context,
private val requiredEditText: Boolean,
private val requiredSpinner: Boolean,
private val title: String,
private val inputType: Int?,
private val hintEditText: String?,
private val descriptionSpinner: String?,
private val optionsSpinner: Array<String>?
) {
interface DialogCallback {
fun onPositiveButtonClick(contentEditText: String?, selectedScale: String)
fun onCancelButtonClick()
}
fun showDialog(callback: DialogCallback) {
val binding = DialogPolygonLayoutBinding.inflate(LayoutInflater.from(context))
binding.title.text = title
if (inputType != null) {
binding.etContent.inputType = inputType
}
binding.etContent.hint = hintEditText
binding.tvSpinnerDescription.text = descriptionSpinner
if (!requiredEditText) binding.etContent.visibility = View.GONE
if (!requiredSpinner) {
binding.spinnerScale.visibility = View.GONE
binding.tvSpinnerDescription.visibility = View.GONE
} else {
val adapter =
ArrayAdapter(context, android.R.layout.simple_spinner_item, optionsSpinner!!)
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
binding.spinnerScale.adapter = adapter
}
val alertDialogBuilder = AlertDialog.Builder(context)
alertDialogBuilder.setView(binding.root)
val alertDialog = alertDialogBuilder.create()
binding.btnPositive.setOnClickListener {
val sides = if (binding.etContent.isVisible) binding.etContent.text.toString() else null
val selectedScale =
if (binding.spinnerScale.isVisible) binding.spinnerScale.selectedItem.toString() else ""
callback.onPositiveButtonClick(sides, selectedScale)
alertDialog.dismiss()
}
binding.btnNegative.setOnClickListener {
callback.onCancelButtonClick()
alertDialog.dismiss()
}
alertDialog.show()
}
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/ui/dialogs/PolygonDialog.kt | 2238594490 |
package com.ivanbarbosa.polygoncraft
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft
* Create by Ivan Barbosa on 5/02/2024 at 4:21 p.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
@HiltAndroidApp
class PolygonApplication:Application() | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/PolygonApplication.kt | 1988782805 |
package com.ivanbarbosa.polygoncraft.utils
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.utils
* Create by Ivan Barbosa on 11/02/2024 at 6:24 p. m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
enum class Scale(val value: Double) {
x1(0.73),
x2(1.48),
x3(2.22)
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/utils/Scale.kt | 2516586490 |
package com.ivanbarbosa.polygoncraft.utils
import android.content.Context
import androidx.annotation.ArrayRes
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.utils
* Create by Ivan Barbosa on 11/02/2024 at 3:59 p.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
fun Context.getStringArray(@ArrayRes resourceId: Int): Array<String> {
return resources.getStringArray(resourceId)
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/utils/ExtensionsResource.kt | 3854770026 |
package com.ivanbarbosa.polygoncraft.utils
import com.ivanbarbosa.polygoncraft.data.entities.Point
import kotlin.math.cos
import kotlin.math.sin
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.utils
* Create by Ivan Barbosa on 7/02/2024 at 9:05 p.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
fun MutableList<Point>.calculateCoordinates(
sides: Int,
displacement: Double = 0.45
) {
val initialAngle = 0.0
val angleStep = 360.0 / sides
for (i in 0 until sides) {
val angle = initialAngle + i * angleStep
val x = (cos(Math.toRadians(angle)) * displacement) + displacement
val y = (sin(Math.toRadians(angle)) * displacement) + displacement
this.add(Point(x, y))
}
}
fun MutableList<Point>.calculateScalePoint(point: List<Point>, scale: Double) {
point.forEach {
val x = (it.x * scale)
val y = (it.y * scale)
this.add(Point(x, y))
}
}
fun MutableList<Point>.investScalePoint(point: List<Point>, scale: Double) {
point.forEach {
val x = (it.x / scale)
val y = (it.y / scale)
this.add(Point(x, y))
}
}
| PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/utils/ExtencionsPoint.kt | 3597362054 |
package com.ivanbarbosa.polygoncraft.utils
import android.content.Context
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.utils
* Create by Ivan Barbosa on 8/02/2024 at 8:25 a. m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
object SharedPreferencesManager {
private const val PREF_NAME = "polygons_prefs"
private const val KEY_NAME = "name"
fun saveName(context: Context, name: String?) {
val preferences = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
val editor = preferences.edit()
editor.putString(KEY_NAME, name)
editor.apply()
}
fun getName(context: Context): String? {
val preferences = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
return preferences.getString(KEY_NAME, "")
}
fun removeName(context: Context) {
val preferences = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
val editor = preferences.edit()
editor.remove(KEY_NAME)
editor.apply()
}
}
| PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/utils/SharedPreferencesManager.kt | 685352742 |
package com.ivanbarbosa.polygoncraft.utils
import android.content.Context
/*
* Project: PolygonCraft
* From: com.ivanbarbosa.polygoncraft.ui.desing
* Create by Ivan Barbosa on 7/02/2024 at 5:31 p.m.
* Linkedin: https://www.linkedin.com/in/ivanbarbosaortega/
*/
class CanvasUtils(private val context: Context) {
private val aspectRatio: Float
get() {
val width = context.resources.displayMetrics.widthPixels.toFloat()
val height = context.resources.displayMetrics.heightPixels.toFloat()
return width / height
}
fun scaleInY(): Float = if (aspectRatio >= 1.0f) 0.5f else 0.5f * aspectRatio
fun scaleInX(): Float = if (aspectRatio >= 1.0f) 0.5f / aspectRatio else 0.5f
} | PolygonCraft/app/src/main/java/com/ivanbarbosa/polygoncraft/utils/CanvasUtils.kt | 3589750079 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.