289 lines
12 KiB
Kotlin
289 lines
12 KiB
Kotlin
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
package org.mozilla.fenix.settings.quicksettings
|
|
|
|
import android.app.Dialog
|
|
import android.content.Context
|
|
import android.content.pm.PackageManager.PERMISSION_GRANTED
|
|
import android.graphics.Color
|
|
import android.graphics.drawable.ColorDrawable
|
|
import android.os.Bundle
|
|
import android.view.Gravity.BOTTOM
|
|
import android.view.LayoutInflater
|
|
import android.view.View
|
|
import android.view.ViewGroup
|
|
import android.widget.LinearLayout
|
|
import androidx.appcompat.app.AppCompatDialogFragment
|
|
import androidx.appcompat.view.ContextThemeWrapper
|
|
import androidx.core.widget.NestedScrollView
|
|
import com.google.android.material.bottomsheet.BottomSheetDialog
|
|
import kotlinx.coroutines.CoroutineScope
|
|
import kotlinx.coroutines.Dispatchers
|
|
import kotlinx.coroutines.Job
|
|
import kotlinx.coroutines.launch
|
|
import mozilla.components.browser.session.Session
|
|
import mozilla.components.feature.sitepermissions.SitePermissions
|
|
import mozilla.components.support.ktx.kotlin.toUri
|
|
import org.mozilla.fenix.FenixViewModelProvider
|
|
import org.mozilla.fenix.HomeActivity
|
|
import org.mozilla.fenix.R
|
|
import org.mozilla.fenix.browser.BrowserFragment
|
|
import org.mozilla.fenix.exceptions.ExceptionDomains
|
|
import org.mozilla.fenix.ext.components
|
|
import org.mozilla.fenix.ext.requireComponents
|
|
import org.mozilla.fenix.mvi.ActionBusFactory
|
|
import org.mozilla.fenix.mvi.getAutoDisposeObservable
|
|
import org.mozilla.fenix.mvi.getManagedEmitter
|
|
import org.mozilla.fenix.settings.PhoneFeature
|
|
import org.mozilla.fenix.utils.ItsNotBrokenSnack
|
|
import java.net.MalformedURLException
|
|
import java.net.URL
|
|
import kotlin.coroutines.CoroutineContext
|
|
|
|
private const val REQUEST_CODE_QUICK_SETTINGS_PERMISSIONS = 4
|
|
|
|
@SuppressWarnings("TooManyFunctions")
|
|
class QuickSettingsSheetDialogFragment : AppCompatDialogFragment(), CoroutineScope {
|
|
private val safeArguments get() = requireNotNull(arguments)
|
|
private val sessionId: String by lazy { QuickSettingsSheetDialogFragmentArgs.fromBundle(safeArguments).sessionId }
|
|
private val url: String by lazy { QuickSettingsSheetDialogFragmentArgs.fromBundle(safeArguments).url }
|
|
private val isSecured: Boolean by lazy { QuickSettingsSheetDialogFragmentArgs.fromBundle(safeArguments).isSecured }
|
|
private val isTrackingProtectionOn: Boolean by lazy {
|
|
QuickSettingsSheetDialogFragmentArgs.fromBundle(safeArguments).isTrackingProtectionOn
|
|
}
|
|
private val promptGravity: Int by lazy { QuickSettingsSheetDialogFragmentArgs.fromBundle(safeArguments).gravity }
|
|
private lateinit var quickSettingsComponent: QuickSettingsComponent
|
|
private lateinit var job: Job
|
|
|
|
private var sitePermissions: SitePermissions? = null
|
|
|
|
override val coroutineContext: CoroutineContext get() = Dispatchers.IO + job
|
|
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
super.onCreate(savedInstanceState)
|
|
job = Job()
|
|
}
|
|
|
|
override fun onCreateView(
|
|
inflater: LayoutInflater,
|
|
container: ViewGroup?,
|
|
savedInstanceState: Bundle?
|
|
): View {
|
|
sitePermissions = QuickSettingsSheetDialogFragmentArgs.fromBundle(safeArguments).sitePermissions
|
|
val rootView = inflateRootView(container)
|
|
requireComponents.core.sessionManager.findSessionById(sessionId)?.register(sessionObserver, view = rootView)
|
|
quickSettingsComponent = QuickSettingsComponent(
|
|
rootView as NestedScrollView,
|
|
ActionBusFactory.get(this),
|
|
FenixViewModelProvider.create(
|
|
this,
|
|
QuickSettingsViewModel::class.java
|
|
) {
|
|
QuickSettingsViewModel(
|
|
QuickSettingsState(
|
|
QuickSettingsState.Mode.Normal(
|
|
url,
|
|
isSecured,
|
|
isTrackingProtectionOn,
|
|
sitePermissions
|
|
)
|
|
)
|
|
)
|
|
}
|
|
)
|
|
return rootView
|
|
}
|
|
|
|
private fun inflateRootView(container: ViewGroup? = null): View {
|
|
val contextThemeWrapper = ContextThemeWrapper(
|
|
activity,
|
|
(activity as HomeActivity).themeManager.currentThemeResource
|
|
)
|
|
return LayoutInflater.from(contextThemeWrapper).inflate(
|
|
R.layout.fragment_quick_settings_dialog_sheet,
|
|
container,
|
|
false
|
|
)
|
|
}
|
|
|
|
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
|
|
val customDialog = if (promptGravity == BOTTOM) {
|
|
return BottomSheetDialog(requireContext(), this.theme)
|
|
} else {
|
|
Dialog(requireContext())
|
|
}
|
|
return customDialog.applyCustomizationsForTopDialog(inflateRootView())
|
|
}
|
|
|
|
private fun Dialog.applyCustomizationsForTopDialog(rootView: View): Dialog {
|
|
addContentView(
|
|
rootView,
|
|
LinearLayout.LayoutParams(
|
|
LinearLayout.LayoutParams.MATCH_PARENT,
|
|
LinearLayout.LayoutParams.MATCH_PARENT
|
|
)
|
|
)
|
|
|
|
window?.apply {
|
|
setGravity(promptGravity)
|
|
setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
|
|
// This must be called after addContentView, or it won't fully fill to the edge.
|
|
setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
|
|
}
|
|
return this
|
|
}
|
|
|
|
override fun onRequestPermissionsResult(
|
|
requestCode: Int,
|
|
permissions: Array<out String>,
|
|
grantResults: IntArray
|
|
) {
|
|
if (arePermissionsGranted(requestCode, grantResults)) {
|
|
val feature = requireNotNull(PhoneFeature.findFeatureBy(permissions))
|
|
getManagedEmitter<QuickSettingsChange>()
|
|
.onNext(QuickSettingsChange.PermissionGranted(feature, sitePermissions))
|
|
}
|
|
}
|
|
|
|
override fun onDestroy() {
|
|
super.onDestroy()
|
|
job.cancel()
|
|
}
|
|
|
|
private fun arePermissionsGranted(requestCode: Int, grantResults: IntArray) =
|
|
requestCode == REQUEST_CODE_QUICK_SETTINGS_PERMISSIONS && grantResults.all { it == PERMISSION_GRANTED }
|
|
|
|
private fun toggleTrackingProtection(context: Context, url: String) {
|
|
val host = try {
|
|
URL(url).host
|
|
} catch (e: MalformedURLException) {
|
|
url
|
|
}
|
|
launch {
|
|
if (!ExceptionDomains.load(context).contains(host)) {
|
|
ExceptionDomains.add(context, host)
|
|
} else {
|
|
ExceptionDomains.remove(context, listOf(host))
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onResume() {
|
|
super.onResume()
|
|
getAutoDisposeObservable<QuickSettingsAction>()
|
|
.subscribe {
|
|
when (it) {
|
|
is QuickSettingsAction.SelectBlockedByAndroid -> {
|
|
requestPermissions(it.permissions, REQUEST_CODE_QUICK_SETTINGS_PERMISSIONS)
|
|
}
|
|
is QuickSettingsAction.SelectTrackingProtectionSettings -> {
|
|
context?.let {
|
|
ItsNotBrokenSnack(it).showSnackbar("2422")
|
|
}
|
|
dismiss()
|
|
}
|
|
is QuickSettingsAction.SelectReportProblem -> {
|
|
launch(Dispatchers.Main) {
|
|
val reportUrl =
|
|
String.format(BrowserFragment.REPORT_SITE_ISSUE_URL, it.url)
|
|
requireComponents.useCases.sessionUseCases.loadUrl.invoke(reportUrl)
|
|
}
|
|
dismiss()
|
|
}
|
|
is QuickSettingsAction.ToggleTrackingProtection -> {
|
|
val trackingEnabled = it.trackingProtection
|
|
context?.let { context: Context -> toggleTrackingProtection(context, url) }
|
|
launch(Dispatchers.Main) {
|
|
getManagedEmitter<QuickSettingsChange>().onNext(
|
|
QuickSettingsChange.Change(
|
|
url,
|
|
isSecured,
|
|
trackingEnabled,
|
|
sitePermissions
|
|
)
|
|
)
|
|
requireContext().components.useCases.sessionUseCases.reload.invoke()
|
|
}
|
|
}
|
|
is QuickSettingsAction.TogglePermission -> {
|
|
|
|
launch {
|
|
sitePermissions = quickSettingsComponent.toggleSitePermission(
|
|
context = requireContext(),
|
|
featurePhone = it.featurePhone,
|
|
url = url,
|
|
sitePermissions = sitePermissions
|
|
)
|
|
|
|
launch(Dispatchers.Main) {
|
|
getManagedEmitter<QuickSettingsChange>()
|
|
.onNext(
|
|
QuickSettingsChange.Stored(
|
|
it.featurePhone,
|
|
sitePermissions
|
|
)
|
|
)
|
|
|
|
requireContext().components.useCases.sessionUseCases.reload.invoke()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isVisible) {
|
|
getManagedEmitter<QuickSettingsChange>()
|
|
.onNext(QuickSettingsChange.PromptRestarted(sitePermissions))
|
|
}
|
|
}
|
|
|
|
private val sessionObserver = object : Session.Observer {
|
|
override fun onUrlChanged(session: Session, url: String) {
|
|
super.onUrlChanged(session, url)
|
|
launch {
|
|
val host = session.url.toUri()?.host
|
|
val sitePermissions: SitePermissions? = host?.let {
|
|
val storage = requireContext().components.core.permissionStorage
|
|
storage.findSitePermissionsBy(it)
|
|
}
|
|
launch(Dispatchers.Main) {
|
|
getManagedEmitter<QuickSettingsChange>().onNext(
|
|
QuickSettingsChange.Change(
|
|
url,
|
|
session.securityInfo.secure,
|
|
session.trackerBlockingEnabled,
|
|
sitePermissions
|
|
)
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onTrackerBlockingEnabledChanged(session: Session, blockingEnabled: Boolean) {
|
|
super.onTrackerBlockingEnabledChanged(session, blockingEnabled)
|
|
getManagedEmitter<QuickSettingsChange>().onNext(
|
|
QuickSettingsChange.Change(
|
|
session.url,
|
|
session.securityInfo.secure,
|
|
blockingEnabled,
|
|
sitePermissions
|
|
)
|
|
)
|
|
}
|
|
|
|
override fun onSecurityChanged(session: Session, securityInfo: Session.SecurityInfo) {
|
|
super.onSecurityChanged(session, securityInfo)
|
|
getManagedEmitter<QuickSettingsChange>().onNext(
|
|
QuickSettingsChange.Change(
|
|
session.url,
|
|
securityInfo.secure,
|
|
session.trackerBlockingEnabled,
|
|
sitePermissions
|
|
)
|
|
)
|
|
}
|
|
}
|
|
}
|