Merge branch 'v3' into q-beta

mobile/src/main/java/be/mygod/vpnhotspot/net/wifi/WifiApManager.kt

@@ -3,15 +3,23 @@ package be.mygod.vpnhotspot.net.wifi
 import android.net.wifi.WifiConfiguration
 import android.net.wifi.WifiManager
 import be.mygod.vpnhotspot.App.Companion.app
+import java.lang.IllegalArgumentException
 
-/**
- * Although the functionalities were removed in API 26, it is already not functioning correctly on API 25.
- *
- * See also: https://android.googlesource.com/platform/frameworks/base/+/5c0b10a4a9eecc5307bb89a271221f2b20448797%5E%21/
- */
 object WifiApManager {
-    private val setWifiApEnabled = WifiManager::class.java.getDeclaredMethod("setWifiApEnabled",
-            WifiConfiguration::class.java, Boolean::class.java)
+    private val getWifiApConfiguration by lazy { WifiManager::class.java.getDeclaredMethod("getWifiApConfiguration") }
+    private val setWifiApConfiguration by lazy {
+        WifiManager::class.java.getDeclaredMethod("setWifiApConfiguration", WifiConfiguration::class.java)
+    }
+    var configuration: WifiConfiguration
+        get() = getWifiApConfiguration.invoke(app.wifi) as WifiConfiguration
+        set(value) {
+            if (setWifiApConfiguration.invoke(app.wifi, value) as? Boolean != true) throw IllegalArgumentException()
+        }
+
+    private val setWifiApEnabled by lazy {
+        WifiManager::class.java.getDeclaredMethod("setWifiApEnabled",
+                WifiConfiguration::class.java, Boolean::class.java)
+    }
     /**
      * Start AccessPoint mode with the specified
      * configuration. If the radio is already running in
@@ -25,6 +33,11 @@ object WifiApManager {
     private fun WifiManager.setWifiApEnabled(wifiConfig: WifiConfiguration?, enabled: Boolean) =
             setWifiApEnabled.invoke(this, wifiConfig, enabled) as Boolean
 
+    /**
+     * Although the functionalities were removed in API 26, it is already not functioning correctly on API 25.
+     *
+     * See also: https://android.googlesource.com/platform/frameworks/base/+/5c0b10a4a9eecc5307bb89a271221f2b20448797%5E%21/
+     */
     @Suppress("DEPRECATION")
     @Deprecated("Not usable since API 26, malfunctioning on API 25")
     fun start(wifiConfig: WifiConfiguration? = null) {

mobile/src/main/java/be/mygod/vpnhotspot/net/wifi/WifiP2pDialogFragment.kt

@@ -1,75 +0,0 @@
-package be.mygod.vpnhotspot.net.wifi
-
-import android.content.DialogInterface
-import android.net.wifi.WifiConfiguration
-import android.net.wifi.WifiConfiguration.AuthAlgorithm
-import android.os.Parcelable
-import android.text.Editable
-import android.text.TextWatcher
-import android.view.View
-import android.widget.EditText
-import android.widget.TextView
-import androidx.appcompat.app.AlertDialog
-import be.mygod.vpnhotspot.AlertDialogFragment
-import be.mygod.vpnhotspot.R
-import kotlinx.android.parcel.Parcelize
-import kotlinx.android.synthetic.main.dialog_wifi_ap.view.*
-import java.nio.charset.Charset
-
-/**
- * Based on: https://android.googlesource.com/platform/packages/apps/Settings/+/39b4674/src/com/android/settings/wifi/WifiApDialog.java
- *
- * This dialog has been deprecated in API 28, but we are still using it since it works better for our purposes.
- * Related: https://android.googlesource.com/platform/packages/apps/Settings/+/defb1183ecb00d6231bac7d934d07f58f90261ea
- */
-class WifiP2pDialogFragment : AlertDialogFragment<WifiP2pDialogFragment.Arg, WifiP2pDialogFragment.Arg>(), TextWatcher {
-    @Parcelize
-    data class Arg(val configuration: WifiConfiguration) : Parcelable
-
-    private lateinit var mView: View
-    private lateinit var mSsid: TextView
-    private lateinit var mPassword: EditText
-    override val ret: Arg? get() {
-        val config = WifiConfiguration()
-        config.SSID = mSsid.text.toString()
-        config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN)
-        if (mPassword.length() != 0) {
-            val password = mPassword.text.toString()
-            config.preSharedKey = password
-        }
-        return Arg(config)
-    }
-
-    override fun AlertDialog.Builder.prepare(listener: DialogInterface.OnClickListener) {
-        mView = requireActivity().layoutInflater.inflate(R.layout.dialog_wifi_ap, null)
-        setView(mView)
-        setTitle(R.string.repeater_configure)
-        mSsid = mView.ssid
-        mPassword = mView.password
-        setPositiveButton(context.getString(R.string.wifi_save), listener)
-        setNegativeButton(context.getString(R.string.wifi_cancel), null)
-        setNeutralButton(context.getString(R.string.repeater_reset_credentials), listener)
-        mSsid.text = arg.configuration.SSID
-        mSsid.addTextChangedListener(this@WifiP2pDialogFragment)
-        mPassword.setText(arg.configuration.preSharedKey)
-        mPassword.addTextChangedListener(this@WifiP2pDialogFragment)
-    }
-
-    override fun onStart() {
-        super.onStart()
-        validate()
-    }
-
-    private fun validate() {
-        val mSsidString = mSsid.text.toString()
-        val ssidValid = mSsid.length() != 0 && Charset.forName("UTF-8").encode(mSsidString).limit() <= 32
-        val passwordValid = mPassword.length() >= 8
-        mView.password_wrapper.error =
-                if (passwordValid) null else requireContext().getString(R.string.credentials_password_too_short)
-        (dialog as AlertDialog).getButton(DialogInterface.BUTTON_POSITIVE).isEnabled = ssidValid && passwordValid
-    }
-
-    override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) { }
-    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) { }
-    override fun afterTextChanged(editable: Editable) = validate()
-}

