Use ViewBoundFeatureWrapper and BackHandler from the base component.

app/src/main/java/org/mozilla/fenix/BackHandler.kt

@@ -1,12 +0,0 @@
-package org.mozilla.fenix
-/* 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/.
- */
-
-/**
- * Interface for fragments that want to handle 'back' button presses.
- */
-interface BackHandler {
-    fun onBackPressed(): Boolean
-}

app/src/main/java/org/mozilla/fenix/HomeActivity.kt

@@ -12,6 +12,7 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.navigation.fragment.NavHostFragment
 import mozilla.components.concept.engine.EngineView
 import mozilla.components.feature.intent.IntentProcessor
+import mozilla.components.support.base.feature.BackHandler
 import mozilla.components.support.utils.SafeIntent
 import org.mozilla.fenix.browser.BrowserFragment
 import org.mozilla.fenix.ext.components

app/src/main/java/org/mozilla/fenix/browser/BrowserFragment.kt

@@ -28,9 +28,9 @@ import mozilla.components.feature.downloads.DownloadsFeature
 import mozilla.components.feature.prompts.PromptFeature
 import mozilla.components.feature.session.SessionFeature
 import mozilla.components.feature.session.SessionUseCases
-import mozilla.components.support.ktx.android.arch.lifecycle.addObservers
-import org.mozilla.fenix.BackHandler
 import org.mozilla.fenix.DefaultThemeManager
+import mozilla.components.support.base.feature.BackHandler
+import mozilla.components.support.base.feature.ViewBoundFeatureWrapper
 import org.mozilla.fenix.R
 import org.mozilla.fenix.components.FindInPageIntegration
 import org.mozilla.fenix.ext.requireComponents
@@ -38,20 +38,22 @@ import org.mozilla.fenix.ext.share
 import org.mozilla.fenix.mvi.ActionBusFactory
 import org.mozilla.fenix.mvi.getSafeManagedObservable
 import org.mozilla.fenix.search.toolbar.SearchAction
-import org.mozilla.fenix.search.toolbar.ToolbarComponent
 import org.mozilla.fenix.search.toolbar.SearchState
-import org.mozilla.fenix.search.toolbar.ToolbarUIView
+import org.mozilla.fenix.search.toolbar.ToolbarComponent
+import org.mozilla.fenix.search.toolbar.ToolbarIntegration
 import org.mozilla.fenix.search.toolbar.ToolbarMenu
