371 lines
14 KiB
Kotlin
371 lines
14 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.browser
|
|
|
|
import android.os.Bundle
|
|
import android.view.Gravity
|
|
import android.view.LayoutInflater
|
|
import android.view.View
|
|
import android.view.ViewGroup
|
|
import android.widget.Button
|
|
import android.widget.RadioButton
|
|
import androidx.core.content.ContextCompat
|
|
import androidx.lifecycle.Observer
|
|
import androidx.lifecycle.lifecycleScope
|
|
import androidx.navigation.fragment.NavHostFragment.findNavController
|
|
import androidx.navigation.fragment.findNavController
|
|
import com.google.android.material.snackbar.Snackbar
|
|
import kotlinx.android.synthetic.main.component_search.*
|
|
import kotlinx.android.synthetic.main.fragment_browser.view.*
|
|
import kotlinx.coroutines.Dispatchers.IO
|
|
import kotlinx.coroutines.Dispatchers.Main
|
|
import kotlinx.coroutines.ExperimentalCoroutinesApi
|
|
import kotlinx.coroutines.Job
|
|
import kotlinx.coroutines.ObsoleteCoroutinesApi
|
|
import kotlinx.coroutines.launch
|
|
import kotlinx.coroutines.withContext
|
|
import mozilla.appservices.places.BookmarkRoot
|
|
import mozilla.components.browser.session.Session
|
|
import mozilla.components.browser.session.SessionManager
|
|
import mozilla.components.feature.readerview.ReaderViewFeature
|
|
import mozilla.components.feature.session.ThumbnailsFeature
|
|
import mozilla.components.lib.state.ext.consumeFrom
|
|
import mozilla.components.support.base.feature.BackHandler
|
|
import mozilla.components.support.base.feature.ViewBoundFeatureWrapper
|
|
import org.mozilla.fenix.HomeActivity
|
|
import org.mozilla.fenix.R
|
|
import org.mozilla.fenix.browser.readermode.DefaultReaderModeController
|
|
import org.mozilla.fenix.components.FenixSnackbar
|
|
import org.mozilla.fenix.components.TabCollectionStorage
|
|
import org.mozilla.fenix.components.metrics.Event
|
|
import org.mozilla.fenix.components.toolbar.BrowserInteractor
|
|
import org.mozilla.fenix.components.toolbar.BrowserToolbarController
|
|
import org.mozilla.fenix.components.toolbar.QuickActionSheetAction
|
|
import org.mozilla.fenix.customtabs.CustomTabsIntegration
|
|
import org.mozilla.fenix.ext.nav
|
|
import org.mozilla.fenix.ext.requireComponents
|
|
import org.mozilla.fenix.home.sessioncontrol.SessionControlChange
|
|
import org.mozilla.fenix.home.sessioncontrol.TabCollection
|
|
import org.mozilla.fenix.mvi.getManagedEmitter
|
|
import org.mozilla.fenix.quickactionsheet.DefaultQuickActionSheetController
|
|
import org.mozilla.fenix.quickactionsheet.QuickActionSheetView
|
|
import java.net.MalformedURLException
|
|
import java.net.URL
|
|
|
|
/**
|
|
* Fragment used for browsing the web within the main app and external apps.
|
|
*/
|
|
@Suppress("TooManyFunctions")
|
|
class BrowserFragment : BaseBrowserFragment(), BackHandler {
|
|
private lateinit var quickActionSheetView: QuickActionSheetView
|
|
|
|
private val readerViewFeature = ViewBoundFeatureWrapper<ReaderViewFeature>()
|
|
private val thumbnailsFeature = ViewBoundFeatureWrapper<ThumbnailsFeature>()
|
|
private val customTabsIntegration = ViewBoundFeatureWrapper<CustomTabsIntegration>()
|
|
private var findBookmarkJob: Job? = null
|
|
|
|
/*
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
super.onCreate(savedInstanceState)
|
|
// Disabled while awaiting a better solution to #3209
|
|
postponeEnterTransition()
|
|
sharedElementEnterTransition =
|
|
TransitionInflater.from(context).inflateTransition(android.R.transition.move).setDuration(
|
|
SHARED_TRANSITION_MS
|
|
)
|
|
}
|
|
*/
|
|
|
|
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
|
|
val view = super.onCreateView(inflater, container, savedInstanceState)
|
|
view.browserLayout.transitionName = "$TAB_ITEM_TRANSITION_NAME${getSessionById()?.id}"
|
|
|
|
startPostponedEnterTransition()
|
|
|
|
return view
|
|
}
|
|
|
|
@Suppress("LongMethod", "ComplexMethod")
|
|
@ObsoleteCoroutinesApi
|
|
@ExperimentalCoroutinesApi
|
|
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
|
|
super.onViewCreated(view, savedInstanceState)
|
|
|
|
val sessionManager = requireComponents.core.sessionManager
|
|
|
|
getSessionById()?.let {
|
|
quickActionSheetView = QuickActionSheetView(view.nestedScrollQuickAction, browserInteractor)
|
|
|
|
customTabSessionId?.let { customTabSessionId ->
|
|
customTabsIntegration.set(
|
|
feature = CustomTabsIntegration(
|
|
requireContext(),
|
|
requireComponents.core.sessionManager,
|
|
toolbar,
|
|
customTabSessionId,
|
|
activity,
|
|
view.nestedScrollQuickAction,
|
|
view.swipeRefresh,
|
|
onItemTapped = { browserInteractor.onBrowserToolbarMenuItemTapped(it) }
|
|
),
|
|
owner = this,
|
|
view = view)
|
|
}
|
|
|
|
consumeFrom(browserStore) {
|
|
quickActionSheetView.update(it)
|
|
browserToolbarView.update(it)
|
|
}
|
|
}
|
|
|
|
thumbnailsFeature.set(
|
|
feature = ThumbnailsFeature(
|
|
requireContext(),
|
|
view.engineView,
|
|
requireComponents.core.sessionManager
|
|
),
|
|
owner = this,
|
|
view = view
|
|
)
|
|
|
|
readerViewFeature.set(
|
|
feature = ReaderViewFeature(
|
|
requireContext(),
|
|
requireComponents.core.engine,
|
|
requireComponents.core.sessionManager,
|
|
view.readerViewControlsBar
|
|
) { available ->
|
|
if (available) { requireComponents.analytics.metrics.track(Event.ReaderModeAvailable) }
|
|
|
|
browserStore.apply {
|
|
dispatch(QuickActionSheetAction.ReadableStateChange(available))
|
|
dispatch(QuickActionSheetAction.ReaderActiveStateChange(
|
|
sessionManager.selectedSession?.readerMode ?: false
|
|
))
|
|
}
|
|
},
|
|
owner = this,
|
|
view = view
|
|
)
|
|
|
|
if ((activity as HomeActivity).browsingModeManager.isPrivate) {
|
|
// We need to update styles for private mode programmatically for now:
|
|
// https://github.com/mozilla-mobile/android-components/issues/3400
|
|
themeReaderViewControlsForPrivateMode(view.readerViewControlsBar)
|
|
}
|
|
}
|
|
|
|
override fun onStart() {
|
|
super.onStart()
|
|
subscribeToSession()
|
|
subscribeToSessions()
|
|
subscribeToTabCollections()
|
|
}
|
|
|
|
override fun onResume() {
|
|
super.onResume()
|
|
|
|
requireComponents.core.tabCollectionStorage.register(collectionStorageObserver, this)
|
|
|
|
getSessionById()?.let { updateBookmarkState(it) }
|
|
|
|
// See #4387 for why we're popping here
|
|
if (getSessionById() == null) findNavController(this).popBackStack(R.id.homeFragment, false)
|
|
}
|
|
|
|
override fun onBackPressed(): Boolean {
|
|
return readerViewFeature.onBackPressed() || super.onBackPressed()
|
|
}
|
|
|
|
override fun removeSessionIfNeeded(): Boolean {
|
|
if (customTabsIntegration.onBackPressed()) return true
|
|
|
|
getSessionById()?.let { session ->
|
|
if (session.source == Session.Source.ACTION_VIEW) requireComponents.core.sessionManager.remove(session)
|
|
}
|
|
return false
|
|
}
|
|
|
|
override fun createBrowserToolbarViewInteractor(
|
|
browserToolbarController: BrowserToolbarController,
|
|
session: Session
|
|
) = BrowserInteractor(
|
|
context = context!!,
|
|
store = browserStore,
|
|
browserToolbarController = browserToolbarController,
|
|
quickActionSheetController = DefaultQuickActionSheetController(
|
|
context = context!!,
|
|
navController = findNavController(),
|
|
currentSession = getSessionById() ?: requireComponents.core.sessionManager.selectedSessionOrThrow,
|
|
appLinksUseCases = requireComponents.useCases.appLinksUseCases,
|
|
bookmarkTapped = {
|
|
lifecycleScope.launch { bookmarkTapped(it) }
|
|
}
|
|
),
|
|
readerModeController = DefaultReaderModeController(readerViewFeature),
|
|
currentSession = session
|
|
)
|
|
|
|
override fun getEngineMargins(): Pair<Int, Int> {
|
|
val toolbarAndQASSize = resources.getDimensionPixelSize(R.dimen.toolbar_and_qab_height)
|
|
val toolbarSize = resources.getDimensionPixelSize(R.dimen.browser_toolbar_height)
|
|
return if (customTabSessionId != null) Pair(toolbarSize, 0) else Pair(0, toolbarAndQASSize)
|
|
}
|
|
|
|
override fun getAppropriateLayoutGravity() = if (customTabSessionId != null) Gravity.TOP else Gravity.BOTTOM
|
|
|
|
private fun themeReaderViewControlsForPrivateMode(view: View) = with(view) {
|
|
listOf(
|
|
R.id.mozac_feature_readerview_font_size_decrease,
|
|
R.id.mozac_feature_readerview_font_size_increase
|
|
).map {
|
|
findViewById<Button>(it)
|
|
}.forEach {
|
|
it.setTextColor(ContextCompat.getColorStateList(context, R.color.readerview_private_button_color))
|
|
}
|
|
|
|
listOf(
|
|
R.id.mozac_feature_readerview_font_serif,
|
|
R.id.mozac_feature_readerview_font_sans_serif
|
|
).map {
|
|
findViewById<RadioButton>(it)
|
|
}.forEach {
|
|
it.setTextColor(ContextCompat.getColorStateList(context, R.color.readerview_private_radio_color))
|
|
}
|
|
}
|
|
|
|
private suspend fun bookmarkTapped(session: Session) = withContext(IO) {
|
|
val bookmarksStorage = requireComponents.core.bookmarksStorage
|
|
val existing = bookmarksStorage.getBookmarksWithUrl(session.url).firstOrNull { it.url == session.url }
|
|
if (existing != null) {
|
|
// Bookmark exists, go to edit fragment
|
|
withContext(Main) {
|
|
nav(
|
|
R.id.browserFragment,
|
|
BrowserFragmentDirections.actionBrowserFragmentToBookmarkEditFragment(existing.guid)
|
|
)
|
|
}
|
|
} else {
|
|
// Save bookmark, then go to edit fragment
|
|
val guid = bookmarksStorage.addItem(
|
|
BookmarkRoot.Mobile.id,
|
|
url = session.url,
|
|
title = session.title,
|
|
position = null
|
|
)
|
|
|
|
withContext(Main) {
|
|
browserStore.dispatch(
|
|
QuickActionSheetAction.BookmarkedStateChange(bookmarked = true)
|
|
)
|
|
requireComponents.analytics.metrics.track(Event.AddBookmark)
|
|
|
|
view?.let {
|
|
FenixSnackbar.make(it.rootView, Snackbar.LENGTH_LONG)
|
|
.setAnchorView(browserToolbarView.view)
|
|
.setAction(getString(R.string.edit_bookmark_snackbar_action)) {
|
|
nav(
|
|
R.id.browserFragment,
|
|
BrowserFragmentDirections.actionBrowserFragmentToBookmarkEditFragment(guid)
|
|
)
|
|
}
|
|
.setText(getString(R.string.bookmark_saved_snackbar))
|
|
.show()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun subscribeToTabCollections() {
|
|
requireComponents.core.tabCollectionStorage.getCollections().observe(this, Observer {
|
|
requireComponents.core.tabCollectionStorage.cachedTabCollections = it
|
|
getManagedEmitter<SessionControlChange>().onNext(SessionControlChange.CollectionsChange(it))
|
|
})
|
|
}
|
|
|
|
private fun subscribeToSession() {
|
|
val observer = object : Session.Observer {
|
|
override fun onLoadingStateChanged(session: Session, loading: Boolean) {
|
|
if (!loading) {
|
|
updateBookmarkState(session)
|
|
browserStore.dispatch(QuickActionSheetAction.BounceNeededChange)
|
|
}
|
|
}
|
|
|
|
override fun onUrlChanged(session: Session, url: String) {
|
|
updateBookmarkState(session)
|
|
updateAppLinksState(session)
|
|
}
|
|
}
|
|
getSessionById()?.register(observer, this, autoPause = true)
|
|
}
|
|
|
|
private fun subscribeToSessions() {
|
|
val observer = object : SessionManager.Observer {
|
|
override fun onSessionSelected(session: Session) {
|
|
(activity as HomeActivity).updateThemeForSession(session)
|
|
updateBookmarkState(session)
|
|
}
|
|
}
|
|
requireComponents.core.sessionManager.register(observer, this, autoPause = true)
|
|
}
|
|
|
|
private suspend fun findBookmarkedURL(session: Session?): Boolean {
|
|
return withContext(IO) {
|
|
session?.let {
|
|
try {
|
|
val url = URL(it.url).toString()
|
|
val list = requireComponents.core.bookmarksStorage.getBookmarksWithUrl(url)
|
|
list.isNotEmpty() && list[0].url == url
|
|
} catch (e: MalformedURLException) {
|
|
false
|
|
}
|
|
} ?: false
|
|
}
|
|
}
|
|
|
|
private fun updateBookmarkState(session: Session) {
|
|
findBookmarkJob?.cancel()
|
|
findBookmarkJob = lifecycleScope.launch(IO) {
|
|
val found = findBookmarkedURL(session)
|
|
withContext(Main) {
|
|
browserStore.dispatch(QuickActionSheetAction.BookmarkedStateChange(found))
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun updateAppLinksState(session: Session) {
|
|
val url = session.url
|
|
val appLinks = requireComponents.useCases.appLinksUseCases.appLinkRedirect
|
|
browserStore.dispatch(QuickActionSheetAction.AppLinkStateChange(appLinks.invoke(url).hasExternalApp()))
|
|
}
|
|
|
|
private val collectionStorageObserver = object : TabCollectionStorage.Observer {
|
|
override fun onCollectionCreated(title: String, sessions: List<Session>) {
|
|
showTabSavedToCollectionSnackbar()
|
|
}
|
|
|
|
override fun onTabsAdded(tabCollection: TabCollection, sessions: List<Session>) {
|
|
showTabSavedToCollectionSnackbar()
|
|
}
|
|
}
|
|
|
|
private fun showTabSavedToCollectionSnackbar() {
|
|
view?.let { view ->
|
|
FenixSnackbar.make(view, Snackbar.LENGTH_SHORT)
|
|
.setText(view.context.getString(R.string.create_collection_tab_saved))
|
|
.setAnchorView(browserToolbarView.view)
|
|
.show()
|
|
}
|
|
}
|
|
|
|
companion object {
|
|
private const val SHARED_TRANSITION_MS = 200L
|
|
private const val TAB_ITEM_TRANSITION_NAME = "tab_item"
|
|
const val REPORT_SITE_ISSUE_URL =
|
|
"https://webcompat.com/issues/new?url=%s&label=browser-fenix"
|
|
}
|
|
}
|