Add comments

[pub/Android/ownCloud.git] / src / com / owncloud / android / authentication / AccountAuthenticator.java

diff --git a/src/com/owncloud/android/authentication/AccountAuthenticator.java b/src/com/owncloud/android/authentication/AccountAuthenticator.java
index d6acbbb..15d758f 100644 (file)
--- a/src/com/owncloud/android/authentication/AccountAuthenticator.java
+++ b/src/com/owncloud/android/authentication/AccountAuthenticator.java
@@ -1,123 +1,127 @@
-/* ownCloud Android client application\r
- *   Copyright (C) 2012  Bartek Przybylski\r
- *   Copyright (C) 2012-2013 ownCloud Inc.\r
- *\r
- *   This program is free software: you can redistribute it and/or modify\r
- *   it under the terms of the GNU General Public License as published by\r
- *   the Free Software Foundation, either version 2 of the License, or\r
- *   (at your option) any later version.\r
- *\r
- *   This program is distributed in the hope that it will be useful,\r
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
- *   GNU General Public License for more details.\r
- *\r
- *   You should have received a copy of the GNU General Public License\r
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.\r
- *\r
- */\r
-\r
-package com.owncloud.android.authentication;\r
-\r
-\r
-import android.accounts.*;\r
-import android.content.Context;\r
-import android.content.Intent;\r
-import android.os.Bundle;\r
-import android.util.Log;\r
-\r
-\r
-/**\r
- *  Authenticator for ownCloud accounts.\r
- * \r
- *  Controller class accessed from the system AccountManager, providing integration of ownCloud accounts with the Android system.\r
- * \r
- *  TODO - better separation in operations for OAuth-capable and regular ownCloud accounts.\r
- *  TODO - review completeness \r
- * \r
- * @author David A. Velasco\r
- */\r
-public class AccountAuthenticator extends AbstractAccountAuthenticator {\r
-    /**\r
-     * Is used by android system to assign accounts to authenticators. Should be\r
-     * used by application and all extensions.\r
-     */\r
-    public static final String ACCOUNT_TYPE = "owncloud";\r
-    public static final String AUTHORITY = "org.owncloud";\r
-    public static final String AUTH_TOKEN_TYPE = "org.owncloud";\r
-    public static final String AUTH_TOKEN_TYPE_PASSWORD = "owncloud.password";\r
-    public static final String AUTH_TOKEN_TYPE_ACCESS_TOKEN = "owncloud.oauth2.access_token";\r
-    public static final String AUTH_TOKEN_TYPE_REFRESH_TOKEN = "owncloud.oauth2.refresh_token";\r
-\r
-    public static final String KEY_AUTH_TOKEN_TYPE = "authTokenType";\r
-    public static final String KEY_REQUIRED_FEATURES = "requiredFeatures";\r
-    public static final String KEY_LOGIN_OPTIONS = "loginOptions";\r
-    public static final String KEY_ACCOUNT = "account";\r
-    /**\r
-     * Value under this key should handle path to webdav php script. Will be\r
-     * removed and usage should be replaced by combining\r
-     * {@link com.owncloud.android.authentication.AuthenticatorActivity.KEY_OC_BASE_URL} and\r
-     * {@link com.owncloud.android.utils.OwnCloudVersion}\r
-     * \r
-     * @deprecated\r
-     */\r
-    public static final String KEY_OC_URL = "oc_url";\r
-    /**\r
-     * Version should be 3 numbers separated by dot so it can be parsed by\r
-     * {@link com.owncloud.android.utils.OwnCloudVersion}\r
-     */\r
-    public static final String KEY_OC_VERSION = "oc_version";\r
-    /**\r
-     * Base url should point to owncloud installation without trailing / ie:\r
-     * http://server/path or https://owncloud.server\r
-     */\r
-    public static final String KEY_OC_BASE_URL = "oc_base_url";\r
-    /**\r
-     * Flag signaling if the ownCloud server can be accessed with OAuth2 access tokens.\r
-     */\r
-    public static final String KEY_SUPPORTS_OAUTH2 = "oc_supports_oauth2";\r
-    \r
-    private static final String TAG = AccountAuthenticator.class.getSimpleName();\r
-    \r
-    private Context mContext;\r
-\r
-    public AccountAuthenticator(Context context) {\r
-        super(context);\r
-        mContext = context;\r
-    }\r
-\r
-    /**\r
-     * {@inheritDoc}\r
-     */\r
-    @Override\r
-    public Bundle addAccount(AccountAuthenticatorResponse response,\r
-            String accountType, String authTokenType,\r
-            String[] requiredFeatures, Bundle options)\r
-            throws NetworkErrorException {\r
-        Log.i(TAG, "Adding account with type " + accountType\r
-                + " and auth token " + authTokenType);\r
-        try {\r
-            validateAccountType(accountType);\r
-        } catch (AuthenticatorException e) {\r
-            Log.e(TAG, "Failed to validate account type " + accountType + ": "\r
-                    + e.getMessage());\r
-            e.printStackTrace();\r
-            return e.getFailureBundle();\r
-        }\r
-        final Intent intent = new Intent(mContext, AuthenticatorActivity.class);\r
-        intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response);\r
-        intent.putExtra(KEY_AUTH_TOKEN_TYPE, authTokenType);\r
-        intent.putExtra(KEY_REQUIRED_FEATURES, requiredFeatures);\r
-        intent.putExtra(KEY_LOGIN_OPTIONS, options);\r
-        intent.putExtra(AuthenticatorActivity.EXTRA_ACTION, AuthenticatorActivity.ACTION_CREATE);\r
-\r
-        setIntentFlags(intent);\r
-        \r
-        final Bundle bundle = new Bundle();\r
-        bundle.putParcelable(AccountManager.KEY_INTENT, intent);\r
-        return bundle;\r
-    }\r
-\r
+/* ownCloud Android client application
+ *   Copyright (C) 2012  Bartek Przybylski
+ *   Copyright (C) 2012-2013 ownCloud Inc.
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License version 2,
+ *   as published by the Free Software Foundation.
+ *
+ *   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 General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package com.owncloud.android.authentication;
+
+import com.owncloud.android.MainApp;
+import com.owncloud.android.R;
+
+import android.accounts.*;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Handler;
+import android.widget.Toast;
+
+import com.owncloud.android.lib.common.accounts.AccountTypeUtils;
+import com.owncloud.android.utils.Log_OC;
+
+
+/**
+ *  Authenticator for ownCloud accounts.
+ * 
+ *  Controller class accessed from the system AccountManager, providing integration of ownCloud accounts with the Android system.
+ * 
+ *  TODO - better separation in operations for OAuth-capable and regular ownCloud accounts.
+ *  TODO - review completeness 
+ * 
+ * @author David A. Velasco
+ */
+public class AccountAuthenticator extends AbstractAccountAuthenticator {
+    
+    /**
+     * Is used by android system to assign accounts to authenticators. Should be
+     * used by application and all extensions.
+     */
+    public static final String KEY_AUTH_TOKEN_TYPE = "authTokenType";
+    public static final String KEY_REQUIRED_FEATURES = "requiredFeatures";
+    public static final String KEY_LOGIN_OPTIONS = "loginOptions";
+    public static final String KEY_ACCOUNT = "account";
+    
+    private static final String TAG = AccountAuthenticator.class.getSimpleName();
+    
+    private Context mContext;
+    
+    private Handler mHandler;
+
+    public AccountAuthenticator(Context context) {
+        super(context);
+        mContext = context;
+        mHandler = new Handler();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Bundle addAccount(AccountAuthenticatorResponse response,
+            String accountType, String authTokenType,
+            String[] requiredFeatures, Bundle options)
+            throws NetworkErrorException {
+        Log_OC.i(TAG, "Adding account with type " + accountType
+                + " and auth token " + authTokenType);
+        
+        final Bundle bundle = new Bundle();
+        
+        AccountManager accountManager = AccountManager.get(mContext);
+        Account[] accounts = accountManager.getAccountsByType(MainApp.getAccountType());
+        
+        if (mContext.getResources().getBoolean(R.bool.multiaccount_support) || accounts.length < 1) {
+            try {
+                validateAccountType(accountType);
+            } catch (AuthenticatorException e) {
+                Log_OC.e(TAG, "Failed to validate account type " + accountType + ": "
+                        + e.getMessage());
+                e.printStackTrace();
+                return e.getFailureBundle();
+            }
+            
+            final Intent intent = new Intent(mContext, AuthenticatorActivity.class);
+            intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response);
+            intent.putExtra(KEY_AUTH_TOKEN_TYPE, authTokenType);
+            intent.putExtra(KEY_REQUIRED_FEATURES, requiredFeatures);
+            intent.putExtra(KEY_LOGIN_OPTIONS, options);
+            intent.putExtra(AuthenticatorActivity.EXTRA_ACTION, AuthenticatorActivity.ACTION_CREATE);
+
+            setIntentFlags(intent);
+            
+            bundle.putParcelable(AccountManager.KEY_INTENT, intent);
+        
+        } else {
+
+            // Return an error
+            bundle.putInt(AccountManager.KEY_ERROR_CODE, AccountManager.ERROR_CODE_UNSUPPORTED_OPERATION);
+            final String message = String.format(mContext.getString(R.string.auth_unsupported_multiaccount), mContext.getString(R.string.app_name)); 
+            bundle.putString(AccountManager.KEY_ERROR_MESSAGE, message);
+           
+            mHandler.post(new Runnable() {
+
+                @Override
+                public void run() {
+                    Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show();
+                }
+            });
+            
+        }
+        
+        return bundle;
+    }
+

     /**\r
      * {@inheritDoc}\r
      */\r
     /**\r
      * {@inheritDoc}\r
      */\r


@@ -127,7 +131,7 @@ public class AccountAuthenticator extends AbstractAccountAuthenticator {
         try {\r
             validateAccountType(account.type);\r
         } catch (AuthenticatorException e) {\r
         try {\r
             validateAccountType(account.type);\r
         } catch (AuthenticatorException e) {\r

-            Log.e(TAG, "Failed to validate account type " + account.type + ": "\r
+            Log_OC.e(TAG, "Failed to validate account type " + account.type + ": "\r

                     + e.getMessage());\r
             e.printStackTrace();\r
             return e.getFailureBundle();\r
                     + e.getMessage());\r
             e.printStackTrace();\r
             return e.getFailureBundle();\r


@@ -151,112 +155,111 @@ public class AccountAuthenticator extends AbstractAccountAuthenticator {
         return null;\r
     }\r
 \r
         return null;\r
     }\r
 \r

-    /**\r
-     * {@inheritDoc}\r
-     */\r
-    @Override\r
-    public Bundle getAuthToken(AccountAuthenticatorResponse response,\r
-            Account account, String authTokenType, Bundle options)\r
-            throws NetworkErrorException {\r
-        /// validate parameters\r
-        try {\r
-            validateAccountType(account.type);\r
-            validateAuthTokenType(authTokenType);\r
-        } catch (AuthenticatorException e) {\r
-            Log.e(TAG, "Failed to validate account type " + account.type + ": "\r
-                    + e.getMessage());\r
-            e.printStackTrace();\r
-            return e.getFailureBundle();\r
-        }\r
-        \r
-        /// check if required token is stored\r
-        final AccountManager am = AccountManager.get(mContext);\r
-        String accessToken;\r
-        if (authTokenType.equals(AUTH_TOKEN_TYPE_PASSWORD)) {\r
-            accessToken = am.getPassword(account);\r
-        } else {\r
-            accessToken = am.peekAuthToken(account, authTokenType);\r
-        }\r
-        if (accessToken != null) {\r
-            final Bundle result = new Bundle();\r
-            result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);\r
-            result.putString(AccountManager.KEY_ACCOUNT_TYPE, ACCOUNT_TYPE);\r
-            result.putString(AccountManager.KEY_AUTHTOKEN, accessToken);\r
-            return result;\r
-        }\r
-        \r
-        /// if not stored, return Intent to access the AuthenticatorActivity and UPDATE the token for the account\r
-        final Intent intent = new Intent(mContext, AuthenticatorActivity.class);\r
-        intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response);\r
-        intent.putExtra(KEY_AUTH_TOKEN_TYPE, authTokenType);\r
-        intent.putExtra(KEY_LOGIN_OPTIONS, options);\r
-        intent.putExtra(AuthenticatorActivity.EXTRA_ACCOUNT, account);\r
-        intent.putExtra(AuthenticatorActivity.EXTRA_ACTION, AuthenticatorActivity.ACTION_UPDATE_TOKEN);\r
-        \r
-\r
-        final Bundle bundle = new Bundle();\r
-        bundle.putParcelable(AccountManager.KEY_INTENT, intent);\r
-        return bundle;\r
-    }\r
-\r
-    @Override\r
-    public String getAuthTokenLabel(String authTokenType) {\r
-        return null;\r
-    }\r
-\r
-    @Override\r
-    public Bundle hasFeatures(AccountAuthenticatorResponse response,\r
-            Account account, String[] features) throws NetworkErrorException {\r
-        final Bundle result = new Bundle();\r
-        result.putBoolean(AccountManager.KEY_BOOLEAN_RESULT, true);\r
-        return result;\r
-    }\r
-\r
-    @Override\r
-    public Bundle updateCredentials(AccountAuthenticatorResponse response,\r
-            Account account, String authTokenType, Bundle options)\r
-            throws NetworkErrorException {\r
-        final Intent intent = new Intent(mContext, AuthenticatorActivity.class);\r
-        intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE,\r
-                response);\r
-        intent.putExtra(KEY_ACCOUNT, account);\r
-        intent.putExtra(KEY_AUTH_TOKEN_TYPE, authTokenType);\r
-        intent.putExtra(KEY_LOGIN_OPTIONS, options);\r
-        setIntentFlags(intent);\r
-\r
-        final Bundle bundle = new Bundle();\r
-        bundle.putParcelable(AccountManager.KEY_INTENT, intent);\r
-        return bundle;\r
-    }\r
-\r
-    @Override\r
-    public Bundle getAccountRemovalAllowed(\r
-            AccountAuthenticatorResponse response, Account account)\r
-            throws NetworkErrorException {\r
-        return super.getAccountRemovalAllowed(response, account);\r
-    }\r
-\r
-    private void setIntentFlags(Intent intent) {\r
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);\r
-        //intent.addFlags(Intent.FLAG_ACTIVITY_MULTIPLE_TASK);\r
-        //intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY); // incompatible with the authorization code grant in OAuth\r
-        intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);\r
-        intent.addFlags(Intent.FLAG_FROM_BACKGROUND);\r
-    }\r
-\r
-    private void validateAccountType(String type)\r
-            throws UnsupportedAccountTypeException {\r
-        if (!type.equals(ACCOUNT_TYPE)) {\r
-            throw new UnsupportedAccountTypeException();\r
-        }\r
-    }\r
-\r
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Bundle getAuthToken(AccountAuthenticatorResponse response,
+            Account account, String authTokenType, Bundle options)
+            throws NetworkErrorException {
+        /// validate parameters
+        try {
+            validateAccountType(account.type);
+            validateAuthTokenType(authTokenType);
+        } catch (AuthenticatorException e) {
+            Log_OC.e(TAG, "Failed to validate account type " + account.type + ": "
+                    + e.getMessage());
+            e.printStackTrace();
+            return e.getFailureBundle();
+        }
+        
+        /// check if required token is stored
+        final AccountManager am = AccountManager.get(mContext);
+        String accessToken;
+        if (authTokenType.equals(AccountTypeUtils.getAuthTokenTypePass(MainApp.getAccountType()))) {
+            accessToken = am.getPassword(account);
+        } else {
+            accessToken = am.peekAuthToken(account, authTokenType);
+        }
+        if (accessToken != null) {
+            final Bundle result = new Bundle();
+            result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);
+            result.putString(AccountManager.KEY_ACCOUNT_TYPE, MainApp.getAccountType());
+            result.putString(AccountManager.KEY_AUTHTOKEN, accessToken);
+            return result;
+        }
+        
+        /// if not stored, return Intent to access the AuthenticatorActivity and UPDATE the token for the account
+        final Intent intent = new Intent(mContext, AuthenticatorActivity.class);
+        intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response);
+        intent.putExtra(KEY_AUTH_TOKEN_TYPE, authTokenType);
+        intent.putExtra(KEY_LOGIN_OPTIONS, options);
+        intent.putExtra(AuthenticatorActivity.EXTRA_ACCOUNT, account);
+        intent.putExtra(AuthenticatorActivity.EXTRA_ACTION, AuthenticatorActivity.ACTION_UPDATE_EXPIRED_TOKEN);
+        
+
+        final Bundle bundle = new Bundle();
+        bundle.putParcelable(AccountManager.KEY_INTENT, intent);
+        return bundle;
+    }
+
+    @Override
+    public String getAuthTokenLabel(String authTokenType) {
+        return null;
+    }
+
+    @Override
+    public Bundle hasFeatures(AccountAuthenticatorResponse response,
+            Account account, String[] features) throws NetworkErrorException {
+        final Bundle result = new Bundle();
+        result.putBoolean(AccountManager.KEY_BOOLEAN_RESULT, true);
+        return result;
+    }
+
+    @Override
+    public Bundle updateCredentials(AccountAuthenticatorResponse response,
+            Account account, String authTokenType, Bundle options)
+            throws NetworkErrorException {
+        final Intent intent = new Intent(mContext, AuthenticatorActivity.class);
+        intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE,
+                response);
+        intent.putExtra(KEY_ACCOUNT, account);
+        intent.putExtra(KEY_AUTH_TOKEN_TYPE, authTokenType);
+        intent.putExtra(KEY_LOGIN_OPTIONS, options);
+        setIntentFlags(intent);
+
+        final Bundle bundle = new Bundle();
+        bundle.putParcelable(AccountManager.KEY_INTENT, intent);
+        return bundle;
+    }
+
+    @Override
+    public Bundle getAccountRemovalAllowed(
+            AccountAuthenticatorResponse response, Account account)
+            throws NetworkErrorException {
+        return super.getAccountRemovalAllowed(response, account);
+    }
+
+    private void setIntentFlags(Intent intent) {
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
+        intent.addFlags(Intent.FLAG_FROM_BACKGROUND);
+    }
+
+    private void validateAccountType(String type)
+            throws UnsupportedAccountTypeException {
+        if (!type.equals(MainApp.getAccountType())) {
+            throw new UnsupportedAccountTypeException();
+        }
+    }
+

     private void validateAuthTokenType(String authTokenType)\r
             throws UnsupportedAuthTokenTypeException {\r
     private void validateAuthTokenType(String authTokenType)\r
             throws UnsupportedAuthTokenTypeException {\r

-        if (!authTokenType.equals(AUTH_TOKEN_TYPE) &&\r
-            !authTokenType.equals(AUTH_TOKEN_TYPE_PASSWORD) &&\r
-            !authTokenType.equals(AUTH_TOKEN_TYPE_ACCESS_TOKEN) &&\r
-            !authTokenType.equals(AUTH_TOKEN_TYPE_REFRESH_TOKEN) ) {\r
+        if (!authTokenType.equals(MainApp.getAuthTokenType()) &&\r
+            !authTokenType.equals(AccountTypeUtils.getAuthTokenTypePass(MainApp.getAccountType())) &&\r
+            !authTokenType.equals(AccountTypeUtils.getAuthTokenTypeAccessToken(MainApp.getAccountType())) &&\r
+            !authTokenType.equals(AccountTypeUtils.getAuthTokenTypeRefreshToken(MainApp.getAccountType())) &&
+            !authTokenType.equals(AccountTypeUtils.getAuthTokenTypeSamlSessionCookie(MainApp.getAccountType()))) {\r

             throw new UnsupportedAuthTokenTypeException();\r
         }\r
     }\r
             throw new UnsupportedAuthTokenTypeException();\r
         }\r
     }\r