Extract account logic from BaseActivity into a mixin

src/main/java/com/nextcloud/client/account/UserAccountManager.java

@@ -20,6 +20,8 @@
 package com.nextcloud.client.account;
 
 import android.accounts.Account;
+import android.app.Activity;
+import android.content.Intent;
 
 import com.nextcloud.java.util.Optional;
 import com.owncloud.android.datamodel.OCFile;
@@ -141,4 +143,12 @@ static String getUsername(Account account) {
         }
     }
 
+    /**
+     * Launch account registration activity.
+     *
+     * This method returns immediately. Authenticator activity will be launched asynchronously.
+     *
+     * @param activity Activity used to launch authenticator flow via {@link Activity#startActivity(Intent)}
+     */
+    void startAccountCreation(Activity activity);
 }

src/main/java/com/nextcloud/client/account/UserAccountManagerImpl.java

@@ -22,6 +22,7 @@
 
 import android.accounts.Account;
 import android.accounts.AccountManager;
+import android.app.Activity;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.preference.PreferenceManager;
@@ -376,4 +377,15 @@ public boolean migrateUserId() {
     private String getAccountType() {
         return context.getString(R.string.account_type);
     }
+
+    @Override
+    public void startAccountCreation(final Activity activity) {
+        accountManager.addAccount(getAccountType(),
+                                  null,
+                                  null,
+                                  null,
+                                  activity,
+                                  null,
+                                  null);
+    }
 }

src/main/java/com/nextcloud/client/core/AsyncRunner.kt

@@ -28,5 +28,14 @@ typealias OnErrorCallback = (Throwable) -> Unit
  * It is provided as an alternative for heavy, platform specific and virtually untestable [android.os.AsyncTask]
  */
 interface AsyncRunner {
+
+    /**
+     * Post a background task and return immediately returning task cancellation interface.
+     *
+     * @param task Task function returning result T; error shall be signalled by throwing an exception.
+     * @param onResult Callback called when task function returns a result
+     * @param onError Callback called when task function throws an exception
+     * @return Cancellable interface, allowing to cancel running task.
+     */
     fun <T> post(task: () -> T, onResult: OnResultCallback<T>? = null, onError: OnErrorCallback? = null): Cancellable
 }

src/main/java/com/nextcloud/client/core/Cancellable.kt

@@ -19,6 +19,20 @@
  */
 package com.nextcloud.client.core
 
+/**
+ * Interface allowing cancellation of a running task.
+ * Once must be careful when cancelling a non-idempotent task,
+ * as cancellation does not guarantee a task termination.
+ * One trivial case would be a task finished and cancelled
+ * before result delivery.
+ *
+ * @see [com.nextcloud.client.core.AsyncRunner]
+ */
 interface Cancellable {
+
+    /**
+     * Cancel running task. Task termination is not guaranteed, but the result
+     * shall not be delivered.
+     */
     fun cancel()
 }

src/main/java/com/nextcloud/client/di/ActivityInjector.java

@@ -23,7 +23,6 @@
 import android.app.Activity;
 import android.app.Application;
 import android.os.Bundle;
-
 import androidx.fragment.app.FragmentActivity;
 import androidx.fragment.app.FragmentManager;
 import dagger.android.AndroidInjection;
@@ -72,4 +71,3 @@ public final void onActivityDestroyed(Activity activity) {
         // not needed
     }
 }
-

src/main/java/com/nextcloud/client/mixins/ActivityMixin.kt

@@ -0,0 +1,40 @@
+/*
+ * Nextcloud Android client application
+ *
+ * @author Chris Narkiewicz
+ * Copyright (C) 2020 Chris Narkiewicz <hello@ezaquarii.com>
+ * Copyright (C) 2020 Nextcloud GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.nextcloud.client.mixins
+
+import android.content.Intent
+import android.os.Bundle
+
+/**
+ * Interface allowing to implement part of [android.app.Activity] logic as
+ * a mix-in.
+ */
+interface ActivityMixin {
+    fun onNewIntent(intent: Intent) { /* no-op */ }
+    fun onSaveInstanceState(outState: Bundle) { /* no-op */ }
+    fun onCreate(savedInstanceState: Bundle?) { /* no-op */ }
+    fun onRestart() { /* no-op */ }
+    fun onStart() { /* no-op */ }
+    fun onResume() { /* no-op */ }
+    fun onPause() { /* no-op */ }
+    fun onStop() { /* no-op */ }
+    fun onDestroy() { /* no-op */ }
+}

src/main/java/com/nextcloud/client/mixins/MixinRegistry.kt

