src/com/owncloud/android/authentication/AuthenticatorActivity.java

   1 /* ownCloud Android client application
   2  *   Copyright (C) 2012  Bartek Przybylski
   3  *   Copyright (C) 2012-2013 ownCloud Inc.
   4  *
   5  *   This program is free software: you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License version 2,
   7  *   as published by the Free Software Foundation.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details.
  13  *
  14  *   You should have received a copy of the GNU General Public License
  15  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  */
  18
  19 package com.owncloud.android.authentication;
  20
  21 import com.owncloud.android.AccountUtils;
  22 import com.owncloud.android.Log_OC;
  23 import com.owncloud.android.ui.dialog.SslValidatorDialog;
  24 import com.owncloud.android.ui.dialog.SslValidatorDialog.OnSslValidatorListener;
  25 import com.owncloud.android.utils.OwnCloudVersion;
  26 import com.owncloud.android.network.OwnCloudClientUtils;
  27 import com.owncloud.android.operations.OwnCloudServerCheckOperation;
  28 import com.owncloud.android.operations.ExistenceCheckOperation;
  29 import com.owncloud.android.operations.OAuth2GetAccessToken;
  30 import com.owncloud.android.operations.OnRemoteOperationListener;
  31 import com.owncloud.android.operations.RemoteOperation;
  32 import com.owncloud.android.operations.RemoteOperationResult;
  33 import com.owncloud.android.operations.RemoteOperationResult.ResultCode;
  34
  35 import android.accounts.Account;
  36 import android.accounts.AccountAuthenticatorActivity;
  37 import android.accounts.AccountManager;
  38 import android.app.AlertDialog;
  39 import android.app.Dialog;
  40 import android.app.ProgressDialog;
  41 import android.content.ContentResolver;
  42 import android.content.DialogInterface;
  43 import android.content.Intent;
  44 import android.content.SharedPreferences;
  45 import android.graphics.Rect;
  46 import android.graphics.drawable.Drawable;
  47 import android.net.Uri;
  48 import android.os.Bundle;
  49 import android.os.Handler;
  50 import android.preference.PreferenceManager;
  51 import android.text.Editable;
  52 import android.text.InputType;
  53 import android.text.TextWatcher;
  54 import android.view.KeyEvent;
  55 import android.view.MotionEvent;
  56 import android.view.View;
  57 import android.view.View.OnClickListener;
  58 import android.view.View.OnFocusChangeListener;
  59 import android.view.View.OnTouchListener;
  60 import android.view.Window;
  61 import android.view.inputmethod.EditorInfo;
  62 import android.widget.CheckBox;
  63 import android.widget.EditText;
  64 import android.widget.Button;
  65 import android.widget.TextView;
  66 import android.widget.Toast;
  67 import android.widget.TextView.OnEditorActionListener;
  68
  69 import com.owncloud.android.R;
  70
  71 import eu.alefzero.webdav.WebdavClient;
  72
  73 /**
  74  * This Activity is used to add an ownCloud account to the App
  75  *
  76  * @author Bartek Przybylski
  77  * @author David A. Velasco
  78  */
  79 public class AuthenticatorActivity extends AccountAuthenticatorActivity
  80 implements  OnRemoteOperationListener, OnSslValidatorListener, OnFocusChangeListener, OnEditorActionListener {
  81
  82     private static final String TAG = AuthenticatorActivity.class.getSimpleName();
  83
  84     public static final String EXTRA_ACCOUNT = "ACCOUNT";
  85     public static final String EXTRA_USER_NAME = "USER_NAME";
  86     public static final String EXTRA_HOST_NAME = "HOST_NAME";
  87     public static final String EXTRA_ACTION = "ACTION";
  88
  89     private static final String KEY_HOST_URL_TEXT = "HOST_URL_TEXT";
  90     private static final String KEY_OC_VERSION = "OC_VERSION";
  91     private static final String KEY_ACCOUNT = "ACCOUNT";
  92     private static final String KEY_SERVER_VALID = "SERVER_VALID";
  93     private static final String KEY_SERVER_CHECKED = "SERVER_CHECKED";
  94     private static final String KEY_SERVER_CHECK_IN_PROGRESS = "SERVER_CHECK_IN_PROGRESS";
  95     private static final String KEY_SERVER_STATUS_TEXT = "SERVER_STATUS_TEXT";
  96     private static final String KEY_SERVER_STATUS_ICON = "SERVER_STATUS_ICON";
  97     private static final String KEY_IS_SSL_CONN = "IS_SSL_CONN";
  98     private static final String KEY_PASSWORD_VISIBLE = "PASSWORD_VISIBLE";
  99     private static final String KEY_AUTH_STATUS_TEXT = "AUTH_STATUS_TEXT";
 100     private static final String KEY_AUTH_STATUS_ICON = "AUTH_STATUS_ICON";
 101     private static final String KEY_REFRESH_BUTTON_ENABLED = "KEY_REFRESH_BUTTON_ENABLED";
 102
 103     private static final String OAUTH_MODE_ON = "on";
 104     private static final String OAUTH_MODE_OFF = "off";
 105     private static final String OAUTH_MODE_OPTIONAL = "optional";
 106
 107     private static final int DIALOG_LOGIN_PROGRESS = 0;
 108     private static final int DIALOG_SSL_VALIDATOR = 1;
 109     private static final int DIALOG_CERT_NOT_SAVED = 2;
 110     private static final int DIALOG_OAUTH2_LOGIN_PROGRESS = 3;
 111
 112     public static final byte ACTION_CREATE = 0;
 113     public static final byte ACTION_UPDATE_TOKEN = 1;
 114
 115     private String mHostBaseUrl;
 116     private OwnCloudVersion mDiscoveredVersion;
 117
 118     private int mServerStatusText, mServerStatusIcon;
 119     private boolean mServerIsChecked, mServerIsValid, mIsSslConn;
 120     private int mAuthStatusText, mAuthStatusIcon;
 121
 122     private final Handler mHandler = new Handler();
 123     private Thread mOperationThread;
 124     private OwnCloudServerCheckOperation mOcServerChkOperation;
 125     private ExistenceCheckOperation mAuthCheckOperation;
 126     private RemoteOperationResult mLastSslUntrustedServerResult;
 127
 128     private Uri mNewCapturedUriFromOAuth2Redirection;
 129
 130     private AccountManager mAccountMgr;
 131     private boolean mJustCreated;
 132     private byte mAction;
 133     private Account mAccount;
 134
 135     private Button mCheckServerButton;
 136     private EditText mHostUrlInput;
 137     private EditText mUsernameInput;
 138     private EditText mPasswordInput;
 139     private CheckBox mOAuth2Check;
 140     private String mOAuthAccessToken;
 141     private View mOkButton;
 142     private TextView mAuthStatusLayout;
 143
 144     private TextView mOAuthAuthEndpointText;
 145     private TextView mOAuthTokenEndpointText;
 146
 147     private boolean mRefreshButtonEnabled;
 148
 149     private boolean mHostUrlInputEnabled;
 150
 151
 152     /**
 153      * {@inheritDoc}
 154      *
 155      * IMPORTANT ENTRY POINT 1: activity is shown to the user
 156      */
 157     @Override
 158     protected void onCreate(Bundle savedInstanceState) {
 159         super.onCreate(savedInstanceState);
 160         getWindow().requestFeature(Window.FEATURE_NO_TITLE);
 161
 162         /// set view and get references to view elements
 163         setContentView(R.layout.account_setup);
 164         mCheckServerButton = (Button) findViewById(R.id.checkServerButton);
 165         mHostUrlInput = (EditText) findViewById(R.id.hostUrlInput);
 166         mUsernameInput = (EditText) findViewById(R.id.account_username);
 167         mPasswordInput = (EditText) findViewById(R.id.account_password);
 168         mOAuthAuthEndpointText = (TextView)findViewById(R.id.oAuthEntryPoint_1);
 169         mOAuthTokenEndpointText = (TextView)findViewById(R.id.oAuthEntryPoint_2);
 170         mOAuth2Check = (CheckBox) findViewById(R.id.oauth_onOff_check);
 171         mOkButton = findViewById(R.id.buttonOK);
 172         mAuthStatusLayout = (TextView) findViewById(R.id.auth_status_text);
 173
 174         /// set Host Url Input Enabled
 175         mHostUrlInputEnabled = getResources().getBoolean(R.bool.show_server_url_input);
 176
 177
 178         /// complete label for 'register account' button
 179         Button b = (Button) findViewById(R.id.account_register);
 180         if (b != null) {
 181             b.setText(String.format(getString(R.string.auth_register), getString(R.string.app_name)));
 182         }
 183
 184         /// initialization
 185         mAccountMgr = AccountManager.get(this);
 186         mNewCapturedUriFromOAuth2Redirection = null;
 187         mAction = getIntent().getByteExtra(EXTRA_ACTION, ACTION_CREATE);
 188         mAccount = null;
 189         mHostBaseUrl = "";
 190
 191         // URL Branding
 192         if (!mHostUrlInputEnabled)
 193         {
 194             mHostUrlInput.setText(getString(R.string.server_url));
 195             mHostUrlInput.setVisibility(View.GONE);
 196
 197             mCheckServerButton.setVisibility(View.VISIBLE);
 198             mCheckServerButton.setOnClickListener(new OnClickListener() {
 199
 200                 @Override
 201                 public void onClick(View v) {
 202                     checkOcServer();
 203
 204                 }
 205             });
 206
 207             checkOcServer();
 208         }
 209
 210         if (savedInstanceState == null) {
 211             /// connection state and info
 212             mServerStatusText = mServerStatusIcon = 0;
 213             mServerIsValid = false;
 214             mServerIsChecked = false;
 215             mIsSslConn = false;
 216             mAuthStatusText = mAuthStatusIcon = 0;
 217
 218             /// retrieve extras from intent
 219             String tokenType = getIntent().getExtras().getString(AccountAuthenticator.KEY_AUTH_TOKEN_TYPE);
 220             boolean oAuthRequired = AccountAuthenticator.AUTH_TOKEN_TYPE_ACCESS_TOKEN.equals(tokenType) || OAUTH_MODE_ON.equals(getString(R.string.oauth2_mode));
 221
 222             mAccount = getIntent().getExtras().getParcelable(EXTRA_ACCOUNT);
 223             if (mAccount != null) {
 224                 String ocVersion = mAccountMgr.getUserData(mAccount, AccountAuthenticator.KEY_OC_VERSION);
 225                 if (ocVersion != null) {
 226                     mDiscoveredVersion = new OwnCloudVersion(ocVersion);
 227                 }
 228                 mHostBaseUrl = normalizeUrl(mAccountMgr.getUserData(mAccount, AccountAuthenticator.KEY_OC_BASE_URL));
 229                 mHostUrlInput.setText(mHostBaseUrl);
 230                 String userName = mAccount.name.substring(0, mAccount.name.lastIndexOf('@'));
 231                 mUsernameInput.setText(userName);
 232                 oAuthRequired = (mAccountMgr.getUserData(mAccount, AccountAuthenticator.KEY_SUPPORTS_OAUTH2) != null);
 233             }
 234             mOAuth2Check.setChecked(oAuthRequired);
 235             changeViewByOAuth2Check(oAuthRequired);
 236
 237
 238         } else {
 239             /// connection state and info
 240             mServerIsValid = savedInstanceState.getBoolean(KEY_SERVER_VALID);
 241             mServerIsChecked = savedInstanceState.getBoolean(KEY_SERVER_CHECKED);
 242             mServerStatusText = savedInstanceState.getInt(KEY_SERVER_STATUS_TEXT);
 243             mServerStatusIcon = savedInstanceState.getInt(KEY_SERVER_STATUS_ICON);
 244             mIsSslConn = savedInstanceState.getBoolean(KEY_IS_SSL_CONN);
 245             mAuthStatusText = savedInstanceState.getInt(KEY_AUTH_STATUS_TEXT);
 246             mAuthStatusIcon = savedInstanceState.getInt(KEY_AUTH_STATUS_ICON);
 247             if (savedInstanceState.getBoolean(KEY_PASSWORD_VISIBLE, false)) {
 248                 showPassword();
 249             }
 250
 251             /// server data
 252             String ocVersion = savedInstanceState.getString(KEY_OC_VERSION);
 253             if (ocVersion != null) {
 254                 mDiscoveredVersion = new OwnCloudVersion(ocVersion);
 255             }
 256             mHostBaseUrl = savedInstanceState.getString(KEY_HOST_URL_TEXT);
 257
 258             // account data, if updating
 259             mAccount = savedInstanceState.getParcelable(KEY_ACCOUNT);
 260
 261             // check if server check was interrupted by a configuration change
 262             if (savedInstanceState.getBoolean(KEY_SERVER_CHECK_IN_PROGRESS, false)) {
 263                 checkOcServer();
 264             }
 265
 266             // refresh button enabled
 267             mRefreshButtonEnabled = savedInstanceState.getBoolean(KEY_REFRESH_BUTTON_ENABLED);
 268
 269         }
 270
 271         showServerStatus();
 272         showAuthStatus();
 273         if (mServerIsChecked && !mServerIsValid && mRefreshButtonEnabled) showRefreshButton();
 274         mOkButton.setEnabled(mServerIsValid); // state not automatically recovered in configuration changes
 275
 276         if (!OAUTH_MODE_OPTIONAL.equals(getString(R.string.oauth2_mode))) {
 277             mOAuth2Check.setVisibility(View.GONE);
 278         }
 279
 280         if (mAction == ACTION_UPDATE_TOKEN) {
 281             /// lock things that should not change
 282             mHostUrlInput.setEnabled(false);
 283             mUsernameInput.setEnabled(false);
 284             mOAuth2Check.setVisibility(View.GONE);
 285             if (!mServerIsValid && mOcServerChkOperation == null) {
 286                 checkOcServer();
 287             }
 288         }
 289
 290         mPasswordInput.setText("");     // clean password to avoid social hacking (disadvantage: password in removed if the device is turned aside)
 291         mJustCreated = true;
 292
 293         /// bind view elements to listeners
 294         mHostUrlInput.setOnFocusChangeListener(this);
 295         mHostUrlInput.setOnTouchListener(new RightDrawableOnTouchListener() {
 296             @Override
 297             public boolean onDrawableTouch(final MotionEvent event) {
 298                 if (event.getAction() == MotionEvent.ACTION_UP) {
 299                     AuthenticatorActivity.this.onRefreshClick();
 300                 }
 301                 return true;
 302             }
 303         });
 304         mHostUrlInput.addTextChangedListener(new TextWatcher() {
 305
 306             @Override
 307             public void afterTextChanged(Editable s) {
 308                 if (!mHostBaseUrl.equals(normalizeUrl(mHostUrlInput.getText().toString()))) {
 309                     mOkButton.setEnabled(false);
 310                 }
 311             }
 312
 313             @Override
 314             public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
 315
 316             @Override
 317             public void onTextChanged(CharSequence s, int start, int before, int count) {}
 318
 319         });
 320         mPasswordInput.setOnFocusChangeListener(this);
 321         mPasswordInput.setImeOptions(EditorInfo.IME_ACTION_DONE);
 322         mPasswordInput.setOnEditorActionListener(this);
 323         mPasswordInput.setOnTouchListener(new RightDrawableOnTouchListener() {
 324             @Override
 325             public boolean onDrawableTouch(final MotionEvent event) {
 326                 if (event.getAction() == MotionEvent.ACTION_UP) {
 327                     AuthenticatorActivity.this.onViewPasswordClick();
 328                 }
 329                 return true;
 330             }
 331         });
 332     }
 333
 334     /**
 335      * Saves relevant state before {@link #onPause()}
 336      *
 337      * Do NOT save {@link #mNewCapturedUriFromOAuth2Redirection}; it keeps a temporal flag, intended to defer the
 338      * processing of the redirection caught in {@link #onNewIntent(Intent)} until {@link #onResume()}
 339      *
 340      * See {@link #loadSavedInstanceState(Bundle)}
 341      */
 342     @Override
 343     protected void onSaveInstanceState(Bundle outState) {
 344         super.onSaveInstanceState(outState);
 345
 346         /// connection state and info
 347         outState.putInt(KEY_SERVER_STATUS_TEXT, mServerStatusText);
 348         outState.putInt(KEY_SERVER_STATUS_ICON, mServerStatusIcon);
 349         outState.putBoolean(KEY_SERVER_VALID, mServerIsValid);
 350         outState.putBoolean(KEY_SERVER_CHECKED, mServerIsChecked);
 351         outState.putBoolean(KEY_SERVER_CHECK_IN_PROGRESS, (!mServerIsValid && mOcServerChkOperation != null));
 352         outState.putBoolean(KEY_IS_SSL_CONN, mIsSslConn);
 353         outState.putBoolean(KEY_PASSWORD_VISIBLE, isPasswordVisible());
 354         outState.putInt(KEY_AUTH_STATUS_ICON, mAuthStatusIcon);
 355         outState.putInt(KEY_AUTH_STATUS_TEXT, mAuthStatusText);
 356
 357         /// server data
 358         if (mDiscoveredVersion != null) {
 359             outState.putString(KEY_OC_VERSION, mDiscoveredVersion.toString());
 360         }
 361         outState.putString(KEY_HOST_URL_TEXT, mHostBaseUrl);
 362
 363         /// account data, if updating
 364         if (mAccount != null) {
 365             outState.putParcelable(KEY_ACCOUNT, mAccount);
 366         }
 367
 368         // refresh button enabled
 369         outState.putBoolean(KEY_REFRESH_BUTTON_ENABLED, mRefreshButtonEnabled);
 370
 371     }
 372
 373
 374     /**
 375      * The redirection triggered by the OAuth authentication server as response to the GET AUTHORIZATION request
 376      * is caught here.
 377      *
 378      * To make this possible, this activity needs to be qualified with android:launchMode = "singleTask" in the
 379      * AndroidManifest.xml file.
 380      */
 381     @Override
 382     protected void onNewIntent (Intent intent) {
 383         Log_OC.d(TAG, "onNewIntent()");
 384         Uri data = intent.getData();
 385         if (data != null && data.toString().startsWith(getString(R.string.oauth2_redirect_uri))) {
 386             mNewCapturedUriFromOAuth2Redirection = data;
 387         }
 388     }
 389
 390
 391     /**
 392      * The redirection triggered by the OAuth authentication server as response to the GET AUTHORIZATION, and
 393      * deferred in {@link #onNewIntent(Intent)}, is processed here.
 394      */
 395     @Override
 396     protected void onResume() {
 397         super.onResume();
 398         // the state of mOAuth2Check is automatically recovered between configuration changes, but not before onCreate() finishes; so keep the next lines here
 399         changeViewByOAuth2Check(mOAuth2Check.isChecked());
 400         if (mAction == ACTION_UPDATE_TOKEN && mJustCreated) {
 401             if (mOAuth2Check.isChecked())
 402                 Toast.makeText(this, R.string.auth_expired_oauth_token_toast, Toast.LENGTH_LONG).show();
 403             else
 404                 Toast.makeText(this, R.string.auth_expired_basic_auth_toast, Toast.LENGTH_LONG).show();
 405         }
 406
 407         if (mNewCapturedUriFromOAuth2Redirection != null) {
 408             getOAuth2AccessTokenFromCapturedRedirection();
 409         }
 410
 411         mJustCreated = false;
 412     }
 413
 414
 415     /**
 416      * Parses the redirection with the response to the GET AUTHORIZATION request to the
 417      * oAuth server and requests for the access token (GET ACCESS TOKEN)
 418      */
 419     private void getOAuth2AccessTokenFromCapturedRedirection() {
 420         /// Parse data from OAuth redirection
 421         String queryParameters = mNewCapturedUriFromOAuth2Redirection.getQuery();
 422         mNewCapturedUriFromOAuth2Redirection = null;
 423
 424         /// Showing the dialog with instructions for the user.
 425         showDialog(DIALOG_OAUTH2_LOGIN_PROGRESS);
 426
 427         /// GET ACCESS TOKEN to the oAuth server
 428         RemoteOperation operation = new OAuth2GetAccessToken(   getString(R.string.oauth2_client_id),
 429                 getString(R.string.oauth2_redirect_uri),
 430                 getString(R.string.oauth2_grant_type),
 431                 queryParameters);
 432         //WebdavClient client = OwnCloudClientUtils.createOwnCloudClient(Uri.parse(getString(R.string.oauth2_url_endpoint_access)), getApplicationContext());
 433         WebdavClient client = OwnCloudClientUtils.createOwnCloudClient(Uri.parse(mOAuthTokenEndpointText.getText().toString().trim()), getApplicationContext());
 434         operation.execute(client, this, mHandler);
 435     }
 436
 437
 438
 439     /**
 440      * Handles the change of focus on the text inputs for the server URL and the password
 441      */
 442     public void onFocusChange(View view, boolean hasFocus) {
 443         if (view.getId() == R.id.hostUrlInput) {
 444             if (!hasFocus) {
 445                 onUrlInputFocusLost((TextView) view);
 446                 if (!mServerIsValid) {
 447                     showRefreshButton();
 448                 }
 449             }
 450             else {
 451                 hideRefreshButton();
 452             }
 453
 454         } else if (view.getId() == R.id.account_password) {
 455             onPasswordFocusChanged((TextView) view, hasFocus);
 456         }
 457     }
 458
 459
 460     /**
 461      * Handles changes in focus on the text input for the server URL.
 462      *
 463      * IMPORTANT ENTRY POINT 2: When (!hasFocus), user wrote the server URL and changed to
 464      * other field. The operation to check the existence of the server in the entered URL is
 465      * started.
 466      *
 467      * When hasFocus:    user 'comes back' to write again the server URL.
 468      *
 469      * @param hostInput     TextView with the URL input field receiving the change of focus.
 470      */
 471     private void onUrlInputFocusLost(TextView hostInput) {
 472         if (!mHostBaseUrl.equals(normalizeUrl(mHostUrlInput.getText().toString()))) {
 473             checkOcServer();
 474         } else {
 475             mOkButton.setEnabled(mServerIsValid);
 476         }
 477     }
 478
 479
 480     private void checkOcServer() {
 481         String uri = trimUrlWebdav(mHostUrlInput.getText().toString().trim());
 482
 483         if (!mHostUrlInputEnabled){
 484             uri = getString(R.string.server_url);
 485         }
 486
 487         mServerIsValid = false;
 488         mServerIsChecked = false;
 489         mOkButton.setEnabled(false);
 490         mDiscoveredVersion = null;
 491         hideRefreshButton();
 492         if (uri.length() != 0) {
 493             mServerStatusText = R.string.auth_testing_connection;
 494             mServerStatusIcon = R.drawable.progress_small;
 495             showServerStatus();
 496             mOcServerChkOperation = new  OwnCloudServerCheckOperation(uri, this);
 497             WebdavClient client = OwnCloudClientUtils.createOwnCloudClient(Uri.parse(uri), this);
 498             mOperationThread = mOcServerChkOperation.execute(client, this, mHandler);
 499         } else {
 500             mServerStatusText = 0;
 501             mServerStatusIcon = 0;
 502             showServerStatus();
 503         }
 504     }
 505
 506
 507     /**
 508      * Handles changes in focus on the text input for the password (basic authorization).
 509      *
 510      * When (hasFocus), the button to toggle password visibility is shown.
 511      *
 512      * When (!hasFocus), the button is made invisible and the password is hidden.
 513      *
 514      * @param passwordInput    TextView with the password input field receiving the change of focus.
 515      * @param hasFocus          'True' if focus is received, 'false' if is lost
 516      */
 517     private void onPasswordFocusChanged(TextView passwordInput, boolean hasFocus) {
 518         if (hasFocus) {
 519             showViewPasswordButton();
 520         } else {
 521             hidePassword();
 522             hidePasswordButton();
 523         }
 524     }
 525
 526
 527     private void showViewPasswordButton() {
 528         //int drawable = android.R.drawable.ic_menu_view;
 529         int drawable = R.drawable.ic_view;
 530         if (isPasswordVisible()) {
 531             //drawable = android.R.drawable.ic_secure;
 532             drawable = R.drawable.ic_hide;
 533         }
 534         mPasswordInput.setCompoundDrawablesWithIntrinsicBounds(0, 0, drawable, 0);
 535     }
 536
 537     private boolean isPasswordVisible() {
 538         return ((mPasswordInput.getInputType() & InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD) == InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
 539     }
 540
 541     private void hidePasswordButton() {
 542         mPasswordInput.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0);
 543     }
 544
 545     private void showPassword() {
 546         mPasswordInput.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
 547         showViewPasswordButton();
 548     }
 549
 550     private void hidePassword() {
 551         mPasswordInput.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
 552         showViewPasswordButton();
 553     }
 554
 555
 556     /**
 557      * Cancels the authenticator activity
 558      *
 559      * IMPORTANT ENTRY POINT 3: Never underestimate the importance of cancellation
 560      *
 561      * This method is bound in the layout/acceoun_setup.xml resource file.
 562      *
 563      * @param view      Cancel button
 564      */
 565     public void onCancelClick(View view) {
 566         setResult(RESULT_CANCELED);     // TODO review how is this related to AccountAuthenticator (debugging)
 567         finish();
 568     }
 569
 570
 571
 572     /**
 573      * Checks the credentials of the user in the root of the ownCloud server
 574      * before creating a new local account.
 575      *
 576      * For basic authorization, a check of existence of the root folder is
 577      * performed.
 578      *
 579      * For OAuth, starts the flow to get an access token; the credentials test
 580      * is postponed until it is available.
 581      *
 582      * IMPORTANT ENTRY POINT 4
 583      *
 584      * @param view      OK button
 585      */
 586     public void onOkClick(View view) {
 587         // this check should be unnecessary
 588         if (mDiscoveredVersion == null || !mDiscoveredVersion.isVersionValid()  || mHostBaseUrl == null || mHostBaseUrl.length() == 0) {
 589             mServerStatusIcon = R.drawable.common_error;
 590             mServerStatusText = R.string.auth_wtf_reenter_URL;
 591             showServerStatus();
 592             mOkButton.setEnabled(false);
 593             Log_OC.wtf(TAG,  "The user was allowed to click 'connect' to an unchecked server!!");
 594             return;
 595         }
 596
 597         if (mOAuth2Check.isChecked()) {
 598             startOauthorization();
 599
 600         } else {
 601             checkBasicAuthorization();
 602         }
 603     }
 604
 605
 606     /**
 607      * Tests the credentials entered by the user performing a check of existence on
 608      * the root folder of the ownCloud server.
 609      */
 610     private void checkBasicAuthorization() {
 611         /// get the path to the root folder through WebDAV from the version server
 612         String webdav_path = AccountUtils.getWebdavPath(mDiscoveredVersion, false);
 613
 614         /// get basic credentials entered by user
 615         String username = mUsernameInput.getText().toString();
 616         String password = mPasswordInput.getText().toString();
 617
 618         /// be gentle with the user
 619         showDialog(DIALOG_LOGIN_PROGRESS);
 620
 621         /// test credentials accessing the root folder
 622         mAuthCheckOperation = new  ExistenceCheckOperation("", this, false);
 623         WebdavClient client = OwnCloudClientUtils.createOwnCloudClient(Uri.parse(mHostBaseUrl + webdav_path), this);
 624         client.setBasicCredentials(username, password);
 625         mOperationThread = mAuthCheckOperation.execute(client, this, mHandler);
 626     }
 627
 628
 629     /**
 630      * Starts the OAuth 'grant type' flow to get an access token, with
 631      * a GET AUTHORIZATION request to the BUILT-IN authorization server.
 632      */
 633     private void startOauthorization() {
 634         // be gentle with the user
 635         mAuthStatusIcon = R.drawable.progress_small;
 636         mAuthStatusText = R.string.oauth_login_connection;
 637         showAuthStatus();
 638
 639         // GET AUTHORIZATION request
 640         //Uri uri = Uri.parse(getString(R.string.oauth2_url_endpoint_auth));
 641         Uri uri = Uri.parse(mOAuthAuthEndpointText.getText().toString().trim());
 642         Uri.Builder uriBuilder = uri.buildUpon();
 643         uriBuilder.appendQueryParameter(OAuth2Constants.KEY_RESPONSE_TYPE, getString(R.string.oauth2_response_type));
 644         uriBuilder.appendQueryParameter(OAuth2Constants.KEY_REDIRECT_URI, getString(R.string.oauth2_redirect_uri));
 645         uriBuilder.appendQueryParameter(OAuth2Constants.KEY_CLIENT_ID, getString(R.string.oauth2_client_id));
 646         uriBuilder.appendQueryParameter(OAuth2Constants.KEY_SCOPE, getString(R.string.oauth2_scope));
 647         //uriBuilder.appendQueryParameter(OAuth2Constants.KEY_STATE, whateverwewant);
 648         uri = uriBuilder.build();
 649         Log_OC.d(TAG, "Starting browser to view " + uri.toString());
 650         Intent i = new Intent(Intent.ACTION_VIEW, uri);
 651         startActivity(i);
 652     }
 653
 654
 655     /**
 656      * Callback method invoked when a RemoteOperation executed by this Activity finishes.
 657      *
 658      * Dispatches the operation flow to the right method.
 659      */
 660     @Override
 661     public void onRemoteOperationFinish(RemoteOperation operation, RemoteOperationResult result) {
 662
 663         if (operation instanceof OwnCloudServerCheckOperation) {
 664             onOcServerCheckFinish((OwnCloudServerCheckOperation) operation, result);
 665
 666         } else if (operation instanceof OAuth2GetAccessToken) {
 667             onGetOAuthAccessTokenFinish((OAuth2GetAccessToken)operation, result);
 668
 669         } else if (operation instanceof ExistenceCheckOperation)  {
 670             onAuthorizationCheckFinish((ExistenceCheckOperation)operation, result);
 671
 672         }
 673     }
 674
 675
 676     /**
 677      * Processes the result of the server check performed when the user finishes the enter of the
 678      * server URL.
 679      *
 680      * @param operation     Server check performed.
 681      * @param result        Result of the check.
 682      */
 683     private void onOcServerCheckFinish(OwnCloudServerCheckOperation operation, RemoteOperationResult result) {
 684         if (operation.equals(mOcServerChkOperation)) {
 685             /// save result state
 686             mServerIsChecked = true;
 687             mServerIsValid = result.isSuccess();
 688             mIsSslConn = (result.getCode() == ResultCode.OK_SSL);
 689             mOcServerChkOperation = null;
 690
 691             /// update status icon and text
 692             if (mServerIsValid) {
 693                 hideRefreshButton();
 694             } else {
 695                 showRefreshButton();
 696             }
 697             updateServerStatusIconAndText(result);
 698             showServerStatus();
 699
 700             /// very special case (TODO: move to a common place for all the remote operations)
 701             if (result.getCode() == ResultCode.SSL_RECOVERABLE_PEER_UNVERIFIED) {
 702                 mLastSslUntrustedServerResult = result;
 703                 showDialog(DIALOG_SSL_VALIDATOR);
 704             }
 705
 706             /// retrieve discovered version and normalize server URL
 707             mDiscoveredVersion = operation.getDiscoveredVersion();
 708             mHostBaseUrl = normalizeUrl(mHostUrlInput.getText().toString());
 709
 710             /// allow or not the user try to access the server
 711             mOkButton.setEnabled(mServerIsValid);
 712
 713         }   // else nothing ; only the last check operation is considered;
 714         // multiple can be triggered if the user amends a URL before a previous check can be triggered
 715     }
 716
 717
 718     private String normalizeUrl(String url) {
 719         if (url != null && url.length() > 0) {
 720             url = url.trim();
 721             if (!url.toLowerCase().startsWith("http://") &&
 722                     !url.toLowerCase().startsWith("https://")) {
 723                 if (mIsSslConn) {
 724                     url = "https://" + url;
 725                 } else {
 726                     url = "http://" + url;
 727                 }
 728             }
 729
 730             // OC-208: Add suffix remote.php/webdav to normalize (OC-34)
 731             url = trimUrlWebdav(url);
 732
 733             if (url.endsWith("/")) {
 734                 url = url.substring(0, url.length() - 1);
 735             }
 736
 737         }
 738         Log_OC.d(TAG, "URL Normalize " + url);
 739         return (url != null ? url : "");
 740     }
 741
 742
 743     private String trimUrlWebdav(String url){
 744         if(url.toLowerCase().endsWith(AccountUtils.WEBDAV_PATH_4_0)){
 745             url = url.substring(0, url.length() - AccountUtils.WEBDAV_PATH_4_0.length());
 746         } else if(url.toLowerCase().endsWith(AccountUtils.WEBDAV_PATH_2_0)){
 747             url = url.substring(0, url.length() - AccountUtils.WEBDAV_PATH_2_0.length());
 748         } else if (url.toLowerCase().endsWith(AccountUtils.WEBDAV_PATH_1_2)){
 749             url = url.substring(0, url.length() - AccountUtils.WEBDAV_PATH_1_2.length());
 750         }
 751         return (url != null ? url : "");
 752     }
 753
 754
 755     /**
 756      * Chooses the right icon and text to show to the user for the received operation result.
 757      *
 758      * @param result    Result of a remote operation performed in this activity
 759      */
 760     private void updateServerStatusIconAndText(RemoteOperationResult result) {
 761         mServerStatusIcon = R.drawable.common_error;    // the most common case in the switch below
 762
 763         switch (result.getCode()) {
 764         case OK_SSL:
 765             mServerStatusIcon = android.R.drawable.ic_secure;
 766             mServerStatusText = R.string.auth_secure_connection;
 767             break;
 768
 769         case OK_NO_SSL:
 770         case OK:
 771             if (mHostUrlInput.getText().toString().trim().toLowerCase().startsWith("http://") ) {
 772                 mServerStatusText = R.string.auth_connection_established;
 773                 mServerStatusIcon = R.drawable.ic_ok;
 774             } else {
 775                 mServerStatusText = R.string.auth_nossl_plain_ok_title;
 776                 mServerStatusIcon = android.R.drawable.ic_partial_secure;
 777             }
 778             break;
 779
 780         case NO_NETWORK_CONNECTION:
 781             mServerStatusIcon = R.drawable.no_network;
 782             mServerStatusText = R.string.auth_no_net_conn_title;
 783             break;
 784
 785         case SSL_RECOVERABLE_PEER_UNVERIFIED:
 786             mServerStatusText = R.string.auth_ssl_unverified_server_title;
 787             break;
 788         case BAD_OC_VERSION:
 789             mServerStatusText = R.string.auth_bad_oc_version_title;
 790             break;
 791         case WRONG_CONNECTION:
 792             mServerStatusText = R.string.auth_wrong_connection_title;
 793             break;
 794         case TIMEOUT:
 795             mServerStatusText = R.string.auth_timeout_title;
 796             break;
 797         case INCORRECT_ADDRESS:
 798             mServerStatusText = R.string.auth_incorrect_address_title;
 799             break;
 800         case SSL_ERROR:
 801             mServerStatusText = R.string.auth_ssl_general_error_title;
 802             break;
 803         case UNAUTHORIZED:
 804             mServerStatusText = R.string.auth_unauthorized;
 805             break;
 806         case HOST_NOT_AVAILABLE:
 807             mServerStatusText = R.string.auth_unknown_host_title;
 808             break;
 809         case INSTANCE_NOT_CONFIGURED:
 810             mServerStatusText = R.string.auth_not_configured_title;
 811             break;
 812         case FILE_NOT_FOUND:
 813             mServerStatusText = R.string.auth_incorrect_path_title;
 814             break;
 815         case OAUTH2_ERROR:
 816             mServerStatusText = R.string.auth_oauth_error;
 817             break;
 818         case OAUTH2_ERROR_ACCESS_DENIED:
 819             mServerStatusText = R.string.auth_oauth_error_access_denied;
 820             break;
 821         case UNHANDLED_HTTP_CODE:
 822         case UNKNOWN_ERROR:
 823             mServerStatusText = R.string.auth_unknown_error_title;
 824             break;
 825         default:
 826             mServerStatusText = 0;
 827             mServerStatusIcon = 0;
 828         }
 829     }
 830
 831
 832     /**
 833      * Chooses the right icon and text to show to the user for the received operation result.
 834      *
 835      * @param result    Result of a remote operation performed in this activity
 836      */
 837     private void updateAuthStatusIconAndText(RemoteOperationResult result) {
 838         mAuthStatusIcon = R.drawable.common_error;    // the most common case in the switch below
 839
 840         switch (result.getCode()) {
 841         case OK_SSL:
 842             mAuthStatusIcon = android.R.drawable.ic_secure;
 843             mAuthStatusText = R.string.auth_secure_connection;
 844             break;
 845
 846         case OK_NO_SSL:
 847         case OK:
 848             if (mHostUrlInput.getText().toString().trim().toLowerCase().startsWith("http://") ) {
 849                 mAuthStatusText = R.string.auth_connection_established;
 850                 mAuthStatusIcon = R.drawable.ic_ok;
 851             } else {
 852                 mAuthStatusText = R.string.auth_nossl_plain_ok_title;
 853                 mAuthStatusIcon = android.R.drawable.ic_partial_secure;
 854             }
 855             break;
 856
 857         case NO_NETWORK_CONNECTION:
 858             mAuthStatusIcon = R.drawable.no_network;
 859             mAuthStatusText = R.string.auth_no_net_conn_title;
 860             break;
 861
 862         case SSL_RECOVERABLE_PEER_UNVERIFIED:
 863             mAuthStatusText = R.string.auth_ssl_unverified_server_title;
 864             break;
 865         case BAD_OC_VERSION:
 866             mAuthStatusText = R.string.auth_bad_oc_version_title;
 867             break;
 868         case WRONG_CONNECTION:
 869             mAuthStatusText = R.string.auth_wrong_connection_title;
 870             break;
 871         case TIMEOUT:
 872             mAuthStatusText = R.string.auth_timeout_title;
 873             break;
 874         case INCORRECT_ADDRESS:
 875             mAuthStatusText = R.string.auth_incorrect_address_title;
 876             break;
 877         case SSL_ERROR:
 878             mAuthStatusText = R.string.auth_ssl_general_error_title;
 879             break;
 880         case UNAUTHORIZED:
 881             mAuthStatusText = R.string.auth_unauthorized;
 882             break;
 883         case HOST_NOT_AVAILABLE:
 884             mAuthStatusText = R.string.auth_unknown_host_title;
 885             break;
 886         case INSTANCE_NOT_CONFIGURED:
 887             mAuthStatusText = R.string.auth_not_configured_title;
 888             break;
 889         case FILE_NOT_FOUND:
 890             mAuthStatusText = R.string.auth_incorrect_path_title;
 891             break;
 892         case OAUTH2_ERROR:
 893             mAuthStatusText = R.string.auth_oauth_error;
 894             break;
 895         case OAUTH2_ERROR_ACCESS_DENIED:
 896             mAuthStatusText = R.string.auth_oauth_error_access_denied;
 897             break;
 898         case UNHANDLED_HTTP_CODE:
 899         case UNKNOWN_ERROR:
 900             mAuthStatusText = R.string.auth_unknown_error_title;
 901             break;
 902         default:
 903             mAuthStatusText = 0;
 904             mAuthStatusIcon = 0;
 905         }
 906     }
 907
 908
 909     /**
 910      * Processes the result of the request for and access token send
 911      * to an OAuth authorization server.
 912      *
 913      * @param operation     Operation performed requesting the access token.
 914      * @param result        Result of the operation.
 915      */
 916     private void onGetOAuthAccessTokenFinish(OAuth2GetAccessToken operation, RemoteOperationResult result) {
 917         try {
 918             dismissDialog(DIALOG_OAUTH2_LOGIN_PROGRESS);
 919         } catch (IllegalArgumentException e) {
 920             // NOTHING TO DO ; can't find out what situation that leads to the exception in this code, but user logs signal that it happens
 921         }
 922
 923         String webdav_path = AccountUtils.getWebdavPath(mDiscoveredVersion, true);
 924         if (result.isSuccess() && webdav_path != null) {
 925             /// be gentle with the user
 926             showDialog(DIALOG_LOGIN_PROGRESS);
 927
 928             /// time to test the retrieved access token on the ownCloud server
 929             mOAuthAccessToken = ((OAuth2GetAccessToken)operation).getResultTokenMap().get(OAuth2Constants.KEY_ACCESS_TOKEN);
 930             Log_OC.d(TAG, "Got ACCESS TOKEN: " + mOAuthAccessToken);
 931             mAuthCheckOperation = new ExistenceCheckOperation("", this, false);
 932             WebdavClient client = OwnCloudClientUtils.createOwnCloudClient(Uri.parse(mHostBaseUrl + webdav_path), this);
 933             client.setBearerCredentials(mOAuthAccessToken);
 934             mAuthCheckOperation.execute(client, this, mHandler);
 935
 936         } else {
 937             updateAuthStatusIconAndText(result);
 938             showAuthStatus();
 939             Log_OC.d(TAG, "Access failed: " + result.getLogMessage());
 940         }
 941     }
 942
 943
 944     /**
 945      * Processes the result of the access check performed to try the user credentials.
 946      *
 947      * Creates a new account through the AccountManager.
 948      *
 949      * @param operation     Access check performed.
 950      * @param result        Result of the operation.
 951      */
 952     private void onAuthorizationCheckFinish(ExistenceCheckOperation operation, RemoteOperationResult result) {
 953         try {
 954             dismissDialog(DIALOG_LOGIN_PROGRESS);
 955         } catch (IllegalArgumentException e) {
 956             // NOTHING TO DO ; can't find out what situation that leads to the exception in this code, but user logs signal that it happens
 957         }
 958
 959         if (result.isSuccess()) {
 960             Log_OC.d(TAG, "Successful access - time to save the account");
 961
 962             if (mAction == ACTION_CREATE) {
 963                 createAccount();
 964
 965             } else {
 966                 updateToken();
 967             }
 968
 969             finish();
 970
 971         } else if (result.isServerFail() || result.isException()) {
 972             /// if server fail or exception in authorization, the UI is updated as when a server check failed
 973             mServerIsChecked = true;
 974             mServerIsValid = false;
 975             mIsSslConn = false;
 976             mOcServerChkOperation = null;
 977             mDiscoveredVersion = null;
 978             mHostBaseUrl = normalizeUrl(mHostUrlInput.getText().toString());
 979
 980             // update status icon and text
 981             updateServerStatusIconAndText(result);
 982             showServerStatus();
 983             mAuthStatusIcon = 0;
 984             mAuthStatusText = 0;
 985             showAuthStatus();
 986
 987             // update input controls state
 988             showRefreshButton();
 989             mOkButton.setEnabled(false);
 990
 991             // very special case (TODO: move to a common place for all the remote operations) (dangerous here?)
 992             if (result.getCode() == ResultCode.SSL_RECOVERABLE_PEER_UNVERIFIED) {
 993                 mLastSslUntrustedServerResult = result;
 994                 showDialog(DIALOG_SSL_VALIDATOR);
 995             }
 996
 997         } else {    // authorization fail due to client side - probably wrong credentials
 998             updateAuthStatusIconAndText(result);
 999             showAuthStatus();
1000             Log_OC.d(TAG, "Access failed: " + result.getLogMessage());
1001         }
1002     }
1003
1004
1005     /**
1006      * Sets the proper response to get that the Account Authenticator that started this activity saves
1007      * a new authorization token for mAccount.
1008      */
1009     private void updateToken() {
1010         Bundle response = new Bundle();
1011         response.putString(AccountManager.KEY_ACCOUNT_NAME, mAccount.name);
1012         response.putString(AccountManager.KEY_ACCOUNT_TYPE, mAccount.type);
1013         boolean isOAuth = mOAuth2Check.isChecked();
1014         if (isOAuth) {
1015             response.putString(AccountManager.KEY_AUTHTOKEN, mOAuthAccessToken);
1016             // the next line is necessary; by now, notifications are calling directly to the AuthenticatorActivity to update, without AccountManager intervention
1017             mAccountMgr.setAuthToken(mAccount, AccountAuthenticator.AUTH_TOKEN_TYPE_ACCESS_TOKEN, mOAuthAccessToken);
1018         } else {
1019             response.putString(AccountManager.KEY_AUTHTOKEN, mPasswordInput.getText().toString());
1020             mAccountMgr.setPassword(mAccount, mPasswordInput.getText().toString());
1021         }
1022         setAccountAuthenticatorResult(response);
1023     }
1024
1025
1026     /**
1027      * Creates a new account through the Account Authenticator that started this activity.
1028      *
1029      * This makes the account permanent.
1030      *
1031      * TODO Decide how to name the OAuth accounts
1032      */
1033     private void createAccount() {
1034         /// create and save new ownCloud account
1035         boolean isOAuth = mOAuth2Check.isChecked();
1036
1037         Uri uri = Uri.parse(mHostBaseUrl);
1038         String username = mUsernameInput.getText().toString().trim();
1039         if (isOAuth) {
1040             username = "OAuth_user" + (new java.util.Random(System.currentTimeMillis())).nextLong();
1041         }
1042         String accountName = username + "@" + uri.getHost();
1043         if (uri.getPort() >= 0) {
1044             accountName += ":" + uri.getPort();
1045         }
1046         mAccount = new Account(accountName, AccountAuthenticator.ACCOUNT_TYPE);
1047         if (isOAuth) {
1048             mAccountMgr.addAccountExplicitly(mAccount, "", null);  // with our implementation, the password is never input in the app
1049         } else {
1050             mAccountMgr.addAccountExplicitly(mAccount, mPasswordInput.getText().toString(), null);
1051         }
1052
1053         /// add the new account as default in preferences, if there is none already
1054         Account defaultAccount = AccountUtils.getCurrentOwnCloudAccount(this);
1055         if (defaultAccount == null) {
1056             SharedPreferences.Editor editor = PreferenceManager
1057                     .getDefaultSharedPreferences(this).edit();
1058             editor.putString("select_oc_account", accountName);
1059             editor.commit();
1060         }
1061
1062         /// prepare result to return to the Authenticator
1063         //  TODO check again what the Authenticator makes with it; probably has the same effect as addAccountExplicitly, but it's not well done
1064         final Intent intent = new Intent();
1065         intent.putExtra(AccountManager.KEY_ACCOUNT_TYPE,    AccountAuthenticator.ACCOUNT_TYPE);
1066         intent.putExtra(AccountManager.KEY_ACCOUNT_NAME,    mAccount.name);
1067         if (!isOAuth)
1068             intent.putExtra(AccountManager.KEY_AUTHTOKEN,   AccountAuthenticator.ACCOUNT_TYPE); // TODO check this; not sure it's right; maybe
1069         intent.putExtra(AccountManager.KEY_USERDATA,        username);
1070         if (isOAuth) {
1071             mAccountMgr.setAuthToken(mAccount, AccountAuthenticator.AUTH_TOKEN_TYPE_ACCESS_TOKEN, mOAuthAccessToken);
1072         }
1073         /// add user data to the new account; TODO probably can be done in the last parameter addAccountExplicitly, or in KEY_USERDATA
1074         mAccountMgr.setUserData(mAccount, AccountAuthenticator.KEY_OC_VERSION,    mDiscoveredVersion.toString());
1075         mAccountMgr.setUserData(mAccount, AccountAuthenticator.KEY_OC_BASE_URL,   mHostBaseUrl);
1076         if (isOAuth)
1077             mAccountMgr.setUserData(mAccount, AccountAuthenticator.KEY_SUPPORTS_OAUTH2, "TRUE");  // TODO this flag should be unnecessary
1078
1079         setAccountAuthenticatorResult(intent.getExtras());
1080         setResult(RESULT_OK, intent);
1081
1082         /// immediately request for the synchronization of the new account
1083         Bundle bundle = new Bundle();
1084         bundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
1085         ContentResolver.requestSync(mAccount, AccountAuthenticator.AUTHORITY, bundle);
1086     }
1087
1088
1089     /**
1090      * {@inheritDoc}
1091      *
1092      * Necessary to update the contents of the SSL Dialog
1093      *
1094      * TODO move to some common place for all possible untrusted SSL failures
1095      */
1096     @Override
1097     protected void onPrepareDialog(int id, Dialog dialog, Bundle args) {
1098         switch (id) {
1099         case DIALOG_LOGIN_PROGRESS:
1100         case DIALOG_CERT_NOT_SAVED:
1101         case DIALOG_OAUTH2_LOGIN_PROGRESS:
1102             break;
1103         case DIALOG_SSL_VALIDATOR: {
1104             ((SslValidatorDialog)dialog).updateResult(mLastSslUntrustedServerResult);
1105             break;
1106         }
1107         default:
1108             Log_OC.e(TAG, "Incorrect dialog called with id = " + id);
1109         }
1110     }
1111
1112
1113     /**
1114      * {@inheritDoc}
1115      */
1116     @Override
1117     protected Dialog onCreateDialog(int id) {
1118         Dialog dialog = null;
1119         switch (id) {
1120         case DIALOG_LOGIN_PROGRESS: {
1121             /// simple progress dialog
1122             ProgressDialog working_dialog = new ProgressDialog(this);
1123             working_dialog.setMessage(getResources().getString(R.string.auth_trying_to_login));
1124             working_dialog.setIndeterminate(true);
1125             working_dialog.setCancelable(true);
1126             working_dialog
1127             .setOnCancelListener(new DialogInterface.OnCancelListener() {
1128                 @Override
1129                 public void onCancel(DialogInterface dialog) {
1130                     /// TODO study if this is enough
1131                     Log_OC.i(TAG, "Login canceled");
1132                     if (mOperationThread != null) {
1133                         mOperationThread.interrupt();
1134                         finish();
1135                     }
1136                 }
1137             });
1138             dialog = working_dialog;
1139             break;
1140         }
1141         case DIALOG_OAUTH2_LOGIN_PROGRESS: {
1142             ProgressDialog working_dialog = new ProgressDialog(this);
1143             working_dialog.setMessage(String.format("Getting authorization"));
1144             working_dialog.setIndeterminate(true);
1145             working_dialog.setCancelable(true);
1146             working_dialog
1147             .setOnCancelListener(new DialogInterface.OnCancelListener() {
1148                 @Override
1149                 public void onCancel(DialogInterface dialog) {
1150                     Log_OC.i(TAG, "Login canceled");
1151                     finish();
1152                 }
1153             });
1154             dialog = working_dialog;
1155             break;
1156         }
1157         case DIALOG_SSL_VALIDATOR: {
1158             /// TODO start to use new dialog interface, at least for this (it is a FragmentDialog already)
1159             dialog = SslValidatorDialog.newInstance(this, mLastSslUntrustedServerResult, this);
1160             break;
1161         }
1162         case DIALOG_CERT_NOT_SAVED: {
1163             AlertDialog.Builder builder = new AlertDialog.Builder(this);
1164             builder.setMessage(getResources().getString(R.string.ssl_validator_not_saved));
1165             builder.setCancelable(false);
1166             builder.setPositiveButton(R.string.common_ok, new DialogInterface.OnClickListener() {
1167                 @Override
1168                 public void onClick(DialogInterface dialog, int which) {
1169                     dialog.dismiss();
1170                 };
1171             });
1172             dialog = builder.create();
1173             break;
1174         }
1175         default:
1176             Log_OC.e(TAG, "Incorrect dialog called with id = " + id);
1177         }
1178         return dialog;
1179     }
1180
1181
1182     /**
1183      * Starts and activity to open the 'new account' page in the ownCloud web site
1184      *
1185      * @param view      'Account register' button
1186      */
1187     public void onRegisterClick(View view) {
1188         Intent register = new Intent(Intent.ACTION_VIEW, Uri.parse(getString(R.string.url_account_register)));
1189         setResult(RESULT_CANCELED);
1190         startActivity(register);
1191     }
1192
1193
1194     /**
1195      * Updates the content and visibility state of the icon and text associated
1196      * to the last check on the ownCloud server.
1197      */
1198     private void showServerStatus() {
1199         TextView tv = (TextView) findViewById(R.id.server_status_text);
1200
1201         if (mServerStatusIcon == 0 && mServerStatusText == 0) {
1202             tv.setVisibility(View.INVISIBLE);
1203
1204         } else {
1205             tv.setText(mServerStatusText);
1206             tv.setCompoundDrawablesWithIntrinsicBounds(mServerStatusIcon, 0, 0, 0);
1207             tv.setVisibility(View.VISIBLE);
1208         }
1209
1210     }
1211
1212
1213     /**
1214      * Updates the content and visibility state of the icon and text associated
1215      * to the interactions with the OAuth authorization server.
1216      */
1217     private void showAuthStatus() {
1218         if (mAuthStatusIcon == 0 && mAuthStatusText == 0) {
1219             mAuthStatusLayout.setVisibility(View.INVISIBLE);
1220
1221         } else {
1222             mAuthStatusLayout.setText(mAuthStatusText);
1223             mAuthStatusLayout.setCompoundDrawablesWithIntrinsicBounds(mAuthStatusIcon, 0, 0, 0);
1224             mAuthStatusLayout.setVisibility(View.VISIBLE);
1225         }
1226     }
1227
1228
1229     private void showRefreshButton() {
1230         mHostUrlInput.setCompoundDrawablesWithIntrinsicBounds(0, 0, R.drawable.ic_action_refresh_black, 0);
1231         mRefreshButtonEnabled = true;
1232
1233         if (!mHostUrlInputEnabled){
1234            mCheckServerButton.setVisibility(View.VISIBLE);
1235         }
1236     }
1237
1238     private void hideRefreshButton() {
1239         mHostUrlInput.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0);
1240         mRefreshButtonEnabled = false;
1241
1242         if (!mHostUrlInputEnabled){
1243             mCheckServerButton.setVisibility(View.INVISIBLE);
1244         }
1245     }
1246
1247     /**
1248      * Called when the refresh button in the input field for ownCloud host is clicked.
1249      *
1250      * Performs a new check on the URL in the input field.
1251      *
1252      * @param view      Refresh 'button'
1253      */
1254     public void onRefreshClick() {
1255         checkOcServer();
1256     }
1257
1258
1259     /**
1260      * Called when the eye icon in the password field is clicked.
1261      *
1262      * Toggles the visibility of the password in the field.
1263      */
1264     public void onViewPasswordClick() {
1265         int selectionStart = mPasswordInput.getSelectionStart();
1266         int selectionEnd = mPasswordInput.getSelectionEnd();
1267         if (isPasswordVisible()) {
1268             hidePassword();
1269         } else {
1270             showPassword();
1271         }
1272         mPasswordInput.setSelection(selectionStart, selectionEnd);
1273     }
1274
1275
1276     /**
1277      * Called when the checkbox for OAuth authorization is clicked.
1278      *
1279      * Hides or shows the input fields for user & password.
1280      *
1281      * @param view      'View password' 'button'
1282      */
1283     public void onCheckClick(View view) {
1284         CheckBox oAuth2Check = (CheckBox)view;
1285         changeViewByOAuth2Check(oAuth2Check.isChecked());
1286
1287     }
1288
1289     /**
1290      * Changes the visibility of input elements depending upon the kind of authorization
1291      * chosen by the user: basic or OAuth
1292      *
1293      * @param checked       'True' when OAuth is selected.
1294      */
1295     public void changeViewByOAuth2Check(Boolean checked) {
1296
1297         if (checked) {
1298             mOAuthAuthEndpointText.setVisibility(View.VISIBLE);
1299             mOAuthTokenEndpointText.setVisibility(View.VISIBLE);
1300             mUsernameInput.setVisibility(View.GONE);
1301             mPasswordInput.setVisibility(View.GONE);
1302         } else {
1303             mOAuthAuthEndpointText.setVisibility(View.GONE);
1304             mOAuthTokenEndpointText.setVisibility(View.GONE);
1305             mUsernameInput.setVisibility(View.VISIBLE);
1306             mPasswordInput.setVisibility(View.VISIBLE);
1307         }
1308
1309     }
1310
1311     /**
1312      * Called from SslValidatorDialog when a new server certificate was correctly saved.
1313      */
1314     public void onSavedCertificate() {
1315         mOperationThread = mOcServerChkOperation.retry(this, mHandler);
1316     }
1317
1318     /**
1319      * Called from SslValidatorDialog when a new server certificate could not be saved
1320      * when the user requested it.
1321      */
1322     @Override
1323     public void onFailedSavingCertificate() {
1324         showDialog(DIALOG_CERT_NOT_SAVED);
1325     }
1326
1327
1328     /**
1329      *  Called when the 'action' button in an IME is pressed ('enter' in software keyboard).
1330      *
1331      *  Used to trigger the authorization check when the user presses 'enter' after writing the password.
1332      */
1333     @Override
1334     public boolean onEditorAction(TextView inputField, int actionId, KeyEvent event) {
1335         if (inputField != null && inputField.equals(mPasswordInput) &&
1336                 actionId == EditorInfo.IME_ACTION_DONE) {
1337             if (mOkButton.isEnabled()) {
1338                 mOkButton.performClick();
1339             }
1340         }
1341         return false;   // always return false to grant that the software keyboard is hidden anyway
1342     }
1343
1344
1345     private abstract static class RightDrawableOnTouchListener implements OnTouchListener  {
1346
1347         private int fuzz = 75;
1348
1349         /**
1350          * {@inheritDoc}
1351          */
1352         @Override
1353         public boolean onTouch(View view, MotionEvent event) {
1354             Drawable rightDrawable = null;
1355             if (view instanceof TextView) {
1356                 Drawable[] drawables = ((TextView)view).getCompoundDrawables();
1357                 if (drawables.length > 2) {
1358                     rightDrawable = drawables[2];
1359                 }
1360             }
1361             if (rightDrawable != null) {
1362                 final int x = (int) event.getX();
1363                 final int y = (int) event.getY();
1364                 final Rect bounds = rightDrawable.getBounds();
1365                 if (x >= (view.getRight() - bounds.width() - fuzz) && x <= (view.getRight() - view.getPaddingRight() + fuzz)
1366                     && y >= (view.getPaddingTop() - fuzz) && y <= (view.getHeight() - view.getPaddingBottom()) + fuzz) {
1367
1368                     return onDrawableTouch(event);
1369                 }
1370             }
1371             return false;
1372         }
1373
1374         public abstract boolean onDrawableTouch(final MotionEvent event);
1375     }
1376
1377 }