content
stringlengths 0
13M
| path
stringlengths 4
263
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.pandey.shubham.katty.core.base
import com.pandey.shubham.katty.core.utils.DefaultScope
import kotlinx.coroutines.CoroutineScope
/**
* Created by shubhampandey
*/
abstract class UseCase<in T, out R> where R: Any {
abstract fun run(param: T?, scope: CoroutineScope): R
operator fun invoke(params: T? = null, scope: CoroutineScope = DefaultScope()): R = run(params, scope)
} | katty/app/src/main/java/com/pandey/shubham/katty/core/base/UseCase.kt | 1282508793 |
package com.pandey.shubham.katty.core.base
import android.view.ViewGroup
import androidx.paging.PagingDataAdapter
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
/**
* Created by shubhampandey
*/
abstract class BasePagingAdapter<T : Any, VH : RecyclerView.ViewHolder>(
diffCallback: DiffUtil.ItemCallback<T>) : PagingDataAdapter<T, VH>(diffCallback) {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VH {
return viewHolder(parent, viewType)
}
override fun onBindViewHolder(holder: VH, position: Int) {
}
abstract fun viewHolder(parent: ViewGroup, viewType: Int): VH
} | katty/app/src/main/java/com/pandey/shubham/katty/core/base/BasePagingAdapter.kt | 387549685 |
package com.pandey.shubham.katty.core.base
import android.content.Context
import android.util.AttributeSet
import android.widget.FrameLayout
import androidx.viewbinding.ViewBinding
/**
* Created by shubhampandey
*/
abstract class BaseCustomView<T : ViewBinding> @JvmOverloads constructor(
context: Context,
attributeSet: AttributeSet? = null,
defyStyle: Int = 0
) : FrameLayout(context, attributeSet, defyStyle) {
private val _binding: T by lazy { viewBinding() }
protected val binding: T get() = _binding
abstract fun viewBinding(): T
} | katty/app/src/main/java/com/pandey/shubham/katty/core/base/BaseCustomView.kt | 4178198721 |
package com.pandey.shubham.katty.core.base
import android.content.Context
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.content.ContextCompat
import androidx.fragment.app.Fragment
import androidx.viewbinding.ViewBinding
import com.google.android.material.snackbar.Snackbar
import com.pandey.shubham.katty.R
import com.pandey.shubham.katty.core.failure.model.ErrorMessage
/**
* Created by shubhampandey
*/
abstract class BaseFragment<VB: ViewBinding, T> : Fragment() {
private var _binding: VB? = null
protected open val binding: VB get() = _binding!!
private var _callback: T? = null
protected val callback: T? get() = _callback
private var snackbar: Snackbar? = null
@Suppress("UNCHECKED_CAST")
override fun onAttach(context: Context) {
super.onAttach(context)
if (parentFragment != null) {
this._callback = parentFragment as T
} else {
this._callback = context as T
}
}
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
_binding = viewBinding(inflater, container)
return _binding!!.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
populateViews()
attachListeners()
}
protected fun onBackPressed() {
requireActivity().onBackPressedDispatcher.onBackPressed()
}
internal fun showLoader() =
with(activity) {
if (this is NetworkLoaderActivity) showLoader()
}
internal fun hideLoader() =
with(activity) {
if (this is NetworkLoaderActivity) hideLoader()
}
internal fun showError(error: ErrorMessage, retryCallback: () -> Unit) =
with(activity) {
if (this is NetworkLoaderActivity) showError(error, retryCallback)
}
internal fun hideError() =
with(activity) {
if (this is NetworkLoaderActivity) hideError()
}
internal fun showActionSnackBar(
message: String,
actionText: String,
action: () -> Any
) {
snackbar = Snackbar.make(binding.root, message, Snackbar.LENGTH_INDEFINITE).apply {
setAction(actionText) { _ -> action.invoke() }
setActionTextColor(ContextCompat.getColor(requireContext(), R.color.black))
show()
}
}
internal fun showSnackBar(message: String, showTime: Int = Snackbar.LENGTH_SHORT) {
snackbar = Snackbar.make(binding.root, message, showTime).apply {
setActionTextColor(ContextCompat.getColor(requireContext(), R.color.black))
show()
}
}
internal fun hideActionSnackBar() {
snackbar?.dismiss()
}
protected abstract fun viewBinding(inflater: LayoutInflater, container: ViewGroup?): VB
protected abstract fun populateViews()
protected abstract fun attachListeners()
override fun onDestroy() {
super.onDestroy()
_binding = null
}
} | katty/app/src/main/java/com/pandey/shubham/katty/core/base/BaseFragment.kt | 726592093 |
package com.pandey.shubham.katty.core.base
import com.pandey.shubham.katty.core.failure.model.ErrorMessage
import com.pandey.shubham.katty.core.utils.gone
import com.pandey.shubham.katty.core.utils.visible
import com.pandey.shubham.katty.databinding.ActivityMainBinding
/**
* Created by shubhampandey
*/
abstract class NetworkLoaderActivity: com.pandey.shubham.katty.core.base.BaseActivity<ActivityMainBinding>() {
override fun viewBinding() = ActivityMainBinding.inflate(layoutInflater)
internal fun showLoader() {
binding.nwLoader.visible()
}
fun hideLoader() {
binding.nwLoader.gone()
}
fun showError(error: ErrorMessage, retryCallback: () -> Unit) {
binding.networkError.visible()
binding.networkError.setData(error, retryCallback)
}
fun hideError() {
binding.networkError.gone()
}
} | katty/app/src/main/java/com/pandey/shubham/katty/core/base/NetworkLoaderActivity.kt | 2177501773 |
package com.pandey.shubham.katty.core.widgets
import android.view.ViewGroup
import com.pandey.shubham.katty.R
import com.pandey.shubham.katty.core.base.BaseAdapter
import com.pandey.shubham.katty.core.base.BaseViewHolder
import com.pandey.shubham.katty.core.utils.inflater
import com.pandey.shubham.katty.core.utils.setNetworkImage
import com.pandey.shubham.katty.databinding.ItemCarouselImageBinding
/**
* Created by shubhampandey
*/
class ImageCarouselAdapter(dataset: List<String>) : BaseAdapter<String, ItemCarouselImageBinding>(dataset) {
override fun viewHolder(parent: ViewGroup, viewType: Int): BaseViewHolder<String, ItemCarouselImageBinding> {
val itemBinding = ItemCarouselImageBinding.inflate(parent.inflater(), parent, false)
return ItemImageViewHolder(itemBinding)
}
class ItemImageViewHolder(
override val binding: ItemCarouselImageBinding
) : BaseViewHolder<String, ItemCarouselImageBinding>(binding) {
override fun bind(data: String) {
binding.ivCarousel.setNetworkImage(data, R.drawable.image_plaholder)
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/core/widgets/ImageCarouselAdapter.kt | 636192174 |
package com.pandey.shubham.katty.core.widgets
import android.content.Context
import android.util.AttributeSet
import android.view.LayoutInflater
import com.pandey.shubham.katty.core.base.BaseCustomView
import com.pandey.shubham.katty.databinding.LayoutNetworkViewBinding
import com.pandey.shubham.katty.core.failure.model.ErrorMessage
/**
* Created by shubhampandey
*/
class NetworkErrorView @JvmOverloads constructor(
context: Context,
attributeSet: AttributeSet? = null,
defyStyle: Int = 0
) : BaseCustomView<LayoutNetworkViewBinding>(context, attributeSet, defyStyle) {
override fun viewBinding() = LayoutNetworkViewBinding.inflate(LayoutInflater.from(context), this, true)
fun setData(error: ErrorMessage, retryCallback: () -> Unit) {
binding.tvErrorMessage.text = error.errorMessage
binding.btnRetry.setOnClickListener { retryCallback() }
}
} | katty/app/src/main/java/com/pandey/shubham/katty/core/widgets/NetworkErrorView.kt | 2423900118 |
package com.pandey.shubham.katty.core.widgets
import android.content.Context
import android.util.AttributeSet
import android.util.Log
import android.view.LayoutInflater
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.PagerSnapHelper
import androidx.recyclerview.widget.RecyclerView
import androidx.recyclerview.widget.SnapHelper
import com.pandey.shubham.katty.R
import com.pandey.shubham.katty.core.base.BaseCustomView
import com.pandey.shubham.katty.core.utils.getSnapPosition
import com.pandey.shubham.katty.databinding.LayoutImageCarouselBinding
/**
* Created by shubhampandey
*/
class ImageCarouselWidget @JvmOverloads constructor(
context: Context,
attributeSet: AttributeSet? = null,
defyStyle: Int = 0
) : BaseCustomView<LayoutImageCarouselBinding>(context, attributeSet, defyStyle) {
override fun viewBinding() = LayoutImageCarouselBinding.inflate(LayoutInflater.from(context), this, true)
fun setData(images: List<String>) {
val pagerSnapHelper = PagerSnapHelper()
with(binding.rvImages) {
layoutManager = LinearLayoutManager(context, RecyclerView.HORIZONTAL, false)
adapter = ImageCarouselAdapter(images)
pagerSnapHelper.attachToRecyclerView(this)
binding.indicator.text = context.getString(R.string.indicator_txt, 1, images.count())
addOnScrollListener(snapScrollListener(pagerSnapHelper) {
binding.indicator.text = context.getString(R.string.indicator_txt, it + 1, images.count())
})
}
}
private fun snapScrollListener(snapHelper: SnapHelper, onScrollChanged: (Int) -> Unit) = object : RecyclerView.OnScrollListener() {
private var snapPosition = RecyclerView.NO_POSITION
override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
if (newState == RecyclerView.SCROLL_STATE_IDLE) {
maybeNotifySnapPositionChange(recyclerView)
}
}
private fun maybeNotifySnapPositionChange(recyclerView: RecyclerView) {
val snapPosition = snapHelper.getSnapPosition(recyclerView)
val snapPositionChanged = this.snapPosition != snapPosition
if (snapPositionChanged) {
onScrollChanged(snapPosition)
this.snapPosition = snapPosition
}
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/core/widgets/ImageCarouselWidget.kt | 16854458 |
package com.pandey.shubham.katty.core.widgets
import android.content.Context
import android.util.AttributeSet
import android.view.LayoutInflater
import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleOwner
import com.pandey.shubham.katty.core.base.BaseCustomView
import com.pandey.shubham.katty.core.utils.onAfterTextChange
import com.pandey.shubham.katty.databinding.LayoutSearchWidgetBinding
/**
* Created by shubhampandey
*/
class SearchWidget @JvmOverloads constructor(
context: Context,
attributeSet: AttributeSet? = null,
defyStyle: Int = 0
) : BaseCustomView<LayoutSearchWidgetBinding>(context, attributeSet, defyStyle), DefaultLifecycleObserver {
override fun viewBinding() = LayoutSearchWidgetBinding.inflate(LayoutInflater.from(context), this, true)
private var onTextChanged: ((CharSequence) -> Unit?)? = null
private val textWatcher = onAfterTextChange { text ->
if (!text.isNullOrBlank()) {
onTextChanged?.let { it(text) }
}
}
override fun onCreate(owner: LifecycleOwner) {
super.onCreate(owner)
binding.etSearch.addTextChangedListener(textWatcher)
}
fun onTextChanged(lifecycle: Lifecycle, onTextChanged: (CharSequence) -> Unit) {
lifecycle.addObserver(this)
this.onTextChanged = onTextChanged
}
override fun onDestroy(owner: LifecycleOwner) {
binding.etSearch.removeTextChangedListener(textWatcher)
}
} | katty/app/src/main/java/com/pandey/shubham/katty/core/widgets/SearchWidget.kt | 2391713866 |
package com.pandey.shubham.katty
import android.app.Application
import android.content.Context
import dagger.hilt.android.HiltAndroidApp
import java.lang.ref.WeakReference
/**
* Created by shubhampandey
*/
@HiltAndroidApp
class KattyApp: Application() {
companion object {
private lateinit var contextWeakReference: WeakReference<Context>
@JvmStatic
fun init(context: Context) {
this.contextWeakReference = WeakReference(context)
}
@JvmStatic
fun getAppContext() = contextWeakReference.get()
}
override fun onCreate() {
super.onCreate()
init(this)
}
} | katty/app/src/main/java/com/pandey/shubham/katty/KattyApp.kt | 3335348974 |
package com.pandey.shubham.katty.feature.search.ui
import com.pandey.shubham.katty.core.base.BaseViewHolder
import com.pandey.shubham.katty.databinding.ItemSearchResultBinding
import com.pandey.shubham.katty.feature.search.data.SearchSuggestion
/**
* Created by shubhampandey
*/
class SearchItemViewHolder(override val binding: ItemSearchResultBinding) :
BaseViewHolder<SearchSuggestion, ItemSearchResultBinding>(binding) {
override fun bind(data: SearchSuggestion) {
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/search/ui/SearchItemViewHolder.kt | 1904390415 |
package com.pandey.shubham.katty.feature.search.ui
import android.content.Context
import android.content.Intent
import android.os.Bundle
import com.pandey.shubham.katty.R
import com.pandey.shubham.katty.core.base.NetworkLoaderActivity
/**
* Created by shubhampandey
*/
class SearchActivity: NetworkLoaderActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
loadFragment(savedInstanceState)
}
private fun loadFragment(savedInstanceState: Bundle?) {
if (savedInstanceState == null) {
openFragment(R.id.feed_container, SearchFragment.newInstance())
}
}
override fun onBackStackUpdate() {
// do nothing
}
companion object {
fun start(context: Context) {
context.startActivity(Intent(context, SearchActivity::class.java))
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/search/ui/SearchActivity.kt | 1550651703 |
package com.pandey.shubham.katty.feature.search.ui
import android.view.LayoutInflater
import android.view.ViewGroup
import com.pandey.shubham.katty.core.base.BaseFragment
import com.pandey.shubham.katty.core.utils.Callback
import com.pandey.shubham.katty.databinding.FragmentSearchBinding
/**
* Created by shubhampandey
*/
class SearchFragment: BaseFragment<FragmentSearchBinding, Callback>() {
override fun viewBinding(inflater: LayoutInflater, container: ViewGroup?): FragmentSearchBinding {
return FragmentSearchBinding.inflate(inflater, container, false)
}
override fun populateViews() {
binding.searchToolbar.setNavigationOnClickListener { onBackPressed() }
binding.etSearch.onTextChanged(lifecycle) {
//
}
}
override fun attachListeners() {
// TODO
}
companion object {
fun newInstance() = SearchFragment()
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/search/ui/SearchFragment.kt | 254015349 |
package com.pandey.shubham.katty.feature.search.ui
import android.view.ViewGroup
import com.pandey.shubham.katty.core.base.BaseAdapter
import com.pandey.shubham.katty.core.base.BaseViewHolder
import com.pandey.shubham.katty.core.utils.inflater
import com.pandey.shubham.katty.databinding.ItemSearchResultBinding
import com.pandey.shubham.katty.feature.search.data.SearchSuggestion
/**
* Created by shubhampandey
*/
class SearchAdapter(
private val dataset: List<SearchSuggestion>
) : BaseAdapter<SearchSuggestion, ItemSearchResultBinding>(dataset) {
override fun viewHolder(parent: ViewGroup, viewType: Int): BaseViewHolder<SearchSuggestion, ItemSearchResultBinding> {
val itemBinding = ItemSearchResultBinding.inflate(parent.inflater(), parent, false)
return SearchItemViewHolder(itemBinding)
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/search/ui/SearchAdapter.kt | 247597507 |
package com.pandey.shubham.katty.feature.search.data
/**
* Created by shubhampandey
*/
data class SearchSuggestion(
val imageUrl: String?,
val title: String?,
val subtitle: String?
) | katty/app/src/main/java/com/pandey/shubham/katty/feature/search/data/SearchSuggestion.kt | 3383115489 |
package com.pandey.shubham.katty.feature.detail.ui
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.core.os.bundleOf
import androidx.fragment.app.viewModels
import com.pandey.shubham.katty.R
import com.pandey.shubham.katty.core.base.BaseFragment
import com.pandey.shubham.katty.core.failure.model.ErrorMessage
import com.pandey.shubham.katty.core.utils.Callback
import com.pandey.shubham.katty.core.utils.ERROR_ADDING_FAVOURITE
import com.pandey.shubham.katty.core.utils.setDrawable
import com.pandey.shubham.katty.databinding.FragmentFeedItemDetailBinding
import com.pandey.shubham.katty.feature.detail.data.CatImageResponseItem
import com.pandey.shubham.katty.feature.detail.domain.model.CatDetailInfo
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
import dagger.hilt.android.AndroidEntryPoint
/**
* Created by shubhampandey
*/
@AndroidEntryPoint
class FeedItemDetailFragment : BaseFragment<FragmentFeedItemDetailBinding, Callback>() {
private val viewModel: FeedDetailViewModel by viewModels()
private val cateBreedId: String? by lazy { arguments?.getString(CAT_BREED_ID) }
private var catBreedItemInfo: CatBreedItemInfo? = null
override fun viewBinding(inflater: LayoutInflater, container: ViewGroup?): FragmentFeedItemDetailBinding {
return FragmentFeedItemDetailBinding.inflate(inflater, container, false)
}
override fun populateViews() {
attachObserver()
}
override fun attachListeners() {
binding.feedDetailToolbar.setNavigationOnClickListener { onBackPressed() }
binding.ivFavourite.setOnClickListener { onFavoriteClicked() }
}
private fun onFavoriteClicked() {
catBreedItemInfo?.let {
it.isFavourite = !it.isFavourite
viewModel.addToFavourite(it)
toggleFavourite(it.isFavourite)
}
}
private fun attachObserver() {
viewModel.feedDetailUiState.observe(viewLifecycleOwner) { onFeedDetailUiStateChange(it) }
}
private fun onFeedDetailUiStateChange(state: FeedDetailUiState) {
when(state) {
is FeedDetailUiState.ShowLoader -> showLoader()
is FeedDetailUiState.ShowError -> handleError(state.throwable)
is FeedDetailUiState.ShowFeedDetail -> showFeedDetail(state.detailInfo)
is FeedDetailUiState.OnFavouriteEvent -> onFavoriteEvent(state.isSuccess, state.error)
}
}
private fun onFavoriteEvent(success: Boolean, error: String?) {
if (!success) { showSnackBar(error ?: ERROR_ADDING_FAVOURITE) }
}
private fun handleError(throwable: Throwable?) {
hideLoader()
showError(ErrorMessage(errorMessage = throwable?.message)) {
viewModel.getCateDetail(cateBreedId)
}
}
private fun showFeedDetail(detail: CatDetailInfo?) {
hideLoader()
val catInfo = detail?.breedItemInfo
catInfo?.run {
catBreedItemInfo = catInfo
binding.tvName.text = requireContext().getString(R.string.txt_name, name ?: "")
binding.tvOrigin.text = requireContext().getString(R.string.txt_origin, origin)
binding.tvTemperament.text = requireContext().getString(R.string.txt_temperament, temperament)
binding.tvDescription.text = requireContext().getString(R.string.txt_description, description)
toggleFavourite(isFavourite)
showImages(detail.images)
}
}
private fun showImages(images: List<CatImageResponseItem>?) {
if (!images.isNullOrEmpty()) {
val imageUrls = images.mapNotNull { it.url }
binding.imageCarousel.setData(imageUrls)
}
}
private fun toggleFavourite(isFavourite: Boolean) {
if (isFavourite) {
binding.ivFavourite.setDrawable(R.drawable.icon_heart_filled_red_24)
} else {
binding.ivFavourite.setDrawable(R.drawable.icon_heart_outlined_24)
}
}
companion object {
const val CAT_BREED_ID = "cat_breed_id"
private const val IS_FAVOURITE = "is_favourite"
fun newInstance(catBreedId: String?, isFavourite: Boolean) = FeedItemDetailFragment().apply {
arguments = bundleOf(
Pair(CAT_BREED_ID, catBreedId),
Pair(IS_FAVOURITE, isFavourite)
)
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/detail/ui/FeedItemDetailFragment.kt | 988789378 |
package com.pandey.shubham.katty.feature.detail.ui
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.pandey.shubham.katty.core.network.NETWORK_ERROR_UNKNOWN
import com.pandey.shubham.katty.core.network.NetworkState
import com.pandey.shubham.katty.feature.detail.domain.model.CatDetailInfo
import com.pandey.shubham.katty.feature.detail.domain.usecase.GetCatDetailUseCase
import com.pandey.shubham.katty.feature.detail.ui.FeedItemDetailFragment.Companion.CAT_BREED_ID
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
import com.pandey.shubham.katty.feature.feed.domain.usecase.AddFavoriteUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import java.io.IOException
import javax.inject.Inject
/**
* Created by shubhampandey
*
*/
@HiltViewModel
class FeedDetailViewModel @Inject constructor(
private val detailUseCase: GetCatDetailUseCase,
private val addFavoriteUseCase: AddFavoriteUseCase,
savedStateHandle: SavedStateHandle
): ViewModel() {
private val _feedDetailUiState: MutableLiveData<FeedDetailUiState> = MutableLiveData()
val feedDetailUiState: LiveData<FeedDetailUiState> = _feedDetailUiState
init {
val catBreedId = savedStateHandle.get<String>(CAT_BREED_ID)
getCateDetail(catBreedId)
}
fun getCateDetail(catBreedId: String?) {
_feedDetailUiState.value = FeedDetailUiState.ShowLoader
detailUseCase(catBreedId).onEach { state ->
when (state) {
is NetworkState.Error -> _feedDetailUiState.value = FeedDetailUiState.ShowError(state.throwable)
is NetworkState.Success -> handleResponse(state.data)
}
}.launchIn(viewModelScope)
}
fun addToFavourite(catBreedItemInfo: CatBreedItemInfo) {
addFavoriteUseCase(catBreedItemInfo.toBreedInfoEntity()).onEach { state ->
val isSuccess = when(state) {
is NetworkState.Success -> true
is NetworkState.Error -> false
}
_feedDetailUiState.value = FeedDetailUiState.OnFavouriteEvent(isSuccess)
}.launchIn(viewModelScope)
}
private fun handleResponse(data: CatDetailInfo?) {
if (data != null) {
_feedDetailUiState.value = FeedDetailUiState.ShowFeedDetail(data)
} else {
_feedDetailUiState.value = FeedDetailUiState.ShowError(IOException(NETWORK_ERROR_UNKNOWN))
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/detail/ui/FeedDetailViewModel.kt | 3184977410 |
package com.pandey.shubham.katty.feature.detail.ui
import com.pandey.shubham.katty.feature.detail.domain.model.CatDetailInfo
/**
* Created by shubhampandey
*/
sealed class FeedDetailUiState {
data object ShowLoader: FeedDetailUiState()
data class ShowError(val throwable: Throwable?): FeedDetailUiState()
data class ShowFeedDetail(val detailInfo: CatDetailInfo?): FeedDetailUiState()
data class OnFavouriteEvent(val isSuccess: Boolean, val error: String? = null): FeedDetailUiState()
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/detail/ui/FeedDetailUiState.kt | 2929981099 |
package com.pandey.shubham.katty.feature.detail.di
import com.pandey.shubham.katty.feature.detail.domain.usecase.GetCatDetailUseCase
import com.pandey.shubham.katty.feature.feed.data.repository.FeedRepository
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
/**
* Created by shubhampandey
*/
@Module
@InstallIn(SingletonComponent::class)
class FeedDetailModule {
@Provides
fun provideCatDetailUseCase(feedRepository: FeedRepository): GetCatDetailUseCase {
return GetCatDetailUseCase(feedRepository)
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/detail/di/FeedDetailModule.kt | 1637759206 |
package com.pandey.shubham.katty.feature.detail.data
import android.os.Parcelable
import androidx.annotation.Keep
import kotlinx.parcelize.Parcelize
/**
* Created by shubhampandey
*/
@Keep
@Parcelize
class CatImageResponse : ArrayList<CatImageResponseItem>(), Parcelable | katty/app/src/main/java/com/pandey/shubham/katty/feature/detail/data/CatImageResponse.kt | 2668747466 |
package com.pandey.shubham.katty.feature.detail.data
import android.os.Parcelable
import androidx.annotation.Keep
import kotlinx.parcelize.Parcelize
/**
* Created by shubhampandey
*/
@Keep
@Parcelize
data class CatImageResponseItem(
val height: Int?,
val id: String?,
val url: String?,
val width: Int?
): Parcelable | katty/app/src/main/java/com/pandey/shubham/katty/feature/detail/data/CatImageResponseItem.kt | 2804321731 |
package com.pandey.shubham.katty.feature.detail.domain.model
import androidx.annotation.Keep
import com.pandey.shubham.katty.feature.detail.data.CatImageResponseItem
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
/**
* Created by shubhampandey
*/
@Keep
data class CatDetailInfo(
val breedItemInfo: CatBreedItemInfo?,
val images: List<CatImageResponseItem>?
) | katty/app/src/main/java/com/pandey/shubham/katty/feature/detail/domain/model/CatDetailInfo.kt | 3660047090 |
package com.pandey.shubham.katty.feature.detail.domain.usecase
import com.pandey.shubham.katty.core.base.UseCase
import com.pandey.shubham.katty.core.failure.NoDataAvailableException
import com.pandey.shubham.katty.core.network.NetworkState
import com.pandey.shubham.katty.core.network.getNetworkResult
import com.pandey.shubham.katty.feature.detail.domain.model.CatDetailInfo
import com.pandey.shubham.katty.feature.feed.data.repository.FeedRepository
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
/**
* Created by shubhampandey
*/
class GetCatDetailUseCase @Inject constructor(
private val repository: FeedRepository
): UseCase<String, Flow<NetworkState<CatDetailInfo>>>() {
override fun run(param: String?, scope: CoroutineScope) = flow {
val imageResponse = repository.getCatImages(param)
val images = if (imageResponse is NetworkState.Success) {
imageResponse.data
} else {
null
}
val localData = repository.getFavouriteFromDb(param).first()
if (localData != null) {
val cateDetail = CatDetailInfo(localData.toCatBreedItem(), images)
emit(NetworkState.Success(cateDetail))
} else {
repository.getCatBreedDetail(param).getNetworkResult(
onSuccess = { response ->
val catDetailInfo = CatDetailInfo(response?.toCatBreedItem(), images)
emit(NetworkState.Success(catDetailInfo))
},
onError = {
emit(NetworkState.Error(it))
}
)
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/detail/domain/usecase/GetCatDetailUseCase.kt | 2005276317 |
package com.pandey.shubham.katty.feature.feed.ui
import android.os.Bundle
import com.pandey.shubham.katty.R
import com.pandey.shubham.katty.core.base.NetworkLoaderActivity
import com.pandey.shubham.katty.feature.detail.ui.FeedItemDetailFragment
import com.pandey.shubham.katty.feature.feed.ui.callbacks.HomeFeedFragmentCallback
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class HomeActivity : NetworkLoaderActivity(), HomeFeedFragmentCallback {
private var backStackCount = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
loadFragment(savedInstanceState)
}
private fun loadFragment(savedInstanceState: Bundle?) {
if (savedInstanceState == null) {
openFragment(R.id.feed_container, HomeFeedFragment.newInstance())
}
}
override fun openDetailFragment(catBreedId: String?, isFavorite: Boolean) {
openFragment(R.id.feed_container, FeedItemDetailFragment.newInstance(catBreedId, isFavorite), addToBackStack = true)
backStackCount = supportFragmentManager.backStackEntryCount
}
override fun onBackStackUpdate() {
if (supportFragmentManager.backStackEntryCount == backStackCount - 1) {
val homeFragment = supportFragmentManager.findFragmentByTag(HomeFeedFragment::class.java.canonicalName)
if (homeFragment != null && homeFragment is HomeFeedFragment) {
homeFragment.updateFavorite()
}
}
backStackCount = supportFragmentManager.backStackEntryCount
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/ui/HomeActivity.kt | 2504293481 |
package com.pandey.shubham.katty.feature.feed.ui
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.paging.CombinedLoadStates
import androidx.paging.LoadState
import androidx.paging.PagingData
import androidx.paging.cachedIn
import com.pandey.shubham.katty.core.failure.model.ErrorMessage
import com.pandey.shubham.katty.core.network.NetworkState
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
import com.pandey.shubham.katty.feature.feed.domain.usecase.AddFavoriteUseCase
import com.pandey.shubham.katty.feature.feed.domain.usecase.GetFavouriteUseCase
import com.pandey.shubham.katty.feature.feed.domain.usecase.GetFeedDataUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.launch
import javax.inject.Inject
/**
* Created by shubhampandey
*/
@HiltViewModel
class HomeFeedViewModel @Inject constructor(
getFeedDataUseCase: GetFeedDataUseCase,
private val addFavoriteUseCase: AddFavoriteUseCase,
private val getFavouriteUseCase: GetFavouriteUseCase
): ViewModel() {
private val _homeUiState: MutableLiveData<HomeUiState> = MutableLiveData()
val homeUiState: LiveData<HomeUiState> = _homeUiState
val fetchFeedDataPaginated = getFeedDataUseCase.invoke().cachedIn(viewModelScope)
fun addToFavourite(favourite: CatBreedItemInfo) {
addFavoriteUseCase(favourite.toBreedInfoEntity()).onEach { state ->
when(state) {
is NetworkState.Success -> {
_homeUiState.value = HomeUiState.OnFavouriteUpdated(true, null)
}
is NetworkState.Error -> {
_homeUiState.value = HomeUiState.OnFavouriteUpdated(false, state.throwable.message)
}
}
}.launchIn(viewModelScope)
}
fun getFavoriteBreed(breedId: String) {
viewModelScope.launch {
getFavouriteUseCase(breedId).collectLatest {
_homeUiState.value = HomeUiState.UpdateFavorite(it)
}
}
}
fun onLoadingStateUpdate(loadStates: CombinedLoadStates) {
when(loadStates.refresh) {
is LoadState.Loading -> _homeUiState.value = HomeUiState.ShowLoader(true)
is LoadState.Error -> _homeUiState.value = HomeUiState.ShowError(ErrorMessage(errorMessage = (loadStates.refresh as LoadState.Error).error.message))
is LoadState.NotLoading -> _homeUiState.value = HomeUiState.OnNotLoading
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/ui/HomeFeedViewModel.kt | 2232364281 |
package com.pandey.shubham.katty.feature.feed.ui.callbacks
import com.pandey.shubham.katty.core.utils.Callback
/**
* Created by shubhampandey
*/
interface HomeFeedFragmentCallback : Callback {
fun openDetailFragment(catBreedId: String?, isFavorite: Boolean)
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/ui/callbacks/HomeFeedFragmentCallback.kt | 1248305776 |
package com.pandey.shubham.katty.feature.feed.ui
import com.pandey.shubham.katty.core.database.CatBreedInfoEntity
import com.pandey.shubham.katty.core.failure.model.ErrorMessage
/**
* Created by shubhampandey
*/
sealed class HomeUiState {
data class ShowLoader(val isLoading: Boolean): HomeUiState()
data class ShowError(val error: ErrorMessage): HomeUiState()
data object OnNotLoading: HomeUiState()
data class UpdateFavorite(val catBreedItemEntity: CatBreedInfoEntity?): HomeUiState()
data class OnFavouriteUpdated(val isSuccess: Boolean, val error: String?): HomeUiState()
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/ui/HomeUiState.kt | 2460922242 |
package com.pandey.shubham.katty.feature.feed.ui.adapter
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.paging.LoadState
import androidx.paging.LoadStateAdapter
import com.pandey.shubham.katty.databinding.ItemNetworkStateBinding
import com.pandey.shubham.katty.feature.feed.ui.viewholders.NetworkStateItemViewHolder
/**
* Created by shubhampandey
*/
class FeedLoadingAdapter(
private val retryCallback: () -> Unit
) : LoadStateAdapter<NetworkStateItemViewHolder>() {
override fun onCreateViewHolder(parent: ViewGroup, loadState: LoadState) =
NetworkStateItemViewHolder(
ItemNetworkStateBinding.inflate(
LayoutInflater.from(parent.context),
parent, false)
) { retryCallback() }
override fun onBindViewHolder(holder: NetworkStateItemViewHolder, loadState: LoadState) = holder.bind(loadState)
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/ui/adapter/FeedLoadingAdapter.kt | 1083587428 |
package com.pandey.shubham.katty.feature.feed.ui.adapter
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
import com.pandey.shubham.katty.R
import com.pandey.shubham.katty.core.base.BasePagingAdapter
import com.pandey.shubham.katty.core.utils.absoluteAdapterPosition
import com.pandey.shubham.katty.core.utils.isInRange
import com.pandey.shubham.katty.databinding.ItemFeedViewBinding
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
import com.pandey.shubham.katty.feature.feed.ui.viewholders.FeedItemViewHolder
/**
* Created by shubhampandey
*/
class HomeFeedAdapter(
private val onItemClick: (Int, CatBreedItemInfo) -> Unit,
private val onFavoriteClicked: (CatBreedItemInfo) -> Unit
) : BasePagingAdapter<CatBreedItemInfo, FeedItemViewHolder>(DIFF_UTILS) {
override fun viewHolder(parent: ViewGroup, viewType: Int): FeedItemViewHolder {
val itemBinding = ItemFeedViewBinding.inflate(LayoutInflater.from(parent.context), parent, false)
val viewHolder = FeedItemViewHolder(itemBinding)
setItemClickListener(viewHolder)
return viewHolder
}
private fun setItemClickListener(viewHolder: FeedItemViewHolder) {
with(viewHolder) {
itemView.setOnClickListener {
absoluteAdapterPosition { position ->
getItem(position) { onItemClick(position, it) }
}
}
itemView.findViewById<View>(R.id.iv_favourite).setOnClickListener {
absoluteAdapterPosition { position ->
getItem(position) { item ->
item.isFavourite = !item.isFavourite
onFavoriteClicked(item)
notifyItemChanged(position, item.isFavourite)
}
}
}
}
}
private inline fun getItem(position: Int, block: (CatBreedItemInfo) -> Unit) {
if (position.isInRange(itemCount)) {
getItem(position)?.let(block)
}
}
override fun onBindViewHolder(holder: FeedItemViewHolder, position: Int) {
if (position != RecyclerView.NO_POSITION) {
val item = getItem(position)
item?.let { holder.bind(item) }
}
}
override fun onBindViewHolder(holder: FeedItemViewHolder, position: Int, payloads: MutableList<Any>) {
if (payloads.isNotEmpty()) {
holder.toggleFavourite(payloads[0] as Boolean)
} else {
super.onBindViewHolder(holder, position, payloads)
}
}
fun updateItem(position: Int, isFavorite: Boolean) {
getItem(position) {
it.isFavourite = isFavorite
}
notifyItemChanged(position, isFavorite)
}
companion object {
private val DIFF_UTILS = object : DiffUtil.ItemCallback<CatBreedItemInfo>() {
override fun areItemsTheSame(oldItem: CatBreedItemInfo, newItem: CatBreedItemInfo): Boolean {
return oldItem.breedId == newItem.breedId
}
override fun areContentsTheSame(oldItem: CatBreedItemInfo, newItem: CatBreedItemInfo): Boolean {
return oldItem == newItem
}
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/ui/adapter/HomeFeedAdapter.kt | 1579138253 |
package com.pandey.shubham.katty.feature.feed.ui
import android.view.LayoutInflater
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import android.view.ViewGroup
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.MenuProvider
import androidx.fragment.app.viewModels
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.pandey.shubham.katty.R
import com.pandey.shubham.katty.core.base.BaseFragment
import com.pandey.shubham.katty.core.database.CatBreedInfoEntity
import com.pandey.shubham.katty.core.failure.model.ErrorMessage
import com.pandey.shubham.katty.core.utils.ERROR_ADDING_FAVOURITE
import com.pandey.shubham.katty.core.utils.SpaceItemDecoration
import com.pandey.shubham.katty.core.utils.Utility
import com.pandey.shubham.katty.core.utils.gone
import com.pandey.shubham.katty.core.utils.visible
import com.pandey.shubham.katty.databinding.FragmentHomeFeedBinding
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
import com.pandey.shubham.katty.feature.feed.ui.adapter.FeedLoadingAdapter
import com.pandey.shubham.katty.feature.feed.ui.adapter.HomeFeedAdapter
import com.pandey.shubham.katty.feature.feed.ui.callbacks.HomeFeedFragmentCallback
import com.pandey.shubham.katty.feature.search.ui.SearchActivity
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
@AndroidEntryPoint
class HomeFeedFragment : BaseFragment<FragmentHomeFeedBinding, HomeFeedFragmentCallback>() {
private val viewModel: HomeFeedViewModel by viewModels()
private var currentDetailPosition: Int = 0
private var currentDetailId : String? = null
private val feedAdapter: HomeFeedAdapter by lazy {
HomeFeedAdapter(
{ position, item -> openDetailFragment(position, item) },
{ item -> onFavouriteClicked(item) }
)
}
override fun viewBinding(inflater: LayoutInflater, container: ViewGroup?): FragmentHomeFeedBinding {
return FragmentHomeFeedBinding.inflate(inflater, container, false)
}
override fun populateViews() {
setupOptionMenu()
setFeedAdapter()
attachObserver()
}
private fun setupOptionMenu() {
with(requireActivity() as AppCompatActivity) {
setSupportActionBar(binding.toolbar)
addMenuProvider(object : MenuProvider {
override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
menuInflater.inflate(R.menu.main_menu, menu)
}
override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
when(menuItem.itemId) {
R.id.action_search -> SearchActivity.start(this@with)
R.id.action_refresh -> feedAdapter.refresh()
}
return true
}
}, viewLifecycleOwner)
}
}
override fun attachListeners() {
binding.swipeRefresh.setOnRefreshListener { feedAdapter.refresh() }
if (!Utility.isNetworkAvailable()) {
showActionSnackBar(getString(R.string.internet_error), getString(R.string.try_again)) {
feedAdapter.retry()
}
}
}
private fun attachObserver() {
viewModel.fetchFeedDataPaginated.observe(viewLifecycleOwner) {
feedAdapter.submitData(lifecycle, it)
}
lifecycleScope.launch {
feedAdapter.loadStateFlow.collectLatest { loadStates ->
viewModel.onLoadingStateUpdate(loadStates)
}
}
viewModel.homeUiState.observe(viewLifecycleOwner) { state ->
when(state) {
is HomeUiState.ShowLoader -> handleLoader()
is HomeUiState.ShowError -> handleError(state.error)
is HomeUiState.OnNotLoading -> handleIdleState()
is HomeUiState.UpdateFavorite -> updateFavouriteItem(state.catBreedItemEntity)
is HomeUiState.OnFavouriteUpdated -> onFavoriteUpdated(state.isSuccess, state.error)
else -> {
// do nothing
}
}
}
}
private fun onFavoriteUpdated(success: Boolean, error: String?) {
if (!success) showSnackBar(error ?: ERROR_ADDING_FAVOURITE)
}
private fun updateFavouriteItem(catBreedItemInfo: CatBreedInfoEntity?) {
val addToFavorite = catBreedItemInfo != null // if null remove from favourite.
feedAdapter.updateItem(currentDetailPosition, addToFavorite)
}
private fun handleLoader() {
if (feedAdapter.itemCount == 0) {
binding.swipeRefresh.isRefreshing = false
showLoader()
} else {
hideLoader()
binding.swipeRefresh.isRefreshing = true
}
}
private fun handleError(error: ErrorMessage) {
hideLoader()
binding.swipeRefresh.isRefreshing = false
if (feedAdapter.itemCount == 0) {
onInitialLoadingError(error)
} else {
onRefreshError(error)
}
}
private fun onRefreshError(error: ErrorMessage) {
val errorMessage = error.errorMessage ?: getString(R.string.something_went_wrong)
showActionSnackBar(errorMessage, getString(R.string.try_again)) { feedAdapter.retry() }
}
private fun onInitialLoadingError(error: ErrorMessage) {
binding.rvFeed.gone()
showError(error) { feedAdapter.retry() }
}
private fun handleIdleState() {
hideLoader()
hideError()
binding.rvFeed.visible()
binding.swipeRefresh.isRefreshing = false
hideActionSnackBar()
}
private fun setFeedAdapter() {
with(binding.rvFeed) {
layoutManager = LinearLayoutManager(requireContext(), RecyclerView.VERTICAL, false)
adapter = feedAdapter.withLoadStateFooter(FeedLoadingAdapter { feedAdapter.retry() })
addItemDecoration(SpaceItemDecoration(resources.getDimensionPixelOffset(R.dimen.dimen32dp), RecyclerView.VERTICAL))
}
}
private fun onFavouriteClicked(favourite: CatBreedItemInfo) {
viewModel.addToFavourite(favourite)
}
/**
* Update the favorite state when user navigate back from detail.
*/
fun updateFavorite() {
if (currentDetailId.isNullOrBlank()) return
viewModel.getFavoriteBreed(currentDetailId!!)
hideError()
}
private fun openDetailFragment(position: Int, feedItem: CatBreedItemInfo) {
this.currentDetailPosition = position
currentDetailId = feedItem.breedId
callback?.openDetailFragment(feedItem.breedId, feedItem.isFavourite)
}
companion object {
fun newInstance() = HomeFeedFragment()
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/ui/HomeFeedFragment.kt | 339588565 |
package com.pandey.shubham.katty.feature.feed.ui.viewholders
import androidx.core.view.isVisible
import androidx.paging.LoadState
import androidx.recyclerview.widget.RecyclerView
import com.pandey.shubham.katty.databinding.ItemNetworkStateBinding
class NetworkStateItemViewHolder(
private val binding: ItemNetworkStateBinding,
private val retryCallback: () -> Unit
) : RecyclerView.ViewHolder(binding.root) {
init {
binding.btnRetry.setOnClickListener { retryCallback() }
}
fun bind(loadState: LoadState) {
with(binding) {
nwLoader.isVisible = loadState is LoadState.Loading
btnRetry.isVisible = loadState is LoadState.Error
tvError.isVisible = !(loadState as? LoadState.Error)?.error?.message.isNullOrBlank()
tvError.text = (loadState as? LoadState.Error)?.error?.message
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/ui/viewholders/NetworkStateItemViewHolder.kt | 2115210226 |
package com.pandey.shubham.katty.feature.feed.ui.viewholders
import com.bumptech.glide.Glide
import com.pandey.shubham.katty.R
import com.pandey.shubham.katty.core.base.BaseViewHolder
import com.pandey.shubham.katty.core.utils.setDrawable
import com.pandey.shubham.katty.databinding.ItemFeedViewBinding
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
/**
* Created by shubhampandey
*/
class FeedItemViewHolder(override val binding: ItemFeedViewBinding): BaseViewHolder<CatBreedItemInfo, ItemFeedViewBinding>(binding) {
override fun bind(data: CatBreedItemInfo) {
data.run {
Glide.with(binding.root).load(imageUrl).into(binding.ivFeed)
binding.tvName.text = context.getString(R.string.txt_name, name ?: "")
binding.tvOrigin.text = context.getString(R.string.txt_origin, origin)
binding.tvTemperament.text = context.getString(R.string.txt_temperament, temperament)
toggleFavourite(isFavourite)
}
}
fun toggleFavourite(isFavorite: Boolean) {
if (isFavorite) {
binding.ivFavourite.setDrawable(R.drawable.icon_heart_filled_red_24)
} else {
binding.ivFavourite.setDrawable(R.drawable.icon_heart_outlined_24)
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/ui/viewholders/FeedItemViewHolder.kt | 175603020 |
package com.pandey.shubham.katty.feature.feed.di
import com.pandey.shubham.katty.feature.feed.data.repository.FeedRepository
import com.pandey.shubham.katty.feature.feed.domain.usecase.AddFavoriteUseCase
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
/**
* Created by shubhampandey
*/
@Module
@InstallIn(SingletonComponent::class)
class FeedModule {
@Provides
fun provideAddFavoriteUseCase(feedRepository: FeedRepository): AddFavoriteUseCase {
return AddFavoriteUseCase(feedRepository)
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/di/FeedModule.kt | 1647448647 |
package com.pandey.shubham.katty.feature.feed.data.repository
import androidx.lifecycle.LiveData
import androidx.paging.PagingData
import com.pandey.shubham.katty.core.database.CatBreedInfoEntity
import com.pandey.shubham.katty.core.network.NetworkState
import com.pandey.shubham.katty.feature.detail.data.CatImageResponse
import com.pandey.shubham.katty.feature.feed.data.dtos.CatDetailItemResponse
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
import kotlinx.coroutines.flow.Flow
/**
* Created by shubhampandey
*/
interface FeedRepository {
fun getCatImagesPaginated(): LiveData<PagingData<CatBreedItemInfo>>
suspend fun updateFavorite(catBreedItemInfo: CatBreedInfoEntity): Number
fun getFavouriteFromDb(breedId: String?): Flow<CatBreedInfoEntity?>
suspend fun getCatBreedDetail(catBreedId: String?): NetworkState<CatDetailItemResponse?>
suspend fun getCatImages(catBreedId: String?): NetworkState<CatImageResponse?>
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/data/repository/FeedRepository.kt | 1156241169 |
package com.pandey.shubham.katty.feature.feed.data.repository
import android.util.Log
import androidx.paging.Pager
import androidx.paging.PagingConfig
import androidx.paging.liveData
import com.pandey.shubham.katty.core.FeedApiService
import com.pandey.shubham.katty.core.database.AppDatabase
import com.pandey.shubham.katty.core.database.CatBreedInfoEntity
import com.pandey.shubham.katty.core.failure.InvalidIdException
import com.pandey.shubham.katty.core.network.NetworkState
import com.pandey.shubham.katty.core.network.makeRequest
import com.pandey.shubham.katty.core.utils.DEFAULT_PAGE_SIZE
import com.pandey.shubham.katty.core.utils.MAX_CACHED_ITEMS
import com.pandey.shubham.katty.feature.detail.data.CatImageResponse
import com.pandey.shubham.katty.feature.feed.data.FeedDataSource
import com.pandey.shubham.katty.feature.feed.data.dtos.CatDetailItemResponse
import kotlinx.coroutines.Dispatchers.IO
import javax.inject.Inject
/**
* Created by shubhampandey
*/
private const val TAG = "FeedRepositoryImpl"
class FeedRepositoryImpl @Inject constructor(
private val apiService: FeedApiService,
private val appDatabase: AppDatabase
): FeedRepository {
private val defaultConfig get() = PagingConfig(
pageSize = DEFAULT_PAGE_SIZE,
maxSize = MAX_CACHED_ITEMS,
prefetchDistance = DEFAULT_PAGE_SIZE, // to load items in advance.
)
private val pager
get() = Pager(
config = defaultConfig,
pagingSourceFactory = { FeedDataSource(apiService, appDatabase) },
)
override fun getCatImagesPaginated() = pager.liveData
override suspend fun updateFavorite(catBreedItemInfo: CatBreedInfoEntity): Long {
return if (catBreedItemInfo.isFavourite) {
appDatabase.cateInfoDao().addFavouriteBreed(catBreedItemInfo)
} else {
appDatabase.cateInfoDao().removeFavorite(catBreedItemInfo.breedId).toLong()
}
}
override fun getFavouriteFromDb(breedId: String?) = appDatabase.cateInfoDao().getFavouriteBreed(breedId)
override suspend fun getCatBreedDetail(catBreedId: String?): NetworkState<CatDetailItemResponse?> {
return try {
if (catBreedId.isNullOrBlank()) throw InvalidIdException()
makeRequest(IO) { apiService.getCatBreedDetail(catBreedId) }
} catch (ex: Exception) {
NetworkState.Error(throwable = ex)
}
}
override suspend fun getCatImages(catBreedId: String?): NetworkState<CatImageResponse?> {
return try {
if (catBreedId.isNullOrBlank()) throw InvalidIdException()
makeRequest(IO) { apiService.getCatImages(catBreedId) }
} catch (ex: Exception) {
Log.e(TAG, ex.toString())
NetworkState.Error(throwable = ex)
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/data/repository/FeedRepositoryImpl.kt | 1530250492 |
package com.pandey.shubham.katty.feature.feed.data
import android.net.http.HttpException
import android.util.Log
import androidx.paging.PagingSource
import androidx.paging.PagingState
import com.pandey.shubham.katty.core.FeedApiService
import com.pandey.shubham.katty.core.database.AppDatabase
import com.pandey.shubham.katty.core.network.getNetworkResult
import com.pandey.shubham.katty.core.network.makeRequest
import com.pandey.shubham.katty.core.utils.DEFAULT_PAGE_SIZE
import com.pandey.shubham.katty.core.utils.NO_INTERNET_CONNECTION
import com.pandey.shubham.katty.core.utils.Utility
import com.pandey.shubham.katty.feature.feed.data.dtos.CatDetailItemResponse
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
import kotlinx.coroutines.Dispatchers.IO
import java.io.IOException
/**
* Created by shubhampandey
*/
private const val TAG = "FeedDataSource"
class FeedDataSource(
private val apiService: FeedApiService,
private val appDatabase: AppDatabase,
private val initialPage: Int = 1
) : PagingSource<Int, CatBreedItemInfo>() {
override suspend fun load(params: LoadParams<Int>): LoadResult<Int, CatBreedItemInfo> {
try {
val position = params.key ?: initialPage
val favouriteBreedList = appDatabase.cateInfoDao().getFavouriteBreeds()
var hasNext = false
var breedItemList: List<CatBreedItemInfo> = emptyList()
if (Utility.isNetworkAvailable()) {
val favouriteIdList = favouriteBreedList.map { it.breedId }
val networkState = makeRequest(IO) {
apiService.getCatBreeds(offset = DEFAULT_PAGE_SIZE, pageNumber = position, "DESC")
}
networkState.getNetworkResult(
onSuccess = { response ->
val feedItems = response as? ArrayList<CatDetailItemResponse>
hasNext = !feedItems.isNullOrEmpty()
breedItemList = feedItems?.map { it.toCatBreedItem(favouriteIdList.contains(it.breedId)) } ?: emptyList()
} , onError = {
Log.e(TAG, it.toString())
breedItemList = favouriteBreedList.map { it.toCatBreedItem() }
}
)
} else {
breedItemList = favouriteBreedList.map { it.toCatBreedItem() }
}
return if (breedItemList.isNotEmpty()) {
LoadResult.Page(
data = breedItemList,
prevKey = if (position == initialPage) null else position.minus(1),
nextKey = if (!hasNext) null else position.plus(1)
)
} else {
LoadResult.Error(IOException(NO_INTERNET_CONNECTION))
}
} catch (ex: Exception) {
Log.e(TAG, ex.toString())
return LoadResult.Error(ex)
}
}
override fun getRefreshKey(state: PagingState<Int, CatBreedItemInfo>): Int? {
return state.anchorPosition?.let { anchorPosition ->
val anchorPage = state.closestPageToPosition(anchorPosition)
anchorPage?.prevKey?.plus(1) ?: anchorPage?.nextKey?.minus(1)
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/data/FeedDataSource.kt | 1798797971 |
package com.pandey.shubham.katty.feature.feed.data.dtos
import android.os.Parcelable
import androidx.annotation.Keep
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
/**
* Created by shubhampandey
*/
@Keep
@Parcelize
data class CatImageResponse(
val id: String?,
@SerializedName("url") val imageUrl: String?,
val width: Int?,
val height: Int?
): Parcelable | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/data/dtos/CatImageResponse.kt | 2831931266 |
package com.pandey.shubham.katty.feature.feed.data.dtos
import android.os.Parcelable
import androidx.annotation.Keep
import com.google.gson.annotations.SerializedName
import com.pandey.shubham.katty.core.utils.Utility
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
import kotlinx.parcelize.Parcelize
@Keep
@Parcelize
data class CatDetailItemResponse(
@SerializedName("id") val breedId: String,
val weight: Weight?,
val indoor: Int?,
val name: String?,
@SerializedName("reference_image_id")
val imageId: String?,
@SerializedName("alt_names") val alternateNames: String?,
val adaptability: Int?,
@SerializedName("affection_level") val affectionLevel: Int?,
val temperament: String?,
val description: String?,
val origin: String?,
@SerializedName("life_span") val lifeSpan: String?
): Parcelable {
fun toCatBreedItem(isFavourite: Boolean = false): CatBreedItemInfo {
return CatBreedItemInfo(
breedId = breedId,
imageUrl = Utility.getImageUrl(imageId), // TODO: get this from api.
name = name,
weight = weight,
temperament = temperament,
origin = origin,
description = description,
lifeSpan = lifeSpan,
isFavourite = isFavourite
)
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/data/dtos/CatDetailItemResponse.kt | 3208183692 |
package com.pandey.shubham.katty.feature.feed.data.dtos
import android.os.Parcelable
import androidx.annotation.Keep
import kotlinx.parcelize.Parcelize
@Keep
@Parcelize
class CatDetailResponse : ArrayList<CatDetailItemResponse>(), Parcelable | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/data/dtos/CatDetailResponse.kt | 3410963370 |
package com.pandey.shubham.katty.feature.feed.data.dtos
import android.os.Parcelable
import androidx.annotation.Keep
import kotlinx.parcelize.Parcelize
@Keep
@Parcelize
data class Weight(
val imperial: String?,
val metric: String?
): Parcelable | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/data/dtos/Weight.kt | 3002963338 |
package com.pandey.shubham.katty.feature.feed.domain.model
import androidx.annotation.Keep
import com.pandey.shubham.katty.core.database.CatBreedInfoEntity
import com.pandey.shubham.katty.feature.feed.data.dtos.Weight
@Keep
data class CatBreedItemInfo(
val breedId: String,
val imageUrl: String?,
val name: String?,
val weight: Weight?,
val temperament: String?,
val origin: String?,
val description: String?,
val lifeSpan:String?,
var isFavourite: Boolean = false
) {
fun toBreedInfoEntity(): CatBreedInfoEntity {
return CatBreedInfoEntity(
breedId = breedId,
imageUrl = imageUrl,
name = name,
weight = weight,
temperament = temperament,
origin = origin,
description = description,
lifeSpan = lifeSpan,
isFavourite = isFavourite,
createdAt = System.currentTimeMillis()
)
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/domain/model/CatBreedItemInfo.kt | 2950383048 |
package com.pandey.shubham.katty.feature.feed.domain.usecase
import androidx.lifecycle.LiveData
import androidx.paging.PagingData
import com.pandey.shubham.katty.core.base.UseCase
import com.pandey.shubham.katty.feature.feed.data.repository.FeedRepository
import com.pandey.shubham.katty.feature.feed.domain.model.CatBreedItemInfo
import kotlinx.coroutines.CoroutineScope
import javax.inject.Inject
/**
* Created by shubhampandey
*/
class GetFeedDataUseCase @Inject constructor(
private val feedRepository: FeedRepository
) : UseCase<Unit, LiveData<PagingData<CatBreedItemInfo>>>() {
override fun run(param: Unit?, scope: CoroutineScope) = feedRepository.getCatImagesPaginated()
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/domain/usecase/GetFeedDataUseCase.kt | 4217143526 |
package com.pandey.shubham.katty.feature.feed.domain.usecase
import com.pandey.shubham.katty.core.base.UseCase
import com.pandey.shubham.katty.core.database.CatBreedInfoEntity
import com.pandey.shubham.katty.core.network.NetworkState
import com.pandey.shubham.katty.core.utils.ERROR_ADDING_FAVOURITE
import com.pandey.shubham.katty.feature.feed.data.repository.FeedRepository
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import java.io.IOException
import javax.inject.Inject
/**
* Created by shubhampandey
*/
class AddFavoriteUseCase @Inject constructor(
private val repository: FeedRepository
) : UseCase<CatBreedInfoEntity, Flow<NetworkState<Boolean>>>() {
override fun run(param: CatBreedInfoEntity?, scope: CoroutineScope) = flow {
if (param == null) emit(NetworkState.Error(IOException(ERROR_ADDING_FAVOURITE)))
val result = repository.updateFavorite(param!!)
if (result.toInt() >= 0) {
emit(NetworkState.Success(true))
} else {
emit(NetworkState.Error(IOException(ERROR_ADDING_FAVOURITE)))
}
}
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/domain/usecase/AddFavoriteUseCase.kt | 3776347698 |
package com.pandey.shubham.katty.feature.feed.domain.usecase
import com.pandey.shubham.katty.core.base.UseCase
import com.pandey.shubham.katty.core.database.CatBreedInfoEntity
import com.pandey.shubham.katty.feature.feed.data.repository.FeedRepository
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
/**
* Created by shubhampandey
*/
class
GetFavouriteUseCase @Inject constructor(
private val repository: FeedRepository
) : UseCase<String, Flow<CatBreedInfoEntity?>>() {
override fun run(param: String?, scope: CoroutineScope): Flow<CatBreedInfoEntity?> = repository.getFavouriteFromDb(param)
} | katty/app/src/main/java/com/pandey/shubham/katty/feature/feed/domain/usecase/GetFavouriteUseCase.kt | 2446564714 |
package com.example.quizapp
import android.annotation.SuppressLint
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.RadioButton
import android.widget.RadioGroup
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
private lateinit var questionTextView: TextView
private lateinit var optionsRadioGroup: RadioGroup
private lateinit var submitButton: Button
private lateinit var feedbackTextView: TextView
private val questions = listOf(
Question("What is the capital of France?", listOf("Berlin", "Paris", "Madrid"), 1),
Question("Which planet is known as the Red Planet?", listOf("Venus", "Mars", "Jupiter"), 1)
// Add more questions as needed
)
private var currentQuestionIndex = 0
private val userAnswers = mutableMapOf<Int, Int>() // Map to store user answers (questionIndex -> selectedOptionIndex)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
questionTextView = findViewById(R.id.questionTextView)
optionsRadioGroup = findViewById(R.id.optionsRadioGroup)
submitButton = findViewById(R.id.submitButton)
feedbackTextView = findViewById(R.id.feedbackTextView)
displayQuestion()
submitButton.setOnClickListener {
checkAnswer()
}
}
private fun displayQuestion() {
val currentQuestion = questions[currentQuestionIndex]
questionTextView.text = currentQuestion.text
optionsRadioGroup.removeAllViews()
currentQuestion.options.forEachIndexed { index, option ->
val radioButton = RadioButton(this)
radioButton.text = option
radioButton.id = index
optionsRadioGroup.addView(radioButton)
}
}
@SuppressLint("SetTextI18n")
private fun checkAnswer() {
val selectedOptionIndex = optionsRadioGroup.checkedRadioButtonId
val currentQuestion = questions[currentQuestionIndex]
if (selectedOptionIndex == -1) {
// No option selected
showFeedback("Please select an option.")
} else {
// Store the user's answer
userAnswers[currentQuestionIndex] = selectedOptionIndex
// Display feedback
if (selectedOptionIndex == currentQuestion.correctOptionIndex) {
showFeedback("Question ${currentQuestionIndex + 1}: Correct!")
} else {
showFeedback("Question ${currentQuestionIndex + 1}: Incorrect. The correct answer is ${currentQuestion.options[currentQuestion.correctOptionIndex]}.")
}
}
// Move to the next question or finish the quiz
if (currentQuestionIndex < questions.size - 1) {
currentQuestionIndex++
displayQuestion()
} else {
// End of the quiz
submitButton.isEnabled = false
questionTextView.text = "Quiz completed!"
optionsRadioGroup.removeAllViews()
displayResults()
}
}
private fun showFeedback(message: String) {
feedbackTextView.append("$message\n")
}
private fun displayResults() {
feedbackTextView.append("\n\nResults:\n")
for ((questionIndex, selectedOptionIndex) in userAnswers) {
val currentQuestion = questions[questionIndex]
val isCorrect = selectedOptionIndex == currentQuestion.correctOptionIndex
val resultMessage = if (isCorrect) "Correct" else "Incorrect"
feedbackTextView.append("Question ${questionIndex + 1}: $resultMessage\n")
}
}
}
| bharatintern/MainActivity.kt | 3686056423 |
package com.example.quizapp
data class Question(
val text: String,
val options: List<String>,
val correctOptionIndex: Int
)
| bharatintern/Question.kt | 2512291229 |
package com.alopgal962.appfigma
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.alopgal962.appfigma", appContext.packageName)
}
} | AppFigma/app/src/androidTest/java/com/alopgal962/appfigma/ExampleInstrumentedTest.kt | 2123094164 |
package com.alopgal962.appfigma
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)
}
} | AppFigma/app/src/test/java/com/alopgal962/appfigma/ExampleUnitTest.kt | 3876324516 |
package com.alopgal962.appfigma.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) | AppFigma/app/src/main/java/com/alopgal962/appfigma/ui/theme/Color.kt | 2296833653 |
package com.alopgal962.appfigma.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 AppFigmaTheme(
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
)
} | AppFigma/app/src/main/java/com/alopgal962/appfigma/ui/theme/Theme.kt | 1391333466 |
package com.alopgal962.appfigma.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
)
*/
) | AppFigma/app/src/main/java/com/alopgal962/appfigma/ui/theme/Type.kt | 2066363721 |
package com.alopgal962.appfigma
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.alopgal962.appfigma.screens.Screenprinci
import com.alopgal962.appfigma.ui.theme.AppFigmaTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
AppFigmaTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
Screenprinci()
}
}
}
}
}
| AppFigma/app/src/main/java/com/alopgal962/appfigma/MainActivity.kt | 1816155887 |
package com.alopgal962.appfigma.screens
import android.annotation.SuppressLint
import android.util.Log
import android.view.RoundedCorner
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import com.alopgal962.appfigma.comparadorcomponentes.Comparadorcomponentes
import com.alopgal962.appfigma.comparadores.Comparadores
import com.alopgal962.appfigma.comparadorordenadores.Comparadorordenadores
import com.alopgal962.appfigma.comparadorprecio.Comparadorprecio
import com.alopgal962.appfigma.menuabajo.Menuabajo
import com.alopgal962.appfigma.menuarriba.Menuarriba
import com.alopgal962.appfigma.ofertas.Ofertas
import com.alopgal962.appfigma.ofertascomponentes.Ofertascomponentes
import com.alopgal962.appfigma.ofertasportatiles.Ofertasportatiles
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun Screenprinci() {
Scaffold(
topBar = {
Menuarriba(
textoABuscar = "",
modifier = Modifier.size(415.dp, 100.dp)) },
bottomBar = {
Menuabajo(
modifier = Modifier.size(415.dp, 80.dp),
onCasaTapped = { Log.d("CASA", "PULSADO-CASA") },
onBuscarTapped = { Log.d("BUSCAR", "PULSADO-BUSCAR") })
}) {
//Columna que muestra la pantalla del centr
Column(
modifier = Modifier
.fillMaxSize()
.padding(top = 100.dp, bottom = 80.dp)
.background(Color(240, 235, 242))
,
horizontalAlignment = Alignment.CenterHorizontally
) {
Row(Modifier.padding(top = 30.dp)) {
Ofertas(Modifier.size(120.dp, 35.dp))
}
Row(Modifier.padding(top = 30.dp)) {
Ofertasportatiles(
Modifier
.size(148.dp, 120.dp)
.clip(RoundedCornerShape(10.dp)))
Spacer(modifier = Modifier.padding(15.dp))
Ofertascomponentes(
Modifier
.size(148.dp, 120.dp)
.clip(RoundedCornerShape(10.dp)))
}
Row(Modifier.padding(top = 40.dp)) {
Comparadores(modifier = Modifier.size(140.dp, 35.dp))
}
Row(Modifier.padding(top = 40.dp)) {
Comparadorprecio(
Modifier
.size(148.dp, 120.dp)
.clip(RoundedCornerShape(10.dp)))
Spacer(modifier = Modifier.padding(15.dp))
Comparadorcomponentes(
Modifier
.size(148.dp, 120.dp)
.clip(RoundedCornerShape(10.dp)))
}
Row(Modifier.padding(top = 40.dp)) {
Comparadorordenadores(Modifier.size(328.dp,95.dp).clip(RoundedCornerShape(10.dp)))
}
}
}
} | AppFigma/app/src/main/java/com/alopgal962/appfigma/screens/Screens.kt | 3189771335 |
/**
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.codelabs.productimagesearch
import android.annotation.SuppressLint
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.drawable.BitmapDrawable
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import com.google.codelabs.productimagesearch.api.ProductSearchAPIClient
import com.google.codelabs.productimagesearch.databinding.ActivityProductSearchBinding
import com.google.codelabs.productimagesearch.api.ProductSearchResult
class ProductSearchActivity : AppCompatActivity() {
companion object {
const val TAG = "ProductSearchActivity"
const val CROPPED_IMAGE_FILE_NAME = "MLKitCroppedFile_"
const val REQUEST_TARGET_IMAGE_PATH = "REQUEST_TARGET_IMAGE_PATH"
}
private lateinit var viewBinding: ActivityProductSearchBinding
private lateinit var apiClient: ProductSearchAPIClient
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewBinding = ActivityProductSearchBinding.inflate(layoutInflater)
setContentView(viewBinding.root)
initViews()
// Receive the query image and show it on the screen
intent.getStringExtra(REQUEST_TARGET_IMAGE_PATH)?.let { absolutePath ->
viewBinding.ivQueryImage.setImageBitmap(BitmapFactory.decodeFile(absolutePath))
}
// Initialize an API client for Vision API Product Search
apiClient = ProductSearchAPIClient(this)
}
private fun initViews() {
// Setup RecyclerView
with(viewBinding.recyclerView) {
setHasFixedSize(true)
adapter = ProductSearchAdapter()
layoutManager =
LinearLayoutManager(
this@ProductSearchActivity,
LinearLayoutManager.VERTICAL,
false
)
}
// Events
viewBinding.btnSearch.setOnClickListener {
// Display progress
viewBinding.progressBar.visibility = View.VISIBLE
(viewBinding.ivQueryImage.drawable as? BitmapDrawable)?.bitmap?.let {
searchByImage(it)
}
}
}
/**
* Use Product Search API to search with the given query image
*/
private fun searchByImage(queryImage: Bitmap) {
apiClient.annotateImage(queryImage)
.addOnSuccessListener { showSearchResult(it) }
.addOnFailureListener { error ->
Log.e(TAG, "Error calling Vision API Product Search.", error)
showErrorResponse(error.localizedMessage)
}
}
/**
* Show search result.
*/
private fun showSearchResult(result: List<ProductSearchResult>) {
viewBinding.progressBar.visibility = View.GONE
// Update the recycler view to display the search result.
(viewBinding.recyclerView.adapter as? ProductSearchAdapter)?.submitList(
result
)
}
/**
* Show Error Response
*/
private fun showErrorResponse(message: String?) {
viewBinding.progressBar.visibility = View.GONE
// Show the error when calling API.
Toast.makeText(this, "Error: $message", Toast.LENGTH_SHORT).show()
}
}
/**
* Adapter RecyclerView
*/
class ProductSearchAdapter :
ListAdapter<ProductSearchResult, ProductSearchAdapter.ProductViewHolder>(diffCallback) {
companion object {
val diffCallback = object : DiffUtil.ItemCallback<ProductSearchResult>() {
override fun areItemsTheSame(
oldItem: ProductSearchResult,
newItem: ProductSearchResult
) = oldItem.imageId == newItem.imageId && oldItem.imageUri == newItem.imageUri
override fun areContentsTheSame(
oldItem: ProductSearchResult,
newItem: ProductSearchResult
) = oldItem == newItem
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = ProductViewHolder(
LayoutInflater.from(parent.context).inflate(R.layout.item_product, parent, false)
)
override fun onBindViewHolder(holder: ProductViewHolder, position: Int) {
holder.bind(getItem(position))
}
/**
* ViewHolder to hold the data inside
*/
class ProductViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
/**
* Bind data to views
*/
@SuppressLint("SetTextI18n")
fun bind(product: ProductSearchResult) {
with(itemView) {
findViewById<TextView>(R.id.tvProductName).text = "Name: ${product.name}"
findViewById<TextView>(R.id.tvProductScore).text = "Similarity score: ${product.score}"
findViewById<TextView>(R.id.tvProductLabel).text = "Labels: ${product.label}"
// Show the image using Glide
Glide.with(itemView).load(product.imageUri).into(findViewById(R.id.ivProduct))
}
}
}
}
| Product-image-search/app/src/main/java/com/google/codelabs/productimagesearch/ProductSearchActivity.kt | 3905042298 |
/**
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.codelabs.productimagesearch
import android.content.Intent
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.ImageDecoder
import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.os.Environment
import android.provider.MediaStore
import android.util.Log
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.FileProvider
import com.google.codelabs.productimagesearch.databinding.ActivityObjectDetectorBinding
import com.google.mlkit.vision.common.InputImage
import com.google.mlkit.vision.objects.DetectedObject
import com.google.mlkit.vision.objects.ObjectDetection
import com.google.mlkit.vision.objects.defaults.ObjectDetectorOptions
import com.google.mlkit.vision.objects.defaults.PredefinedCategory
import java.io.File
import java.io.FileOutputStream
import java.io.IOException
class ObjectDetectorActivity : AppCompatActivity() {
companion object {
private const val REQUEST_IMAGE_CAPTURE = 1000
private const val REQUEST_IMAGE_GALLERY = 1001
private const val TAKEN_BY_CAMERA_FILE_NAME = "MLKitDemo_"
private const val IMAGE_PRESET_1 = "Preset1.jpg"
private const val IMAGE_PRESET_2 = "Preset2.jpg"
private const val IMAGE_PRESET_3 = "Preset3.jpg"
private const val TAG = "MLKit-ODT"
}
private lateinit var viewBinding: ActivityObjectDetectorBinding
private var cameraPhotoUri: Uri? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewBinding = ActivityObjectDetectorBinding.inflate(layoutInflater)
setContentView(viewBinding.root)
initViews()
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
// After taking camera, display to Preview
if (resultCode == RESULT_OK) {
when (requestCode) {
REQUEST_IMAGE_CAPTURE -> cameraPhotoUri?.let {
this.setViewAndDetect(
getBitmapFromUri(it)
)
}
REQUEST_IMAGE_GALLERY -> data?.data?.let { this.setViewAndDetect(getBitmapFromUri(it)) }
}
}
}
private fun initViews() {
with(viewBinding) {
ivPreset1.setImageBitmap(getBitmapFromAsset(IMAGE_PRESET_1))
ivPreset2.setImageBitmap(getBitmapFromAsset(IMAGE_PRESET_2))
ivPreset3.setImageBitmap(getBitmapFromAsset(IMAGE_PRESET_3))
ivCapture.setOnClickListener { dispatchTakePictureIntent() }
ivGalleryApp.setOnClickListener { choosePhotoFromGalleryApp() }
ivPreset1.setOnClickListener { setViewAndDetect(getBitmapFromAsset(IMAGE_PRESET_1)) }
ivPreset2.setOnClickListener { setViewAndDetect(getBitmapFromAsset(IMAGE_PRESET_2)) }
ivPreset3.setOnClickListener { setViewAndDetect(getBitmapFromAsset(IMAGE_PRESET_3)) }
// Default display
setViewAndDetect(getBitmapFromAsset(IMAGE_PRESET_2))
// Callback received when the user taps on any of the detected objects.
ivPreview.setOnObjectClickListener { objectImage ->
startProductImageSearch(objectImage)
}
}
}
private fun startProductImageSearch(objectImage: Bitmap) {
try {
// Create file based Bitmap. We use PNG to preserve the image quality
val savedFile = createImageFile(ProductSearchActivity.CROPPED_IMAGE_FILE_NAME)
objectImage.compress(Bitmap.CompressFormat.PNG, 100, FileOutputStream(savedFile))
// Start the product search activity (using Vision Product Search API.).
startActivity(
Intent(
this,
ProductSearchActivity::class.java
).apply {
// As the size limit of a bundle is 1MB, we need to save the bitmap to a file
// and reload it in the other activity to support large query images.
putExtra(
ProductSearchActivity.REQUEST_TARGET_IMAGE_PATH,
savedFile.absolutePath
)
})
} catch (e: Exception) {
// IO Exception, Out Of memory ....
Toast.makeText(this, e.message, Toast.LENGTH_SHORT).show()
Log.e(TAG, "Error starting the product image search activity.", e)
}
}
/**
* Update the UI with the input image and start object detection
*/
private fun setViewAndDetect(bitmap: Bitmap?) {
bitmap?.let {
// Clear the dots indicating the previous detection result
viewBinding.ivPreview.drawDetectionResults(emptyList())
// Display the input image on the screen.
viewBinding.ivPreview.setImageBitmap(bitmap)
// Run object detection and show the detection results.
runObjectDetection(bitmap)
}
}
/**
* Detect Objects in a given Bitmap
*/
private fun runObjectDetection(bitmap: Bitmap) {
// Step 1: create ML Kit's InputImage object
val image = InputImage.fromBitmap(bitmap, 0)
// Step 2: acquire detector object
val options = ObjectDetectorOptions.Builder()
.setDetectorMode(ObjectDetectorOptions.SINGLE_IMAGE_MODE)
.enableMultipleObjects()
.enableClassification()
.build()
val objectDetector = ObjectDetection.getClient(options)
// Step 3: feed given image to detector and setup callback
objectDetector.process(image)
.addOnSuccessListener { results ->
// Keep only the FASHION_GOOD objects
val filteredResults = results.filter { result ->
result.labels.indexOfFirst { it.text == PredefinedCategory.FASHION_GOOD } != -1
}
// Visualize the detection result
runOnUiThread {
viewBinding.ivPreview.drawDetectionResults(filteredResults)
}
}
.addOnFailureListener {
// Task failed with an exception
Log.e(TAG, it.message.toString())
}
}
/**
* Show Camera App to take a picture based Intent
*/
private fun dispatchTakePictureIntent() {
Intent(MediaStore.ACTION_IMAGE_CAPTURE).also { takePictureIntent ->
// Ensure that there's a camera activity to handle the intent
takePictureIntent.resolveActivity(packageManager)?.also {
// Create the File where the photo should go
val photoFile: File? = try {
createImageFile(TAKEN_BY_CAMERA_FILE_NAME)
} catch (ex: IOException) {
// Error occurred while creating the File
null
}
// Continue only if the File was successfully created
photoFile?.also {
cameraPhotoUri = FileProvider.getUriForFile(
this,
"com.google.codelabs.productimagesearch.fileprovider",
it
)
// Setting output file to take a photo
takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, cameraPhotoUri)
// Open camera based Intent.
startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE)
}
} ?: run {
Toast.makeText(this, getString(R.string.camera_app_not_found), Toast.LENGTH_LONG)
.show()
}
}
}
/**
* Show gallery app to pick photo from intent.
*/
private fun choosePhotoFromGalleryApp() {
startActivityForResult(Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
type = "image/*"
addCategory(Intent.CATEGORY_OPENABLE)
}, REQUEST_IMAGE_GALLERY)
}
/**
* The output file will be stored on private storage of this app
* By calling function getExternalFilesDir
* This photo will be deleted when uninstall app.
*/
@Throws(IOException::class)
private fun createImageFile(fileName: String): File {
// Create an image file name
val storageDir: File? = getExternalFilesDir(Environment.DIRECTORY_PICTURES)
return File.createTempFile(
fileName, /* prefix */
".jpg", /* suffix */
storageDir /* directory */
)
}
/**
* Method to copy asset files sample to private app folder.
* Return the Uri of an output file.
*/
private fun getBitmapFromAsset(fileName: String): Bitmap? {
return try {
BitmapFactory.decodeStream(assets.open(fileName))
} catch (ex: IOException) {
null
}
}
/**
* Function to get the Bitmap From Uri.
* Uri is received by using Intent called to Camera or Gallery app
* SuppressWarnings => we have covered this warning.
*/
private fun getBitmapFromUri(imageUri: Uri): Bitmap? {
val bitmap = try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
ImageDecoder.decodeBitmap(ImageDecoder.createSource(contentResolver, imageUri))
} else {
// Add Suppress annotation to skip warning by Android Studio.
// This warning resolved by ImageDecoder function.
@Suppress("DEPRECATION")
MediaStore.Images.Media.getBitmap(contentResolver, imageUri)
}
} catch (ex: IOException) {
null
}
// Make a copy of the bitmap in a desirable format
return bitmap?.copy(Bitmap.Config.ARGB_8888, false)
}
/**
* Function to log information about object detected by ML Kit.
*/
private fun debugPrint(detectedObjects: List<DetectedObject>) {
detectedObjects.forEachIndexed { index, detectedObject ->
val box = detectedObject.boundingBox
Log.d(TAG, "Detected object: $index")
Log.d(TAG, " trackingId: ${detectedObject.trackingId}")
Log.d(TAG, " boundingBox: (${box.left}, ${box.top}) - (${box.right},${box.bottom})")
detectedObject.labels.forEach {
Log.d(TAG, " categories: ${it.text}")
Log.d(TAG, " confidence: ${it.confidence}")
}
}
}
}
| Product-image-search/app/src/main/java/com/google/codelabs/productimagesearch/ObjectDetectorActivity.kt | 881877090 |
/**
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.codelabs.productimagesearch.api
/**
* Class to mapping with search result response
*/
data class SearchResultResponse(val responses: List<Response>?)
data class Response(
val productSearchResults: ProductSearchResults?
)
data class ProductSearchResults(
val indexTime: String,
val results: List<Result>,
val productGroupedResults: List<ProductGroupedResult>
)
data class ProductGroupedResult(
val boundingPoly: BoundingPoly,
val results: List<Result>
)
data class BoundingPoly(
val normalizedVertices: List<NormalizedVertex>
)
data class NormalizedVertex(
val x: Double,
val y: Double
)
data class Result(
val product: Product,
val score: Double,
val image: String
)
data class Product(
val name: String,
val displayName: String,
val productCategory: String,
val productLabels: List<ProductLabel>
)
data class ProductLabel(
val key: String,
val value: String
)
/**
* Transformed product search result.
*/
data class ProductSearchResult(
val imageId: String,
val score: Double,
val label: String,
val name: String,
var imageUri: String? = null
) | Product-image-search/app/src/main/java/com/google/codelabs/productimagesearch/api/SearchResult.kt | 647958194 |
/**
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.codelabs.productimagesearch.api
import android.content.Context
import android.graphics.Bitmap
import android.util.Base64
import android.util.Log
import com.android.volley.toolbox.JsonObjectRequest
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import com.google.android.gms.tasks.Task
import com.google.android.gms.tasks.TaskCompletionSource
import com.google.android.gms.tasks.Tasks
import com.google.codelabs.productimagesearch.ProductSearchActivity
import com.google.gson.Gson
import com.google.gson.JsonSyntaxException
import org.json.JSONObject
import java.io.ByteArrayOutputStream
class ProductSearchAPIClient(context: Context){
companion object {
const val VISION_API_PRODUCT_MAX_RESULT = 5
// Define the product search backend
// Option 1: Use the demo project that we have already deployed for you
const val VISION_API_URL =
"https://us-central1-odml-codelabs.cloudfunctions.net/productSearch"
const val VISION_API_KEY = ""
const val VISION_API_PROJECT_ID = "odml-codelabs"
const val VISION_API_LOCATION_ID = "us-east1"
const val VISION_API_PRODUCT_SET_ID = "product_set0"
// Option 2: Go through the Vision API Product Search quickstart and deploy to your project.
// Fill in the const below with your project info.
// const val VISION_API_URL = "https://vision.googleapis.com/v1"
// const val VISION_API_KEY = "YOUR_API_KEY"
// const val VISION_API_PROJECT_ID = "YOUR_PROJECT_ID"
// const val VISION_API_LOCATION_ID = "YOUR_LOCATION_ID"
// const val VISION_API_PRODUCT_SET_ID = "YOUR_PRODUCT_SET_ID"
}
// Instantiate the RequestQueue.
private val requestQueue = Volley.newRequestQueue(context)
/**
* Convert an image to its Base64 representation
*/
private fun convertBitmapToBase64(bitmap: Bitmap): String {
val byteArrayOutputStream = ByteArrayOutputStream()
bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream)
val byteArray: ByteArray = byteArrayOutputStream.toByteArray()
return Base64.encodeToString(byteArray, Base64.DEFAULT)
}
/**
* Use Product Search API to search with the given query image
* Call the projects.locations.images.annotate endpoint.
*/
fun annotateImage(image: Bitmap): Task<List<ProductSearchResult>> {
// Initialization to use the Task API
val apiSource = TaskCompletionSource<List<ProductSearchResult>>()
val apiTask = apiSource.task
// Convert the query image to its Base64 representation to call the Product Search API.
val base64: String = convertBitmapToBase64(image)
// Craft the request body JSON.
val requestJson = """
{
"requests": [
{
"image": {
"content": """".trimIndent() + base64 + """"
},
"features": [
{
"type": "PRODUCT_SEARCH",
"maxResults": $VISION_API_PRODUCT_MAX_RESULT
}
],
"imageContext": {
"productSearchParams": {
"productSet": "projects/${VISION_API_PROJECT_ID}/locations/${VISION_API_LOCATION_ID}/productSets/${VISION_API_PRODUCT_SET_ID}",
"productCategories": [
"apparel-v2"
]
}
}
}
]
}
""".trimIndent()
// Add a new request to the queue
requestQueue.add(object :
JsonObjectRequest(
Method.POST,
"$VISION_API_URL/images:annotate?key=$VISION_API_KEY",
JSONObject(requestJson),
{ response ->
// Parse the API JSON response to a list of ProductSearchResult object/
val productList = apiResponseToObject(response)
// Return the list.
// Loop through the product list and create tasks to load reference images.
// We will call the projects.locations.products.referenceImages.get endpoint
// for each product.
val fetchReferenceImageTasks = productList.map { fetchReferenceImage(it) }
// When all reference image fetches have completed,
// return the ProductSearchResult list
Tasks.whenAllComplete(fetchReferenceImageTasks)
// Return the list of ProductSearchResult with product images' HTTP URLs.
.addOnSuccessListener { apiSource.setResult(productList) }
// An error occurred so returns it to the caller.
.addOnFailureListener { apiSource.setException(it) } },
// Return the error
{ error -> apiSource.setException(error) }
) {
override fun getBodyContentType() = "application/json"
}.apply {
setShouldCache(false)
})
return apiTask
}
/**
* Fetch and transform product image
* Call the projects.locations.products.referenceImages.get endpoint
*/
private fun fetchReferenceImage(searchResult: ProductSearchResult): Task<ProductSearchResult> {
// Initialization to use the Task API
val apiSource = TaskCompletionSource<ProductSearchResult>()
val apiTask = apiSource.task
// Craft the API request to get details about the reference image of the product
val stringRequest = object : StringRequest(
Method.GET,
"$VISION_API_URL/${searchResult.imageId}?key=$VISION_API_KEY",
{ response ->
val responseJson = JSONObject(response)
val gcsUri = responseJson.getString("uri")
// Convert the GCS URL to its HTTPS representation
val httpUri = gcsUri.replace("gs://", "https://storage.googleapis.com/")
// Save the HTTPS URL to the search result object
searchResult.imageUri = httpUri
// Invoke the listener to continue with processing the API response (eg. show on UI)
apiSource.setResult(searchResult)
},
{ error -> apiSource.setException(error) }
) {
override fun getBodyContentType(): String {
return "application/json; charset=utf-8"
}
}
Log.d(ProductSearchActivity.TAG, "Sending API request.")
// Add the request to the RequestQueue.
requestQueue.add(stringRequest)
return apiTask
}
/**
* Convert the JSON API response to a list of ProductSearchResult objects
*/
@Throws(JsonSyntaxException::class)
private fun apiResponseToObject(response: JSONObject): List<ProductSearchResult> {
// Parse response JSON string into objects.
val productSearchResults = mutableListOf<ProductSearchResult>()
val searchResult =
Gson().fromJson(response.toString(), SearchResultResponse::class.java)
Log.d(ProductSearchActivity.TAG, "results: $searchResult")
searchResult.responses?.get(0)?.productSearchResults?.results?.forEach { result ->
productSearchResults.add(
ProductSearchResult(
result.image,
result.score,
result.product.productLabels.joinToString { "${it.key} - ${it.value}" },
result.product.name
)
)
}
return productSearchResults
}
}
| Product-image-search/app/src/main/java/com/google/codelabs/productimagesearch/api/ProductSearchAPIClient.kt | 3775304308 |
/**
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.codelabs.productimagesearch
import android.annotation.SuppressLint
import android.content.Context
import android.graphics.*
import android.graphics.drawable.BitmapDrawable
import android.util.AttributeSet
import android.util.Log
import android.view.MotionEvent
import androidx.appcompat.widget.AppCompatImageView
import com.google.mlkit.vision.objects.DetectedObject
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.pow
/**
* Customize ImageView which can be clickable on some Detection Result Bound.
*/
class ImageClickableView : AppCompatImageView {
companion object {
private const val TAG = "ImageClickableView"
private const val CLICKABLE_RADIUS = 40f
private const val SHADOW_RADIUS = 10f
}
private val dotPaint = createDotPaint()
private var onObjectClickListener: ((cropBitmap: Bitmap) -> Unit)? = null
// This variable is used to hold the actual size of bounding box detection result due to
// the ratio might changed after Bitmap fill into ImageView
private var transformedResults = listOf<TransformedDetectionResult>()
constructor(context: Context) : super(context)
constructor(context: Context, attrs: AttributeSet) : super(context, attrs)
/**
* Callback when user click to detection result rectangle.
*/
fun setOnObjectClickListener(listener: ((objectImage: Bitmap) -> Unit)) {
this.onObjectClickListener = listener
}
/**
* Draw white circle at the center of each detected object on the image
*/
fun drawDetectionResults(results: List<DetectedObject>) {
(drawable as? BitmapDrawable)?.bitmap?.let { srcImage ->
// Get scale size based width/height
val scaleFactor =
max(srcImage.width / width.toFloat(), srcImage.height / height.toFloat())
// Calculate the total padding (based center inside scale type)
val diffWidth = abs(width - srcImage.width / scaleFactor) / 2
val diffHeight = abs(height - srcImage.height / scaleFactor) / 2
// Transform the original Bounding Box to actual bounding box based the display size of ImageView.
transformedResults = results.map { result ->
// Calculate to create new coordinates of Rectangle Box match on ImageView.
val actualRectBoundingBox = RectF(
(result.boundingBox.left / scaleFactor) + diffWidth,
(result.boundingBox.top / scaleFactor) + diffHeight,
(result.boundingBox.right / scaleFactor) + diffWidth,
(result.boundingBox.bottom / scaleFactor) + diffHeight
)
val dotCenter = PointF(
(actualRectBoundingBox.right + actualRectBoundingBox.left) / 2,
(actualRectBoundingBox.bottom + actualRectBoundingBox.top) / 2,
)
// Transform to new object to hold the data inside.
// This object is necessary to avoid performance
TransformedDetectionResult(actualRectBoundingBox, result.boundingBox, dotCenter)
}
Log.d(
TAG,
"srcImage: ${srcImage.width}/${srcImage.height} - imageView: ${width}/${height} => scaleFactor: $scaleFactor"
)
// Invalid to re-draw the canvas
// Method onDraw will be called with new data.
invalidate()
}
}
override fun onDraw(canvas: Canvas) {
super.onDraw(canvas)
// Getting detection results and draw the dot view onto detected object.
transformedResults.forEach { result ->
// Draw Dot View
canvas.drawCircle(result.dotCenter.x, result.dotCenter.y, CLICKABLE_RADIUS, dotPaint)
}
}
@SuppressLint("ClickableViewAccessibility")
override fun onTouchEvent(event: MotionEvent): Boolean {
when (event.action) {
MotionEvent.ACTION_DOWN -> {
val touchX = event.x
val touchY = event.y
val index =
transformedResults.indexOfFirst {
val dx = (touchX - it.dotCenter.x).toDouble().pow(2.0)
val dy = (touchY - it.dotCenter.y).toDouble().pow(2.0)
(dx + dy) < CLICKABLE_RADIUS.toDouble().pow(2.0)
}
// If a matching object found, call the objectClickListener
if (index != -1) {
cropBitMapBasedResult(transformedResults[index])?.let {
onObjectClickListener?.invoke(it)
}
}
}
}
return super.onTouchEvent(event)
}
/**
* This function will be used to crop the segment of Bitmap based touching by user.
*/
private fun cropBitMapBasedResult(result: TransformedDetectionResult): Bitmap? {
// Crop image from Original Bitmap with Original Rect Bounding Box
(drawable as? BitmapDrawable)?.bitmap?.let {
return Bitmap.createBitmap(
it,
result.originalBoxRectF.left,
result.originalBoxRectF.top,
result.originalBoxRectF.width(),
result.originalBoxRectF.height()
)
}
return null
}
/**
* Return Dot Paint to draw circle
*/
private fun createDotPaint() = Paint(Paint.ANTI_ALIAS_FLAG).apply {
color = Color.WHITE
style = Paint.Style.FILL
setShadowLayer(SHADOW_RADIUS, 0F, 0F, Color.BLACK)
// Force to use software to render by disable hardware acceleration.
// Important: the shadow will not work without this line.
setLayerType(LAYER_TYPE_SOFTWARE, this)
}
}
/**
* This class holds the transformed data
* @property: actualBoxRectF: The bounding box after calculated
* @property: originalBoxRectF: The original bounding box (Before transformed), use for crop bitmap.
*/
data class TransformedDetectionResult(
val actualBoxRectF: RectF,
val originalBoxRectF: Rect,
val dotCenter: PointF
)
| Product-image-search/app/src/main/java/com/google/codelabs/productimagesearch/ImageClickableView.kt | 293288338 |
package com.flagg.msu.count
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.flagg.msu.count", appContext.packageName)
}
} | Count/app/src/androidTest/java/com/flagg/msu/count/ExampleInstrumentedTest.kt | 878685069 |
package com.flagg.msu.count
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)
}
} | Count/app/src/test/java/com/flagg/msu/count/ExampleUnitTest.kt | 2100500925 |
package com.flagg.msu.count
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.TextView
class MainActivity: AppCompatActivity() {
private lateinit var tap_button: Button
private lateinit var tap_count: TextView
private val count = Counter()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
tap_button = findViewById(R.id.tap_button)
tap_count = findViewById(R.id.tap_count)
tap_button.setOnClickListener {
count.addCount()
tap_count.text = count.getCount().toString()
}
}
class Counter {
private var count: Int = 0
fun addCount() {
count++
}
fun getCount(): Int {
return count
}
}
}
| Count/app/src/main/java/com/flagg/msu/count/MainActivity.kt | 3086545751 |
package hr.foi.rampu.jetpackcomposebasics
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("hr.foi.rampu.jetpackcomposebasics", appContext.packageName)
}
} | Jetpack-Compose-Basics/app/src/androidTest/java/hr/foi/rampu/jetpackcomposebasics/ExampleInstrumentedTest.kt | 2692772171 |
package hr.foi.rampu.jetpackcomposebasics
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)
}
} | Jetpack-Compose-Basics/app/src/test/java/hr/foi/rampu/jetpackcomposebasics/ExampleUnitTest.kt | 2031528875 |
package hr.foi.rampu.jetpackcomposebasics.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)
val Navy = Color(0xFF073042)
val Blue = Color(0xFF4285F4)
val LightBlue = Color(0xFFD7EFFE)
val Chartreuse = Color(0xFFEFF7CF) | Jetpack-Compose-Basics/app/src/main/java/hr/foi/rampu/jetpackcomposebasics/ui/theme/Color.kt | 3703088050 |
package hr.foi.rampu.jetpackcomposebasics.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.Color
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(
surface = Blue,
onSurface = Navy,
primary = Navy,
onPrimary = Chartreuse
)
private val LightColorScheme = lightColorScheme(
primary = LightBlue,
surface = Blue,
onSurface = Color.White,
onPrimary = Navy
/* 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 JetpackComposeBasicsTheme(
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
)
} | Jetpack-Compose-Basics/app/src/main/java/hr/foi/rampu/jetpackcomposebasics/ui/theme/Theme.kt | 2902194039 |
package hr.foi.rampu.jetpackcomposebasics.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
)
*/
) | Jetpack-Compose-Basics/app/src/main/java/hr/foi/rampu/jetpackcomposebasics/ui/theme/Type.kt | 3634125787 |
package hr.foi.rampu.jetpackcomposebasics
import android.content.res.Configuration.UI_MODE_NIGHT_YES
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.animation.animateContentSize
import androidx.compose.animation.core.FastOutSlowInEasing
import androidx.compose.animation.core.animateDpAsState
import androidx.compose.animation.core.tween
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ExpandLess
import androidx.compose.material.icons.filled.ExpandMore
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import hr.foi.rampu.jetpackcomposebasics.ui.theme.JetpackComposeBasicsTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
JetpackComposeBasicsTheme {
MyApp(modifier = Modifier.fillMaxSize())
}
}
}
}
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
var expanded by rememberSaveable {
mutableStateOf(false)
}
Surface(
color = MaterialTheme.colorScheme.primary,
modifier = modifier.padding(vertical = 4.dp, horizontal = 8.dp)
){
Row(modifier = modifier
.padding(12.dp)
.animateContentSize(
animationSpec = tween(
durationMillis = 350,
easing = FastOutSlowInEasing
)
)){
Column(
modifier = Modifier
.weight(1f)
.padding(12.dp)
) {
Text(text = "Hello,")
Text (
text = name,
style = MaterialTheme.typography.headlineMedium.copy(
fontWeight = FontWeight.ExtraBold
)
)
if(expanded) {
Text(
text = ("Composem ipsum color sit lazy, " +
"padding theme elit, sed do bouncy.").repeat(4)
)
}
}
IconButton(
onClick = { expanded = !expanded }
) {
Icon(
imageVector = if(expanded) Icons.Filled.ExpandLess else Icons.Filled.ExpandMore,
if (expanded)
stringResource(R.string.show_less)
else
stringResource(R.string.show_more)
)
}
}
}
}
@Composable
fun Greetings(
modifier: Modifier = Modifier,
names: List<String> = List(30) {"$it"}
){
LazyColumn(modifier = modifier.padding(vertical = 4.dp)) {
items(items = names){ name ->
Greeting(name = name)
}
}
}
@Composable
fun MyApp(
modifier: Modifier = Modifier
){
Surface(
modifier = modifier,
color = MaterialTheme.colorScheme.background
) {
var shouldShowOnboarding by rememberSaveable { mutableStateOf(true) }
if(shouldShowOnboarding){
OnboardingScreen(onContinueClicked = { shouldShowOnboarding = false})
}else{
Greetings()
}
}
}
@Composable
fun OnboardingScreen(
onContinueClicked: () -> Unit,
modifier: Modifier = Modifier
){
var shouldShowOnboarding by rememberSaveable {
mutableStateOf(true)
}
Column(
modifier = modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
){
Text("Welcome to the Basics Codelab")
Button(
modifier = Modifier.padding(vertical = 24.dp),
onClick = onContinueClicked
) {
Text(text = "Continue")
}
}
}
//@Preview(
// showBackground = true,
// widthDp = 320,
// uiMode = UI_MODE_NIGHT_YES,
// name = "GreetingsDarkPreview"
//)
@Preview(showBackground = true, widthDp = 320)
@Composable
fun GreetingPreview() {
JetpackComposeBasicsTheme {
Greetings()
}
}
//@Preview(showBackground = true, widthDp = 320)
//@Composable
//fun OnBoardingPreview() {
// JetpackComposeBasicsTheme {
// OnboardingScreen(onContinueClicked = {})
// }
//} | Jetpack-Compose-Basics/app/src/main/java/hr/foi/rampu/jetpackcomposebasics/MainActivity.kt | 639741504 |
package com.example.loginv4
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.loginv4", appContext.packageName)
}
} | loginv4/app/src/androidTest/java/com/example/loginv4/ExampleInstrumentedTest.kt | 582652026 |
package com.example.loginv4
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)
}
} | loginv4/app/src/test/java/com/example/loginv4/ExampleUnitTest.kt | 1977430916 |
package com.example.loginv4
import android.os.Bundle
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat
class inicio : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContentView(R.layout.activity_inicio)
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
insets
}
}
} | loginv4/app/src/main/java/com/example/loginv4/inicio.kt | 2113770326 |
package com.example.loginv4
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.TextView
import android.widget.Toast
//import com.google.firebase.Firebase
import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.ktx.auth
import com.google.firebase.ktx.Firebase
class MainActivity : AppCompatActivity() {
private lateinit var firebaseAuth: FirebaseAuth
private lateinit var auth: FirebaseAuth.AuthStateListener
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val btningresar: Button = findViewById(R.id.ButtonAccess)
val btnadd: Button = findViewById(R.id.ButtonAdd)
val emailtxt: TextView = findViewById(R.id.emailText)
val passtxt: TextView = findViewById(R.id.passwortText)
firebaseAuth = Firebase.auth
btningresar.setOnClickListener() {
if(emailtxt.text.isNotEmpty() && passtxt.text.isNotEmpty()){
singIn(emailtxt.text.toString(), passtxt.text.toString())
}
else{
Toast.makeText(baseContext, "Error de email y/o contrasena esta en blanco", Toast.LENGTH_SHORT)
.show()
}
}
}
private fun singIn(email: String, password: String) {
firebaseAuth.signInWithEmailAndPassword(email, password).addOnCompleteListener(this) {
task ->
if (task.isSuccessful) {
val user = firebaseAuth.currentUser
Toast.makeText(baseContext, user?.uid.toString(), Toast.LENGTH_SHORT).show()
val i = Intent(this, inicio::class.java)
startActivity(i)
} else {
Toast.makeText(baseContext, "Error de email y/o contrasena", Toast.LENGTH_SHORT)
.show()
}
}
}
}
/*Hola este es un comentario de prueba*/
//fun main (){
// print( "hola")
// Write a message to the database
//val database = Firebase.database
// val myRef = database.getReference("message")
// myRef.setValue("Hello, World!")
| loginv4/app/src/main/java/com/example/loginv4/MainActivity.kt | 158364182 |
package io.github.christianfajardo.randomuser
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.*
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("io.github.kabirnayeem99.friends", appContext.packageName)
}
} | RandomuserMVVM/app/src/androidTest/java/io/github/christianfajardo/randomuser/ExampleInstrumentedTest.kt | 355587428 |
package io.github.christianfajardo.randomuser.viewmodels
import junit.framework.TestCase
class UserViewModelTest : TestCase() {
public override fun setUp() {
super.setUp()
}
} | RandomuserMVVM/app/src/test/java/io/github/christianfajardo/randomuser/viewmodels/UserViewModelTest.kt | 2205400045 |
package io.github.christianfajardo.randomuser
import org.junit.Test
import org.junit.Assert.*
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | RandomuserMVVM/app/src/test/java/io/github/christianfajardo/randomuser/ExampleUnitTest.kt | 384086900 |
package io.github.christianfajardo.randomuser.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import io.github.christianfajardo.randomuser.BuildConfig
import io.github.christianfajardo.randomuser.data.sources.RemoteDataSource
import io.github.christianfajardo.randomuser.utils.Constants.BASE_URL
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.adapter.rxjava3.RxJava3CallAdapterFactory
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class NetworkModule {
@Singleton
@Provides
fun providesHttpLoggingInterceptor(): HttpLoggingInterceptor {
val levelType: HttpLoggingInterceptor.Level =
if (BuildConfig.BUILD_TYPE.contentEquals("debug"))
HttpLoggingInterceptor.Level.BODY
else
HttpLoggingInterceptor.Level.NONE
return HttpLoggingInterceptor()
.apply {
level = levelType
}
}
@Singleton
@Provides
fun providesOkHttpClient(
httpLoggingInterceptor: HttpLoggingInterceptor,
): OkHttpClient =
OkHttpClient
.Builder()
.addInterceptor(httpLoggingInterceptor)
.readTimeout(10L, TimeUnit.SECONDS)
.writeTimeout(10L, TimeUnit.SECONDS)
.build()
@Singleton
@Provides
fun provideRxJavaCallAdapterFactory(): RxJava3CallAdapterFactory =
RxJava3CallAdapterFactory.create()
@Singleton
@Provides
fun provideGsonConverter(): GsonConverterFactory =
GsonConverterFactory.create()
@Singleton
@Provides
fun provideRetrofit(
okHttpClient: OkHttpClient,
rxAdapter: RxJava3CallAdapterFactory,
gsonConverter: GsonConverterFactory
): Retrofit = Retrofit.Builder()
.addConverterFactory(gsonConverter)
.baseUrl(BASE_URL)
.client(okHttpClient)
.addCallAdapterFactory(rxAdapter)
.build()
@Singleton
@Provides
fun provideRemoteDataSource(retrofit: Retrofit): RemoteDataSource =
retrofit.create(RemoteDataSource::class.java)
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/di/NetworkModule.kt | 1758362025 |
package io.github.christianfajardo.randomuser.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.components.ViewModelComponent
import io.github.christianfajardo.randomuser.data.repository.RandomUserRepositoryImpl
import io.github.christianfajardo.randomuser.data.sources.RemoteDataSource
import io.github.christianfajardo.randomuser.domain.repository.RandomUserRepository
@Module
@InstallIn(ViewModelComponent::class)
class ViewModelModule {
@Provides
fun providesRepository(remoteDataSource: RemoteDataSource): RandomUserRepository =
RandomUserRepositoryImpl(remoteDataSource)
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/di/ViewModelModule.kt | 1672959666 |
package io.github.christianfajardo.randomuser.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.components.ActivityComponent
import io.github.christianfajardo.randomuser.presentation.landing.UserAdapter
import io.reactivex.rxjava3.disposables.CompositeDisposable
@Module
@InstallIn(ActivityComponent::class)
class ActivityModule {
@Provides
fun provideUserAdapter(): UserAdapter = UserAdapter()
@Provides
fun provideCompositeDisposable(): CompositeDisposable = CompositeDisposable()
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/di/ActivityModule.kt | 3701125588 |
package io.github.christianfajardo.randomuser
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class RandomUser : Application() | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/RandomUser.kt | 2475862699 |
package io.github.christianfajardo.randomuser.utils
import android.util.Log
import io.github.christianfajardo.randomuser.BuildConfig
fun Exception.print(tag: String, functionName: String) {
if (BuildConfig.DEBUG) {
Log.e(
tag, "$functionName: ${
this.message ?: "An unknown error has occurred"
}", this
)
}
}
| RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/utils/UtilitiesExtensions.kt | 428643878 |
package io.github.christianfajardo.randomuser.utils
/**
* Generic Resource class
* for more sophisticated status and
* error handling
*
* This sealed class holds, three state,
*
* [Success], which takes the data as a parameter
*
* [Error], which takes error message [String] as a param
*
* [Loading], which takes no param
*
*/
sealed class Resource<T>(
val data: T? = null,
val message: String? = null
) {
/**
* Signifies the successful state,
* which may mean the data has been returned successfully
*
* takes the data (of [Any] type) as a parameter
*/
class Success<T>(data: T) : Resource<T>(data)
/**
* Signifies the error state,
* which means the data could not be loaded,
* but there has been provided an error message
* to inform about the issue.
*
* takes the error message ([String]) as a parameter
*/
class Error<T>(message: String, data: T? = null) : Resource<T>(data, message)
/**
* Signifies the loading state,
* which means the data is not loaded yet,
* it is currently processing
*/
class Loading<T> : Resource<T>()
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/utils/Resource.kt | 1697901732 |
package io.github.christianfajardo.randomuser.utils
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.schedulers.Schedulers
object NetworkUtilities {
/**
* Observers network status
*/
fun observerNetwork(): Observable<Boolean> {
val command = "ping -c 1 example.com"
return Observable.just(Runtime.getRuntime().exec(command).waitFor() == 0)
.observeOn(Schedulers.io())
.onErrorReturn { false }
}
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/utils/NetworkUtilities.kt | 1467656756 |
package io.github.christianfajardo.randomuser.utils
/**
* This class holds all the app level constants,
* that won't change during the execution time of
* this application
*/
object Constants {
/**
* Wi-Fi settings action name to open it directly with implicit intent
*/
const val WIFI_SETTING_ACTION: String = "android.settings.WIFI_SETTINGS"
/**
* The base API URL to fetch the data from
*/
const val BASE_URL: String = "https://randomuser.me/api/"
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/utils/Constants.kt | 3123623710 |
package io.github.christianfajardo.randomuser.data.repository
import io.github.christianfajardo.randomuser.data.sources.RemoteDataSource
import io.github.christianfajardo.randomuser.domain.model.User
import io.github.christianfajardo.randomuser.domain.repository.RandomUserRepository
import io.github.christianfajardo.randomuser.utils.Resource
import io.reactivex.rxjava3.core.Flowable
import io.reactivex.rxjava3.schedulers.Schedulers
import javax.inject.Inject
class RandomUserRepositoryImpl @Inject constructor(private var remoteDataSource: RemoteDataSource) :
RandomUserRepository {
override fun getUserList(): Flowable<Resource<List<User>>> {
return remoteDataSource.getResponse()
.retry(3)
.observeOn(Schedulers.io())
.map { apiResponse ->
Resource.Success(apiResponse.userList) as Resource<List<User>>
}
.onErrorReturnItem(Resource.Error("An error has occurred"))
}
}
| RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/data/repository/RandomUserRepositoryImpl.kt | 2892691585 |
package io.github.christianfajardo.randomuser.data.sources
import io.github.christianfajardo.randomuser.domain.model.ApiResponse
import io.reactivex.rxjava3.core.Flowable
import retrofit2.Call
import retrofit2.http.GET
import retrofit2.http.Query
interface RemoteDataSource {
@GET(".")
fun getResponse(
@Query("results") resultAmount: Int = 100
): Flowable<ApiResponse>
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/data/sources/RemoteDataSource.kt | 4045051488 |
package io.github.christianfajardo.randomuser.domain.repository
import io.github.christianfajardo.randomuser.domain.model.User
import io.github.christianfajardo.randomuser.utils.Resource
import io.reactivex.rxjava3.core.Flowable
interface RandomUserRepository {
fun getUserList(): Flowable<Resource<List<User>>>
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/repository/RandomUserRepository.kt | 2724882404 |
package io.github.christianfajardo.randomuser.domain.model
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class Registered(
@SerializedName("date") val date: String,
@SerializedName("age") val age: Int,
) : Parcelable | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/model/Registered.kt | 3885424061 |
package io.github.christianfajardo.randomuser.domain.model
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class Location(
@SerializedName("street") val street: Street,
@SerializedName("city") val city: String,
@SerializedName("state") val state: String,
@SerializedName("country") val country: String,
@SerializedName("postcode") val postcode: String,
@SerializedName("coordinates") val coordinates: Coordinates,
@SerializedName("timezone") val timezone: Timezone
) : Parcelable
| RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/model/Location.kt | 4134931949 |
package io.github.christianfajardo.randomuser.domain.model
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class Coordinates(
@SerializedName("latitude") val latitude: String,
@SerializedName("longitude") val longitude: String,
) : Parcelable | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/model/Coordinates.kt | 833607798 |
package io.github.christianfajardo.randomuser.domain.model
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class Timezone(
@SerializedName("offset") val offset: String,
@SerializedName("description") val description: String
) : Parcelable
| RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/model/Timezone.kt | 4077538041 |
package io.github.christianfajardo.randomuser.domain.model
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class Name(
@SerializedName("title") val title: String,
@SerializedName("first") val first: String,
@SerializedName("last") val last: String
) : Parcelable | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/model/Name.kt | 2957080467 |
package io.github.christianfajardo.randomuser.domain.model
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class Picture(
@SerializedName("large") val large: String,
@SerializedName("medium") val medium: String,
@SerializedName("thumbnail") val thumbnail: String
) : Parcelable
| RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/model/Picture.kt | 2206539080 |
package io.github.christianfajardo.randomuser.domain.model
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class User(
@SerializedName("name") val name: Name,
@SerializedName("gender") val gender: String,
@SerializedName("location") val location: Location,
@SerializedName("email") val email: String,
@SerializedName("phone") val phone: String,
@SerializedName("cell") val cell: String,
@SerializedName("picture") val picture: Picture,
@SerializedName("registered") val registered: Registered,
@SerializedName("coordinates") val coordinates: Coordinates?
) : Parcelable | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/model/User.kt | 66478133 |
package io.github.christianfajardo.randomuser.domain.model
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.parcelize.Parcelize
@Parcelize
data class Street(
@SerializedName("number") val number: Int,
@SerializedName("name") val name: String
) : Parcelable
| RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/model/Street.kt | 1187572063 |
package io.github.christianfajardo.randomuser.domain.model
import com.google.gson.annotations.SerializedName
data class ApiResponse(
@SerializedName("results") val userList: List<User>
)
| RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/domain/model/ApiResponse.kt | 3636476085 |
package io.github.christianfajardo.randomuser.presentation.landing
import androidx.lifecycle.ViewModel
import dagger.hilt.android.lifecycle.HiltViewModel
import io.github.christianfajardo.randomuser.domain.model.User
import io.github.christianfajardo.randomuser.domain.repository.RandomUserRepository
import io.github.christianfajardo.randomuser.utils.NetworkUtilities
import io.github.christianfajardo.randomuser.utils.Resource
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
import io.reactivex.rxjava3.core.Flowable
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.schedulers.Schedulers
import javax.inject.Inject
@HiltViewModel
class UserViewModel
@Inject constructor(private var repo: RandomUserRepository) : ViewModel() {
private var userListFlowablePrivate: Flowable<Resource<List<User>>> =
repo.getUserList()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.cache()
fun getUsers(){
userListFlowablePrivate=repo.getUserList()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.cache()
}
private var internetStatusPrivate: Observable<Boolean> = NetworkUtilities
.observerNetwork()
.observeOn(AndroidSchedulers.mainThread())
var userListFlowable: Flowable<Resource<List<User>>> = userListFlowablePrivate
var internetStatus: Observable<Boolean> = internetStatusPrivate
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/presentation/landing/UserViewModel.kt | 4072398229 |
package io.github.christianfajardo.randomuser.presentation.landing
import android.annotation.SuppressLint
import android.content.Context
import android.content.Intent
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.recyclerview.widget.AsyncListDiffer
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.card.MaterialCardView
import de.hdodenhof.circleimageview.CircleImageView
import io.github.christianfajardo.randomuser.R
import io.github.christianfajardo.randomuser.domain.model.User
import io.github.christianfajardo.randomuser.presentation.userdetails.UserDetailsActivity
import io.github.christianfajardo.randomuser.presentation.userdetails.UserDetailsActivity.Companion.USER_DATA
import io.github.christianfajardo.randomuser.presentation.loadImage
import javax.inject.Inject
class UserAdapter @Inject constructor() : RecyclerView.Adapter<UserAdapter.UserViewHolder>() {
inner class UserViewHolder(private var view: View) : RecyclerView.ViewHolder(view) {
private val context: Context = view.context
private var tvFullName: TextView = view.findViewById(R.id.tvFullName)
private var tvCountry: TextView = view.findViewById(R.id.tvCountry)
private var ivPortrait: CircleImageView = view.findViewById(R.id.ivPortrait)
private var mcvUserCard: MaterialCardView = view.findViewById(R.id.mcvUserCard)
@SuppressLint("SetTextI18n")
fun bindTo(user: User) {
tvFullName.text = "${user.name.first} ${user.name.last}"
tvCountry.text = user.email
ivPortrait.loadImage(user.picture.medium)
mcvUserCard.setOnClickListener {
val intent = Intent(view.context, UserDetailsActivity::class.java)
intent.putExtra(USER_DATA, user)
context.startActivity(intent)
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): UserViewHolder {
val context = parent.context
val inflater = LayoutInflater.from(context)
val userCard = inflater.inflate(R.layout.list_item_user, parent, false)
return UserViewHolder(userCard)
}
override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
val user = differ.currentList[position]
holder.bindTo(user)
}
fun getList ()=differ.currentList
override fun getItemCount(): Int = differ.currentList.size
private val diffCallback =
object : DiffUtil.ItemCallback<User>() {
override fun areItemsTheSame(oldItem: User, newItem: User): Boolean {
return oldItem == newItem
}
override fun areContentsTheSame(oldItem: User, newItem: User): Boolean {
if (oldItem.location.country != newItem.location.country) {
return false
}
if (oldItem.name.first != newItem.name.first) {
return false
}
if (oldItem.name.last != newItem.name.last) {
return false
}
if (oldItem.picture.medium != newItem.picture.medium) {
return false
}
return true
}
}
val differ = AsyncListDiffer(this, diffCallback)
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/presentation/landing/UserAdapter.kt | 3489564623 |
package io.github.christianfajardo.randomuser.presentation.landing
import android.content.Intent
import android.content.res.Configuration
import android.os.Bundle
import android.util.Log
import android.view.View
import android.widget.ImageView
import android.widget.ProgressBar
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.widget.SearchView
import androidx.recyclerview.widget.GridLayoutManager
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.snackbar.Snackbar
import dagger.hilt.android.AndroidEntryPoint
import io.github.christianfajardo.randomuser.BuildConfig
import io.github.christianfajardo.randomuser.utils.Resource
import io.github.christianfajardo.randomuser.utils.Constants
import io.github.christianfajardo.randomuser.utils.print
import io.github.christianfajardo.randomuser.R
import io.reactivex.rxjava3.disposables.CompositeDisposable
import javax.inject.Inject
@AndroidEntryPoint
class LandingActivity : AppCompatActivity() {
private lateinit var rvFriends: RecyclerView
private lateinit var pbLoading: ProgressBar
private lateinit var ivNoInternet: ImageView
private lateinit var parentLayout: View
private lateinit var searchView: SearchView
@Inject
lateinit var compositeDisposable: CompositeDisposable
@Inject
lateinit var userAdapter: UserAdapter
private val userViewModel: UserViewModel by viewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_landing)
initViews()
observeViewModel()
setUpRecyclerView()
setupSearchView()
}
private fun setupSearchView() {
searchView = findViewById(R.id.searchView)
searchView.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
override fun onQueryTextSubmit(query: String?): Boolean {
return false
}
override fun onQueryTextChange(newText: String?): Boolean {
if (newText.isNullOrBlank()) {
userViewModel.getUsers()
compositeDisposable.add(
userViewModel.userListFlowable.subscribe { resource ->
when (resource) {
is Resource.Success -> {
userAdapter.differ.submitList(resource.data)
}
}
}
)
return true
}
rvFriends.visibility = View.VISIBLE
val userAdapterList = userAdapter.getList()
val filteredList = if (!newText.isNullOrBlank()) {
val list=userAdapterList.filter { user ->
val fullName = "${user.name.first} ${user.name.last}"
fullName.contains(newText, ignoreCase = true) ||
user.email.contains(newText, ignoreCase = true)
}
list
} else {
Log.d("No","No action")
emptyList()
}
userAdapter.differ.submitList(filteredList)
return true
}
})
}
private fun initViews() {
parentLayout = findViewById(android.R.id.content)
rvFriends = findViewById(R.id.rvFriends)
pbLoading = findViewById(R.id.pbLoading)
ivNoInternet = findViewById(R.id.ivNoInternet)
}
private fun observeViewModel() {
compositeDisposable.add(
userViewModel
.userListFlowable
.subscribe { resource ->
when (resource) {
is Resource.Loading -> {
pbLoading.visibility = View.VISIBLE
ivNoInternet.visibility = View.GONE
}
is Resource.Error -> {
pbLoading.visibility = View.GONE
ivNoInternet.visibility = View.VISIBLE
if (BuildConfig.DEBUG) {
Log.e(tag, "setUpObserver: ${resource.message}")
}
showErrorSnackBar()
}
is Resource.Success -> {
pbLoading.visibility = View.GONE
ivNoInternet.visibility = View.GONE
rvFriends.visibility = View.VISIBLE
userAdapter.differ.submitList(resource.data)
}
}
})
}
override fun onStop() {
compositeDisposable.clear()
super.onStop()
}
private fun showErrorSnackBar() {
val snackBar = Snackbar.make(parentLayout, "Something went wrong", Snackbar.LENGTH_SHORT)
compositeDisposable.add(userViewModel.internetStatus.subscribe { internetStatus ->
if (!internetStatus) {
snackBar.setText("Your Internet Connection is off")
snackBar.setAction(
"TURN ON"
) {
try {
launchWifiSettings()
userViewModel.userListFlowable.retry()
} catch (e: Exception) {
e.print(tag, "launchwifi set")
snackBar.setText("Could not open Wi-Fi settings")
snackBar.show()
}
}
snackBar.show()
} else {
snackBar.show()
}
})
}
private fun setUpRecyclerView() {
rvFriends.apply {
val gridViewItemAmount: Int = 3
layoutManager =
if (resources.configuration.orientation == Configuration.ORIENTATION_LANDSCAPE) {
GridLayoutManager(
this@LandingActivity,
gridViewItemAmount
)
} else {
LinearLayoutManager(this@LandingActivity)
}
adapter = userAdapter
overScrollMode = View.OVER_SCROLL_NEVER
}
}
private fun launchWifiSettings() {
val intent = Intent(Constants.WIFI_SETTING_ACTION)
intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
startActivity(intent)
}
private val tag = "LandingActivity"
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/presentation/landing/LandingActivity.kt | 922914576 |
package io.github.christianfajardo.randomuser.presentation.userdetails
import android.annotation.SuppressLint
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.ImageView
import android.widget.LinearLayout
import android.widget.TextView
import io.github.christianfajardo.randomuser.domain.model.User
import android.content.Intent
import android.net.Uri
import android.widget.Toast
import com.google.android.gms.maps.CameraUpdateFactory
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.OnMapReadyCallback
import com.google.android.gms.maps.SupportMapFragment
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.model.MarkerOptions
import com.google.android.material.card.MaterialCardView
import dagger.hilt.android.AndroidEntryPoint
import io.github.christianfajardo.randomuser.R
import io.github.christianfajardo.randomuser.presentation.loadImage
import java.text.SimpleDateFormat
import java.util.Locale
@AndroidEntryPoint
class UserDetailsActivity : AppCompatActivity(), OnMapReadyCallback {
private lateinit var ivPortraitDetails: ImageView
private lateinit var tvFullNameDetails: TextView
private lateinit var tvAddressDetails: TextView
private lateinit var tvCityDetails: TextView
private lateinit var tvEmailDetails: TextView
private lateinit var tvCellPhoneDetails: TextView
private lateinit var llEmail: LinearLayout
private lateinit var mcvUserCard: MaterialCardView
private lateinit var tvGenderDetails: TextView
private lateinit var tvRegisteredDetails: TextView
private lateinit var tvCoordinatesDetails: TextView
private lateinit var map: GoogleMap
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_user_details)
initViews()
showUpButton()
getUserData()
val mapFragment = supportFragmentManager.findFragmentById(R.id.map) as SupportMapFragment
mapFragment.getMapAsync(this)
}
// shows the back button in the action bar
private fun showUpButton() {
supportActionBar?.setDisplayHomeAsUpEnabled(true)
}
// change the navigate up functionality to the onBackPressed
// so that, the activity in the back stack gets loaded
override fun onSupportNavigateUp(): Boolean {
super.onBackPressed()
return false
}
private fun initViews() {
ivPortraitDetails = findViewById(R.id.ivPortrait)
tvFullNameDetails = findViewById(R.id.tvFullNameDetails)
tvAddressDetails = findViewById(R.id.tvAddressDetails)
tvCityDetails = findViewById(R.id.tvCityDetails)
tvEmailDetails = findViewById(R.id.tvEmailDetails)
tvCellPhoneDetails = findViewById(R.id.tvCellPhoneDetails)
llEmail = findViewById(R.id.llEmail)
mcvUserCard = findViewById(R.id.mcvUserCard)
tvGenderDetails= findViewById(R.id.tvGenderDetails)
tvRegisteredDetails=findViewById(R.id.tvRegisteredDetails)
tvCoordinatesDetails=findViewById(R.id.tvCoordinatesDetails)
}
// gets the user data sent by the previous intent
// and loads the UI if the user data can be retrieved
private fun getUserData() {
val userData = intent.getParcelableExtra<User>(USER_DATA)
if (userData != null) {
loadUi(userData)
} else {
Toast.makeText(this, "User details could not be retrieved.", Toast.LENGTH_SHORT).show()
}
}
@SuppressLint("SetTextI18n")
private fun loadUi(user: User) {
ivPortraitDetails.loadImage(user.picture.large)
tvFullNameDetails.text = "${user.name.first} ${user.name.last}"
tvAddressDetails.text = user.location.street.name
tvCityDetails.text = "${user.location.city}, ${user.location.state}, ${user.location.country}"
tvEmailDetails.text = user.email
tvCellPhoneDetails.text = user.cell
tvGenderDetails.text= user.gender
val registrationDateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.getDefault())
val registrationDate = registrationDateFormat.parse(user.registered.date)
val formattedRegistrationDate = SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())
.format(registrationDate)
tvRegisteredDetails.text = formattedRegistrationDate
tvCoordinatesDetails.text= "${user.location.coordinates.latitude} ${user.location.coordinates.longitude}"
llEmail.setOnClickListener {
navigateToEmail(user.email)
}
// sets the action bar title to the first name of the user
supportActionBar?.subtitle = "${user.name.first} ${user.name.last}"
}
// launch email app to send an mail to the user's mail
private fun navigateToEmail(email: String) {
val emailIntent = Intent(Intent.ACTION_SENDTO).apply {
data = Uri.parse("mailto:$email")
}
startActivity(Intent.createChooser(emailIntent, "Send email"))
}
override fun onMapReady(googleMap: GoogleMap) {
map = googleMap
val coordinates = intent.getParcelableExtra<User>(USER_DATA)?.location?.coordinates
if (coordinates != null) {
val location = LatLng(coordinates.latitude.toDouble(), coordinates.longitude.toDouble())
map.addMarker(MarkerOptions().position(location).title("User's Location"))
map.moveCamera(CameraUpdateFactory.newLatLng(location))
map.animateCamera(CameraUpdateFactory.zoomTo(10.0f))
}
}
companion object {
const val USER_DATA = "user_data"
}
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/presentation/userdetails/UserDetailsActivity.kt | 3134121401 |
package io.github.christianfajardo.randomuser.presentation
import android.widget.ImageView
import com.bumptech.glide.Glide
import com.bumptech.glide.request.RequestOptions
import io.github.christianfajardo.randomuser.R
fun ImageView.loadImage(url: String?) {
val options = RequestOptions()
.error(R.drawable.ic_image_not_found)
.placeholder(R.drawable.ic_image_downloading)
Glide.with(this.context)
.setDefaultRequestOptions(options)
.load(url)
.into(this)
} | RandomuserMVVM/app/src/main/java/io/github/christianfajardo/randomuser/presentation/PresentationExtensions.kt | 2454071054 |
package com.ozcanbayram.logren
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.ozcanbayram.logren", appContext.packageName)
}
} | Logren/app/src/androidTest/java/com/ozcanbayram/logren/ExampleInstrumentedTest.kt | 63710884 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.