+import org.mozilla.fenix.search.toolbar.ToolbarUIView
 
 class BrowserFragment : Fragment(), BackHandler {
-
-    private lateinit var contextMenuFeature: ContextMenuFeature
-    private lateinit var downloadsFeature: DownloadsFeature
-    private lateinit var findInPageIntegration: FindInPageIntegration
-    private lateinit var promptsFeature: PromptFeature
-    private lateinit var sessionFeature: SessionFeature
     private lateinit var toolbarComponent: ToolbarComponent
-    private lateinit var customTabsToolbarFeature: CustomTabsToolbarFeature
+
+    private val sessionFeature = ViewBoundFeatureWrapper<SessionFeature>()
+    private val contextMenuFeature = ViewBoundFeatureWrapper<ContextMenuFeature>()
+    private val downloadsFeature = ViewBoundFeatureWrapper<DownloadsFeature>()
+    private val promptsFeature = ViewBoundFeatureWrapper<PromptFeature>()
+    private val findInPageIntegration = ViewBoundFeatureWrapper<FindInPageIntegration>()
+    private val customTabsToolbarFeature = ViewBoundFeatureWrapper<CustomTabsToolbarFeature>()
+    private val toolbarIntegration = ViewBoundFeatureWrapper<ToolbarIntegration>()
 
     override fun onCreateView(
         inflater: LayoutInflater,
@@ -108,63 +110,67 @@ class BrowserFragment : Fragment(), BackHandler {
 
         val sessionManager = requireComponents.core.sessionManager
 
-        contextMenuFeature = ContextMenuFeature(
+        contextMenuFeature.set(
-            requireFragmentManager(),
+            feature = ContextMenuFeature(
-            sessionManager,
+                requireFragmentManager(),
-            ContextMenuCandidate.defaultCandidates(
+                sessionManager,
+                ContextMenuCandidate.defaultCandidates(
+                    requireContext(),
+                    requireComponents.useCases.tabsUseCases,
+                    view),
+                view.engineView),
+            owner = this,
+            view = view)
+
+        downloadsFeature.set(
+            feature = DownloadsFeature(
                 requireContext(),
-                requireComponents.useCases.tabsUseCases,
+                sessionManager = sessionManager,
-                view),
+                fragmentManager = childFragmentManager,
-            view.engineView)
+                onNeedToRequestPermissions = { permissions ->
+                    requestPermissions(permissions, REQUEST_CODE_DOWNLOAD_PERMISSIONS)
+                }),
+            owner = this,
+            view = view)
 
-        downloadsFeature = DownloadsFeature(
+        promptsFeature.set(
-            requireContext(),
+            feature = PromptFeature(
-            sessionManager = sessionManager,
+                fragment = this,
-            fragmentManager = childFragmentManager,
+                sessionManager = sessionManager,
-            onNeedToRequestPermissions = { permissions ->
+                fragmentManager = requireFragmentManager(),
-                requestPermissions(permissions, REQUEST_CODE_DOWNLOAD_PERMISSIONS)
+                onNeedToRequestPermissions = { permissions ->
-            }
+                    requestPermissions(permissions, REQUEST_CODE_PROMPT_PERMISSIONS)
-        )
+                }),
+            owner = this,
+            view = view)
 
-        promptsFeature = PromptFeature(
+        sessionFeature.set(
-            fragment = this,
+            feature = SessionFeature(
-            sessionManager = sessionManager,
+                sessionManager,
-            fragmentManager = requireFragmentManager(),
+                SessionUseCases(sessionManager),
-            onNeedToRequestPermissions = { permissions ->
+                view.engineView,
-                requestPermissions(permissions, REQUEST_CODE_PROMPT_PERMISSIONS)
+                sessionId),
-            }
+            owner = this,
-        )
+            view = view)
 
-        sessionFeature = SessionFeature(
+        findInPageIntegration.set(
-            sessionManager,
+            feature = FindInPageIntegration(requireComponents.core.sessionManager, view.findInPageView),
-            SessionUseCases(sessionManager),
+            owner = this,
-            view.engineView,
+            view = view)
-            sessionId
-        )
 
-        findInPageIntegration = FindInPageIntegration(requireComponents.core.sessionManager, view.findInPageView)
+        customTabsToolbarFeature.set(
+            feature = CustomTabsToolbarFeature(
+                sessionManager,
+                toolbar,
+                sessionId,
+                closeListener = { requireActivity().finish() }),
+            owner = this,
+            view = view)
 
-        customTabsToolbarFeature = CustomTabsToolbarFeature(
+        toolbarIntegration.set(
-            sessionManager,
+            feature = (toolbarComponent.uiView as ToolbarUIView).toolbarIntegration,
-            toolbar,
+            owner = this,
-            sessionId
+            view = view)
-        ) { requireActivity().finish() }
-
-        lifecycle.addObservers(
-            contextMenuFeature,
-            downloadsFeature,
-            findInPageIntegration,
-            promptsFeature,
-            sessionFeature,
-            (toolbarComponent.uiView as ToolbarUIView).toolbarIntegration,
-            customTabsToolbarFeature
-        )
-    }
-
-    override fun onDestroyView() {
-        super.onDestroyView()
-
-        lifecycle.removeObserver(sessionFeature)
     }
 
     @SuppressWarnings("ReturnCount")
@@ -180,13 +186,17 @@ class BrowserFragment : Fragment(), BackHandler {
 
     override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
         when (requestCode) {
-            REQUEST_CODE_DOWNLOAD_PERMISSIONS -> downloadsFeature.onPermissionsResult(permissions, grantResults)
+            REQUEST_CODE_DOWNLOAD_PERMISSIONS -> downloadsFeature.withFeature {
-            REQUEST_CODE_PROMPT_PERMISSIONS -> promptsFeature.onPermissionsResult(permissions, grantResults)
+                it.onPermissionsResult(permissions, grantResults)
+            }
+            REQUEST_CODE_PROMPT_PERMISSIONS -> promptsFeature.withFeature {
+                it.onPermissionsResult(permissions, grantResults)
+            }
         }
     }
 
     override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
-        promptsFeature.onActivityResult(requestCode, resultCode, data)
+        promptsFeature.withFeature { it.onActivityResult(requestCode, resultCode, data) }
     }
 
     // This method triggers the complexity warning. However it's actually not that hard to understand.

app/src/main/java/org/mozilla/fenix/components/FindInPageIntegration.kt

@@ -6,9 +6,6 @@ package org.mozilla.fenix.components
 
 import android.content.Context
 import android.util.AttributeSet
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleObserver
-import androidx.lifecycle.OnLifecycleEvent
 import android.view.View
 import androidx.coordinatorlayout.widget.CoordinatorLayout
 import mozilla.components.browser.session.SessionManager
@@ -16,28 +13,28 @@ import mozilla.components.browser.toolbar.BrowserToolbar
 import mozilla.components.feature.findinpage.FindInPageFeature
 import mozilla.components.feature.findinpage.view.FindInPageBar
 import mozilla.components.feature.findinpage.view.FindInPageView
+import mozilla.components.support.base.feature.BackHandler
+import mozilla.components.support.base.feature.LifecycleAwareFeature
 
 class FindInPageIntegration(
     private val sessionManager: SessionManager,
     private val view: FindInPageView
-) : LifecycleObserver {
+) : LifecycleAwareFeature, BackHandler {
     private val feature = FindInPageFeature(sessionManager, view, ::onClose)
 
-    @OnLifecycleEvent(Lifecycle.Event.ON_START)
+    override fun start() {
-    fun onStart() {
         feature.start()
 
         FindInPageIntegration.launch = this::launch
     }
 
-    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
+    override fun stop() {
-    fun onStop() {
         feature.stop()
 
         FindInPageIntegration.launch = null
     }
 
-    fun onBackPressed(): Boolean {
+    override fun onBackPressed(): Boolean {
         return feature.onBackPressed()
     }
 

app/src/main/java/org/mozilla/fenix/search/toolbar/ToolbarIntegration.kt

@@ -5,9 +5,6 @@
 package org.mozilla.fenix.search.toolbar
 
 import android.content.Context
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleObserver
-import androidx.lifecycle.OnLifecycleEvent
 import androidx.navigation.Navigation
 import mozilla.components.browser.domains.autocomplete.DomainAutocompleteProvider
 import mozilla.components.browser.session.SessionManager
@@ -17,6 +14,7 @@ import mozilla.components.concept.storage.HistoryStorage
 import mozilla.components.feature.toolbar.ToolbarAutocompleteFeature
 import mozilla.components.feature.toolbar.ToolbarFeature
 import org.mozilla.fenix.DefaultThemeManager
+import mozilla.components.support.base.feature.LifecycleAwareFeature
 import org.mozilla.fenix.R
 import org.mozilla.fenix.ext.application
 import org.mozilla.fenix.ext.components
@@ -29,7 +27,7 @@ class ToolbarIntegration(
     historyStorage: HistoryStorage,
     sessionManager: SessionManager,
     sessionId: String? = null
-) : LifecycleObserver {
+) : LifecycleAwareFeature {
     init {
         toolbar.setMenuBuilder(toolbarMenu.menuBuilder)
 
@@ -59,18 +57,11 @@ class ToolbarIntegration(
         sessionId
     )
 
-    @OnLifecycleEvent(Lifecycle.Event.ON_START)
+    override fun start() {
-    fun start() {
         toolbarFeature.start()
     }
 
-    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
+    override fun stop() {
-    fun stop() {
         toolbarFeature.stop()
     }
-
-    companion object {
-        const val browserActionMarginDp = 8
-        const val urlBoxMargin = 8
-    }
 }