content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.example.firstcomposeproject.di
import androidx.lifecycle.ViewModel
import com.example.firstcomposeproject.presentation.comments.CommentViewModel
import dagger.Binds
import dagger.Module
import dagger.multibindings.IntoMap
@Module
interface CommentViewModelModule {
@IntoMap
@ViewModelKey(CommentViewModel::class)
@Binds
fun bindCommentViewModel(viewModel: CommentViewModel): ViewModel
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/di/CommentViewModelModule.kt | 2740189310 |
package com.example.firstcomposeproject.di
import androidx.lifecycle.ViewModel
import com.example.firstcomposeproject.presentation.main.MainViewModel
import com.example.firstcomposeproject.presentation.news.NewsFeedViewModel
import dagger.Binds
import dagger.Module
import dagger.multibindings.IntoMap
@Module
interface ViewModelModule {
@IntoMap
@ViewModelKey(NewsFeedViewModel::class)
@Binds
fun bindNewsFeedViewModel(viewModel: NewsFeedViewModel): ViewModel
@IntoMap
@ViewModelKey(MainViewModel::class)
@Binds
fun bindMainViewModel(viewModel: MainViewModel): ViewModel
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/di/ViewModelModule.kt | 2950930192 |
package com.example.firstcomposeproject.di
import javax.inject.Scope
@Scope
@Retention(AnnotationRetention.RUNTIME)
annotation class ApplicationScope | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/di/ApplicationScope.kt | 2859580172 |
package com.example.firstcomposeproject.di
import androidx.lifecycle.ViewModel
import dagger.MapKey
import kotlin.reflect.KClass
@MapKey
@Retention(AnnotationRetention.RUNTIME)
annotation class ViewModelKey(val value: KClass<out ViewModel>) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/di/ViewModelKey.kt | 2650598817 |
package com.example.firstcomposeproject.navigation
import androidx.compose.runtime.Composable
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import com.example.firstcomposeproject.domain.entities.FeedPost
@Composable
fun AppNavGraph(
navHostController: NavHostController,
newsFeedScreenContent: @Composable () -> Unit,
commentScreenContent: @Composable (FeedPost) -> Unit,
favoritesScreenContent: @Composable () -> Unit,
profileScreenContent: @Composable () -> Unit
) {
NavHost(
navController = navHostController,
startDestination = Screen.Home.route
) {
homeScreenGraph(
newsFeedScreenContent = newsFeedScreenContent,
commentScreenContent = commentScreenContent
)
composable(Screen.Favorites.route) {
favoritesScreenContent()
}
composable(Screen.Profile.route) {
profileScreenContent()
}
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/navigation/NavGraph.kt | 461938419 |
package com.example.firstcomposeproject.navigation
import android.net.Uri
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.google.gson.Gson
sealed class Screen(
val route: String
) {
object NewsFeed: Screen(ROUTE_NEWS_FEED)
object Favorites: Screen(ROUTE_FAVORITES)
object Profile: Screen(ROUTE_PROFILE)
object Home: Screen(ROUTE_HOME)
object Comments: Screen(ROUTE_COMMENTS) {
private const val ROUTE_FOR_ARGS = "comments"
fun getRouteWithArgs(feedPost: FeedPost): String {
val feedPostJson = Gson().toJson(feedPost)
return "$ROUTE_FOR_ARGS/${feedPostJson.encode()}"
}
}
companion object {
const val KEY_FEED_POST = "feed_post"
const val ROUTE_COMMENTS = "comments/{$KEY_FEED_POST}"
const val ROUTE_NEWS_FEED = "news_feed"
const val ROUTE_FAVORITES = "favorites"
const val ROUTE_PROFILE = "profile"
const val ROUTE_HOME = "home"
}
}
fun String.encode(): String {
return Uri.encode(this)
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/navigation/Screen.kt | 1446400731 |
package com.example.firstcomposeproject.navigation
import androidx.compose.runtime.Composable
import androidx.navigation.NavGraphBuilder
import androidx.navigation.NavType
import androidx.navigation.compose.composable
import androidx.navigation.navArgument
import androidx.navigation.navigation
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.google.gson.Gson
fun NavGraphBuilder.homeScreenGraph(
newsFeedScreenContent: @Composable () -> Unit,
commentScreenContent: @Composable (FeedPost) -> Unit
) {
navigation(
startDestination = Screen.NewsFeed.route,
route = Screen.Home.route
) {
composable(Screen.NewsFeed.route) {
newsFeedScreenContent()
}
composable(
route = Screen.Comments.route,
arguments = listOf(
navArgument(Screen.KEY_FEED_POST) {
type = NavType.StringType
}
)
) {
val feedPostJson = it.arguments?.getString(Screen.KEY_FEED_POST) ?: ""
val feedPost = Gson().fromJson(feedPostJson, FeedPost::class.java)
commentScreenContent(feedPost)
}
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/navigation/HomeScreenNavGraph.kt | 1495391492 |
package com.example.firstcomposeproject.navigation
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.navigation.NavGraph.Companion.findStartDestination
import androidx.navigation.NavHostController
import androidx.navigation.compose.rememberNavController
import com.example.firstcomposeproject.domain.entities.FeedPost
class NavigationState (
val navHostController: NavHostController
) {
fun navigateTo(route: String) {
navHostController.navigate(route) {
popUpTo(navHostController.graph.findStartDestination().id) {
saveState = true
}
launchSingleTop = true
restoreState = true
}
}
fun navigateToComments(feedPost: FeedPost) {
navHostController.navigate(Screen.Comments.getRouteWithArgs(feedPost))
}
}
@Composable
fun rememberNavigationState(
navHostController: NavHostController = rememberNavController()
) : NavigationState {
return remember {
NavigationState(navHostController)
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/navigation/NavigationState.kt | 3989324742 |
package com.example.firstcomposeproject.data.network
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.create
object ApiFactory {
private val okHttpClient = OkHttpClient.Builder()
.addInterceptor(HttpLoggingInterceptor().apply {
level = HttpLoggingInterceptor.Level.BODY
})
.build()
private val retrofit = Retrofit.Builder()
.baseUrl("https://api.vk.com/method/")
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient)
.build()
val apiService: ApiService = retrofit.create()
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/network/ApiFactory.kt | 2653228103 |
package com.example.firstcomposeproject.data.network
import com.example.firstcomposeproject.data.model.CommentsResponseDto
import com.example.firstcomposeproject.data.model.LikesCountResponseDto
import com.example.firstcomposeproject.data.model.NewsFeedResponseDto
import retrofit2.http.GET
import retrofit2.http.Query
interface ApiService {
@GET("newsfeed.getRecommended?v=5.131")
suspend fun loadRecommendations(
@Query("access_token") token: String
): NewsFeedResponseDto
@GET("newsfeed.getRecommended?v=5.131")
suspend fun loadRecommendations(
@Query("access_token") token: String,
@Query("start_from") startFrom: String
): NewsFeedResponseDto
@GET("likes.add?v=5.131&type=post")
suspend fun addLike(
@Query("access_token") token: String,
@Query("owner_id") ownerId: Long,
@Query("item_id") postId: Long
): LikesCountResponseDto
@GET("likes.delete?v=5.131&type=post")
suspend fun deleteLike(
@Query("access_token") token: String,
@Query("owner_id") ownerId: Long,
@Query("item_id") postId: Long
): LikesCountResponseDto
@GET("newsfeed.ignoreItem?v=5.131&type=wall")
suspend fun ignorePost(
@Query("access_token") accessToken: String,
@Query("owner_id") ownerId: Long,
@Query("item_id") postId: Long
)
@GET("wall.getComments?v=5.131&extended=1&fields=photo_100")
suspend fun getComments(
@Query("access_token") accessToken: String,
@Query("owner_id") ownerId: Long,
@Query("post_id") postId: Long
): CommentsResponseDto
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/network/ApiService.kt | 2712141397 |
package com.example.firstcomposeproject.data.repositories
import com.example.firstcomposeproject.data.extensions.mergeWith
import com.example.firstcomposeproject.data.mappers.NewsFeedMapper
import com.example.firstcomposeproject.data.network.ApiService
import com.example.firstcomposeproject.domain.Repository
import com.example.firstcomposeproject.domain.entities.AuthState
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.domain.entities.PostComment
import com.example.firstcomposeproject.domain.entities.StatisticType
import com.vk.api.sdk.VKPreferencesKeyValueStorage
import com.vk.api.sdk.auth.VKAccessToken
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.retry
import kotlinx.coroutines.flow.stateIn
import javax.inject.Inject
class NewsFeedRepositoryImpl@Inject constructor(
private val apiService: ApiService,
private val mapper: NewsFeedMapper,
private val storage: VKPreferencesKeyValueStorage,
) : Repository {
private val coroutineScope = CoroutineScope(Dispatchers.Default)
private val token
get() = VKAccessToken.restore(storage)
private val nextDataNeededEvents = MutableSharedFlow<Unit>(replay = 1)
private val refreshedListFlow = MutableSharedFlow<List<FeedPost>>()
private val loadedListFlow = flow {
nextDataNeededEvents.emit(Unit)
nextDataNeededEvents.collect {
val startFrom = nextFrom
if (startFrom == null && feedPosts.isNotEmpty()) {
emit(feedPosts)
return@collect
}
val response = if (startFrom == null) {
apiService.loadRecommendations(getAccessToken())
} else {
apiService.loadRecommendations(getAccessToken(), startFrom)
}
nextFrom = response.newsFeedContent.nextFrom
val posts = mapper.mapResponseToPosts(response)
_feedPosts.addAll(posts)
emit(feedPosts)
}
}.retry {
delay(RETRY_TIMEOUT_MILLIS)
true
}
private val _feedPosts = mutableListOf<FeedPost>()
private val feedPosts: List<FeedPost>
get() = _feedPosts.toList()
private var nextFrom: String? = null
private val checkAuthStateEvents = MutableSharedFlow<Unit>(replay = 1)
private val authStateFlow = flow {
checkAuthStateEvents.emit(Unit)
checkAuthStateEvents.collect {
val currentToken = token
val loggedIn = currentToken != null && currentToken.isValid
val authState = if (loggedIn) AuthState.Authorized else AuthState.NotAuthorized
emit(authState)
}
}.stateIn(
scope = coroutineScope,
started = SharingStarted.Lazily,
initialValue = AuthState.Initial
)
private val recommendations: StateFlow<List<FeedPost>> = loadedListFlow
.mergeWith(refreshedListFlow)
.stateIn(
scope = coroutineScope,
started = SharingStarted.Lazily,
initialValue = feedPosts
)
override fun getAuthStateFlow(): StateFlow<AuthState> = authStateFlow
override fun getRecommendations(): StateFlow<List<FeedPost>> = recommendations
override suspend fun loadNextData() {
nextDataNeededEvents.emit(Unit)
}
override suspend fun checkAuthState() {
checkAuthStateEvents.emit(Unit)
}
private fun getAccessToken(): String {
return token?.accessToken ?: throw IllegalStateException("Token is null")
}
override suspend fun deletePost(feedPost: FeedPost) {
apiService.ignorePost(
accessToken = getAccessToken(),
ownerId = feedPost.communityId,
postId = feedPost.id
)
_feedPosts.remove(feedPost)
refreshedListFlow.emit(feedPosts)
}
override fun getComments(feedPost: FeedPost): StateFlow<List<PostComment>> = flow {
val comments = apiService.getComments(
accessToken = getAccessToken(),
ownerId = feedPost.communityId,
postId = feedPost.id
)
emit(mapper.mapResponseToComments(comments))
}.retry {
delay(RETRY_TIMEOUT_MILLIS)
true
}.stateIn(
scope = coroutineScope,
started = SharingStarted.Lazily,
initialValue = listOf()
)
override suspend fun changeLikeStatus(feedPost: FeedPost) {
val response = if (feedPost.isLiked) {
apiService.deleteLike(
token = getAccessToken(),
ownerId = feedPost.communityId,
postId = feedPost.id
)
} else {
apiService.addLike(
token = getAccessToken(),
ownerId = feedPost.communityId,
postId = feedPost.id
)
}
val newLikesCount = response.likes.count
val newStatistics = feedPost.statistics.apply {
put(StatisticType.LIKES, newLikesCount)
}
val newPost = feedPost.copy(statistics = newStatistics, isLiked = !feedPost.isLiked)
val postIndex = _feedPosts.indexOf(feedPost)
_feedPosts[postIndex] = newPost
}
companion object {
private const val RETRY_TIMEOUT_MILLIS = 3000L
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/repositories/NewsFeedRepositoryImpl.kt | 1196716036 |
package com.example.firstcomposeproject.data.extensions
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.merge
fun <T> Flow<T>.mergeWith(another: Flow<T>): Flow<T> {
return merge(this, another)
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/extensions/FlowExt.kt | 164638366 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class ViewDto(
@SerializedName("count") val count: Int
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/ViewDto.kt | 229339682 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class CommentDto(
@SerializedName("id") val id: Long,
@SerializedName("from_id") val authorId: Long,
@SerializedName("text") val text: String,
@SerializedName("date") val date: Long
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/CommentDto.kt | 2919111294 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class AttachmentDto(
@SerializedName("photo") val photo: PhotoDto?
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/AttachmentDto.kt | 2688664361 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class LikeDto (
@SerializedName("count") val count: Int,
@SerializedName("user_likes") val userLikes: Int
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/LikeDto.kt | 2742776312 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class CommentsContentDto(
@SerializedName("items") val comments: List<CommentDto>,
@SerializedName("profiles") val profiles: List<ProfileDto>
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/CommentsContentDto.kt | 3822833050 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class CommentsResponseDto(
@SerializedName("response") val content: CommentsContentDto
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/CommentsResponseDto.kt | 319832063 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class PhotoDto(
@SerializedName("sizes") val photoUrls: List<PhotoUrlDto>
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/PhotoDto.kt | 3101548879 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class LikesCountResponseDto(
@SerializedName("response") val likes: LikesCountDto
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/LikesCountResponseDto.kt | 3985193787 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class ProfileDto(
@SerializedName("id") val id: Long,
@SerializedName("first_name") val firstName: String,
@SerializedName("last_name") val lastName: String,
@SerializedName("photo_100") val avatarUrl: String
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/ProfileDto.kt | 3592755834 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class RepostDto(
@SerializedName("count") val count: Int
)
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/RepostDto.kt | 3880171673 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class NewsFeedResponseDto(
@SerializedName("response") val newsFeedContent: NewsFeedContentDto
)
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/NewsFeedResponseDto.kt | 4177851652 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class PhotoUrlDto(
@SerializedName("url") val url: String
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/PhotoUrlDto.kt | 45544006 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class PostDto(
@SerializedName("id") val id: Long,
@SerializedName("source_id") val communityId: Long,
@SerializedName("date") val date: Long,
@SerializedName("text") val text: String,
@SerializedName("attachments") val attachments: List<AttachmentDto>?,
@SerializedName("comments") val comments: CommentsDto,
@SerializedName("likes") val likes: LikeDto,
@SerializedName("reposts") val reposts: RepostDto,
@SerializedName("views") val views: ViewDto,
@SerializedName("is_favourite") val isFavourite: Boolean
)
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/PostDto.kt | 3568734895 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class GroupDto(
@SerializedName("id") val id: Long,
@SerializedName("name") val name: String,
@SerializedName("photo_200") val imageUrl: String
)
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/GroupDto.kt | 1335184800 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class NewsFeedContentDto(
@SerializedName("items") val posts: List<PostDto>,
@SerializedName("groups") val groups: List<GroupDto>,
@SerializedName("next_from") val nextFrom: String?
)
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/NewsFeedContentDto.kt | 2971740782 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class CommentsDto(
@SerializedName("count") val count: Int
)
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/CommentsDto.kt | 2658939120 |
package com.example.firstcomposeproject.data.model
import com.google.gson.annotations.SerializedName
data class LikesCountDto(
@SerializedName("likes") val count: Int
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/model/LikesCountDto.kt | 1218266997 |
package com.example.firstcomposeproject.data.mappers
import com.example.firstcomposeproject.data.model.CommentsResponseDto
import com.example.firstcomposeproject.data.model.NewsFeedResponseDto
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.domain.entities.PostComment
import com.example.firstcomposeproject.domain.entities.StatisticType
import java.sql.Date
import java.text.SimpleDateFormat
import java.util.Locale
import kotlin.math.absoluteValue
import javax.inject.Inject
class NewsFeedMapper @Inject constructor() {
fun mapResponseToPosts(responseDto: NewsFeedResponseDto): List<FeedPost> {
val result = mutableListOf<FeedPost>()
val posts = responseDto.newsFeedContent.posts
val groups = responseDto.newsFeedContent.groups
for (post in posts) {
val group = groups.find { it.id == post.communityId.absoluteValue } ?: break
val feedPost = FeedPost(
id = post.id,
communityId = post.communityId,
communityName = group.name,
publicationDate = mapTimestampToDate(post.date * 1000),
communityImageUrl = group.imageUrl,
contentText = post.text,
contentImageUrl = post.attachments?.firstOrNull()?.photo?.photoUrls?.lastOrNull()?.url,
statistics = hashMapOf(
StatisticType.LIKES to post.likes.count,
StatisticType.VIEWS to post.views.count,
StatisticType.SHARES to post.reposts.count,
StatisticType.COMMENTS to post.comments.count
),
isLiked = post.likes.userLikes > 0
)
result.add(feedPost)
}
return result
}
fun mapResponseToComments(response: CommentsResponseDto): List<PostComment> {
val result = mutableListOf<PostComment>()
val comments = response.content.comments
val profiles = response.content.profiles
for (comment in comments) {
if (comment.text.isBlank()) continue
val author = profiles.firstOrNull { it.id == comment.authorId } ?: continue
val postComment = PostComment(
id = comment.id,
authorName = "${author.firstName} ${author.lastName}",
authorAvatarUrl = author.avatarUrl,
commentText = comment.text,
publicationDate = mapTimestampToDate(comment.date)
)
result.add(postComment)
}
return result
}
private fun mapTimestampToDate(timestamp: Long): String {
val date = Date(timestamp)
return SimpleDateFormat("d MMMM yyyy, hh:mm", Locale.getDefault()).format(date)
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/data/mappers/NewsFeedMapper.kt | 2100590575 |
package com.example.firstcomposeproject.domain
import com.example.firstcomposeproject.domain.entities.AuthState
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.domain.entities.PostComment
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.StateFlow
interface Repository {
fun getAuthStateFlow(): StateFlow<AuthState>
fun getRecommendations(): StateFlow<List<FeedPost>>
fun getComments(feedPost: FeedPost): Flow<List<PostComment>>
suspend fun loadNextData()
suspend fun checkAuthState()
suspend fun deletePost(feedPost: FeedPost)
suspend fun changeLikeStatus(feedPost: FeedPost)
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/Repository.kt | 1362024514 |
package com.example.firstcomposeproject.domain.usecases
import com.example.firstcomposeproject.domain.Repository
import com.example.firstcomposeproject.domain.entities.FeedPost
import javax.inject.Inject
class DeletePostUseCase @Inject constructor(
private val repository: Repository
) {
suspend operator fun invoke(feedPost: FeedPost) {
repository.deletePost(feedPost)
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/usecases/DeletePostUseCase.kt | 904750026 |
package com.example.firstcomposeproject.domain.usecases
import com.example.firstcomposeproject.domain.Repository
import javax.inject.Inject
class LoadNextDataUseCase @Inject constructor(
private val repository: Repository
) {
suspend operator fun invoke() {
repository.loadNextData()
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/usecases/LoadNextDataUseCase.kt | 2888459109 |
package com.example.firstcomposeproject.domain.usecases
import com.example.firstcomposeproject.domain.Repository
import javax.inject.Inject
class CheckAuthStateUseCase @Inject constructor(
private val repository: Repository
) {
suspend operator fun invoke() {
repository.checkAuthState()
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/usecases/CheckAuthStateUseCase.kt | 3860300985 |
package com.example.firstcomposeproject.domain.usecases
import com.example.firstcomposeproject.domain.Repository
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.domain.entities.PostComment
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
class GetCommentUseCase @Inject constructor(
private val repository: Repository
) {
operator fun invoke(feedPost: FeedPost): Flow<List<PostComment>> {
return repository.getComments(feedPost)
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/usecases/GetCommentUseCase.kt | 1704557115 |
package com.example.firstcomposeproject.domain.usecases
import com.example.firstcomposeproject.domain.Repository
import com.example.firstcomposeproject.domain.entities.AuthState
import kotlinx.coroutines.flow.StateFlow
import javax.inject.Inject
class GetAuthStateUseCase @Inject constructor(
private val repository: Repository
) {
operator fun invoke(): StateFlow<AuthState> {
return repository.getAuthStateFlow()
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/usecases/GetAuthStateUseCase.kt | 374605641 |
package com.example.firstcomposeproject.domain.usecases
import com.example.firstcomposeproject.domain.Repository
import com.example.firstcomposeproject.domain.entities.FeedPost
import javax.inject.Inject
class ChangeLikeStatusUseCase @Inject constructor(
private val repository: Repository
) {
suspend operator fun invoke(feedPost: FeedPost) = repository.changeLikeStatus(feedPost)
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/usecases/ChangeLikeStatusUseCase.kt | 377870822 |
package com.example.firstcomposeproject.domain.usecases
import com.example.firstcomposeproject.domain.Repository
import com.example.firstcomposeproject.domain.entities.FeedPost
import kotlinx.coroutines.flow.StateFlow
import javax.inject.Inject
class GetRecommendationsUseCase @Inject constructor(
private val repository: Repository
) {
operator fun invoke(): StateFlow<List<FeedPost>> {
return repository.getRecommendations()
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/usecases/GetRecommendationsUseCase.kt | 3719228939 |
package com.example.firstcomposeproject.domain.entities
data class PostComment(
val id: Long,
val authorName: String,
val authorAvatarUrl: String,
val commentText: String,
val publicationDate: String
) | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/entities/PostComment.kt | 1801889498 |
package com.example.firstcomposeproject.domain.entities
data class FeedPost(
val id: Long,
val communityId: Long,
val communityName: String = "/dev/null",
val publicationDate: String = "14:00",
val communityImageUrl: String,
val contentText: String,
val contentImageUrl: String?,
val statistics: MutableMap<StatisticType, Int> = hashMapOf(
StatisticType.VIEWS to 111,
StatisticType.LIKES to 444,
StatisticType.SHARES to 222,
StatisticType.COMMENTS to 333
),
val isLiked: Boolean
)
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/entities/FeedPost.kt | 2464271120 |
package com.example.firstcomposeproject.domain.entities
enum class StatisticType {
VIEWS, SHARES, COMMENTS, LIKES
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/entities/StatisticType.kt | 115669099 |
package com.example.firstcomposeproject.domain.entities
sealed class AuthState {
object Authorized: AuthState()
object NotAuthorized: AuthState()
object Initial: AuthState()
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/domain/entities/AuthState.kt | 3782721115 |
package com.example.firstcomposeproject.presentation.comments
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.domain.entities.PostComment
sealed class CommentScreenState{
object Initial : CommentScreenState()
data class Comments(
val feedPost: FeedPost,
val comments: List<PostComment>
): CommentScreenState()
}
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/comments/CommentScreenState.kt | 2810241775 |
package com.example.firstcomposeproject.presentation.comments
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.rounded.ArrowBack
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import coil.compose.AsyncImage
import com.example.firstcomposeproject.R
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.domain.entities.PostComment
import com.example.firstcomposeproject.presentation.NewsFeedApplication
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun CommentScreen(
feedPost: FeedPost,
backPressed: () -> Unit
) {
val component = (LocalContext.current.applicationContext as NewsFeedApplication)
.component
.getCommentsScreenComponentFactory()
.create(feedPost)
val viewModel: CommentViewModel = viewModel(factory = component.getViewModelFactory())
val screenState = viewModel.screenState.collectAsState(CommentScreenState.Initial)
val currentState = screenState.value
if (currentState is CommentScreenState.Comments) {
Scaffold(
topBar = {
TopAppBar(
title = {
Text(
text = stringResource(R.string.comments),
color = MaterialTheme.colorScheme.primary,
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
},
navigationIcon = {
IconButton(onClick = { backPressed() }) {
Icon(
imageVector = Icons.Rounded.ArrowBack,
contentDescription = stringResource(R.string.button_back_to_posts),
tint = MaterialTheme.colorScheme.primary
)
}
}
)
}
) { paddingValues ->
LazyColumn(
modifier = Modifier.padding(paddingValues),
contentPadding = PaddingValues(
top = 16.dp,
bottom = 72.dp,
start = 8.dp,
end = 8.dp
)
) {
items(
items = currentState.comments,
key = { it.id }
) { item ->
Comment(item)
}
}
}
}
}
@Composable
private fun Comment(comment: PostComment) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 8.dp)
) {
AsyncImage(
modifier = Modifier
.size(48.dp)
.clip(CircleShape)
,
model = comment.authorAvatarUrl,
contentDescription = null
)
Spacer(modifier = Modifier.width(8.dp))
Column {
Text(
text = comment.authorName,
color = MaterialTheme.colorScheme.primary
)
Spacer(modifier = Modifier.width(8.dp))
Text(
text = comment.commentText,
color = MaterialTheme.colorScheme.primary
)
Spacer(modifier = Modifier.width(8.dp))
Text(
text = comment.publicationDate,
color = MaterialTheme.colorScheme.secondary
)
}
}
}
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/comments/CommentScreen.kt | 184645346 |
package com.example.firstcomposeproject.presentation.comments
import androidx.lifecycle.ViewModel
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.domain.usecases.GetCommentUseCase
import kotlinx.coroutines.flow.map
import javax.inject.Inject
class CommentViewModel @Inject constructor(
private val feedPost: FeedPost,
private val getCommentUseCase: GetCommentUseCase
) : ViewModel() {
val screenState = getCommentUseCase(feedPost)
.map {
CommentScreenState.Comments(
feedPost = feedPost,
comments = it
)
}
}
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/comments/CommentViewModel.kt | 2934069147 |
package com.example.firstcomposeproject.presentation
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import javax.inject.Inject
import javax.inject.Provider
class ViewModelFactory @Inject constructor(
private val viewModelProviders: @JvmSuppressWildcards Map<Class<out ViewModel>, Provider<ViewModel>>
) : ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
return viewModelProviders[modelClass]?.get() as T
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/ViewModelFactory.kt | 1645718160 |
package com.example.firstcomposeproject.presentation
import android.app.Application
import com.example.firstcomposeproject.di.ApplicationComponent
import com.example.firstcomposeproject.di.DaggerApplicationComponent
class NewsFeedApplication : Application() {
val component: ApplicationComponent by lazy {
DaggerApplicationComponent.factory().create(this)
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/NewsFeedApplication.kt | 747720315 |
package com.example.firstcomposeproject.presentation.news
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.rounded.MoreVert
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Icon
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.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import coil.compose.AsyncImage
import com.example.firstcomposeproject.R
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.domain.entities.StatisticType
import com.example.firstcomposeproject.ui.theme.DarkRed
@Composable
fun PostCard(
modifier: Modifier = Modifier,
feedPost: FeedPost,
onCommentClickListener: (StatisticType) -> Unit,
onLikeClickListener: (StatisticType) -> Unit
) {
Card(
modifier = modifier,
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.onSecondary)
) {
Column (
modifier = Modifier.padding(8.dp)
) {
PostTop(feedPost)
Spacer(modifier = Modifier.height(8.dp))
Text(
text = feedPost.contentText,
color = MaterialTheme.colorScheme.onPrimary
)
Spacer(modifier = Modifier.height(8.dp))
AsyncImage(
model = feedPost.contentImageUrl,
modifier = Modifier
.fillMaxWidth()
.wrapContentHeight(),
contentDescription = null,
contentScale = ContentScale.FillWidth
)
Spacer(modifier = Modifier.height(8.dp))
PostBottom(
feedPost,
onCommentClickListener = onCommentClickListener,
onLikeClickListener = onLikeClickListener,
isFavourite = feedPost.isLiked
)
}
}
}
@Composable
fun PostAvatar(feedPost: FeedPost) {
Row (
horizontalArrangement = Arrangement.Start,
verticalAlignment = Alignment.CenterVertically
) {
AsyncImage(
model = feedPost.communityImageUrl,
modifier = Modifier
.size(50.dp)
.clip(CircleShape),
contentDescription = null
)
Column(
modifier = Modifier.padding(5.dp),
horizontalAlignment = Alignment.Start
) {
Text(
text = feedPost.communityName,
color = MaterialTheme.colorScheme.onPrimary,
fontSize = 16.sp,
fontWeight = FontWeight.Normal,
)
Text(
text = feedPost.publicationDate,
color = MaterialTheme.colorScheme.onPrimary,
fontWeight = FontWeight.Normal,
fontSize = 16.sp
)
}
}
}
@Composable
fun PostTop(feedPost: FeedPost) {
Row (
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
){
PostAvatar(feedPost)
Icon (
imageVector = Icons.Rounded.MoreVert,
contentDescription = null,
tint = MaterialTheme.colorScheme.onSecondary
)
}
}
@Composable
fun PostBottom(
feedPost: FeedPost,
onCommentClickListener: (StatisticType) -> Unit,
onLikeClickListener: (StatisticType) -> Unit,
isFavourite: Boolean
) {
Row (
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
){
Row {
Row(
modifier = Modifier.weight(4f)
) {
IconWithText(feedPost,
StatisticType.VIEWS,
R.drawable.ic_views_count,
)
}
Row(
modifier = Modifier.weight(5f),
Arrangement.SpaceEvenly
) {
IconWithText(feedPost, StatisticType.SHARES, R.drawable.ic_share)
IconWithText(feedPost, StatisticType.COMMENTS, R.drawable.ic_comment,
onItemClickListener = {
onCommentClickListener(StatisticType.COMMENTS)
}
)
IconWithText(
feedPost = feedPost,
type = StatisticType.LIKES,
iconResId = if (isFavourite) R.drawable.ic_like_set else R.drawable.ic_like,
onItemClickListener = {
onLikeClickListener(StatisticType.LIKES)
},
tint = if (isFavourite) DarkRed else MaterialTheme.colorScheme.onPrimary
)
}
}
}
}
private fun formatStatisticCount(count: Int): String {
return if (count > 100_000) {
String.format("%sK", (count / 1000))
} else if (count > 1000) {
String.format("%.1fK", (count / 1000f))
} else {
count.toString()
}
}
@Composable
fun IconWithText(
feedPost: FeedPost,
type: StatisticType,
iconResId: Int,
onItemClickListener: (() -> Unit)? = null,
tint: Color = MaterialTheme.colorScheme.onPrimary
) {
val modifier = if (onItemClickListener == null) {
Modifier
} else {
Modifier.clickable {
onItemClickListener()
}
}
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = modifier
) {
Icon(
painter = painterResource(id = iconResId),
contentDescription = null,
tint = tint,
)
Spacer(modifier = Modifier.width(5.dp))
val count = feedPost.statistics[type] ?: 0
Text(
text = formatStatisticCount(count),
color = MaterialTheme.colorScheme.onPrimary
)
}
}
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/news/PostCard.kt | 2326514542 |
package com.example.firstcomposeproject.presentation.news
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.DismissDirection
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.SwipeToDismiss
import androidx.compose.material3.rememberDismissState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.presentation.ViewModelFactory
import com.example.firstcomposeproject.ui.theme.DarkBlue
@Composable
fun NewsFeedScreen(
viewModelFactory: ViewModelFactory,
paddingValues: PaddingValues,
onCommentClickListener: (FeedPost) -> Unit
) {
val viewModel: NewsFeedViewModel = viewModel(factory = viewModelFactory)
val screenState = viewModel.screenState.collectAsState(NewsFeedScreenState.Initial)
when(val currentState = screenState.value) {
is NewsFeedScreenState.Posts -> {
FeedPosts(
viewModel = viewModel,
paddingValues = paddingValues,
posts = currentState.posts,
onCommentClickListener = onCommentClickListener,
nextDataIsLoading = currentState.nextDataIsLoading
)
}
NewsFeedScreenState.Initial -> {}
NewsFeedScreenState.Loading -> {
Box(
modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center
) {
CircularProgressIndicator(color = DarkBlue)
}
}
}
}
@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
@Composable
private fun FeedPosts(
viewModel: NewsFeedViewModel,
paddingValues: PaddingValues,
posts: List<FeedPost>,
onCommentClickListener: (FeedPost) -> Unit,
nextDataIsLoading: Boolean
) {
LazyColumn(
modifier = Modifier.padding(paddingValues),
contentPadding = PaddingValues(
top = 16.dp, start = 8.dp, end = 8.dp, bottom = 16.dp
),
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
items(items = posts, key = { it.id }) { feedPost ->
val dismissState = rememberDismissState()
if (dismissState.isDismissed(DismissDirection.EndToStart)) {
viewModel.delete(feedPost)
}
SwipeToDismiss(
modifier = Modifier.animateItemPlacement(),
state = dismissState,
background = {},
directions = setOf(DismissDirection.EndToStart),
dismissContent = {
PostCard(
feedPost = feedPost,
onCommentClickListener = {
onCommentClickListener(feedPost)
},
onLikeClickListener = {
viewModel.changeLikeStatus(feedPost)
}
)
}
)
}
item {
if (nextDataIsLoading) {
Box(
modifier = Modifier
.fillMaxWidth()
.wrapContentHeight()
.padding(16.dp),
contentAlignment = Alignment.Center,
) {
CircularProgressIndicator(color = DarkBlue)
}
} else {
SideEffect {
viewModel.loadNextRecommendations()
}
}
}
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/news/NewsFeedScreen.kt | 204829044 |
package com.example.firstcomposeproject.presentation.news
import android.util.Log
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.firstcomposeproject.data.extensions.mergeWith
import com.example.firstcomposeproject.domain.entities.FeedPost
import com.example.firstcomposeproject.domain.usecases.ChangeLikeStatusUseCase
import com.example.firstcomposeproject.domain.usecases.DeletePostUseCase
import com.example.firstcomposeproject.domain.usecases.GetRecommendationsUseCase
import com.example.firstcomposeproject.domain.usecases.LoadNextDataUseCase
import kotlinx.coroutines.CoroutineExceptionHandler
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.onStart
import kotlinx.coroutines.launch
import javax.inject.Inject
class NewsFeedViewModel @Inject constructor(
private val getRecommendationsUseCase: GetRecommendationsUseCase,
private val loadNextDataUseCase: LoadNextDataUseCase,
private val changeLikeStatusUseCase: ChangeLikeStatusUseCase,
private val deletePostUseCase: DeletePostUseCase,
) : ViewModel() {
private val exceptionHandler = CoroutineExceptionHandler { _, _ ->
Log.d("NewsFeedViewModel", "Exception caught by exception handler")
}
private val recommendationsFlow = getRecommendationsUseCase()
private val loadNextDataFlow = MutableSharedFlow<NewsFeedScreenState>()
val screenState = recommendationsFlow
.filter { it.isNotEmpty() }
.map { NewsFeedScreenState.Posts(posts = it) as NewsFeedScreenState }
.onStart { emit(NewsFeedScreenState.Loading) }
.mergeWith(loadNextDataFlow)
fun loadNextRecommendations() {
viewModelScope.launch {
loadNextDataFlow.emit(
NewsFeedScreenState.Posts(
posts = recommendationsFlow.value,
nextDataIsLoading = true
)
)
loadNextDataUseCase()
}
}
fun changeLikeStatus(feedPost: FeedPost) {
viewModelScope.launch(exceptionHandler) {
changeLikeStatusUseCase(feedPost)
}
}
fun delete(feedPost: FeedPost) {
viewModelScope.launch(exceptionHandler) {
deletePostUseCase(feedPost)
}
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/news/NewsFeedViewModel.kt | 1268616764 |
package com.example.firstcomposeproject.presentation.news
import com.example.firstcomposeproject.domain.entities.FeedPost
sealed class NewsFeedScreenState {
object Initial: NewsFeedScreenState()
object Loading : NewsFeedScreenState()
data class Posts(
val posts: List<FeedPost>,
val nextDataIsLoading: Boolean = false
) : NewsFeedScreenState()
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/news/NewsFeedScreenState.kt | 2855005642 |
package com.example.firstcomposeproject.presentation.main
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.firstcomposeproject.domain.usecases.CheckAuthStateUseCase
import com.example.firstcomposeproject.domain.usecases.GetAuthStateUseCase
import kotlinx.coroutines.launch
import javax.inject.Inject
class MainViewModel @Inject constructor(
private val getAuthStateFlowUseCase: GetAuthStateUseCase,
private val checkAuthStateUseCase: CheckAuthStateUseCase,
) : ViewModel() {
val authState = getAuthStateFlowUseCase()
fun performAuthResult() {
viewModelScope.launch {
checkAuthStateUseCase()
}
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/main/MainViewModel.kt | 3516437384 |
package com.example.firstcomposeproject.presentation.main
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.compose.runtime.collectAsState
import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.firstcomposeproject.domain.entities.AuthState
import com.example.firstcomposeproject.presentation.NewsFeedApplication
import com.example.firstcomposeproject.presentation.ViewModelFactory
import com.example.firstcomposeproject.ui.theme.FirstComposeProjectTheme
import com.vk.api.sdk.VK
import com.vk.api.sdk.auth.VKScope
import javax.inject.Inject
class MainActivity : ComponentActivity() {
@Inject
lateinit var viewModelFactory: ViewModelFactory
private val component by lazy {
(application as NewsFeedApplication).component
}
override fun onCreate(savedInstanceState: Bundle?) {
component.inject(this)
super.onCreate(savedInstanceState)
setContent {
FirstComposeProjectTheme {
val viewModel: MainViewModel = viewModel(factory = viewModelFactory)
val authState = viewModel.authState.collectAsState(AuthState.Initial)
val launcher = rememberLauncherForActivityResult(
contract = VK.getVKAuthActivityResultContract()
) {
viewModel.performAuthResult()
}
when (authState.value) {
is AuthState.Authorized -> {
MainScreen(viewModelFactory)
}
is AuthState.NotAuthorized -> {
LoginScreen {
launcher.launch(listOf(VKScope.WALL, VKScope.FRIENDS))
}
}
else -> {
}
}
}
}
}
}
| P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/main/MainActivity.kt | 4228716936 |
package com.example.firstcomposeproject.presentation.main
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.outlined.Favorite
import androidx.compose.material.icons.outlined.Home
import androidx.compose.material.icons.outlined.Person
import androidx.compose.ui.graphics.vector.ImageVector
import com.example.firstcomposeproject.R
import com.example.firstcomposeproject.navigation.Screen
sealed class NavigationItem (
val screen: Screen,
val titleResId: Int,
val icon: ImageVector
) {
object Home: NavigationItem(
screen = Screen.NewsFeed,
titleResId = R.string.navigation_item_main,
icon = Icons.Outlined.Home
)
object Favorites: NavigationItem(
screen = Screen.Favorites,
titleResId = R.string.navigation_item_favorites,
icon = Icons.Outlined.Favorite
)
object Person: NavigationItem(
screen = Screen.Profile,
titleResId = R.string.navigation_item_person,
icon = Icons.Outlined.Person
)
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/main/NavigationItem.kt | 385046944 |
package com.example.firstcomposeproject.presentation.main
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.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
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.res.stringResource
import androidx.compose.ui.unit.dp
import com.example.firstcomposeproject.R
import com.example.firstcomposeproject.ui.theme.DarkBlue
@Composable
fun LoginScreen(
onLoginClick: () -> Unit
) {
Box(
modifier = Modifier.fillMaxSize(),
contentAlignment = Alignment.Center
) {
Column(
modifier = Modifier.wrapContentHeight(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Image(
modifier = Modifier.size(100.dp),
painter = painterResource(id = R.drawable.vk_logo),
contentDescription = null
)
Spacer(modifier = Modifier.height(100.dp))
Button(
colors = ButtonDefaults.buttonColors(
containerColor = DarkBlue,
contentColor = Color.White
),
onClick = { onLoginClick() }
) {
Text(text = stringResource(R.string.enter))
}
}
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/main/LoginScreen.kt | 543831182 |
package com.example.firstcomposeproject.presentation.main
import android.annotation.SuppressLint
import android.util.Log
import androidx.compose.material3.BottomAppBar
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.NavigationBarItem
import androidx.compose.material3.NavigationBarItemDefaults
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.res.stringResource
import androidx.navigation.compose.currentBackStackEntryAsState
import com.example.firstcomposeproject.navigation.AppNavGraph
import com.example.firstcomposeproject.navigation.rememberNavigationState
import com.example.firstcomposeproject.presentation.ViewModelFactory
import com.example.firstcomposeproject.presentation.comments.CommentScreen
import com.example.firstcomposeproject.presentation.news.NewsFeedScreen
@SuppressLint("UnusedMaterialScaffoldPaddingParameter", "UnusedMaterial3ScaffoldPaddingParameter")
@Composable
fun MainScreen(viewModelFactory: ViewModelFactory) {
val navigationState = rememberNavigationState()
Scaffold (
containerColor = MaterialTheme.colorScheme.onSecondary,
bottomBar = {
BottomAppBar {
val navBackStackEntry by navigationState.navHostController.currentBackStackEntryAsState()
val currentRoute = navBackStackEntry?.destination?.route
val items = listOf(
NavigationItem.Home,
NavigationItem.Favorites,
NavigationItem.Person
)
items.forEach{item ->
NavigationBarItem(
selected = (currentRoute == item.screen.route),
onClick = { navigationState.navigateTo(item.screen.route)},
icon = {
Icon(item.icon, contentDescription = null)
},
label = { Text(text = stringResource(id = item.titleResId))},
colors = NavigationBarItemDefaults.colors(
selectedIconColor = MaterialTheme.colorScheme.onPrimary,
selectedTextColor = MaterialTheme.colorScheme.onPrimary,
unselectedIconColor = MaterialTheme.colorScheme.onSecondary,
unselectedTextColor = MaterialTheme.colorScheme.onSecondary
)
)
}
}
}
) { paddingValues ->
AppNavGraph(
navHostController = navigationState.navHostController,
newsFeedScreenContent = {
NewsFeedScreen(
viewModelFactory = viewModelFactory,
paddingValues = paddingValues,
onCommentClickListener = {
navigationState.navigateToComments(it)
}
)
},
commentScreenContent = {feedPost ->
Log.d("MATAG", "feedPost = $feedPost")
CommentScreen(
feedPost = feedPost,
backPressed = {
navigationState.navHostController.popBackStack()
}
)
},
favoritesScreenContent = { Text(text = "Favorites")},
profileScreenContent = { Text(text = "Profile")}
)
}
} | P0012_FirstComposeProject/app/src/main/java/com/example/firstcomposeproject/presentation/main/MainScreen.kt | 530702882 |
package com.muhammadsayed.fancyslider
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.muhammadsayed.fancyslider", appContext.packageName)
}
} | FancySlider/app/src/androidTest/java/com/muhammadsayed/fancyslider/ExampleInstrumentedTest.kt | 636005233 |
package com.muhammadsayed.fancyslider
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)
}
} | FancySlider/app/src/test/java/com/muhammadsayed/fancyslider/ExampleUnitTest.kt | 1505435790 |
package com.muhammadsayed.fancyslider.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) | FancySlider/app/src/main/java/com/muhammadsayed/fancyslider/ui/theme/Color.kt | 1769887058 |
package com.muhammadsayed.fancyslider.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 FancySliderTheme(
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
)
} | FancySlider/app/src/main/java/com/muhammadsayed/fancyslider/ui/theme/Theme.kt | 2608195787 |
package com.muhammadsayed.fancyslider.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
)
*/
) | FancySlider/app/src/main/java/com/muhammadsayed/fancyslider/ui/theme/Type.kt | 601477436 |
package com.muhammadsayed.fancyslider
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.animation.animateColorAsState
import androidx.compose.animation.core.animateDpAsState
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.animation.core.tween
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.detectDragGestures
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.offset
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.pager.HorizontalPager
import androidx.compose.foundation.pager.PagerState
import androidx.compose.foundation.pager.rememberPagerState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Clear
import androidx.compose.material3.Icon
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.mutableFloatStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.drawBehind
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Path
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalConfiguration
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.IntOffset
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.util.lerp
import androidx.compose.ui.zIndex
import com.muhammadsayed.fancyslider.ui.theme.FancySliderTheme
import kotlin.math.roundToInt
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
FancySliderTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
FancySlider()
}
}
}
}
}
@OptIn(ExperimentalFoundationApi::class)
@Composable
fun FancySlider() {
// ACTUAL OFFSET
fun PagerState.offsetForPage(page: Int) = (currentPage - page) + currentPageOffsetFraction
val pagesTotal = 12
val configuration = LocalConfiguration.current
val screenWidth = configuration.screenWidthDp.dp
val distance = screenWidth / 6 / 2
val indicatorSize = 40
val pagerState = rememberPagerState(pageCount = { 12 })
var offsetX by remember { mutableFloatStateOf(0f) }
var progress by remember {
mutableFloatStateOf(0f)
}
var isDragging by remember {
mutableStateOf(false)
}
val duration = 100
val colorRed =
animateColorAsState(
targetValue = if (isDragging) Color(0xFFEBEBEB)
else Color(0xFFFD98C6), label = "Red Color Animation",
animationSpec = tween(durationMillis = duration)
)
val colorGreen =
animateColorAsState(
targetValue = if (isDragging) Color(0xFFEBEBEB)
else Color(0xFF59D0C7), label = "Green Color Animation",
animationSpec = tween(durationMillis = duration)
)
val sizeAnimation = animateDpAsState(
targetValue = if (isDragging) Dp(35f) else Dp(45f),
label = "Size Animation",
animationSpec = tween(durationMillis = duration)
)
LaunchedEffect(key1 = progress) {
pagerState.animateScrollToPage((progress * 12).roundToInt() + 1)
}
Column(
Modifier
.fillMaxSize()
.background(Color(0xFF1A8DFB))
) {
Spacer(modifier = Modifier.height(30.dp))
Text(
text = "month",
fontSize = 30.sp,
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center, color = Color.White
)
Spacer(modifier = Modifier.height(10.dp))
HorizontalPager(
pagerState,
pageSpacing = -(300.dp),
modifier = Modifier.weight(1f),
userScrollEnabled = false,
) { page ->
Box(
contentAlignment = Alignment.Center,
modifier = Modifier
.zIndex(page.toFloat() * 12)
.graphicsLayer {
val pageOffset = pagerState.offsetForPage(page)
translationX = -pageOffset * 400
alpha = lerp(
start = 0.1f,
stop = 1f,
fraction = 0.8f - pageOffset.coerceIn(0f, 1f)
)
scaleX = 1f + pageOffset * 0.9f
scaleY = 1f + pageOffset * 0.9f
}
) {
Text(
text = "${page + 1}",
fontSize = 200.sp,
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center,
color = Color.White
)
}
}
Row(
Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceEvenly
) {
Icon(
Icons.Default.Clear,
tint = Color.White,
contentDescription = null,
modifier = Modifier
.size(sizeAnimation.value)
.drawBehind {
drawCircle(color = colorRed.value)
})
Icon(
Icons.Default.Check,
tint = Color.White,
contentDescription = null,
modifier = Modifier
.size(sizeAnimation.value)
.drawBehind {
drawCircle(color = colorGreen.value)
})
}
Spacer(modifier = Modifier.height(indicatorSize.dp + 20.dp))
Row(
horizontalArrangement = Arrangement.SpaceAround,
modifier = Modifier.fillMaxWidth()
) {
val numberDuration = 150
repeat(pagesTotal) {
val isAroundCurrentPage =
((progress * 12f) + 1 in it - 0.75f..it + 0.75f)
val animation by animateDpAsState(
targetValue =
if (isAroundCurrentPage)
-Dp(indicatorSize.toFloat() / 2) - Dp(3f)
else
Dp(0f),
label = "Offset Animation", animationSpec = tween(numberDuration)
)
val scale by animateFloatAsState(
targetValue = if (isAroundCurrentPage) 1.5f else 1f,
label = "Scale Animation", animationSpec = tween(numberDuration)
)
if (it % 2 == 1) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier
.offset(y = animation)
.graphicsLayer {
if (isAroundCurrentPage) {
scaleX = scale
scaleY = scale
}
}
) {
Text(
text = "${(it + 1)}",
fontSize = 16.sp,
textAlign = TextAlign.Center,
color = if (isAroundCurrentPage) Color.White else Color.White.copy(
alpha = 0.5f
)
)
Spacer(modifier = Modifier.height(3.dp))
Spacer(
modifier = Modifier
.width(1.dp)
.height(7.dp)
.background(
if (isAroundCurrentPage) Color.White else Color.White.copy(
alpha = 0.5f
)
)
)
}
}
}
}
Box(
modifier = Modifier
.background(Color.White)
.fillMaxWidth()
.height(150.dp)
) {
Box(
modifier = Modifier
.fillMaxWidth()
.offset(y = -(1.dp))
.height((indicatorSize / 2).dp)
.background(Color(0xFF1A8DFB))
)
//thumb
Box(modifier = Modifier
.offset {
IntOffset(
offsetX.roundToInt() - (distance.roundToPx() / 2) + 5,
30
)
}
.height(indicatorSize.dp / 2)
.width(distance * 2)
.drawBehind {
val curveWidth = 60
val path = Path().apply {
val topRight = Offset(size.width, 0f)
val bottomLeft = Offset(0f, size.height)
val bottomRight = Offset(size.width, size.height)
moveTo(bottomLeft.x - curveWidth, bottomLeft.y)
// Draw curve
val controlPointX1 = (topRight.x) / 2
val controlPointY1 = -(topRight.x) / 2
val endPointX = topRight.x + curveWidth
val endPointY = bottomRight.y
cubicTo(
controlPointX1,
controlPointY1,
controlPointX1,
controlPointY1,
endPointX,
endPointY
)
lineTo(bottomLeft.x, bottomLeft.y)
close()
}
drawPath(
path = path,
color = Color.White,
)
})
// indicator circle
Box(modifier = Modifier
.offset { IntOffset(offsetX.roundToInt(), 0) }
.size(indicatorSize.dp)
.shadow(5.dp, shape = CircleShape)
.background(
shape = CircleShape,
color = Color.White
)
.graphicsLayer {
//set initial offsetX
offsetX = distance.toPx() - (indicatorSize / 2).dp.toPx()
}
.pointerInput(Unit) {
distance.toPx() - (indicatorSize / 2).dp.toPx()
detectDragGestures(onDragEnd = {
isDragging = false
}, onDrag = { change, dragAmount ->
isDragging = true
change.consume()
offsetX = (offsetX + dragAmount.x)
.coerceIn(
-indicatorSize.dp.toPx() / 2,//distance.toPx() - (indicatorSize / 2).dp.toPx(),
screenWidth.toPx() - indicatorSize.dp.toPx() - distance.toPx() + (indicatorSize / 2).dp.toPx()
)
progress = (offsetX / screenWidth.toPx()).coerceIn(-0.1f, 1f)
})
}
)
}
}
}
@Preview
@Composable
private fun FancySliderPreview() {
FancySlider()
} | FancySlider/app/src/main/java/com/muhammadsayed/fancyslider/MainActivity.kt | 3941331132 |
package com.example.recyclerviews
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.recyclerviews", appContext.packageName)
}
} | RecyclerViews/app/src/androidTest/java/com/example/recyclerviews/ExampleInstrumentedTest.kt | 3780816842 |
package com.example.recyclerviews
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)
}
} | RecyclerViews/app/src/test/java/com/example/recyclerviews/ExampleUnitTest.kt | 3532142161 |
package com.example.recyclerviews
import androidx.lifecycle.ViewModel
class PlacesViewModel: ViewModel() {
private val places = mutableListOf<Place>(Place("Auckland", "it's pretty"), Place("Patagonia", "it's also pretty"))
fun getPlaces(): List<Place> {
return places
}
fun addNewPlace(place: Place, position: Int? = null): Int {
if (places.any { it.name.uppercase() == place.name.uppercase()}) {
return -1
}
return if (position != null) {
places.add(position, place)
position
} else {
places.add(place)
places.lastIndex
}
}
fun movePlace(from: Int, to: Int) {
val place = places.removeAt(from)
places.add(to, place)
}
fun deletePlace(position: Int): Place {
return places.removeAt(position)
}
} | RecyclerViews/app/src/main/java/com/example/recyclerviews/PlacesViewModel.kt | 3921024170 |
package com.example.recyclerviews
import android.content.Context
import android.content.Intent
import android.net.Uri
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.inputmethod.InputMethodManager
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
import androidx.lifecycle.ViewModelProvider
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.snackbar.Snackbar
class MainActivity : AppCompatActivity(), OnListItemClickedListener, OnDataChangedListener {
private lateinit var newPlaceEditText: EditText
// adding new var for the reason
private lateinit var newPlaceReasonEditText: EditText
private lateinit var addNewPlaceButton: Button
private lateinit var placeListRecyclerView: RecyclerView
private lateinit var placesRecyclerAdapter: PlaceRecyclerAdapter
private val placesListModel: PlacesViewModel by lazy {
ViewModelProvider(this).get(PlacesViewModel::class.java)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
newPlaceReasonEditText = findViewById(R.id.new_place_reason)
placeListRecyclerView = findViewById(R.id.place_list)
newPlaceEditText = findViewById(R.id.new_place_name)
addNewPlaceButton = findViewById(R.id.add_new_place_button)
val places = placesListModel.getPlaces()
placesRecyclerAdapter = PlaceRecyclerAdapter(places, this)
placeListRecyclerView.layoutManager = LinearLayoutManager(this)
placeListRecyclerView.adapter = placesRecyclerAdapter
ItemTouchHelper(OnListItemSwipeListener(this))
.attachToRecyclerView(placeListRecyclerView)
addNewPlaceButton.setOnClickListener {
addNewPlace()
}
}
private fun addNewPlace() {
// check if either the name or the reason are empty. if they are, prompt the user for both
// otherwise make a new place object and put it into the recycler
val name = newPlaceEditText.text.toString().trim()
val reason = newPlaceReasonEditText.text.toString().trim()
if (name.isEmpty()|| reason.isEmpty()) {
Toast.makeText(this, "Enter a place name, and a reason for going", Toast.LENGTH_SHORT).show()
} else {
val place = Place(name, reason)
val positionAdded = placesListModel.addNewPlace(place)
if (positionAdded == -1) {
Toast.makeText(this, "You already added that place", Toast.LENGTH_SHORT).show()
} else {
placesRecyclerAdapter.notifyItemInserted(positionAdded)
clearForm()
hideKeyboard()
}
}
}
private fun clearForm() {
newPlaceEditText.text.clear()
newPlaceReasonEditText.text.clear()
}
private fun hideKeyboard() {
this.currentFocus?.let { view ->
val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
imm?.hideSoftInputFromWindow(view.windowToken, 0)
}
}
override fun onListItemClicked(place: Place) {
val placeLocationUri = Uri.parse("geo:0,0?q=${place}")
val mapIntent = Intent(Intent.ACTION_VIEW, placeLocationUri)
startActivity(mapIntent)
}
override fun onListItemMoved(from: Int, to: Int) {
placesListModel.movePlace(from, to)
placesRecyclerAdapter.notifyItemMoved(from, to)
}
override fun onListItemDeleted(position: Int) {
val place = placesListModel.deletePlace(position)
placesRecyclerAdapter.notifyItemRemoved(position)
Snackbar.make(findViewById(R.id.container), getString(R.string.place_deleted, place.name), Snackbar.LENGTH_LONG)
.setAction(getString(R.string.undo_delete)) {
placesListModel.addNewPlace(place, position)
placesRecyclerAdapter.notifyItemInserted(position)
}
.show()
}
} | RecyclerViews/app/src/main/java/com/example/recyclerviews/MainActivity.kt | 2023397055 |
package com.example.recyclerviews
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import android.widget.ImageView
import androidx.recyclerview.widget.RecyclerView
interface OnListItemClickedListener {
fun onListItemClicked(place: Place)
}
class PlaceRecyclerAdapter(private val places: List<Place>,
private val onListItemClickedListener: OnListItemClickedListener):
RecyclerView.Adapter<PlaceRecyclerAdapter.ViewHolder>() {
inner class ViewHolder(private val view: View): RecyclerView.ViewHolder(view){
fun bind(place: Place) {
val placeNameText: TextView = view.findViewById(R.id.place_name)
placeNameText.text = place.name
val placeReasonText: TextView = view.findViewById(R.id.place_reason)
placeReasonText.text = place.reason
val dateCreatedOnText = view.findViewById<TextView>(R.id.date_place_added)
dateCreatedOnText.text = view.context.getString(R.string.created_on, place.formattedDate())
val mapIcon: ImageView = view.findViewById(R.id.map_icon)
mapIcon.setOnClickListener {
onListItemClickedListener.onListItemClicked(place)
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val view = LayoutInflater.from(parent.context).inflate(R.layout.place_list_item, parent, false)
return ViewHolder(view)
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
val place = places[position]
holder.bind(place)
}
override fun getItemCount(): Int {
return places.size
}
}
| RecyclerViews/app/src/main/java/com/example/recyclerviews/PlaceRecyclerAdapter.kt | 2003847965 |
package com.example.recyclerviews
import java.text.SimpleDateFormat
import java.util.*
data class Place(val name: String, val reason: String, val dateAdded: Date = Date()) {
fun formattedDate(): String {
return SimpleDateFormat("EEE, d MMMM yyy", Locale.getDefault()).format(dateAdded)
}
} | RecyclerViews/app/src/main/java/com/example/recyclerviews/Place.kt | 933743779 |
package com.example.recyclerviews
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.RecyclerView
interface OnDataChangedListener {
fun onListItemMoved(from:Int, to:Int)
fun onListItemDeleted(position: Int)
}
class OnListItemSwipeListener(private val onDataChangedListener: OnDataChangedListener):
ItemTouchHelper.SimpleCallback(
ItemTouchHelper.UP or ItemTouchHelper.DOWN,
ItemTouchHelper.RIGHT) {
override fun onMove(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
target: RecyclerView.ViewHolder
): Boolean {
val fromPosition = viewHolder.adapterPosition
val toPosition = target.adapterPosition
onDataChangedListener.onListItemMoved(fromPosition, toPosition)
return true
}
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
if (direction == ItemTouchHelper.RIGHT) {
onDataChangedListener.onListItemDeleted(viewHolder.adapterPosition)
}
}
}
| RecyclerViews/app/src/main/java/com/example/recyclerviews/OnListItemSwipeListener.kt | 3805388298 |
package com.example.lesson_2_5
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.lesson_2_5", appContext.packageName)
}
} | lesson_2_5/app/src/androidTest/java/com/example/lesson_2_5/ExampleInstrumentedTest.kt | 3963162178 |
package com.example.lesson_2_5
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)
}
} | lesson_2_5/app/src/test/java/com/example/lesson_2_5/ExampleUnitTest.kt | 1456000978 |
package com.example.lesson_2_5
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.bumptech.glide.Glide
import com.example.lesson_2_5.databinding.ActivityMainBinding
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
class MainActivity : AppCompatActivity() {
private lateinit var binding :ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
Glide.with(binding.loveImage).load("https://www.logos.com/grow/wp-content/uploads/2023/02/WxW-Love.png").into(binding.loveImage)
initClickers()
}
private fun initClickers() {
with(binding){
btnCalculate.setOnClickListener{
RetrofitService.api.getLove(etFirst.text.toString(), etSecond.text.toString())
.enqueue(object :Callback<LoveModel>{
override fun onResponse(
call: Call<LoveModel>,
response: Response<LoveModel>
) {
val intent = Intent(this@MainActivity, SecondActivity::class.java)
intent.putExtra("result", response.body()?.percentage.toString())
startActivity(intent)
}
override fun onFailure(call: Call<LoveModel>, t: Throwable) {
tvResult.text = t.message
}
})
}
}
}
} | lesson_2_5/app/src/main/java/com/example/lesson_2_5/MainActivity.kt | 3105038644 |
package com.example.lesson_2_5
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
object RetrofitService {
val retrofit = Retrofit.Builder().baseUrl("https://love-calculator.p.rapidapi.com")
.addConverterFactory(GsonConverterFactory.create()).build()
val api = retrofit.create(LoveApi::class.java)
} | lesson_2_5/app/src/main/java/com/example/lesson_2_5/RetrofitService.kt | 3475119349 |
package com.example.lesson_2_5
data class LoveModel(
val fname: String,
val sname: String,
val percentage: String,
val result: String
) | lesson_2_5/app/src/main/java/com/example/lesson_2_5/LoveModel.kt | 367728522 |
package com.example.lesson_2_5
import retrofit2.Call
import retrofit2.http.GET
import retrofit2.http.Header
import retrofit2.http.Query
interface LoveApi {
@GET("getPercentage")
fun getLove(
@Query("sname") secondName: String,
@Query("fname") firstName: String,
@Header("X-RapidAPI-Key") key: String = "7753737404msh1de34a18e6f9f85p107731jsne1168a9b8ff3",
@Header("X-RapidAPI-Host") host: String = "love-calculator.p.rapidapi.com",
): Call<LoveModel>
} | lesson_2_5/app/src/main/java/com/example/lesson_2_5/LoveApi.kt | 670267668 |
package com.example.lesson_2_5
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.bumptech.glide.Glide
import com.example.lesson_2_5.databinding.ActivitySecondBinding
class SecondActivity : AppCompatActivity() {
private lateinit var binding: ActivitySecondBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivitySecondBinding.inflate(layoutInflater)
setContentView(binding.root)
val intent = intent.getStringExtra("result")
binding.tvResult.text = intent
Glide.with(binding.loveImage).load("https://encrypted-tbn2.gstatic.com/images?q=tbn:ANd9GcSTELcBYiBtHk-wR6bYGyPdcP26ARO_yR-LjDR3pnQaZf4gRQ5b").into(binding.loveImage)
}
} | lesson_2_5/app/src/main/java/com/example/lesson_2_5/SecondActivity.kt | 1706522058 |
package com.example.app2
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.app2", appContext.packageName)
}
} | Radio/app/src/androidTest/java/com/example/app2/ExampleInstrumentedTest.kt | 4168859909 |
package com.example.app2
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)
}
} | Radio/app/src/test/java/com/example/app2/ExampleUnitTest.kt | 1980600484 |
package com.example.app2
import android.app.AlertDialog
import android.content.Context
import android.content.DialogInterface
import android.net.ConnectivityManager
import android.net.NetworkCapabilities
import android.os.Build
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.view.View
import android.webkit.WebView
import android.widget.Button
import android.widget.CompoundButton
import android.widget.ImageView
import android.widget.SeekBar
import android.widget.Switch
import android.widget.TextView
import androidx.core.content.ContextCompat.getSystemService
import androidx.lifecycle.ViewModelProvider.NewInstanceFactory.Companion.instance
import java.util.Locale
class Handler : View.OnClickListener, SeekBar.OnSeekBarChangeListener, CompoundButton.OnCheckedChangeListener,
DialogInterface.OnClickListener
{
private var am_stations = arrayOf("wfan","kabc","wbap","wls","karnam")
private var fm_stations = arrayOf("wxyt","kurb","wkim","wwtn","kdxe","karnfm","klal")
private var fm_nums = arrayOf(97.1,98.5,98.9,99.7,101.9,102.9,107.7)
private var am_nums = arrayOf(660,790,820,890,920)
private var setting = "am"
private var current = "" //current station. 'wxytfm' 'wabcam'
private var imageView = MainActivity.getInstance().findViewById<ImageView>(R.id.imageView)
private var textView = MainActivity.getInstance().findViewById<TextView>(R.id.textView)
override fun onClick(p0: DialogInterface?, p1: Int) {
if (p1 == DialogInterface.BUTTON_NEGATIVE)
{ }
else if (p1 == DialogInterface.BUTTON_POSITIVE)
{ }
}
override fun onClick(p0: View?) {
var wv : WebView = MainActivity.getInstance().findViewById<WebView>(R.id.webView)
if (current != ""){
var radio = "https://playerservices.streamtheworld.com/api/livestream-redirect/" +
current + setting + ".mp3"
//wv?.loadUrl("google.com")
wv.settings.javaScriptEnabled = true
wv.settings.userAgentString = "Mozilla/5.0 (Windows NT 5.1; rv:40.0) Gecko/20100101 Firefox/40.0"
wv?.loadUrl(radio)
//wv?.loadUrl("http://static.france24.com/live/F24_EN_LO_HLS/live_web.m3u8")
}
}
override fun onProgressChanged(p0: SeekBar?, p1: Int, p2: Boolean) {
var progress = p1 - 15
var newProgress : Double = 0.0
var margin = 6
if (setting == "am") {
newProgress = (540 + (11.6 * progress)) //convert 0-100 scale to am scale
progress = newProgress.toInt()
var index:Int = 0
var isChannel : Boolean = false
for(value in am_nums)
{
isChannel = (progress >= value - margin && progress < value + margin)
if(!isChannel)
current = ""
if(isChannel)
{
current = am_stations[index]
if(current.equals("karnam"))
current = "karn"
break
}
index++
}
/*when (progress) {
am_nums[0] -> current = am_stations[0]
am_nums[1] -> current = am_stations[1]
am_nums[2] -> current = am_stations[2]
am_nums[3] -> current = am_stations[3]
am_nums[4] -> current = am_stations[3]
else -> current = ""
}*/
}
else if (setting == "fm"){
progress = p1 + 6
newProgress = (88 + (0.2 * progress))//convert 0-100 scale to am scale
progress = newProgress.toInt()
margin = 1
var index:Int = 0
var isChannel : Boolean = false
for(value in fm_nums)
{
isChannel = (progress >= value - margin && progress < value + margin)
if(!isChannel)
current = ""
if(isChannel)
{
current = fm_stations[index]
if(current.equals("karnfm"))
current = "karn"
break
}
index++
}
/*when (progress) {
fm_nums[0] as Int -> current = fm_stations[0]
fm_nums[1] as Int-> current = fm_stations[1]
fm_nums[2] as Int-> current = fm_stations[2]
fm_nums[3] as Int-> current = fm_stations[3]
fm_nums[4] as Int-> current = fm_stations[4]
fm_nums[5] as Int-> current = fm_stations[5]
fm_nums[6] as Int-> current = fm_stations[6]
else -> current = ""
}*/
}
if (current != "") {
var id = MainActivity.getInstance().resources.getIdentifier(current, "drawable",MainActivity.getInstance().packageName)
imageView.setImageResource(id)
textView.setText(current.toUpperCase(Locale.getDefault()))
}
else {
var id = MainActivity.getInstance().resources.getIdentifier("launch", "drawable",MainActivity.getInstance().packageName)
imageView.setImageResource(id)
textView.setText("Now Playing...")
}
}
override fun onStartTrackingTouch(p0: SeekBar?) {
}
override fun onStopTrackingTouch(p0: SeekBar?) {
}
override fun onCheckedChanged(p0: CompoundButton?, p1: Boolean) {
var text = p0?.getText()
if (text == "AM") {
p0?.setText("FM")
setting = "fm"
}
else {
p0?.setText("AM")
setting = "am"
}
current = ""
var id = MainActivity.getInstance().resources.getIdentifier("launch", "drawable",MainActivity.getInstance().packageName)
imageView.setImageResource(id)
textView.setText("Now Playing...")
}
}
class MainActivity : AppCompatActivity() {
companion object
{
private var instance : MainActivity? = null
public fun getInstance() : MainActivity
{
return instance!!
}
}
/*override fun onResume(){
super.onResume()
//Change image
var id = MainActivity.getInstance().resources.getIdentifier("launch", "drawable",MainActivity.getInstance().packageName)
var image = findViewById<ImageView>(R.id.imageView)
image.setImageResource(id)
//Change text
var text = findViewById<TextView>(R.id.textView)
text.text = "Now Playing..."
//Change Seekbar
var seekBar = findViewById<SeekBar>(R.id.slider)
seekBar.progress = 0
//Change Switch
var switch = findViewById<Switch>(R.id.switch1)
switch.isChecked = true
}*/
fun checkInternetConnection(): Boolean
{
val cm = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
// Test for connection
cm.isDefaultNetworkActive
val networkInfo = isNetworkAvailable(this)//cm.isDefaultNetworkActive
if (networkInfo)
return true
else
return false
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
if (supportActionBar != null)
supportActionBar?.hide() //Hide Title Bar
setContentView(R.layout.activity_main)
instance = this
//create handler
var handler = Handler()
//if user doesn't have internet connection, create a warning dialog
var result = checkInternetConnection()
if (!result) {
//Display alert box
val dialogBuilder = AlertDialog.Builder(this)
dialogBuilder.setMessage("Not Connected To Internet")
dialogBuilder.setPositiveButton("OK",handler)
dialogBuilder.setNegativeButton("Cancel", handler)
val alert1 = dialogBuilder.create()
alert1.setTitle("No Internet")
alert1.show()
}
val slider = findViewById<SeekBar>(R.id.slider)
val switch1 = findViewById<Switch>(R.id.switch1)
val button = findViewById<Button>(R.id.button)
//Register Handler with UI
slider.setOnSeekBarChangeListener(handler)
switch1.setOnCheckedChangeListener(handler)
button.setOnClickListener(handler)
}
fun isNetworkAvailable(context: Context): Boolean {
var connectivityManager =
(context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
val network =
connectivityManager.activeNetwork // network is currently in a high power state for performing data transmission.
Log.d("Network", "active network $network")
network ?: return false // return false if network is null
val actNetwork = connectivityManager.getNetworkCapabilities(network)
?: return false // return false if Network Capabilities is null
return when {
actNetwork.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> { // check if wifi is connected
Log.d("Network", "wifi connected")
true
}
actNetwork.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> { // check if mobile dats is connected
Log.d("Network", "cellular network connected")
true
}
else -> {
Log.d("Network", "internet not connected")
false
}
}
}
return false;
}
}
| Radio/app/src/main/java/com/example/app2/MainActivity.kt | 492298041 |
package com.chokosoft.mealzapp
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.chokosoft.mealzapp", appContext.packageName)
}
} | MealzApp/app/src/androidTest/java/com/chokosoft/mealzapp/ExampleInstrumentedTest.kt | 1853476066 |
package com.chokosoft.mealzapp
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)
}
} | MealzApp/app/src/test/java/com/chokosoft/mealzapp/ExampleUnitTest.kt | 4144885237 |
package com.chokosoft.mealzapp.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) | MealzApp/app/src/main/java/com/chokosoft/mealzapp/ui/theme/Color.kt | 1759891025 |
package com.chokosoft.mealzapp.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 MealzAppTheme(
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
)
} | MealzApp/app/src/main/java/com/chokosoft/mealzapp/ui/theme/Theme.kt | 3395149429 |
package com.chokosoft.mealzapp.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
)
*/
) | MealzApp/app/src/main/java/com/chokosoft/mealzapp/ui/theme/Type.kt | 2223778249 |
package com.chokosoft.mealzapp.ui.meals
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.tooling.preview.Preview
import androidx.lifecycle.viewmodel.compose.viewModel
import com.chokosoft.mealzapp.model.response.MealResponse
import com.chokosoft.mealzapp.ui.theme.MealzAppTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MealzAppTheme {
MealsCategoriesScreen()
}
}
}
}
@Composable
fun MealsCategoriesScreen() {
val viewModel: MealsCategoriesViewModel = viewModel()
val rememberedMeals: MutableState<List<MealResponse>> = remember { mutableStateOf(emptyList<MealResponse>())
}
viewModel.getMeals { response ->
val meals = response?.categories
rememberedMeals.value = meals.orEmpty()
}
LazyColumn {
items(rememberedMeals.value) { meals->
Text(
text = meals.name
)
}
}
}
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
MealzAppTheme {
MealsCategoriesScreen()
}
} | MealzApp/app/src/main/java/com/chokosoft/mealzapp/ui/meals/MainActivity.kt | 1532853279 |
package com.chokosoft.mealzapp.ui.meals
import androidx.lifecycle.ViewModel
import com.chokosoft.mealzapp.model.MealsRepository
import com.chokosoft.mealzapp.model.response.MealResponse
import com.chokosoft.mealzapp.model.response.MealsCategoriesResponse
import retrofit2.Callback
class MealsCategoriesViewModel(private val repository: MealsRepository = MealsRepository()): ViewModel() {
fun getMeals(successCallback: (response: MealsCategoriesResponse?) -> Unit) {
repository.getMeals() { response ->
successCallback(response)
}
}
} | MealzApp/app/src/main/java/com/chokosoft/mealzapp/ui/meals/MealsCategoriesViewModel.kt | 722964867 |
package com.chokosoft.mealzapp.model.response
import com.google.gson.annotations.SerializedName
data class MealsCategoriesResponse(public val categories: List<MealResponse>) {
}
data class MealResponse(
@SerializedName("idCategory") val id: String,
@SerializedName("strCategory") val name: String,
@SerializedName("strCategoryDescription") val description: String,
@SerializedName("strCategoryThumb") val imageUrl: String
) | MealzApp/app/src/main/java/com/chokosoft/mealzapp/model/response/Responses.kt | 3283904120 |
package com.chokosoft.mealzapp.model
import com.chokosoft.mealzapp.model.api.MealsWebService
import com.chokosoft.mealzapp.model.response.MealsCategoriesResponse
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
// Gets and maps the data from the server.
class MealsRepository(private val webService: MealsWebService = MealsWebService()) {
fun getMeals(successCallback: (response: MealsCategoriesResponse?) -> Unit) {
return webService.getMeals().enqueue(object : Callback<MealsCategoriesResponse> {
override fun onResponse(
call: Call<MealsCategoriesResponse>,
response: Response<MealsCategoriesResponse>
) {
if (response.isSuccessful) {
successCallback(response.body())
}
}
override fun onFailure(call: Call<MealsCategoriesResponse>, t: Throwable) {
// TODO("Not yet implemented")
}
})
}
} | MealzApp/app/src/main/java/com/chokosoft/mealzapp/model/MealsRepository.kt | 1322432781 |
package com.chokosoft.mealzapp.model.api
import com.chokosoft.mealzapp.model.response.MealsCategoriesResponse
import retrofit2.Call
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.GET
class MealsWebService {
private lateinit var api: MealsApi
init {
val retrofit = Retrofit.Builder()
.baseUrl("https://www.themealdb.com/api/json/v1/1/")
.addConverterFactory(GsonConverterFactory.create())
.build()
api = retrofit.create(MealsApi::class.java)
}
fun getMeals(): Call<MealsCategoriesResponse> {
return api.getMeals()
}
interface MealsApi {
@GET("categories.php")
fun getMeals(): Call<MealsCategoriesResponse>
}
} | MealzApp/app/src/main/java/com/chokosoft/mealzapp/model/api/MealsWebService.kt | 3136285156 |
package com.example.bmicalculator
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.bmicalculator", appContext.packageName)
}
} | BMI-Calculater/src/androidTest/java/com/example/bmicalculator/ExampleInstrumentedTest.kt | 3931177402 |
package com.example.bmicalculator
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)
}
} | BMI-Calculater/src/test/java/com/example/bmicalculator/ExampleUnitTest.kt | 3134266843 |
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import androidx.core.content.ContextCompat
import com.example.bmicalculator.R
class MainActivity : AppCompatActivity() {
private lateinit var weightTxt: EditText
private lateinit var heightTxt: EditText
private lateinit var calBtn: Button
private lateinit var countTxt: TextView
private lateinit var resultTxt: TextView
private lateinit var rangeTxt: TextView
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
weightTxt = findViewById(R.id.wightEt)
heightTxt = findViewById(R.id.hightEt)
calBtn = findViewById(R.id.calBtn)
countTxt = findViewById(R.id.countTxt)
resultTxt = findViewById(R.id.resultTxt)
rangeTxt = findViewById(R.id.rangeTxt)
calBtn.setOnClickListener {
val weight = weightTxt.text.toString()
val height = heightTxt.text.toString()
if (validateInput(weight, height)) {
val bmi = weight.toFloat() / ((height.toFloat() / 100) * (height.toFloat() / 100))
val bmiDigit = String.format("%.2f", bmi).toFloat()
displayResult(bmiDigit)
}
}
}
private fun validateInput(weight: String?, height: String?): Boolean {
return when {
weight.isNullOrEmpty() -> {
Toast.makeText(this, "Weight is empty", Toast.LENGTH_LONG).show()
return false
}
height.isNullOrEmpty() -> {
Toast.makeText(this, "Height is empty", Toast.LENGTH_LONG).show()
return false
}
else -> {
return true
}
}
}
private fun displayResult(bmi: Float) {
countTxt.text = bmi.toString()
resultTxt.text = "You are healthy"
rangeTxt.text = "(Normal range is 18.5-24.5)"
var result = ""
var color = 0
var range = ""
when {
bmi < 18.50 -> {
result = "Underweight"
color = R.color.under_weight
range = "(Underweight range is less than 18.50)"
}
bmi in 18.50..24.99 -> {
result = "Healty"
color = R.color.normal
range = "(Healty range is 18.50-24.99)"
}
bmi in 25.00..29.99 -> {
result = "Overweight"
color = R.color.over_weight
range = "(Overweight range is 24.99-29.99)"
}
bmi > 29.99 -> {
result = "Obese"
color = R.color.obese
range = "(Obese range is greater than 29.99)"
}
}
resultTxt.setTextColor(ContextCompat.getColor(this, color))
resultTxt.text = result
rangeTxt.setTextColor(ContextCompat.getColor(this, color))
rangeTxt.text = range
}
} | BMI-Calculater/src/main/java/com/example/bmicalculator/MainActivity.kt | 1193414062 |
package com.example.posts
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class PostsApplicationTests {
@Test
fun contextLoads() {
}
}
| postsproject/src/test/kotlin/com/example/posts/PostsApplicationTests.kt | 1556985068 |
package com.example.posts
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class PostsApplication
fun main(args: Array<String>) {
runApplication<PostsApplication>(*args)
}
| postsproject/src/main/kotlin/com/example/posts/PostsApplication.kt | 4212491044 |
package com.example.posts.repositories
import com.example.posts.models.Comment
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository
@Repository
interface CommentRepository : JpaRepository<Comment, Long> {
}
| postsproject/src/main/kotlin/com/example/posts/repositories/CommentRepository.kt | 2943096629 |
package com.example.posts.repositories
import com.example.posts.models.Category
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository
@Repository
interface CategoryRepository : JpaRepository<Category, Long> {
}
| postsproject/src/main/kotlin/com/example/posts/repositories/CategoryRepository.kt | 3469957356 |
package com.example.posts.repositories
import com.example.posts.models.Post
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository
@Repository
interface PostRepository : JpaRepository<Post, Long> {
}
| postsproject/src/main/kotlin/com/example/posts/repositories/PostRepository.kt | 851053679 |
package com.example.posts.models
import com.fasterxml.jackson.annotation.JsonIgnore
import com.fasterxml.jackson.annotation.JsonProperty
import java.time.Instant
data class CommentDTO(
@JsonIgnore
val postId: Long,
@JsonProperty("contenido")
val content: String,
@JsonProperty("fecha_creacion")
val createdAt: Instant,
@JsonProperty("fecha_actualizacion")
val updatedAt: Instant,
) | postsproject/src/main/kotlin/com/example/posts/models/CommentDTO.kt | 1927404415 |
package com.example.posts.models
import com.fasterxml.jackson.annotation.JsonManagedReference
import jakarta.persistence.*
import org.hibernate.annotations.CreationTimestamp
import org.hibernate.annotations.UpdateTimestamp
import java.time.Instant
@Entity
@Table(name = "categoria")
data class Category(
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
val id: Long = 0,
@Column(name = "nombre", nullable = false, length = 150)
val name: String,
@Column(name = "fecha_creacion", nullable = false)
@CreationTimestamp
val createdAt: Instant,
@Column(name = "fecha_actualizacion", nullable = false)
@UpdateTimestamp
val updatedAt: Instant,
@OneToMany(mappedBy = "category", cascade = [CascadeType.ALL], fetch = FetchType.LAZY)
@JsonManagedReference
val posts: List<Post> = mutableListOf()
)
| postsproject/src/main/kotlin/com/example/posts/models/Category.kt | 1204514582 |
package com.example.posts.models
import com.fasterxml.jackson.annotation.JsonBackReference
import jakarta.persistence.*
import org.hibernate.annotations.CreationTimestamp
import org.hibernate.annotations.UpdateTimestamp
import java.time.Instant
@Entity
@Table(name = "comentario")
data class Comment(
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
val id: Long = 0,
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "post_id", nullable = false)
@JsonBackReference
val post: Post,
@Column(name = "contenido", nullable = false, length = 500)
val content: String,
@Column(name = "fecha_creacion", nullable = false)
@CreationTimestamp
val createdAt: Instant,
@Column(name = "fecha_actualizacion", nullable = false)
@UpdateTimestamp
val updatedAt: Instant,
)
| postsproject/src/main/kotlin/com/example/posts/models/Comment.kt | 2467793275 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.