[WOOMOB-3851] Request the Android 17 local network permission for POS phone-as-reader

RELEASE-NOTES.txt

@@ -5,6 +5,7 @@
 25.5
 -----
 - [*****] [Internal] Updated the app's target SDK to Android 17 (API 37) [https://github.com/woocommerce/woocommerce-android/pull/16413]
+- [*] Remote Tap to Pay keeps working on Android 17: the phone now asks for local network permission before it advertises itself, and the tablet asks before it connects to a phone reader
 - [*] QR login now asks you to choose a store when your WordPress.com account has multiple sites instead of preselecting one [https://github.com/woocommerce/woocommerce-android/pull/16400]
 - [Internal] Close analytics gaps in the Remote Tap to Pay flow: transport on the reader-ready event, cause chains in error descriptions, no stale card reader model, and a real session ended reason [https://github.com/woocommerce/woocommerce-android/pull/16368]
 - [*] Tap to Pay no longer disappears from the Payments screen shortly after it appears [https://github.com/woocommerce/woocommerce-android/pull/16370]

WooCommerce/src/main/AndroidManifest.xml

@@ -15,6 +15,7 @@
     <uses-permission android:name="android.permission.ACTION_OPEN_DOCUMENT" />
     <uses-permission android:name="android.permission.NFC" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />
     <uses-permission
         android:name="com.google.android.gms.permission.AD_ID"
         tools:node="remove" />

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/payments/cardreader/payment/RemoteTapToPayPaymentViewState.kt

@@ -32,6 +32,24 @@ data class RemoteTapToPayLocationPermissionDenied(
     primaryActionLabel = R.string.card_reader_mode_location_permission_open_settings,
 )
 
+data class RemoteTapToPayLocalNetworkPermissionExplainer(
+    override val onPrimaryActionClicked: (() -> Unit),
+) : ViewState(
+    headerLabel = R.string.card_reader_mode_local_network_permission_header,
+    paymentStateLabel = UiStringRes(R.string.card_reader_mode_local_network_permission_subtitle),
+    illustration = R.drawable.img_card_reader_tpp_connecting,
+    primaryActionLabel = R.string.card_reader_mode_local_network_permission_continue,
+)
+
+data class RemoteTapToPayLocalNetworkPermissionDenied(
+    override val onPrimaryActionClicked: (() -> Unit),
+) : ViewState(
+    headerLabel = R.string.card_reader_mode_local_network_permission_header,
+    paymentStateLabel = UiStringRes(R.string.card_reader_mode_local_network_permission_denied_subtitle),
+    illustration = R.drawable.img_card_reader_tpp_connecting,
+    primaryActionLabel = R.string.card_reader_mode_local_network_permission_open_settings,
+)
+
 data class RemoteTapToPayReadyToPair(
     val deviceName: String,
     val fingerprintSuffix: String,

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/payments/cardreader/readermode/CardReaderModeActivity.kt

@@ -23,10 +23,23 @@
     private val locationPermissionLauncher = registerForActivityResult(
         ActivityResultContracts.RequestPermission()
     ) { granted ->
-        viewModel.onLocationPermissionResult(
-            granted = granted,
-            shouldShowRationale = WooPermissionUtils.shouldShowFineLocationPermissionRationale(this),
-        )
+        when {
+            granted -> checkPermissionsAndStartSession()
+            WooPermissionUtils.shouldShowFineLocationPermissionRationale(this) ->
+                viewModel.onLocationPermissionMissing()
+            else -> viewModel.onLocationPermissionDenied()
+        }
+    }
+
+    private val localNetworkPermissionLauncher = registerForActivityResult(
+        ActivityResultContracts.RequestPermission()
+    ) { granted ->
+        when {
+            granted -> checkPermissionsAndStartSession()
+            WooPermissionUtils.shouldShowLocalNetworkPermissionRationale(this) ->
+                viewModel.onLocalNetworkPermissionMissing()
+            else -> viewModel.onLocalNetworkPermissionDenied()
+        }
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -46,19 +59,26 @@
                         CardReaderModeEvent.Exit -> finish()
                         CardReaderModeEvent.RequestLocationPermission ->
                             locationPermissionLauncher.launch(Manifest.permission.ACCESS_FINE_LOCATION)
+                        CardReaderModeEvent.RequestLocalNetworkPermission ->
+                            localNetworkPermissionLauncher.launch(Manifest.permission.ACCESS_LOCAL_NETWORK)
                         CardReaderModeEvent.OpenAppSettings ->
                             WooPermissionUtils.showAppSettings(this@CardReaderModeActivity, openInNewStack = false)
                     }
                 }
             }
         }
+    }
 
