Android Open Source - NativeClient-Android Login Manager

From Project

Back to project page NativeClient-Android.
License

The source code is released under:
Apache License
If you think the Android project NativeClient-Android listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
Java Source Code

/*
Copyright (c) Microsoft/*  w  ww  .jav  a2s.  c  om*/
All Rights Reserved
Apache 2.0 License
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
See the Apache Version 2.0 License for specific language governing permissions and limitations under the License.
 */
/**
 * LoginManager.java
 */

package com.azure.webapi;

import java.util.Locale;

import org.apache.http.client.methods.HttpPost;
import org.apache.http.protocol.HTTP;

import android.annotation.SuppressLint;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.graphics.Bitmap;
import android.view.MotionEvent;
import android.view.View;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.EditText;
import android.widget.LinearLayout;

import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonParser;

/**
 * Class for handling Login operations with Authentication Providers and Windows
 * Azure Mobile Services
 */
@SuppressLint({ "SetJavaScriptEnabled" })
class LoginManager {
  /**
   * The MobileServiceClient used to invoke the login operations
   */
  private MobileServiceClient mClient;

  /**
   * Login process initial URL
   */
  private static final String START_URL = "login/";

  /**
   * Login process final URL
   */
  private static final String END_URL = "login/done";

  /**
   * Token indicator for interactive authentication URL
   */
  private static final String TOKEN_MARK = "#token=";

  /**
   * Authentication Token parameter in JSON objects
   */
  private static final String TOKEN_JSON_PARAMETER = "authenticationToken";

  /**
   * UserId property in JSON objects
   */
  private static final String USERID_JSON_PROPERTY = "userId";

  /**
   * User property in JSON objects
   */
  private static final String USER_JSON_PROPERTY = "user";

  /**
   * Constructor for LoginManager
   * 
   * @param client
   *            The MobileServiceClient used to invoke the login operations
   */
  public LoginManager(MobileServiceClient client) {
    if (client == null) {
      throw new IllegalArgumentException("Client can not be null");
    }

    mClient = client;
  }

  /**
   * Invokes Windows Azure Mobile Service authentication using a
   * provider-specific oAuth token
   * 
   * @param provider
   *            The provider used for the authentication process
   * @param oAuthToken
   *            The oAuth token used for authentication
   * @param callback
   *            Callback to invoke when the authentication process finishes
   */

  public void authenticate(MobileServiceAuthenticationProvider provider,
      String oAuthToken, final UserAuthenticationCallback callback) {
    if (oAuthToken == null || oAuthToken.trim() == "") {
      throw new IllegalArgumentException(
          "oAuthToken can not be null or empty");
    }

    // Create the login URL
    String url = mClient.getAppUrl().toString() + LoginManager.START_URL
        + provider.toString().toLowerCase(Locale.getDefault());

    authenticateWithToken(oAuthToken, url, callback);
  }

  /**
   * Creates the UI for the interactive authentication process
   * 
   * @param provider
   *            The provider used for the authentication process
   * @param startUrl
   *            The initial URL for the authentication process
   * @param endUrl
   *            The final URL for the authentication process
   * @param context
   *            The context used to create the authentication dialog
   * @param callback
   *            Callback to invoke when the authentication process finishes
   */
  protected void showLoginUI(MobileServiceAuthenticationProvider provider,
      final String startUrl, final String endUrl, final Context context,
      LoginUIOperationCallback callback) {
    if (startUrl == null || startUrl == "") {
      throw new IllegalArgumentException(
          "startUrl can not be null or empty");
    }

    if (endUrl == null || endUrl == "") {
      throw new IllegalArgumentException(
          "endUrl can not be null or empty");
    }

    if (context == null) {
      throw new IllegalArgumentException("context can not be null");
    }

    final LoginUIOperationCallback externalCallback = callback;
    final AlertDialog.Builder builder = new AlertDialog.Builder(context);
    // Create the Web View to show the login page
    final WebView wv = new WebView(context);
    builder.setTitle("Connecting to a service");
    builder.setCancelable(true);
    builder.setOnCancelListener(new DialogInterface.OnCancelListener() {

      @Override
      public void onCancel(DialogInterface dialog) {
        if (externalCallback != null) {
          externalCallback.onCompleted(null,
              new MobileServiceException("User Canceled"));
        }
      }
    });

    // Set cancel button's action
    builder.setNegativeButton("Cancel",
        new DialogInterface.OnClickListener() {

          @Override
          public void onClick(DialogInterface dialog, int which) {
            if (externalCallback != null) {
              externalCallback
                  .onCompleted(null,
                      new MobileServiceException(
                          "User Canceled"));
            }
            wv.destroy();
          }
        });

    wv.getSettings().setJavaScriptEnabled(true);

    wv.requestFocus(View.FOCUS_DOWN);
    wv.setOnTouchListener(new View.OnTouchListener() {

      @Override
      public boolean onTouch(View view, MotionEvent event) {
        int action = event.getAction();
        if (action == MotionEvent.ACTION_DOWN
            || action == MotionEvent.ACTION_UP) {
          if (!view.hasFocus()) {
            view.requestFocus();
          }
        }

        return false;
      }
    });

    // Create a LinearLayout and add the WebView to the Layout
    LinearLayout layout = new LinearLayout(context);
    layout.setOrientation(LinearLayout.VERTICAL);
    layout.addView(wv);

    // Add a dummy EditText to the layout as a workaround for a bug
    // that prevents showing the keyboard for the WebView on some devices
    EditText dummyEditText = new EditText(context);
    dummyEditText.setVisibility(View.GONE);
    layout.addView(dummyEditText);

    // Add the layout to the dialog
    builder.setView(layout);

    final AlertDialog dialog = builder.create();

    wv.setWebViewClient(new WebViewClient() {

      @Override
      public void onPageStarted(WebView view, String url, Bitmap favicon) {
        // If the URL of the started page matches with the final URL
        // format, the login process finished
        if (isFinalUrl(url)) {
          if (externalCallback != null) {
            externalCallback.onCompleted(url, null);
          }

          dialog.dismiss();
        }

        super.onPageStarted(view, url, favicon);
      }

      // Checks if the given URL matches with the final URL's format
      private boolean isFinalUrl(String url) {
        if (url == null) {
          return false;
        }

        return url.startsWith(endUrl);
      }

      // Checks if the given URL matches with the start URL's format
      private boolean isStartUrl(String url) {
        if (url == null) {
          return false;
        }

        return url.startsWith(startUrl);
      }

      @Override
      public void onPageFinished(WebView view, String url) {
        if (isStartUrl(url)) {
          if (externalCallback != null) {
            externalCallback
                .onCompleted(
                    null,
                    new MobileServiceException(
                        "Logging in with the selected authentication provider is not enabled"));
          }

          dialog.dismiss();
        }
      }
    });

    wv.loadUrl(startUrl);
    dialog.show();
  }

