taler-android

HandleUriScreen.kt (8951B)

---

 /*
  * This file is part of GNU Taler
  * (C) 2026 Taler Systems S.A.
  *
  * GNU Taler is free software; you can redistribute it and/or modify it under the
  * terms of the GNU General Public License as published by the Free Software
  * Foundation; either version 3, or (at your option) any later version.
  *
  * GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
  */
 
 package net.taler.wallet
 
 import android.net.Uri
 import android.util.Log
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.livedata.observeAsState
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.core.net.toUri
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import net.taler.wallet.backend.TalerErrorInfo
 import net.taler.wallet.compose.LoadingScreen
 import net.taler.wallet.compose.RetryScreen
 import net.taler.wallet.main.MainViewModel
 import net.taler.wallet.main.TAG
 import net.taler.wallet.refund.RefundStatus
 import java.io.IOException
 import java.net.HttpURLConnection
 import java.net.URL
 import java.util.Locale
 
 @Composable
 fun HandleUriScreen(
     model: MainViewModel,
     uriString: String,
     onNavigate: NavigateCallback,
     onNavigateBack: () -> Unit,
     onShowError: (error: TalerErrorInfo) -> Unit,
 ) {
     var processing by remember { mutableStateOf(false) }
     var errorInfo by remember { mutableStateOf<TalerErrorInfo?>(null) }
     val networkStatus by model.networkManager.networkStatus.observeAsState()
     val devMode by model.devMode.observeAsState(false)
     val scope = rememberCoroutineScope()
 
     fun processTalerUri() {
         if (processing) return
         processing = true
 
         val uri = uriString.trim().toUri()
         // wifi connection logic omitted for now as it uses requireContext()
 
         getTalerAction(model, uri, 3, MutableLiveData()).observeForever { u ->
             Log.v(TAG, "found action $u")
 
             if (u.startsWith("payto://", ignoreCase = true)) {
                 onNavigate(WalletDestination.PaytoUri(u), true)
                 return@observeForever
             }
 
             val normalizedURL = u.lowercase(Locale.ROOT)
             var ext = false
             val action = normalizedURL.substring(
                 if (normalizedURL.startsWith("taler://", ignoreCase = true)) {
                     "taler://".length
                 } else if (normalizedURL.startsWith("ext+taler://", ignoreCase = true)) {
                     ext = true
                     "ext+taler://".length
                 } else if (normalizedURL.startsWith("taler+http://", ignoreCase = true) &&
                     model.devMode.value == true
                 ) {
                     "taler+http://".length
                 } else {
                     normalizedURL.length
                 }
             )
 
             val u2 = if (ext) {
                 "taler://" + u.substring("ext+taler://".length)
             } else u
 
             when {
                 action.startsWith("pay/", ignoreCase = true) -> {
                     scope.launch {
                         model.paymentManager.preparePay(u2)?.let { transactionId ->
                             if (model.transactionManager.selectTransaction(transactionId)) {
                                 onNavigate(WalletDestination.TransactionPayment, true)
                             }
                         }
                     }
                 }
                 action.startsWith("withdraw/", ignoreCase = true) -> {
                     model.withdrawManager.resetWithdrawal()
                     onNavigate(WalletDestination.PromptWithdraw(
                         withdrawUri = u2,
                         editableCurrency = false
                     ), true)
                 }
                 action.startsWith("withdraw-exchange/", ignoreCase = true) -> {
                     model.withdrawManager.resetWithdrawal()
                     onNavigate(WalletDestination.PromptWithdraw(
                         withdrawExchangeUri = u2,
                         editableCurrency = false
                     ), true)
                 }
                 action.startsWith("refund/", ignoreCase = true) -> {
                     model.showProgressBar.value = true
                     model.refundManager.refund(u2).observeForever { status ->
                         model.showProgressBar.value = false
                         when (status) {
                             is RefundStatus.Error -> {
                                 errorInfo = status.error
                             }
                             is RefundStatus.Success -> {
                                 onNavigateBack()
                             }
                         }
                     }
                 }
                 action.startsWith("pay-pull/", ignoreCase = true) -> {
                     model.peerManager.preparePeerPullDebit(u2)
                     onNavigate(WalletDestination.PromptPullPayment, true)
                 }
                 action.startsWith("pay-push/", ignoreCase = true) -> {
                     model.peerManager.preparePeerPushCredit(u2)
                     onNavigate(WalletDestination.PromptPushPayment, true)
                 }
                 action.startsWith("pay-template/", ignoreCase = true) -> {
                     onNavigate(WalletDestination.PromptPayTemplate(u2), true)
                 }
                 action.startsWith("dev-experiment/", ignoreCase = true) -> {
                     model.applyDevExperiment(u2) { error ->
                         errorInfo = error
                     }
                     onNavigateBack()
                 }
                 else -> {
                     errorInfo = TalerErrorInfo.makeCustomError("Unsupported URI: $u2")
                 }
             }
         }
     }
 
     LaunchedEffect(networkStatus) {
         if (networkStatus == true) {
             processTalerUri()
         }
     }
 
     LaunchedEffect(errorInfo) {
         val currentError = errorInfo
         if (currentError != null) {
             onShowError(currentError)
             onNavigateBack()
         }
     }
 
     Box(Modifier.fillMaxSize()) {
         if (networkStatus == true) {
             LoadingScreen()
         } else {
             RetryScreen {
                 processTalerUri()
             }
         }
     }
 }
 
 private fun getTalerAction(
     model: MainViewModel,
     uri: Uri,
     maxRedirects: Int,
     actionFound: MutableLiveData<String>,
 ): MutableLiveData<String> {
     val scheme = uri.scheme ?: return actionFound
 
     if (scheme == "http" || scheme == "https") {
         model.viewModelScope.launch(Dispatchers.IO) {
             try {
                 val conn = URL(uri.toString()).openConnection() as HttpURLConnection
                 conn.setRequestProperty("Accept", "text/html")
                 conn.connectTimeout = 5000
                 conn.requestMethod = "HEAD"
                 conn.connect()
                 val status = conn.responseCode
 
                 if (status == HttpURLConnection.HTTP_OK || status == HttpURLConnection.HTTP_PAYMENT_REQUIRED) {
                     val talerHeader = conn.headerFields["Taler"]
                     if (talerHeader != null && talerHeader[0] != null) {
                         val talerHeaderUri = talerHeader[0].toUri()
                         getTalerAction(model, talerHeaderUri, 0, actionFound)
                     } else {
                         // Error handling omitted for brevity
                     }
                 } else if (status == HttpURLConnection.HTTP_MOVED_TEMP
                     || status == HttpURLConnection.HTTP_MOVED_PERM
                     || status == HttpURLConnection.HTTP_SEE_OTHER
                 ) {
                     val location = conn.headerFields["Location"]
                     if (location != null && location[0] != null) {
                         val locUri = location[0].toUri()
                         getTalerAction(model, locUri, maxRedirects - 1, actionFound)
                     }
                 }
             } catch (e: IOException) {
                 // Error handling omitted
             }
         }
     } else {
         actionFound.postValue(uri.toString())
     }
 
     return actionFound
 }