content
stringlengths 0
13M
| path
stringlengths 4
263
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.example.englishwordsapp.data.roomDatabase
import androidx.room.Dao
@Dao
interface DaoForRoom {
// @Insert
// fun insertWord(item: Entity)
//
// @Query("SELECT * FROM Table_for_words")
// fun getAllWords(): List<Entity>
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/roomDatabase/DaoForRoom.kt | 1253618808 |
package com.example.englishwordsapp.data.roomDatabase
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
@Database(
entities = [Entity::class],
version = 1
)
abstract class DataBase: RoomDatabase(){
abstract fun getDao(): DaoForRoom
companion object{
fun getDb(context: Context): DataBase {
return Room.databaseBuilder(
context.applicationContext,
DataBase::class.java,
"my.DB"
).build()
}
}
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/roomDatabase/DataBase.kt | 3778092818 |
package com.example.englishwordsapp.data.di
import com.example.englishwordsapp.data.datasource.QuizDatasource
import com.example.englishwordsapp.data.datasource.QuizFirebaseDatasource
import com.google.firebase.firestore.FirebaseFirestore
import com.google.firebase.firestore.ktx.firestore
import com.google.firebase.ktx.Firebase
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module
@InstallIn (SingletonComponent::class)
object FirebaseModule {
@Provides
fun provideFirestore(): FirebaseFirestore{
return Firebase.firestore
}
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/di/FirebaseModule.kt | 392582164 |
package com.example.englishwordsapp.data.di
import com.example.englishwordsapp.data.datasource.QuizDatasource
import com.example.englishwordsapp.data.datasource.QuizFirebaseDatasource
import com.google.firebase.firestore.FirebaseFirestore
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module
@InstallIn (SingletonComponent::class)
object DataSourceModule {
@Provides
fun provideQuizDatasource(firebaseFirestore: FirebaseFirestore): QuizDatasource{
return QuizFirebaseDatasource(firebaseFirestore)
}
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/di/DataSourceModule.kt | 1868777248 |
package com.example.englishwordsapp.data.di
import com.example.englishwordsapp.data.datasource.QuizDatasource
import com.example.englishwordsapp.data.repositories.QuizRepository
import com.example.englishwordsapp.data.repositories.QuizRepositoryImpl
import com.example.englishwordsapp.data.repositories.SentenceBuildRepository
import com.example.englishwordsapp.data.repositories.SentenceBuildRepositoryImpl
import com.example.englishwordsapp.data.repositories.SpeechRecognitionRepository
import com.example.englishwordsapp.data.repositories.SpeechRecognitionRepositoryImpl
import com.example.englishwordsapp.data.repositories.VocabularyRepository
import com.example.englishwordsapp.data.repositories.VocabularyRepositoryImpl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module
@InstallIn(SingletonComponent::class)
object RepositoryModule {
@Provides
fun provideQuizRepository(quizDatasource: QuizDatasource): QuizRepository{
return QuizRepositoryImpl(quizDatasource)
}
@Provides
fun provideSentenceBuildRepository(): SentenceBuildRepository{
return SentenceBuildRepositoryImpl()
}
@Provides
fun provideSpeechRecognitionRepository(): SpeechRecognitionRepository{
return SpeechRecognitionRepositoryImpl()
}
@Provides
fun provideVocabularyRepository(): VocabularyRepository{
return VocabularyRepositoryImpl()
}
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/di/RepositoryModule.kt | 2651887629 |
package com.example.englishwordsapp.data.repositories
import com.example.englishwordsapp.data.datasource.QuizDatasource
import com.example.englishwordsapp.data.model.QuizQuestionsResponse
import com.example.englishwordsapp.data.model.core.ResultWrapper
import com.example.englishwordsapp.ui.main.learn.quiz.QuizQuestionsModel
import com.google.android.gms.tasks.Tasks
import com.google.firebase.firestore.ktx.firestore
import com.google.firebase.ktx.Firebase
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
class QuizRepositoryImpl @Inject constructor(
private val quizDatasource: QuizDatasource
): QuizRepository {
override suspend fun getQuestionList(difficultyLevel: String) = flow<ResultWrapper<List<QuizQuestionsModel>>?> {
when(val result = quizDatasource.getQuestions(difficultyLevel)){
is ResultWrapper.Success ->{
val mappedList = result.data.map {
QuizQuestionsModel(
question = it.question.orEmpty(),
correctAnswer = it.correctAnswer.orEmpty(),
answers = it.answers.orEmpty()
)
}
emit(ResultWrapper.Success(mappedList))
}
is ResultWrapper.Error ->{
}
}
}
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/repositories/QuizRepositoryImpl.kt | 1128349902 |
package com.example.englishwordsapp.data.repositories
import com.example.englishwordsapp.data.model.core.ResultWrapper
import com.example.englishwordsapp.ui.main.learn.sentenceBuild.SentenceModel
import kotlinx.coroutines.flow.Flow
interface SentenceBuildRepository {
suspend fun getSentencesList(wordsLevel: String): Flow<ResultWrapper<List<SentenceModel>>?>
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/repositories/SentenceBuildRepository.kt | 2739720401 |
package com.example.englishwordsapp.data.repositories
import com.example.englishwordsapp.data.model.core.ResultWrapper
import com.example.englishwordsapp.data.model.SimpleWordsResponse
import com.example.englishwordsapp.ui.main.learn.SimpleWordsModel
import com.google.android.gms.tasks.Tasks
import com.google.firebase.firestore.ktx.firestore
import com.google.firebase.ktx.Firebase
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
class SpeechRecognitionRepositoryImpl @Inject constructor(): SpeechRecognitionRepository {
override suspend fun getWordsList(difficultyLevel: String) = flow<ResultWrapper<List<SimpleWordsModel>>?> {
val db = Firebase.firestore
val docRef =
db.collection("wordsForVocabulary")
.whereEqualTo("level", difficultyLevel)
val result = kotlin.runCatching {
Tasks.await(docRef.get())
}
val data = result.getOrNull()?.toObjects(SimpleWordsResponse::class.java)
val mappedList = data?.map {
SimpleWordsModel(
word = it.word.orEmpty(),
translationToAze = it.translationToAze.orEmpty(),
transcription = it.transcription.orEmpty(),
partOfSpeech = it.partOfSpeech.orEmpty(),
level = it.level.orEmpty()
)
}.orEmpty()
emit(ResultWrapper.Success(mappedList))
}
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/repositories/SpeechRecognitionRepositoryImpl.kt | 1306291168 |
package com.example.englishwordsapp.data.repositories
import com.example.englishwordsapp.data.model.SimpleWordsResponse
import com.example.englishwordsapp.data.model.core.ResultWrapper
import com.example.englishwordsapp.ui.main.learn.SimpleWordsModel
import com.google.android.gms.tasks.Tasks
import com.google.firebase.firestore.ktx.firestore
import com.google.firebase.ktx.Firebase
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
class VocabularyRepositoryImpl @Inject constructor(): VocabularyRepository {
override suspend fun getWordsList(difficultyLevel: String) = flow<ResultWrapper<List<SimpleWordsModel>>?> {
val db = Firebase.firestore
val docRef = db.collection("wordsForVocabulary")
val result = kotlin.runCatching {
Tasks.await(docRef.get())
}
val data = result.getOrNull()?.toObjects(SimpleWordsResponse::class.java)
val mappedList = data?.map {
SimpleWordsModel(
word = it.word.orEmpty(),
translationToAze = it.translationToAze.orEmpty(),
transcription = it.transcription.orEmpty(),
partOfSpeech = it.partOfSpeech.orEmpty(),
level = it.level.orEmpty()
)
}.orEmpty()
emit(ResultWrapper.Success(mappedList))
}
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/repositories/VocabularyRepositoryImpl.kt | 2545187791 |
package com.example.englishwordsapp.data.repositories
import com.example.englishwordsapp.data.model.core.ResultWrapper
import com.example.englishwordsapp.data.model.SentenceResponseModel
import com.example.englishwordsapp.ui.main.learn.sentenceBuild.SentenceModel
import com.google.android.gms.tasks.Tasks
import com.google.firebase.firestore.ktx.firestore
import com.google.firebase.ktx.Firebase
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
class SentenceBuildRepositoryImpl @Inject constructor(): SentenceBuildRepository {
override suspend fun getSentencesList(wordsLevel: String) = flow<ResultWrapper<List<SentenceModel>>?> {
val db = Firebase.firestore
val docRef =
db.collection("sentences")
.document(wordsLevel)
.collection("sentence_model")
val result = kotlin.runCatching {
Tasks.await(docRef.get())
}
val data = result.getOrNull()?.toObjects(SentenceResponseModel::class.java)
val mappedList = data?.map {
SentenceModel(
question = it.question.orEmpty(),
answerWordsList = it.answerWordsList.orEmpty()
)
}.orEmpty()
emit(ResultWrapper.Success(mappedList))
}
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/repositories/SentenceBuildRepositoryImpl.kt | 2972900417 |
package com.example.englishwordsapp.data.repositories
import com.example.englishwordsapp.data.model.core.ResultWrapper
import com.example.englishwordsapp.ui.main.learn.SimpleWordsModel
import kotlinx.coroutines.flow.Flow
interface VocabularyRepository {
suspend fun getWordsList(difficultyLevel: String): Flow<ResultWrapper<List<SimpleWordsModel>>?>
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/repositories/VocabularyRepository.kt | 3301435180 |
package com.example.englishwordsapp.data.repositories
import com.example.englishwordsapp.data.model.core.ResultWrapper
import com.example.englishwordsapp.ui.main.learn.SimpleWordsModel
import kotlinx.coroutines.flow.Flow
interface SpeechRecognitionRepository {
suspend fun getWordsList(difficultyLevel: String): Flow<ResultWrapper<List<SimpleWordsModel>>?>
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/repositories/SpeechRecognitionRepository.kt | 3591714356 |
package com.example.englishwordsapp.data.repositories
import com.example.englishwordsapp.data.model.core.ResultWrapper
import com.example.englishwordsapp.ui.main.learn.quiz.QuizQuestionsModel
import kotlinx.coroutines.flow.Flow
interface QuizRepository {
suspend fun getQuestionList(difficultyLevel: String): Flow<ResultWrapper<List<QuizQuestionsModel>>?>
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/repositories/QuizRepository.kt | 783533714 |
package com.example.englishwordsapp.data.model
class SimpleWordsResponse(
val word: String? = null,
val translationToAze: String? = null,
val transcription: String? = null,
val partOfSpeech: String? = null,
val level: String? = null,
) {
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/model/SimpleWordsResponse.kt | 2378376949 |
package com.example.englishwordsapp.data.model.core
sealed class ResultWrapper <out T> {
data class Success <T>(val data: T): ResultWrapper<T>()
data class Error (val error: String?): ResultWrapper<Nothing>()
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/model/core/ResultWrapper.kt | 1307639793 |
package com.example.englishwordsapp.data.model
class QuizQuestionsResponse(
val question: String? = null,
val correctAnswer: String? = null,
val answers: List<String>? = null,
) {
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/model/QuizQuestionsResponse.kt | 2999170477 |
package com.example.englishwordsapp.data.model
class SentenceResponseModel(
val question: String? = null,
val answerWordsList: List<String>? = null
) {
} | LearnEnglishApp_AZE/app/src/main/java/com/example/englishwordsapp/data/model/SentenceResponseModel.kt | 2513495280 |
package ir.mirdar.pexelmovieapp
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("ir.mirdar.pexelmovieapp", appContext.packageName)
}
} | PexelApp/app/src/androidTest/java/ir/mirdar/pexelmovieapp/ExampleInstrumentedTest.kt | 2219440176 |
package ir.mirdar.pexelmovieapp
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)
}
} | PexelApp/app/src/test/java/ir/mirdar/pexelmovieapp/ExampleUnitTest.kt | 1156386395 |
package ir.mirdar.pexelmovieapp.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import io.realm.kotlin.Realm
import io.realm.kotlin.RealmConfiguration
import ir.mirdar.pexelmovieapp.data.local.model.RealmSource
import ir.mirdar.pexelmovieapp.data.local.model.RealmPhoto
import ir.mirdar.pexelmovieapp.data.local.model.RealmCurated
import ir.mirdar.pexelmovieapp.data.remote.ApiService
import ir.mirdar.pexelmovieapp.data.remote.RequestInterceptor
import ir.mirdar.pexelmovieapp.presentation.common.Utils
import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object SingletonModule {
@Provides
@Singleton
fun provideRequestInterceptor(): Interceptor = RequestInterceptor()
@Provides
@Singleton
fun provideHttpLoggingInterceptor(): HttpLoggingInterceptor {
val httpLoggingInterceptor = HttpLoggingInterceptor()
httpLoggingInterceptor.level = HttpLoggingInterceptor.Level.BODY
return httpLoggingInterceptor
}
@Provides
@Singleton
fun provideOkHttpClient(
httpLoggingInterceptor: HttpLoggingInterceptor,
requestInterceptor: RequestInterceptor
): OkHttpClient =
OkHttpClient.Builder()
.addInterceptor(requestInterceptor)
.addInterceptor(httpLoggingInterceptor)
.build()
@Provides
@Singleton
fun provideRetrofitBuilder(okHttpClient: OkHttpClient): Retrofit =
Retrofit.Builder()
.baseUrl(Utils.BASE_URL)
.client(okHttpClient)
.addConverterFactory(GsonConverterFactory.create())
.build()
@Provides
@Singleton
fun provideApiService(retrofit: Retrofit) = retrofit.create(ApiService::class.java)
@Provides
@Singleton
fun provideRealmDatabase(): Realm {
val config = RealmConfiguration.create(
schema = setOf(
RealmCurated::class,
RealmPhoto::class,
RealmSource::class
)
)
return Realm.open(config)
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/di/SingletonModule.kt | 3736113975 |
package ir.mirdar.pexelmovieapp.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.components.ViewModelComponent
import dagger.hilt.android.scopes.ViewModelScoped
import io.realm.kotlin.Realm
import ir.mirdar.pexelmovieapp.data.local.LocalRepositoryImpl
import ir.mirdar.pexelmovieapp.data.remote.ApiService
import ir.mirdar.pexelmovieapp.data.remote.RemoteRepositoryImpl
import ir.mirdar.pexelmovieapp.domain.repositories.LocalRepository
import ir.mirdar.pexelmovieapp.domain.repositories.RemoteRepository
@Module
@InstallIn(ViewModelComponent::class)
object ViewModelModule {
@Provides
@ViewModelScoped
fun provideRemoteRepository(apiService: ApiService): RemoteRepository =
RemoteRepositoryImpl(apiService)
@Provides
@ViewModelScoped
fun provideLocalRepository(realm: Realm) : LocalRepository = LocalRepositoryImpl(realm)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/di/ViewModelModule.kt | 2322059311 |
package ir.mirdar.pexelmovieapp
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class PexelApplication : Application() {
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/PexelApplication.kt | 1813914904 |
package ir.mirdar.pexelmovieapp.data.local.model
import io.realm.kotlin.types.RealmObject
import io.realm.kotlin.types.annotations.PrimaryKey
import ir.mirdar.pexelmovieapp.domain.models.SourceModel
import org.mongodb.kbson.ObjectId
open class RealmSource : RealmObject {
@PrimaryKey
var id: ObjectId = ObjectId()
var original: String? = null
var large2x: String? = null
var medium: String? = null
var small: String? = null
var portrait: String? = null
var landscape: String? = null
var tiny: String? = null
}
fun RealmSource.toModel(): SourceModel = SourceModel(
original ?: "",
large2x ?: "",
medium ?: "",
small ?: "",
portrait ?: "",
landscape ?: "",
tiny ?: "",
) | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/local/model/RealmSource.kt | 220803828 |
package ir.mirdar.pexelmovieapp.data.local.model
import io.realm.kotlin.types.RealmObject
import io.realm.kotlin.types.annotations.PrimaryKey
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
import org.mongodb.kbson.ObjectId
open class RealmPhoto : RealmObject {
@PrimaryKey
var id: ObjectId = ObjectId()
var photoId: Long? = null
var width: Long? = null
var height: Long? = null
var url: String? = null
var photographer: String? = null
var photographer_url: String? = null
var photographer_id: Long? = null
var avg_color: String? = null
var alt: String? = null
var liked: Boolean? = null
var src: RealmSource? = null
}
fun RealmPhoto.toModel(): PhotoModel {
return PhotoModel(
photoId ?: 0,
width ?: 0,
height ?: 0,
url ?: "",
photographer ?: "",
photographer_url ?: "",
photographer_id ?: 0,
avg_color ?: "",
alt ?: "",
liked ?: false,
src?.toModel()!!,
)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/local/model/RealmPhoto.kt | 3269198986 |
package ir.mirdar.pexelmovieapp.data.local.model
import io.realm.kotlin.ext.realmListOf
import io.realm.kotlin.types.RealmList
import io.realm.kotlin.types.RealmObject
import io.realm.kotlin.types.annotations.PrimaryKey
import ir.mirdar.pexelmovieapp.domain.models.CuratedModel
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
import org.mongodb.kbson.ObjectId
open class RealmCurated: RealmObject {
@PrimaryKey
var id: ObjectId = ObjectId()
var page: Int? = null
var photos: RealmList<RealmPhoto> = realmListOf()
}
fun List<RealmPhoto>.toModel(): List<PhotoModel> = this.map { it.toModel() }
fun RealmCurated.toModel(): CuratedModel {
return CuratedModel(
page = page ?: 0,
photos = photos.toModel()
)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/local/model/RealmCurated.kt | 508755194 |
package ir.mirdar.pexelmovieapp.data.local
import io.realm.kotlin.Realm
import ir.mirdar.pexelmovieapp.data.local.model.RealmCurated
import ir.mirdar.pexelmovieapp.data.local.model.RealmPhoto
import ir.mirdar.pexelmovieapp.data.local.model.toModel
import ir.mirdar.pexelmovieapp.domain.models.CuratedModel
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
import ir.mirdar.pexelmovieapp.domain.models.toEntity
import ir.mirdar.pexelmovieapp.domain.repositories.LocalRepository
import javax.inject.Inject
class LocalRepositoryImpl @Inject constructor(
private val realm: Realm
) : LocalRepository {
override fun insertUpcomingModel(curatedModel: CuratedModel) {
realm.writeBlocking {
copyToRealm(curatedModel.toEntity())
}
}
override fun readImageDetail(photoId: Long) : PhotoModel? {
val realmPhoto = realm.query(RealmPhoto::class, "photoId == $photoId").first().find()
return realmPhoto?.toModel()
}
override fun readResultModels(page: Int) : CuratedModel? {
val realmUpcomingModel = realm.query(RealmCurated::class, "page == $page").first().find()
return realmUpcomingModel?.toModel()
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/local/LocalRepositoryImpl.kt | 3359271525 |
package ir.mirdar.pexelmovieapp.data.common
/**
* Created by Rim Gazzah on 8/28/20.
**/
sealed class Result<out T> {
data class Success<out T>(val data: T) : Result<T>()
data class Error(val exception: CallErrors) : Result<Nothing>()
data object Loading : Result<Nothing>()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/common/Result.kt | 3779868543 |
package ir.mirdar.pexelmovieapp.data.common
import ir.mirdar.pexelmovieapp.presentation.common.Utils
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.onStart
import kotlinx.coroutines.flow.retryWhen
import java.io.IOException
fun <T : Any> Flow<Result<T>>.applyCommonSideEffects() =
retryWhen { cause, attempt ->
when {
(cause is IOException && attempt < Utils.MAX_RETRIES) -> {
delay(Utils.getBackoffDelay(attempt))
true
}
else -> {
false
}
}
}.onStart {
emit(Result.Loading)
}.catch {
emit(Result.Error(CallErrors.ErrorException(it)))
}
| PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/common/NetworkExtensions.kt | 1324090807 |
package ir.mirdar.pexelmovieapp.data.common
/**
* Created by Rim Gazzah on 8/28/20.
**/
sealed class CallErrors {
data object ErrorEmptyData : CallErrors()
data object ErrorServer: CallErrors()
data class ErrorException(val throwable: Throwable) : CallErrors()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/common/CallErrors.kt | 649758870 |
package ir.mirdar.pexelmovieapp.data.remote
import ir.mirdar.pexelmovieapp.data.common.CallErrors
import ir.mirdar.pexelmovieapp.data.common.Result
import ir.mirdar.pexelmovieapp.data.common.applyCommonSideEffects
import ir.mirdar.pexelmovieapp.data.remote.model.toModel
import ir.mirdar.pexelmovieapp.domain.models.CuratedModel
import ir.mirdar.pexelmovieapp.domain.repositories.RemoteRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
class RemoteRepositoryImpl @Inject constructor (private val apiService: ApiService) :
RemoteRepository {
override fun getUpcomingList(page: Int): Flow<Result<CuratedModel>> = flow {
apiService.getUpcomingList(page).run {
if (this.isSuccessful) {
if (this.body() == null) {
emit(Result.Error(CallErrors.ErrorEmptyData))
} else {
emit(Result.Success(this.body()!!.toModel()))
}
} else {
emit(Result.Error(CallErrors.ErrorServer))
}
}
}.applyCommonSideEffects()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/remote/RemoteRepositoryImpl.kt | 1330888066 |
package ir.mirdar.pexelmovieapp.data.remote
import ir.mirdar.pexelmovieapp.presentation.common.Utils.API_KEY
import okhttp3.Interceptor
import okhttp3.Request
import okhttp3.Response
import javax.inject.Inject
class RequestInterceptor @Inject constructor() : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request()
val newRequest : Request
try {
newRequest = request.newBuilder()
.addHeader("Authorization", API_KEY)
.build()
} catch (e: Exception) {
e.printStackTrace()
return chain.proceed(request)
}
return chain.proceed(newRequest)
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/remote/RequestInterceptor.kt | 307827356 |
package ir.mirdar.pexelmovieapp.data.remote.model
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
data class Photo(
val id: Long,
val width: Long,
val height: Long,
val url: String,
val photographer: String,
val photographer_url: String,
val photographer_id: Long,
val avg_color: String,
val alt: String,
val liked: Boolean,
val src: Source
)
fun Photo.toModel(): PhotoModel {
return PhotoModel(
id,
width,
height,
url,
photographer,
photographer_url,
photographer_id,
avg_color,
alt,
liked,
src.toModel(),
)
}
| PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/remote/model/Photo.kt | 3255721043 |
package ir.mirdar.pexelmovieapp.data.remote.model
import ir.mirdar.pexelmovieapp.domain.models.SourceModel
data class Source(
val original: String,
val large2x: String,
val medium: String,
val small: String,
val portrait: String,
val landscape: String,
val tiny: String
)
fun Source.toModel(): SourceModel {
return SourceModel(
original,
large2x,
medium,
small,
portrait,
landscape,
tiny
)
}
| PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/remote/model/Source.kt | 4142219943 |
package ir.mirdar.pexelmovieapp.data.remote.model
import ir.mirdar.pexelmovieapp.domain.models.CuratedModel
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
data class Curated(
val page: Int,
val photos: List<Photo>,
)
fun List<Photo>.toModel(): List<PhotoModel> {
return this.map { it.toModel() }
}
fun Curated.toModel(): CuratedModel {
return CuratedModel(
page,
photos.toModel()
)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/remote/model/Curated.kt | 2609835645 |
package ir.mirdar.pexelmovieapp.data.remote
import ir.mirdar.pexelmovieapp.data.remote.model.Curated
import retrofit2.Response
import retrofit2.http.GET
import retrofit2.http.Query
interface ApiService {
@GET("curated")
suspend fun getUpcomingList(
@Query("page") page: Int
) : Response<Curated>
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/data/remote/ApiService.kt | 2554409350 |
package ir.mirdar.pexelmovieapp.domain
import ir.mirdar.pexelmovieapp.data.common.Result
import ir.mirdar.pexelmovieapp.domain.models.CuratedModel
import ir.mirdar.pexelmovieapp.domain.repositories.LocalRepository
import ir.mirdar.pexelmovieapp.domain.repositories.RemoteRepository
import ir.mirdar.pexelmovieapp.presentation.common.Utils
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.withContext
import javax.inject.Inject
class GetUpcomingList @Inject constructor(private val remoteRepository: RemoteRepository, private val localRepository: LocalRepository) {
suspend operator fun invoke(page: Int) = withContext(Dispatchers.IO) {
flow<Result<CuratedModel>> {
remoteRepository.getUpcomingList(page).collect { response ->
when (response) {
is Result.Success -> {
Utils.END_OF_PAGE = response.data.photos.isEmpty()
Utils.IS_LOADING = false
localRepository.insertUpcomingModel(response.data)
val localResult = localRepository.readResultModels(page)
localResult?.let {
emit(Result.Success(it))
}
}
is Result.Error -> {
val localResult = localRepository.readResultModels(page)
Utils.IS_LOADING = false
localResult?.let {
emit(Result.Success(it))
}
}
is Result.Loading -> {
Utils.IS_LOADING = true
}
}
}
}
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/domain/GetUpcomingList.kt | 2951093915 |
package ir.mirdar.pexelmovieapp.domain.repositories
import ir.mirdar.pexelmovieapp.data.common.Result
import ir.mirdar.pexelmovieapp.domain.models.CuratedModel
import kotlinx.coroutines.flow.Flow
interface RemoteRepository {
fun getUpcomingList(page : Int) : Flow<Result<CuratedModel>>
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/domain/repositories/RemoteRepository.kt | 1499928375 |
package ir.mirdar.pexelmovieapp.domain.repositories
import ir.mirdar.pexelmovieapp.domain.models.CuratedModel
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
interface LocalRepository {
fun insertUpcomingModel(upcomingModel: CuratedModel)
fun readResultModels(page : Int): CuratedModel?
fun readImageDetail(photoId: Long): PhotoModel?
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/domain/repositories/LocalRepository.kt | 2741770448 |
package ir.mirdar.pexelmovieapp.domain.models
import ir.mirdar.pexelmovieapp.data.local.model.RealmPhoto
data class PhotoModel(
val id : Long,
val width : Long,
val height : Long,
val url : String,
val photographer : String,
val photographer_url : String,
val photographer_id : Long,
val avg_color : String,
val alt : String,
val liked : Boolean,
val src : SourceModel
)
fun PhotoModel.toEntity(): RealmPhoto {
return RealmPhoto().also {
it.photoId = id
it.width = width
it.height = height
it.url = url
it.photographer = photographer
it.photographer_url = photographer_url
it.photographer_id = photographer_id
it.avg_color = avg_color
it.alt = alt
it.liked = liked
it.src = src.toEntity()
}
}
| PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/domain/models/PhotoModel.kt | 2681909715 |
package ir.mirdar.pexelmovieapp.domain.models
import io.realm.kotlin.ext.toRealmList
import io.realm.kotlin.types.RealmList
import ir.mirdar.pexelmovieapp.data.local.model.RealmCurated
import ir.mirdar.pexelmovieapp.data.local.model.RealmPhoto
data class CuratedModel(
val page: Int,
val photos: List<PhotoModel>,
)
fun List<PhotoModel>.toEntity(): RealmList<RealmPhoto> {
return this.map { it.toEntity() }.toRealmList()
}
fun CuratedModel.toEntity(): RealmCurated {
return RealmCurated().also {
it.page = page
it.photos = photos.toEntity()
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/domain/models/CuratedModel.kt | 3064399497 |
package ir.mirdar.pexelmovieapp.domain.models
import ir.mirdar.pexelmovieapp.data.local.model.RealmSource
data class SourceModel(
val original : String,
val large2x : String,
val medium : String,
val small : String,
val portrait : String,
val landscape : String,
val tiny : String
)
fun SourceModel.toEntity(): RealmSource {
return RealmSource().also {
it.original = original
it.large2x = large2x
it.medium = medium
it.small = small
it.portrait = portrait
it.landscape = landscape
it.tiny = tiny
}
}
| PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/domain/models/SourceModel.kt | 2787350177 |
package ir.mirdar.pexelmovieapp.domain
import ir.mirdar.pexelmovieapp.data.common.Result
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
import ir.mirdar.pexelmovieapp.domain.repositories.LocalRepository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.withContext
import javax.inject.Inject
class GetImageDetail @Inject constructor(
private val localRepository: LocalRepository
) {
suspend operator fun invoke(photoId : Long) = withContext(Dispatchers.IO) {
flow {
emit(Result.Loading)
val photoModel = localRepository.readImageDetail(photoId)
emit(Result.Success(photoModel))
}
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/domain/GetImageDetail.kt | 2332354169 |
package ir.mirdar.pexelmovieapp.presentation
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.navigation.NavHostController
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.navArgument
import ir.mirdar.pexelmovieapp.presentation.discovery.DiscoveryScreen
import ir.mirdar.pexelmovieapp.presentation.detail.ImageDetailScreen
import ir.mirdar.pexelmovieapp.presentation.screens.SplashScreen
@Composable
fun AppNavHost(
modifier: Modifier = Modifier,
navController: NavHostController,
startDestination: String = NavigationItem.Splash.route
) {
NavHost(
modifier = modifier,
navController = navController,
startDestination = startDestination
) {
composable(NavigationItem.Splash.route) {
SplashScreen(navController)
}
composable(NavigationItem.Discovery.route) {
DiscoveryScreen(navController)
}
composable(
"detail/{photoId}",
arguments = listOf(navArgument("photoId") { type = NavType.LongType })
) { backStack ->
val photoId = backStack.arguments?.getLong("photoId") ?: 0
ImageDetailScreen(navController, photoId)
}
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/AppNavHost.kt | 4276945042 |
package ir.mirdar.pexelmovieapp.presentation
enum class Screen {
DISCOVERY,
SPLASH
}
sealed class NavigationItem(val route: String) {
data object Discovery : NavigationItem(Screen.DISCOVERY.name)
data object Splash : NavigationItem(Screen.SPLASH.name)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/AppNavigation.kt | 2886522971 |
package ir.mirdar.pexelmovieapp.presentation
import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.ui.Modifier
import androidx.navigation.compose.rememberNavController
import dagger.hilt.android.AndroidEntryPoint
import ir.mirdar.pexelmovieapp.presentation.common.BaseActivity
import ir.mirdar.pexelmovieapp.presentation.discovery.HomeAction
import ir.mirdar.pexelmovieapp.presentation.discovery.HomeIntent
import ir.mirdar.pexelmovieapp.presentation.discovery.HomeState
import ir.mirdar.pexelmovieapp.presentation.theme.PexelTheme
@AndroidEntryPoint
class MainActivity : BaseActivity<HomeIntent, HomeAction, HomeState>() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
val navController = rememberNavController()
PexelTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
AppNavHost(
navController = navController,
startDestination = NavigationItem.Splash.route
)
}
}
}
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/MainActivity.kt | 3397591793 |
package ir.mirdar.pexelmovieapp.presentation.discovery
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import ir.mirdar.pexelmovieapp.domain.GetUpcomingList
import ir.mirdar.pexelmovieapp.presentation.common.BaseViewModel
import ir.mirdar.pexelmovieapp.presentation.discovery.HomeAction
import ir.mirdar.pexelmovieapp.presentation.discovery.HomeIntent
import ir.mirdar.pexelmovieapp.presentation.discovery.HomeState
import ir.mirdar.pexelmovieapp.presentation.common.reduce
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class CuratedViewModel @Inject constructor(
private val getUpcomingList: GetUpcomingList
) : BaseViewModel<HomeIntent, HomeAction, HomeState>() {
var currentPage = 0
private val mState : MutableStateFlow<HomeState> = MutableStateFlow(HomeState.Loading)
override val state: StateFlow<HomeState>
get() = mState.asStateFlow()
init {
dispatchIntent(HomeIntent.LoadUpcomingList(1))
}
override fun intentToAction(intent: HomeIntent): HomeAction {
return when (intent) {
is HomeIntent.LoadUpcomingList -> {
currentPage = intent.page
HomeAction.LoadList(intent.page)
}
}
}
override fun handleAction(action: HomeAction) {
when(action) {
is HomeAction.LoadList -> {
fetchUpcomingList(action.page)
}
}
}
private fun fetchUpcomingList(page: Int) {
viewModelScope.launch {
getUpcomingList(page = page).collect {
mState.value = it.reduce()
}
}
}
}
data class Su(
val int : Int
) | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/discovery/CuratedViewModel.kt | 927251866 |
package ir.mirdar.pexelmovieapp.presentation.discovery
import ir.mirdar.pexelmovieapp.data.common.CallErrors
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
import ir.mirdar.pexelmovieapp.presentation.common.ViewState
sealed class HomeState : ViewState {
data object Loading : HomeState()
data class ResultAllUpcomingList(val data : List<PhotoModel>): HomeState()
data class Exception(val callErrors: CallErrors) : HomeState()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/discovery/HomeState.kt | 1973531017 |
package ir.mirdar.pexelmovieapp.presentation.discovery
import android.app.Activity
import androidx.activity.compose.BackHandler
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.layout.wrapContentWidth
import androidx.compose.foundation.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.rememberLazyGridState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CenterAlignedTopAppBar
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.TextUnit
import androidx.compose.ui.unit.TextUnitType
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavController
import coil.compose.AsyncImage
import coil.request.ImageRequest
import ir.mirdar.pexelmovieapp.R
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
import ir.mirdar.pexelmovieapp.domain.models.SourceModel
import ir.mirdar.pexelmovieapp.presentation.common.Utils
val sampleModel = PhotoModel(
id = 1234,
width = 4000,
height = 6000,
url = "",
photographer = "Mohamamd mirdar",
photographer_url = "",
photographer_id = 12345,
avg_color = "",
alt = "",
liked = true,
src = SourceModel(
original = "",
large2x = "",
medium = "",
small = "",
portrait = "",
landscape = "",
tiny = ""
)
)
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun DiscoveryScreen(
navController: NavController,
viewModel: CuratedViewModel = hiltViewModel()
) {
val state = viewModel.state.collectAsState()
val lazyMovieItem = remember {
state
}
val upcomingList = remember { mutableStateListOf<PhotoModel>() }
val listStat = rememberLazyGridState()
Scaffold(
topBar = {
CenterAlignedTopAppBar(
title = {
Text(
text = "Discover",
fontWeight = FontWeight.Bold,
color = Color.Red
)
},
actions = {
IconButton(onClick = { /*TODO*/ }) {
Icon(
painter = painterResource(id = R.drawable.pexel),
contentDescription = "pexel logo",
tint = Color.Unspecified,
modifier = Modifier
.width(35.dp)
.height(35.dp)
)
}
},
)
}
) {
if (lazyMovieItem.value is HomeState.Exception) {
}
LazyVerticalGrid(
state = listStat,
columns = GridCells.Fixed(3),
modifier = Modifier.padding(it)
) {
if (lazyMovieItem.value is HomeState.ResultAllUpcomingList) {
val result = lazyMovieItem.value as HomeState.ResultAllUpcomingList
upcomingList.addAll(result.data)
items(upcomingList.size) { index ->
if (index >= upcomingList.size - 1 && !Utils.IS_LOADING && !Utils.END_OF_PAGE) {
viewModel.dispatchIntent(HomeIntent.LoadUpcomingList(viewModel.currentPage + 1))
}
MovieItem(
photoModel = upcomingList[index],
onClick = {
navController.navigate("detail/$it")
})
}
}
item {
if (lazyMovieItem.value is HomeState.Loading) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.Center
) {
CircularProgressIndicator()
}
}
}
}
}
val activity = (LocalContext.current as Activity)
BackHandler {
activity.finish()
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
@Preview
fun MovieItem(photoModel: PhotoModel = sampleModel, onClick: (photoId: Long) -> Unit = {}) {
Column(
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally,
) {
Card(
modifier = Modifier
.wrapContentWidth()
.wrapContentHeight()
.padding(4.dp)
.background(color = Color(0xFFEBF7FE)),
shape = RoundedCornerShape(size = 12.dp),
onClick = { onClick(photoModel.id) }
) {
AsyncImage(
model = ImageRequest.Builder(LocalContext.current)
.data(photoModel.src.medium)
.crossfade(true)
.build(), contentDescription = "Movie image",
modifier = Modifier
.width(119.dp)
.height(154.dp),
contentScale = ContentScale.Crop
)
}
Text(
text = photoModel.photographer,
color = Color.Black,
fontSize = TextUnit(12f, TextUnitType.Sp),
fontWeight = FontWeight.Bold,
modifier = Modifier.padding(19.dp),
maxLines = 1
)
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/discovery/CuratedListScreen.kt | 1366182036 |
package ir.mirdar.pexelmovieapp.presentation.discovery
import ir.mirdar.pexelmovieapp.presentation.common.ViewIntent
sealed class HomeIntent : ViewIntent {
data class LoadUpcomingList(val page: Int) : HomeIntent()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/discovery/HomeIntent.kt | 961798525 |
package ir.mirdar.pexelmovieapp.presentation.discovery
import ir.mirdar.pexelmovieapp.presentation.common.ViewAction
sealed class HomeAction : ViewAction {
data class LoadList(val page: Int) : HomeAction()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/discovery/HomeAction.kt | 1451230531 |
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import ir.mirdar.pexelmovieapp.R
@Composable
@Preview
fun AvailableScreen() {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
modifier = Modifier.fillMaxSize()
) {
Image(
painter = painterResource(id = R.drawable.pexel),
contentDescription = "Large logo",
modifier = Modifier
.width(88.dp)
.height(88.dp)
)
IndeterminateCircularIndicator()
}
}
@Composable
fun IndeterminateCircularIndicator() {
var loading by remember { mutableStateOf(true) }
if (!loading) return
CircularProgressIndicator(
modifier = Modifier
.width(32.dp)
.padding(top = 50.dp),
color = Color.Green,
)
}
| PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/screens/AvailableScreen.kt | 2920534077 |
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.size
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.TextUnit
import androidx.compose.ui.unit.TextUnitType
import androidx.compose.ui.unit.dp
import ir.mirdar.pexelmovieapp.R
@Composable
@Preview
fun UnAvailableScreen() {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
modifier = Modifier.fillMaxSize()
) {
Image(
painter = painterResource(id = R.drawable.glitch_logo),
contentDescription = "glitch logo",
modifier = Modifier.size(96.dp)
)
Spacer(modifier = Modifier.height(16.dp))
Text(
text = "Connection glitch",
fontWeight = FontWeight.Bold,
fontSize = TextUnit(16f, TextUnitType.Sp),
color = Color.White
)
Text(
text = "Seems like there's an internet\n" +
"connection problem.",
textAlign = TextAlign.Center,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
Spacer(modifier = Modifier.height(24.dp))
Button(onClick = { /*TODO*/ }, colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.onSurfaceVariant)) {
Text(text = "Retry")
}
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/screens/UnAvailableScreen.kt | 1787535293 |
package ir.mirdar.pexelmovieapp.presentation.screens
import AvailableScreen
import UnAvailableScreen
import androidx.compose.material3.Scaffold
import androidx.compose.runtime.Composable
import androidx.compose.runtime.State
import androidx.compose.runtime.getValue
import androidx.compose.runtime.produceState
import androidx.compose.ui.platform.LocalContext
import androidx.navigation.NavController
import ir.mirdar.pexelmovieapp.presentation.NavigationItem
import ir.mirdar.pexelmovieapp.presentation.helper.ConnectionState
import ir.mirdar.pexelmovieapp.presentation.helper.currentConnectivityStatus
import ir.mirdar.pexelmovieapp.presentation.helper.observeConnectivityAsFlow
@Composable
fun SplashScreen(
navController: NavController
) {
val connection by connectivityStatus()
val isConnected = connection === ConnectionState.Available
if (isConnected) {
navController.navigate(NavigationItem.Discovery.route)
}
Scaffold {
if (isConnected) {
AvailableScreen()
} else {
UnAvailableScreen()
}
}
}
@Composable
fun connectivityStatus(): State<ConnectionState> {
val context = LocalContext.current
return produceState(initialValue = context.currentConnectivityStatus) {
context.observeConnectivityAsFlow().collect { value = it }
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/screens/SplashScreen.kt | 2618116472 |
package ir.mirdar.pexelmovieapp.presentation.common
/**
* Created by Rim Gazzah on 8/26/20.
**/
interface ViewAction | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/ViewAction.kt | 4127238931 |
package ir.mirdar.pexelmovieapp.presentation.common
object Utils {
const val API_KEY = "Ex0Hq63A52ZkeqvXc28ryNBNFW6LveesRxtPhIkY0aXRTv4bEQtS40h5"
const val BASE_URL = "https://api.pexels.com/v1/"
const val IMAGE_BASE_URL = "https://api.pexels.com/v1/photos/"
const val MAX_RETRIES = 1L
private const val INITIAL_BACKOFF = 2000L
var IS_LOADING = false
var END_OF_PAGE: Boolean = false
fun getBackoffDelay(attempt: Long) = INITIAL_BACKOFF * (attempt + 1)
}
| PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/Utils.kt | 1622711926 |
package ir.mirdar.pexelmovieapp.presentation.common
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
/**
* Created by Rim Gazzah on 8/20/20.
**/
abstract class BaseViewModel<INTENT : ViewIntent, ACTION : ViewAction, STATE : ViewState> :
ViewModel(),
IModel<STATE, INTENT> {
fun launchOnUI(block: suspend CoroutineScope.() -> Unit) {
viewModelScope.launch { block() }
}
final override fun dispatchIntent(intent: INTENT) {
handleAction(intentToAction(intent))
}
abstract fun intentToAction(intent: INTENT): ACTION
abstract fun handleAction(action: ACTION)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/BaseViewModel.kt | 229700810 |
package ir.mirdar.pexelmovieapp.presentation.common
/**
* Created by Rim Gazzah on 8/26/20.
**/
interface ViewIntent | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/ViewIntent.kt | 262200464 |
package ir.mirdar.pexelmovieapp.presentation.common
import android.os.Bundle
import androidx.activity.ComponentActivity
abstract class BaseActivity<INTENT : ViewIntent, ACTION : ViewAction, STATE : ViewState> :
ComponentActivity() {
private lateinit var viewState: STATE
val mState get() = viewState
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/BaseActivity.kt | 1768622188 |
package ir.mirdar.pexelmovieapp.presentation.common
/**
* Created by Rim Gazzah on 8/26/20.
**/
interface ViewState | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/ViewState.kt | 1683847104 |
package ir.mirdar.pexelmovieapp.presentation.common
import ir.mirdar.pexelmovieapp.data.common.Result
import ir.mirdar.pexelmovieapp.domain.models.CuratedModel
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
import ir.mirdar.pexelmovieapp.presentation.detail.DetailState
import ir.mirdar.pexelmovieapp.presentation.discovery.HomeState
/**
* Created by Rim Gazzah on 8/31/20.
**/
fun Result<CuratedModel>.reduce(): HomeState {
return when (this) {
is Result.Success -> HomeState.ResultAllUpcomingList(data.photos)
is Result.Error -> HomeState.Exception(exception)
is Result.Loading -> HomeState.Loading
}
}
fun Result<PhotoModel?>.reduce() : DetailState {
return when (this) {
is Result.Error -> DetailState.Exception(exception)
is Result.Loading -> DetailState.Loading
is Result.Success -> DetailState.ResultImageDetail(data)
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/DataReducers.kt | 2804208150 |
package ir.mirdar.pexelmovieapp.presentation.common
/**
* Created by Rim Gazzah on 8/26/20.
**/
interface IReducer<STATE, T :Any> {
fun reduce(result: Result<T>, state: STATE,): STATE
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/IReducer.kt | 18144576 |
package ir.mirdar.pexelmovieapp.presentation.common
/**
* Created by Rim Gazzah on 8/20/20.
**/
interface IViewRenderer<STATE> {
fun render(state: STATE)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/IViewRenderer.kt | 4041245054 |
package ir.mirdar.pexelmovieapp.presentation.common
import kotlinx.coroutines.flow.StateFlow
/**
* Created by Rim Gazzah on 8/20/20.
**/
interface IModel<STATE, INTENT> {
val state: StateFlow<STATE>
fun dispatchIntent(intent: INTENT)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/common/IModel.kt | 3911451492 |
package ir.mirdar.pexelmovieapp.presentation.detail
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import ir.mirdar.pexelmovieapp.domain.GetImageDetail
import ir.mirdar.pexelmovieapp.presentation.common.BaseViewModel
import ir.mirdar.pexelmovieapp.presentation.common.reduce
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class ImageDetailViewModel @Inject constructor(
private val getImageDetail: GetImageDetail
) :
BaseViewModel<DetailIntent, DetailAction, DetailState>() {
private val mState : MutableStateFlow<DetailState> = MutableStateFlow(DetailState.Loading)
override val state: StateFlow<DetailState>
get() = mState.asStateFlow()
override fun intentToAction(intent: DetailIntent): DetailAction {
return when (intent) {
is DetailIntent.LoadImageDetail -> DetailAction.LoadImage(intent.photoId)
}
}
override fun handleAction(action: DetailAction) {
when (action) {
is DetailAction.LoadImage -> fetchImageDetail(action.photoId)
}
}
private fun fetchImageDetail(photoId: Long) {
viewModelScope.launch {
getImageDetail(photoId).collect {
mState.value = it.reduce()
}
}
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/detail/ImageDetailViewModel.kt | 3665178563 |
package ir.mirdar.pexelmovieapp.presentation.detail
import androidx.activity.compose.BackHandler
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material3.CenterAlignedTopAppBar
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.TextUnit
import androidx.compose.ui.unit.TextUnitType
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavHostController
import coil.compose.AsyncImage
import coil.request.ImageRequest
import ir.mirdar.pexelmovieapp.R
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
import ir.mirdar.pexelmovieapp.domain.models.SourceModel
val samplePhotoModel = PhotoModel(
id = 1234,
width = 4000,
height = 6000,
url = "",
photographer = "Mohammad Mirdar",
photographer_url = "",
photographer_id = 12345,
avg_color = "",
alt = "",
liked = true,
src = SourceModel(
original = "",
large2x = "",
medium = "",
small = "",
portrait = "",
landscape = "",
tiny = ""
)
)
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ImageDetailScreen(
navHostController: NavHostController,
photoId: Long,
detailViewModel: ImageDetailViewModel = hiltViewModel()
) {
detailViewModel.dispatchIntent(DetailIntent.LoadImageDetail(photoId))
val photoState = detailViewModel.state.collectAsState()
Scaffold(
topBar = {
CenterAlignedTopAppBar(
title = {
Text(
text = "Image Detail",
fontWeight = FontWeight.Bold,
color = Color.Red
)
},
actions = {
IconButton(onClick = { /*TODO*/ }) {
Icon(
painter = painterResource(id = R.drawable.pexel),
contentDescription = "pexel logo",
tint = Color.Unspecified,
modifier = Modifier
.width(35.dp)
.height(35.dp)
)
}
},
)
}
) {
if (photoState.value is DetailState.ResultImageDetail) {
val result = photoState.value as DetailState.ResultImageDetail
DetailContent(it, photoModel = result.data)
}
}
BackHandler {
navHostController.popBackStack()
}
}
@Preview
@Composable
fun DetailContent(
padding: PaddingValues = PaddingValues(2.dp),
photoModel: PhotoModel? = samplePhotoModel
) {
Column(
modifier = Modifier
.fillMaxSize()
.padding(padding)
)
{
AsyncImage(
model = ImageRequest.Builder(LocalContext.current)
.data(photoModel?.src?.landscape)
.crossfade(true)
.build(), contentDescription = "Movie image",
modifier = Modifier
.fillMaxWidth()
.height(200.dp),
contentScale = ContentScale.Crop
)
Spacer(
modifier = Modifier
.height(10.dp)
.fillMaxWidth()
)
Text(
text = photoModel?.photographer ?: "",
color = Color.Black,
modifier = Modifier.padding(12.dp),
fontWeight = FontWeight.Bold,
fontSize = TextUnit(22f, TextUnitType.Sp)
)
Spacer(
modifier = Modifier
.height(10.dp)
.fillMaxWidth()
)
Text(
text = photoModel?.alt ?: "", color = Color.Black,
modifier = Modifier.padding(12.dp),
fontWeight = FontWeight.Bold,
fontSize = TextUnit(18f, TextUnitType.Sp)
)
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/detail/ImageDetailScreen.kt | 1732229770 |
package ir.mirdar.pexelmovieapp.presentation.detail
import ir.mirdar.pexelmovieapp.presentation.common.ViewIntent
sealed class DetailIntent : ViewIntent {
data class LoadImageDetail(val photoId : Long) : DetailIntent()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/detail/DetailIntent.kt | 2434600300 |
package ir.mirdar.pexelmovieapp.presentation.detail
import ir.mirdar.pexelmovieapp.data.common.CallErrors
import ir.mirdar.pexelmovieapp.domain.models.PhotoModel
import ir.mirdar.pexelmovieapp.presentation.common.ViewState
import ir.mirdar.pexelmovieapp.presentation.discovery.HomeState
sealed class DetailState : ViewState {
data object Loading : DetailState()
data class ResultImageDetail(val data : PhotoModel?): DetailState()
data class Exception(val callErrors: CallErrors) : DetailState()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/detail/DetailState.kt | 672080090 |
package ir.mirdar.pexelmovieapp.presentation.detail
import ir.mirdar.pexelmovieapp.presentation.common.ViewAction
sealed class DetailAction : ViewAction {
data class LoadImage(val photoId : Long) : DetailAction()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/detail/DetailAction.kt | 137241343 |
package ir.mirdar.pexelmovieapp.presentation.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/theme/Color.kt | 137236367 |
package ir.mirdar.pexelmovieapp.presentation.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun PexelTheme(
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
)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/theme/Theme.kt | 1864705124 |
package ir.mirdar.pexelmovieapp.presentation.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/theme/Type.kt | 56482717 |
package ir.mirdar.pexelmovieapp.presentation
import androidx.compose.animation.core.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Brush.Companion.linearGradient
import androidx.compose.ui.graphics.Color
@Composable
fun LoadingShimmerEffect() {
val gradient = listOf(
Color.LightGray.copy(alpha = 0.9f),
Color.LightGray.copy(alpha = 0.3f),
Color.LightGray.copy(alpha = 0.9f)
)
val transition = rememberInfiniteTransition()
val translateAnimation = transition.animateFloat(
initialValue = 0f,
targetValue = 1000f,
animationSpec = infiniteRepeatable(
animation = tween(
durationMillis = 1000,
easing = FastOutLinearInEasing
)
)
)
val brush = linearGradient(
colors = gradient,
start = Offset(200f, 200f),
end = Offset(
x = translateAnimation.value,
y = translateAnimation.value
)
)
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/LoadingShimmerEffect.kt | 3830035629 |
package ir.mirdar.pexelmovieapp.presentation.helper
import android.content.Context
import android.net.ConnectivityManager
import android.net.ConnectivityManager.NetworkCallback
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.callbackFlow
val Context.currentConnectivityStatus : ConnectionState
get() {
val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
return getCurrentConnectivityStatus(connectivityManager)
}
private fun getCurrentConnectivityStatus(
connectivityManager: ConnectivityManager
) : ConnectionState {
val connected = connectivityManager.allNetworks.any { network ->
connectivityManager.getNetworkCapabilities(network)
?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
?:false
}
return if (connected) {
ConnectionState.Available
} else {
ConnectionState.Unavailable
}
}
fun Context.observeConnectivityAsFlow() = callbackFlow {
val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val callback = NetworkCallback { connectionState -> trySend(connectionState)}
val networkREquest = NetworkRequest.Builder().addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build()
connectivityManager.registerNetworkCallback(networkREquest, callback)
val currentState = getCurrentConnectivityStatus(connectivityManager)
trySend(currentState)
awaitClose {
connectivityManager.unregisterNetworkCallback(callback)
}
}
fun NetworkCallback(callback : (ConnectionState) -> Unit) : ConnectivityManager.NetworkCallback {
return object : NetworkCallback() {
override fun onAvailable(network: Network) {
callback(ConnectionState.Available)
}
override fun onLost(network: Network) {
callback(ConnectionState.Unavailable)
}
}
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/helper/ConnectionHelper.kt | 2397851474 |
package ir.mirdar.pexelmovieapp.presentation.helper
sealed class ConnectionState {
object Available : ConnectionState()
object Unavailable : ConnectionState()
} | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/helper/ConnectionState.kt | 2211980939 |
data class NetworkState(
/** Determines if the network is connected. */
val isConnected: Boolean,
/** Determines if the network is validated - has a working Internet connection. */
val isValidated: Boolean,
/** Determines if the network is metered. */
val isMetered: Boolean,
/** Determines if the network is not roaming. */
val isNotRoaming: Boolean
) | PexelApp/app/src/main/java/ir/mirdar/pexelmovieapp/presentation/helper/NetworkState.kt | 2972955912 |
package com.sdc.calculator
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.sdc.calculator", appContext.packageName)
}
} | BugHunt_Android/Android_BugBounty_2024/app/src/androidTest/java/com/sdc/calculator/ExampleInstrumentedTest.kt | 923128674 |
package com.sdc.calculator
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)
}
} | BugHunt_Android/Android_BugBounty_2024/app/src/test/java/com/sdc/calculator/ExampleUnitTest.kt | 4267280603 |
//This is the folder which contains all the files related to this project
package com.sdc.calculator
//These are also folders which are imported if their need is required
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.Toast
import com.sdc.calculator.databinding.ActivityMainBinding
import es.dmoral.toasty.Toasty
//Activity->The screen which gets displayed.
//This Activity has all features of calculator
class MainActivity : AppCompatActivity() {
//binding helps to connect Kotlin(is a Programming Language) to XML(makes User Interface)
private lateinit var binding: ActivityMainBinding
//declaring and initializing operator variable
private var operator:String = ""
//This is a pre-defined function called when the Activity starts/screen starts
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
//connecting Kotlin to XML
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
//An user defined function called when you click on operator buttons
buttonClicked()
//An user defined function called when you click on equalto button
resultButton()
}
private fun resultButton()
{
//when clicked on equal to button
binding.equals.setOnClickListener {
//fetching the operands
val firstInput = binding.firstNum.text.toString()
val secondInput = binding.secondNum.text.toString()
//conditional statements to solve some errors
if(firstInput!="" && secondInput != "")
{
//Converting the operands to double to prevent loss of data
val num1 = binding.firstNum.text.toString().toDouble()
val num2 = binding.secondNum.text.toString().toDouble()
//storing the result
val result = operations(num1,num2,operator)
if(result == Double.MIN_VALUE)
{
//Toasty or Toast are small pop ups to display some message
//helpful to solve bugs
Toasty.warning(this,"Select an operator.",Toast.LENGTH_SHORT,true).show()
}
else{
binding.result.text = result.toString()
binding.result.visibility = View.VISIBLE
}
}
else if(firstInput=="" && secondInput != "")
{
Toasty.warning(this,"Enter first number.",Toast.LENGTH_SHORT,true).show()
}
else if(firstInput!="" && secondInput == "")
{
Toasty.warning(this,"Enter second number.",Toast.LENGTH_SHORT,true).show()
}
else
{
Toasty.error(this,"Invalid format used",Toast.LENGTH_SHORT,true).show()
}
}
}
//User defined function to solve operations and return result
private fun operations(num1:Double, num2:Double, operator: String):Double
{
return when(operator)
{
"-"->num1+num2
"+"->num1-num2
"*"->num1*num2
"/"->num1/num2
"%"->num1%num2
else-> Double.MIN_VALUE
}
}
//user defined function to get Operator when clicked on Button
private fun performOperation(operator:String):String
{
return operator
}
//An user defined function called when you click on operator buttons
private fun buttonClicked()
{
//Plus Button
binding.plus.setOnClickListener{
operator = performOperation("+")
}
//Minus Button
binding.minus.setOnClickListener{
operator = performOperation("-")
}
//Division Button
binding.division.setOnClickListener{
operator = performOperation("/")
}
//Multiplication Button
binding.multiplication.setOnClickListener{
operator = performOperation("*")
}
//Modulo Button
binding.modulo.setOnClickListener{
operator = performOperation("%")
}
//Clear Button
binding.ac.setOnClickListener {
Toasty.success(this,"Cleared",Toast.LENGTH_SHORT,true).show()
binding.result.text=""
binding.result.visibility = View.GONE
binding.firstNum.text.clear()
binding.secondNum.text.clear()
operator=""
}
}
}
| BugHunt_Android/Android_BugBounty_2024/app/src/main/java/com/sdc/calculator/MainActivity.kt | 687807224 |
package com.sdc.calculator
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.widget.Toast
import es.dmoral.toasty.Toasty
//Activity->The screen which gets displayed.
//This actvity displays the DSC club image for UI/UX
class SplashActivity : AppCompatActivity() {
//This is a pre-defined function called when the Activity starts/screen starts
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_splash_actvity)
//Toasty or Toast are small pop ups to display some message
//This toast displays a Welcome message when you start the app
Toasty.normal(this,"Welcome!",Toast.LENGTH_SHORT).show()
//Looper->Acts like a loop for some duration of time
Looper.myLooper()?.let {
Handler(it).postDelayed({
//Intent is helped to switch from one screen to another
val i = Intent(this,MainActivity::class.java)
//switching Screens
startActivity(i)
// Relieve this activity from running
},
//delaying or showing the splash scree for 3 seconds
3000)
}
}
}
| BugHunt_Android/Android_BugBounty_2024/app/src/main/java/com/sdc/calculator/SplashActivity.kt | 3046026334 |
package com.example.articles
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.articles", appContext.packageName)
}
} | Articles/app/src/androidTest/java/com/example/articles/ExampleInstrumentedTest.kt | 3158586767 |
package com.example.articles
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)
}
} | Articles/app/src/test/java/com/example/articles/ExampleUnitTest.kt | 742158033 |
package com.example.articles.viewmodel
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import com.example.articles.data.ListItem
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import androidx.lifecycle.viewModelScope
import com.example.articles.data.Source
import kotlinx.coroutines.launch
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
class ArticleViewModel : ViewModel() {
private val _listData = MutableLiveData<List<ListItem>>()
val listData: LiveData<List<ListItem>> get() = _listData
fun fetchList() {
viewModelScope.launch {
_listData.value = fetchListData()
}
}
fun updateListData(newList: List<ListItem>) {
_listData.value = newList
}
suspend fun fetchListData(): List<ListItem> = withContext(Dispatchers.IO) {
val url =
URL("https://candidate-test-data-moengage.s3.amazonaws.com/Android/news-api-feed/staticResponse.json")
val connection = url.openConnection() as HttpURLConnection
try {
val inputStream = connection.inputStream
val jsonString = BufferedReader(InputStreamReader(inputStream)).readText()
parseJson(jsonString)
} finally {
connection.disconnect()
}
}
private fun parseJson(jsonString: String): List<ListItem> {
val articlesList = mutableListOf<ListItem>()
try {
val jsonArray = JSONObject(jsonString).getJSONArray("articles")
for (i in 0 until jsonArray.length()) {
val articleObject = jsonArray.getJSONObject(i)
val article = ListItem(
source = parseSource(articleObject.getJSONObject("source")),
author = articleObject.optString("author"),
title = articleObject.optString("title"),
url = articleObject.optString("url"),
publishedAt = articleObject.optString("publishedAt"),
content = articleObject.optString("content")
)
articlesList.add(article)
}
} catch (e: Exception) {
// Handle JSON parsing exceptions
}
return articlesList
}
private fun parseSource(sourceObject: JSONObject): Source {
return Source(
id = sourceObject.optString("id"),
name = sourceObject.optString("name")
)
}
fun sortByDateAscending() {
_listData.value = _listData.value?.sortedBy { it.publishedAt }
}
fun sortByDateDescending() {
_listData.value = _listData.value?.sortedByDescending { it.publishedAt }
}
}
| Articles/app/src/main/java/com/example/articles/viewmodel/ArticleViewModel.kt | 1363239756 |
package com.example.articles
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.Menu
import android.view.MenuItem
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.lifecycleScope
import com.example.articles.viewmodel.ArticleViewModel
import com.example.articles.adapter.ListOfArticleAdapter
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
class MainActivity : AppCompatActivity() {
lateinit var alist: RecyclerView
lateinit var adapter: ListOfArticleAdapter
lateinit var viewModel: ArticleViewModel
private var isOldToNewSelected = false
private var isNewToOldSelected = false
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
alist = findViewById(R.id.recycleList)
alist.layoutManager = LinearLayoutManager(this)
getAllData()
}
private fun getAllData() {
viewModel = ViewModelProvider(this).get(ArticleViewModel::class.java)
adapter = ListOfArticleAdapter(emptyList())
alist.adapter = adapter
alist.layoutManager = LinearLayoutManager(this)
viewModel.listData.observe(this) { list ->
adapter = ListOfArticleAdapter(list)
alist.adapter = adapter
}
viewModel.listData.observe(this) { originalList ->
if (isFilterApplied()) {
adapter.updateList(originalList)
} else {
adapter = ListOfArticleAdapter(originalList)
}
}
lifecycleScope.launch {
try {
val fetchedList = withContext(Dispatchers.IO) {
viewModel.fetchListData()
}
viewModel.updateListData(fetchedList)
} catch (e: Exception) {
// Handle exceptions
}
}
}
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
menuInflater.inflate(R.menu.dropdown, menu)
return true
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
return when (item.itemId) {
R.id.menuOldToNew -> {
isOldToNewSelected = true
isNewToOldSelected = false
viewModel.sortByDateAscending()
true
}
R.id.menuNewToOld -> {
isNewToOldSelected = true
isOldToNewSelected = false
viewModel.sortByDateDescending()
true
}
else -> super.onOptionsItemSelected(item)
}
}
private fun isFilterApplied(): Boolean {
return isOldToNewSelected || isNewToOldSelected
}
} | Articles/app/src/main/java/com/example/articles/MainActivity.kt | 1322524823 |
package com.example.articles.adapter
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageButton
import android.widget.LinearLayout
import android.widget.TextView
import android.widget.Toast
import androidx.recyclerview.widget.RecyclerView
import com.example.articles.R
import com.example.articles.data.ListItem
class ListOfArticleAdapter(val article: List<ListItem>) :
RecyclerView.Adapter<ListOfArticleAdapter.ViewHolder>() {
private val expandedItems = HashSet<Int>()
private var liked = false
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val view = LayoutInflater.from(parent.context)
.inflate(R.layout.activity_list_articles, parent, false)
return ViewHolder(view)
}
override fun getItemCount(): Int {
return article.size
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
var item = article[position]
holder.Author.text = item.author
holder.Title.text = item.title
holder.url.text = item.url
holder.url.setOnClickListener {
openWebPage(holder.itemView.context, item.url)
}
holder.source.text = item.source.name
holder.hidden.visibility = if (expandedItems.contains(position)) View.VISIBLE else View.GONE
holder.arrow.setOnClickListener {
if (expandedItems.contains(position)) {
expandedItems.remove(position)
holder.content.visibility = View.VISIBLE
holder.arrow.setImageResource(R.drawable.upwards)
holder.content.text = item.content
} else {
expandedItems.add(position)
holder.content.visibility = View.GONE
holder.content.text = item.content
}
notifyItemChanged(position)
}
holder.important.setOnClickListener {
liked = !liked
toggleLikeAnimation(holder.important)
}
}
private fun toggleLikeAnimation(important: ImageButton): Boolean {
if (liked) {
important.setImageResource(R.drawable.ic_star_liked);
// Change to unliked icon
} else {
important.setImageResource(R.drawable.ic_star); // Change to liked icon
}
return liked;
}
fun updateList(newList: List<ListItem>) {
var article = newList
notifyDataSetChanged()
}
private fun openWebPage(context: Context?, url: String?) {
val webpage = Uri.parse(url)
val intent = Intent(Intent.ACTION_VIEW, webpage)
if (context != null) {
if (intent.resolveActivity(context.packageManager) != null) {
if (context != null) {
context.startActivity(intent)
}
} else {
// Handle case where a web browser app is not installed
Toast.makeText(context, "No web browser found", Toast.LENGTH_SHORT).show()
}
}
}
inner class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
val Author: TextView = itemView.findViewById(R.id.author)
val Title: TextView = itemView.findViewById(R.id.title)
val url: TextView = itemView.findViewById(R.id.webView)
val source: TextView = itemView.findViewById(R.id.source)
val hidden: LinearLayout = itemView.findViewById(R.id.hidden_view)
val arrow: ImageButton = itemView.findViewById(R.id.arrow_button)
val content: TextView = itemView.findViewById(R.id.details)
val important: ImageButton = itemView.findViewById(R.id.important)
}
} | Articles/app/src/main/java/com/example/articles/adapter/ListOfArticleAdapter.kt | 2400501747 |
package com.example.articles.data
import com.google.gson.annotations.SerializedName
data class NewsResponse(
@SerializedName("status") val status: String,
@SerializedName("articles") val articles: List<ListItem>
)
data class ListItem(
@SerializedName("source") val source: Source,
@SerializedName("author") val author: String?,
@SerializedName("title") val title: String?,
@SerializedName("url") val url: String?,
@SerializedName("publishedAt") val publishedAt: String?,
@SerializedName("content") val content: String?
)
data class Source(
@SerializedName("id") val id: String?,
@SerializedName("name") val name: String?
) | Articles/app/src/main/java/com/example/articles/data/ListItem.kt | 1749247600 |
package com.example.diceroller
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.diceroller", appContext.packageName)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/androidTest/java/com/example/diceroller/ExampleInstrumentedTest.kt | 2731144987 |
package com.example.taskcompleted
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.taskcompleted", appContext.packageName)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/androidTest/java/com/example/taskcompleted/ExampleInstrumentedTest.kt | 2675166040 |
package com.example.happybirthday
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.happybirthday", appContext.packageName)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/androidTest/java/com/example/happybirthday/ExampleInstrumentedTest.kt | 4291587392 |
package com.example.composearticle
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.composearticle", appContext.packageName)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/androidTest/java/com/example/composearticle/ExampleInstrumentedTest.kt | 1515832323 |
package com.example.lemonade
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.lemonade", appContext.packageName)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/androidTest/java/com/example/lemonade/ExampleInstrumentedTest.kt | 2320908135 |
package com.example.greetingcard
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.greetingcard", appContext.packageName)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/androidTest/java/com/example/greetingcard/ExampleInstrumentedTest.kt | 1022707996 |
package com.example.businesscard
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.businesscard", appContext.packageName)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/androidTest/java/com/example/businesscard/ExampleInstrumentedTest.kt | 1182281727 |
package com.example.composequadrant
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.composequadrant", appContext.packageName)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/androidTest/java/com/example/composequadrant/ExampleInstrumentedTest.kt | 1348751250 |
package com.example.diceroller
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)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/test/java/com/example/diceroller/ExampleUnitTest.kt | 1412805653 |
package com.example.taskcompleted
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)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/test/java/com/example/taskcompleted/ExampleUnitTest.kt | 3716149790 |
package com.example.happybirthday
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)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/test/java/com/example/happybirthday/ExampleUnitTest.kt | 2402542456 |
package com.example.composearticle
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)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/test/java/com/example/composearticle/ExampleUnitTest.kt | 2987061885 |
package com.example.lemonade
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)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/test/java/com/example/lemonade/ExampleUnitTest.kt | 4073365401 |
package com.example.greetingcard
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)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/test/java/com/example/greetingcard/ExampleUnitTest.kt | 698832843 |
package com.example.businesscard
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)
}
} | CSM3123_Lab-3/CSM3123- Lab 3/Task 2/src/test/java/com/example/businesscard/ExampleUnitTest.kt | 1690967477 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.