@@ -0,0 +1,88 @@
+/*
+ * Nextcloud Android client application
+ *
+ * @author Chris Narkiewicz
+ * Copyright (C) 2020 Chris Narkiewicz <hello@ezaquarii.com>
+ * Copyright (C) 2020 Nextcloud GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.nextcloud.client.mixins
+
+import android.content.Intent
+import android.os.Bundle
+
+/**
+ * Mix-in registry allows forwards lifecycle calls to all
+ * registered mix-ins.
+ *
+ * Once instantiated, all [android.app.Activity] lifecycle methods
+ * must call relevant registry companion methods.
+ *
+ * Calling the registry from [android.app.Application.ActivityLifecycleCallbacks] is
+ * not possible as not all callbacks are supported by this interface.
+ */
+class MixinRegistry : ActivityMixin {
+
+    private val mixins = mutableListOf<ActivityMixin>()
+
+    fun add(vararg mixins: ActivityMixin) {
+        mixins.forEach { this.mixins.add(it) }
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        mixins.forEach { it.onNewIntent(intent) }
+    }
+
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        mixins.forEach { it.onSaveInstanceState(outState) }
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        mixins.forEach { it.onCreate(savedInstanceState) }
+    }
+
+    override fun onRestart() {
+        super.onRestart()
+        mixins.forEach { it.onRestart() }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        mixins.forEach { it.onStart() }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        mixins.forEach { it.onResume() }
+    }
+
+    override fun onPause() {
+        super.onPause()
+        mixins.forEach { it.onPause() }
+    }
+
+    override fun onStop() {
+        super.onStop()
+        mixins.forEach { it.onStop() }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        mixins.forEach { it.onDestroy() }
+    }
+}

src/main/java/com/nextcloud/client/mixins/Package.md

@@ -0,0 +1,10 @@
+# Package com.nextcloud.client.mixins
+
+This package provides utilities and interfaces 
+allowing implementation of UI logic as mix-ins.
+
+Mix-ins allow encapsulation of non-visual logic
+as classes facilitating composition over inheritance.
+
+For more information about mix-in concept, please
+refer to [article on Wikipedia](https://en.wikipedia.org/wiki/Mixin).

src/main/java/com/nextcloud/client/mixins/SessionMixin.kt

@@ -0,0 +1,133 @@
+/*
+ * Nextcloud Android client application
+ *
+ * @author Chris Narkiewicz
+ * Copyright (C) 2020 Chris Narkiewicz <hello@ezaquarii.com>
+ * Copyright (C) 2020 Nextcloud GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.nextcloud.client.mixins
+
+import android.accounts.Account
+import android.app.Activity
+import android.content.ContentResolver
+import android.content.Intent
+import android.os.Bundle
+import com.nextcloud.client.account.User
+import com.nextcloud.client.account.UserAccountManager
+import com.nextcloud.java.util.Optional
+import com.owncloud.android.datamodel.FileDataStorageManager
+import com.owncloud.android.lib.resources.status.OCCapability
+import com.owncloud.android.ui.activity.BaseActivity
+
+/**
+ * Session mixin collects all account / user handling logic currently
+ * spread over various activities.
+ *
+ * It is an intermediary step facilitating comprehensive rework of
+ * account handling logic.
+ */
+class SessionMixin constructor(
+    private val activity: Activity,
+    private val contentResolver: ContentResolver,
+    private val accountManager: UserAccountManager
+) : ActivityMixin {
+
+    private companion object {
+        private val TAG = BaseActivity::class.java.simpleName
+    }
+
+    var currentAccount: Account? = null
+        private set
+    var storageManager: FileDataStorageManager? = null
+        private set
+    var capabilities: OCCapability? = null
+        private set
+
+    fun setAccount(account: Account?) {
+        val validAccount = account != null && accountManager.setCurrentOwnCloudAccount(account.name)
+        if (validAccount) {
+            currentAccount = account
+        } else {
+            swapToDefaultAccount()
+        }
+
+        currentAccount?.let {
+            val storageManager = FileDataStorageManager(currentAccount, contentResolver)
+            this.storageManager = storageManager
+            this.capabilities = storageManager.getCapability(it.name)
+        }
+    }
+
+    fun setUser(user: User) {
+        setAccount(user.toPlatformAccount())
+    }
+
+    fun getUser(): Optional<User> = when (val it = this.currentAccount) {
+        null -> Optional.empty()
+        else -> accountManager.getUser(it.name)
+    }
+
+    /**
+     * Tries to swap the current ownCloud [Account] for other valid and existing.
+     *
+     * If no valid ownCloud [Account] exists, then the user is requested
+     * to create a new ownCloud [Account].
+     */
+    private fun swapToDefaultAccount() {
+        // default to the most recently used account
+        val newAccount = accountManager.currentAccount
+        if (newAccount == null) {
+            // no account available: force account creation
+            startAccountCreation()
+        } else {
+            currentAccount = newAccount
+        }
+    }
+
+    /**
+     * Launches the account creation activity.
+     */
+    fun startAccountCreation() {
+        accountManager.startAccountCreation(activity)
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        val current = accountManager.currentAccount
+        val currentAccount = this.currentAccount
+        if (current != null && currentAccount != null && !currentAccount.name.equals(current.name)) {
+            this.currentAccount = current
+        }
+    }
+
+    /**
+     *  Since ownCloud {@link Account} can be managed from the system setting menu, the existence of the {@link
+     *  Account} associated to the instance must be checked every time it is restarted.
+     */
+    override fun onRestart() {
+        super.onRestart()
+        val validAccount = currentAccount != null && accountManager.exists(currentAccount)
+        if (!validAccount) {
+            swapToDefaultAccount()
+        }
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val account = accountManager.currentAccount
+        setAccount(account)
+    }
+}

src/main/java/com/nextcloud/client/onboarding/FirstRunActivity.java

@@ -72,8 +72,6 @@ public class FirstRunActivity extends BaseActivity implements ViewPager.OnPageCh
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
-        enableAccountHandling = false;
-
         super.onCreate(savedInstanceState);
         setContentView(R.layout.first_run_activity);