mobile/src/main/java/be/mygod/vpnhotspot/net/wifi/configuration/P2pSupplicantConfiguration.kt

@@ -1,4 +1,4 @@
-package be.mygod.vpnhotspot.net.wifi
+package be.mygod.vpnhotspot.net.wifi.configuration
 
 import android.net.wifi.p2p.WifiP2pGroup
 import android.os.Build

mobile/src/main/java/be/mygod/vpnhotspot/net/wifi/configuration/WifiApDialogFragment.kt

@@ -0,0 +1,190 @@
+package be.mygod.vpnhotspot.net.wifi.configuration
+
+import android.annotation.TargetApi
+import android.content.ClipData
+import android.content.DialogInterface
+import android.net.wifi.WifiConfiguration
+import android.net.wifi.WifiConfiguration.AuthAlgorithm
+import android.os.Build
+import android.os.Parcelable
+import android.text.Editable
+import android.text.TextWatcher
+import android.util.Base64
+import android.view.MenuItem
+import android.view.View
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import androidx.appcompat.app.AlertDialog
+import androidx.appcompat.widget.Toolbar
+import androidx.core.view.isGone
+import be.mygod.vpnhotspot.AlertDialogFragment
+import be.mygod.vpnhotspot.App.Companion.app
+import be.mygod.vpnhotspot.R
+import be.mygod.vpnhotspot.util.QRCodeDialog
+import be.mygod.vpnhotspot.util.toByteArray
+import be.mygod.vpnhotspot.util.toParcelable
+import kotlinx.android.parcel.Parcelize
+import kotlinx.android.synthetic.main.dialog_wifi_ap.view.*
+import java.lang.IllegalStateException
+import java.nio.charset.Charset
+
+/**
+ * Based on: https://android.googlesource.com/platform/packages/apps/Settings/+/39b4674/src/com/android/settings/wifi/WifiApDialog.java
+ *
+ * This dialog has been deprecated in API 28, but we are still using it since it works better for our purposes.
+ * Related: https://android.googlesource.com/platform/packages/apps/Settings/+/defb1183ecb00d6231bac7d934d07f58f90261ea
+ */
+class WifiApDialogFragment : AlertDialogFragment<WifiApDialogFragment.Arg, WifiApDialogFragment.Arg>(), TextWatcher,
+        Toolbar.OnMenuItemClickListener {
+    companion object {
+        private const val BASE64_FLAGS = Base64.NO_PADDING or Base64.NO_WRAP
+        private val channels by lazy { (1..165).map { BandOption.Channel(it) } }
+    }
+
+    @Parcelize
+    data class Arg(val configuration: WifiConfiguration,
+                   val readOnly: Boolean = false,
+                   /**
+                    * KeyMgmt is enforced to WPA_PSK.
+                    * Various values for apBand are allowed according to different rules.
+                    */
+                   val p2pMode: Boolean = false) : Parcelable
+
+    @TargetApi(23)
+    private sealed class BandOption {
+        open val apBand get() = AP_BAND_2GHZ
+        open val apChannel get() = 0
+
+        object BandAny : BandOption() {
+            override val apBand get() = AP_BAND_ANY
+            override fun toString() = app.getString(R.string.wifi_ap_choose_auto)
+        }
+        object Band2GHz : BandOption() {
+            override fun toString() = app.getString(R.string.wifi_ap_choose_2G)
+        }
+        object Band5GHz : BandOption() {
+            override val apBand get() = AP_BAND_5GHZ
+            override fun toString() = app.getString(R.string.wifi_ap_choose_5G)
+        }
+        class Channel(override val apChannel: Int) : BandOption() {
+            override fun toString() = "${channelToFrequency(apChannel)} MHz ($apChannel)"
+        }
+    }
+
+    private lateinit var dialogView: View
+    private lateinit var bandOptions: MutableList<BandOption>
+    private var started = false
+    override val ret get() = Arg(WifiConfiguration().apply {
+        SSID = dialogView.ssid.text.toString()
+        allowedKeyManagement.set(
+                if (arg.p2pMode) WifiConfiguration.KeyMgmt.WPA_PSK else dialogView.security.selectedItemPosition)
+        allowedAuthAlgorithms.set(AuthAlgorithm.OPEN)
+        if (dialogView.password.length() != 0) preSharedKey = dialogView.password.text.toString()
+        if (Build.VERSION.SDK_INT >= 23) {
+            val bandOption = dialogView.band.selectedItem as BandOption
+            apBand = bandOption.apBand
+            apChannel = bandOption.apChannel
+        }
+    })
+
+    override fun AlertDialog.Builder.prepare(listener: DialogInterface.OnClickListener) {
+        val activity = requireActivity()
+        dialogView = activity.layoutInflater.inflate(R.layout.dialog_wifi_ap, null)
+        setView(dialogView)
+        if (!arg.readOnly) setPositiveButton(R.string.wifi_save, listener)
+        setNegativeButton(R.string.donations__button_close, null)
+        dialogView.toolbar.inflateMenu(R.menu.toolbar_configuration)
+        dialogView.toolbar.setOnMenuItemClickListener(this@WifiApDialogFragment)
+        if (!arg.readOnly) dialogView.ssid.addTextChangedListener(this@WifiApDialogFragment)
+        if (arg.p2pMode) dialogView.security_wrapper.isGone = true else dialogView.security.apply {
+            adapter = ArrayAdapter(activity, android.R.layout.simple_spinner_item, 0,
+                    WifiConfiguration.KeyMgmt.strings).apply {
+                setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
+            }
+            onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+                override fun onNothingSelected(parent: AdapterView<*>?) =
+                        throw IllegalStateException("Must select something")
+                override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
+                    dialogView.password_wrapper.isGone = position == WifiConfiguration.KeyMgmt.NONE
+                }
+            }
+        }
+        if (!arg.readOnly) dialogView.password.addTextChangedListener(this@WifiApDialogFragment)
+        if (Build.VERSION.SDK_INT >= 23) {
+            bandOptions = mutableListOf<BandOption>().apply {
+                if (arg.p2pMode) add(BandOption.BandAny) else {
+                    if (Build.VERSION.SDK_INT >= 28) add(BandOption.BandAny)
+                    add(BandOption.Band2GHz)
+                    add(BandOption.Band5GHz)
+                }
+                addAll(channels)
+            }
+            dialogView.band.adapter = ArrayAdapter(activity, android.R.layout.simple_spinner_item, 0,
+                    bandOptions).apply {
+                setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
+            }
+        } else dialogView.band_wrapper.isGone = true
+        populateFromConfiguration(arg.configuration)
+    }
+
+    private fun populateFromConfiguration(configuration: WifiConfiguration) {
+        dialogView.ssid.setText(configuration.SSID)
+        if (!arg.p2pMode) dialogView.security.setSelection(configuration.apKeyManagement)
+        dialogView.password.setText(configuration.preSharedKey)
+        if (Build.VERSION.SDK_INT >= 23) {
+            dialogView.band.setSelection(if (configuration.apChannel in 1..165) {
+                bandOptions.indexOfFirst { it.apChannel == configuration.apChannel }
+            } else bandOptions.indexOfFirst { it.apBand == configuration.apBand })
+        }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        started = true
+        if (!arg.readOnly) validate()
+    }
+
+    /**
+     * This function is reached only if not arg.readOnly.
+     */
+    private fun validate() {
+        if (!started) return
+        val ssidValid = dialogView.ssid.length() != 0 &&
+                Charset.forName("UTF-8").encode(dialogView.ssid.text.toString()).limit() <= 32
+        val passwordValid = when (dialogView.security.selectedItemPosition) {
+            WifiConfiguration.KeyMgmt.WPA_PSK, WPA2_PSK -> dialogView.password.length() >= 8
+            else -> true    // do not try to validate
+        }
+        dialogView.password_wrapper.error = if (passwordValid) null else {
+            requireContext().getString(R.string.credentials_password_too_short)
+        }
+        (dialog as AlertDialog).getButton(DialogInterface.BUTTON_POSITIVE).isEnabled = ssidValid && passwordValid
+    }
+
+    override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) { }
+    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) { }
+    override fun afterTextChanged(editable: Editable) = validate()
+
+    override fun onMenuItemClick(item: MenuItem?): Boolean {
+        return when (item?.itemId) {
+            android.R.id.copy -> {
+                app.clipboard.primaryClip = ClipData.newPlainText(null,
+                        Base64.encodeToString(ret.configuration.toByteArray(), BASE64_FLAGS))
+                true
+            }
+            android.R.id.paste -> {
+                app.clipboard.primaryClip?.getItemAt(0)?.text?.apply {
+                    Base64.decode(toString(), BASE64_FLAGS).toParcelable<WifiConfiguration>()
+                            ?.let { populateFromConfiguration(it) }
+                }
+                true
+            }
+            R.id.share_qr -> {
+                QRCodeDialog().withArg(ret.configuration.toQRString())
+                        .show(fragmentManager ?: return false, "QRCodeDialog")
+                true
+            }
+            else -> false
+        }
+    }
+}

