wip

2024-04-11 07:53:38 -07:00
parent a5d4cbfaec
commit 03b88c5b4b
26 changed files with 956 additions and 0 deletions
--- a/app/src/main/java/xyz/quaver/pupil/adapters/TransferPeersAdapter.kt
+++ b/app/src/main/java/xyz/quaver/pupil/adapters/TransferPeersAdapter.kt
@@ -0,0 +1,44 @@
+package xyz.quaver.pupil.adapters
+
+import android.net.wifi.p2p.WifiP2pDevice
+import android.net.wifi.p2p.WifiP2pDeviceList
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.BaseAdapter
+import androidx.recyclerview.widget.RecyclerView
+import xyz.quaver.pupil.R
+import xyz.quaver.pupil.databinding.TransferPeerListItemBinding
+
+class TransferPeersAdapter(
+    private val devices: Collection<WifiP2pDevice>,
+    private val onDeviceSelected: (WifiP2pDevice) -> Unit
+): RecyclerView.Adapter<TransferPeersAdapter.ViewHolder>() {
+
+    class ViewHolder(val binding: TransferPeerListItemBinding): RecyclerView.ViewHolder(binding.root)
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val binding = TransferPeerListItemBinding.inflate(
+            LayoutInflater.from(parent.context),
+            parent,
+            false
+        )
+        return ViewHolder(binding)
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val device = devices.elementAt(position)
+
+        holder.binding.deviceName.text = device.deviceName
+        holder.binding.deviceAddress.text = device.deviceAddress
+
+        holder.binding.root.setOnClickListener {
+            onDeviceSelected(device)
+        }
+    }
+
+    override fun getItemCount(): Int {
+        return devices.size
+    }
+}
--- a/app/src/main/java/xyz/quaver/pupil/receiver/WifiDirectBroadcastReceiver.kt
+++ b/app/src/main/java/xyz/quaver/pupil/receiver/WifiDirectBroadcastReceiver.kt
@@ -0,0 +1,59 @@
+package xyz.quaver.pupil.receiver
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.wifi.p2p.WifiP2pManager
+import android.os.Build
+import android.os.Parcelable
+import android.util.Log
+import androidx.core.app.ActivityCompat
+import xyz.quaver.pupil.ui.ErrorType
+import xyz.quaver.pupil.ui.TransferStep
+import xyz.quaver.pupil.ui.TransferViewModel
+
+private inline fun <reified T : Parcelable> Intent.getParcelableExtraCompat(key: String): T? = when {
+    Build.VERSION.SDK_INT >= 33 -> getParcelableExtra(key, T::class.java)
+    else -> @Suppress("DEPRECATION") getParcelableExtra(key) as? T
+}
+
+class WifiDirectBroadcastReceiver(
+    private val manager: WifiP2pManager,
+    private val channel: WifiP2pManager.Channel,
+    private val viewModel: TransferViewModel
+): BroadcastReceiver() {
+    @SuppressLint("MissingPermission")
+    override fun onReceive(context: Context?, intent: Intent?) {
+        context!!
+        when (intent?.action) {
+            WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION -> {
+                val state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1)
+                viewModel.setWifiP2pEnabled(state == WifiP2pManager.WIFI_P2P_STATE_ENABLED)
+            }
+            WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION -> {
+                manager.requestPeers(channel) { peers ->
+                    viewModel.setPeers(peers)
+                }
+            }
+            WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION -> {
+                // Respond to new connection or disconnections
+                val networkInfo = intent.getParcelableExtraCompat<android.net.NetworkInfo>(WifiP2pManager.EXTRA_NETWORK_INFO)
+
+                if (networkInfo?.isConnected == true) {
+                    manager.requestConnectionInfo(channel) { info ->
+                        viewModel.setConnectionInfo(info)
+                    }
+                } else {
+                    viewModel.setConnectionInfo(null)
+                }
+            }
+            WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION -> {
+                // Respond to this device's wifi state changing
+                viewModel.setThisDevice(intent.getParcelableExtraCompat(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE))
+            }
+        }
+    }
+}
--- a/app/src/main/java/xyz/quaver/pupil/ui/TransferActivity.kt
+++ b/app/src/main/java/xyz/quaver/pupil/ui/TransferActivity.kt
@@ -0,0 +1,294 @@
+package xyz.quaver.pupil.ui
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.BroadcastReceiver
+import android.content.IntentFilter
+import android.content.pm.ActivityInfo
+import android.content.pm.PackageManager
+import android.net.wifi.WpsInfo
+import android.net.wifi.p2p.WifiP2pConfig
+import android.net.wifi.p2p.WifiP2pDevice
+import android.net.wifi.p2p.WifiP2pDeviceList
+import android.net.wifi.p2p.WifiP2pInfo
+import android.net.wifi.p2p.WifiP2pManager
+import android.os.Build.VERSION
+import android.os.Build.VERSION_CODES
+import android.os.Bundle
+import android.util.Log
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.activity.viewModels
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.app.ActivityCompat
+import androidx.fragment.app.commit
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.flowWithLifecycle
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import xyz.quaver.pupil.R
+import xyz.quaver.pupil.receiver.WifiDirectBroadcastReceiver
+import xyz.quaver.pupil.ui.fragment.TransferDirectionFragment
+import xyz.quaver.pupil.ui.fragment.TransferPermissionFragment
+import xyz.quaver.pupil.ui.fragment.TransferTargetFragment
+import xyz.quaver.pupil.ui.fragment.TransferWaitForConnectionFragment
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
+
+class TransferActivity : AppCompatActivity(R.layout.transfer_activity) {
+
+    private val viewModel: TransferViewModel by viewModels()
+
+    private val intentFilter = IntentFilter().apply {
+        addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)
+        addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION)
+        addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)
+        addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)
+    }
+
+    private lateinit var manager: WifiP2pManager
+    private lateinit var channel: WifiP2pManager.Channel
+
+    private var receiver: BroadcastReceiver? = null
+
+    private val requestPermissionLauncher = registerForActivityResult(
+        ActivityResultContracts.RequestPermission()
+    ) { granted ->
+        if (granted) {
+            viewModel.setStep(TransferStep.TARGET)
+        } else {
+            viewModel.setStep(TransferStep.PERMISSION)
+        }
+    }
+
+    private fun checkPermission(force: Boolean = false): Boolean {
+        val permissionRequired = if (VERSION.SDK_INT < VERSION_CODES.TIRAMISU) {
+            Manifest.permission.ACCESS_FINE_LOCATION
+        } else {
+            Manifest.permission.NEARBY_WIFI_DEVICES
+        }
+
+        val permissionGranted =
+            ActivityCompat.checkSelfPermission(this, permissionRequired) == PackageManager.PERMISSION_GRANTED
+
+        val shouldShowRationale =
+            ActivityCompat.shouldShowRequestPermissionRationale(this, permissionRequired)
+
+        if (!permissionGranted) {
+            if (shouldShowRationale && force) {
+                viewModel.setStep(TransferStep.PERMISSION)
+            } else {
+                requestPermissionLauncher.launch(permissionRequired)
+            }
+            return false
+        }
+
+        return true
+    }
+
+    @SuppressLint("SourceLockedOrientationActivity")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        supportActionBar?.hide()
+        requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+
+        manager = getSystemService(WIFI_P2P_SERVICE) as WifiP2pManager
+        channel = manager.initialize(this, mainLooper, null)
+
+        viewModel.peerToConnect.observe(this) { peer ->
+            if (peer == null) { return@observe }
+            if (!checkPermission()) { return@observe }
+
+            val config = WifiP2pConfig().apply {
+                deviceAddress = peer.deviceAddress
+                wps.setup = WpsInfo.PBC
+            }
+
+            manager.connect(channel, config, object: WifiP2pManager.ActionListener {
+                override fun onSuccess() {
+                    Log.d("PUPILD", "Connection successful")
+                }
+
+                override fun onFailure(reason: Int) {
+                    Log.d("PUPILD", "Connection failed: $reason")
+                    viewModel.setPeers(null)
+                }
+            })
+        }
+
+        viewModel.connectionInfo.observe(this) { info ->
+            if (info == null) { return@observe }
+
+            if (info.groupFormed && info.isGroupOwner) {
+                // Do something
+                Log.d("PUPILD", "Group formed and is group owner")
+                Log.d("PUPILD", "Group owner IP: ${info.groupOwnerAddress.hostAddress}")
+            } else if (info.groupFormed) {
+                // Do something
+                Log.d("PUPILD", "Group formed")
+                Log.d("PUPILD", "Group owner IP: ${info.groupOwnerAddress.hostAddress}")
+                Log.d("PUPILD", "Local IP: ${info.groupOwnerAddress.hostAddress}")
+                Log.d("PUPILD", "Is group owner: ${info.isGroupOwner}")
+            }
+        }
+
+        lifecycleScope.launch {
+            viewModel.step.flowWithLifecycle(lifecycle, Lifecycle.State.STARTED).collect { step ->
+                when (step) {
+                    TransferStep.TARGET,
+                    TransferStep.TARGET_FORCE -> {
+                        if (!checkPermission(step == TransferStep.TARGET_FORCE)) {
+                            return@collect
+                        }
+
+                        manager.discoverPeers(channel, object: WifiP2pManager.ActionListener {
+                            override fun onSuccess() { }
+
+                            override fun onFailure(reason: Int) {
+                            }
+                        })
+
+                        supportFragmentManager.commit {
+                            replace(R.id.fragment_container_view, TransferTargetFragment())
+                        }
+                    }
+                    TransferStep.DIRECTION -> {
+                        supportFragmentManager.commit {
+                            replace(R.id.fragment_container_view, TransferDirectionFragment())
+                        }
+                    }
+                    TransferStep.PERMISSION -> {
+                        supportFragmentManager.commit {
+                            replace(R.id.fragment_container_view, TransferPermissionFragment())
+                        }
+                    }
+                    TransferStep.WAIT_FOR_CONNECTION -> {
+                        if (!checkPermission()) { return@collect }
+
+                        runCatching {
+                            suspendCoroutine { continuation ->
+                                manager.removeGroup(channel, object: WifiP2pManager.ActionListener {
+                                    override fun onSuccess() {
+                                        continuation.resume(Unit)
+                                    }
+
+                                    override fun onFailure(reason: Int) {
+                                        continuation.resume(Unit)
+                                    }
+                                })
+                            }
+
+                            suspendCoroutine { continuation ->
+                                manager.cancelConnect(channel, object: WifiP2pManager.ActionListener {
+                                    override fun onSuccess() {
+                                        continuation.resume(Unit)
+                                    }
+
+                                    override fun onFailure(reason: Int) {
+                                        continuation.resume(Unit)
+                                    }
+                                })
+                            }
+
+                            suspendCoroutine { continuation ->
+                                manager.createGroup(channel, object: WifiP2pManager.ActionListener {
+                                    override fun onSuccess() {
+                                        continuation.resume(Unit)
+                                    }
+
+                                    override fun onFailure(reason: Int) {
+                                        continuation.resumeWithException(Exception("Failed to create group $reason"))
+                                    }
+                                })
+                            }
+                        }.onFailure {
+                            Log.e("PUPILD", "Failed to create group", it)
+                        }
+
+                        supportFragmentManager.commit {
+                            replace(R.id.fragment_container_view, TransferWaitForConnectionFragment())
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+
+    override fun onResume() {
+        super.onResume()
+        WifiDirectBroadcastReceiver(manager, channel, viewModel).also {
+            receiver = it
+            registerReceiver(it, intentFilter)
+        }
+    }
+
+    override fun onPause() {
+        super.onPause()
+        receiver?.let { unregisterReceiver(it) }
+        receiver = null
+    }
+}
+
+enum class TransferStep {
+    TARGET, TARGET_FORCE, DIRECTION, PERMISSION, WAIT_FOR_CONNECTION
+}
+
+enum class ErrorType {
+}
+
+class TransferViewModel : ViewModel() {
+    private val _step: MutableStateFlow<TransferStep> = MutableStateFlow(TransferStep.DIRECTION)
+    val step: StateFlow<TransferStep> = _step
+
+    private val _error = MutableLiveData<ErrorType?>(null)
+    val error: LiveData<ErrorType?> = _error
+
+    private val _wifiP2pEnabled: MutableLiveData<Boolean> = MutableLiveData(false)
+    val wifiP2pEnabled: LiveData<Boolean> = _wifiP2pEnabled
+
+    private val _thisDevice: MutableLiveData<WifiP2pDevice?> = MutableLiveData(null)
+    val thisDevice: LiveData<WifiP2pDevice?> = _thisDevice
+
+    private val _peers: MutableLiveData<WifiP2pDeviceList?> = MutableLiveData(null)
+    val peers: LiveData<WifiP2pDeviceList?> = _peers
+
+    private val _connectionInfo: MutableLiveData<WifiP2pInfo?> = MutableLiveData(null)
+    val connectionInfo: LiveData<WifiP2pInfo?> = _connectionInfo
+
+    private val _peerToConnect: MutableLiveData<WifiP2pDevice?> = MutableLiveData(null)
+    val peerToConnect: LiveData<WifiP2pDevice?> = _peerToConnect
+
+    fun setStep(step: TransferStep) {
+        _step.value = step
+    }
+
+    fun setWifiP2pEnabled(enabled: Boolean) {
+        _wifiP2pEnabled.value = enabled
+    }
+
+    fun setThisDevice(device: WifiP2pDevice?) {
+        _thisDevice.value = device
+    }
+
+    fun setPeers(peers: WifiP2pDeviceList?) {
+        _peers.value = peers
+    }
+
+    fun setConnectionInfo(info: WifiP2pInfo?) {
+        _connectionInfo.value = info
+    }
+
+    fun setError(error: ErrorType?) {
+        _error.value = error
+    }
+
+    fun connect(device: WifiP2pDevice) {
+        _peerToConnect.value = device
+    }
+}
--- a/app/src/main/java/xyz/quaver/pupil/ui/fragment/SettingsFragment.kt
+++ b/app/src/main/java/xyz/quaver/pupil/ui/fragment/SettingsFragment.kt
@@ -21,12 +21,14 @@ package xyz.quaver.pupil.ui.fragment
 import android.app.Activity
 import android.content.*
 import android.os.Bundle
+import android.util.Log
 import android.widget.Toast
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.preference.*
 import com.google.android.gms.oss.licenses.OssLicensesMenuActivity
 import com.google.firebase.crashlytics.FirebaseCrashlytics
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -40,6 +42,7 @@ import xyz.quaver.pupil.clientHolder
 import xyz.quaver.pupil.types.SendLogException
 import xyz.quaver.pupil.ui.LockActivity
 import xyz.quaver.pupil.ui.SettingsActivity
+import xyz.quaver.pupil.ui.TransferActivity
 import xyz.quaver.pupil.ui.dialog.*
 import xyz.quaver.pupil.util.*
 import xyz.quaver.pupil.util.downloader.DownloadManager
@@ -113,6 +116,9 @@ class SettingsFragment :
                    )
                    Toast.makeText(context, R.string.copied_to_clipboard, Toast.LENGTH_SHORT).show()
                }
+                "transfer_data" -> {
+                    activity?.startActivity(Intent(activity, TransferActivity::class.java))
+                }
                else -> return false
            }
        }