  /**
   * Creates a User based on a Windows Azure Mobile Service JSON object
   * containing a UserId and Authentication Token
   * 
   * @param json
   *            JSON object used to create the User
   * @return The created user if it is a valid JSON object. Null otherwise
   * @throws MobileServiceException
   */
  private MobileServiceUser createUserFromJSON(JsonObject json)
      throws MobileServiceException {
    if (json == null) {
      throw new IllegalArgumentException("json can not be null");
    }

    // If the JSON object is valid, create a MobileServiceUser object
    if (json.has(USER_JSON_PROPERTY)) {
      JsonObject jsonUser = json.getAsJsonObject(USER_JSON_PROPERTY);

      if (!jsonUser.has(USERID_JSON_PROPERTY)) {
        throw new JsonParseException(USERID_JSON_PROPERTY
            + " property expected");
      }
      String userId = jsonUser.get(USERID_JSON_PROPERTY).getAsString();

      MobileServiceUser user = new MobileServiceUser(userId);

      if (!json.has(TOKEN_JSON_PARAMETER)) {
        throw new JsonParseException(TOKEN_JSON_PARAMETER
            + " property expected");
      }

      user.setAuthenticationToken(json.get(TOKEN_JSON_PARAMETER)
          .getAsString());
      return user;
    } else {
      // If the JSON contains an error property show it, otherwise raise
      // an error with JSON content
      if (json.has("error")) {
        throw new MobileServiceException(json.get("error")
            .getAsString());
      } else {
        throw new JsonParseException(json.toString());
      }
    }
  }

  /**
   * Invokes Windows Azure Mobile Services authentication using the specified
   * token
   * 
   * @param token
   *            The token used for authentication
   * @param url
   *            The URL used for the authentication process
   * @param callback
   *            Callback to invoke when the authentication process finishes
   */
  private void authenticateWithToken(String token, String url,
      final UserAuthenticationCallback callback) {
    if (token == null) {
      throw new IllegalArgumentException("token can not be null");
    }

    if (url == null) {
      throw new IllegalArgumentException("url can not be null");
    }

    // Create a request
    final ServiceFilterRequest request = new ServiceFilterRequestImpl(
        new HttpPost(url));
    request.addHeader(HTTP.CONTENT_TYPE, MobileServiceConnection.JSON_CONTENTTYPE);
    
    try {
      // Set request's content with the token
      request.setContent(token);
    } catch (Exception e) {
      // this should never happen
    }
    final MobileServiceConnection connection = mClient.createConnection();

    // Create the AsyncTask that will execute the request
    new RequestAsyncTask(request, connection) {
      @Override
      protected void onPostExecute(ServiceFilterResponse response) {
        if (callback != null) {

          if (mTaskException == null && response != null) {
            MobileServiceUser user = null;
            try {
              // Get the user from the response and create a
              // MobileServiceUser object from the JSON
              String content = response.getContent();
              user = createUserFromJSON((JsonObject) new JsonParser()
                  .parse((content.trim())));

            } catch (Exception e) {
              // Something went wrong, call onCompleted method
              // with exception
              callback.onCompleted(null,
                  new MobileServiceException(
                      "Error while authenticating user.",
                      e), response);
              return;
            }

            // Call onCompleted method
            callback.onCompleted(user, null, response);
          } else {
            // Something went wrong, call onCompleted method with
            // exception
            callback.onCompleted(null, new MobileServiceException(
                "Error while authenticating user.",
                mTaskException), response);
          }
        }
      }
    }.execute();
  }

  /**
   * Internal callback used after the interactive authentication UI is
   * completed
   */
  interface LoginUIOperationCallback {
    /**
     * Method to call if the operation finishes successfully
     * 
     * @param url
     *            The final login URL
     * @param e
     *            An exception representing the error, in case there was one
     */
    void onCompleted(String url, Exception exception);

  }
}
Java Source Code List
