-        <service

-            android:name="org.torproject.android.service.TorService"

-            android:enabled="true"

-            android:exported="false"

-            android:stopWithTask="true">

-        </service>

-import org.torproject.android.service.util.Prefs

-    @OptIn(DelicateCoroutinesApi::class) // GlobalScope usage

-    open fun setupInMainProcessOnly() {

-

-            GlobalScope.launch(Dispatchers.IO) {

-                // Give TAS the base Context

-                Prefs.setContext(applicationContext)

-            }

-import org.mozilla.fenix.tor.TorControllerTAS

-/* 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.tor

-

-import android.os.Bundle

-import android.view.LayoutInflater

-import android.view.View

-import android.view.ViewGroup

-import androidx.core.view.children

-import androidx.fragment.app.Fragment

-import androidx.lifecycle.lifecycleScope

-import org.mozilla.fenix.BuildConfig

-import org.mozilla.fenix.databinding.FragmentHomeBinding

-import org.mozilla.fenix.ext.requireComponents

-import org.mozilla.fenix.tor.interactor.DefaultTorBootstrapInteractor

-import org.mozilla.fenix.tor.interactor.TorBootstrapInteractor

-import androidx.navigation.fragment.findNavController

-import com.google.android.material.appbar.AppBarLayout

-import org.mozilla.fenix.HomeActivity

-import org.mozilla.fenix.R

-import org.mozilla.fenix.ext.components

-import org.mozilla.fenix.ext.hideToolbar

-import org.mozilla.fenix.ext.settings

-import org.mozilla.fenix.tor.controller.DefaultTorBootstrapController

-import org.mozilla.fenix.tor.view.TorBootstrapView

-

-

-@Suppress("TooManyFunctions", "LargeClass")

-class TorBootstrapFragment : Fragment() {

-

-    internal var _binding: FragmentHomeBinding? = null

-    private val binding get() = _binding!!

-

-

-    private var torBootstrapView: TorBootstrapView? = null

-

-    private var _torBootstrapInteractor: TorBootstrapInteractor? = null

-    private val torBootstrapInteractor: TorBootstrapInteractor

-        get() = _torBootstrapInteractor!!

-

-    private lateinit var torBootstrapStatus: TorBootstrapStatus

-

-

-    @Suppress("LongMethod")

-    override fun onCreateView(

-        inflater: LayoutInflater,

-        container: ViewGroup?,

-        savedInstanceState: Bundle?,

-    ): View {

-        _binding = FragmentHomeBinding.inflate(inflater, container, false)

-        val components = requireComponents

-

-        torBootstrapStatus = TorBootstrapStatus(

-            !BuildConfig.DISABLE_TOR,

-            components.torController,

-            ::dispatchModeChanges

-        )

-

-        if (!torBootstrapStatus.isBootstrapping()) {

-            openHome()

-        }

-

-        // Was _sessionControlInteractor

-        _torBootstrapInteractor = DefaultTorBootstrapInteractor(

-            controller = DefaultTorBootstrapController(

-                handleTorBootstrapConnect = ::handleTorBootstrapConnect,

-                cancelTorBootstrap = ::cancelTorBootstrap,

-                initiateTorBootstrap = ::initiateTorBootstrap,

-                openTorNetworkSettings = ::openTorNetworkSettings

-            ),

-        )

-

-        torBootstrapView = TorBootstrapView(

-            containerView = binding.sessionControlRecyclerView,

-            viewLifecycleOwner = viewLifecycleOwner,

-            interactor = torBootstrapInteractor,

-        )

-

-        adjustHomeFragmentView()

-        updateSessionControlView()

-        showSessionControlView()

-

-        return binding.root

-    }

-

-    private fun updateSessionControlView() {

-        torBootstrapView?.update(requireContext().components.appStore.state)

-    }

-

-    // This function should be paired with showSessionControlView()

-    private fun adjustHomeFragmentView() {

-        binding.sessionControlRecyclerView.apply {

-            visibility = View.INVISIBLE

-        }

-

-        binding.sessionControlRecyclerView.apply {

-            setPadding(0, 0, 0, 0)

-            (layoutParams as ViewGroup.MarginLayoutParams).setMargins(0, 0, 0, 0)

-        }

-

-        binding.homeAppBar.apply {

-            visibility = View.GONE

-

-            // Reset this as SCROLL in case it was previously set as NO_SCROLL after bootstrap

-            children.forEach {

-                (it.layoutParams as AppBarLayout.LayoutParams).scrollFlags =

-                    AppBarLayout.LayoutParams.SCROLL_FLAG_SCROLL

-            }

-        }

-        binding.onionPatternImage.apply {

-            visibility = View.GONE

-        }

-        binding.toolbarLayout.apply {

-            visibility = View.GONE

-        }

-    }

-

-    // This function should be paired with adjustHomeFragmentView()

-    private fun showSessionControlView() {

-        binding.sessionControlRecyclerView.apply {

-            visibility = View.VISIBLE

-        }

-    }

-

-    private fun dispatchModeChanges(isBootstrapping: Boolean) {

-        //requireComponents.appStore.dispatch(AppAction.ModeChange(mode))

-        if (!isBootstrapping) {

-            openHome()

-        } else {

-            adjustHomeFragmentView()

-            updateSessionControlView()

-            showSessionControlView()

-        }

-    }

-

-    override fun onStop() {

-        super.onStop()

-        torBootstrapStatus.unregisterTorListener()

-    }

-

-    override fun onResume() {

-        super.onResume()

-

-        torBootstrapStatus.registerTorListener()

-

-        // fenix#40176: Ensure the Home fragment is rendered correctly when we resume.

-        val isBootstraping = torBootstrapStatus.isBootstrapping()

-

-        if (!isBootstraping) {

-            openHome()

-        }

-

-        adjustHomeFragmentView()

-        updateSessionControlView()

-        showSessionControlView()

-

-        hideToolbar()

-

-        // Whenever a tab is selected its last access timestamp is automatically updated by A-C.

-        // However, in the case of resuming the app to the home fragment, we already have an

-        // existing selected tab, but its last access timestamp is outdated. No action is

-        // triggered to cause an automatic update on warm start (no tab selection occurs). So we

-        // update it manually here.

-        requireComponents.useCases.sessionUseCases.updateLastAccess()

-        (requireActivity() as HomeActivity).navigateToHome()

-    }

-

-    private fun handleTorBootstrapConnect() {

-        requireComponents.torController.onTorConnecting()

-    }

-

-    private fun cancelTorBootstrap() {

-        requireComponents.torController.stopTor()

-    }

-

-    private fun initiateTorBootstrap(withDebugLogging: Boolean = false) {

-        requireComponents.torController.initiateTorBootstrap(lifecycleScope, withDebugLogging)

-    }

-

-    private fun openTorNetworkSettings() {

-        val directions =

-            TorBootstrapFragmentDirections.actionTorbootstrapFragmentToSettingsFragment(

-                requireContext().getString(R.string.pref_key_connection)

-            )

-        findNavController().navigate(directions)

-    }

-

-    private fun openHome() {

-        val directions =

-            TorBootstrapFragmentDirections

-                .actionStartupHome()

-        findNavController().navigate(directions)

-    }

-

-}

-

-    companion object {

-        fun fromString(status: String): TorStatus {

-            return when (status) {

-                "ON" -> ON

-                "STARTING" -> STARTING

-                "STOPPING" -> STOPPING

-                "OFF" -> OFF

-                else -> UNKNOWN

-            }

-        }

-    }

-

-    fun isOff() = this == OFF

-    fun isOn() = this == ON

-    fun isStarting() = this == STARTING

-    fun isStarted() = ((this == STARTING) || (this == ON))

-    fun isStopping() = this == STOPPING

-    fun isUnknown() = this == UNKNOWN

-package org.mozilla.fenix.tor

-

-import android.content.BroadcastReceiver

-import android.content.Context

-import android.content.Intent

-import android.content.IntentFilter

-import androidx.lifecycle.LifecycleCoroutineScope

-import androidx.localbroadcastmanager.content.LocalBroadcastManager

-import kotlinx.coroutines.channels.Channel

-import kotlinx.coroutines.launch

-import kotlinx.coroutines.withTimeoutOrNull

-import org.mozilla.fenix.BuildConfig

-import org.torproject.android.service.TorService

-import org.torproject.android.service.TorServiceConstants

-import org.torproject.android.service.util.Prefs

-

-@SuppressWarnings("TooManyFunctions")

-class TorControllerTAS (private val context: Context): TorController {

-    private val lbm: LocalBroadcastManager = LocalBroadcastManager.getInstance(context)

-    private val entries = mutableListOf<Pair<String?, String?>>()

-    override val logEntries get() = entries

-    override var quickstart: Boolean = false // Stub, is never used

-

-    private var torListeners = mutableListOf<TorEvents>()

-

-    private var pendingRegisterChangeList = mutableListOf<Pair<TorEvents, Boolean>>()

-    private var lockTorListenersMutation = false

-

-    private var lastKnownStatus = TorStatus.OFF

-    private var wasTorBootstrapped = false

-    private var isTorRestarting = false

-

-    // This may be a lie

-    private var isTorBootstrapped = false

-        get() = ((lastKnownStatus == TorStatus.ON) && wasTorBootstrapped)

-

-    val isDebugLoggingEnabled get() =

-        context

-            .getSharedPreferences("org.torproject.android_preferences", Context.MODE_PRIVATE)

-            .getBoolean("pref_enable_logging", false)

-

-    override val isStarting get() = lastKnownStatus.isStarting()

-    override val isRestarting get() = isTorRestarting

-    override val isBootstrapped get() = isTorBootstrapped

-    override val isConnected get() = (lastKnownStatus.isStarted() && !isTorRestarting)

-

-    override var bridgesEnabled: Boolean

-        get() = Prefs.bridgesEnabled()

-        set(value) { Prefs.putBridgesEnabled(value) }

-

-    override var bridgeTransport: TorBridgeTransportConfig

-        get() {

-            return TorBridgeTransportConfigUtil.getStringToBridgeTransport(

-                Prefs.getBridgesList()

-            )

-        }

-        set(value) {

-            if (value == TorBridgeTransportConfig.USER_PROVIDED) {

-                // Don't set the pref when the value is USER_PROVIDED because

-                // "user_provided" is not a valid bridge or transport type.

-                // This call should be followed by setting userProvidedBridges.

-                return

-            }

-            Prefs.setBridgesList(value.transportName)

-        }

-

-    override var userProvidedBridges: String?

-        get() {

-            val bridges = Prefs.getBridgesList()

-            val bridgeType =

-                TorBridgeTransportConfigUtil.getStringToBridgeTransport(bridges)

-            return when (bridgeType) {

-                TorBridgeTransportConfig.USER_PROVIDED -> bridges

-                else -> null

-            }

-        }

-        set(value) {

-            Prefs.setBridgesList(value)

-        }

-

-    override fun start() {

-        // Register receiver

-        lbm.registerReceiver(

-            persistentBroadcastReceiver,

-            IntentFilter(TorServiceConstants.ACTION_STATUS)

-        )

-        lbm.registerReceiver(

-            persistentBroadcastReceiver,

-            IntentFilter(TorServiceConstants.LOCAL_ACTION_LOG)

-        )

-    }

-

-    override fun stop() {

-        lbm.unregisterReceiver(persistentBroadcastReceiver)

-    }

-

-    private val persistentBroadcastReceiver = object : BroadcastReceiver() {

-        override fun onReceive(context: Context, intent: Intent) {

-            if (intent.action == null ||

-                (intent.action != TorServiceConstants.ACTION_STATUS &&

-                        intent.action != TorServiceConstants.LOCAL_ACTION_LOG)

-            ) {

-                return

-            }

-            val action = intent.action

-

-            val logentry: String?

-            val status: String?

-            if (action == TorServiceConstants.LOCAL_ACTION_LOG) {

-                logentry = intent.getExtras()

-                    ?.getCharSequence(TorServiceConstants.LOCAL_EXTRA_LOG) as? String?

-            } else {

-                logentry = null

-            }

-

-            status = intent.getExtras()

-                ?.getCharSequence(TorServiceConstants.EXTRA_STATUS) as? String?

-

-            if (logentry == null && status == null) {

-                return

-            }

-

-            onTorStatusUpdate(logentry, status)

-

-            if (status == null) {

-                return

-            }

-

-            val newStatus = TorStatus.fromString(status)

-

-            if (newStatus.isUnknown() && wasTorBootstrapped) {

-                stopTor()

-            }

-

-            entries.add(Pair(logentry, status))

-

-            if (logentry != null && logentry.contains(TorServiceConstants.TOR_CONTROL_PORT_MSG_BOOTSTRAP_DONE)) {

-                wasTorBootstrapped = true

-                onTorConnected()

-            }

-

-            if (lastKnownStatus.isStopping() && newStatus.isOff()) {

-                if (isTorRestarting) {

-                    initiateTorBootstrap()

-                } else {

-                    onTorStopped()

-                }

-            }

-

-            if (lastKnownStatus.isOff() && newStatus.isStarting()) {

-                isTorRestarting = false

-            }

-

-            lastKnownStatus = newStatus

-        }

-    }

-

-    override fun onTorConnecting() {

-        lockTorListenersMutation = true

-        torListeners.forEach { it.onTorConnecting() }

-        lockTorListenersMutation = false

-

-        handlePendingRegistrationChanges()

-    }

-

-    override fun onTorConnected() {

-        lockTorListenersMutation = true

-        torListeners.forEach { it.onTorConnected() }

-        lockTorListenersMutation = false

-

-        handlePendingRegistrationChanges()

-    }

-

-    override fun onTorStatusUpdate(entry: String?, status: String?, progress: Double?) {

-        lockTorListenersMutation = true

-        torListeners.forEach { it.onTorStatusUpdate(entry, status) }

-        lockTorListenersMutation = false

-

-        handlePendingRegistrationChanges()

-    }

-

-    override fun onTorStopped() {

-        lockTorListenersMutation = true

-        torListeners.forEach { it.onTorStopped() }

-        lockTorListenersMutation = false

-

-        handlePendingRegistrationChanges()

-    }

-

-    override fun registerTorListener(l: TorEvents) {

-        if (torListeners.contains(l)) {

-            return

-        }

-

-        if (lockTorListenersMutation) {

-            pendingRegisterChangeList.add(Pair(l, true))

-        } else {

-            torListeners.add(l)

-        }

-    }

-

-    override fun unregisterTorListener(l: TorEvents) {

-        if (!torListeners.contains(l)) {

-            return

-        }

-

-        if (lockTorListenersMutation) {

-            pendingRegisterChangeList.add(Pair(l, false))

-        } else {

-            torListeners.remove(l)

-        }

-    }

-

-    override fun registerTorLogListener(l: TorLogs) {}

-    override fun unregisterTorLogListener(l: TorLogs) {}

-

-    private fun handlePendingRegistrationChanges() {

-        pendingRegisterChangeList.forEach {

-            if (it.second) {

-                registerTorListener(it.first)

-            } else {

-                unregisterTorListener(it.first)

-            }

-        }

-

-        pendingRegisterChangeList.clear()

-    }

-

-    /**

-     * Receive the current Tor status.

-     *

-     * Send a request for the current status and receive the response.

-     * Returns true if Tor is running, false otherwise.

-     *

-     */

-    private suspend fun checkTorIsStarted(): Boolean {

-        val channel = Channel<Boolean>()

-

-        // Register receiver

-        val lbm: LocalBroadcastManager = LocalBroadcastManager.getInstance(context)

-        val localBroadcastReceiver = object : BroadcastReceiver() {

-            override fun onReceive(context: Context, intent: Intent) {

-                val action = intent.action ?: return

-                // We only want ACTION_STATUS messages

-                if (action != TorServiceConstants.ACTION_STATUS) {

-                    return

-                }

-                // The current status has the EXTRA_STATUS key

-                val currentStatus =

-                    intent.getStringExtra(TorServiceConstants.EXTRA_STATUS)

-                channel.trySend(currentStatus === TorServiceConstants.STATUS_ON)

-            }

-        }

-        lbm.registerReceiver(

-            localBroadcastReceiver,

-            IntentFilter(TorServiceConstants.ACTION_STATUS)

-        )

-

-        // Request service status

-        sendServiceAction(TorServiceConstants.ACTION_STATUS)

-

-        // Wait for response and unregister receiver

-        var torIsStarted = false

-        withTimeoutOrNull(torServiceResponseTimeout) {

-            torIsStarted = channel.receive()

-        }

-        lbm.unregisterReceiver(localBroadcastReceiver)

-        return torIsStarted

-    }

-

-    override fun initiateTorBootstrap(lifecycleScope: LifecycleCoroutineScope?, withDebugLogging: Boolean) {

-        if (BuildConfig.DISABLE_TOR) {

-            return

-        }

-

-        context.getSharedPreferences("org.torproject.android_preferences", Context.MODE_PRIVATE)

-            .edit().putBoolean("pref_enable_logging", withDebugLogging).apply()

-

-        if (lifecycleScope == null) {

-            sendServiceAction(TorServiceConstants.ACTION_START)

-        } else {

-            lifecycleScope.launch {

-                val torNeedsStart = !checkTorIsStarted()

-                if (torNeedsStart) {

-                    sendServiceAction(TorServiceConstants.ACTION_START)

-                }

-            }

-        }

-    }

-

-    override fun stopTor() {

-        if (BuildConfig.DISABLE_TOR) {

-            return

-        }

-

-        val torService = Intent(context, TorService::class.java)

-        context.stopService(torService)

-    }

-

-    override fun setTorStopped() {

-        lastKnownStatus = TorStatus.OFF

-        onTorStopped()

-    }

-

-    override fun restartTor() {

-        // tor-android-service doesn't dynamically update the torrc file,

-        // and it doesn't use SETCONF, so we completely restart the service.

-        // However, don't restart if we aren't started and we weren't

-        // previously started.

-        if (!lastKnownStatus.isStarted() && !wasTorBootstrapped) {

-            return

-        }

-

-        if (!lastKnownStatus.isStarted() && wasTorBootstrapped) {

-            // If we aren't started, but we were previously bootstrapped,

-            // then we handle a "restart" request as a "start" restart

-            initiateTorBootstrap()

-        } else {

-            // |isTorRestarting| tracks the state of restart. When we receive an |OFF| state

-            // from TorService in persistentBroadcastReceiver::onReceive we restart the Tor

-            // service.

-            isTorRestarting = true

-            stopTor()

-        }

-    }

-

-    private fun sendServiceAction(action: String) {

-        val torServiceStatus = Intent(context, TorService::class.java)

-        torServiceStatus.action = action

-        context.startService(torServiceStatus)

-    }

-

-    companion object {

-        const val torServiceResponseTimeout = 5000L

-    }

-

-    // Compat with TorControlGV Stubs

-

-    override fun getLastErrorState() : TorError? {

-        return null;

-    }

-}