@@ -300,6 +306,9 @@ class SettingsFragment :
                                true
                            }
                        }
+                        "transfer_data" -> {
+                            onPreferenceClickListener = this@SettingsFragment
+                        }
                    }

                }
--- a/app/src/main/java/xyz/quaver/pupil/ui/fragment/TransferDirectionFragment.kt
+++ b/app/src/main/java/xyz/quaver/pupil/ui/fragment/TransferDirectionFragment.kt
@@ -0,0 +1,44 @@
+package xyz.quaver.pupil.ui.fragment
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import xyz.quaver.pupil.R
+import xyz.quaver.pupil.databinding.TransferDirectionFragmentBinding
+import xyz.quaver.pupil.ui.TransferStep
+import xyz.quaver.pupil.ui.TransferViewModel
+
+class TransferDirectionFragment : Fragment(R.layout.transfer_direction_fragment) {
+
+    private var _binding: TransferDirectionFragmentBinding? = null
+    private val binding get() = _binding!!
+
+    private val viewModel: TransferViewModel by activityViewModels()
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        _binding = TransferDirectionFragmentBinding.inflate(inflater, container, false)
+
+        binding.inButton.setOnClickListener {
+            viewModel.setStep(TransferStep.TARGET)
+        }
+
+        binding.outButton.setOnClickListener {
+            viewModel.setStep(TransferStep.WAIT_FOR_CONNECTION)
+        }
+
+        return binding.root
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        _binding = null
+    }
+
+}
--- a/app/src/main/java/xyz/quaver/pupil/ui/fragment/TransferPermissionFragment.kt
+++ b/app/src/main/java/xyz/quaver/pupil/ui/fragment/TransferPermissionFragment.kt
@@ -0,0 +1,38 @@
+package xyz.quaver.pupil.ui.fragment
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import xyz.quaver.pupil.databinding.TransferPermissionFragmentBinding
+import xyz.quaver.pupil.ui.TransferStep
+import xyz.quaver.pupil.ui.TransferViewModel
+
+class TransferPermissionFragment: Fragment() {
+
+    private var _binding: TransferPermissionFragmentBinding? = null
+    private val binding get() = _binding!!
+
+    private val viewModel: TransferViewModel by activityViewModels()
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        _binding = TransferPermissionFragmentBinding.inflate(inflater, container, false)
+
+        binding.permissionsButton.setOnClickListener {
+            viewModel.setStep(TransferStep.TARGET_FORCE)
+        }
+
+        return binding.root
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        _binding = null
+    }
+}
--- a/app/src/main/java/xyz/quaver/pupil/ui/fragment/TransferTargetFragment.kt
+++ b/app/src/main/java/xyz/quaver/pupil/ui/fragment/TransferTargetFragment.kt
@@ -0,0 +1,69 @@
+package xyz.quaver.pupil.ui.fragment
+
+import android.os.Bundle
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ArrayAdapter
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import xyz.quaver.pupil.R
+import xyz.quaver.pupil.adapters.TransferPeersAdapter
+import xyz.quaver.pupil.databinding.TransferTargetFragmentBinding
+import xyz.quaver.pupil.ui.TransferStep
+import xyz.quaver.pupil.ui.TransferViewModel
+
+class TransferTargetFragment : Fragment() {
+
+    private var _binding: TransferTargetFragmentBinding? = null
+    private val binding get() = _binding!!
+
+    private val viewModel: TransferViewModel by activityViewModels()
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        _binding = TransferTargetFragmentBinding.inflate(inflater, container, false)
+
+        viewModel.thisDevice.observe(viewLifecycleOwner) { device ->
+            if (device == null) {
+                return@observe
+            }
+
+            if (device.status == 3) {
+                binding.ripple.startRippleAnimation()
+                binding.retryButton.visibility = View.INVISIBLE
+            } else {
+                binding.ripple.stopRippleAnimation()
+                binding.retryButton.visibility = View.VISIBLE
+            }
+        }
+
+        viewModel.peers.observe(viewLifecycleOwner) { peers ->
+            if (peers == null) {
+                return@observe
+            }
+
+            binding.deviceList.adapter = TransferPeersAdapter(peers.deviceList) {
+                viewModel.connect(it)
+            }
+        }
+
+        binding.ripple.startRippleAnimation()
+
+        binding.retryButton.setOnClickListener {
+            viewModel.setStep(TransferStep.TARGET)
+        }
+
+        return binding.root
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        _binding = null
+    }
+
+}
--- a/app/src/main/java/xyz/quaver/pupil/ui/fragment/TransferWaitForConnectionFragment.kt
+++ b/app/src/main/java/xyz/quaver/pupil/ui/fragment/TransferWaitForConnectionFragment.kt
@@ -0,0 +1,32 @@
+package xyz.quaver.pupil.ui.fragment
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import xyz.quaver.pupil.databinding.TransferWaitForConnectionFragmentBinding
+
+class TransferWaitForConnectionFragment : Fragment() {
+
+    private var _binding: TransferWaitForConnectionFragmentBinding? = null
+    private val binding get() = _binding!!
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        _binding = TransferWaitForConnectionFragmentBinding.inflate(layoutInflater)
+
+        binding.ripple.startRippleAnimation()
+
+        return binding.root
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        _binding = null
+    }
+
+}