* IMPORTANT ENTRY POINT 1: activity is shown to the user
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
//Log_OC.e(TAG, "onCreate init");
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 showLegacyLogin;
if (getIntent().getBooleanExtra(EXTRA_USE_PROVIDER_AS_WEBLOGIN, false)) {
webViewLoginMethod = true;
webloginUrl = getString(R.string.provider_registration_server);
showLegacyLogin = false;
} else {
webViewLoginMethod = !TextUtils.isEmpty(getResources().getString(R.string.webview_login_url));
showWebViewLoginUrl = getResources().getBoolean(R.bool.show_server_url_input);
showLegacyLogin = true;
}
if (webViewLoginMethod) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
/// load user interface
if (!webViewLoginMethod) {
setContentView(R.layout.account_setup);
/// initialize general UI elements
initOverallUi();
findViewById(R.id.centered_refresh_button).setOnClickListener(v -> checkOcServer());
findViewById(R.id.embedded_refresh_button).setOnClickListener(v -> checkOcServer());
/// 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);
} else {
setContentView(R.layout.account_setup_webview);
mLoginWebView = findViewById(R.id.login_webview);
initWebViewLogin(webloginUrl, showLegacyLogin, false);
}
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 showLegacyLogin, 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);
webViewFidoBridge = WebViewFidoBridge.createInstanceForWebView(this, mLoginWebView);
Map
* See {@link super#onSaveInstanceState(Bundle)}
*/
@Override
protected void onSaveInstanceState(Bundle outState) {
//Log_OC.e(TAG, "onSaveInstanceState init" );
super.onSaveInstanceState(outState);
/// global state
outState.putLong(KEY_WAITING_FOR_OP_ID, mWaitingForOpId);
if (!webViewLoginMethod) {
/// Server PRE-fragment state
outState.putString(KEY_SERVER_STATUS_TEXT, mServerStatusText);
outState.putInt(KEY_SERVER_STATUS_ICON, mServerStatusIcon);
outState.putBoolean(KEY_SERVER_CHECKED, mServerIsChecked);
outState.putBoolean(KEY_SERVER_VALID, mServerIsValid);
/// Authentication PRE-fragment state
outState.putBoolean(KEY_PASSWORD_EXPOSED, isPasswordVisible());
outState.putInt(KEY_AUTH_STATUS_ICON, mAuthStatusIcon);
outState.putString(KEY_AUTH_STATUS_TEXT, mAuthStatusText);
outState.putString(KEY_AUTH_TOKEN, mAuthToken);
}
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 (!webViewLoginMethod) {
outState.putString(KEY_USERNAME, mUsernameInput.getText().toString().trim());
outState.putString(KEY_PASSWORD, mPasswordInput.getText().toString());
}
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;
//Log_OC.e(TAG, "onSaveInstanceState end" );
}
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
mServerIsChecked = savedInstanceState.getBoolean(KEY_SERVER_CHECKED, false);
// 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)) {
webViewLoginMethod = true;
setContentView(R.layout.account_setup_webview);
mLoginWebView = findViewById(R.id.login_webview);
initWebViewLogin(getString(R.string.provider_registration_server), false, 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();
if (!webViewLoginMethod) {
// bound here to avoid spurious changes triggered by Android on device rotations
mHostUrlInput.setOnFocusChangeListener(this);
mHostUrlInput.addTextChangedListener(mHostUrlInputWatcher);
String dataString = getIntent().getDataString();
if (dataString != null) {
try {
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 {
populateLoginFields(dataString);
}
} catch (IllegalArgumentException e) {
DisplayUtils.showSnackMessage(findViewById(R.id.scroll), R.string.auth_illegal_login_used);
Log_OC.e(TAG, "Illegal login data URL used, no Login pre-fill!", e);
}
}
}
// 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);
}
if (!webViewLoginMethod) {
mHostUrlInput.removeTextChangedListener(mHostUrlInputWatcher);
mHostUrlInput.setOnFocusChangeListener(null);
}
super.onPause();
}
@Override
protected void onDestroy() {
mHostUrlInputWatcher = null;
if (mOperationsServiceConnection != null) {
unbindService(mOperationsServiceConnection);
mOperationsServiceBinder = null;
}
if (webViewLoginMethod) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR);
}
super.onDestroy();
}
/**
* Handles the change of focus on the text inputs for the server URL and the password
*/
public void onFocusChange(View view, boolean hasFocus) {
if (view.getId() == R.id.host_url_input) {
if (!hasFocus) {
onUrlInputFocusLost();
} else {
showRefreshButton(false);
}
} else if (view.getId() == R.id.account_password) {
onPasswordFocusChanged(hasFocus);
}
}
/**
* Handles changes in focus on the text input for the server URL.
*
* IMPORTANT ENTRY POINT 2: When (!hasFocus), user wrote the server URL and changed to other field. The operation to
* check the existence of the server in the entered URL is started.
*
* When hasFocus: user 'comes back' to write again the server URL.
*/
private void onUrlInputFocusLost() {
if (!mServerInfo.mBaseUrl.equals(
AuthenticatorUrlUtils.normalizeUrl(mHostUrlInput.getText().toString(), mServerInfo.mIsSslConn))) {
// check server again only if the user changed something in the field
checkOcServer();
} else {
mOkButton.setEnabled(mServerIsValid);
showRefreshButton(!mServerIsValid);
}
}
private void checkOcServer() {
String uri;
if (mHostUrlInput != null && !mHostUrlInput.getText().toString().isEmpty()) {
uri = mHostUrlInput.getText().toString().trim();
mOkButton.setEnabled(false);
showRefreshButton(false);
} else {
uri = mServerInfo.mBaseUrl;
}
mServerIsValid = false;
mServerIsChecked = false;
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();
}
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!");
}
} else {
mServerStatusText = EMPTY_STRING;
mServerStatusIcon = 0;
if (!webViewLoginMethod) {
showServerStatus();
}
}
}
/**
* Handles changes in focus on the text input for the password (basic authorization).
*
* When (hasFocus), the button to toggle password visibility is shown.
*
* When (!hasFocus), the button is made invisible and the password is hidden.
*
* @param hasFocus 'True' if focus is received, 'false' if is lost
*/
private void onPasswordFocusChanged(boolean hasFocus) {
if (hasFocus) {
showViewPasswordButton();
} else {
hidePassword();
hidePasswordButton();
}
}
private void showViewPasswordButton() {
int drawable = R.drawable.ic_show;
if (isPasswordVisible()) {
drawable = R.drawable.ic_hide;
}
mPasswordInput.setCompoundDrawablesWithIntrinsicBounds(0, 0, drawable, 0);
}
private boolean isPasswordVisible() {
return ((mPasswordInput.getInputType() & InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD) ==
InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
}
private void hidePasswordButton() {
mPasswordInput.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0);
}
private void showPassword() {
mPasswordInput.setInputType(
InputType.TYPE_CLASS_TEXT |
InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD |
InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS
);
showViewPasswordButton();
}
private void hidePassword() {
mPasswordInput.setInputType(
InputType.TYPE_CLASS_TEXT |
InputType.TYPE_TEXT_VARIATION_PASSWORD |
InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS
);
showViewPasswordButton();
}
/**
* Checks the credentials of the user in the root of the ownCloud server before creating a new local account.
*
* For basic authorization, a check of existence of the root folder is performed.
*
* For OAuth, starts the flow to get an access token; the credentials test is postponed until it is available.
*
* IMPORTANT ENTRY POINT 4
*/
public void onOkClick() {
// this check should be unnecessary
if (mServerInfo.mVersion == null ||
!mServerInfo.mVersion.isVersionValid() ||
TextUtils.isEmpty(mServerInfo.mBaseUrl)) {
mServerStatusIcon = R.drawable.ic_alert;
mServerStatusText = getResources().getString(R.string.auth_wtf_reenter_URL);
showServerStatus();
mOkButton.setEnabled(false);
return;
}
checkBasicAuthorization(null, null);
}
/**
* 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) {
/// get basic credentials entered by user
String username;
String password;
if (!webViewLoginMethod) {
username = mUsernameInput.getText().toString().trim();
password = mPasswordInput.getText().toString();
} else {
username = webViewUsername;
password = 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(username, password);
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;
String username;
if (result.getData().get(0) instanceof UserInfo) {
username = ((UserInfo) result.getData().get(0)).getDisplayName();
} else {
username = (String) result.getData().get(0);
}
if (mAction == ACTION_CREATE) {
if (!webViewLoginMethod) {
mUsernameInput.setText(username);
}
success = createAccount(result);
} else {
if (!webViewLoginMethod && !mUsernameInput.getText().toString().trim().equals(username)) {
// fail - not a new account, but an existing one; disallow
result = new RemoteOperationResult(ResultCode.ACCOUNT_NOT_THE_SAME);
mAuthToken = EMPTY_STRING;
updateAuthStatusIconAndText(result);
showAuthStatus();
Log_OC.d(TAG, result.getLogMessage());
} 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 {
if (!webViewLoginMethod) {
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
mServerIsChecked = true;
mWaitingForOpId = Long.MAX_VALUE;
// update server status, but don't show it yet
if (!webViewLoginMethod) {
updateServerStatusIconAndText(result);
}
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);
}
webViewLoginMethod = !forceOldLoginMethod;
if (webViewUser != null && !webViewUser.isEmpty() &&
webViewPassword != null && !webViewPassword.isEmpty()) {
checkBasicAuthorization(webViewUser, webViewPassword);
} else if (webViewLoginMethod) {
// hide old login
setOldLoginVisibility(View.GONE);
setContentView(R.layout.account_setup_webview);
mLoginWebView = findViewById(R.id.login_webview);
initWebViewLogin(mServerInfo.mBaseUrl + WEB_LOGIN, true, false);
} else {
// show old login
setOldLoginVisibility(View.VISIBLE);
}
if (!authSupported(mServerInfo.mAuthMethod)) {
if (!webViewLoginMethod) {
// overrides updateServerStatusIconAndText()
updateServerStatusIconNoRegularAuth();
}
mServerIsValid = false;
} else {
mServerIsValid = true;
}
} else {
mServerIsValid = false;
}
// refresh UI
if (!webViewLoginMethod) {
showRefreshButton(!mServerIsValid);
showServerStatus();
mOkButton.setEnabled(mServerIsValid);
}
if (!mServerIsValid) {
// hide old login
setOldLoginVisibility(View.GONE);
}
/// very special case (TODO: move to a common place for all the remote operations)
if (result.getCode() == ResultCode.SSL_RECOVERABLE_PEER_UNVERIFIED) {
showUntrustedCertDialog(result);
}
}
private void setOldLoginVisibility(int visible) {
mOkButton.setVisibility(visible);
mUsernameInput.setVisibility(visible);
mPasswordInput.setVisibility(visible);
if (View.VISIBLE == visible) {
scanQR.setVisibility(View.GONE);
} else {
scanQR.setVisibility(View.VISIBLE);
}
}
private boolean authSupported(AuthenticationMethod authMethod) {
return AuthenticationMethod.BASIC_HTTP_AUTH.equals(authMethod);
}
/**
* 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 (webViewLoginMethod && !showWebViewLoginUrl) {
DisplayUtils.showErrorAndFinishActivity(this, mAuthStatusText);
}
break;
case UNHANDLED_HTTP_CODE:
default:
mAuthStatusText = ErrorMessageAdapter.getErrorCauseMessage(result, null, getResources());
if (webViewLoginMethod && !showWebViewLoginUrl) {
DisplayUtils.showErrorAndFinishActivity(this, mAuthStatusText);
}
}
}
private void updateStatusIconFailUserName(int failedStatusText) {
mAuthStatusIcon = R.drawable.ic_alert;
mAuthStatusText = getResources().getString(failedStatusText);
}
private void updateServerStatusIconNoRegularAuth() {
mServerStatusIcon = R.drawable.ic_alert;
mServerStatusText = getResources().getString(R.string.auth_can_not_auth_against_server);
}
/**
* 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;
dismissDialog(WAIT_DIALOG_TAG);
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;
forceOldLoginMethod = false;
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
if (mLoginWebView != null) {
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
mServerIsChecked = true;
mServerIsValid = false;
mServerInfo = new GetServerInfoOperation.ServerInfo();
// update status icon and text
updateServerStatusIconAndText(result);
showServerStatus();
mAuthStatusIcon = 0;
mAuthStatusText = EMPTY_STRING;
if (!webViewLoginMethod) {
showAuthStatus();
// update input controls state
showRefreshButton(true);
mOkButton.setEnabled(false);
}
// 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
if (webViewLoginMethod) {
mLoginWebView = findViewById(R.id.login_webview);
if (mLoginWebView != null) {
initWebViewLogin(mServerInfo.mBaseUrl + WEB_LOGIN, true, 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
if (mLoginWebView != null) {
mLoginWebView.setVisibility(View.GONE);
}
if (webViewLoginMethod) {
updateAuthStatusIconAndText(result);
} else {
setContentView(R.layout.account_setup);
initOverallUi();
mHostUrlInput.setText(mServerInfo.mBaseUrl);
mServerStatusView.setVisibility(View.GONE);
showAuthStatus();
}
}
} else {
updateAuthStatusIconAndText(result);
showAuthStatus();
}
// 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);
if (webViewLoginMethod) {
response.putString(AccountManager.KEY_AUTHTOKEN, webViewPassword);
mAccountMgr.setPassword(mAccount, webViewPassword);
} else {
response.putString(AccountManager.KEY_AUTHTOKEN, mPasswordInput.getText().toString());
mAccountMgr.setPassword(mAccount, mPasswordInput.getText().toString());
}
// remove managed clients for this account to enforce creation with fresh credentials
OwnCloudAccount ocAccount = new OwnCloudAccount(mAccount, this);
OwnCloudClientManagerFactory.getDefaultSingleton().removeClientFor(ocAccount);
setAccountAuthenticatorResult(response);
final 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;
if (!webViewLoginMethod) {
loginName = mUsernameInput.getText().toString().trim();
} else {
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;
if (webViewLoginMethod) {
mAccountMgr.addAccountExplicitly(mAccount, webViewPassword, null);
} else {
mAccountMgr.addAccountExplicitly(mAccount, mPasswordInput.getText().toString(), 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