-/* 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.tor.controller

-

-import org.mozilla.fenix.tor.interactor.TorBootstrapInteractor

-

-interface TorBootstrapController {

-    /**

-     * @see [TorBootstrapInteractor.onTorBootstrapConnectClicked]

-     */

-    fun handleTorBootstrapConnectClicked()

-

-    /**

-     * @see [TorBootstrapInteractor.onTorStopBootstrapping]

-     */

-    fun handleTorStopBootstrapping()

-

-    /**

-     * @see [TorBootstrapInteractor.onTorStartBootstrapping]

-     */

-    fun handleTorStartBootstrapping()

-

-    /**

-     * @see [TorBootstrapInteractor.onTorStartDebugBootstrapping]

-     */

-    fun handleTorStartDebugBootstrapping()

-

-    /**

-     * @see [TorBootstrapInteractor.onTorBootstrapNetworkSettingsClicked]

-     */

-    fun handleTorNetworkSettingsClicked()

-

-

-}

-

-class DefaultTorBootstrapController(

-    private val handleTorBootstrapConnect: () -> Unit,

-    private val initiateTorBootstrap: (Boolean) -> Unit,

-    private val cancelTorBootstrap: () -> Unit,

-    private val openTorNetworkSettings: () -> Unit

-) : TorBootstrapController {

-    override fun handleTorBootstrapConnectClicked() {

-        handleTorBootstrapConnect()

-    }

-

-    override fun handleTorStopBootstrapping() {

-        cancelTorBootstrap()

-    }

-

-    override fun handleTorStartBootstrapping() {

-        initiateTorBootstrap(false)

-    }

-

-    override fun handleTorStartDebugBootstrapping() {

-        initiateTorBootstrap(true)

-    }

-

-    override fun handleTorNetworkSettingsClicked() {

-        openTorNetworkSettings()

-    }

-}