mobile/src/main/java/be/mygod/vpnhotspot/net/wifi/configuration/WifiConfiguration.kt

@@ -0,0 +1,113 @@
+package be.mygod.vpnhotspot.net.wifi.configuration
+
+import android.net.wifi.WifiConfiguration
+import androidx.annotation.RequiresApi
+import be.mygod.vpnhotspot.net.wifi.WifiApManager
+import timber.log.Timber
+import java.lang.reflect.InvocationTargetException
+
+val WPA2_PSK = WifiConfiguration.KeyMgmt.strings.indexOf("WPA2_PSK")
+
+/**
+ * apBand and apChannel is available since API 23.
+ *
+ * https://android.googlesource.com/platform/frameworks/base/+/android-6.0.0_r1/wifi/java/android/net/wifi/WifiConfiguration.java#242
+ */
+private val apBandField by lazy { WifiConfiguration::class.java.getDeclaredField("apBand") }
+private val apChannelField by lazy { WifiConfiguration::class.java.getDeclaredField("apChannel") }
+
+/**
+ * 2GHz band.
+ *
+ * https://android.googlesource.com/platform/frameworks/base/+/android-7.0.0_r1/wifi/java/android/net/wifi/WifiConfiguration.java#241
+ */
+@RequiresApi(23)
+const val AP_BAND_2GHZ = 0
+/**
+ * 5GHz band.
+ */
+@RequiresApi(23)
+const val AP_BAND_5GHZ = 1
+/**
+ * Device is allowed to choose the optimal band (2Ghz or 5Ghz) based on device capability,
+ * operating country code and current radio conditions.
+ *
+ * Introduced in 9.0, but we will abuse this constant anyway.
+ * https://android.googlesource.com/platform/frameworks/base/+/android-9.0.0_r1/wifi/java/android/net/wifi/WifiConfiguration.java#295
+ */
+@RequiresApi(23)
+const val AP_BAND_ANY = -1
+
+/**
+ * The band which AP resides on
+ * -1:Any 0:2G 1:5G
+ * By default, 2G is chosen
+ */
+var WifiConfiguration.apBand: Int
+    @RequiresApi(23) get() = apBandField.get(this) as Int
+    @RequiresApi(23) set(value) = apBandField.set(this, value)
+/**
+ * The channel which AP resides on
+ * 2G  1-11
+ * 5G  36,40,44,48,149,153,157,161,165
+ * 0 - find a random available channel according to the apBand
+ */
+var WifiConfiguration.apChannel: Int
+    @RequiresApi(23) get() = apChannelField.get(this) as Int
+    @RequiresApi(23) set(value) = apChannelField.set(this, value)
+
+/**
+ * The frequency which AP resides on (MHz). Resides in range [2412, 5815].
+ */
+fun channelToFrequency(channel: Int) = when (channel) {
+    in 1..14 -> 2407 + 5 * channel
+    in 15..165 -> 5000 + 5 * channel
+    else -> throw IllegalArgumentException("Invalid channel $channel")
+}
+
+val WifiConfiguration.apKeyManagement get() = allowedKeyManagement.nextSetBit(0).also { selected ->
+    check(selected >= 0) { "No key management selected" }
+    check(allowedKeyManagement.nextSetBit(selected + 1) < 0) { "More than 1 key managements supplied" }
+}
+
+private val qrSanitizer = Regex("([\\\\\":;,])")
+/**
+ * Documentation: https://github.com/zxing/zxing/wiki/Barcode-Contents#wi-fi-network-config-android-ios-11
+ */
+fun WifiConfiguration.toQRString() = StringBuilder("WIFI:").apply {
+    fun String.sanitize() = qrSanitizer.replace(this) { "\\${it.groupValues[1]}" }
+    var password = true
+    when (apKeyManagement) {
+        WifiConfiguration.KeyMgmt.NONE -> password = false
+        WifiConfiguration.KeyMgmt.WPA_PSK, WifiConfiguration.KeyMgmt.WPA_EAP, WPA2_PSK -> append("T:WPA;")
+        else -> throw IllegalArgumentException("Unsupported authentication type")
+    }
+    append("S:")
+    append(SSID.sanitize())
+    append(';')
+    if (password) {
+        append("P:")
+        append(preSharedKey.sanitize())
+        append(';')
+    }
+    if (hiddenSSID) append("H:true;")
+    append(';')
+}.toString()
+
+/**
+ * Based on:
+ * https://android.googlesource.com/platform/packages/apps/Settings/+/android-5.0.0_r1/src/com/android/settings/wifi/WifiApDialog.java#88
+ * https://android.googlesource.com/platform/packages/apps/Settings/+/b1af85d/src/com/android/settings/wifi/tether/WifiTetherSettings.java#162
+ */
+fun newWifiApConfiguration(ssid: String, passphrase: String?) = try {
+    WifiApManager.configuration
+} catch (e: InvocationTargetException) {
+    if (e.targetException !is SecurityException) Timber.w(e)
+    WifiConfiguration()
+}.apply {
+    SSID = ssid
+    preSharedKey = passphrase
+    allowedKeyManagement.clear()
+    allowedAuthAlgorithms.clear()
+    allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN)
+}