content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package io.github.caimucheng.leaf.common.viewmodel
import android.content.res.AssetManager
import android.os.Environment
import android.system.Os
import android.util.Log
import androidx.lifecycle.viewModelScope
import io.github.caimucheng.leaf.common.mvi.MVIViewModel
import io.github.caimucheng.leaf.common.mvi.UiIntent
import io.github.caimucheng.leaf.common.mvi.UiState
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.apache.commons.compress.archivers.ArchiveStreamFactory
import org.apache.commons.compress.archivers.tar.TarArchiveEntry
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry
import org.apache.commons.compress.archivers.zip.ZipArchiveInputStream
import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream
import java.io.File
import java.io.FileInputStream
enum class FileUnZipTotalState {
UNSTARTED, PROCESSING, DONE, FAILED
}
data class FileUnZipState(
val name: String = "",
val from: String = "",
val to: String = "",
val progress: Int = 0,
val totalState: FileUnZipTotalState = FileUnZipTotalState.UNSTARTED,
val exception: Exception? = null
) : UiState()
sealed class FileUnZipIntent : UiIntent() {
data class Start(val name: String, val from: String, val to: String, val type: String) :
FileUnZipIntent()
data class StartFromAssets(
val assets: AssetManager,
val name: String,
val from: String,
val to: String,
val type: String,
) : FileUnZipIntent()
}
class FileUnZipViewModel : MVIViewModel<FileUnZipState, FileUnZipIntent>() {
override fun initialValue(): FileUnZipState {
return FileUnZipState()
}
override fun handleIntent(intent: FileUnZipIntent, currentState: FileUnZipState) {
when (intent) {
is FileUnZipIntent.Start -> start(intent.name, intent.from, intent.to, intent.type)
is FileUnZipIntent.StartFromAssets -> startFromInputStream(
intent.assets,
intent.name,
intent.from,
intent.to,
intent.type
)
}
}
private fun startFromInputStream(
assets: AssetManager,
name: String,
from: String,
to: String,
type: String
) {
viewModelScope.launch {
setState(
state.value.copy(
name = name,
from = from,
to = to,
totalState = FileUnZipTotalState.PROCESSING
)
)
try {
startFromInputStreamSuspend(assets, from, to, type)
setState(
state.value.copy(
totalState = FileUnZipTotalState.DONE
)
)
} catch (e: Exception) {
if (e is CancellationException) throw e
setState(state.value.copy(totalState = FileUnZipTotalState.FAILED, exception = e))
}
}
}
private fun start(name: String, from: String, to: String, type: String) {
viewModelScope.launch {
setState(
state.value.copy(
name = name,
from = from,
to = to,
totalState = FileUnZipTotalState.PROCESSING
)
)
try {
startSuspend(from, to, type)
setState(
state.value.copy(
totalState = FileUnZipTotalState.DONE
)
)
} catch (e: Exception) {
if (e is CancellationException) throw e
setState(state.value.copy(totalState = FileUnZipTotalState.FAILED, exception = e))
}
}
}
private suspend fun startFromInputStreamSuspend(
assets: AssetManager,
from: String,
to: String,
type: String
) {
return withContext(Dispatchers.IO) {
val toFile = File(to)
when (type) {
"zip" -> decompressZip(assets, from, toFile)
"gz" -> decompressTarGz(assets, from, toFile)
else -> throw IllegalArgumentException("Unknown type")
}
}
}
private suspend fun startSuspend(from: String, to: String, type: String) {
return withContext(Dispatchers.IO) {
val fromFile = File(from)
val toFile = File(to)
when (type) {
"zip" -> decompressZip(fromFile, toFile)
"gz" -> decompressTarGz(fromFile, toFile)
else -> throw IllegalArgumentException("Unknown type")
}
}
}
@Suppress("BlockingMethodInNonBlockingContext")
private suspend fun decompressTarGz(fromFile: File, toFile: File) {
toFile.mkdirs()
val buffer = ByteArray(8192)
val archiveStreamFactory = ArchiveStreamFactory("UTF-8")
var transferred: Long = 0
var decompressedSize: Long = 0
FileInputStream(fromFile).buffered().use {
val archiveInputStream =
archiveStreamFactory.createArchiveInputStream<TarArchiveInputStream>(
ArchiveStreamFactory.TAR,
GzipCompressorInputStream(it)
)
var archiveEntry: TarArchiveEntry
while (archiveInputStream.nextEntry.also { entry -> archiveEntry = entry } != null) {
decompressedSize += archiveEntry.size
}
}
FileInputStream(fromFile).use {
val archiveInputStream =
archiveStreamFactory.createArchiveInputStream<TarArchiveInputStream>(
ArchiveStreamFactory.TAR,
GzipCompressorInputStream(it)
)
var archiveEntry: TarArchiveEntry
while (archiveInputStream.nextEntry.also { entry -> archiveEntry = entry } != null) {
val outputFile =
File(toFile, archiveEntry.name)
if (archiveEntry.isSymbolicLink) {
try {
Os.symlink(
relativeTo(
outputFile.parentFile ?: outputFile,
archiveEntry.linkName
).absolutePath,
outputFile.absolutePath
)
} catch (_: Exception) {
}
continue
}
if (archiveEntry.isDirectory) {
outputFile.mkdirs()
continue
}
val output = outputFile.outputStream().buffered()
output.use {
var nRead: Int
var tempProgress = 0
var progress: Int
while (archiveInputStream.read(buffer, 0, buffer.size)
.also { bytes -> nRead = bytes } >= 0
) {
output.write(buffer, 0, nRead)
output.flush()
transferred += nRead.toLong()
progress = (transferred * 100L / decompressedSize).toInt()
if (progress > tempProgress) {
tempProgress = progress
withContext(Dispatchers.Main) {
setState(state.value.copy(progress = progress))
}
}
}
}
val splitIndex = archiveEntry.name.lastIndexOf("bin/")
if (splitIndex != -1) {
outputFile.setExecutable(true, true)
}
}
}
}
private suspend fun decompressTarGz(assets: AssetManager, from: String, toFile: File) {
toFile.mkdirs()
val buffer = ByteArray(8192)
val archiveStreamFactory = ArchiveStreamFactory("UTF-8")
var transferred: Long = 0
var decompressedSize: Long = 0
assets.open(from).buffered().use {
val archiveInputStream =
archiveStreamFactory.createArchiveInputStream<TarArchiveInputStream>(
ArchiveStreamFactory.TAR,
GzipCompressorInputStream(it)
)
var archiveEntry: TarArchiveEntry
while (archiveInputStream.nextEntry.also { entry -> archiveEntry = entry } != null) {
decompressedSize += archiveEntry.size
}
}
assets.open(from).use {
val archiveInputStream =
archiveStreamFactory.createArchiveInputStream<TarArchiveInputStream>(
ArchiveStreamFactory.TAR,
GzipCompressorInputStream(it)
)
var archiveEntry: TarArchiveEntry
while (archiveInputStream.nextEntry.also { entry -> archiveEntry = entry } != null) {
val outputFile =
File(toFile, archiveEntry.name)
if (archiveEntry.isSymbolicLink) {
try {
Os.symlink(
relativeTo(
outputFile.parentFile ?: outputFile,
archiveEntry.linkName
).absolutePath,
outputFile.absolutePath
)
} catch (_: Exception) {
}
continue
}
if (archiveEntry.isDirectory) {
outputFile.mkdirs()
continue
}
val output = outputFile.outputStream().buffered()
output.use {
var nRead: Int
var tempProgress = 0
var progress: Int
while (archiveInputStream.read(buffer, 0, buffer.size)
.also { bytes -> nRead = bytes } >= 0
) {
output.write(buffer, 0, nRead)
output.flush()
transferred += nRead.toLong()
progress = (transferred * 100L / decompressedSize).toInt()
if (progress > tempProgress) {
tempProgress = progress
withContext(Dispatchers.Main) {
setState(state.value.copy(progress = progress))
}
}
}
}
val splitIndex = archiveEntry.name.lastIndexOf("bin/")
if (splitIndex != -1) {
outputFile.setExecutable(true, true)
}
}
}
}
private fun relativeTo(baseFile: File, name: String): File {
var currentBaseFile = baseFile
val paths = name.split("/")
if (paths[0].isEmpty()) {
return File(name)
}
for (path in paths) {
currentBaseFile = if (path == "..") {
currentBaseFile.parentFile ?: currentBaseFile
} else {
File(currentBaseFile, path)
}
}
return currentBaseFile
}
@Suppress("BlockingMethodInNonBlockingContext")
private suspend fun decompressZip(fromFile: File, toFile: File) {
toFile.mkdirs()
val buffer = ByteArray(8192)
val archiveStreamFactory = ArchiveStreamFactory("UTF-8")
var transferred: Long = 0
var decompressedSize: Long = 0
FileInputStream(fromFile).buffered().use {
val archiveInputStream =
archiveStreamFactory.createArchiveInputStream<ZipArchiveInputStream>(
ArchiveStreamFactory.ZIP,
it
)
var archiveEntry: ZipArchiveEntry
while (archiveInputStream.nextEntry.also { entry -> archiveEntry = entry } != null) {
decompressedSize += archiveEntry.size
}
}
FileInputStream(fromFile).buffered().use {
val archiveInputStream =
archiveStreamFactory.createArchiveInputStream<ZipArchiveInputStream>(
ArchiveStreamFactory.ZIP,
it
)
var archiveEntry: ZipArchiveEntry
while (archiveInputStream.nextEntry.also { entry -> archiveEntry = entry } != null) {
val outputFile = File(toFile, archiveEntry.name)
if (archiveEntry.isDirectory) {
outputFile.mkdirs()
continue
}
val output = outputFile.outputStream().buffered()
output.use {
var nRead: Int
var tempProgress = 0
var progress: Int
while (archiveInputStream.read(buffer, 0, buffer.size)
.also { bytes -> nRead = bytes } >= 0
) {
output.write(buffer, 0, nRead)
output.flush()
transferred += nRead.toLong()
progress = (transferred * 100L / decompressedSize).toInt()
if (progress > tempProgress) {
tempProgress = progress
withContext(Dispatchers.Main) {
setState(state.value.copy(progress = progress))
}
}
}
}
}
}
}
private suspend fun decompressZip(assets: AssetManager, from: String, toFile: File) {
toFile.mkdirs()
val buffer = ByteArray(8192)
val archiveStreamFactory = ArchiveStreamFactory("UTF-8")
var transferred: Long = 0
var decompressedSize: Long = 0
assets.open(from).buffered().use {
val archiveInputStream =
archiveStreamFactory.createArchiveInputStream<ZipArchiveInputStream>(
ArchiveStreamFactory.ZIP,
it
)
var archiveEntry: ZipArchiveEntry
while (archiveInputStream.nextEntry.also { entry -> archiveEntry = entry } != null) {
decompressedSize += archiveEntry.size
}
}
assets.open(from).use {
val archiveInputStream =
archiveStreamFactory.createArchiveInputStream<ZipArchiveInputStream>(
ArchiveStreamFactory.ZIP,
it
)
var archiveEntry: ZipArchiveEntry
while (archiveInputStream.nextEntry.also { entry -> archiveEntry = entry } != null) {
val outputFile = File(toFile, archiveEntry.name)
if (archiveEntry.isDirectory) {
outputFile.mkdirs()
continue
}
val output = outputFile.outputStream().buffered()
output.use {
var nRead: Int
var tempProgress = 0
var progress: Int
while (archiveInputStream.read(buffer, 0, buffer.size)
.also { bytes -> nRead = bytes } >= 0
) {
output.write(buffer, 0, nRead)
output.flush()
transferred += nRead.toLong()
progress = (transferred * 100L / decompressedSize).toInt()
if (progress > tempProgress) {
tempProgress = progress
withContext(Dispatchers.Main) {
setState(state.value.copy(progress = progress))
}
}
}
}
}
}
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/viewmodel/FileUnZipViewModel.kt | 3249387738 |
package io.github.caimucheng.leaf.common.viewmodel
import androidx.lifecycle.viewModelScope
import io.github.caimucheng.leaf.common.mvi.MVIViewModel
import io.github.caimucheng.leaf.common.mvi.UiIntent
import io.github.caimucheng.leaf.common.mvi.UiState
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.io.File
import java.io.IOException
enum class FileDeleteTotalState {
UNSTARTED, PROCESSING, DONE, FAILED
}
data class FileDeleteState(
val name: String = "",
val path: String = "",
val totalState: FileDeleteTotalState = FileDeleteTotalState.UNSTARTED
) : UiState()
sealed class FileDeleteIntent : UiIntent() {
data class Start(val name: String, val path: String) : FileDeleteIntent()
}
class FileDeleteViewModel : MVIViewModel<FileDeleteState, FileDeleteIntent>() {
override fun initialValue(): FileDeleteState {
return FileDeleteState()
}
override fun handleIntent(intent: FileDeleteIntent, currentState: FileDeleteState) {
when (intent) {
is FileDeleteIntent.Start -> start(intent.name, intent.path)
}
}
private fun start(name: String, path: String) {
viewModelScope.launch {
setState(
state.value.copy(
name = name,
path = path,
totalState = FileDeleteTotalState.PROCESSING
)
)
try {
startSuspend(path)
setState(
state.value.copy(
totalState = FileDeleteTotalState.DONE
)
)
} catch (e: Exception) {
if (e is CancellationException) throw e
setState(state.value.copy(totalState = FileDeleteTotalState.FAILED))
}
}
}
private suspend fun startSuspend(path: String) {
return withContext(Dispatchers.IO) {
val file = File(path)
val result = if (file.isFile) {
processFile(file)
} else {
processFolder(file)
}
if (!result) {
throw IOException()
}
}
}
private fun processFolder(file: File): Boolean {
var result = true
val children = file.listFiles() ?: emptyArray()
for (child in children) {
result = if (child.isFile) {
processFile(child) && result
} else {
processFolder(child) && result
}
}
result = file.delete() && result
return result
}
private fun processFile(file: File): Boolean {
return file.delete()
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/viewmodel/FileDeleteViewModel.kt | 1864052751 |
package io.github.caimucheng.leaf.common.adapter
import android.content.Context
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.core.content.ContextCompat
import androidx.recyclerview.widget.RecyclerView
import androidx.viewbinding.ViewBinding
import io.github.caimucheng.leaf.common.R
import io.github.caimucheng.leaf.common.callback.FileSelectorCallback
import io.github.caimucheng.leaf.common.databinding.LayoutFileSelectorBinding
import java.io.File
class FileSelectorAdapter(
private val context: Context,
private val files: List<File>,
private val matchingSuffix: List<String>?,
private val onItemClick: (file: File) -> Unit
) : RecyclerView.Adapter<FileSelectorAdapter.ViewHolder>() {
inner class ViewHolder(val viewBinding: LayoutFileSelectorBinding) :
RecyclerView.ViewHolder(viewBinding.root)
private val inflater by lazy {
LayoutInflater.from(context)
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
return ViewHolder(LayoutFileSelectorBinding.inflate(inflater, parent, false))
}
override fun getItemCount(): Int {
return files.size
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
val viewBinding = holder.viewBinding
val file = files[position]
if (file.isDirectory) {
viewBinding.icon.setBackgroundResource(R.drawable.baseline_folder_24)
} else {
if (matchingSuffix != null) {
if (".${file.extension}" in matchingSuffix) {
viewBinding.icon.setBackgroundResource(R.drawable.baseline_plumbing_24)
} else {
viewBinding.icon.setBackgroundResource(R.drawable.baseline_insert_drive_file_24)
}
} else {
viewBinding.icon.setBackgroundResource(R.drawable.baseline_insert_drive_file_24)
}
}
viewBinding.name.text = file.name
viewBinding.root.setOnClickListener {
onItemClick(file)
}
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/adapter/FileSelectorAdapter.kt | 3442345643 |
package io.github.caimucheng.leaf.common.depository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.io.File
class FileSelectorDepository {
suspend fun enter(targetDirectory: File, matchingSuffix: List<String>?): List<File> {
return withContext(Dispatchers.IO) {
val files = (targetDirectory.listFiles()?.toList() ?: emptyList())
if (matchingSuffix != null) {
sortList(files.filter { if (it.isFile) ".${it.extension}" in matchingSuffix else true })
} else {
sortList(files)
}
}
}
suspend fun refresh(currentDirectory: File, matchingSuffix: List<String>?): List<File> {
return withContext(Dispatchers.IO) {
val files = (currentDirectory.listFiles()?.toList() ?: emptyList())
if (matchingSuffix != null) {
sortList(files.filter { if (it.isFile) ".${it.extension}" in matchingSuffix else true })
} else {
sortList(files)
}
}
}
private fun sortList(files: List<File>): List<File> {
return files.sortedWith { first, second ->
if (first.isDirectory && second.isFile) {
return@sortedWith -1
}
if (first.isFile && second.isDirectory) {
return@sortedWith 1
}
first.name.compareTo(second.name)
}
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/depository/FileSelectorDepository.kt | 2071838889 |
package io.github.caimucheng.leaf.common.fragment
import android.annotation.SuppressLint
import android.app.Dialog
import android.os.Bundle
import android.os.Environment
import android.view.LayoutInflater
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
import androidx.core.view.MenuProvider
import androidx.fragment.app.DialogFragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.recyclerview.widget.LinearLayoutManager
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.github.caimucheng.leaf.common.R
import io.github.caimucheng.leaf.common.adapter.FileSelectorAdapter
import io.github.caimucheng.leaf.common.callback.FileSelectorCallback
import io.github.caimucheng.leaf.common.databinding.FragmentFileSelectorBinding
import io.github.caimucheng.leaf.common.viewmodel.FileSelectorIntent
import io.github.caimucheng.leaf.common.viewmodel.FileSelectorViewModel
import io.github.caimucheng.leaf.common.viewmodel.FileState
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
import java.io.File
class FileSelectorFragment : DialogFragment() {
private lateinit var viewBinding: FragmentFileSelectorBinding
private var fileSelectorCallback: FileSelectorCallback? = null
private val files by lazy {
ArrayList<File>()
}
private val adapter by lazy {
FileSelectorAdapter(
context = requireContext(),
files = files,
matchingSuffix = arguments?.getStringArrayList("matchingSuffix"),
onItemClick = {
if (it.isDirectory) {
viewLifecycleOwner.lifecycleScope.launch {
fileSelectorViewModel.intent.send(
FileSelectorIntent.Enter(it, arguments?.getStringArrayList("matchingSuffix"))
)
}
} else {
fileSelectorCallback?.onFileSelected(it)
}
}
)
}
private val fileSelectorViewModel: FileSelectorViewModel by viewModels()
fun setFileSelectorCallback(fileSelectorCallback: FileSelectorCallback) {
this.fileSelectorCallback = fileSelectorCallback
}
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
return MaterialAlertDialogBuilder(requireContext(), theme)
.show()
}
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
viewBinding = FragmentFileSelectorBinding.inflate(inflater, container, false)
return viewBinding.root
}
@SuppressLint("NotifyDataSetChanged")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
setupToolbar()
setupRecyclerView()
viewLifecycleOwner.lifecycleScope.launch {
repeatOnLifecycle(Lifecycle.State.STARTED) {
fileSelectorViewModel.intent.send(FileSelectorIntent.Refresh(arguments?.getStringArrayList("matchingSuffix")))
fileSelectorViewModel.state.collectLatest {
when (it.fileState) {
FileState.Loading -> {
viewBinding.content.visibility = View.GONE
viewBinding.placeholder.visibility = View.GONE
viewBinding.loading.visibility = View.VISIBLE
}
FileState.Done -> {
viewBinding.loading.visibility = View.GONE
viewBinding.toolbar.subtitle = it.currentDirectory.absolutePath
files.clear()
files.addAll(it.files)
adapter.notifyDataSetChanged()
if (files.isNotEmpty()) {
viewBinding.placeholder.visibility = View.GONE
viewBinding.content.visibility = View.VISIBLE
} else {
viewBinding.content.visibility = View.GONE
viewBinding.placeholder.visibility = View.VISIBLE
}
}
}
}
}
}
}
private fun setupToolbar() {
viewBinding.toolbar.setNavigationOnClickListener {
dismiss()
}
viewBinding.toolbar.addMenuProvider(object : MenuProvider {
override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
menuInflater.inflate(R.menu.menu_file_selector, menu)
}
override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
if (menuItem.itemId == R.id.up) {
if (fileSelectorViewModel.state.value.currentDirectory.absolutePath != Environment.getExternalStorageDirectory().absolutePath) {
viewLifecycleOwner.lifecycleScope.launch {
fileSelectorViewModel.intent.send(
FileSelectorIntent.Enter(
fileSelectorViewModel.state.value.currentDirectory.parentFile
?: Environment.getExternalStorageDirectory(),
arguments?.getStringArrayList("matchingSuffix")
)
)
}
}
}
return false
}
}, viewLifecycleOwner)
}
private fun setupRecyclerView() {
viewBinding.recyclerView.layoutManager =
LinearLayoutManager(requireContext(), LinearLayoutManager.VERTICAL, false)
viewBinding.recyclerView.adapter = adapter
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/fragment/FileSelectorFragment.kt | 1001877185 |
package io.github.caimucheng.leaf.common.fragment
import android.annotation.SuppressLint
import android.app.Dialog
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.DialogFragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.github.caimucheng.leaf.common.R
import io.github.caimucheng.leaf.common.callback.FileDeleteCallback
import io.github.caimucheng.leaf.common.databinding.FragmentFileDeleteBinding
import io.github.caimucheng.leaf.common.viewmodel.FileDeleteIntent
import io.github.caimucheng.leaf.common.viewmodel.FileDeleteTotalState
import io.github.caimucheng.leaf.common.viewmodel.FileDeleteViewModel
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
class FileDeleteFragment : DialogFragment() {
private lateinit var viewBinding: FragmentFileDeleteBinding
private val fileDeleteViewModel: FileDeleteViewModel by viewModels()
private var fileDeleteCallback: FileDeleteCallback? = null
fun setFileDeleteCallback(fileDeleteCallback: FileDeleteCallback) {
this.fileDeleteCallback = fileDeleteCallback
}
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
return MaterialAlertDialogBuilder(requireContext())
.show()
}
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
viewBinding = FragmentFileDeleteBinding.inflate(inflater, container, false)
return viewBinding.root
}
@SuppressLint("SetTextI18n")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val name = arguments?.getString("name") ?: return dismiss()
val path = arguments?.getString("path") ?: return dismiss()
viewLifecycleOwner.lifecycleScope.launch {
if (fileDeleteViewModel.state.value.totalState == FileDeleteTotalState.UNSTARTED) {
fileDeleteViewModel.intent.send(FileDeleteIntent.Start(name, path))
}
repeatOnLifecycle(Lifecycle.State.STARTED) {
fileDeleteViewModel.state.collectLatest {
viewBinding.name.text = getString(R.string.name, name)
viewBinding.path.text = getString(R.string.path, it.path)
if (it.totalState == FileDeleteTotalState.DONE) {
fileDeleteCallback?.onDeleteSuccess() ?: dismiss()
}
if (it.totalState == FileDeleteTotalState.FAILED) {
fileDeleteCallback?.onDeleteFailed() ?: dismiss()
}
}
}
}
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/fragment/FileDeleteFragment.kt | 1676684949 |
package io.github.caimucheng.leaf.common.fragment
import android.annotation.SuppressLint
import android.app.Dialog
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.DialogFragment
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.github.caimucheng.leaf.common.databinding.FragmentProgressBinding
class ProgressFragment : DialogFragment() {
private var title = ""
private var message = ""
private var max = 100
private var progress = 0
private var type = "circle"
private lateinit var viewBinding: FragmentProgressBinding
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
return MaterialAlertDialogBuilder(requireContext())
.show()
}
fun setTitle(title: String): ProgressFragment {
this.title = title
if (::viewBinding.isInitialized) {
viewBinding.toolbar.title = title
}
return this
}
fun setMessage(message: String): ProgressFragment {
this.message = message
if (::viewBinding.isInitialized) {
when (type) {
"linear" -> viewBinding.linearProgressMessage.text = message
"circle" -> viewBinding.circleProgressMessage.text = message
}
}
return this
}
@SuppressLint("SetTextI18n")
fun setMax(max: Int): ProgressFragment {
this.max = max
if (::viewBinding.isInitialized) {
when (type) {
"linear" -> {
viewBinding.linearProgressIndicator.max = max
viewBinding.percent.text = "${progress / max}%"
}
"circle" -> {
viewBinding.circleProgressIndicator.max = max
}
}
}
return this
}
@SuppressLint("SetTextI18n")
fun setProgress(progress: Int) {
this.progress = progress
if (::viewBinding.isInitialized) {
when (type) {
"linear" -> {
viewBinding.linearProgressIndicator.progress = progress
viewBinding.percent.text = "${progress / max}%"
}
"circle" -> {
viewBinding.circleProgressIndicator.progress = progress
}
}
}
}
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
viewBinding = FragmentProgressBinding.inflate(inflater, container, false)
return viewBinding.root
}
@SuppressLint("SetTextI18n")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
type = arguments?.getString("type", "circle") ?: "circle"
val indeterminate = arguments?.getBoolean("indeterminate", true) ?: true
when (type) {
"circle" -> viewBinding.circleProgressContent.visibility = View.VISIBLE
"linear" -> viewBinding.linearProgressContent.visibility = View.VISIBLE
else -> throw IllegalArgumentException("Unknown type")
}
viewBinding.toolbar.title = title
when (type) {
"linear" -> {
viewBinding.linearProgressIndicator.isIndeterminate = indeterminate
viewBinding.linearProgressMessage.text = message
viewBinding.linearProgressIndicator.max = max
viewBinding.linearProgressIndicator.progress = progress
viewBinding.percent.text = "${progress / max}%"
}
"circle" -> {
viewBinding.circleProgressIndicator.isIndeterminate = indeterminate
viewBinding.circleProgressMessage.text = message
viewBinding.circleProgressIndicator.max = max
viewBinding.circleProgressIndicator.progress = progress
}
}
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/fragment/ProgressFragment.kt | 1729555186 |
package io.github.caimucheng.leaf.common.fragment
import android.annotation.SuppressLint
import android.app.Dialog
import android.content.res.AssetManager
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.DialogFragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.github.caimucheng.leaf.common.R
import io.github.caimucheng.leaf.common.callback.FileUnZipCallback
import io.github.caimucheng.leaf.common.databinding.FragmentFileUnzipBinding
import io.github.caimucheng.leaf.common.viewmodel.FileUnZipIntent
import io.github.caimucheng.leaf.common.viewmodel.FileUnZipTotalState
import io.github.caimucheng.leaf.common.viewmodel.FileUnZipViewModel
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
class FileUnZipFragment : DialogFragment() {
private lateinit var viewBinding: FragmentFileUnzipBinding
private val fileUnZipViewModel: FileUnZipViewModel by viewModels()
private var fileUnZipCallback: FileUnZipCallback? = null
private var assets: AssetManager? = null
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
return MaterialAlertDialogBuilder(requireContext())
.show()
}
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
viewBinding = FragmentFileUnzipBinding.inflate(inflater, container, false)
return viewBinding.root
}
fun setFileUnZipCallback(fileUnZipCallback: FileUnZipCallback) {
this.fileUnZipCallback = fileUnZipCallback
}
fun setAssets(assets: AssetManager) {
this.assets = assets
}
@SuppressLint("SetTextI18n")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val name = arguments?.getString("name") ?: return dismiss()
val from = arguments?.getString("from") ?: return dismiss()
val to = arguments?.getString("to") ?: return dismiss()
val type = arguments?.getString("type") ?: "zip"
viewLifecycleOwner.lifecycleScope.launch {
if (fileUnZipViewModel.state.value.totalState == FileUnZipTotalState.UNSTARTED) {
if (assets != null) {
fileUnZipViewModel.intent.send(
FileUnZipIntent.StartFromAssets(
assets!!,
name,
from,
to,
type
)
)
} else {
fileUnZipViewModel.intent.send(FileUnZipIntent.Start(name, from, to, type))
}
}
repeatOnLifecycle(Lifecycle.State.STARTED) {
fileUnZipViewModel.state.collectLatest {
viewBinding.name.text = getString(R.string.name, it.name)
viewBinding.from.text = getString(R.string.from, it.from)
viewBinding.to.text = getString(R.string.to, it.to)
viewBinding.progress.text = getString(R.string.progress, it.progress) + "%"
viewBinding.indicator.progress = it.progress
if (it.totalState == FileUnZipTotalState.DONE) {
fileUnZipCallback?.onUnZipSuccess() ?: dismiss()
}
if (it.totalState == FileUnZipTotalState.FAILED) {
fileUnZipCallback?.onUnZipFailed(it.exception!!) ?: dismiss()
}
}
}
}
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/fragment/FileUnZipFragment.kt | 1181912897 |
package io.github.caimucheng.leaf.common.fragment
import android.annotation.SuppressLint
import android.app.Dialog
import android.content.res.AssetManager
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.DialogFragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.github.caimucheng.leaf.common.R
import io.github.caimucheng.leaf.common.callback.FileCopyCallback
import io.github.caimucheng.leaf.common.databinding.FragmentFileCopyBinding
import io.github.caimucheng.leaf.common.viewmodel.FileCopyIntent
import io.github.caimucheng.leaf.common.viewmodel.FileCopyTotalState
import io.github.caimucheng.leaf.common.viewmodel.FileCopyViewModel
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
import java.io.File
class FileCopyFragment : DialogFragment() {
private lateinit var viewBinding: FragmentFileCopyBinding
private val fileCopyViewModel: FileCopyViewModel by viewModels()
private var fileCopyCallback: FileCopyCallback? = null
private var assets: AssetManager? = null
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
return MaterialAlertDialogBuilder(requireContext())
.show()
}
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
viewBinding = FragmentFileCopyBinding.inflate(inflater, container, false)
return viewBinding.root
}
fun setFileCopyCallback(fileCopyCallback: FileCopyCallback) {
this.fileCopyCallback = fileCopyCallback
}
fun setAssets(assets: AssetManager) {
this.assets = assets
}
@SuppressLint("SetTextI18n")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val name = arguments?.getString("name") ?: return dismiss()
val from = arguments?.getString("from") ?: return dismiss()
val to = arguments?.getString("to") ?: return dismiss()
viewLifecycleOwner.lifecycleScope.launch {
if (fileCopyViewModel.state.value.totalState == FileCopyTotalState.UNSTARTED) {
if (assets != null) {
fileCopyViewModel.intent.send(
FileCopyIntent.StartFromAssets(
assets!!,
name,
from,
to
)
)
} else {
fileCopyViewModel.intent.send(FileCopyIntent.Start(name, from, to))
}
}
repeatOnLifecycle(Lifecycle.State.STARTED) {
fileCopyViewModel.state.collectLatest {
viewBinding.name.text = getString(R.string.name, name)
viewBinding.from.text = getString(R.string.from, it.from)
viewBinding.to.text = getString(R.string.to, it.to)
viewBinding.progress.text = getString(R.string.progress, it.progress) + "%"
viewBinding.indicator.progress = it.progress
if (it.totalState == FileCopyTotalState.DONE) {
fileCopyCallback?.onCopySuccess() ?: dismiss()
}
if (it.totalState == FileCopyTotalState.FAILED) {
fileCopyCallback?.onCopyFailed(it.exception!!) ?: dismiss()
}
}
}
}
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/fragment/FileCopyFragment.kt | 1058069626 |
package io.github.caimucheng.leaf.common.mvi
abstract class UiIntent | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/mvi/UiIntent.kt | 3890264107 |
package io.github.caimucheng.leaf.common.mvi
abstract class UiState | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/mvi/UiState.kt | 2632843143 |
package io.github.caimucheng.leaf.common.mvi
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.CoroutineName
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.cancel
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.consumeAsFlow
import kotlinx.coroutines.launch
abstract class MVIAppViewModel<S : UiState, I : UiIntent> {
@Suppress("MemberVisibilityCanBePrivate")
protected val viewModelScope: CoroutineScope =
CoroutineScope(CoroutineName("AppViewModelCoroutine") + Dispatchers.Default)
@Suppress("LeakingThis")
private val _state: MutableStateFlow<S> = MutableStateFlow(initialValue())
val state: StateFlow<S> = _state.asStateFlow()
@Suppress("MemberVisibilityCanBePrivate")
val intent: Channel<I> = Channel(Channel.UNLIMITED)
abstract fun initialValue(): S
init {
viewModelScope.launch {
intent.consumeAsFlow().collect {
handleIntent(it, _state.value)
}
}
}
abstract fun handleIntent(intent: I, currentState: S)
protected fun setState(state: S) {
_state.value = state
}
open fun onCleared() {
viewModelScope.cancel()
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/mvi/MVIAppViewModel.kt | 1146884497 |
package io.github.caimucheng.leaf.common.mvi
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.consumeAsFlow
import kotlinx.coroutines.launch
abstract class MVIViewModel<S : UiState, I : UiIntent> : ViewModel() {
@Suppress("LeakingThis")
private val _state: MutableStateFlow<S> = MutableStateFlow(initialValue())
val state: StateFlow<S> = _state.asStateFlow()
@Suppress("MemberVisibilityCanBePrivate")
val intent: Channel<I> = Channel(Channel.UNLIMITED)
abstract fun initialValue(): S
init {
viewModelScope.launch {
intent.consumeAsFlow().collect {
handleIntent(it, _state.value)
}
}
}
abstract fun handleIntent(intent: I, currentState: S)
protected fun setState(state: S) {
_state.value = state
}
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/mvi/MVIViewModel.kt | 2365886973 |
package io.github.caimucheng.leaf.common.callback
interface FileUnZipCallback {
fun onUnZipSuccess()
fun onUnZipFailed(e: Exception)
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/callback/FileUnZipCallback.kt | 2158153317 |
package io.github.caimucheng.leaf.common.callback
interface FileCopyCallback {
fun onCopySuccess()
fun onCopyFailed(e: Exception)
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/callback/FileCopyCallback.kt | 61752332 |
package io.github.caimucheng.leaf.common.callback
import java.io.File
interface FileSelectorCallback {
fun onFileSelected(file: File)
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/callback/FileSelectorCallback.kt | 125667808 |
package io.github.caimucheng.leaf.common.callback
interface FileDeleteCallback {
fun onDeleteSuccess()
fun onDeleteFailed()
} | LeafIDE/common/src/main/java/io/github/caimucheng/leaf/common/callback/FileDeleteCallback.kt | 1553813825 |
package com.example.uas
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.uas", appContext.packageName)
}
} | UAS_Pemob/app/src/androidTest/java/com/example/uas/ExampleInstrumentedTest.kt | 2030542813 |
package com.example.uas
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)
}
} | UAS_Pemob/app/src/test/java/com/example/uas/ExampleUnitTest.kt | 258686177 |
package com.example.uas.ui.bookmark
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.recyclerview.widget.LinearLayoutManager
import com.example.uas.FavoriteAdapter
import com.example.uas.database.UnivRoomDatabase
import com.example.uas.databinding.FragmentBookMarkBinding
import com.mobile.mp3_final.repository.UnivRespos
import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [BookMarkFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class BookMarkFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
private lateinit var binding: FragmentBookMarkBinding
private lateinit var favoriteAdapter: FavoriteAdapter
private lateinit var univRespos: UnivRespos
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
// Inflate the layout for this fragment
binding = FragmentBookMarkBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
univRespos = UnivRespos(requireActivity().application)
favoriteAdapter = FavoriteAdapter(univRespos)
binding.rvFavorite.apply {
layoutManager = LinearLayoutManager(requireContext())
adapter = favoriteAdapter
}
loadDatafromDB()
}
@OptIn(DelicateCoroutinesApi::class)
private fun loadDatafromDB(){
GlobalScope.launch(Dispatchers.IO){
val univDao = UnivRoomDatabase.getDatabase(requireContext()).UnivDao()
val univ = univDao.getAllUniv()
withContext(Dispatchers.Main) {
favoriteAdapter.setUniv(univ)
}
}
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment BookMarkFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
BookMarkFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | UAS_Pemob/app/src/main/java/com/example/uas/ui/bookmark/BookMarkFragment.kt | 3108473987 |
package com.example.uas.ui.search
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.example.uas.R
import com.example.uas.UnivAdapter
import com.example.uas.api.ApiConfig
import com.example.uas.api.UnivResponseItem
import com.example.uas.databinding.FragmentSearchBinding
import com.mobile.mp3_final.repository.UnivRespos
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [SearchFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class SearchFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
private lateinit var binding: FragmentSearchBinding
private lateinit var adapter: UnivAdapter
private lateinit var rv : RecyclerView
private lateinit var univRespos: UnivRespos
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
// Inflate the layout for this fragment
binding = FragmentSearchBinding.inflate(inflater, container, false)
val view = binding.root
rv = view.findViewById(R.id.rv_chara)
val application = requireNotNull(this.activity).application
univRespos = UnivRespos(application)
adapter = UnivAdapter(ArrayList(), univRespos)
rv.adapter = adapter
rv.layoutManager = LinearLayoutManager(requireContext())
getChara()
return view
}
private fun getChara() {
val client = ApiConfig.getApiService().getChara()
client.enqueue(object:Callback<List<UnivResponseItem>>{
override fun onResponse(
call: Call<List<UnivResponseItem>>,
response: Response<List<UnivResponseItem>>
) {
if (response.isSuccessful) {
val responseBody = response.body()
val adapter = responseBody?.let { UnivAdapter(it, univRespos) }
binding.rvChara.adapter = adapter
}
else {
Log.e("Home Fragment" , "network call failure on response: ${response.message()}")
}
}
override fun onFailure(call: Call<List<UnivResponseItem>>, t: Throwable) {
Log.e("Home Fragment","network call failure: ${t.message}")
}
})
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment SearchFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
SearchFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | UAS_Pemob/app/src/main/java/com/example/uas/ui/search/SearchFragment.kt | 1332606164 |
package com.example.uas.database
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
@Database(entities = [Univ::class], version = 1)
abstract class UnivRoomDatabase: RoomDatabase() {
abstract fun UnivDao() : UnivDao
companion object {
@Volatile
private var INSTANCE:UnivRoomDatabase?= null
@JvmStatic
fun getDatabase(context: Context):UnivRoomDatabase {
if (INSTANCE == null) {
synchronized(UnivRoomDatabase::class.java) {
INSTANCE = Room.databaseBuilder(context.applicationContext,
UnivRoomDatabase::class.java, "chara_database")
.build()
}
}
return INSTANCE as UnivRoomDatabase
}
}
} | UAS_Pemob/app/src/main/java/com/example/uas/database/UnivRoomDatabase.kt | 2236747985 |
package com.example.uas.database
import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
@Dao
interface UnivDao {
@Insert(onConflict = OnConflictStrategy.IGNORE)
fun insert (univ: Univ)
@Update
fun update(univ: Univ)
@Delete
fun delete(univ: Univ)
@Query("SELECT * FROM Univ")
fun getAllUniv(): List<Univ>
@Query("SELECT * FROM Univ WHERE name = :name AND country = :country")
fun getUnivData(name: String?, country : String?): Univ?
} | UAS_Pemob/app/src/main/java/com/example/uas/database/UnivDao.kt | 2869248622 |
package com.example.uas.database
import android.os.Parcelable
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
import kotlinx.parcelize.Parcelize
@Entity
@Parcelize
data class Univ(
@PrimaryKey(autoGenerate = true)
@ColumnInfo(name = "id")
var id: Int = 0,
@ColumnInfo(name = "name")
var name: String?= null,
@ColumnInfo(name = "country")
var country: String?= null,
): Parcelable
| UAS_Pemob/app/src/main/java/com/example/uas/database/Univ.kt | 235090919 |
package com.mobile.mp3_final.repository
import android.app.Application
import androidx.lifecycle.MutableLiveData
import com.example.uas.database.Univ
import com.example.uas.database.UnivDao
import com.example.uas.database.UnivRoomDatabase
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
class UnivRespos(application: Application) {
private var mUnivDao:UnivDao
private val executorService: ExecutorService = Executors.newSingleThreadExecutor()
init {
val db = UnivRoomDatabase.getDatabase(application)
mUnivDao = db.UnivDao()
}
private val insertionStatus = MutableLiveData<Boolean>()
fun insertIfNotExists(name: String?, country: String?) {
executorService.execute {
val existingUniv = mUnivDao.getUnivData(name, country)
if (existingUniv == null) {
val newUniv = Univ(name = name, country = country)
mUnivDao.insert(newUniv)
insertionStatus.postValue(true)
}
else {
insertionStatus.postValue(false)
}
}
}
fun deleteExistingUniv(name: String, country : String) {
executorService.execute {
val existingNote = mUnivDao.getUnivData(name, country)
existingNote?.let {
mUnivDao.delete(it)
}
}
}
fun update(univ: Univ) {
executorService.execute {
mUnivDao.update(univ)
}
}
} | UAS_Pemob/app/src/main/java/com/example/uas/repository/UnivRespos.kt | 3985882138 |
package com.example.uas
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.navigation.findNavController
import androidx.navigation.ui.setupWithNavController
import com.example.uas.databinding.ActivityMainBinding
import com.google.android.material.bottomnavigation.BottomNavigationView
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding =ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
val bottomNav: BottomNavigationView = binding.botNavView
val navController = findNavController(R.id.nav_host_fragment_activity_main)
bottomNav.setupWithNavController(navController)
}
} | UAS_Pemob/app/src/main/java/com/example/uas/MainActivity.kt | 1544868464 |
package com.example.uas
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageButton
import android.widget.TextView
import android.widget.Toast
import androidx.recyclerview.widget.RecyclerView
import com.example.uas.api.UnivResponseItem
import com.mobile.mp3_final.repository.UnivRespos
class UnivAdapter(
private val chara: List<UnivResponseItem>,
private val univRespos: UnivRespos
) : RecyclerView.Adapter<UnivAdapter.ViewHolder>() {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val view = LayoutInflater.from(parent.context)
.inflate(R.layout.item_row_univ, parent, false)
return ViewHolder(view)
}
override fun getItemCount(): Int {
return chara.size
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
val data = chara[position]
holder.name.text = data.name
holder.country.text = data.country
holder.favorite.setOnClickListener {
val dataInsert = chara[position]
univRespos.insertIfNotExists(dataInsert.name, dataInsert.country)
Toast.makeText(holder.itemView.context, "Data berhasil disimpan", Toast.LENGTH_SHORT).show()
}
}
inner class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
val name: TextView = view.findViewById(R.id.tv_univ_name)
val country: TextView = view.findViewById(R.id.tv_univ_country)
val favorite: ImageButton = view.findViewById(R.id.btn_favorite)
init {
favorite.setOnClickListener {
val position = adapterPosition
if (position != RecyclerView.NO_POSITION) {
val data = chara[position]
// Handle ImageButton click
univRespos.insertIfNotExists(data.name, data.country)
Toast.makeText(view.context, "Data berhasil disimpan", Toast.LENGTH_SHORT).show()
}
}
}
}
}
| UAS_Pemob/app/src/main/java/com/example/uas/UnivAdapter.kt | 3058970322 |
package com.example.uas.api
import com.google.gson.annotations.SerializedName
data class UnivResponse(
@field:SerializedName("UnivResponse")
val univResponse: List<UnivResponseItem?>? = null
)
data class UnivResponseItem(
@field:SerializedName("country")
val country: String? = null,
@field:SerializedName("web_pages")
val webPages: List<String?>? = null,
@field:SerializedName("name")
val name: String? = null,
@field:SerializedName("domains")
val domains: List<String?>? = null,
@field:SerializedName("alpha_two_code")
val alphaTwoCode: String? = null,
@field:SerializedName("state-province")
val stateProvince: Any? = null
)
| UAS_Pemob/app/src/main/java/com/example/uas/api/UnivResponse.kt | 2775347062 |
package com.example.uas.api
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
class ApiConfig {
companion object {
fun getApiService(): ApiService {
val loggingInterceptor =
HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY)
val client = OkHttpClient.Builder()
.addInterceptor(loggingInterceptor)
.build()
val retrofit = Retrofit.Builder()
.baseUrl("https://raw.githubusercontent.com/")
.addConverterFactory(GsonConverterFactory.create())
.client(client)
.build()
return retrofit.create(ApiService::class.java)
}
}
} | UAS_Pemob/app/src/main/java/com/example/uas/api/ApiConfig.kt | 2745118081 |
package com.example.uas.api
import retrofit2.Call
import retrofit2.http.GET
interface ApiService {
@GET("Hipo/university-domains-list/master/world_universities_and_domains.json")
fun getChara(): Call<List<UnivResponseItem>>
} | UAS_Pemob/app/src/main/java/com/example/uas/api/ApiService.kt | 3506027784 |
package com.example.uas
import android.annotation.SuppressLint
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import com.example.uas.database.Univ
import com.example.uas.databinding.ItemRowFavBinding
import com.mobile.mp3_final.repository.UnivRespos
class FavoriteAdapter (
private val univRespos: UnivRespos) :
RecyclerView.Adapter<FavoriteAdapter.FavViewHolder>(){
private val listUniv = ArrayList<Univ>()
inner class FavViewHolder (private val binding: ItemRowFavBinding) : RecyclerView.ViewHolder(binding.root){
fun bind (univ : Univ){
with(binding){
tvItemName.text = univ.name
tvItemDescription.text = univ.country
}
}
init {
binding.deleteBtn.setOnClickListener {
val position = adapterPosition
if (position != RecyclerView.NO_POSITION) {
val univToDelete = listUniv[position]
univToDelete.name?.let { name->
univToDelete.country?.let { country ->
univRespos.deleteExistingUniv(name, country)
listUniv.removeAt(position)
notifyItemRemoved(position)
}
}
}
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): FavViewHolder {
val binding = ItemRowFavBinding.inflate(LayoutInflater.from(parent.context), parent, false )
return FavViewHolder(binding)
}
override fun getItemCount(): Int {
return listUniv.size
}
override fun onBindViewHolder(holder: FavViewHolder, position: Int) {
holder.bind(listUniv[position])
}
@SuppressLint("NotifyDataSetChanged")
fun setUniv(univ: List<Univ>) {
listUniv.clear()
listUniv.addAll(univ)
notifyDataSetChanged()
}
} | UAS_Pemob/app/src/main/java/com/example/uas/FavoriteAdapter.kt | 3071941004 |
package com.dicoding.newsapp.ui
import android.os.Bundle
import androidx.annotation.StringRes
import androidx.appcompat.app.AppCompatActivity
import com.dicoding.newsapp.R
import com.dicoding.newsapp.databinding.ActivityHomeBinding
import com.google.android.material.tabs.TabLayout
import com.google.android.material.tabs.TabLayoutMediator
class HomeActivity : AppCompatActivity() {
private lateinit var binding: ActivityHomeBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityHomeBinding.inflate(layoutInflater)
setContentView(binding.root)
val sectionsPagerAdapter = SectionsPagerAdapter(this)
binding.viewPager.adapter = sectionsPagerAdapter
TabLayoutMediator(
binding.tabs, binding.viewPager
) { tab: TabLayout.Tab, position: Int ->
tab.text = resources.getString(TAB_TITLES[position])
}.attach()
supportActionBar?.elevation = 0f
}
companion object {
@StringRes
private val TAB_TITLES = intArrayOf(R.string.home, R.string.bookmark)
}
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/ui/HomeActivity.kt | 3209370039 |
package com.dicoding.newsapp.ui
import android.content.Context
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import com.dicoding.newsapp.data.NewsRepository
import com.dicoding.newsapp.di.Injection
class ViewModelFactory private constructor(private val newsRepository: NewsRepository) :
ViewModelProvider.NewInstanceFactory() {
@Suppress("UNCHECKED_CAST")
override fun <T : ViewModel> create(modelClass: Class<T>): T {
if (modelClass.isAssignableFrom(NewsViewModel::class.java)) {
return NewsViewModel(newsRepository) as T
}
throw IllegalArgumentException("Unknown ViewModel class: " + modelClass.name)
}
companion object {
@Volatile
private var instance: ViewModelFactory? = null
fun getInstance(context: Context): ViewModelFactory =
instance ?: synchronized(this) {
instance ?: ViewModelFactory(Injection.provideRepository(context))
}.also { instance = it }
}
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/ui/ViewModelFactory.kt | 375604895 |
package com.dicoding.newsapp.ui
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.fragment.app.Fragment
import androidx.viewpager2.adapter.FragmentStateAdapter
class SectionsPagerAdapter internal constructor(activity: AppCompatActivity) : FragmentStateAdapter(activity) {
override fun createFragment(position: Int): Fragment {
val fragment = NewsFragment()
val bundle = Bundle()
if (position == 0) {
bundle.putString(NewsFragment.ARG_TAB, NewsFragment.TAB_NEWS)
} else {
bundle.putString(NewsFragment.ARG_TAB, NewsFragment.TAB_BOOKMARK)
}
fragment.arguments = bundle
return fragment
}
override fun getItemCount(): Int {
return 2
}
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/ui/SectionsPagerAdapter.kt | 81996761 |
package com.dicoding.newsapp.ui
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.recyclerview.widget.LinearLayoutManager
import com.dicoding.newsapp.databinding.FragmentNewsBinding
class NewsFragment : Fragment() {
private var tabName: String? = null
private var _binding: FragmentNewsBinding? = null
private val binding get() = _binding
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
_binding = FragmentNewsBinding.inflate(layoutInflater, container, false)
return binding?.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
tabName = arguments?.getString(ARG_TAB)
val factory: ViewModelFactory = ViewModelFactory.getInstance(requireActivity())
val viewModel: NewsViewModel by viewModels {
factory
}
val newsAdapter = NewsAdapter()
binding?.rvNews?.apply {
layoutManager = LinearLayoutManager(context)
setHasFixedSize(true)
adapter = newsAdapter
}
}
override fun onDestroy() {
super.onDestroy()
_binding = null
}
companion object {
const val ARG_TAB = "tab_name"
const val TAB_NEWS = "news"
const val TAB_BOOKMARK = "bookmark"
}
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/ui/NewsFragment.kt | 228383840 |
package com.dicoding.newsapp.ui
import android.annotation.SuppressLint
import android.content.Intent
import android.net.Uri
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import com.bumptech.glide.request.RequestOptions
import com.dicoding.newsapp.R
import com.dicoding.newsapp.data.local.entity.NewsEntity
import com.dicoding.newsapp.databinding.ItemNewsBinding
import com.dicoding.newsapp.ui.NewsAdapter.MyViewHolder
import com.dicoding.newsapp.utils.DateFormatter
class NewsAdapter : ListAdapter<NewsEntity, MyViewHolder>(DIFF_CALLBACK) {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MyViewHolder {
val binding = ItemNewsBinding.inflate(LayoutInflater.from(parent.context), parent, false)
return MyViewHolder(binding)
}
override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
val news = getItem(position)
holder.bind(news)
}
class MyViewHolder(val binding: ItemNewsBinding) : RecyclerView.ViewHolder(
binding.root
) {
fun bind(news: NewsEntity) {
binding.tvItemTitle.text = news.title
binding.tvItemPublishedDate.text = DateFormatter.formatDate(news.publishedAt)
Glide.with(itemView.context)
.load(news.urlToImage)
.apply(RequestOptions.placeholderOf(R.drawable.ic_loading).error(R.drawable.ic_error))
.into(binding.imgPoster)
itemView.setOnClickListener {
val intent = Intent(Intent.ACTION_VIEW)
intent.data = Uri.parse(news.url)
itemView.context.startActivity(intent)
}
}
}
companion object {
val DIFF_CALLBACK: DiffUtil.ItemCallback<NewsEntity> =
object : DiffUtil.ItemCallback<NewsEntity>() {
override fun areItemsTheSame(oldItem: NewsEntity, newItem: NewsEntity): Boolean {
return oldItem.title == newItem.title
}
@SuppressLint("DiffUtilEquals")
override fun areContentsTheSame(oldItem: NewsEntity, newItem: NewsEntity): Boolean {
return oldItem == newItem
}
}
}
}
| fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/ui/NewsAdapter.kt | 3404389560 |
package com.dicoding.newsapp.ui
import androidx.lifecycle.ViewModel
import com.dicoding.newsapp.data.NewsRepository
class NewsViewModel(
private val newsRepository: NewsRepository
) : ViewModel() {
fun getHeadlineNews() = newsRepository.getHeadlineNews()
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/ui/NewsViewModel.kt | 2975325301 |
package com.dicoding.newsapp.di
import android.content.Context
import com.dicoding.newsapp.data.NewsRepository
import com.dicoding.newsapp.data.local.room.NewsDatabase
import com.dicoding.newsapp.data.remote.retrofit.ApiConfig
import com.dicoding.newsapp.utils.AppExecutors
object Injection {
fun provideRepository(context: Context): NewsRepository {
val apiService = ApiConfig.getApiService()
val database = NewsDatabase.getInstance(context)
val dao = database.newsDao()
val appExecutors = AppExecutors()
return NewsRepository.getInstance(apiService, dao, appExecutors)
}
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/di/Injection.kt | 3007226566 |
package com.dicoding.newsapp.utils
import java.text.DateFormat
import java.text.ParseException
import java.text.SimpleDateFormat
import java.util.*
object DateFormatter {
fun formatDate(currentDate: String): String? {
val currentFormat = "yyyy-MM-dd'T'hh:mm:ss'Z'"
val targetFormat = "dd MMM yyyy | HH:mm"
val timezone = "GMT"
val currentDf: DateFormat = SimpleDateFormat(currentFormat, Locale.getDefault())
currentDf.timeZone = TimeZone.getTimeZone(timezone)
val targetDf: DateFormat = SimpleDateFormat(targetFormat, Locale.getDefault())
var targetDate: String? = null
try {
val date = currentDf.parse(currentDate)
if (date != null) {
targetDate = targetDf.format(date)
}
} catch (ex: ParseException) {
ex.printStackTrace()
}
return targetDate
}
}
| fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/utils/DateFormatter.kt | 795394264 |
package com.dicoding.newsapp.utils
import android.os.Handler
import android.os.Looper
import java.util.concurrent.Executor
import java.util.concurrent.Executors
class AppExecutors {
val diskIO: Executor = Executors.newSingleThreadExecutor()
val networkIO: Executor = Executors.newFixedThreadPool(3)
val mainThread: Executor = MainThreadExecutor()
private class MainThreadExecutor : Executor {
private val mainThreadHandler = Handler(Looper.getMainLooper())
override fun execute(command: Runnable) {
mainThreadHandler.post(command)
}
}
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/utils/AppExecutors.kt | 538163813 |
package com.dicoding.newsapp.data
sealed class Result<out R> private constructor() {
data class Success<out T>(val data: T) : Result<T>()
data class Error(val error: String) : Result<Nothing>()
object Loading : Result<Nothing>()
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/data/Result.kt | 398125349 |
package com.dicoding.newsapp.data.local.room
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import com.dicoding.newsapp.data.local.entity.NewsEntity
@Database(entities = [NewsEntity::class], version = 1, exportSchema = false)
abstract class NewsDatabase : RoomDatabase() {
abstract fun newsDao(): NewsDao
companion object {
@Volatile
private var instance: NewsDatabase? = null
fun getInstance(context: Context): NewsDatabase =
instance ?: synchronized(this) {
instance ?: Room.databaseBuilder(
context.applicationContext,
NewsDatabase::class.java, "News.db"
).build()
}
}
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/data/local/room/NewsDatabase.kt | 3178658940 |
package com.dicoding.newsapp.data.local.room
import androidx.lifecycle.LiveData
import androidx.room.*
import com.dicoding.newsapp.data.local.entity.NewsEntity
@Dao
interface NewsDao {
@Query("SELECT * FROM news ORDER BY publishedAt DESC")
fun getNews(): LiveData<List<NewsEntity>>
@Query("SELECT * FROM news where bookmarked = 1")
fun getBookmarkedNews(): LiveData<List<NewsEntity>>
@Insert(onConflict = OnConflictStrategy.IGNORE)
fun insertNews(news: List<NewsEntity>)
@Update
fun updateNews(news: NewsEntity)
@Query("DELETE FROM news WHERE bookmarked = 0")
fun deleteAll()
@Query("SELECT EXISTS(SELECT * FROM news WHERE title = :title AND bookmarked = 1)")
fun isNewsBookmarked(title: String): Boolean
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/data/local/room/NewsDao.kt | 4206899659 |
package com.dicoding.newsapp.data.local.entity
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity(tableName = "news")
class NewsEntity(
@field:ColumnInfo(name = "title")
@field:PrimaryKey
val title: String,
@field:ColumnInfo(name = "publishedAt")
val publishedAt: String,
@field:ColumnInfo(name = "urlToImage")
val urlToImage: String? = null,
@field:ColumnInfo(name = "url")
val url: String? = null,
@field:ColumnInfo(name = "bookmarked")
var isBookmarked: Boolean
) | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/data/local/entity/NewsEntity.kt | 1595222583 |
package com.dicoding.newsapp.data
import androidx.lifecycle.LiveData
import androidx.lifecycle.MediatorLiveData
import com.dicoding.newsapp.BuildConfig
import com.dicoding.newsapp.data.local.entity.NewsEntity
import com.dicoding.newsapp.data.local.room.NewsDao
import com.dicoding.newsapp.data.remote.response.NewsResponse
import com.dicoding.newsapp.data.remote.retrofit.ApiService
import com.dicoding.newsapp.utils.AppExecutors
import retrofit2.Call
import retrofit2.Response
class NewsRepository private constructor(
private val apiService: ApiService,
private val newsDao: NewsDao,
private val appExecutors: AppExecutors
) {
private val result = MediatorLiveData<Result<List<NewsEntity>>>()
fun getHeadlineNews(): LiveData<Result<List<NewsEntity>>> {
result.value = Result.Loading
val client = apiService.getNews(BuildConfig.API_KEY)
client.enqueue(object : retrofit2.Callback<NewsResponse> {
override fun onResponse(call: Call<NewsResponse>, response: Response<NewsResponse>) {
if (response.isSuccessful) {
val articles = response.body()?.articles
val newsList = ArrayList<NewsEntity>()
appExecutors.diskIO.execute {
articles?.forEach { article ->
val isBookmarked = newsDao.isNewsBookmarked(article.title)
val news = NewsEntity(
article.title,
article.publishedAt,
article.urlToImage,
article.url,
isBookmarked
)
newsList.add(news)
}
newsDao.deleteAll()
newsDao.insertNews(newsList)
}
}
}
override fun onFailure(call: Call<NewsResponse>, t: Throwable) {
result.value = Result.Error(t.message.toString())
}
})
val localData = newsDao.getNews()
result.addSource(localData) { newData: List<NewsEntity> ->
result.value = Result.Success(newData)
}
return result
}
companion object{
@Volatile
private var instance: NewsRepository? = null
fun getInstance(
apiService: ApiService,
newsDao: NewsDao,
appExecutors: AppExecutors
): NewsRepository =
instance ?: synchronized(this) {
instance ?: NewsRepository(apiService, newsDao, appExecutors)
}.also { instance = it }
}
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/data/NewsRepository.kt | 3570930101 |
package com.dicoding.newsapp.data.remote.response
import com.google.gson.annotations.SerializedName
data class NewsResponse(
@field:SerializedName("totalResults")
val totalResults: Int,
@field:SerializedName("articles")
val articles: List<ArticlesItem>,
@field:SerializedName("status")
val status: String
)
data class Source(
@field:SerializedName("name")
val name: String,
@field:SerializedName("id")
val id: Any
)
data class ArticlesItem(
@field:SerializedName("publishedAt")
val publishedAt: String,
@field:SerializedName("author")
val author: String,
@field:SerializedName("urlToImage")
val urlToImage: String,
@field:SerializedName("description")
val description: String,
@field:SerializedName("source")
val source: Source,
@field:SerializedName("title")
val title: String,
@field:SerializedName("url")
val url: String,
@field:SerializedName("content")
val content: Any
)
| fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/data/remote/response/NewsResponse.kt | 774233736 |
package com.dicoding.newsapp.data.remote.retrofit
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
object ApiConfig {
fun getApiService(): ApiService {
val loggingInterceptor = HttpLoggingInterceptor()
.setLevel(HttpLoggingInterceptor.Level.BODY)
val client: OkHttpClient = OkHttpClient.Builder()
.addInterceptor(loggingInterceptor)
.build()
val retrofit = Retrofit.Builder()
.baseUrl("https://newsapi.org/v2/")
.addConverterFactory(GsonConverterFactory.create())
.client(client)
.build()
return retrofit.create(ApiService::class.java)
}
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/data/remote/retrofit/ApiConfig.kt | 3192421517 |
package com.dicoding.newsapp.data.remote.retrofit
import com.dicoding.newsapp.data.remote.response.NewsResponse
import retrofit2.Call
import retrofit2.http.GET
import retrofit2.http.Query
interface ApiService {
@GET("top-headlines?country=id&category=science")
fun getNews(@Query("apiKey") apiKey: String): Call<NewsResponse>
} | fundamental-android-practice/MyLocalRepository/app/src/main/java/com/dicoding/newsapp/data/remote/retrofit/ApiService.kt | 1372167262 |
package dev.rushia.myalarmmanager
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("dev.rushia.myalarmmanager", appContext.packageName)
}
} | fundamental-android-practice/MyAlarmManager/app/src/androidTest/java/dev/rushia/myalarmmanager/ExampleInstrumentedTest.kt | 1706750153 |
package dev.rushia.myalarmmanager
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)
}
} | fundamental-android-practice/MyAlarmManager/app/src/test/java/dev/rushia/myalarmmanager/ExampleUnitTest.kt | 3431147997 |
package dev.rushia.myalarmmanager
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
} | fundamental-android-practice/MyAlarmManager/app/src/main/java/dev/rushia/myalarmmanager/MainActivity.kt | 1883028995 |
package dev.rushia.myalarmmanager
import android.app.DatePickerDialog
import android.content.Context
import android.widget.DatePicker
import androidx.fragment.app.DialogFragment
import java.util.Calendar
class DatePickerFragment : DialogFragment(), DatePickerDialog.OnDateSetListener {
private var mListener: DialogDateListener? = null
override fun onDateSet(view: DatePicker?, year: Int, month: Int, dayOfMonth: Int) {
mListener?.onDialogDateSet(tag, year, month, dayOfMonth)
}
override fun onAttach(context: Context) {
super.onAttach(context)
mListener = context as DialogDateListener?
}
override fun onDetach() {
super.onDetach()
if (mListener != null) {
mListener = null
}
}
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
val calendar = Calendar.getInstance()
val year = calendar.get(Calendar.YEAR)
val month = calendar.get(Calendar.MONTH)
val date = calendar.get(Calendar.DATE)
return DatePickerDialog(activity as Context, this, year, month, date)
}
override fun onDateSet(view: DatePicker, year: Int, month: Int, dayOfMonth: Int) {
mListener?.onDialogDateSet(tag, year, month, dayOfMonth)
}
interface DialogDateListener{
}
} | fundamental-android-practice/MyAlarmManager/app/src/main/java/dev/rushia/myalarmmanager/DatePickerFragment.kt | 2267391820 |
package dev.rushia.myalarmmanager
import android.app.AlarmManager
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.media.RingtoneManager
import android.os.Build
import android.util.Log
import android.widget.Toast
import androidx.core.app.NotificationCompat
import androidx.core.content.ContextCompat
import java.text.ParseException
import java.text.SimpleDateFormat
import java.util.Calendar
import java.util.Locale
class AlarmReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
// This method is called when the BroadcastReceiver is receiving an Intent broadcast.
val type = intent.getStringExtra(EXTRA_TYPE)
val message = intent.getStringExtra(EXTRA_MESSAGE)
val title =
if (type.equals(TYPE_ONE_TIME, ignoreCase = true)) TYPE_ONE_TIME else TYPE_REPEATING
val notifId =
if (type.equals(TYPE_ONE_TIME, ignoreCase = true)) ID_ONETIME else ID_REPEATING
if (message != null) {
showAlarmNotification(context, title, message, notifId)
}
}
fun setOneTimeAlarm(
context: Context,
type: String,
date: String,
time: String,
message: String
) {
if (isDateInvalid(date, DATE_FORMAT) || isDateInvalid(time, TIME_FORMAT)) return
val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
val intent = Intent(context, AlarmReceiver::class.java)
intent.putExtra(EXTRA_MESSAGE, message)
intent.putExtra(EXTRA_TYPE, type)
Log.e("ONE TIME", "$date $time")
val dateArray = date.split("-").toTypedArray()
val timeArray = time.split(":").toTypedArray()
val calendar = Calendar.getInstance()
calendar.set(Calendar.YEAR, Integer.parseInt(dateArray[0]))
calendar.set(Calendar.MONTH, Integer.parseInt(dateArray[1]) - 1)
calendar.set(Calendar.DAY_OF_MONTH, Integer.parseInt(dateArray[2]))
calendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(timeArray[0]))
calendar.set(Calendar.MINUTE, Integer.parseInt(timeArray[1]))
calendar.set(Calendar.SECOND, 0)
val pendingIntent =
PendingIntent.getBroadcast(context, ID_ONETIME, intent, PendingIntent.FLAG_IMMUTABLE)
alarmManager.set(AlarmManager.RTC_WAKEUP, calendar.timeInMillis, pendingIntent)
Toast.makeText(context, "One time alarm set up", Toast.LENGTH_SHORT).show()
}
private fun isDateInvalid(date: String, format: String): Boolean {
return try {
val df = SimpleDateFormat(format, Locale.getDefault())
df.isLenient = false
df.parse(date)
false
} catch (e: ParseException) {
true
}
}
private fun showAlarmNotification(
context: Context,
title: String,
message: String,
notifId: Int
) {
val channelId = "Channel_1"
val channelName = "AlarmManager channel"
val notificationManagerCompat =
context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
val alarmSound = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)
val builder = NotificationCompat.Builder(context, channelId)
.setSmallIcon(R.drawable.baseline_access_time_24)
.setContentTitle(title)
.setContentText(message)
.setColor(ContextCompat.getColor(context, android.R.color.transparent))
.setVibrate(longArrayOf(1000, 1000, 1000, 1000, 1000))
.setSound(alarmSound)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
val channel = NotificationChannel(
channelId,
channelName,
NotificationManager.IMPORTANCE_DEFAULT
)
channel.enableVibration(true)
channel.vibrationPattern = longArrayOf(1000, 1000, 1000, 1000, 1000)
builder.setChannelId(channelId)
notificationManagerCompat.createNotificationChannel(channel)
}
val notification = builder.build()
notificationManagerCompat.notify(notifId, notification)
}
companion object {
const val TYPE_ONE_TIME = "OneTimeAlarm"
const val TYPE_REPEATING = "RepeatingAlarm"
const val EXTRA_MESSAGE = "message"
const val EXTRA_TYPE = "type"
// Siapkan 2 id untuk 2 macam alarm, onetime dan repeating
private const val ID_ONETIME = 100
private const val ID_REPEATING = 101
private const val DATE_FORMAT = "yyyy-MM-dd"
private const val TIME_FORMAT = "HH:mm"
}
} | fundamental-android-practice/MyAlarmManager/app/src/main/java/dev/rushia/myalarmmanager/AlarmReceiver.kt | 1928165048 |
package dev.rushia.myappbar
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("dev.rushia.myappbar", appContext.packageName)
}
} | fundamental-android-practice/MyAppBar/app/src/androidTest/java/dev/rushia/myappbar/ExampleInstrumentedTest.kt | 2283245481 |
package dev.rushia.myappbar
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)
}
} | fundamental-android-practice/MyAppBar/app/src/test/java/dev/rushia/myappbar/ExampleUnitTest.kt | 2872133463 |
package dev.rushia.myappbar
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import dev.rushia.myappbar.databinding.ActivityMainBinding
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// setContentView(R.layout.activity_main)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
binding.topAppBar.setOnMenuItemClickListener { menuItem ->
when (menuItem.itemId) {
R.id.menu1 -> {
supportFragmentManager.beginTransaction()
.replace(R.id.fragment_container, MenuFragment()).addToBackStack(null)
.commit()
true
}
R.id.menu2 -> {
val intent = Intent(this, MenuActivity::class.java)
startActivity(intent)
true
}
else -> false
}
}
}
} | fundamental-android-practice/MyAppBar/app/src/main/java/dev/rushia/myappbar/MainActivity.kt | 236989780 |
package dev.rushia.myappbar
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Toast
import dev.rushia.myappbar.databinding.ActivityMenuBinding
class MenuActivity : AppCompatActivity() {
private lateinit var binding: ActivityMenuBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMenuBinding.inflate(layoutInflater)
setContentView(binding.root)
with(binding) {
searchView.setupWithSearchBar(searchBar)
searchView
.editText
.setOnEditorActionListener { textView, actionId, event ->
searchBar.text = searchView.text
searchView.hide()
Toast.makeText(this@MenuActivity, searchView.text, Toast.LENGTH_SHORT).show()
false
}
}
}
} | fundamental-android-practice/MyAppBar/app/src/main/java/dev/rushia/myappbar/MenuActivity.kt | 3175417068 |
package dev.rushia.myappbar
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [MenuFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class MenuFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_menu, container, false)
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment MenuFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
MenuFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | fundamental-android-practice/MyAppBar/app/src/main/java/dev/rushia/myappbar/MenuFragment.kt | 3631815993 |
package dev.rushia.mysettingpreference
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("dev.rushia.mysettingpreference", appContext.packageName)
}
} | fundamental-android-practice/MySettingPreference/app/src/androidTest/java/dev/rushia/mysettingpreference/ExampleInstrumentedTest.kt | 94842506 |
package dev.rushia.mysettingpreference
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)
}
} | fundamental-android-practice/MySettingPreference/app/src/test/java/dev/rushia/mysettingpreference/ExampleUnitTest.kt | 3227539355 |
package dev.rushia.mysettingpreference
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.preference.EditTextPreference
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
supportFragmentManager.beginTransaction().add(R.id.setting_holder, MyPreferenceFragment())
.commit()
}
} | fundamental-android-practice/MySettingPreference/app/src/main/java/dev/rushia/mysettingpreference/MainActivity.kt | 2546377909 |
package dev.rushia.mysettingpreference
import android.content.SharedPreferences
import android.os.Bundle
import androidx.preference.CheckBoxPreference
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceFragmentCompat
class MyPreferenceFragment : PreferenceFragmentCompat(),
SharedPreferences.OnSharedPreferenceChangeListener {
private lateinit var NAME: String
private lateinit var EMAIL: String
private lateinit var AGE: String
private lateinit var PHONE: String
private lateinit var LOVE: String
private lateinit var namePreference: EditTextPreference
private lateinit var emailPreference: EditTextPreference
private lateinit var agePreference: EditTextPreference
private lateinit var phonePreference: EditTextPreference
private lateinit var isLoveMuPreference: CheckBoxPreference
override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
addPreferencesFromResource(R.xml.preferences)
init()
setSummaries()
}
companion object {
private const val DEFAULT_VALUE = "Tidak Ada"
}
private fun init() {
NAME = resources.getString(R.string.key_name)
EMAIL = resources.getString(R.string.key_email)
AGE = resources.getString(R.string.key_age)
PHONE = resources.getString(R.string.key_phone)
LOVE = resources.getString(R.string.key_love)
namePreference = findPreference<EditTextPreference>(NAME) as EditTextPreference
emailPreference = findPreference<EditTextPreference>(EMAIL) as EditTextPreference
agePreference = findPreference<EditTextPreference>(AGE) as EditTextPreference
phonePreference = findPreference<EditTextPreference>(PHONE) as EditTextPreference
isLoveMuPreference = findPreference<CheckBoxPreference>(LOVE) as CheckBoxPreference
}
private fun setSummaries() {
val sh = preferenceManager.sharedPreferences
namePreference.summary = sh.getString(NAME, DEFAULT_VALUE)
emailPreference.summary = sh.getString(EMAIL, DEFAULT_VALUE)
agePreference.summary = sh.getString(AGE, DEFAULT_VALUE)
phonePreference.summary = sh.getString(PHONE, DEFAULT_VALUE)
isLoveMuPreference.isChecked = sh.getBoolean(LOVE, false)
}
override fun onResume() {
super.onResume()
preferenceScreen.sharedPreferences.registerOnSharedPreferenceChangeListener(this)
}
override fun onPause() {
super.onPause()
preferenceScreen.sharedPreferences.unregisterOnSharedPreferenceChangeListener(this)
}
override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences, key: String?) {
if (key == NAME) {
namePreference.summary = sharedPreferences.getString(NAME, DEFAULT_VALUE)
}
if (key == EMAIL) {
emailPreference.summary = sharedPreferences.getString(EMAIL, DEFAULT_VALUE)
}
if (key == AGE) {
agePreference.summary = sharedPreferences.getString(AGE, DEFAULT_VALUE)
}
if (key == PHONE) {
phonePreference.summary = sharedPreferences.getString(PHONE, DEFAULT_VALUE)
}
if (key == LOVE) {
isLoveMuPreference.isChecked = sharedPreferences.getBoolean(LOVE, false)
}
}
} | fundamental-android-practice/MySettingPreference/app/src/main/java/dev/rushia/mysettingpreference/MyPreferenceFragment.kt | 599830387 |
package dev.rushia.restaurantreview
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("dev.rushia.restaurantreview", appContext.packageName)
}
} | fundamental-android-practice/RestaurantReview/app/src/androidTest/java/dev/rushia/restaurantreview/ExampleInstrumentedTest.kt | 3735164714 |
package dev.rushia.restaurantreview
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)
}
} | fundamental-android-practice/RestaurantReview/app/src/test/java/dev/rushia/restaurantreview/ExampleUnitTest.kt | 3719217384 |
package dev.rushia.restaurantreview.ui
import android.util.Log
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import dev.rushia.restaurantreview.data.response.CustomerReviewsItem
import dev.rushia.restaurantreview.data.response.PostReviewResponse
import dev.rushia.restaurantreview.data.response.Restaurant
import dev.rushia.restaurantreview.data.response.RestaurantResponse
import dev.rushia.restaurantreview.data.retrofit.ApiConfig
import dev.rushia.restaurantreview.util.Event
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
class MainViewModel : ViewModel() {
private val TAG = "MainViewModel"
private val _restaurant = MutableLiveData<Restaurant>()
val restaurant: LiveData<Restaurant> = _restaurant
private val _listReview = MutableLiveData<List<CustomerReviewsItem>>()
val listReview: LiveData<List<CustomerReviewsItem>> = _listReview
private val _isLoading = MutableLiveData<Boolean>()
val isLoading: LiveData<Boolean> = _isLoading
private val _snackbarText = MutableLiveData<Event<String>>()
val snackbarText: LiveData<Event<String>> = _snackbarText
init {
findRestaurant()
}
private fun findRestaurant() {
_isLoading.value = true
val client = ApiConfig.getApiService().getRestraurant(Companion.RESTAURANT_ID)
client.enqueue(object : Callback<RestaurantResponse> {
override fun onResponse(
call: Call<RestaurantResponse>,
response: Response<RestaurantResponse>
) {
_isLoading.value = false
if (response.isSuccessful) {
_restaurant.value = response.body()?.restaurant
_listReview.value = response.body()?.restaurant?.customerReviews
} else {
Log.e(TAG, "onFailure : ${response.message()}")
}
}
override fun onFailure(call: Call<RestaurantResponse>, t: Throwable) {
_isLoading.value = false
Log.e(TAG, "onFailure : ${t.message.toString()}")
}
})
}
fun postReview(review: String) {
_isLoading.value = true
val client =
ApiConfig.getApiService().postReview(Companion.RESTAURANT_ID, "Dicoding", review)
client.enqueue(object : Callback<PostReviewResponse> {
override fun onResponse(
call: Call<PostReviewResponse>,
response: Response<PostReviewResponse>
) {
_isLoading.value = false
if (response.isSuccessful) {
_listReview.value = response.body()?.customerReviews
_snackbarText.value = Event(response.body()?.message.toString())
} else {
Log.e(TAG, "onFailure: ${response.message()}")
}
}
override fun onFailure(call: Call<PostReviewResponse>, t: Throwable) {
_isLoading.value = false
Log.e(TAG, "onFailure: ${t.message.toString()}")
}
})
}
companion object {
private const val RESTAURANT_ID = "uewq1zg2zlskfw1e867"
}
} | fundamental-android-practice/RestaurantReview/app/src/main/java/dev/rushia/restaurantreview/ui/MainViewModel.kt | 2198653536 |
package dev.rushia.restaurantreview.ui
import android.content.Context
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.view.View
import android.view.inputmethod.InputMethodManager
import androidx.activity.viewModels
import androidx.lifecycle.ViewModelProvider
import androidx.recyclerview.widget.DividerItemDecoration
import androidx.recyclerview.widget.LinearLayoutManager
import com.bumptech.glide.Glide
import com.google.android.material.snackbar.Snackbar
import dev.rushia.restaurantreview.ReviewAdapter
import dev.rushia.restaurantreview.data.response.CustomerReviewsItem
import dev.rushia.restaurantreview.data.response.PostReviewResponse
import dev.rushia.restaurantreview.data.response.Restaurant
import dev.rushia.restaurantreview.data.response.RestaurantResponse
import dev.rushia.restaurantreview.data.retrofit.ApiConfig
import dev.rushia.restaurantreview.databinding.ActivityMainBinding
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
private val mainViewModel by viewModels<MainViewModel>()
companion object {
private const val TAG = "MainActivity"
private const val RESTAURANT_ID = "uewq1zg2zlskfw1e867"
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
supportActionBar?.hide()
// val layoutManager = LinearLayoutManager(this)
// binding.rvReview.layoutManager = layoutManager
// val itemDecoration = DividerItemDecoration(this, layoutManager.orientation)
// binding.rvReview.addItemDecoration(itemDecoration)
// findRestaurant()
//
// binding.btnSend.setOnClickListener { view ->
// postReview(binding.edReview.text.toString())
// val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
// imm.hideSoftInputFromWindow(view.windowToken, 0)
// }
mainViewModel.restaurant.observe(this) { restaurant ->
setRestaurantData(restaurant)
}
mainViewModel.snackbarText.observe(this) {
it.getContentIfNotHandled()?.let { snackBarText ->
Snackbar.make(window.decorView.rootView, snackBarText, Snackbar.LENGTH_SHORT).show()
}
}
val layoutManager = LinearLayoutManager(this)
binding.rvReview.layoutManager = layoutManager
val itemDecoration = DividerItemDecoration(this, layoutManager.orientation)
binding.rvReview.addItemDecoration(itemDecoration)
mainViewModel.listReview.observe(this) { consumerReviews ->
setReviewData(consumerReviews)
}
mainViewModel.isLoading.observe(this) {
showLoading(it)
}
binding.btnSend.setOnClickListener { view ->
mainViewModel.postReview(binding.edReview.text.toString())
val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
imm.hideSoftInputFromWindow(view.windowToken, 0)
}
}
private fun findRestaurant() {
showLoading(true)
val client = ApiConfig.getApiService().getRestraurant(RESTAURANT_ID)
client.enqueue(object : Callback<RestaurantResponse> {
override fun onResponse(
call: Call<RestaurantResponse>, response: Response<RestaurantResponse>
) {
showLoading(false)
if (response.isSuccessful) {
val responseBody = response.body()
if (responseBody != null) {
setRestaurantData(responseBody.restaurant)
setReviewData(responseBody.restaurant.customerReviews)
}
} else {
Log.e(TAG, "onFailure: ${response.message()}")
}
}
override fun onFailure(call: Call<RestaurantResponse>, t: Throwable) {
showLoading(false)
Log.e(TAG, "onFailure: ${t.message}")
}
})
}
private fun setRestaurantData(restaurant: Restaurant) {
binding.tvTitle.text = restaurant.name
binding.tvDescription.text = restaurant.description
Glide.with(this@MainActivity)
.load("https://restaurant-api.dicoding.dev/images/large/${restaurant.pictureId}")
.into(binding.ivPicture)
}
private fun setReviewData(consumerReviews: List<CustomerReviewsItem>) {
val adapter = ReviewAdapter()
adapter.submitList(consumerReviews)
binding.rvReview.adapter = adapter
binding.edReview.setText("")
}
private fun showLoading(isLoading: Boolean) {
if (isLoading) {
binding.progressBar.visibility = View.VISIBLE
} else {
binding.progressBar.visibility = View.GONE
}
}
private fun postReview(review: String) {
showLoading(true)
val client = ApiConfig.getApiService().postReview(RESTAURANT_ID, "Dicoding", review)
client.enqueue(object : Callback<PostReviewResponse> {
override fun onResponse(
call: Call<PostReviewResponse>, response: Response<PostReviewResponse>
) {
showLoading(false)
val responseBody = response.body()
if (response.isSuccessful && responseBody != null) {
setReviewData(responseBody.customerReviews)
} else {
Log.e(TAG, "onFailure: ${response.message()}")
}
}
override fun onFailure(call: Call<PostReviewResponse>, t: Throwable) {
showLoading(false)
Log.e(TAG, "onFailure: ${t.message}")
}
})
}
} | fundamental-android-practice/RestaurantReview/app/src/main/java/dev/rushia/restaurantreview/ui/MainActivity.kt | 1702766865 |
package dev.rushia.restaurantreview.util
open class Event<out T>(private val content: T) {
@Suppress("MemberVisibilityCanBePrivate")
var hasBeenHandled = false
private set
fun getContentIfNotHandled(): T? {
return if (hasBeenHandled) {
null
} else {
hasBeenHandled = true
content
}
}
fun peekContent(): T = content
} | fundamental-android-practice/RestaurantReview/app/src/main/java/dev/rushia/restaurantreview/util/Event.kt | 164617213 |
package dev.rushia.restaurantreview
import android.annotation.SuppressLint
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import dev.rushia.restaurantreview.data.response.CustomerReviewsItem
import dev.rushia.restaurantreview.databinding.ItemReviewBinding
class ReviewAdapter : ListAdapter<CustomerReviewsItem, ReviewAdapter.MyViewHolder>(DIFF_CALLBACK) {
class MyViewHolder(val binding: ItemReviewBinding) : RecyclerView.ViewHolder(binding.root) {
@SuppressLint("SetTextI18n")
fun bind(review: CustomerReviewsItem) {
binding.tvItem.text = "${review.review}\n- ${review.name}"
}
}
companion object {
val DIFF_CALLBACK = object : DiffUtil.ItemCallback<CustomerReviewsItem>() {
override fun areItemsTheSame(
oldItem: CustomerReviewsItem,
newItem: CustomerReviewsItem
): Boolean {
return oldItem == newItem
}
override fun areContentsTheSame(
oldItem: CustomerReviewsItem,
newItem: CustomerReviewsItem
): Boolean {
return oldItem == newItem
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MyViewHolder {
val binding = ItemReviewBinding.inflate(LayoutInflater.from(parent.context), parent, false)
return MyViewHolder(binding)
}
override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
val review = getItem(position)
holder.bind(review)
}
} | fundamental-android-practice/RestaurantReview/app/src/main/java/dev/rushia/restaurantreview/ReviewAdapter.kt | 863325492 |
package dev.rushia.restaurantreview
| fundamental-android-practice/RestaurantReview/app/src/main/java/dev/rushia/restaurantreview/RestaurantResponse.kt | 1687099481 |
package dev.rushia.restaurantreview.data.response
import com.google.gson.annotations.SerializedName
data class RestaurantResponse(
@field:SerializedName("restaurant")
val restaurant: Restaurant,
@field:SerializedName("error")
val error: Boolean,
@field:SerializedName("message")
val message: String
)
data class Restaurant(
@field:SerializedName("customerReviews")
val customerReviews: List<CustomerReviewsItem>,
@field:SerializedName("pictureId")
val pictureId: String,
@field:SerializedName("name")
val name: String,
@field:SerializedName("rating")
val rating: Any,
@field:SerializedName("description")
val description: String,
@field:SerializedName("id")
val id: String
)
data class CustomerReviewsItem(
@field:SerializedName("date")
val date: String,
@field:SerializedName("review")
val review: String,
@field:SerializedName("name")
val name: String
)
data class PostReviewResponse(
@field:SerializedName("customerReviews") val customerReviews: List<CustomerReviewsItem>,
@field:SerializedName("error") val error: Boolean,
@field:SerializedName("message") val message: String
)
| fundamental-android-practice/RestaurantReview/app/src/main/java/dev/rushia/restaurantreview/data/response/RestaurantResponse.kt | 2522475080 |
package dev.rushia.restaurantreview.data.retrofit
import dev.rushia.restaurantreview.BuildConfig
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
class ApiConfig {
companion object {
fun getApiService(): ApiService {
val loggingInterceptor = if (BuildConfig.DEBUG) {
HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY)
} else {
HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.NONE)
}
val client = OkHttpClient.Builder()
.addInterceptor(loggingInterceptor)
.build()
val retrofit = Retrofit.Builder()
.baseUrl("https://restaurant-api.dicoding.dev/")
.addConverterFactory(GsonConverterFactory.create())
.client(client)
.build()
return retrofit.create(ApiService::class.java)
}
}
} | fundamental-android-practice/RestaurantReview/app/src/main/java/dev/rushia/restaurantreview/data/retrofit/ApiConfig.kt | 446401723 |
package dev.rushia.restaurantreview.data.retrofit
import dev.rushia.restaurantreview.data.response.PostReviewResponse
import dev.rushia.restaurantreview.data.response.RestaurantResponse
import retrofit2.Call
import retrofit2.http.*
interface ApiService {
@GET("detail/{id}")
fun getRestraurant(
@Path("id") id: String
): Call<RestaurantResponse>
@FormUrlEncoded
@Headers("Authorization: token 12345")
@POST("review")
fun postReview(
@Field("id") id: String,
@Field("name") name: String,
@Field("review") review: String
): Call<PostReviewResponse>
}
| fundamental-android-practice/RestaurantReview/app/src/main/java/dev/rushia/restaurantreview/data/retrofit/ApiService.kt | 2868991728 |
package dev.rushia.mybottomnavigation
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("dev.rushia.mybottomnavigation", appContext.packageName)
}
} | fundamental-android-practice/MyBottomNavigation/app/src/androidTest/java/dev/rushia/mybottomnavigation/ExampleInstrumentedTest.kt | 8028980 |
package dev.rushia.mybottomnavigation
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)
}
} | fundamental-android-practice/MyBottomNavigation/app/src/test/java/dev/rushia/mybottomnavigation/ExampleUnitTest.kt | 3529557040 |
package dev.rushia.mybottomnavigation.ui.home
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class HomeViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is home Fragment"
}
val text: LiveData<String> = _text
} | fundamental-android-practice/MyBottomNavigation/app/src/main/java/dev/rushia/mybottomnavigation/ui/home/HomeViewModel.kt | 663911778 |
package dev.rushia.mybottomnavigation.ui.home
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import dev.rushia.mybottomnavigation.databinding.FragmentHomeBinding
class HomeFragment : Fragment() {
private var _binding: FragmentHomeBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val homeViewModel =
ViewModelProvider(this).get(HomeViewModel::class.java)
_binding = FragmentHomeBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textHome
homeViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | fundamental-android-practice/MyBottomNavigation/app/src/main/java/dev/rushia/mybottomnavigation/ui/home/HomeFragment.kt | 1077719514 |
package dev.rushia.mybottomnavigation.ui.dashboard
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import dev.rushia.mybottomnavigation.databinding.FragmentDashboardBinding
class DashboardFragment : Fragment() {
private var _binding: FragmentDashboardBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val dashboardViewModel =
ViewModelProvider(this).get(DashboardViewModel::class.java)
_binding = FragmentDashboardBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textDashboard
dashboardViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | fundamental-android-practice/MyBottomNavigation/app/src/main/java/dev/rushia/mybottomnavigation/ui/dashboard/DashboardFragment.kt | 676703499 |
package dev.rushia.mybottomnavigation.ui.dashboard
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class DashboardViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is dashboard Fragment"
}
val text: LiveData<String> = _text
} | fundamental-android-practice/MyBottomNavigation/app/src/main/java/dev/rushia/mybottomnavigation/ui/dashboard/DashboardViewModel.kt | 2694226662 |
package dev.rushia.mybottomnavigation.ui.notifications
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class NotificationsViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is notifications Fragment"
}
val text: LiveData<String> = _text
} | fundamental-android-practice/MyBottomNavigation/app/src/main/java/dev/rushia/mybottomnavigation/ui/notifications/NotificationsViewModel.kt | 4200024916 |
package dev.rushia.mybottomnavigation.ui.notifications
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import dev.rushia.mybottomnavigation.databinding.FragmentNotificationsBinding
class NotificationsFragment : Fragment() {
private var _binding: FragmentNotificationsBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val notificationsViewModel =
ViewModelProvider(this).get(NotificationsViewModel::class.java)
_binding = FragmentNotificationsBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textNotifications
notificationsViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | fundamental-android-practice/MyBottomNavigation/app/src/main/java/dev/rushia/mybottomnavigation/ui/notifications/NotificationsFragment.kt | 1678510166 |
package dev.rushia.mybottomnavigation
import android.os.Bundle
import com.google.android.material.bottomnavigation.BottomNavigationView
import androidx.appcompat.app.AppCompatActivity
import androidx.navigation.findNavController
import androidx.navigation.ui.AppBarConfiguration
import androidx.navigation.ui.setupActionBarWithNavController
import androidx.navigation.ui.setupWithNavController
import dev.rushia.mybottomnavigation.databinding.ActivityMainBinding
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
val navView: BottomNavigationView = binding.navView
val navController = findNavController(R.id.nav_host_fragment_activity_main)
// Passing each menu ID as a set of Ids because each
// menu should be considered as top level destinations.
val appBarConfiguration = AppBarConfiguration(
setOf(
R.id.navigation_home, R.id.navigation_dashboard, R.id.navigation_notifications, R.id.navigation_profile
)
)
setupActionBarWithNavController(navController, appBarConfiguration)
navView.setupWithNavController(navController)
}
} | fundamental-android-practice/MyBottomNavigation/app/src/main/java/dev/rushia/mybottomnavigation/MainActivity.kt | 1870721722 |
package dev.rushia.mybottomnavigation
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [ProfileFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class ProfileFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_profile, container, false)
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment ProfileFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
ProfileFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | fundamental-android-practice/MyBottomNavigation/app/src/main/java/dev/rushia/mybottomnavigation/ProfileFragment.kt | 41062175 |
package dev.rushia.mynavigation
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("dev.rushia.mynavigation", appContext.packageName)
}
} | fundamental-android-practice/MyNavigation/app/src/androidTest/java/dev/rushia/mynavigation/ExampleInstrumentedTest.kt | 3880967621 |
package dev.rushia.mynavigation
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)
}
} | fundamental-android-practice/MyNavigation/app/src/test/java/dev/rushia/mynavigation/ExampleUnitTest.kt | 2135012653 |
package dev.rushia.mynavigation
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class ProfileActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_profile)
}
} | fundamental-android-practice/MyNavigation/app/src/main/java/dev/rushia/mynavigation/ProfileActivity.kt | 1257567738 |
package dev.rushia.mynavigation
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.navigation.findNavController
import dev.rushia.mynavigation.databinding.FragmentCategoryBinding
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [CategoryFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class CategoryFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
private var _binding: FragmentCategoryBinding? = null
private val binding get() = _binding!!
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
// return inflater.inflate(R.layout.fragment_category, container, false)
_binding = FragmentCategoryBinding.inflate(inflater, container, false)
val view = binding.root
return view
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.btnCategoryLifestyle.setOnClickListener {
// val mBundle = Bundle()
// mBundle.putString(EXTRA_NAME, "Lifestyle")
// mBundle.putLong(EXTRA_STOCK, 7)
// it.findNavController().navigate(R.id.action_categoryFragment_to_detailCategoryFragment, mBundle)
val toDetailCategoryFragment = CategoryFragmentDirections.actionCategoryFragmentToDetailCategoryFragment()
toDetailCategoryFragment.name = "Lifestyle (SafeArgs)"
toDetailCategoryFragment.stock = 7L
view.findNavController().navigate(toDetailCategoryFragment)
}
}
override fun onDestroy() {
super.onDestroy()
_binding = null
}
companion object {
const val EXTRA_NAME = "extra_name"
const val EXTRA_STOCK = "extra_stock"
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment CategoryFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
CategoryFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | fundamental-android-practice/MyNavigation/app/src/main/java/dev/rushia/mynavigation/CategoryFragment.kt | 2649428374 |
package dev.rushia.mynavigation
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
} | fundamental-android-practice/MyNavigation/app/src/main/java/dev/rushia/mynavigation/MainActivity.kt | 2898716966 |
package dev.rushia.mynavigation
import android.annotation.SuppressLint
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.navigation.Navigation
import dev.rushia.mynavigation.databinding.FragmentDetailCategoryBinding
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [DetailCategoryFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class DetailCategoryFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
private var _binding: FragmentDetailCategoryBinding? = null
private val binding get() = _binding!!
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
_binding = FragmentDetailCategoryBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val dataName = DetailCategoryFragmentArgs.fromBundle(arguments as Bundle).name
val dataDescription = DetailCategoryFragmentArgs.fromBundle(arguments as Bundle).stock
// val dataDescription = arguments?.getLong(CategoryFragment.EXTRA_STOCK)
binding.tvCategoryName.text = dataName
binding.tvCategoryDescription.text = "Stock : $dataDescription"
binding.btnHome.setOnClickListener(
Navigation.createNavigateOnClickListener(R.id.action_detailCategoryFragment_to_homeFragment)
)
}
override fun onDestroy() {
super.onDestroy()
_binding = null
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment DetailCategoryFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
DetailCategoryFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | fundamental-android-practice/MyNavigation/app/src/main/java/dev/rushia/mynavigation/DetailCategoryFragment.kt | 2753827693 |
package dev.rushia.mynavigation
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.navigation.Navigation
import androidx.navigation.findNavController
import dev.rushia.mynavigation.databinding.FragmentHomeBinding
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [HomeFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class HomeFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
private var _binding: FragmentHomeBinding? = null
private val binding get() = _binding!!
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
// return inflater.inflate(R.layout.fragment_home, container, false)
_binding = FragmentHomeBinding.inflate(inflater, container, false)
val view = binding.root
return view
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.btnCategory.setOnClickListener(
Navigation.createNavigateOnClickListener(R.id.action_homeFragment_to_categoryFragment)
)
binding.btnProfile.setOnClickListener {
it.findNavController().navigate(R.id.action_homeFragment_to_profileActivity)
}
}
override fun onDestroy() {
super.onDestroy()
_binding = null
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment HomeFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
HomeFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | fundamental-android-practice/MyNavigation/app/src/main/java/dev/rushia/mynavigation/HomeFragment.kt | 3096035722 |
package dev.rushia.mynoteapps
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("dev.rushia.mynoteapps", appContext.packageName)
}
} | fundamental-android-practice/MyNoteApps/app/src/androidTest/java/dev/rushia/mynoteapps/ExampleInstrumentedTest.kt | 1317114207 |
package dev.rushia.mynoteapps
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)
}
} | fundamental-android-practice/MyNoteApps/app/src/test/java/dev/rushia/mynoteapps/ExampleUnitTest.kt | 4017725941 |
package dev.rushia.mynoteapps.ui.insert
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.Menu
import android.view.MenuItem
import android.widget.Toast
import androidx.appcompat.app.AlertDialog
import androidx.lifecycle.ViewModelProvider
import dev.rushia.mynoteapps.R
import dev.rushia.mynoteapps.database.Note
import dev.rushia.mynoteapps.databinding.ActivityNoteAddUpdateBinding
import dev.rushia.mynoteapps.helper.DateHelper
import dev.rushia.mynoteapps.helper.ViewModelFactory
class NoteAddUpdateActivity : AppCompatActivity() {
companion object {
const val EXTRA_NOTE = "extra_note"
const val ALERT_DIALOG_CLOSE = 10
const val ALERT_DIALOG_DELETE = 20
}
private var isEdit = false
private var note: Note? = null
private lateinit var noteAddUpdateViewModel: NoteAddUpdateViewModel
private var _activityNoteAddUpdateBinding: ActivityNoteAddUpdateBinding? = null
private val binding get() = _activityNoteAddUpdateBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
_activityNoteAddUpdateBinding = ActivityNoteAddUpdateBinding.inflate(layoutInflater)
setContentView(binding?.root)
noteAddUpdateViewModel = obtainViewModel(this@NoteAddUpdateActivity)
note = intent.getParcelableExtra(EXTRA_NOTE)
if (note != null) {
isEdit = true
} else {
note = Note()
}
val actionBarTitle: String
val btnTitle: String
if (isEdit) {
actionBarTitle = getString(R.string.change)
btnTitle = getString(R.string.update)
if (note != null) {
note?.let { note ->
binding?.edtTitle?.setText(note.title)
binding?.edtDescription?.setText(note.description)
}
}
} else {
actionBarTitle = getString(R.string.add)
btnTitle = getString(R.string.save)
}
supportActionBar?.title = actionBarTitle
supportActionBar?.setDisplayHomeAsUpEnabled(true)
binding?.btnSubmit?.text = btnTitle
binding?.btnSubmit?.setOnClickListener {
val title = binding?.edtTitle?.text.toString().trim()
val description = binding?.edtDescription?.text.toString().trim()
when {
title.isEmpty() -> {
binding?.edtTitle?.error = getString(R.string.empty)
}
description.isEmpty() -> {
binding?.edtDescription?.error = getString(R.string.empty)
}
else -> {
note.let {
note
note?.title = title
note?.description = description
}
if (isEdit) {
noteAddUpdateViewModel.update(note as Note)
showToast(getString(R.string.changed))
} else {
note.let { note ->
note?.date = DateHelper.getCurrentDate()
}
noteAddUpdateViewModel.insert(note as Note)
showToast(getString(R.string.added))
}
finish()
}
}
}
}
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
if (isEdit) {
menuInflater.inflate(R.menu.menufile, menu)
}
return super.onCreateOptionsMenu(menu)
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_delete -> showAlertDialog(ALERT_DIALOG_DELETE)
android.R.id.home -> showAlertDialog(ALERT_DIALOG_CLOSE)
}
return super.onOptionsItemSelected(item)
}
override fun onBackPressed() {
super.onBackPressed()
showAlertDialog(ALERT_DIALOG_CLOSE)
}
private fun showAlertDialog(type: Int) {
val isDialogClose = type == ALERT_DIALOG_CLOSE
val dialogTitle: String
val dialogMessage: String
if (isDialogClose) {
dialogTitle = getString(R.string.cancel)
dialogMessage = getString(R.string.message_cancel)
} else {
dialogMessage = getString(R.string.message_delete)
dialogTitle = getString(R.string.delete)
}
val alertDialogBuilder = AlertDialog.Builder(this)
with(alertDialogBuilder) {
setTitle(dialogTitle)
setMessage(dialogMessage)
setCancelable(false)
setPositiveButton(getString(R.string.yes)) { _, _ ->
if (!isDialogClose) {
noteAddUpdateViewModel.delete(note as Note)
showToast(getString(R.string.deleted))
}
finish()
}
setNegativeButton(getString(R.string.no)) { dialog, _ -> dialog.cancel() }
}
val alertDialog = alertDialogBuilder.create()
alertDialog.show()
}
private fun showToast(message: String) {
Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
}
override fun onDestroy() {
super.onDestroy()
_activityNoteAddUpdateBinding = null
}
private fun obtainViewModel(activity: AppCompatActivity): NoteAddUpdateViewModel {
val factory = ViewModelFactory.getInstance(activity.application)
return ViewModelProvider(activity, factory).get(NoteAddUpdateViewModel::class.java)
}
} | fundamental-android-practice/MyNoteApps/app/src/main/java/dev/rushia/mynoteapps/ui/insert/NoteAddUpdateActivity.kt | 1930435948 |
package dev.rushia.mynoteapps.ui.insert
import android.app.Application
import androidx.lifecycle.ViewModel
import dev.rushia.mynoteapps.database.Note
import dev.rushia.mynoteapps.repository.NoteRepository
class NoteAddUpdateViewModel(application: Application) : ViewModel() {
private val mNoteRepository: NoteRepository = NoteRepository(application)
fun insert(note: Note) {
mNoteRepository.insert(note)
}
fun update(note: Note) {
mNoteRepository.update(note)
}
fun delete(note: Note) {
mNoteRepository.delete(note)
}
} | fundamental-android-practice/MyNoteApps/app/src/main/java/dev/rushia/mynoteapps/ui/insert/NoteAddUpdateViewModel.kt | 3114735731 |
package dev.rushia.mynoteapps.ui.main
import android.app.Application
import androidx.lifecycle.LiveData
import androidx.lifecycle.ViewModel
import dev.rushia.mynoteapps.database.Note
import dev.rushia.mynoteapps.repository.NoteRepository
class MainViewModel(application: Application) : ViewModel() {
private val mNoteRepository: NoteRepository = NoteRepository(application)
fun getAllNotes(): LiveData<List<Note>> = mNoteRepository.getAllNotes()
} | fundamental-android-practice/MyNoteApps/app/src/main/java/dev/rushia/mynoteapps/ui/main/MainViewModel.kt | 4041549743 |
package dev.rushia.mynoteapps.ui.main
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.lifecycle.ViewModelProvider
import androidx.recyclerview.widget.LinearLayoutManager
import dev.rushia.mynoteapps.R
import dev.rushia.mynoteapps.databinding.ActivityMainBinding
import dev.rushia.mynoteapps.helper.ViewModelFactory
import dev.rushia.mynoteapps.ui.insert.NoteAddUpdateActivity
class MainActivity : AppCompatActivity() {
private var _activityMainBinding: ActivityMainBinding? = null
private val binding get() = _activityMainBinding
private lateinit var adapter: NoteAdapter
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
_activityMainBinding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding?.root)
val mainViewModel = obtainViewModel(this@MainActivity)
mainViewModel.getAllNotes().observe(this) { noteList ->
if (noteList != null) {
adapter.setListNotes(noteList)
}
}
adapter = NoteAdapter()
binding?.rvNotes?.layoutManager = LinearLayoutManager(this)
binding?.rvNotes?.setHasFixedSize(true)
binding?.rvNotes?.adapter = adapter
binding?.fabAdd?.setOnClickListener {
val intent = Intent(this@MainActivity, NoteAddUpdateActivity::class.java)
startActivity(intent)
}
}
override fun onDestroy() {
super.onDestroy()
_activityMainBinding = null
}
private fun obtainViewModel(activity: AppCompatActivity): MainViewModel {
val factory = ViewModelFactory.getInstance(activity.application)
return ViewModelProvider(activity, factory).get(MainViewModel::class.java)
}
} | fundamental-android-practice/MyNoteApps/app/src/main/java/dev/rushia/mynoteapps/ui/main/MainActivity.kt | 402864103 |
package dev.rushia.mynoteapps.ui.main
import android.content.Intent
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
import dev.rushia.mynoteapps.database.Note
import dev.rushia.mynoteapps.databinding.ItemNoteBinding
import dev.rushia.mynoteapps.helper.NoteDiffCallback
import dev.rushia.mynoteapps.ui.insert.NoteAddUpdateActivity
class NoteAdapter : RecyclerView.Adapter<NoteAdapter.NoteViewHolder>() {
private val listNotes = ArrayList<Note>()
fun setListNotes(listNotes: List<Note>) {
val diffCallback = NoteDiffCallback(this.listNotes, listNotes)
val diffResult = DiffUtil.calculateDiff(diffCallback)
this.listNotes.clear()
this.listNotes.addAll(listNotes)
diffResult.dispatchUpdatesTo(this)
}
inner class NoteViewHolder(private val binding: ItemNoteBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind(note: Note){
with(binding){
tvItemTitle.text = note.title
tvItemDate.text = note.date
tvItemDescription.text = note.description
cvItemNote.setOnClickListener{
val intent = Intent(it.context, NoteAddUpdateActivity::class.java)
intent.putExtra(NoteAddUpdateActivity.EXTRA_NOTE, note)
it.context.startActivity(intent)
}
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): NoteViewHolder {
val binding = ItemNoteBinding.inflate(LayoutInflater.from(parent.context), parent, false)
return NoteViewHolder(binding)
}
override fun getItemCount(): Int {
return listNotes.size
}
override fun onBindViewHolder(holder: NoteViewHolder, position: Int) {
holder.bind(listNotes[position])
}
} | fundamental-android-practice/MyNoteApps/app/src/main/java/dev/rushia/mynoteapps/ui/main/NoteAdapter.kt | 3664662478 |
package dev.rushia.mynoteapps.database
import android.os.Parcelable
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
import kotlinx.parcelize.Parcelize
@Entity
@Parcelize
data class Note(
@PrimaryKey(autoGenerate = true) @ColumnInfo(name = "id") var id: Int = 0,
@ColumnInfo(name = "title") var title: String? = null,
@ColumnInfo(name = "description") var description: String? = null,
@ColumnInfo(name = "date") var date: String? = null
) : Parcelable | fundamental-android-practice/MyNoteApps/app/src/main/java/dev/rushia/mynoteapps/database/Note.kt | 333769107 |
package dev.rushia.mynoteapps.database
import androidx.lifecycle.LiveData
import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
@Dao
interface NoteDao {
@Insert(onConflict = OnConflictStrategy.IGNORE)
fun insert(note: Note)
@Update
fun update(note: Note)
@Delete
fun delete(note: Note)
@Query("SELECT * FROM note ORDER BY id ASC")
fun getAllNotes(): LiveData<List<Note>>
} | fundamental-android-practice/MyNoteApps/app/src/main/java/dev/rushia/mynoteapps/database/NoteDao.kt | 270231304 |
package dev.rushia.mynoteapps.database
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
@Database(entities = [Note::class], version = 1)
abstract class NoteRoomDatabase : RoomDatabase() {
abstract fun noteDao(): NoteDao
companion object {
@Volatile
private var INSTANCE: NoteRoomDatabase? = null
@JvmStatic
fun getDatabase(context: Context): NoteRoomDatabase {
if (INSTANCE == null) {
synchronized(NoteRoomDatabase::class.java) {
INSTANCE = Room.databaseBuilder(
context.applicationContext, NoteRoomDatabase::class.java, "note_database"
).build()
}
}
return INSTANCE as NoteRoomDatabase
}
}
} | fundamental-android-practice/MyNoteApps/app/src/main/java/dev/rushia/mynoteapps/database/NoteRoomDatabase.kt | 2847660672 |
package dev.rushia.mynoteapps.repository
import android.app.Application
import androidx.lifecycle.LiveData
import dev.rushia.mynoteapps.database.Note
import dev.rushia.mynoteapps.database.NoteDao
import dev.rushia.mynoteapps.database.NoteRoomDatabase
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
class NoteRepository(application: Application) {
private val mNotesDao: NoteDao
private val executorService: ExecutorService = Executors.newSingleThreadExecutor()
init {
val db = NoteRoomDatabase.getDatabase(application)
mNotesDao = db.noteDao()
}
fun getAllNotes(): LiveData<List<Note>> = mNotesDao.getAllNotes()
fun insert(note: Note) {
executorService.execute { mNotesDao.insert(note) }
}
fun delete(note: Note) {
executorService.execute { mNotesDao.delete(note) }
}
fun update(note: Note) {
executorService.execute { mNotesDao.update(note) }
}
} | fundamental-android-practice/MyNoteApps/app/src/main/java/dev/rushia/mynoteapps/repository/NoteRepository.kt | 1774816907 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.