-        if (savedInstanceState == null) {
-            if (WooPermissionUtils.hasFineLocationPermission(this)) {
-                viewModel.onLocationPermissionResult(granted = true, shouldShowRationale = false)
-            } else {
-                viewModel.onLocationPermissionMissing()
-            }
+    override fun onResume() {
+        super.onResume()
+        checkPermissionsAndStartSession()
+    }
+
+    private fun checkPermissionsAndStartSession() {
+        when {
+            !WooPermissionUtils.hasFineLocationPermission(this) -> viewModel.onLocationPermissionMissing()
+            !WooPermissionUtils.hasLocalNetworkPermission(this) -> viewModel.onLocalNetworkPermissionMissing()
+            else -> viewModel.onPermissionsGranted()
         }
     }
 }

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/payments/cardreader/readermode/CardReaderModeEvent.kt

@@ -3,5 +3,6 @@ package com.woocommerce.android.ui.payments.cardreader.readermode
 sealed class CardReaderModeEvent {
     data object Exit : CardReaderModeEvent()
     data object RequestLocationPermission : CardReaderModeEvent()
+    data object RequestLocalNetworkPermission : CardReaderModeEvent()
     data object OpenAppSettings : CardReaderModeEvent()
 }

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/payments/cardreader/readermode/CardReaderModeViewModel.kt

@@ -12,6 +12,8 @@ import com.woocommerce.android.cardreader.remote.CardReaderRemoteSession
 import com.woocommerce.android.cardreader.remote.CardReaderRemoteSessionState
 import com.woocommerce.android.tools.SelectedSite
 import com.woocommerce.android.ui.payments.cardreader.payment.RemoteTapToPayError
+import com.woocommerce.android.ui.payments.cardreader.payment.RemoteTapToPayLocalNetworkPermissionDenied
+import com.woocommerce.android.ui.payments.cardreader.payment.RemoteTapToPayLocalNetworkPermissionExplainer
 import com.woocommerce.android.ui.payments.cardreader.payment.RemoteTapToPayLocationPermissionDenied
 import com.woocommerce.android.ui.payments.cardreader.payment.RemoteTapToPayLocationPermissionExplainer
 import com.woocommerce.android.ui.payments.cardreader.payment.RemoteTapToPayReadyToPair