-/* 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.tor.interactor

-

-import org.mozilla.fenix.tor.controller.TorBootstrapController

-

-interface TorBootstrapInteractor {

-    /**

-     * Initiates Tor bootstrapping. Called when a user clicks on the "Connect" button.

-     */

-    fun onTorBootstrapConnectClicked()

-

-    /**

-     * Initiates Tor bootstrapping. Called when a user clicks on the "Connect" button.

-     */

-    fun onTorStartBootstrapping()

-

-    /**

-     * Stop Tor bootstrapping. Called when a user clicks on the "settings" cog/button.

-     */

-    fun onTorStopBootstrapping()

-

-    /**

-     * Initiates Tor bootstrapping with debug logging. Called when bootstrapping fails with

-     * the control.txt file not existing.

-     */

-    fun onTorStartDebugBootstrapping()

-

-    /**

-     * Open Tor Network Settings preference screen

-     */

-    fun onTorBootstrapNetworkSettingsClicked()

-}

-

-class DefaultTorBootstrapInteractor(

-    private val controller: TorBootstrapController,

-) : TorBootstrapInteractor {

-

-    override fun onTorBootstrapConnectClicked() {

-        controller.handleTorBootstrapConnectClicked()

-    }

-

-    override fun onTorStopBootstrapping() {

-        controller.handleTorStopBootstrapping()

-    }

-

-    override fun onTorStartBootstrapping() {

-        controller.handleTorStartBootstrapping()

-    }

-

-    override fun onTorStartDebugBootstrapping() {

-        controller.handleTorStartDebugBootstrapping()

-    }

-

-    override fun onTorBootstrapNetworkSettingsClicked() {

-        controller.handleTorNetworkSettingsClicked()

-    }

-}

