diff options
Diffstat (limited to 'ui/src/main/java/com')
23 files changed, 569 insertions, 532 deletions
diff --git a/ui/src/main/java/com/wireguard/android/Application.kt b/ui/src/main/java/com/wireguard/android/Application.kt index 5563fe62..8b3be8de 100644 --- a/ui/src/main/java/com/wireguard/android/Application.kt +++ b/ui/src/main/java/com/wireguard/android/Application.kt @@ -8,13 +8,10 @@ import android.content.Context import android.content.Intent import android.content.SharedPreferences import android.content.SharedPreferences.OnSharedPreferenceChangeListener -import android.os.AsyncTask import android.os.Build -import android.os.Handler -import android.os.Looper import android.os.StrictMode -import android.os.StrictMode.VmPolicy import android.os.StrictMode.ThreadPolicy +import android.os.StrictMode.VmPolicy import android.util.Log import androidx.appcompat.app.AppCompatDelegate import androidx.preference.PreferenceManager @@ -23,18 +20,18 @@ import com.wireguard.android.backend.GoBackend import com.wireguard.android.backend.WgQuickBackend import com.wireguard.android.configStore.FileConfigStore import com.wireguard.android.model.TunnelManager -import com.wireguard.android.util.AsyncWorker -import com.wireguard.android.util.ExceptionLoggers import com.wireguard.android.util.ModuleLoader import com.wireguard.android.util.RootShell import com.wireguard.android.util.ToolsInstaller -import java9.util.concurrent.CompletableFuture +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch import java.lang.ref.WeakReference import java.util.Locale class Application : android.app.Application(), OnSharedPreferenceChangeListener { - private val futureBackend = CompletableFuture<Backend>() - private lateinit var asyncWorker: AsyncWorker + private val futureBackend = CompletableDeferred<Backend>() private var backend: Backend? = null private lateinit var moduleLoader: ModuleLoader private lateinit var rootShell: RootShell @@ -58,10 +55,37 @@ class Application : android.app.Application(), OnSharedPreferenceChangeListener } } + private fun determineBackend(): Backend { + var backend: Backend? = null + var didStartRootShell = false + if (!ModuleLoader.isModuleLoaded() && moduleLoader.moduleMightExist()) { + try { + rootShell.start() + didStartRootShell = true + moduleLoader.loadModule() + } catch (ignored: Exception) { + } + } + if (!sharedPreferences.getBoolean("disable_kernel_module", false) && ModuleLoader.isModuleLoaded()) { + try { + if (!didStartRootShell) + rootShell.start() + val wgQuickBackend = WgQuickBackend(applicationContext, rootShell, toolsInstaller) + wgQuickBackend.setMultipleTunnels(sharedPreferences.getBoolean("multiple_tunnels", false)) + backend = wgQuickBackend + } catch (ignored: Exception) { + } + } + if (backend == null) { + backend = GoBackend(applicationContext) + GoBackend.setAlwaysOnCallback { get().tunnelManager.restoreState(true) } + } + return backend + } + override fun onCreate() { Log.i(TAG, USER_AGENT) super.onCreate() - asyncWorker = AsyncWorker(AsyncTask.SERIAL_EXECUTOR, Handler(Looper.getMainLooper())) rootShell = RootShell(applicationContext) toolsInstaller = ToolsInstaller(applicationContext, rootShell) moduleLoader = ModuleLoader(applicationContext, rootShell, USER_AGENT) @@ -74,7 +98,14 @@ class Application : android.app.Application(), OnSharedPreferenceChangeListener } tunnelManager = TunnelManager(FileConfigStore(applicationContext)) tunnelManager.onCreate() - asyncWorker.supplyAsync(Companion::getBackend).thenAccept { futureBackend.complete(it) } + GlobalScope.launch(Dispatchers.IO) { + try { + backend = determineBackend() + futureBackend.complete(backend!!) + } catch (e: Throwable) { + Log.println(Log.ERROR, TAG, Log.getStackTraceString(e)) + } + } sharedPreferences.registerOnSharedPreferenceChangeListener(this) } @@ -99,45 +130,7 @@ class Application : android.app.Application(), OnSharedPreferenceChangeListener } @JvmStatic - fun getAsyncWorker() = get().asyncWorker - - @JvmStatic - fun getBackend(): Backend { - val app = get() - synchronized(app.futureBackend) { - if (app.backend == null) { - var backend: Backend? = null - var didStartRootShell = false - if (!ModuleLoader.isModuleLoaded() && app.moduleLoader.moduleMightExist()) { - try { - app.rootShell.start() - didStartRootShell = true - app.moduleLoader.loadModule() - } catch (ignored: Exception) { - } - } - if (!app.sharedPreferences.getBoolean("disable_kernel_module", false) && ModuleLoader.isModuleLoaded()) { - try { - if (!didStartRootShell) - app.rootShell.start() - val wgQuickBackend = WgQuickBackend(app.applicationContext, app.rootShell, app.toolsInstaller) - wgQuickBackend.setMultipleTunnels(app.sharedPreferences.getBoolean("multiple_tunnels", false)) - backend = wgQuickBackend - } catch (ignored: Exception) { - } - } - if (backend == null) { - backend = GoBackend(app.applicationContext) - GoBackend.setAlwaysOnCallback { get().tunnelManager.restoreState(true).whenComplete(ExceptionLoggers.D) } - } - app.backend = backend - } - return app.backend!! - } - } - - @JvmStatic - fun getBackendAsync() = get().futureBackend + suspend fun getBackend() = get().futureBackend.await() @JvmStatic fun getModuleLoader() = get().moduleLoader diff --git a/ui/src/main/java/com/wireguard/android/BootShutdownReceiver.kt b/ui/src/main/java/com/wireguard/android/BootShutdownReceiver.kt index 41aff76d..70899a0c 100644 --- a/ui/src/main/java/com/wireguard/android/BootShutdownReceiver.kt +++ b/ui/src/main/java/com/wireguard/android/BootShutdownReceiver.kt @@ -8,19 +8,20 @@ import android.content.BroadcastReceiver import android.content.Context import android.content.Intent import android.util.Log -import com.wireguard.android.backend.Backend import com.wireguard.android.backend.WgQuickBackend -import com.wireguard.android.util.ExceptionLoggers +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch class BootShutdownReceiver : BroadcastReceiver() { override fun onReceive(context: Context, intent: Intent) { - Application.getBackendAsync().thenAccept { backend: Backend? -> - if (backend !is WgQuickBackend) return@thenAccept - val action = intent.action ?: return@thenAccept + GlobalScope.launch(Dispatchers.Main.immediate) { + if (Application.getBackend() !is WgQuickBackend) return@launch + val action = intent.action ?: return@launch val tunnelManager = Application.getTunnelManager() if (Intent.ACTION_BOOT_COMPLETED == action) { Log.i(TAG, "Broadcast receiver restoring state (boot)") - tunnelManager.restoreState(false).whenComplete(ExceptionLoggers.D) + tunnelManager.restoreState(false) } else if (Intent.ACTION_SHUTDOWN == action) { Log.i(TAG, "Broadcast receiver saving state (shutdown)") tunnelManager.saveState() diff --git a/ui/src/main/java/com/wireguard/android/QuickTileService.kt b/ui/src/main/java/com/wireguard/android/QuickTileService.kt index 5099668e..5989499f 100644 --- a/ui/src/main/java/com/wireguard/android/QuickTileService.kt +++ b/ui/src/main/java/com/wireguard/android/QuickTileService.kt @@ -21,6 +21,9 @@ import com.wireguard.android.activity.TunnelToggleActivity import com.wireguard.android.backend.Tunnel import com.wireguard.android.model.ObservableTunnel import com.wireguard.android.widget.SlashDrawable +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch /** * Service that maintains the application's custom Quick Settings tile. This service is bound by the @@ -40,7 +43,7 @@ class QuickTileService : TileService() { var ret: IBinder? = null try { ret = super.onBind(intent) - } catch (e: Exception) { + } catch (e: Throwable) { Log.d(TAG, "Failed to bind to TileService", e) } return ret @@ -54,11 +57,12 @@ class QuickTileService : TileService() { tile.icon = if (tile.icon == iconOn) iconOff else iconOn tile.updateTile() } - tunnel!!.setStateAsync(Tunnel.State.TOGGLE).whenComplete { _, t -> - if (t == null) { + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + tunnel!!.setStateAsync(Tunnel.State.TOGGLE) updateTile() - } else { - val toggleIntent = Intent(this, TunnelToggleActivity::class.java) + } catch (_: Throwable) { + val toggleIntent = Intent(this@QuickTileService, TunnelToggleActivity::class.java) toggleIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) startActivity(toggleIntent) } diff --git a/ui/src/main/java/com/wireguard/android/activity/BaseActivity.kt b/ui/src/main/java/com/wireguard/android/activity/BaseActivity.kt index 14ab0bdb..e663c1f2 100644 --- a/ui/src/main/java/com/wireguard/android/activity/BaseActivity.kt +++ b/ui/src/main/java/com/wireguard/android/activity/BaseActivity.kt @@ -9,6 +9,9 @@ import androidx.databinding.CallbackRegistry import androidx.databinding.CallbackRegistry.NotifierCallback import com.wireguard.android.Application import com.wireguard.android.model.ObservableTunnel +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch /** * Base class for activities that need to remember the currently-selected tunnel. @@ -35,11 +38,8 @@ abstract class BaseActivity : ThemeChangeAwareActivity() { intent != null -> intent.getStringExtra(KEY_SELECTED_TUNNEL) else -> null } - if (savedTunnelName != null) { - Application.getTunnelManager() - .tunnels - .thenAccept { selectedTunnel = it[savedTunnelName] } - } + if (savedTunnelName != null) + GlobalScope.launch(Dispatchers.Main.immediate) { selectedTunnel = Application.getTunnelManager().getTunnels()[savedTunnelName] } // The selected tunnel must be set before the superclass method recreates fragments. super.onCreate(savedInstanceState) @@ -51,6 +51,7 @@ abstract class BaseActivity : ThemeChangeAwareActivity() { } protected abstract fun onSelectedTunnelChanged(oldTunnel: ObservableTunnel?, newTunnel: ObservableTunnel?) + fun removeOnSelectedTunnelChangedListener( listener: OnSelectedTunnelChangedListener) { selectionChangeRegistry.remove(listener) diff --git a/ui/src/main/java/com/wireguard/android/activity/LogViewerActivity.kt b/ui/src/main/java/com/wireguard/android/activity/LogViewerActivity.kt index 87fdc236..e689f8ea 100644 --- a/ui/src/main/java/com/wireguard/android/activity/LogViewerActivity.kt +++ b/ui/src/main/java/com/wireguard/android/activity/LogViewerActivity.kt @@ -42,6 +42,7 @@ import com.wireguard.android.widget.EdgeToEdge.setUpScrollingContent import com.wireguard.crypto.KeyPair import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.cancel import kotlinx.coroutines.launch import kotlinx.coroutines.withContext @@ -67,7 +68,7 @@ class LogViewerActivity : AppCompatActivity() { private var rawLogLines = StringBuffer() private var recyclerView: RecyclerView? = null private var saveButton: MenuItem? = null - private val coroutineScope = CoroutineScope(Dispatchers.Default) + private val logStreamingScope = CoroutineScope(Dispatchers.IO) private val year by lazy { val yearFormatter: DateFormat = SimpleDateFormat("yyyy", Locale.US) yearFormatter.format(Date()) @@ -114,7 +115,7 @@ class LogViewerActivity : AppCompatActivity() { addItemDecoration(DividerItemDecoration(context, LinearLayoutManager.VERTICAL)) } - coroutineScope.launch { streamingLog() } + logStreamingScope.launch { streamingLog() } binding.shareFab.setOnClickListener { revokeLastUri() @@ -133,6 +134,11 @@ class LogViewerActivity : AppCompatActivity() { } } + override fun onDestroy() { + super.onDestroy() + logStreamingScope.cancel() + } + override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { if (requestCode == SHARE_ACTIVITY_REQUEST) { revokeLastUri() @@ -153,27 +159,21 @@ class LogViewerActivity : AppCompatActivity() { true } R.id.save_log -> { - coroutineScope.launch { saveLog() } + GlobalScope.launch { saveLog() } true } else -> super.onOptionsItemSelected(item) } } - override fun onDestroy() { - super.onDestroy() - coroutineScope.cancel() - } - private suspend fun saveLog() { - val context = this - withContext(Dispatchers.Main) { + withContext(Dispatchers.Main.immediate) { saveButton?.isEnabled = false withContext(Dispatchers.IO) { var exception: Throwable? = null var outputFile: DownloadsFileSaver.DownloadsFile? = null try { - outputFile = DownloadsFileSaver.save(context, "wireguard-log.txt", "text/plain", true) + outputFile = DownloadsFileSaver.save(this@LogViewerActivity, "wireguard-log.txt", "text/plain", true) outputFile.outputStream.use { it.write(rawLogLines.toString().toByteArray(Charsets.UTF_8)) } @@ -181,7 +181,7 @@ class LogViewerActivity : AppCompatActivity() { outputFile?.delete() exception = e } - withContext(Dispatchers.Main) { + withContext(Dispatchers.Main.immediate) { saveButton?.isEnabled = true Snackbar.make(findViewById(android.R.id.content), if (exception == null) getString(R.string.log_export_success, outputFile?.fileName) @@ -212,7 +212,7 @@ class LogViewerActivity : AppCompatActivity() { rawLogLines.append(line) rawLogLines.append('\n') val logLine = parseLine(line) - withContext(Dispatchers.Main) { + withContext(Dispatchers.Main.immediate) { if (logLine != null) { recyclerView?.let { val shouldScroll = haveScrolled && !it.canScrollVertically(1) @@ -348,7 +348,7 @@ class LogViewerActivity : AppCompatActivity() { return openPipeHelper(uri, "text/plain", null, log) { output, _, _, _, l -> try { FileOutputStream(output.fileDescriptor).write(l!!) - } catch (_: Exception) { + } catch (_: Throwable) { } } } diff --git a/ui/src/main/java/com/wireguard/android/activity/SettingsActivity.kt b/ui/src/main/java/com/wireguard/android/activity/SettingsActivity.kt index 81548fe7..3abfe07c 100644 --- a/ui/src/main/java/com/wireguard/android/activity/SettingsActivity.kt +++ b/ui/src/main/java/com/wireguard/android/activity/SettingsActivity.kt @@ -19,8 +19,8 @@ import com.wireguard.android.R import com.wireguard.android.backend.WgQuickBackend import com.wireguard.android.util.AdminKnobs import com.wireguard.android.util.ModuleLoader -import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import java.util.ArrayList @@ -102,8 +102,8 @@ class SettingsActivity : ThemeChangeAwareActivity() { preferenceManager.findPreference<Preference>("multiple_tunnels") ).filterNotNull() wgQuickOnlyPrefs.forEach { it.isVisible = false } - Application.getBackendAsync().thenAccept { backend -> - if (backend is WgQuickBackend) { + GlobalScope.launch(Dispatchers.Main.immediate) { + if (Application.getBackend() is WgQuickBackend) { ++preferenceScreen.initialExpandedChildrenCount wgQuickOnlyPrefs.forEach { it.isVisible = true } } else { @@ -121,11 +121,11 @@ class SettingsActivity : ThemeChangeAwareActivity() { moduleInstaller?.parent?.removePreference(moduleInstaller) } else { kernelModuleDisabler?.parent?.removePreference(kernelModuleDisabler) - CoroutineScope(Dispatchers.Main).launch { + GlobalScope.launch(Dispatchers.Main.immediate) { try { withContext(Dispatchers.IO) { Application.getRootShell().start() } moduleInstaller?.isVisible = true - } catch (_: Exception) { + } catch (_: Throwable) { moduleInstaller?.parent?.removePreference(moduleInstaller) } } diff --git a/ui/src/main/java/com/wireguard/android/activity/TunnelToggleActivity.kt b/ui/src/main/java/com/wireguard/android/activity/TunnelToggleActivity.kt index 44d81c01..004b10be 100644 --- a/ui/src/main/java/com/wireguard/android/activity/TunnelToggleActivity.kt +++ b/ui/src/main/java/com/wireguard/android/activity/TunnelToggleActivity.kt @@ -17,27 +17,31 @@ import com.wireguard.android.QuickTileService import com.wireguard.android.R import com.wireguard.android.backend.Tunnel import com.wireguard.android.util.ErrorMessages +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch @RequiresApi(Build.VERSION_CODES.N) class TunnelToggleActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) val tunnel = Application.getTunnelManager().lastUsedTunnel ?: return - tunnel.setStateAsync(Tunnel.State.TOGGLE).whenComplete { _, t -> - TileService.requestListeningState(this, ComponentName(this, QuickTileService::class.java)) - onToggleFinished(t) + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + tunnel.setStateAsync(Tunnel.State.TOGGLE) + } catch (e: Throwable) { + TileService.requestListeningState(this@TunnelToggleActivity, ComponentName(this@TunnelToggleActivity, QuickTileService::class.java)) + val error = ErrorMessages[e] + val message = getString(R.string.toggle_error, error) + Log.e(TAG, message, e) + Toast.makeText(this@TunnelToggleActivity, message, Toast.LENGTH_LONG).show() + finishAffinity() + return@launch + } + TileService.requestListeningState(this@TunnelToggleActivity, ComponentName(this@TunnelToggleActivity, QuickTileService::class.java)) finishAffinity() } } - - private fun onToggleFinished(throwable: Throwable?) { - if (throwable == null) return - val error = ErrorMessages[throwable] - val message = getString(R.string.toggle_error, error) - Log.e(TAG, message, throwable) - Toast.makeText(this, message, Toast.LENGTH_LONG).show() - } - companion object { private const val TAG = "WireGuard/TunnelToggleActivity" } diff --git a/ui/src/main/java/com/wireguard/android/databinding/BindingAdapters.kt b/ui/src/main/java/com/wireguard/android/databinding/BindingAdapters.kt index 055c2f06..b4c27a63 100644 --- a/ui/src/main/java/com/wireguard/android/databinding/BindingAdapters.kt +++ b/ui/src/main/java/com/wireguard/android/databinding/BindingAdapters.kt @@ -158,7 +158,7 @@ object BindingAdapters { return 0 return try { Integer.parseInt(s) - } catch (_: Exception) { + } catch (_: Throwable) { 0 } } diff --git a/ui/src/main/java/com/wireguard/android/fragment/AppListDialogFragment.kt b/ui/src/main/java/com/wireguard/android/fragment/AppListDialogFragment.kt index 1a29c5e6..966ba7d1 100644 --- a/ui/src/main/java/com/wireguard/android/fragment/AppListDialogFragment.kt +++ b/ui/src/main/java/com/wireguard/android/fragment/AppListDialogFragment.kt @@ -14,7 +14,6 @@ import androidx.databinding.Observable import androidx.fragment.app.DialogFragment import androidx.fragment.app.Fragment import com.google.android.material.tabs.TabLayout -import com.wireguard.android.Application import com.wireguard.android.BR import com.wireguard.android.R import com.wireguard.android.databinding.AppListDialogFragmentBinding @@ -22,8 +21,8 @@ import com.wireguard.android.databinding.ObservableKeyedArrayList import com.wireguard.android.model.ApplicationData import com.wireguard.android.util.ErrorMessages import com.wireguard.android.util.requireTargetFragment -import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.launch import kotlinx.coroutines.withContext @@ -37,7 +36,7 @@ class AppListDialogFragment : DialogFragment() { private fun loadData() { val activity = activity ?: return val pm = activity.packageManager - CoroutineScope(Dispatchers.Default).launch { + GlobalScope.launch(Dispatchers.Default) { try { val applicationData: MutableList<ApplicationData> = ArrayList() withContext(Dispatchers.IO) { @@ -57,12 +56,12 @@ class AppListDialogFragment : DialogFragment() { } } applicationData.sortWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name }) - withContext(Dispatchers.Main) { + withContext(Dispatchers.Main.immediate) { appData.clear() appData.addAll(applicationData) } - } catch (e: Exception) { - withContext(Dispatchers.Main) { + } catch (e: Throwable) { + withContext(Dispatchers.Main.immediate) { val error = ErrorMessages[e] val message = activity.getString(R.string.error_fetching_apps, error) Toast.makeText(activity, message, Toast.LENGTH_LONG).show() diff --git a/ui/src/main/java/com/wireguard/android/fragment/BaseFragment.kt b/ui/src/main/java/com/wireguard/android/fragment/BaseFragment.kt index 82802623..997c2221 100644 --- a/ui/src/main/java/com/wireguard/android/fragment/BaseFragment.kt +++ b/ui/src/main/java/com/wireguard/android/fragment/BaseFragment.kt @@ -17,13 +17,15 @@ import com.wireguard.android.Application import com.wireguard.android.R import com.wireguard.android.activity.BaseActivity import com.wireguard.android.activity.BaseActivity.OnSelectedTunnelChangedListener -import com.wireguard.android.backend.Backend import com.wireguard.android.backend.GoBackend import com.wireguard.android.backend.Tunnel import com.wireguard.android.databinding.TunnelDetailFragmentBinding import com.wireguard.android.databinding.TunnelListItemBinding import com.wireguard.android.model.ObservableTunnel import com.wireguard.android.util.ErrorMessages +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch /** * Base class for fragments that need to know the currently-selected tunnel. Only does anything when @@ -70,14 +72,14 @@ abstract class BaseFragment : Fragment(), OnSelectedTunnelChangedListener { is TunnelListItemBinding -> binding.item else -> return } ?: return - Application.getBackendAsync().thenAccept { backend: Backend? -> - if (backend is GoBackend) { + GlobalScope.launch(Dispatchers.Main.immediate) { + if (Application.getBackend() is GoBackend) { val intent = GoBackend.VpnService.prepare(view.context) if (intent != null) { pendingTunnel = tunnel pendingTunnelUp = checked startActivityForResult(intent, REQUEST_CODE_VPN_PERMISSION) - return@thenAccept + return@launch } } setTunnelStateWithPermissionsResult(tunnel, checked) @@ -85,19 +87,22 @@ abstract class BaseFragment : Fragment(), OnSelectedTunnelChangedListener { } private fun setTunnelStateWithPermissionsResult(tunnel: ObservableTunnel, checked: Boolean) { - tunnel.setStateAsync(Tunnel.State.of(checked)).whenComplete { _, throwable -> - if (throwable == null) return@whenComplete - val error = ErrorMessages[throwable] - val messageResId = if (checked) R.string.error_up else R.string.error_down - val message = requireContext().getString(messageResId, error) - val view = view - if (view != null) - Snackbar.make(view, message, Snackbar.LENGTH_LONG) - .setAnchorView(view.findViewById<View>(R.id.create_fab)) - .show() - else - Toast.makeText(requireContext(), message, Toast.LENGTH_LONG).show() - Log.e(TAG, message, throwable) + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + tunnel.setStateAsync(Tunnel.State.of(checked)) + } catch (e: Throwable) { + val error = ErrorMessages[e] + val messageResId = if (checked) R.string.error_up else R.string.error_down + val message = requireContext().getString(messageResId, error) + val view = view + if (view != null) + Snackbar.make(view, message, Snackbar.LENGTH_LONG) + .setAnchorView(view.findViewById<View>(R.id.create_fab)) + .show() + else + Toast.makeText(requireContext(), message, Toast.LENGTH_LONG).show() + Log.e(TAG, message, e) + } } } diff --git a/ui/src/main/java/com/wireguard/android/fragment/ConfigNamingDialogFragment.kt b/ui/src/main/java/com/wireguard/android/fragment/ConfigNamingDialogFragment.kt index d1b01944..12406df2 100644 --- a/ui/src/main/java/com/wireguard/android/fragment/ConfigNamingDialogFragment.kt +++ b/ui/src/main/java/com/wireguard/android/fragment/ConfigNamingDialogFragment.kt @@ -16,6 +16,9 @@ import com.wireguard.android.R import com.wireguard.android.databinding.ConfigNamingDialogFragmentBinding import com.wireguard.config.BadConfigException import com.wireguard.config.Config +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch import java.io.ByteArrayInputStream import java.io.IOException import java.nio.charset.StandardCharsets @@ -28,11 +31,12 @@ class ConfigNamingDialogFragment : DialogFragment() { private fun createTunnelAndDismiss() { binding?.let { val name = it.tunnelNameText.text.toString() - Application.getTunnelManager().create(name, config).whenComplete { tunnel, throwable -> - if (tunnel != null) { + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + Application.getTunnelManager().create(name, config) dismiss() - } else { - it.tunnelNameTextLayout.error = throwable.message + } catch (e: Throwable) { + it.tunnelNameTextLayout.error = e.message } } } @@ -49,7 +53,7 @@ class ConfigNamingDialogFragment : DialogFragment() { val configBytes = configText!!.toByteArray(StandardCharsets.UTF_8) config = try { Config.parse(ByteArrayInputStream(configBytes)) - } catch (e: Exception) { + } catch (e: Throwable) { when (e) { is BadConfigException, is IOException -> throw IllegalArgumentException("Invalid config passed to ${javaClass.simpleName}", e) else -> throw e diff --git a/ui/src/main/java/com/wireguard/android/fragment/TunnelDetailFragment.kt b/ui/src/main/java/com/wireguard/android/fragment/TunnelDetailFragment.kt index 2b5a4ba6..e81b4e6d 100644 --- a/ui/src/main/java/com/wireguard/android/fragment/TunnelDetailFragment.kt +++ b/ui/src/main/java/com/wireguard/android/fragment/TunnelDetailFragment.kt @@ -18,6 +18,9 @@ import com.wireguard.android.databinding.TunnelDetailPeerBinding import com.wireguard.android.model.ObservableTunnel import com.wireguard.android.widget.EdgeToEdge.setUpRoot import com.wireguard.android.widget.EdgeToEdge.setUpScrollingContent +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch import java.util.Timer import java.util.TimerTask @@ -79,7 +82,13 @@ class TunnelDetailFragment : BaseFragment() { override fun onSelectedTunnelChanged(oldTunnel: ObservableTunnel?, newTunnel: ObservableTunnel?) { binding ?: return binding!!.tunnel = newTunnel - if (newTunnel == null) binding!!.config = null else newTunnel.configAsync.thenAccept { config -> binding!!.config = config } + if (newTunnel == null) binding!!.config = null else GlobalScope.launch(Dispatchers.Main.immediate) { + try { + binding!!.config = newTunnel.getConfigAsync() + } catch (_: Throwable) { + binding!!.config = null + } + } lastState = Tunnel.State.TOGGLE updateStats() } @@ -105,30 +114,31 @@ class TunnelDetailFragment : BaseFragment() { val state = tunnel.state if (state != Tunnel.State.UP && lastState == state) return lastState = state - tunnel.statisticsAsync.whenComplete { statistics, throwable -> - if (throwable != null) { + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + val statistics = tunnel.getStatisticsAsync() for (i in 0 until binding!!.peersLayout.childCount) { val peer: TunnelDetailPeerBinding = DataBindingUtil.getBinding(binding!!.peersLayout.getChildAt(i)) ?: continue - peer.transferLabel.visibility = View.GONE - peer.transferText.visibility = View.GONE + val publicKey = peer.item!!.publicKey + val rx = statistics.peerRx(publicKey) + val tx = statistics.peerTx(publicKey) + if (rx == 0L && tx == 0L) { + peer.transferLabel.visibility = View.GONE + peer.transferText.visibility = View.GONE + continue + } + peer.transferText.text = requireContext().getString(R.string.transfer_rx_tx, formatBytes(rx), formatBytes(tx)) + peer.transferLabel.visibility = View.VISIBLE + peer.transferText.visibility = View.VISIBLE } - return@whenComplete - } - for (i in 0 until binding!!.peersLayout.childCount) { - val peer: TunnelDetailPeerBinding = DataBindingUtil.getBinding(binding!!.peersLayout.getChildAt(i)) - ?: continue - val publicKey = peer.item!!.publicKey - val rx = statistics.peerRx(publicKey) - val tx = statistics.peerTx(publicKey) - if (rx == 0L && tx == 0L) { + } catch (e: Throwable) { + for (i in 0 until binding!!.peersLayout.childCount) { + val peer: TunnelDetailPeerBinding = DataBindingUtil.getBinding(binding!!.peersLayout.getChildAt(i)) + ?: continue peer.transferLabel.visibility = View.GONE peer.transferText.visibility = View.GONE - continue } - peer.transferText.text = requireContext().getString(R.string.transfer_rx_tx, formatBytes(rx), formatBytes(tx)) - peer.transferLabel.visibility = View.VISIBLE - peer.transferText.visibility = View.VISIBLE } } } diff --git a/ui/src/main/java/com/wireguard/android/fragment/TunnelEditorFragment.kt b/ui/src/main/java/com/wireguard/android/fragment/TunnelEditorFragment.kt index cf39d052..5b556bc2 100644 --- a/ui/src/main/java/com/wireguard/android/fragment/TunnelEditorFragment.kt +++ b/ui/src/main/java/com/wireguard/android/fragment/TunnelEditorFragment.kt @@ -25,13 +25,16 @@ import com.wireguard.android.backend.Tunnel import com.wireguard.android.databinding.TunnelEditorFragmentBinding import com.wireguard.android.fragment.AppListDialogFragment.AppSelectionListener import com.wireguard.android.model.ObservableTunnel -import com.wireguard.android.util.BiometricAuthenticator import com.wireguard.android.util.AdminKnobs +import com.wireguard.android.util.BiometricAuthenticator import com.wireguard.android.util.ErrorMessages import com.wireguard.android.viewmodel.ConfigProxy import com.wireguard.android.widget.EdgeToEdge.setUpRoot import com.wireguard.android.widget.EdgeToEdge.setUpScrollingContent import com.wireguard.config.Config +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch /** * Fragment for editing a WireGuard configuration. @@ -130,7 +133,7 @@ class TunnelEditorFragment : BaseFragment(), AppSelectionListener { binding ?: return false val newConfig = try { binding!!.config!!.resolve() - } catch (e: Exception) { + } catch (e: Throwable) { val error = ErrorMessages[e] val tunnelName = if (tunnel == null) binding!!.name else tunnel!!.name val message = getString(R.string.config_save_error, tunnelName, error) @@ -138,20 +141,35 @@ class TunnelEditorFragment : BaseFragment(), AppSelectionListener { Snackbar.make(binding!!.mainContainer, error, Snackbar.LENGTH_LONG).show() return false } - when { - tunnel == null -> { - Log.d(TAG, "Attempting to create new tunnel " + binding!!.name) - val manager = Application.getTunnelManager() - manager.create(binding!!.name!!, newConfig).whenComplete(this::onTunnelCreated) - } - tunnel!!.name != binding!!.name -> { - Log.d(TAG, "Attempting to rename tunnel to " + binding!!.name) - tunnel!!.setNameAsync(binding!!.name!!).whenComplete { _, t -> onTunnelRenamed(tunnel!!, newConfig, t) } - } - else -> { - Log.d(TAG, "Attempting to save config of " + tunnel!!.name) - tunnel!!.setConfigAsync(newConfig) - .whenComplete { _, t -> onConfigSaved(tunnel!!, t) } + GlobalScope.launch(Dispatchers.Main.immediate) { + when { + tunnel == null -> { + Log.d(TAG, "Attempting to create new tunnel " + binding!!.name) + val manager = Application.getTunnelManager() + try { + onTunnelCreated(manager.create(binding!!.name!!, newConfig), null) + } catch (e: Throwable) { + onTunnelCreated(null, e) + } + } + tunnel!!.name != binding!!.name -> { + Log.d(TAG, "Attempting to rename tunnel to " + binding!!.name) + try { + tunnel!!.setNameAsync(binding!!.name!!) + onTunnelRenamed(tunnel!!, newConfig, null) + } catch (e: Throwable) { + onTunnelRenamed(tunnel!!, newConfig, e) + } + } + else -> { + Log.d(TAG, "Attempting to save config of " + tunnel!!.name) + try { + tunnel!!.setConfigAsync(newConfig) + onConfigSaved(tunnel!!, null) + } catch (e: Throwable) { + onConfigSaved(tunnel!!, e) + } + } } } return true @@ -187,13 +205,18 @@ class TunnelEditorFragment : BaseFragment(), AppSelectionListener { binding!!.config = ConfigProxy() if (tunnel != null) { binding!!.name = tunnel!!.name - tunnel!!.configAsync.thenAccept(this::onConfigLoaded) + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + onConfigLoaded(tunnel!!.getConfigAsync()) + } catch (_: Throwable) { + } + } } else { binding!!.name = "" } } - private fun onTunnelCreated(newTunnel: ObservableTunnel, throwable: Throwable?) { + private fun onTunnelCreated(newTunnel: ObservableTunnel?, throwable: Throwable?) { val message: String if (throwable == null) { tunnel = newTunnel @@ -219,7 +242,14 @@ class TunnelEditorFragment : BaseFragment(), AppSelectionListener { Log.d(TAG, message) // Now save the rest of configuration changes. Log.d(TAG, "Attempting to save config of renamed tunnel " + tunnel!!.name) - renamedTunnel.setConfigAsync(newConfig).whenComplete { _, t -> onConfigSaved(renamedTunnel, t) } + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + renamedTunnel.setConfigAsync(newConfig) + onConfigSaved(renamedTunnel, null) + } catch (e: Throwable) { + onConfigSaved(renamedTunnel, e) + } + } } else { val error = ErrorMessages[throwable] message = getString(R.string.tunnel_rename_error, error) diff --git a/ui/src/main/java/com/wireguard/android/fragment/TunnelListFragment.kt b/ui/src/main/java/com/wireguard/android/fragment/TunnelListFragment.kt index 7af5e06b..3250db65 100644 --- a/ui/src/main/java/com/wireguard/android/fragment/TunnelListFragment.kt +++ b/ui/src/main/java/com/wireguard/android/fragment/TunnelListFragment.kt @@ -36,7 +36,14 @@ import com.wireguard.android.widget.EdgeToEdge.setUpRoot import com.wireguard.android.widget.EdgeToEdge.setUpScrollingContent import com.wireguard.android.widget.MultiselectableRelativeLayout import com.wireguard.config.Config -import java9.util.concurrent.CompletableFuture +import kotlinx.coroutines.Deferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext import java.io.BufferedReader import java.io.ByteArrayInputStream import java.io.InputStreamReader @@ -61,108 +68,96 @@ class TunnelListFragment : BaseFragment() { // Config text is valid, now create the tunnel… newInstance(configText).show(parentFragmentManager, null) - } catch (e: Exception) { + } catch (e: Throwable) { onTunnelImportFinished(emptyList(), listOf<Throwable>(e)) } } private fun importTunnel(uri: Uri?) { - val activity = activity - if (activity == null || uri == null) { - return - } - val contentResolver = activity.contentResolver - - val futureTunnels = ArrayList<CompletableFuture<ObservableTunnel>>() - val throwables = ArrayList<Throwable>() - Application.getAsyncWorker().supplyAsync { - val columns = arrayOf(OpenableColumns.DISPLAY_NAME) - var name = "" - contentResolver.query(uri, columns, null, null, null)?.use { cursor -> - if (cursor.moveToFirst() && !cursor.isNull(0)) { - name = cursor.getString(0) + GlobalScope.launch(Dispatchers.Main.immediate) { + withContext(Dispatchers.IO) { + val activity = activity + if (activity == null || uri == null) { + return@withContext } - } - if (name.isEmpty()) { - name = Uri.decode(uri.lastPathSegment) - } - var idx = name.lastIndexOf('/') - if (idx >= 0) { - require(idx < name.length - 1) { resources.getString(R.string.illegal_filename_error, name) } - name = name.substring(idx + 1) - } - val isZip = name.toLowerCase(Locale.ROOT).endsWith(".zip") - if (name.toLowerCase(Locale.ROOT).endsWith(".conf")) { - name = name.substring(0, name.length - ".conf".length) - } else { - require(isZip) { resources.getString(R.string.bad_extension_error) } - } + val contentResolver = activity.contentResolver + val futureTunnels = ArrayList<Deferred<ObservableTunnel>>() + val throwables = ArrayList<Throwable>() + try { + val columns = arrayOf(OpenableColumns.DISPLAY_NAME) + var name = "" + contentResolver.query(uri, columns, null, null, null)?.use { cursor -> + if (cursor.moveToFirst() && !cursor.isNull(0)) { + name = cursor.getString(0) + } + } + if (name.isEmpty()) { + name = Uri.decode(uri.lastPathSegment) + } + var idx = name.lastIndexOf('/') + if (idx >= 0) { + require(idx < name.length - 1) { resources.getString(R.string.illegal_filename_error, name) } + name = name.substring(idx + 1) + } + val isZip = name.toLowerCase(Locale.ROOT).endsWith(".zip") + if (name.toLowerCase(Locale.ROOT).endsWith(".conf")) { + name = name.substring(0, name.length - ".conf".length) + } else { + require(isZip) { resources.getString(R.string.bad_extension_error) } + } - if (isZip) { - ZipInputStream(contentResolver.openInputStream(uri)).use { zip -> - val reader = BufferedReader(InputStreamReader(zip, StandardCharsets.UTF_8)) - var entry: ZipEntry? - while (true) { - entry = zip.nextEntry ?: break - name = entry.name - idx = name.lastIndexOf('/') - if (idx >= 0) { - if (idx >= name.length - 1) { - continue + if (isZip) { + ZipInputStream(contentResolver.openInputStream(uri)).use { zip -> + val reader = BufferedReader(InputStreamReader(zip, StandardCharsets.UTF_8)) + var entry: ZipEntry? + while (true) { + entry = zip.nextEntry ?: break + name = entry.name + idx = name.lastIndexOf('/') + if (idx >= 0) { + if (idx >= name.length - 1) { + continue + } + name = name.substring(name.lastIndexOf('/') + 1) + } + if (name.toLowerCase(Locale.ROOT).endsWith(".conf")) { + name = name.substring(0, name.length - ".conf".length) + } else { + continue + } + try { + Config.parse(reader) + } catch (e: Throwable) { + throwables.add(e) + null + }?.let { + val nameCopy = name + futureTunnels.add(async(SupervisorJob()) { Application.getTunnelManager().create(nameCopy, it) }) + } } - name = name.substring(name.lastIndexOf('/') + 1) } - if (name.toLowerCase(Locale.ROOT).endsWith(".conf")) { - name = name.substring(0, name.length - ".conf".length) + } else { + futureTunnels.add(async(SupervisorJob()) { Application.getTunnelManager().create(name, Config.parse(contentResolver.openInputStream(uri)!!)) }) + } + + if (futureTunnels.isEmpty()) { + if (throwables.size == 1) { + throw throwables[0] } else { - continue - } - try { - Config.parse(reader) - } catch (e: Exception) { - throwables.add(e) - null - }?.let { - futureTunnels.add(Application.getTunnelManager().create(name, it).toCompletableFuture()) + require(throwables.isNotEmpty()) { resources.getString(R.string.no_configs_error) } } } - } - } else { - futureTunnels.add( - Application.getTunnelManager().create( - name, - Config.parse(contentResolver.openInputStream(uri)!!) - ).toCompletableFuture() - ) - } - - if (futureTunnels.isEmpty()) { - if (throwables.size == 1) { - throw throwables[0] - } else { - require(throwables.isNotEmpty()) { resources.getString(R.string.no_configs_error) } - } - } - CompletableFuture.allOf(*futureTunnels.toTypedArray()) - }.whenComplete { future, exception -> - if (exception != null) { - onTunnelImportFinished(emptyList(), listOf(exception)) - } else { - future.whenComplete { _, _ -> - val tunnels = mutableListOf<ObservableTunnel>() - for (futureTunnel in futureTunnels) { - val tunnel: ObservableTunnel? = try { - futureTunnel.getNow(null) - } catch (e: Exception) { + val tunnels = futureTunnels.mapNotNull { + try { + it.await() + } catch (e: Throwable) { throwables.add(e) null } - - if (tunnel != null) { - tunnels.add(tunnel) - } } - onTunnelImportFinished(tunnels, throwables) + withContext(Dispatchers.Main.immediate) { onTunnelImportFinished(tunnels, throwables) } + } catch (e: Throwable) { + withContext(Dispatchers.Main.immediate) { onTunnelImportFinished(emptyList(), listOf(e)) } } } } @@ -226,7 +221,8 @@ class TunnelListFragment : BaseFragment() { override fun onSelectedTunnelChanged(oldTunnel: ObservableTunnel?, newTunnel: ObservableTunnel?) { binding ?: return - Application.getTunnelManager().tunnels.thenAccept { tunnels -> + GlobalScope.launch(Dispatchers.Main.immediate) { + val tunnels = Application.getTunnelManager().getTunnels() if (newTunnel != null) viewForTunnel(newTunnel, tunnels).setSingleSelected(true) if (oldTunnel != null) viewForTunnel(oldTunnel, tunnels).setSingleSelected(false) } @@ -268,11 +264,10 @@ class TunnelListFragment : BaseFragment() { super.onViewStateRestored(savedInstanceState) binding ?: return binding!!.fragment = this - Application.getTunnelManager().tunnels.thenAccept { tunnels -> binding!!.tunnels = tunnels } - val parent = this + GlobalScope.launch(Dispatchers.Main.immediate) { binding!!.tunnels = Application.getTunnelManager().getTunnels() } binding!!.rowConfigurationHandler = object : RowConfigurationHandler<TunnelListItemBinding, ObservableTunnel> { override fun onConfigureRow(binding: TunnelListItemBinding, item: ObservableTunnel, position: Int) { - binding.fragment = parent + binding.fragment = this@TunnelListFragment binding.root.setOnClickListener { if (actionMode == null) { selectedTunnel = item @@ -321,20 +316,24 @@ class TunnelListFragment : BaseFragment() { scaleX = 1f scaleY = 1f } - Application.getTunnelManager().tunnels.thenAccept { tunnels -> - val tunnelsToDelete = ArrayList<ObservableTunnel>() - for (position in copyCheckedItems) tunnelsToDelete.add(tunnels[position]) - val futures = tunnelsToDelete.map { it.delete().toCompletableFuture() }.toTypedArray() - CompletableFuture.allOf(*futures) - .thenApply { futures.size } - .whenComplete(this@TunnelListFragment::onTunnelDeletionFinished) + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + val tunnels = Application.getTunnelManager().getTunnels() + val tunnelsToDelete = ArrayList<ObservableTunnel>() + for (position in copyCheckedItems) tunnelsToDelete.add(tunnels[position]) + val futures = tunnelsToDelete.map { async(SupervisorJob()) { it.deleteAsync() } } + onTunnelDeletionFinished(futures.awaitAll().size, null) + } catch (e: Throwable) { + onTunnelDeletionFinished(0, e) + } } checkedItems.clear() mode.finish() true } R.id.menu_action_select_all -> { - Application.getTunnelManager().tunnels.thenAccept { tunnels -> + GlobalScope.launch(Dispatchers.Main.immediate) { + val tunnels = Application.getTunnelManager().getTunnels() for (i in 0 until tunnels.size) { setItemChecked(i, true) } diff --git a/ui/src/main/java/com/wireguard/android/model/ObservableTunnel.kt b/ui/src/main/java/com/wireguard/android/model/ObservableTunnel.kt index f8691cbb..d9d09b87 100644 --- a/ui/src/main/java/com/wireguard/android/model/ObservableTunnel.kt +++ b/ui/src/main/java/com/wireguard/android/model/ObservableTunnel.kt @@ -4,16 +4,18 @@ */ package com.wireguard.android.model +import android.util.Log import androidx.databinding.BaseObservable import androidx.databinding.Bindable import com.wireguard.android.BR import com.wireguard.android.backend.Statistics import com.wireguard.android.backend.Tunnel import com.wireguard.android.databinding.Keyed -import com.wireguard.android.util.ExceptionLoggers import com.wireguard.config.Config -import java9.util.concurrent.CompletableFuture -import java9.util.concurrent.CompletionStage +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext /** * Encapsulates the volatile and nonvolatile state of a WireGuard tunnel. @@ -30,10 +32,12 @@ class ObservableTunnel internal constructor( @Bindable override fun getName() = name - fun setNameAsync(name: String): CompletionStage<String> = if (name != this.name) - manager.setTunnelName(this, name) - else - CompletableFuture.completedFuture(this.name) + suspend fun setNameAsync(name: String): String = withContext(Dispatchers.Main.immediate) { + if (name != this@ObservableTunnel.name) + manager.setTunnelName(this@ObservableTunnel, name) + else + this@ObservableTunnel.name + } fun onNameChanged(name: String): String { this.name = name @@ -57,31 +61,42 @@ class ObservableTunnel internal constructor( return state } - fun setStateAsync(state: Tunnel.State): CompletionStage<Tunnel.State> = if (state != this.state) - manager.setTunnelState(this, state) - else - CompletableFuture.completedFuture(this.state) + suspend fun setStateAsync(state: Tunnel.State): Tunnel.State = withContext(Dispatchers.Main.immediate) { + if (state != this@ObservableTunnel.state) + manager.setTunnelState(this@ObservableTunnel, state) + else + this@ObservableTunnel.state + } @get:Bindable var config = config get() { if (field == null) - manager.getTunnelConfig(this).whenComplete(ExceptionLoggers.E) + // Opportunistically fetch this if we don't have a cached one, and rely on data bindings to update it eventually + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + manager.getTunnelConfig(this@ObservableTunnel) + } catch (e: Throwable) { + Log.println(Log.ERROR, TAG, Log.getStackTraceString(e)) + } + } return field } private set - val configAsync: CompletionStage<Config> - get() = if (config == null) - manager.getTunnelConfig(this) - else - CompletableFuture.completedFuture(config) + suspend fun getConfigAsync(): Config = withContext(Dispatchers.Main.immediate) { + config ?: manager.getTunnelConfig(this@ObservableTunnel) + } - fun setConfigAsync(config: Config): CompletionStage<Config> = if (config != this.config) - manager.setTunnelConfig(this, config) - else - CompletableFuture.completedFuture(this.config) + suspend fun setConfigAsync(config: Config): Config = withContext(Dispatchers.Main.immediate) { + this@ObservableTunnel.config.let { + if (config != it) + manager.setTunnelConfig(this@ObservableTunnel, config) + else + it + } + } fun onConfigChanged(config: Config?): Config? { this.config = config @@ -94,16 +109,26 @@ class ObservableTunnel internal constructor( var statistics: Statistics? = null get() { if (field == null || field?.isStale != false) - manager.getTunnelStatistics(this).whenComplete(ExceptionLoggers.E) + // Opportunistically fetch this if we don't have a cached one, and rely on data bindings to update it eventually + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + manager.getTunnelStatistics(this@ObservableTunnel) + } catch (e: Throwable) { + Log.println(Log.ERROR, TAG, Log.getStackTraceString(e)) + } + } return field } private set - val statisticsAsync: CompletionStage<Statistics> - get() = if (statistics == null || statistics?.isStale != false) - manager.getTunnelStatistics(this) - else - CompletableFuture.completedFuture(statistics) + suspend fun getStatisticsAsync(): Statistics = withContext(Dispatchers.Main.immediate) { + statistics.let { + if (it == null || it.isStale) + manager.getTunnelStatistics(this@ObservableTunnel) + else + it + } + } fun onStatisticsChanged(statistics: Statistics?): Statistics? { this.statistics = statistics @@ -112,5 +137,10 @@ class ObservableTunnel internal constructor( } - fun delete(): CompletionStage<Void> = manager.delete(this) + suspend fun deleteAsync() = manager.delete(this) + + + companion object { + private const val TAG = "WireGuard/ObservableTunnel" + } } diff --git a/ui/src/main/java/com/wireguard/android/model/TunnelManager.kt b/ui/src/main/java/com/wireguard/android/model/TunnelManager.kt index 5091ed3b..b06585e4 100644 --- a/ui/src/main/java/com/wireguard/android/model/TunnelManager.kt +++ b/ui/src/main/java/com/wireguard/android/model/TunnelManager.kt @@ -9,10 +9,10 @@ import android.content.BroadcastReceiver import android.content.Context import android.content.Intent import android.os.Build +import android.util.Log import androidx.databinding.BaseObservable import androidx.databinding.Bindable import com.wireguard.android.Application.Companion.get -import com.wireguard.android.Application.Companion.getAsyncWorker import com.wireguard.android.Application.Companion.getBackend import com.wireguard.android.Application.Companion.getSharedPreferences import com.wireguard.android.Application.Companion.getTunnelManager @@ -22,60 +22,64 @@ import com.wireguard.android.backend.Statistics import com.wireguard.android.backend.Tunnel import com.wireguard.android.configStore.ConfigStore import com.wireguard.android.databinding.ObservableSortedKeyedArrayList -import com.wireguard.android.util.ExceptionLoggers import com.wireguard.config.Config -import java9.util.concurrent.CompletableFuture -import java9.util.concurrent.CompletionStage -import java.util.ArrayList +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext /** * Maintains and mediates changes to the set of available WireGuard tunnels, */ class TunnelManager(private val configStore: ConfigStore) : BaseObservable() { - val tunnels = CompletableFuture<ObservableSortedKeyedArrayList<String, ObservableTunnel>>() + private val tunnels = CompletableDeferred<ObservableSortedKeyedArrayList<String, ObservableTunnel>>() private val context: Context = get() - private val delayedLoadRestoreTunnels = ArrayList<CompletableFuture<Void>>() private val tunnelMap: ObservableSortedKeyedArrayList<String, ObservableTunnel> = ObservableSortedKeyedArrayList(TunnelComparator) private var haveLoaded = false - private fun addToList(name: String, config: Config?, state: Tunnel.State): ObservableTunnel? { + private fun addToList(name: String, config: Config?, state: Tunnel.State): ObservableTunnel { val tunnel = ObservableTunnel(this, name, config, state) tunnelMap.add(tunnel) return tunnel } - fun create(name: String, config: Config?): CompletionStage<ObservableTunnel> { + suspend fun getTunnels(): ObservableSortedKeyedArrayList<String, ObservableTunnel> = tunnels.await() + + suspend fun create(name: String, config: Config?): ObservableTunnel = withContext(Dispatchers.Main.immediate) { if (Tunnel.isNameInvalid(name)) - return CompletableFuture.failedFuture(IllegalArgumentException(context.getString(R.string.tunnel_error_invalid_name))) + throw IllegalArgumentException(context.getString(R.string.tunnel_error_invalid_name)) if (tunnelMap.containsKey(name)) - return CompletableFuture.failedFuture(IllegalArgumentException(context.getString(R.string.tunnel_error_already_exists, name))) - return getAsyncWorker().supplyAsync { configStore.create(name, config!!) }.thenApply { addToList(name, it, Tunnel.State.DOWN) } + throw IllegalArgumentException(context.getString(R.string.tunnel_error_already_exists, name)) + addToList(name, withContext(Dispatchers.IO) { configStore.create(name, config!!) }, Tunnel.State.DOWN) } - fun delete(tunnel: ObservableTunnel): CompletionStage<Void> { + suspend fun delete(tunnel: ObservableTunnel) = withContext(Dispatchers.Main.immediate) { val originalState = tunnel.state val wasLastUsed = tunnel == lastUsedTunnel // Make sure nothing touches the tunnel. if (wasLastUsed) lastUsedTunnel = null tunnelMap.remove(tunnel) - return getAsyncWorker().runAsync { + try { if (originalState == Tunnel.State.UP) - getBackend().setState(tunnel, Tunnel.State.DOWN, null) + withContext(Dispatchers.IO) { getBackend().setState(tunnel, Tunnel.State.DOWN, null) } try { - configStore.delete(tunnel.name) - } catch (e: Exception) { + withContext(Dispatchers.IO) { configStore.delete(tunnel.name) } + } catch (e: Throwable) { if (originalState == Tunnel.State.UP) - getBackend().setState(tunnel, Tunnel.State.UP, tunnel.config) + withContext(Dispatchers.IO) { getBackend().setState(tunnel, Tunnel.State.UP, tunnel.config) } throw e } - }.whenComplete { _, e -> - if (e == null) - return@whenComplete + } catch (e: Throwable) { // Failure, put the tunnel back. tunnelMap.add(tunnel) if (wasLastUsed) lastUsedTunnel = tunnel + throw e } } @@ -92,14 +96,18 @@ class TunnelManager(private val configStore: ConfigStore) : BaseObservable() { getSharedPreferences().edit().remove(KEY_LAST_USED_TUNNEL).commit() } - fun getTunnelConfig(tunnel: ObservableTunnel): CompletionStage<Config> = getAsyncWorker() - .supplyAsync { configStore.load(tunnel.name) }.thenApply(tunnel::onConfigChanged) - + suspend fun getTunnelConfig(tunnel: ObservableTunnel): Config = withContext(Dispatchers.Main.immediate) { + tunnel.onConfigChanged(withContext(Dispatchers.IO) { configStore.load(tunnel.name) })!! + } fun onCreate() { - getAsyncWorker().supplyAsync { configStore.enumerate() } - .thenAcceptBoth(getAsyncWorker().supplyAsync { getBackend().runningTunnelNames }, this::onTunnelsLoaded) - .whenComplete(ExceptionLoggers.E) + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + onTunnelsLoaded(withContext(Dispatchers.IO) { configStore.enumerate() }, withContext(Dispatchers.IO) { getBackend().runningTunnelNames }) + } catch (e: Throwable) { + Log.println(Log.ERROR, TAG, Log.getStackTraceString(e)) + } + } } private fun onTunnelsLoaded(present: Iterable<String>, running: Collection<String>) { @@ -108,42 +116,38 @@ class TunnelManager(private val configStore: ConfigStore) : BaseObservable() { val lastUsedName = getSharedPreferences().getString(KEY_LAST_USED_TUNNEL, null) if (lastUsedName != null) lastUsedTunnel = tunnelMap[lastUsedName] - var toComplete: Array<CompletableFuture<Void>> - synchronized(delayedLoadRestoreTunnels) { - haveLoaded = true - toComplete = delayedLoadRestoreTunnels.toTypedArray() - delayedLoadRestoreTunnels.clear() - } - restoreState(true).whenComplete { v: Void?, t: Throwable? -> - for (f in toComplete) { - if (t == null) - f.complete(v) - else - f.completeExceptionally(t) - } - } + haveLoaded = true + restoreState(true) tunnels.complete(tunnelMap) } - fun refreshTunnelStates() { - getAsyncWorker().supplyAsync { getBackend().runningTunnelNames } - .thenAccept { running: Set<String> -> for (tunnel in tunnelMap) tunnel.onStateChanged(if (running.contains(tunnel.name)) Tunnel.State.UP else Tunnel.State.DOWN) } - .whenComplete(ExceptionLoggers.E) + private fun refreshTunnelStates() { + GlobalScope.launch(Dispatchers.Main.immediate) { + try { + val running = withContext(Dispatchers.IO) { getBackend().runningTunnelNames } + for (tunnel in tunnelMap) + tunnel.onStateChanged(if (running.contains(tunnel.name)) Tunnel.State.UP else Tunnel.State.DOWN) + } catch (e: Throwable) { + Log.println(Log.ERROR, TAG, Log.getStackTraceString(e)) + } + } } - fun restoreState(force: Boolean): CompletionStage<Void> { - if (!force && !getSharedPreferences().getBoolean(KEY_RESTORE_ON_BOOT, false)) - return CompletableFuture.completedFuture(null) - synchronized(delayedLoadRestoreTunnels) { - if (!haveLoaded) { - val f = CompletableFuture<Void>() - delayedLoadRestoreTunnels.add(f) - return f + fun restoreState(force: Boolean) { + if (!haveLoaded || (!force && !getSharedPreferences().getBoolean(KEY_RESTORE_ON_BOOT, false))) + return + val previouslyRunning = getSharedPreferences().getStringSet(KEY_RUNNING_TUNNELS, null) + ?: return + if (previouslyRunning.isEmpty()) return + GlobalScope.launch(Dispatchers.Main.immediate) { + withContext(Dispatchers.IO) { + try { + tunnelMap.filter { previouslyRunning.contains(it.name) }.map { async(SupervisorJob()) { setTunnelState(it, Tunnel.State.UP) } }.awaitAll() + } catch (e: Throwable) { + Log.println(Log.ERROR, TAG, Log.getStackTraceString(e)) + } } } - val previouslyRunning = getSharedPreferences().getStringSet(KEY_RUNNING_TUNNELS, null) - ?: return CompletableFuture.completedFuture(null) - return CompletableFuture.allOf(*tunnelMap.filter { previouslyRunning.contains(it.name) }.map { setTunnelState(it, Tunnel.State.UP).toCompletableFuture() }.toTypedArray()) } @SuppressLint("ApplySharedPref") @@ -151,16 +155,18 @@ class TunnelManager(private val configStore: ConfigStore) : BaseObservable() { getSharedPreferences().edit().putStringSet(KEY_RUNNING_TUNNELS, tunnelMap.filter { it.state == Tunnel.State.UP }.map { it.name }.toSet()).commit() } - fun setTunnelConfig(tunnel: ObservableTunnel, config: Config): CompletionStage<Config> = getAsyncWorker().supplyAsync { - getBackend().setState(tunnel, tunnel.state, config) - configStore.save(tunnel.name, config) - }.thenApply { tunnel.onConfigChanged(it) } + suspend fun setTunnelConfig(tunnel: ObservableTunnel, config: Config): Config = withContext(Dispatchers.Main.immediate) { + tunnel.onConfigChanged(withContext(Dispatchers.IO) { + getBackend().setState(tunnel, tunnel.state, config) + configStore.save(tunnel.name, config) + })!! + } - fun setTunnelName(tunnel: ObservableTunnel, name: String): CompletionStage<String> { + suspend fun setTunnelName(tunnel: ObservableTunnel, name: String): String = withContext(Dispatchers.Main.immediate) { if (Tunnel.isNameInvalid(name)) - return CompletableFuture.failedFuture(IllegalArgumentException(context.getString(R.string.tunnel_error_invalid_name))) + throw IllegalArgumentException(context.getString(R.string.tunnel_error_invalid_name)) if (tunnelMap.containsKey(name)) { - return CompletableFuture.failedFuture(IllegalArgumentException(context.getString(R.string.tunnel_error_already_exists, name))) + throw IllegalArgumentException(context.getString(R.string.tunnel_error_already_exists, name)) } val originalState = tunnel.state val wasLastUsed = tunnel == lastUsedTunnel @@ -168,34 +174,45 @@ class TunnelManager(private val configStore: ConfigStore) : BaseObservable() { if (wasLastUsed) lastUsedTunnel = null tunnelMap.remove(tunnel) - return getAsyncWorker().supplyAsync { + var throwable: Throwable? = null + var newName: String? = null + try { if (originalState == Tunnel.State.UP) - getBackend().setState(tunnel, Tunnel.State.DOWN, null) - configStore.rename(tunnel.name, name) - val newName = tunnel.onNameChanged(name) + withContext(Dispatchers.IO) { getBackend().setState(tunnel, Tunnel.State.DOWN, null) } + withContext(Dispatchers.IO) { configStore.rename(tunnel.name, name) } + newName = tunnel.onNameChanged(name) if (originalState == Tunnel.State.UP) - getBackend().setState(tunnel, Tunnel.State.UP, tunnel.config) - newName - }.whenComplete { _, e -> + withContext(Dispatchers.IO) { getBackend().setState(tunnel, Tunnel.State.UP, tunnel.config) } + } catch (e: Throwable) { + throwable = e // On failure, we don't know what state the tunnel might be in. Fix that. - if (e != null) - getTunnelState(tunnel) - // Add the tunnel back to the manager, under whatever name it thinks it has. - tunnelMap.add(tunnel) - if (wasLastUsed) - lastUsedTunnel = tunnel + getTunnelState(tunnel) } + // Add the tunnel back to the manager, under whatever name it thinks it has. + tunnelMap.add(tunnel) + if (wasLastUsed) + lastUsedTunnel = tunnel + if (throwable != null) + throw throwable + newName!! } - fun setTunnelState(tunnel: ObservableTunnel, state: Tunnel.State): CompletionStage<Tunnel.State> = tunnel.configAsync - .thenCompose { getAsyncWorker().supplyAsync { getBackend().setState(tunnel, state, it) } } - .whenComplete { newState, e -> - // Ensure onStateChanged is always called (failure or not), and with the correct state. - tunnel.onStateChanged(if (e == null) newState else tunnel.state) - if (e == null && newState == Tunnel.State.UP) - lastUsedTunnel = tunnel - saveState() - } + suspend fun setTunnelState(tunnel: ObservableTunnel, state: Tunnel.State): Tunnel.State = withContext(Dispatchers.Main.immediate) { + var newState = tunnel.state + var throwable: Throwable? = null + try { + newState = withContext(Dispatchers.IO) { getBackend().setState(tunnel, state, tunnel.getConfigAsync()) } + if (newState == Tunnel.State.UP) + lastUsedTunnel = tunnel + } catch (e: Throwable) { + throwable = e + } + tunnel.onStateChanged(newState) + saveState() + if (throwable != null) + throw throwable + newState + } class IntentReceiver : BroadcastReceiver() { override fun onReceive(context: Context, intent: Intent?) { @@ -215,20 +232,25 @@ class TunnelManager(private val configStore: ConfigStore) : BaseObservable() { else -> return } val tunnelName = intent.getStringExtra("tunnel") ?: return - manager.tunnels.thenAccept { - val tunnel = it[tunnelName] ?: return@thenAccept + GlobalScope.launch(Dispatchers.Main.immediate) { + val tunnels = manager.getTunnels() + val tunnel = tunnels[tunnelName] ?: return@launch manager.setTunnelState(tunnel, state) } } } - fun getTunnelState(tunnel: ObservableTunnel): CompletionStage<Tunnel.State> = getAsyncWorker() - .supplyAsync { getBackend().getState(tunnel) }.thenApply(tunnel::onStateChanged) + suspend fun getTunnelState(tunnel: ObservableTunnel): Tunnel.State = withContext(Dispatchers.Main.immediate) { + tunnel.onStateChanged(withContext(Dispatchers.IO) { getBackend().getState(tunnel) }) + } - fun getTunnelStatistics(tunnel: ObservableTunnel): CompletionStage<Statistics> = getAsyncWorker() - .supplyAsync { getBackend().getStatistics(tunnel) }.thenApply(tunnel::onStatisticsChanged) + suspend fun getTunnelStatistics(tunnel: ObservableTunnel): Statistics = withContext(Dispatchers.Main.immediate) { + tunnel.onStatisticsChanged(withContext(Dispatchers.IO) { getBackend().getStatistics(tunnel) })!! + } companion object { + private const val TAG = "WireGuard/TunnelManager" + private const val KEY_LAST_USED_TUNNEL = "last_used_tunnel" private const val KEY_RESTORE_ON_BOOT = "restore_on_boot" private const val KEY_RUNNING_TUNNELS = "enabled_configs" diff --git a/ui/src/main/java/com/wireguard/android/preference/KernelModuleDisablerPreference.kt b/ui/src/main/java/com/wireguard/android/preference/KernelModuleDisablerPreference.kt index 1479d7b6..6c289073 100644 --- a/ui/src/main/java/com/wireguard/android/preference/KernelModuleDisablerPreference.kt +++ b/ui/src/main/java/com/wireguard/android/preference/KernelModuleDisablerPreference.kt @@ -8,22 +8,28 @@ import android.annotation.SuppressLint import android.content.Context import android.content.Intent import android.util.AttributeSet +import android.util.Log import androidx.preference.Preference import com.wireguard.android.Application import com.wireguard.android.R import com.wireguard.android.activity.SettingsActivity import com.wireguard.android.backend.Tunnel import com.wireguard.android.backend.WgQuickBackend -import java9.util.concurrent.CompletableFuture +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext import kotlin.system.exitProcess class KernelModuleDisablerPreference(context: Context, attrs: AttributeSet?) : Preference(context, attrs) { private var state = State.UNKNOWN - init { isVisible = false - Application.getBackendAsync().thenAccept { backend -> - setState(if (backend is WgQuickBackend) State.ENABLED else State.DISABLED) + GlobalScope.launch(Dispatchers.Main.immediate) { + setState(if (Application.getBackend() is WgQuickBackend) State.ENABLED else State.DISABLED) } } @@ -40,17 +46,21 @@ class KernelModuleDisablerPreference(context: Context, attrs: AttributeSet?) : P setState(State.DISABLING) Application.getSharedPreferences().edit().putBoolean("disable_kernel_module", true).commit() } - Application.getAsyncWorker().runAsync { - Application.getTunnelManager().tunnels.thenApply { observableTunnels -> - val downings = observableTunnels.map { it.setStateAsync(Tunnel.State.DOWN).toCompletableFuture() }.toTypedArray() - CompletableFuture.allOf(*downings).thenRun { + GlobalScope.launch(Dispatchers.Main.immediate) { + val observableTunnels = Application.getTunnelManager().getTunnels() + val downings = observableTunnels.map { async(SupervisorJob()) { it.setStateAsync(Tunnel.State.DOWN) } } + try { + downings.awaitAll() + withContext(Dispatchers.IO) { val restartIntent = Intent(context, SettingsActivity::class.java) restartIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP) restartIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) Application.get().startActivity(restartIntent) exitProcess(0) } - }.join() + } catch (e: Throwable) { + Log.println(Log.ERROR, TAG, Log.getStackTraceString(e)) + } } } @@ -69,4 +79,8 @@ class KernelModuleDisablerPreference(context: Context, attrs: AttributeSet?) : P ENABLING(R.string.module_disabler_disabled_title, R.string.success_application_will_restart, false, true), DISABLING(R.string.module_disabler_enabled_title, R.string.success_application_will_restart, false, true); } + + companion object { + private const val TAG = "WireGuard/KernelModuleDisablerPreference" + } } diff --git a/ui/src/main/java/com/wireguard/android/preference/ModuleDownloaderPreference.kt b/ui/src/main/java/com/wireguard/android/preference/ModuleDownloaderPreference.kt index adf0dc27..6960733c 100644 --- a/ui/src/main/java/com/wireguard/android/preference/ModuleDownloaderPreference.kt +++ b/ui/src/main/java/com/wireguard/android/preference/ModuleDownloaderPreference.kt @@ -15,16 +15,14 @@ import com.wireguard.android.Application import com.wireguard.android.R import com.wireguard.android.activity.SettingsActivity import com.wireguard.android.util.ErrorMessages -import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import kotlin.system.exitProcess class ModuleDownloaderPreference(context: Context, attrs: AttributeSet?) : Preference(context, attrs) { private var state = State.INITIAL - private val coroutineScope = CoroutineScope(Dispatchers.Main) - override fun getSummary() = context.getString(state.messageResourceId) override fun getTitle() = context.getString(R.string.module_installer_title) @@ -32,24 +30,26 @@ class ModuleDownloaderPreference(context: Context, attrs: AttributeSet?) : Prefe @SuppressLint("ApplySharedPref") override fun onClick() { setState(State.WORKING) - coroutineScope.launch { + GlobalScope.launch(Dispatchers.Main.immediate) { try { when (withContext(Dispatchers.IO) { Application.getModuleLoader().download() }) { OsConstants.ENOENT -> setState(State.NOTFOUND) OsConstants.EXIT_SUCCESS -> { setState(State.SUCCESS) Application.getSharedPreferences().edit().remove("disable_kernel_module").commit() - CoroutineScope(Dispatchers.Default).launch { - val restartIntent = Intent(context, SettingsActivity::class.java) - restartIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP) - restartIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) - Application.get().startActivity(restartIntent) - exitProcess(0) + GlobalScope.launch(Dispatchers.Main.immediate) { + withContext(Dispatchers.IO) { + val restartIntent = Intent(context, SettingsActivity::class.java) + restartIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP) + restartIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + Application.get().startActivity(restartIntent) + exitProcess(0) + } } } else -> setState(State.FAILURE) } - } catch (e: Exception) { + } catch (e: Throwable) { setState(State.FAILURE) Toast.makeText(context, ErrorMessages[e], Toast.LENGTH_LONG).show() } diff --git a/ui/src/main/java/com/wireguard/android/preference/ToolsInstallerPreference.kt b/ui/src/main/java/com/wireguard/android/preference/ToolsInstallerPreference.kt index e9c0dc36..f9edb6e1 100644 --- a/ui/src/main/java/com/wireguard/android/preference/ToolsInstallerPreference.kt +++ b/ui/src/main/java/com/wireguard/android/preference/ToolsInstallerPreference.kt @@ -10,8 +10,8 @@ import androidx.preference.Preference import com.wireguard.android.Application import com.wireguard.android.R import com.wireguard.android.util.ToolsInstaller -import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.launch import kotlinx.coroutines.withContext @@ -21,15 +21,13 @@ import kotlinx.coroutines.withContext */ class ToolsInstallerPreference(context: Context, attrs: AttributeSet?) : Preference(context, attrs) { private var state = State.INITIAL - private val coroutineScope = CoroutineScope(Dispatchers.Main) - override fun getSummary() = context.getString(state.messageResourceId) override fun getTitle() = context.getString(R.string.tools_installer_title) override fun onAttached() { super.onAttached() - coroutineScope.launch { + GlobalScope.launch(Dispatchers.Main.immediate) { try { val state = withContext(Dispatchers.IO) { Application.getToolsInstaller().areInstalled() } when { @@ -39,7 +37,7 @@ class ToolsInstallerPreference(context: Context, attrs: AttributeSet?) : Prefere state and (ToolsInstaller.SYSTEM or ToolsInstaller.NO) == ToolsInstaller.SYSTEM or ToolsInstaller.NO -> setState(State.INITIAL_SYSTEM) else -> setState(State.INITIAL) } - } catch (_: Exception) { + } catch (_: Throwable) { setState(State.INITIAL) } } @@ -47,7 +45,7 @@ class ToolsInstallerPreference(context: Context, attrs: AttributeSet?) : Prefere override fun onClick() { setState(State.WORKING) - coroutineScope.launch { + GlobalScope.launch(Dispatchers.Main.immediate) { try { val result = withContext(Dispatchers.IO) { Application.getToolsInstaller().install() } when { @@ -55,7 +53,7 @@ class ToolsInstallerPreference(context: Context, attrs: AttributeSet?) : Prefere result and (ToolsInstaller.YES or ToolsInstaller.SYSTEM) == ToolsInstaller.YES or ToolsInstaller.SYSTEM -> setState(State.SUCCESS_SYSTEM) else -> setState(State.FAILURE) } - } catch (_: Exception) { + } catch (_: Throwable) { setState(State.FAILURE) } } diff --git a/ui/src/main/java/com/wireguard/android/preference/VersionPreference.kt b/ui/src/main/java/com/wireguard/android/preference/VersionPreference.kt index f944233b..e3eb0f95 100644 --- a/ui/src/main/java/com/wireguard/android/preference/VersionPreference.kt +++ b/ui/src/main/java/com/wireguard/android/preference/VersionPreference.kt @@ -16,8 +16,8 @@ import com.wireguard.android.R import com.wireguard.android.backend.Backend import com.wireguard.android.backend.GoBackend import com.wireguard.android.backend.WgQuickBackend -import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import java.util.Locale @@ -47,16 +47,16 @@ class VersionPreference(context: Context, attrs: AttributeSet?) : Preference(con } init { - Application.getBackendAsync().thenAccept { backend -> + GlobalScope.launch(Dispatchers.Main.immediate) { + val backend = Application.getBackend() versionSummary = getContext().getString(R.string.version_summary_checking, getBackendPrettyName(context, backend).toLowerCase(Locale.ENGLISH)) - CoroutineScope(Dispatchers.Main).launch { - versionSummary = try { - getContext().getString(R.string.version_summary, getBackendPrettyName(context, backend), withContext(Dispatchers.IO) { backend.version }) - } catch (_: Exception) { - getContext().getString(R.string.version_summary_unknown, getBackendPrettyName(context, backend).toLowerCase(Locale.ENGLISH)) - } - notifyChanged() + notifyChanged() + versionSummary = try { + getContext().getString(R.string.version_summary, getBackendPrettyName(context, backend), withContext(Dispatchers.IO) { backend.version }) + } catch (_: Throwable) { + getContext().getString(R.string.version_summary_unknown, getBackendPrettyName(context, backend).toLowerCase(Locale.ENGLISH)) } + notifyChanged() } } } diff --git a/ui/src/main/java/com/wireguard/android/preference/ZipExporterPreference.kt b/ui/src/main/java/com/wireguard/android/preference/ZipExporterPreference.kt index fe8d39a3..c1eaa9f6 100644 --- a/ui/src/main/java/com/wireguard/android/preference/ZipExporterPreference.kt +++ b/ui/src/main/java/com/wireguard/android/preference/ZipExporterPreference.kt @@ -13,13 +13,18 @@ import androidx.preference.Preference import com.google.android.material.snackbar.Snackbar import com.wireguard.android.Application import com.wireguard.android.R -import com.wireguard.android.model.ObservableTunnel +import com.wireguard.android.util.AdminKnobs import com.wireguard.android.util.BiometricAuthenticator import com.wireguard.android.util.DownloadsFileSaver -import com.wireguard.android.util.AdminKnobs import com.wireguard.android.util.ErrorMessages import com.wireguard.android.util.FragmentUtils -import java9.util.concurrent.CompletableFuture +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext import java.nio.charset.StandardCharsets import java.util.zip.ZipEntry import java.util.zip.ZipOutputStream @@ -29,52 +34,40 @@ import java.util.zip.ZipOutputStream */ class ZipExporterPreference(context: Context, attrs: AttributeSet?) : Preference(context, attrs) { private var exportedFilePath: String? = null - private fun exportZip() { - Application.getTunnelManager().tunnels.thenAccept(this::exportZip) - } - - private fun exportZip(tunnels: List<ObservableTunnel>) { - val futureConfigs = tunnels.map { it.configAsync.toCompletableFuture() }.toTypedArray() - if (futureConfigs.isEmpty()) { - exportZipComplete(null, IllegalArgumentException( - context.getString(R.string.no_tunnels_error))) - return - } - CompletableFuture.allOf(*futureConfigs) - .whenComplete { _, exception -> - Application.getAsyncWorker().supplyAsync { - if (exception != null) throw exception - val outputFile = DownloadsFileSaver.save(context, "wireguard-export.zip", "application/zip", true) - try { - ZipOutputStream(outputFile.outputStream).use { zip -> - for (i in futureConfigs.indices) { - zip.putNextEntry(ZipEntry(tunnels[i].name + ".conf")) - zip.write(futureConfigs[i].getNow(null)!!.toWgQuickString().toByteArray(StandardCharsets.UTF_8)) - } - zip.closeEntry() + GlobalScope.launch(Dispatchers.Main.immediate) { + val tunnels = Application.getTunnelManager().getTunnels() + try { + exportedFilePath = withContext(Dispatchers.IO) { + val configs = tunnels.map { async(SupervisorJob()) { it.getConfigAsync() } }.awaitAll() + if (configs.isEmpty()) { + throw IllegalArgumentException(context.getString(R.string.no_tunnels_error)) + } + val outputFile = DownloadsFileSaver.save(context, "wireguard-export.zip", "application/zip", true) + try { + ZipOutputStream(outputFile.outputStream).use { zip -> + for (i in configs.indices) { + zip.putNextEntry(ZipEntry(tunnels[i].name + ".conf")) + zip.write(configs[i].toWgQuickString().toByteArray(StandardCharsets.UTF_8)) } - } catch (e: Exception) { - outputFile.delete() - throw e + zip.closeEntry() } - outputFile.fileName - }.whenComplete(this::exportZipComplete) + } catch (e: Throwable) { + outputFile.delete() + throw e + } + outputFile.fileName } - } - - private fun exportZipComplete(filePath: String?, throwable: Throwable?) { - if (throwable != null) { - val error = ErrorMessages[throwable] - val message = context.getString(R.string.zip_export_error, error) - Log.e(TAG, message, throwable) - Snackbar.make( - FragmentUtils.getPrefActivity(this).findViewById(android.R.id.content), - message, Snackbar.LENGTH_LONG).show() - isEnabled = true - } else { - exportedFilePath = filePath - notifyChanged() + notifyChanged() + } catch (e: Throwable) { + val error = ErrorMessages[e] + val message = context.getString(R.string.zip_export_error, error) + Log.e(TAG, message, e) + Snackbar.make( + FragmentUtils.getPrefActivity(this@ZipExporterPreference).findViewById(android.R.id.content), + message, Snackbar.LENGTH_LONG).show() + isEnabled = true + } } } diff --git a/ui/src/main/java/com/wireguard/android/util/AsyncWorker.kt b/ui/src/main/java/com/wireguard/android/util/AsyncWorker.kt deleted file mode 100644 index a6e5d4be..00000000 --- a/ui/src/main/java/com/wireguard/android/util/AsyncWorker.kt +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright © 2017-2020 WireGuard LLC. All Rights Reserved. - * SPDX-License-Identifier: Apache-2.0 - */ -package com.wireguard.android.util - -import android.os.Handler -import java9.util.concurrent.CompletableFuture -import java9.util.concurrent.CompletionStage -import java.util.concurrent.Executor - -/** - * Helper class for running asynchronous tasks and ensuring they are completed on the main thread. - */ - -class AsyncWorker(private val executor: Executor, private val handler: Handler) { - - fun runAsync(run: () -> Unit): CompletionStage<Void> { - val future = CompletableFuture<Void>() - executor.execute { - try { - run() - handler.post { future.complete(null) } - } catch (t: Throwable) { - handler.post { future.completeExceptionally(t) } - } - } - return future - } - - fun <T> supplyAsync(get: () -> T?): CompletionStage<T> { - val future = CompletableFuture<T>() - executor.execute { - try { - val result = get() - handler.post { future.complete(result) } - } catch (t: Throwable) { - handler.post { future.completeExceptionally(t) } - } - } - return future - } -} diff --git a/ui/src/main/java/com/wireguard/android/util/ExceptionLoggers.kt b/ui/src/main/java/com/wireguard/android/util/ExceptionLoggers.kt deleted file mode 100644 index 4470134c..00000000 --- a/ui/src/main/java/com/wireguard/android/util/ExceptionLoggers.kt +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright © 2017-2019 WireGuard LLC. All Rights Reserved. - * SPDX-License-Identifier: Apache-2.0 - */ -package com.wireguard.android.util - -import android.util.Log -import java9.util.function.BiConsumer - -/** - * Helpers for logging exceptions from asynchronous tasks. These can be passed to - * `CompletionStage.whenComplete()` at the end of an asynchronous future chain. - */ -enum class ExceptionLoggers(private val priority: Int) : BiConsumer<Any?, Throwable?> { - D(Log.DEBUG), E(Log.ERROR); - - override fun accept(result: Any?, throwable: Throwable?) { - if (throwable != null) - Log.println(Log.ERROR, TAG, Log.getStackTraceString(throwable)) - else if (priority <= Log.DEBUG) - Log.println(priority, TAG, "Future completed successfully") - } - - companion object { - private const val TAG = "WireGuard/ExceptionLoggers" - } -} |