@@ -52,21 +54,36 @@ class CardReaderModeViewModel @Inject constructor(
     private var isSimulated = false
     private var tracking = SessionTracking()
 
+    fun onPermissionsGranted() {
+        startSessionIfNeeded()
+    }
+
     fun onLocationPermissionMissing() {
         if (sessionStarted) return
         _viewState.value = RemoteTapToPayLocationPermissionExplainer(
             onPrimaryActionClicked = { _events.trySend(CardReaderModeEvent.RequestLocationPermission) },
         )
     }
 
-    fun onLocationPermissionResult(granted: Boolean, shouldShowRationale: Boolean) {
-        when {
-            granted -> startSessionIfNeeded()
-            !shouldShowRationale -> _viewState.value = RemoteTapToPayLocationPermissionDenied(
-                onPrimaryActionClicked = { _events.trySend(CardReaderModeEvent.OpenAppSettings) },
-            )
-            else -> onLocationPermissionMissing()
-        }
+    fun onLocationPermissionDenied() {
+        if (sessionStarted) return
+        _viewState.value = RemoteTapToPayLocationPermissionDenied(
+            onPrimaryActionClicked = { _events.trySend(CardReaderModeEvent.OpenAppSettings) },
+        )
+    }
+
+    fun onLocalNetworkPermissionMissing() {
+        if (sessionStarted) return
+        _viewState.value = RemoteTapToPayLocalNetworkPermissionExplainer(
+            onPrimaryActionClicked = { _events.trySend(CardReaderModeEvent.RequestLocalNetworkPermission) },
+        )
+    }
+
+    fun onLocalNetworkPermissionDenied() {
+        if (sessionStarted) return
+        _viewState.value = RemoteTapToPayLocalNetworkPermissionDenied(
+            onPrimaryActionClicked = { _events.trySend(CardReaderModeEvent.OpenAppSettings) },
+        )
     }
 
     private fun startSessionIfNeeded() {

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/cardreader/connection/WooPosCardReaderConnectionController.kt

@@ -87,6 +87,7 @@ class WooPosCardReaderConnectionController(
     private var isRequiredUpdate = true
     private var isBluetoothPermissionPermanentlyDenied = false
     private var isLocationPermissionPermanentlyDenied = false
+    private var isLocalNetworkPermissionPermanentlyDenied = false
 
     fun showRemoteTapToPayExplainer() {
         if (_state.value !is WooPosCardReaderConnectionState.Scanning) return
@@ -185,6 +186,14 @@ class WooPosCardReaderConnectionController(
         checkRequirementsAndStartDiscovery()
     }
 
+    fun onLocalNetworkPermissionResult(granted: Boolean, shouldShowRationale: Boolean) {
+        isLocalNetworkPermissionPermanentlyDenied = !granted && !shouldShowRationale
+        val currentState = _state.value
+        if (granted && currentState is WooPosCardReaderConnectionState.MissingLocalNetworkPermission) {
+            onPhoneConnectClicked(currentState.phone)
+        }
+    }
+
     fun onBluetoothEnabled() {
         checkRequirementsAndStartDiscovery()
     }
@@ -195,10 +204,14 @@ class WooPosCardReaderConnectionController(
 
     fun recheckPermissions() {
         val currentState = _state.value
-        if (currentState is WooPosCardReaderConnectionState.MissingBluetoothPermission ||
-            currentState is WooPosCardReaderConnectionState.MissingLocationPermission
-        ) {
-            checkRequirementsAndStartDiscovery()
+        when {
+            currentState is WooPosCardReaderConnectionState.MissingBluetoothPermission ||
+                currentState is WooPosCardReaderConnectionState.MissingLocationPermission ->
+                checkRequirementsAndStartDiscovery()
+
+            currentState is WooPosCardReaderConnectionState.MissingLocalNetworkPermission &&
+                WooPermissionUtils.hasLocalNetworkPermission(context) ->
+                onPhoneConnectClicked(currentState.phone)
         }
     }
 
@@ -267,6 +280,7 @@ class WooPosCardReaderConnectionController(
         data object RequestBluetoothPermission : ControllerEvent
         data object RequestEnableBluetooth : ControllerEvent
         data object RequestLocationPermission : ControllerEvent
+        data object RequestLocalNetworkPermission : ControllerEvent
         data object RequestEnableLocation : ControllerEvent
         data object OpenAppSettings : ControllerEvent
         data object Cancelled : ControllerEvent
@@ -349,7 +363,7 @@ class WooPosCardReaderConnectionController(
         if (event is WooPosUnifiedDiscoveryEvent.ReadersFound) {
             latestDiscoveredPhones = event.readers.filterIsInstance<WooPosDiscoveredReader.Phone>()
         }
-        if (isShowingConnectionOutcome()) return
+        if (shouldIgnoreDiscoveryUpdates()) return
 
         when (event) {
             is WooPosUnifiedDiscoveryEvent.Started -> {
@@ -379,9 +393,10 @@ class WooPosCardReaderConnectionController(
         }
     }
 
-    private fun isShowingConnectionOutcome(): Boolean =
+    private fun shouldIgnoreDiscoveryUpdates(): Boolean =
         _state.value is WooPosCardReaderConnectionState.Connecting ||
             _state.value is WooPosCardReaderConnectionState.ConnectingFailed ||
+            _state.value is WooPosCardReaderConnectionState.MissingLocalNetworkPermission ||
             _state.value is Connected
 
     private fun handleReadersFound(
@@ -473,6 +488,21 @@ class WooPosCardReaderConnectionController(
 
     private fun onPhoneConnectClicked(phone: WooPosDiscoveredReader.Phone) {
         if (_state.value is WooPosCardReaderConnectionState.Connecting) return
+        if (!WooPermissionUtils.hasLocalNetworkPermission(context)) {
+            logger.d("Local network permission not granted")
+            _state.value = WooPosCardReaderConnectionState.MissingLocalNetworkPermission(
+                phone = phone,
+                onRequestPermissionClicked = {
+                    if (isLocalNetworkPermissionPermanentlyDenied) {
+                        emitEvent(ControllerEvent.OpenAppSettings)
+                    } else {
+                        emitEvent(ControllerEvent.RequestLocalNetworkPermission)
+                    }
+                },
+                onCancelClicked = { cancel() },
+            )
+            return
+        }
         markPhoneReaderSelected()
         tracker.trackOnConnectTapped()
         selectedReader = null

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/cardreader/connection/WooPosCardReaderConnectionDialog.kt

@@ -61,6 +61,7 @@
 import androidx.lifecycle.repeatOnLifecycle
 import com.woocommerce.android.R
 import com.woocommerce.android.ui.woopos.cardreader.WooPosCardReaderOnboardingActivity
+import com.woocommerce.android.ui.woopos.cardreader.remote.WooPosDiscoveredReader
 import com.woocommerce.android.ui.woopos.cardreader.remote.WooPosDiscoveryTransport
 import com.woocommerce.android.ui.woopos.cardreader.remote.WooPosRemoteReaderExplainerContent
 import com.woocommerce.android.ui.woopos.cardreader.remote.WooPosRemoteReaderHintStrip
@@ -82,6 +83,7 @@
 import com.woocommerce.android.ui.woopos.common.composeui.designsystem.currentWooPosBreakpoint
 import com.woocommerce.android.util.ChromeCustomTabUtils
 import kotlinx.coroutines.delay
+import java.net.InetAddress
 
 @Composable
 fun WooPosCardReaderConnectionDialog(
@@ -150,6 +152,16 @@
         viewModel.onLocationPermissionResult(granted, shouldShowRationale)
     }
 
+    val localNetworkPermissionLauncher = rememberLauncherForActivityResult(
+        ActivityResultContracts.RequestPermission()
+    ) { granted ->
+        val shouldShowRationale = ActivityCompat.shouldShowRequestPermissionRationale(
+            context as Activity,
+            Manifest.permission.ACCESS_LOCAL_NETWORK
+        )
+        viewModel.onLocalNetworkPermissionResult(granted, shouldShowRationale)
+    }
+
     val locationSettingsLauncher = rememberLauncherForActivityResult(
         ActivityResultContracts.StartActivityForResult()
     ) {
@@ -215,6 +227,9 @@
                     WooPosCardReaderConnectionViewModel.Event.RequestLocationPermission -> {
                         locationPermissionLauncher.launch(Manifest.permission.ACCESS_FINE_LOCATION)
                     }
+                    WooPosCardReaderConnectionViewModel.Event.RequestLocalNetworkPermission -> {
+                        localNetworkPermissionLauncher.launch(Manifest.permission.ACCESS_LOCAL_NETWORK)
+                    }
                     WooPosCardReaderConnectionViewModel.Event.RequestEnableLocation -> {
                         val intent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)
                         locationSettingsLauncher.launch(intent)
@@ -353,6 +368,14 @@
                         onCancelClicked = currentState.onCancelClicked,
                     )
                 }
+                is WooPosCardReaderConnectionState.MissingLocalNetworkPermission -> {
+                    MissingPermissionContent(
+                        title = stringResource(R.string.woopos_card_reader_local_network_permission_title),
+                        message = stringResource(R.string.woopos_card_reader_local_network_permission_message),
+                        onRequestPermissionClicked = currentState.onRequestPermissionClicked,
+                        onCancelClicked = currentState.onCancelClicked,
+                    )
+                }
                 is WooPosCardReaderConnectionState.MissingBluetoothPermission -> {
                     MissingPermissionContent(
                         title = stringResource(R.string.woopos_card_reader_bluetooth_permission_title),
@@ -1218,6 +1241,31 @@
     }
 }
 
+@WooPosPreview
+@Composable
+fun WooPosCardReaderConnectionDialogMissingLocalNetworkPermissionPreview() {
+    WooPosTheme {
+        WooPosCardReaderConnectionDialogContent(
+            isVisible = true,
+            state = WooPosCardReaderConnectionState.MissingLocalNetworkPermission(
+                phone = WooPosDiscoveredReader.Phone(
+                    serviceName = "woopos-remote-1a2b",
+                    deviceId = "device-id",
+                    name = "Pixel 9",
+                    host = InetAddress.getLoopbackAddress(),
+                    port = 8443,
+                    fingerprintBase64 = "AAAA",
+                    siteHash = "site-hash",
+                ),
+                onRequestPermissionClicked = {},
+                onCancelClicked = {},
+            ),
+            onBackPressed = {},
+            onDismiss = {},
+        )
+    }
+}
+
 @WooPosPreview
 @Composable
 fun WooPosCardReaderConnectionDialogMissingLocationPermissionPreview() {

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/cardreader/connection/WooPosCardReaderConnectionState.kt

@@ -1,5 +1,6 @@
 package com.woocommerce.android.ui.woopos.cardreader.connection
 
+import com.woocommerce.android.ui.woopos.cardreader.remote.WooPosDiscoveredReader
 import com.woocommerce.android.ui.woopos.cardreader.remote.WooPosDiscoveryTransport
 
 sealed interface WooPosCardReaderConnectionState {
@@ -51,6 +52,14 @@ sealed interface WooPosCardReaderConnectionState {
         override val showCloseButton: Boolean = false
     }
 
+    data class MissingLocalNetworkPermission(
+        val phone: WooPosDiscoveredReader.Phone,
+        val onRequestPermissionClicked: () -> Unit,
+        val onCancelClicked: () -> Unit,
+    ) : WooPosCardReaderConnectionState {
+        override val showCloseButton: Boolean = false
+    }
+
     data class MissingBluetoothPermission(
         val onRequestPermissionClicked: () -> Unit,
         val onCancelClicked: () -> Unit,