mirror of https://github.com/TeamNewPipe/NewPipe
354 lines
13 KiB
Kotlin
354 lines
13 KiB
Kotlin
package org.schabi.newpipe.local.subscription.dialog
|
|
|
|
import android.app.Dialog
|
|
import android.content.Context
|
|
import android.os.Bundle
|
|
import android.os.Parcelable
|
|
import android.text.Editable
|
|
import android.text.TextWatcher
|
|
import android.view.LayoutInflater
|
|
import android.view.View
|
|
import android.view.ViewGroup
|
|
import android.view.inputmethod.InputMethodManager
|
|
import android.widget.Toast
|
|
import androidx.fragment.app.DialogFragment
|
|
import androidx.lifecycle.Observer
|
|
import androidx.lifecycle.ViewModelProviders
|
|
import androidx.recyclerview.widget.GridLayoutManager
|
|
import androidx.recyclerview.widget.LinearLayoutManager
|
|
import androidx.recyclerview.widget.RecyclerView
|
|
import com.xwray.groupie.GroupAdapter
|
|
import com.xwray.groupie.Section
|
|
import com.xwray.groupie.kotlinandroidextensions.GroupieViewHolder
|
|
import icepick.Icepick
|
|
import icepick.State
|
|
import kotlinx.android.synthetic.main.dialog_feed_group_create.*
|
|
import org.schabi.newpipe.R
|
|
import org.schabi.newpipe.database.feed.model.FeedGroupEntity
|
|
import org.schabi.newpipe.database.subscription.SubscriptionEntity
|
|
import org.schabi.newpipe.local.subscription.FeedGroupIcon
|
|
import org.schabi.newpipe.local.subscription.dialog.FeedGroupDialog.ScreenState.*
|
|
import org.schabi.newpipe.local.subscription.dialog.FeedGroupDialogViewModel.DialogEvent.ProcessingEvent
|
|
import org.schabi.newpipe.local.subscription.dialog.FeedGroupDialogViewModel.DialogEvent.SuccessEvent
|
|
import org.schabi.newpipe.local.subscription.item.EmptyPlaceholderItem
|
|
import org.schabi.newpipe.local.subscription.item.PickerIconItem
|
|
import org.schabi.newpipe.local.subscription.item.PickerSubscriptionItem
|
|
import org.schabi.newpipe.util.ThemeHelper
|
|
import java.io.Serializable
|
|
|
|
class FeedGroupDialog : DialogFragment() {
|
|
private lateinit var viewModel: FeedGroupDialogViewModel
|
|
private var groupId: Long = NO_GROUP_SELECTED
|
|
private var groupIcon: FeedGroupIcon? = null
|
|
private var groupSortOrder: Long = -1
|
|
|
|
sealed class ScreenState : Serializable {
|
|
object InitialScreen : ScreenState()
|
|
object IconPickerScreen : ScreenState()
|
|
object SubscriptionsPickerScreen : ScreenState()
|
|
object DeleteScreen : ScreenState()
|
|
}
|
|
|
|
@State @JvmField var selectedIcon: FeedGroupIcon? = null
|
|
@State @JvmField var selectedSubscriptions: HashSet<Long> = HashSet()
|
|
@State @JvmField var currentScreen: ScreenState = InitialScreen
|
|
|
|
@State @JvmField var subscriptionsListState: Parcelable? = null
|
|
@State @JvmField var iconsListState: Parcelable? = null
|
|
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
super.onCreate(savedInstanceState)
|
|
Icepick.restoreInstanceState(this, savedInstanceState)
|
|
|
|
setStyle(STYLE_NO_TITLE, ThemeHelper.getMinWidthDialogTheme(requireContext()))
|
|
groupId = arguments?.getLong(KEY_GROUP_ID, NO_GROUP_SELECTED) ?: NO_GROUP_SELECTED
|
|
}
|
|
|
|
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
|
|
return inflater.inflate(R.layout.dialog_feed_group_create, container)
|
|
}
|
|
|
|
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
|
|
return object : Dialog(requireActivity(), theme) {
|
|
override fun onBackPressed() {
|
|
if (currentScreen !is InitialScreen) {
|
|
showScreen(InitialScreen)
|
|
} else {
|
|
super.onBackPressed()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onSaveInstanceState(outState: Bundle) {
|
|
super.onSaveInstanceState(outState)
|
|
|
|
iconsListState = icon_selector.layoutManager?.onSaveInstanceState()
|
|
subscriptionsListState = subscriptions_selector_list.layoutManager?.onSaveInstanceState()
|
|
|
|
Icepick.saveInstanceState(this, outState)
|
|
}
|
|
|
|
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
|
|
super.onViewCreated(view, savedInstanceState)
|
|
|
|
viewModel = ViewModelProviders.of(this, FeedGroupDialogViewModel.Factory(requireContext(), groupId))
|
|
.get(FeedGroupDialogViewModel::class.java)
|
|
|
|
viewModel.groupLiveData.observe(viewLifecycleOwner, Observer(::handleGroup))
|
|
viewModel.subscriptionsLiveData.observe(viewLifecycleOwner, Observer { setupSubscriptionPicker(it.first, it.second) })
|
|
viewModel.dialogEventLiveData.observe(viewLifecycleOwner, Observer {
|
|
when (it) {
|
|
ProcessingEvent -> disableInput()
|
|
SuccessEvent -> dismiss()
|
|
}
|
|
})
|
|
|
|
setupIconPicker()
|
|
setupListeners()
|
|
|
|
showScreen(currentScreen)
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Setup
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
private fun setupListeners() {
|
|
delete_button.setOnClickListener { showScreen(DeleteScreen) }
|
|
|
|
cancel_button.setOnClickListener {
|
|
when (currentScreen) {
|
|
InitialScreen -> dismiss()
|
|
else -> showScreen(InitialScreen)
|
|
}
|
|
}
|
|
|
|
group_name_input_container.error = null
|
|
group_name_input.addTextChangedListener(object : TextWatcher {
|
|
override fun afterTextChanged(s: Editable?) {}
|
|
override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
|
|
|
|
override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
|
|
if (group_name_input_container.isErrorEnabled && !s.isNullOrBlank()) {
|
|
group_name_input_container.error = null
|
|
}
|
|
}
|
|
})
|
|
|
|
confirm_button.setOnClickListener {
|
|
when (currentScreen) {
|
|
InitialScreen -> handlePositiveButtonInitialScreen()
|
|
DeleteScreen -> viewModel.deleteGroup()
|
|
else -> showScreen(InitialScreen)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun handlePositiveButtonInitialScreen() {
|
|
val name = group_name_input.text.toString().trim()
|
|
val icon = selectedIcon ?: groupIcon ?: FeedGroupIcon.ALL
|
|
|
|
if (name.isBlank()) {
|
|
group_name_input_container.error = getString(R.string.feed_group_dialog_empty_name)
|
|
group_name_input.text = null
|
|
group_name_input.requestFocus()
|
|
return
|
|
} else {
|
|
group_name_input_container.error = null
|
|
}
|
|
|
|
if (selectedSubscriptions.isEmpty()) {
|
|
Toast.makeText(requireContext(), getString(R.string.feed_group_dialog_empty_selection), Toast.LENGTH_SHORT).show()
|
|
return
|
|
}
|
|
|
|
when (groupId) {
|
|
NO_GROUP_SELECTED -> viewModel.createGroup(name, icon, selectedSubscriptions)
|
|
else -> viewModel.updateGroup(name, icon, selectedSubscriptions, groupSortOrder)
|
|
}
|
|
}
|
|
|
|
private fun handleGroup(feedGroupEntity: FeedGroupEntity? = null) {
|
|
val icon = feedGroupEntity?.icon ?: FeedGroupIcon.ALL
|
|
val name = feedGroupEntity?.name ?: ""
|
|
groupIcon = feedGroupEntity?.icon
|
|
groupSortOrder = feedGroupEntity?.sortOrder ?: -1
|
|
|
|
icon_preview.setImageResource((if (selectedIcon == null) icon else selectedIcon!!).getDrawableRes(requireContext()))
|
|
|
|
if (group_name_input.text.isNullOrBlank()) {
|
|
group_name_input.setText(name)
|
|
}
|
|
}
|
|
|
|
private fun setupSubscriptionPicker(subscriptions: List<SubscriptionEntity>, selectedSubscriptions: Set<Long>) {
|
|
this.selectedSubscriptions.addAll(selectedSubscriptions)
|
|
val useGridLayout = subscriptions.isNotEmpty()
|
|
|
|
val groupAdapter = GroupAdapter<GroupieViewHolder>()
|
|
groupAdapter.spanCount = if (useGridLayout) 4 else 1
|
|
|
|
val selectedCountText = getString(R.string.feed_group_dialog_selection_count, this.selectedSubscriptions.size)
|
|
selected_subscription_count_view.text = selectedCountText
|
|
subscriptions_selector_header_info.text = selectedCountText
|
|
|
|
Section().apply {
|
|
addAll(subscriptions.map {
|
|
val isSelected = this@FeedGroupDialog.selectedSubscriptions.contains(it.uid)
|
|
PickerSubscriptionItem(it, isSelected)
|
|
})
|
|
setPlaceholder(EmptyPlaceholderItem())
|
|
|
|
groupAdapter.add(this)
|
|
}
|
|
|
|
subscriptions_selector_list.apply {
|
|
layoutManager = if (useGridLayout) {
|
|
GridLayoutManager(requireContext(), groupAdapter.spanCount, RecyclerView.VERTICAL, false)
|
|
} else {
|
|
LinearLayoutManager(requireContext(), RecyclerView.VERTICAL, false)
|
|
}
|
|
|
|
adapter = groupAdapter
|
|
|
|
if (subscriptionsListState != null) {
|
|
layoutManager?.onRestoreInstanceState(subscriptionsListState)
|
|
subscriptionsListState = null
|
|
}
|
|
}
|
|
|
|
groupAdapter.setOnItemClickListener { item, _ ->
|
|
when (item) {
|
|
is PickerSubscriptionItem -> {
|
|
val subscriptionId = item.subscriptionEntity.uid
|
|
|
|
val isSelected = if (this.selectedSubscriptions.contains(subscriptionId)) {
|
|
this.selectedSubscriptions.remove(subscriptionId)
|
|
false
|
|
} else {
|
|
this.selectedSubscriptions.add(subscriptionId)
|
|
true
|
|
}
|
|
|
|
item.isSelected = isSelected
|
|
item.notifyChanged(PickerSubscriptionItem.UPDATE_SELECTED)
|
|
|
|
val updateSelectedCountText = getString(R.string.feed_group_dialog_selection_count, this.selectedSubscriptions.size)
|
|
selected_subscription_count_view.text = updateSelectedCountText
|
|
subscriptions_selector_header_info.text = updateSelectedCountText
|
|
}
|
|
}
|
|
}
|
|
|
|
select_channel_button.setOnClickListener {
|
|
subscriptions_selector_list.scrollToPosition(0)
|
|
showScreen(SubscriptionsPickerScreen)
|
|
}
|
|
}
|
|
|
|
private fun setupIconPicker() {
|
|
val groupAdapter = GroupAdapter<GroupieViewHolder>()
|
|
groupAdapter.addAll(FeedGroupIcon.values().map { PickerIconItem(requireContext(), it) })
|
|
|
|
icon_selector.apply {
|
|
layoutManager = GridLayoutManager(requireContext(), 7, RecyclerView.VERTICAL, false)
|
|
adapter = groupAdapter
|
|
|
|
if (iconsListState != null) {
|
|
layoutManager?.onRestoreInstanceState(iconsListState)
|
|
iconsListState = null
|
|
}
|
|
}
|
|
|
|
groupAdapter.setOnItemClickListener { item, _ ->
|
|
when (item) {
|
|
is PickerIconItem -> {
|
|
selectedIcon = item.icon
|
|
icon_preview.setImageResource(item.iconRes)
|
|
|
|
showScreen(InitialScreen)
|
|
}
|
|
}
|
|
}
|
|
icon_preview.setOnClickListener {
|
|
icon_selector.scrollToPosition(0)
|
|
showScreen(IconPickerScreen)
|
|
}
|
|
|
|
if (groupId == NO_GROUP_SELECTED) {
|
|
val icon = selectedIcon ?: FeedGroupIcon.ALL
|
|
icon_preview.setImageResource(icon.getDrawableRes(requireContext()))
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Screen Selector
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
private fun showScreen(screen: ScreenState) {
|
|
currentScreen = screen
|
|
|
|
options_root.onlyVisibleIn(InitialScreen)
|
|
icon_selector.onlyVisibleIn(IconPickerScreen)
|
|
subscriptions_selector.onlyVisibleIn(SubscriptionsPickerScreen)
|
|
delete_screen_message.onlyVisibleIn(DeleteScreen)
|
|
|
|
separator.onlyVisibleIn(SubscriptionsPickerScreen, IconPickerScreen)
|
|
cancel_button.onlyVisibleIn(InitialScreen, DeleteScreen)
|
|
|
|
confirm_button.setText(when {
|
|
currentScreen == InitialScreen && groupId == NO_GROUP_SELECTED -> R.string.create
|
|
else -> android.R.string.ok
|
|
})
|
|
|
|
delete_button.visibility = when {
|
|
currentScreen != InitialScreen -> View.GONE
|
|
groupId == NO_GROUP_SELECTED -> View.GONE
|
|
else -> View.VISIBLE
|
|
}
|
|
|
|
if (currentScreen != InitialScreen) hideKeyboard()
|
|
}
|
|
|
|
private fun View.onlyVisibleIn(vararg screens: ScreenState) {
|
|
visibility = when (currentScreen) {
|
|
in screens -> View.VISIBLE
|
|
else -> View.GONE
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Utils
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
private fun hideKeyboard() {
|
|
val inputMethodManager = requireActivity().getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
|
|
inputMethodManager.hideSoftInputFromWindow(group_name_input.windowToken, InputMethodManager.RESULT_UNCHANGED_SHOWN)
|
|
group_name_input.clearFocus()
|
|
}
|
|
|
|
private fun disableInput() {
|
|
delete_button?.isEnabled = false
|
|
confirm_button?.isEnabled = false
|
|
cancel_button?.isEnabled = false
|
|
isCancelable = false
|
|
|
|
hideKeyboard()
|
|
}
|
|
|
|
companion object {
|
|
private const val KEY_GROUP_ID = "KEY_GROUP_ID"
|
|
private const val NO_GROUP_SELECTED = -1L
|
|
|
|
fun newInstance(groupId: Long = NO_GROUP_SELECTED): FeedGroupDialog {
|
|
val dialog = FeedGroupDialog()
|
|
|
|
dialog.arguments = Bundle().apply {
|
|
putLong(KEY_GROUP_ID, groupId)
|
|
}
|
|
|
|
return dialog
|
|
}
|
|
}
|
|
} |