-/* 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.tor.view

-

-import android.view.LayoutInflater

-import android.view.ViewGroup

-import androidx.annotation.LayoutRes

-import androidx.lifecycle.LifecycleOwner

-import androidx.recyclerview.widget.DiffUtil

-import androidx.recyclerview.widget.ListAdapter

-import androidx.recyclerview.widget.RecyclerView

-import org.mozilla.fenix.components.Components

-import org.mozilla.fenix.home.topsites.TopSitePagerViewHolder

-import org.mozilla.fenix.tor.interactor.TorBootstrapInteractor

-

-sealed class AdapterItem(@LayoutRes val viewType: Int) {

-    object TorBootstrap : AdapterItem(TorBootstrapPagerViewHolder.LAYOUT_ID)

-

-

-    open fun sameAs(other: AdapterItem) = this::class == other::class

-    open fun getChangePayload(newItem: AdapterItem): Any? = null

-    open fun contentsSameAs(other: AdapterItem) = this::class == other::class

-

-}

-

-class AdapterItemDiffCallback : DiffUtil.ItemCallback<AdapterItem>() {

-    override fun areItemsTheSame(oldItem: AdapterItem, newItem: AdapterItem) =

-        oldItem.sameAs(newItem)

-

-    @Suppress("DiffUtilEquals")

-    override fun areContentsTheSame(oldItem: AdapterItem, newItem: AdapterItem) =

-        oldItem.contentsSameAs(newItem)

-

-    override fun getChangePayload(oldItem: AdapterItem, newItem: AdapterItem): Any? {

-        return oldItem.getChangePayload(newItem) ?: return super.getChangePayload(oldItem, newItem)

-    }

-}

-

-

-

-class TorBootstrapAdapter(

-    private val interactor: TorBootstrapInteractor,

-    private val viewLifecycleOwner: LifecycleOwner,

-    private val components: Components,

-) : ListAdapter<AdapterItem, RecyclerView.ViewHolder>(AdapterItemDiffCallback()) {

-

-    // This method triggers the ComplexMethod lint error when in fact it's quite simple.

-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {

-        val view = LayoutInflater.from(parent.context).inflate(viewType, parent, false)

-        return when (viewType) {

-            TorBootstrapPagerViewHolder.LAYOUT_ID -> TorBootstrapPagerViewHolder(

-                view,

-                components,

-                interactor

-            )

-            else -> throw IllegalStateException()

-        }

-    }

-

-    override fun getItemViewType(position: Int) = getItem(position).viewType

-

-    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int, payloads: MutableList<Any>) {

-        if (payloads.isEmpty()) {

-            onBindViewHolder(holder, position)

-        } else {

-            when (holder) {

-                is TopSitePagerViewHolder -> {

-                    if (payloads[0] is org.mozilla.fenix.home.sessioncontrol.AdapterItem.TopSitePagerPayload) {

-                        val payload = payloads[0] as org.mozilla.fenix.home.sessioncontrol.AdapterItem.TopSitePagerPayload

-                        holder.update(payload)

-                    }

-                }

-            }

-        }

-    }

-

-    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {

-        // no-op. This ViewHolder receives the HomeStore as argument and will observe that

-        // without the need for us to manually update from here the data to be displayed.

-    }

-}

-/* 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.tor.view

-

-import android.view.View

-import androidx.recyclerview.widget.RecyclerView

-import org.mozilla.fenix.R

-import org.mozilla.fenix.components.Components

-import org.mozilla.fenix.databinding.TorBootstrapConnectBinding

-import org.mozilla.fenix.tor.TorEvents

-import org.mozilla.fenix.tor.interactor.TorBootstrapInteractor

-

-class TorBootstrapConnectViewHolder(

-    private val view: View,

-    private val components: Components,

-    private val interactor: TorBootstrapInteractor

-) : RecyclerView.ViewHolder(view), TorEvents {

-

-    var binding: TorBootstrapConnectBinding

-

-    init {

-        binding = TorBootstrapConnectBinding.bind(view)

-

-        with(binding.torBootstrapNetworkSettingsButton) {