messenger-android

LobbyJoinFragment.kt (5878B)

---

 /*
    This file is part of GNUnet.
    Copyright (C) 2021--2025 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
    by the Free Software Foundation, either version 3 of the License,
    or (at your option) any later version.
 
    GNUnet 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
    Affero General Public License for more details.
 
    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    SPDX-License-Identifier: AGPL3.0-or-later
  */
 /*
  * @author t3sserakt
  * @file GNUnetMessenger/app/src/main/java/org/gnunet/gnunetmessenger/ui/contact/LobbyJoinFragment.kt
  */
 
 package org.gnunet.gnunetmessenger.ui.contact
 
 import android.Manifest
 import android.content.pm.PackageManager
 import android.os.Bundle
 import android.util.Log
 import android.view.*
 import android.widget.Button
 import android.widget.EditText
 import androidx.annotation.OptIn
 import androidx.camera.core.*
 import androidx.camera.lifecycle.ProcessCameraProvider
 import androidx.camera.view.PreviewView
 import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
 import androidx.fragment.app.Fragment
 import androidx.lifecycle.lifecycleScope
 import androidx.navigation.fragment.findNavController
 import org.gnunet.gnunetmessenger.R
 import com.google.mlkit.vision.barcode.BarcodeScanning
 import com.google.mlkit.vision.common.InputImage
 import org.gnunet.gnunetmessenger.MainActivity
 import java.util.concurrent.Executors
 import kotlinx.coroutines.launch
 
 class LobbyJoinFragment : Fragment() {
 
     private lateinit var previewView: PreviewView
     private lateinit var qrText: EditText
     private lateinit var joinButton: Button
     private lateinit var cancelButton: Button
 
     private val cameraExecutor = Executors.newSingleThreadExecutor()
 
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View {
         val view = inflater.inflate(R.layout.fragment_join_lobby, container, false)
 
         previewView = view.findViewById(R.id.camera_preview)
         qrText = view.findViewById(R.id.qr_text)
         joinButton = view.findViewById(R.id.join_button)
         cancelButton = view.findViewById(R.id.cancel_button)
 
         joinButton.setOnClickListener {
             val lobbyId = qrText.text.toString()
             val activity = activity as MainActivity
             val gnunetChat = activity.getGnunetChatInstance()
             val handle = activity.getChatHandle()
             viewLifecycleOwner.lifecycleScope.launch {
                 try {
                     gnunetChat.lobbyJoin(handle, lobbyId)
                     findNavController().popBackStack()
                 } catch (t: Throwable) {
                     android.util.Log.e("LobbyJoinFragment", "lobbyJoin failed", t)
                 }
             }
         }
 
         cancelButton.setOnClickListener {
             findNavController().popBackStack()
         }
 
         if (allPermissionsGranted()) {
             startCamera()
         } else {
             requestPermissions(arrayOf(Manifest.permission.CAMERA), 10)
         }
 
         return view
     }
 
     private fun startCamera() {
         val cameraProviderFuture = ProcessCameraProvider.getInstance(requireContext())
 
         cameraProviderFuture.addListener({
             val cameraProvider = cameraProviderFuture.get()
             val preview = Preview.Builder().build().also {
                 it.setSurfaceProvider(previewView.surfaceProvider)
             }
 
             val barcodeScanner = BarcodeScanning.getClient()
 
             val analysis = ImageAnalysis.Builder()
                 .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
                 .build()
 
             analysis.setAnalyzer(cameraExecutor) { imageProxy ->
                 processImageProxy(barcodeScanner, imageProxy)
             }
 
             val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
 
             try {
                 cameraProvider.unbindAll()
                 cameraProvider.bindToLifecycle(this, cameraSelector, preview, analysis)
             } catch (e: Exception) {
                 Log.e("LobbyJoinFragment", "Camera binding failed", e)
             }
 
         }, ContextCompat.getMainExecutor(requireContext()))
     }
 
     @OptIn(ExperimentalGetImage::class)
     private fun processImageProxy(scanner: com.google.mlkit.vision.barcode.BarcodeScanner, imageProxy: ImageProxy) {
         val mediaImage = imageProxy.image ?: run {
             imageProxy.close()
             return
         }
 
         val inputImage = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
         scanner.process(inputImage)
             .addOnSuccessListener { barcodes ->
                 for (barcode in barcodes) {
                     val rawValue = barcode.rawValue
                     if (!rawValue.isNullOrBlank()) {
                         requireActivity().runOnUiThread {
                             qrText.setText(rawValue)
                         }
                         break
                     }
                 }
             }
             .addOnFailureListener {
                 Log.e("LobbyJoinFragment", "Barcode scan failed", it)
             }
             .addOnCompleteListener {
                 imageProxy.close()
             }
     }
 
     private fun allPermissionsGranted() =
         ContextCompat.checkSelfPermission(requireContext(), Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
 
     override fun onDestroy() {
         super.onDestroy()
         cameraExecutor.shutdown()
     }
 }