* IMPORTANT ENTRY POINT 1: activity is shown to the user
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Uri data = getIntent().getData();
boolean directLogin = data != null && data.toString().startsWith(getString(R.string.login_data_own_scheme));
if (savedInstanceState == null && !directLogin) {
onboarding.launchFirstRunIfNeeded(this);
}
onlyAdd = getIntent().getBooleanExtra(KEY_ONLY_ADD, false);
// delete cookies for webView
deleteCookies();
// Workaround, for fixing a problem with Android Library Support v7 19
//getWindow().requestFeature(Window.FEATURE_NO_TITLE);
if (getSupportActionBar() != null) {
getSupportActionBar().hide();
getSupportActionBar().setDisplayHomeAsUpEnabled(false);
getSupportActionBar().setDisplayShowHomeEnabled(false);
getSupportActionBar().setDisplayShowTitleEnabled(false);
}
mIsFirstAuthAttempt = true;
/// init activity state
mAccountMgr = AccountManager.get(this);
/// get input values
mAction = getIntent().getByteExtra(EXTRA_ACTION, ACTION_CREATE);
Bundle extras = getIntent().getExtras();
if (extras != null) {
mAccount = extras.getParcelable(EXTRA_ACCOUNT);
}
if (savedInstanceState != null) {
mWaitingForOpId = savedInstanceState.getLong(KEY_WAITING_FOR_OP_ID);
mIsFirstAuthAttempt = savedInstanceState.getBoolean(KEY_AUTH_IS_FIRST_ATTEMPT_TAG);
}
String webloginUrl = null;
boolean webViewLoginMethod;
if (getIntent().getBooleanExtra(EXTRA_USE_PROVIDER_AS_WEBLOGIN, false)) {
webViewLoginMethod = true;
webloginUrl = getString(R.string.provider_registration_server);
} else {
webViewLoginMethod = !TextUtils.isEmpty(getResources().getString(R.string.webview_login_url));
showWebViewLoginUrl = getResources().getBoolean(R.bool.show_server_url_input);
}
/// load user interface
if (webViewLoginMethod) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
setContentView(R.layout.account_setup_webview);
mLoginWebView = findViewById(R.id.login_webview);
initWebViewLogin(webloginUrl, false);
} else {
setContentView(R.layout.account_setup);
/// initialize general UI elements
initOverallUi();
/// initialize block to be moved to single Fragment to check server and get info about it
/// initialize block to be moved to single Fragment to retrieve and validate credentials
initAuthorizationPreFragment(savedInstanceState);
}
initServerPreFragment(savedInstanceState);
}
private void deleteCookies() {
try {
CookieSyncManager.createInstance(this);
CookieManager cookieManager = CookieManager.getInstance();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
cookieManager.removeAllCookies(null);
} else {
cookieManager.removeAllCookie();
}
} catch (AndroidRuntimeException e) {
Log_OC.e(TAG, e.getMessage());
}
}
private static String getWebLoginUserAgent() {
return Build.MANUFACTURER.substring(0, 1).toUpperCase(Locale.getDefault()) +
Build.MANUFACTURER.substring(1).toLowerCase(Locale.getDefault()) + " " + Build.MODEL + " (Android)";
}
@SuppressLint("SetJavaScriptEnabled")
private void initWebViewLogin(String baseURL, boolean useGenericUserAgent) {
mLoginWebView.setVisibility(View.GONE);
final ProgressBar progressBar = findViewById(R.id.login_webview_progress_bar);
mLoginWebView.getSettings().setAllowFileAccess(false);
mLoginWebView.getSettings().setJavaScriptEnabled(true);
mLoginWebView.getSettings().setDomStorageEnabled(true);
if (useGenericUserAgent) {
mLoginWebView.getSettings().setUserAgentString(MainApp.getUserAgent());
} else {
mLoginWebView.getSettings().setUserAgentString(getWebLoginUserAgent());
}
mLoginWebView.getSettings().setSaveFormData(false);
mLoginWebView.getSettings().setSavePassword(false);
FidoDialogOptions.Builder dialogOptionsBuilder = FidoDialogOptions.builder();
dialogOptionsBuilder.setShowSdkLogo(true);
dialogOptionsBuilder.setTheme(R.style.FidoDialog);
webViewFidoU2fBridge = WebViewFidoBridge.createInstanceForWebView(this, mLoginWebView, dialogOptionsBuilder);
WebauthnDialogOptions.Builder webauthnOptionsBuilder = WebauthnDialogOptions.builder();
webauthnOptionsBuilder.setShowSdkLogo(true);
webauthnOptionsBuilder.setAllowSkipPin(true);
webauthnOptionsBuilder.setTheme(R.style.FidoDialog);
webViewWebauthnBridge = WebViewWebauthnBridge.createInstanceForWebView(this, mLoginWebView, webauthnOptionsBuilder);
Map
* See {@link super#onSaveInstanceState(Bundle)}
*/
@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
//Log_OC.e(TAG, "onSaveInstanceState init" );
super.onSaveInstanceState(outState);
/// global state
outState.putLong(KEY_WAITING_FOR_OP_ID, mWaitingForOpId);
outState.putBoolean(KEY_IS_SSL_CONN, mServerInfo.mIsSslConn);
outState.putString(KEY_HOST_URL_TEXT, mServerInfo.mBaseUrl);
if (mServerInfo.mVersion != null) {
outState.putString(KEY_OC_VERSION, mServerInfo.mVersion.getVersion());
}
outState.putString(KEY_SERVER_AUTH_METHOD, mServerInfo.mAuthMethod.name());
/// authentication
outState.putBoolean(KEY_AUTH_IS_FIRST_ATTEMPT_TAG, mIsFirstAuthAttempt);
/// AsyncTask (User and password)
if (mAsyncTask != null) {
mAsyncTask.cancel(true);
outState.putBoolean(KEY_ASYNC_TASK_IN_PROGRESS, true);
} else {
outState.putBoolean(KEY_ASYNC_TASK_IN_PROGRESS, false);
}
mAsyncTask = null;
}
@Override
public void onRestoreInstanceState(@NonNull Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
// AsyncTask
boolean inProgress = savedInstanceState.getBoolean(KEY_ASYNC_TASK_IN_PROGRESS);
if (inProgress) {
String username = savedInstanceState.getString(KEY_USERNAME);
String password = savedInstanceState.getString(KEY_PASSWORD);
OwnCloudCredentials credentials = OwnCloudCredentialsFactory.newBasicCredentials(username, password);
accessRootFolder(credentials);
}
}
/**
* The redirection triggered by the OAuth authentication server as response to the GET AUTHORIZATION request is
* caught here.
*
* To make this possible, this activity needs to be qualified with android:launchMode = "singleTask" in the
* AndroidManifest.xml file.
*/
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
Log_OC.d(TAG, "onNewIntent()");
if (intent.getBooleanExtra(FirstRunActivity.EXTRA_EXIT, false)) {
super.finish();
}
onlyAdd = intent.getBooleanExtra(KEY_ONLY_ADD, false);
// Passcode
PassCodeManager passCodeManager = new PassCodeManager(preferences);
passCodeManager.onActivityStarted(this);
Uri data = intent.getData();
if (data != null && data.toString().startsWith(getString(R.string.login_data_own_scheme))) {
if (!getResources().getBoolean(R.bool.multiaccount_support) &&
accountManager.getAccounts().length == 1) {
Toast.makeText(this, R.string.no_mutliple_accounts_allowed, Toast.LENGTH_LONG).show();
finish();
return;
} else {
parseAndLoginFromWebView(data.toString());
}
}
if (intent.getBooleanExtra(EXTRA_USE_PROVIDER_AS_WEBLOGIN, false)) {
setContentView(R.layout.account_setup_webview);
mLoginWebView = findViewById(R.id.login_webview);
initWebViewLogin(getString(R.string.provider_registration_server), true);
}
}
/**
* The redirection triggered by the OAuth authentication server as response to the GET AUTHORIZATION, and deferred
* in {@link #onNewIntent(Intent)}, is processed here.
*/
@Override
protected void onResume() {
super.onResume();
// bind to Operations Service
mOperationsServiceConnection = new OperationsServiceConnection();
if (!bindService(new Intent(this, OperationsService.class),
mOperationsServiceConnection,
Context.BIND_AUTO_CREATE)) {
DisplayUtils.showSnackMessage(findViewById(R.id.scroll), R.string.error_cant_bind_to_operations_service);
finish();
}
if (mOperationsServiceBinder != null) {
doOnResumeAndBound();
}
}
@Override
protected void onPause() {
if (mOperationsServiceBinder != null) {
mOperationsServiceBinder.removeOperationListener(this);
}
super.onPause();
}
@Override
protected void onDestroy() {
if (mOperationsServiceConnection != null) {
unbindService(mOperationsServiceConnection);
mOperationsServiceBinder = null;
}
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR);
super.onDestroy();
}
private void checkOcServer() {
String uri;
if (mHostUrlInput != null && !mHostUrlInput.getText().toString().isEmpty()) {
uri = mHostUrlInput.getText().toString().trim();
} else {
uri = mServerInfo.mBaseUrl;
}
mServerInfo = new GetServerInfoOperation.ServerInfo();
if (uri.length() != 0) {
if (mHostUrlInput != null) {
uri = AuthenticatorUrlUtils.stripIndexPhpOrAppsFiles(uri);
mHostUrlInput.setText(uri);
}
// Handle internationalized domain names
try {
uri = DisplayUtils.convertIdn(uri, true);
} catch (IllegalArgumentException ex) {
// Let Owncloud library check the error of the malformed URI
Log_OC.e(TAG, "Error converting internationalized domain name " + uri, ex);
}
if (mHostUrlInput != null) {
mServerStatusText = getResources().getString(R.string.auth_testing_connection);
mServerStatusIcon = R.drawable.progress_small;
showServerStatus();
}
// TODO maybe do this via async task
Intent getServerInfoIntent = new Intent();
getServerInfoIntent.setAction(OperationsService.ACTION_GET_SERVER_INFO);
getServerInfoIntent.putExtra(OperationsService.EXTRA_SERVER_URL,
AuthenticatorUrlUtils.normalizeUrlSuffix(uri));
if (mOperationsServiceBinder != null) {
mWaitingForOpId = mOperationsServiceBinder.queueNewOperation(getServerInfoIntent);
} else {
Log_OC.e(TAG, "Server check tried with OperationService unbound!");
}
}
}
/**
* Tests the credentials entered by the user performing a check of existence on the root folder of the ownCloud
* server.
*/
private void checkBasicAuthorization(@Nullable String webViewUsername, @Nullable String webViewPassword) {
// be gentle with the user
IndeterminateProgressDialog dialog = IndeterminateProgressDialog.newInstance(R.string.auth_trying_to_login,
true);
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.add(dialog, WAIT_DIALOG_TAG);
ft.commitAllowingStateLoss();
// validate credentials accessing the root folder
OwnCloudCredentials credentials = OwnCloudCredentialsFactory.newBasicCredentials(webViewUsername,
webViewPassword);
accessRootFolder(credentials);
}
private void accessRootFolder(OwnCloudCredentials credentials) {
mAsyncTask = new AuthenticatorAsyncTask(this);
Object[] params = {mServerInfo.mBaseUrl, credentials};
mAsyncTask.execute(params);
}
/**
* Callback method invoked when a RemoteOperation executed by this Activity finishes.
*
* Dispatches the operation flow to the right method.
*/
@Override
public void onRemoteOperationFinish(RemoteOperation operation, RemoteOperationResult result) {
if (operation instanceof GetServerInfoOperation) {
if (operation.hashCode() == mWaitingForOpId) {
onGetServerInfoFinish(result);
} // else nothing ; only the last check operation is considered;
// multiple can be started if the user amends a URL quickly
} else if (operation instanceof GetUserInfoRemoteOperation) {
onGetUserNameFinish(result);
}
}
private void onGetUserNameFinish(RemoteOperationResult result) {
mWaitingForOpId = Long.MAX_VALUE;
if (result.isSuccess()) {
boolean success = false;
if (mAction == ACTION_CREATE) {
success = createAccount(result);
} else {
try {
updateAccountAuthentication();
success = true;
} catch (AccountNotFoundException e) {
Log_OC.e(TAG, "Account " + mAccount + " was removed!", e);
DisplayUtils.showSnackMessage(findViewById(R.id.scroll), R.string.auth_account_does_not_exist);
finish();
}
}
if (success) {
finish();
}
} else {
// TODO check
int statusText = result.getCode() == ResultCode.MAINTENANCE_MODE ? R.string.maintenance_mode : R.string.auth_fail_get_user_name;
updateStatusIconFailUserName(statusText);
showAuthStatus();
Log_OC.e(TAG, "Access to user name failed: " + result.getLogMessage());
}
}
/**
* Processes the result of the server check performed when the user finishes the enter of the server URL.
*
* @param result Result of the check.
*/
private void onGetServerInfoFinish(RemoteOperationResult result) {
/// update activity state
mWaitingForOpId = Long.MAX_VALUE;
if (result.isSuccess()) {
/// SUCCESS means:
// 1. connection succeeded, and we know if it's SSL or not
// 2. server is installed
// 3. we got the server version
// 4. we got the authentication method required by the server
mServerInfo = (GetServerInfoOperation.ServerInfo) (result.getData().get(0));
// show outdated warning
if (getResources().getBoolean(R.bool.show_outdated_server_warning) &&
MainApp.OUTDATED_SERVER_VERSION.isSameMajorVersion(mServerInfo.mVersion) &&
!mServerInfo.hasExtendedSupport) {
DisplayUtils.showServerOutdatedSnackbar(this, Snackbar.LENGTH_INDEFINITE);
}
if (webViewUser != null && !webViewUser.isEmpty() &&
webViewPassword != null && !webViewPassword.isEmpty()) {
checkBasicAuthorization(webViewUser, webViewPassword);
} else {
new Thread(() -> {
OwnCloudClient client = OwnCloudClientFactory.createOwnCloudClient(Uri.parse(mServerInfo.mBaseUrl),
this,
true);
RemoteOperationResult remoteOperationResult = new GetCapabilitiesRemoteOperation().execute(client);
if (remoteOperationResult.isSuccess() &&
remoteOperationResult.getData() != null &&
remoteOperationResult.getData().size() > 0) {
OCCapability capability = (OCCapability) remoteOperationResult.getData().get(0);
try {
primaryColor = Color.parseColor(capability.getServerColor());
} catch (IllegalArgumentException e) {
// falls back to primary color
}
}
}).start();
setContentView(R.layout.account_setup_webview);
mLoginWebView = findViewById(R.id.login_webview);
initWebViewLogin(mServerInfo.mBaseUrl + WEB_LOGIN, false);
}
} else {
updateServerStatusIconAndText(result);
showServerStatus();
}
// very special case (TODO: move to a common place for all the remote operations)
if (result.getCode() == ResultCode.SSL_RECOVERABLE_PEER_UNVERIFIED) {
showUntrustedCertDialog(result);
}
}
/**
* Chooses the right icon and text to show to the user for the received operation result.
*
* @param result Result of a remote operation performed in this activity
*/
private void updateServerStatusIconAndText(RemoteOperationResult result) {
mServerStatusIcon = R.drawable.ic_alert; // the most common case in the switch below
switch (result.getCode()) {
case OK_SSL:
mServerStatusIcon = R.drawable.ic_lock_white;
mServerStatusText = getResources().getString(R.string.auth_secure_connection);
break;
case OK_NO_SSL:
case OK:
if (mHostUrlInput.getText().toString().trim().toLowerCase(Locale.ROOT).startsWith(HTTP_PROTOCOL)) {
mServerStatusText = getResources().getString(R.string.auth_connection_established);
mServerStatusIcon = R.drawable.ic_ok;
} else {
mServerStatusText = getResources().getString(R.string.auth_nossl_plain_ok_title);
mServerStatusIcon = R.drawable.ic_lock_open_white;
}
break;
case NO_NETWORK_CONNECTION:
mServerStatusIcon = R.drawable.no_network;
mServerStatusText = getResources().getString(R.string.auth_no_net_conn_title);
break;
case SSL_RECOVERABLE_PEER_UNVERIFIED:
mServerStatusText = getResources().getString(R.string.auth_ssl_unverified_server_title);
break;
case BAD_OC_VERSION:
mServerStatusText = getResources().getString(R.string.auth_bad_oc_version_title);
break;
case WRONG_CONNECTION:
mServerStatusText = getResources().getString(R.string.auth_wrong_connection_title);
break;
case TIMEOUT:
mServerStatusText = getResources().getString(R.string.auth_timeout_title);
break;
case INCORRECT_ADDRESS:
mServerStatusText = getResources().getString(R.string.auth_incorrect_address_title);
break;
case SSL_ERROR:
mServerStatusText = getResources().getString(R.string.auth_ssl_general_error_title);
break;
case UNAUTHORIZED:
mServerStatusText = getResources().getString(R.string.auth_unauthorized);
break;
case HOST_NOT_AVAILABLE:
mServerStatusText = getResources().getString(R.string.auth_unknown_host_title);
break;
case INSTANCE_NOT_CONFIGURED:
mServerStatusText = getResources().getString(R.string.auth_not_configured_title);
break;
case FILE_NOT_FOUND:
mServerStatusText = getResources().getString(R.string.auth_incorrect_path_title);
break;
case OAUTH2_ERROR:
mServerStatusText = getResources().getString(R.string.auth_oauth_error);
break;
case OAUTH2_ERROR_ACCESS_DENIED:
mServerStatusText = getResources().getString(R.string.auth_oauth_error_access_denied);
break;
case UNHANDLED_HTTP_CODE:
mServerStatusText = getResources().getString(R.string.auth_unknown_error_http_title);
break;
case UNKNOWN_ERROR:
if (result.getException() != null &&
!TextUtils.isEmpty(result.getException().getMessage())) {
mServerStatusText = getResources().getString(
R.string.auth_unknown_error_exception_title,
result.getException().getMessage()
);
} else {
mServerStatusText = getResources().getString(R.string.auth_unknown_error_title);
}
break;
case OK_REDIRECT_TO_NON_SECURE_CONNECTION:
mServerStatusIcon = R.drawable.ic_lock_open_white;
mServerStatusText = getResources().getString(R.string.auth_redirect_non_secure_connection_title);
break;
case MAINTENANCE_MODE:
mServerStatusText = getResources().getString(R.string.maintenance_mode);
break;
case UNTRUSTED_DOMAIN:
mServerStatusText = getResources().getString(R.string.untrusted_domain);
break;
default:
mServerStatusText = EMPTY_STRING;
mServerStatusIcon = 0;
break;
}
}
/**
* Chooses the right icon and text to show to the user for the received operation result.
*
* @param result Result of a remote operation performed in this activity
*/
private void updateAuthStatusIconAndText(RemoteOperationResult result) {
mAuthStatusIcon = R.drawable.ic_alert; // the most common case in the switch below
switch (result.getCode()) {
case OK_SSL:
mAuthStatusIcon = R.drawable.ic_lock_white;
mAuthStatusText = getResources().getString(R.string.auth_secure_connection);
break;
case OK_NO_SSL:
case OK:
if (showWebViewLoginUrl) {
if (mHostUrlInput.getText().toString().trim().toLowerCase(Locale.ROOT).startsWith(HTTP_PROTOCOL)) {
mAuthStatusText = getResources().getString(R.string.auth_connection_established);
mAuthStatusIcon = R.drawable.ic_ok;
} else {
mAuthStatusText = getResources().getString(R.string.auth_nossl_plain_ok_title);
mAuthStatusIcon = R.drawable.ic_lock_open_white;
}
}
break;
case NO_NETWORK_CONNECTION:
mAuthStatusIcon = R.drawable.no_network;
mAuthStatusText = getResources().getString(R.string.auth_no_net_conn_title);
break;
case SSL_RECOVERABLE_PEER_UNVERIFIED:
mAuthStatusText = getResources().getString(R.string.auth_ssl_unverified_server_title);
break;
case TIMEOUT:
mAuthStatusText = getResources().getString(R.string.auth_timeout_title);
break;
case HOST_NOT_AVAILABLE:
mAuthStatusText = getResources().getString(R.string.auth_unknown_host_title);
break;
case ACCOUNT_NOT_NEW:
mAuthStatusText = getString(R.string.auth_account_not_new);
if (!showWebViewLoginUrl) {
DisplayUtils.showErrorAndFinishActivity(this, mAuthStatusText);
}
break;
case UNHANDLED_HTTP_CODE:
default:
mAuthStatusText = ErrorMessageAdapter.getErrorCauseMessage(result, null, getResources());
if (!showWebViewLoginUrl) {
DisplayUtils.showErrorAndFinishActivity(this, mAuthStatusText);
}
}
}
private void updateStatusIconFailUserName(int failedStatusText) {
mAuthStatusIcon = R.drawable.ic_alert;
mAuthStatusText = getResources().getString(failedStatusText);
}
/**
* Processes the result of the access check performed to try the user credentials.
*
* Creates a new account through the AccountManager.
*
* @param result Result of the operation.
*/
@Override
public void onAuthenticatorTaskCallback(RemoteOperationResult result) {
mWaitingForOpId = Long.MAX_VALUE;
dismissWaitingDialog();
mAsyncTask = null;
if (result.isSuccess()) {
Log_OC.d(TAG, "Successful access - time to save the account");
boolean success = false;
if (mAction == ACTION_CREATE) {
success = createAccount(result);
} else {
try {
updateAccountAuthentication();
success = true;
} catch (AccountNotFoundException e) {
Log_OC.e(TAG, "Account " + mAccount + " was removed!", e);
DisplayUtils.showSnackMessage(findViewById(R.id.scroll), R.string.auth_account_does_not_exist);
finish();
}
}
// Reset webView
webViewPassword = null;
webViewUser = null;
deleteCookies();
if (success) {
accountManager.setCurrentOwnCloudAccount(mAccount.name);
if (!onlyAdd) {
Intent i = new Intent(this, FileDisplayActivity.class);
i.setAction(FileDisplayActivity.RESTART);
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(i);
}
} else {
// init webView again
mLoginWebView.setVisibility(View.GONE);
setContentView(R.layout.account_setup);
initOverallUi();
mAuthStatusView = findViewById(R.id.auth_status_text);
mHostUrlInput.setText(mServerInfo.mBaseUrl);
mServerStatusView.setVisibility(View.GONE);
showAuthStatus();
}
} else if (result.isServerFail() || result.isException()) {
/// server errors or exceptions in authorization take to requiring a new check of the server
mServerInfo = new GetServerInfoOperation.ServerInfo();
// update status icon and text
updateServerStatusIconAndText(result);
showServerStatus();
mAuthStatusIcon = 0;
mAuthStatusText = EMPTY_STRING;
// very special case (TODO: move to a common place for all the remote operations)
if (result.getCode() == ResultCode.SSL_RECOVERABLE_PEER_UNVERIFIED) {
showUntrustedCertDialog(result);
}
} else { // authorization fail due to client side - probably wrong credentials
mLoginWebView = findViewById(R.id.login_webview);
if (mLoginWebView != null) {
initWebViewLogin(mServerInfo.mBaseUrl + WEB_LOGIN, false);
DisplayUtils.showSnackMessage(this, mLoginWebView, R.string.auth_access_failed,
result.getLogMessage());
} else {
DisplayUtils.showSnackMessage(this, R.string.auth_access_failed, result.getLogMessage());
// init webView again
mLoginWebView.setVisibility(View.GONE);
updateAuthStatusIconAndText(result);
}
// reset webview
webViewPassword = null;
webViewUser = null;
deleteCookies();
Log_OC.d(TAG, "Access failed: " + result.getLogMessage());
}
}
/**
* Updates the authentication token.
*
* Sets the proper response so that the AccountAuthenticator that started this activity saves a new authorization
* token for mAccount.
*
* Kills the session kept by OwnCloudClientManager so that a new one will created with the new credentials when
* needed.
*/
private void updateAccountAuthentication() throws AccountNotFoundException {
Bundle response = new Bundle();
response.putString(AccountManager.KEY_ACCOUNT_NAME, mAccount.name);
response.putString(AccountManager.KEY_ACCOUNT_TYPE, mAccount.type);
response.putString(AccountManager.KEY_AUTHTOKEN, webViewPassword);
mAccountMgr.setPassword(mAccount, webViewPassword);
// remove managed clients for this account to enforce creation with fresh credentials
OwnCloudAccount ocAccount = new OwnCloudAccount(mAccount, this);
OwnCloudClientManagerFactory.getDefaultSingleton().removeClientFor(ocAccount);
setAccountAuthenticatorResult(response);
Intent intent = new Intent();
intent.putExtras(response);
setResult(RESULT_OK, intent);
}
/**
* Creates a new account through the Account Authenticator that started this activity.
*
* This makes the account permanent.
*
* TODO Decide how to name the OAuth accounts
*/
@SuppressFBWarnings("DMI")
@SuppressLint("TrulyRandom")
protected boolean createAccount(RemoteOperationResult authResult) {
String accountType = MainApp.getAccountType(this);
// create and save new ownCloud account
String lastPermanentLocation = authResult.getLastPermanentLocation();
if (lastPermanentLocation != null) {
mServerInfo.mBaseUrl = AuthenticatorUrlUtils.trimWebdavSuffix(lastPermanentLocation);
}
Uri uri = Uri.parse(mServerInfo.mBaseUrl);
// used for authenticate on every login/network connection, determined by first login (weblogin/old login)
// can be anything: email, name, name with whitespaces
String loginName = webViewUser;
String accountName = com.owncloud.android.lib.common.accounts.AccountUtils.buildAccountName(uri, loginName);
Account newAccount = new Account(accountName, accountType);
if (accountManager.exists(newAccount)) {
// fail - not a new account, but an existing one; disallow
RemoteOperationResult result = new RemoteOperationResult(ResultCode.ACCOUNT_NOT_NEW);
updateAuthStatusIconAndText(result);
showAuthStatus();
Log_OC.d(TAG, result.getLogMessage());
return false;
} else {
mAccount = newAccount;
mAccountMgr.addAccountExplicitly(mAccount, webViewPassword, null);
// add the new account as default in preferences, if there is none already
User defaultAccount = accountManager.getUser();
if (defaultAccount.isAnonymous()) {
SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(this).edit();
editor.putString("select_oc_account", accountName);
editor.apply();
}
/// prepare result to return to the Authenticator
// TODO check again what the Authenticator makes with it; probably has the same
// effect as addAccountExplicitly, but it's not well done
final Intent intent = new Intent();
intent.putExtra(AccountManager.KEY_ACCOUNT_TYPE, accountType);
intent.putExtra(AccountManager.KEY_ACCOUNT_NAME, mAccount.name);
intent.putExtra(AccountManager.KEY_USERDATA, loginName);
/// add user data to the new account; TODO probably can be done in the last parameter
// addAccountExplicitly, or in KEY_USERDATA
mAccountMgr.setUserData(mAccount, Constants.KEY_OC_VERSION, mServerInfo.mVersion.getVersion());
mAccountMgr.setUserData(mAccount, Constants.KEY_OC_BASE_URL, mServerInfo.mBaseUrl);
ArrayList