Agregar autenticación a su aplicación de Android

Artículo
06/25/2019

Resumen

En este tutorial podrá agregar la autenticación al proyecto de inicio rápido todolist en Android con un proveedor de identidades admitido. Este tutorial está basado en el tutorial Introducción a Mobile Apps, que debe completar primero.

Registro de la aplicación para la autenticación y configuración de Azure App Service

En primer lugar, debe registrar la aplicación en el sitio del proveedor de identidades y, a continuación, establecerá las credenciales generadas por el proveedor en el back-end de Mobile Apps.

Configure el proveedor de identidades preferido siguiendo las instrucciones específicas del proveedor:
Repita los pasos anteriores para cada proveedor que desee admitir en su aplicación.

Adición de la aplicación a las direcciones URL de redirección externa permitidas

La autenticación segura requiere que se defina un nuevo esquema de dirección URL para la aplicación. Esto permite que el sistema de autenticación se redirija a la aplicación una vez completado el proceso de autenticación. En este tutorial, se usará el esquema de dirección URL appname. Sin embargo, puede utilizar cualquier otro esquema de dirección URL que elija. Debe ser único para la aplicación móvil. Para habilitar la redirección en el lado de servidor:

En Azure Portal, seleccione el servicio App Service.
Haga clic en la opción de menú Autenticación/autorización.
En URL de redirección externas permitidas, introduzca appname://easyauth.callback. El valor de appname de esta cadena es el esquema de dirección URL para la aplicación móvil. Debe seguir la especificación normal de las direcciones URL para un protocolo (usar únicamente letras y números, y comenzar por una letra). Debe tomar nota de la cadena que elija ya que necesitará ajustar el código de la aplicación móvil con el esquema de direcciones URL en varios sitios.
Haga clic en OK.
Haga clic en Save(Guardar).

Restricción de los permisos para los usuarios autenticados

De forma predeterminada, se pueden invocar las API en un back-end de Mobile Apps de forma anónima. A continuación, deberá restringir el acceso a solo los clientes autenticados.

Back-end de Node.js (a través de Azure Portal):

En la configuración Mobile Apps, haga clic en Tablas fáciles y seleccione la tabla. Haga clic en Cambiar permisos, seleccione Solo acceso autenticado para todos los permisos y luego haga clic en Guardar.
Back-end de .NET (C#):

En el proyecto de servidor, vaya aControllersTodoItemController.cs>. Agregue el atributo [Authorize] a la clase TodoItemController , como sigue. Para restringir el acceso solo a determinados métodos, también puede aplicar este atributo solo a esos métodos en lugar de la clase. Vuelva a publicar el proyecto de servidor.
```
  [Authorize]
  public class TodoItemController : TableController<TodoItem>
```
Back-end de Node.js (a través del código de Node.js) :

Para pedir autenticación para acceder a las tablas, agregue la siguiente línea al script del servidor de Node.js:
```
  table.access = 'authenticated';
```
Para más información, consulte Autenticación necesaria para el acceso a las tablas. Para obtener información sobre cómo descargar el proyecto de código de inicio rápido desde su sitio, consulte Cómo: descargar el proyecto de código de inicio rápido de back-end de Node.js con Git.

En Android Studio, abra el proyecto que ha completado con el tutorial Introducción a Mobile Apps. En el menú Run (Ejecutar), haga clic en Run app (Ejecutar aplicación). A continuación, compruebe que se lleva a cabo una excepción no controlada con el código de estado 401 (No autorizado) después de que se inicie la aplicación.

Esta excepción produce porque la aplicación intenta obtener acceso al back-end como usuario sin autenticar, pero la tabla TodoItem requiere ahora autenticación.

A continuación, actualice la aplicación para autenticar usuarios antes de solicitar recursos del back-end de Mobile Apps.

Incorporación de autenticación a la aplicación

Abra el proyecto en Android Studio.

En el Explorador de proyectos de Android Studio, abra el archivo ToDoActivity.java y agregue las siguientes instrucciones de importación:

import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

import com.microsoft.windowsazure.mobileservices.authentication.MobileServiceAuthenticationProvider;
import com.microsoft.windowsazure.mobileservices.authentication.MobileServiceUser;

Agregue el método siguiente a la clase ToDoActivity :

// You can choose any unique number here to differentiate auth providers from each other. Note this is the same code at login() and onActivityResult().
public static final int GOOGLE_LOGIN_REQUEST_CODE = 1;

private void authenticate() {
    // Sign in using the Google provider.
    mClient.login(MobileServiceAuthenticationProvider.Google, "{url_scheme_of_your_app}", GOOGLE_LOGIN_REQUEST_CODE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // When request completes
    if (resultCode == RESULT_OK) {
        // Check the request code matches the one we send in the login request
        if (requestCode == GOOGLE_LOGIN_REQUEST_CODE) {
            MobileServiceActivityResult result = mClient.onActivityResult(data);
            if (result.isLoggedIn()) {
                // sign-in succeeded
                createAndShowDialog(String.format("You are now signed in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                createTable();
            } else {
                // sign-in failed, check the error message
                String errorMessage = result.getErrorMessage();
                createAndShowDialog(errorMessage, "Error");
            }
        }
    }
}

Con este código, se crea un método para administrar el proceso de autenticación de Google. Aparece un cuadro de diálogo que muestra el identificador del usuario autenticado. Solo puede continuar si la autenticación es correcta.

Nota

Si usa un proveedor de identidades que no sea Google, cambie el valor pasado al método login a uno de los siguientes: MicrosoftAccount, Facebook, Twitter o windowsazureactivedirectory.

En el método onCreate, agregue la siguiente línea de código después del código que crea una instancia del objeto MobileServiceClient.
```
authenticate();
```
De este modo se llama al proceso de autenticación.

Mueva el código restante después de authenticate(); en el método onCreate a un nuevo método createTable :

private void createTable() {

    // Get the table instance to use.
    mToDoTable = mClient.getTable(ToDoItem.class);

    mTextNewToDo = (EditText) findViewById(R.id.textNewToDo);

    // Create an adapter to bind the items with the view.
    mAdapter = new ToDoItemAdapter(this, R.layout.row_list_to_do);
    ListView listViewToDo = (ListView) findViewById(R.id.listViewToDo);
    listViewToDo.setAdapter(mAdapter);

    // Load the items from Azure.
    refreshItemsFromTable();
}

Para asegurarse de que el redireccionamiento funcione, agregue el siguiente fragmento de código de RedirectUrlActivity a AndroidManifest.xml:

<activity android:name="com.microsoft.windowsazure.mobileservices.authentication.RedirectUrlActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="{url_scheme_of_your_app}"
            android:host="easyauth.callback"/>
    </intent-filter>
</activity>

Agregue redirectUriScheme a build.gradle de la aplicación Android.

android {
    buildTypes {
        release {
            // ...
            manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
        }
        debug {
            // ...
            manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
        }
    }
}

Agregue com.android.support:customtabs:23.0.1 a las dependencias de build.gradle:

dependencies {
    // ...
    compile 'com.android.support:customtabs:23.0.1'
}

En el menú Ejecutar, haga clic en Ejecutar aplicación para iniciar la aplicación e inicie sesión con el proveedor de identidades que haya elegido.

Advertencia

El esquema de dirección URL mencionado distingue mayúsculas de minúsculas. Asegúrese de que todas las apariciones de {url_scheme_of_you_app} usen las mayúsculas y minúsculas del mismo modo.

Si ha iniciado sesión correctamente, la aplicación se ejecutará sin errores y deberá poder consultar el servicio back-end y realizar actualizaciones en los datos.

Almacenamiento en caché de tokens de autenticación en el cliente

En el ejemplo anterior se mostró un inicio de sesión estándar, que requiere que el cliente se ponga en contacto con el proveedor de identidades y con el servicio de Azure de back-end cada vez que se inicia la aplicación. Este método no es eficaz y puede tener problemas relacionados con el uso si muchos clientes intentan iniciar la aplicación al mismo tiempo. Un método mejor es almacenar en caché el token de autorización devuelto por el servicio de Azure e intentar usarlo primero antes de emplear un inicio de sesión basado en proveedores.

Nota

Puede almacenar en caché el token emitido por el servicio de Azure de back-end con independencia de si es una autenticación administrada por el cliente o por el servicio. Este tutorial utiliza la autenticación administrada por el servicio.

Abra el archivo ToDoActivity.java y agregue las siguientes instrucciones de importación:

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

Agregue los siguientes métodos a la clase ToDoActivity .

public static final String SHAREDPREFFILE = "temp";
public static final String USERIDPREF = "uid";
public static final String TOKENPREF = "tkn";

En el archivo ToDoActivity.java, agregue la siguiente definición para el método cacheUserToken.
```
private void cacheUserToken(MobileServiceUser user)
{
    SharedPreferences prefs = getSharedPreferences(SHAREDPREFFILE, Context.MODE_PRIVATE);
    Editor editor = prefs.edit();
    editor.putString(USERIDPREF, user.getUserId());
    editor.putString(TOKENPREF, user.getAuthenticationToken());
    editor.commit();
}
```
Este método almacena el identificador de usuario y el token en un archivo de preferencias que está marcado como privado. Esto debería proteger el acceso a la memoria caché para que otras aplicaciones del dispositivo no tengan acceso al token. La preferencia es un espacio aislado de la aplicación. Sin embargo, si alguien obtiene acceso al dispositivo, es posible que pueda tener acceso a la caché del token mediante otros medios.

Nota

Puede proteger adicionalmente el token con cifrado si el acceso del token a los datos se considera sumamente sensible y alguien puede obtener acceso al dispositivo. Sin embargo, una solución completamente segura está fuera del alcance de este tutorial y depende de los requisitos de seguridad.

En el archivo ToDoActivity.java, agregue la siguiente definición para el método loadUserTokenCache.

private boolean loadUserTokenCache(MobileServiceClient client)
{
    SharedPreferences prefs = getSharedPreferences(SHAREDPREFFILE, Context.MODE_PRIVATE);
    String userId = prefs.getString(USERIDPREF, null);
    if (userId == null)
        return false;
    String token = prefs.getString(TOKENPREF, null);
    if (token == null)
        return false;

    MobileServiceUser user = new MobileServiceUser(userId);
    user.setAuthenticationToken(token);
    client.setCurrentUser(user);

    return true;
}

En el archivo ToDoActivity.java, reemplace los métodos authenticate y onActivityResult por los siguientes, que usan una caché del token. Cambie el proveedor de inicio de sesión si desea usar otra cuenta que no sea la de Google.

private void authenticate() {
    // We first try to load a token cache if one exists.
    if (loadUserTokenCache(mClient))
    {
        createTable();
    }
    // If we failed to load a token cache, sign in and create a token cache
    else
    {
        // Sign in using the Google provider.
        mClient.login(MobileServiceAuthenticationProvider.Google, "{url_scheme_of_your_app}", GOOGLE_LOGIN_REQUEST_CODE);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // When request completes
    if (resultCode == RESULT_OK) {
        // Check the request code matches the one we send in the sign-in request
        if (requestCode == GOOGLE_LOGIN_REQUEST_CODE) {
            MobileServiceActivityResult result = mClient.onActivityResult(data);
            if (result.isLoggedIn()) {
                // sign-in succeeded
                createAndShowDialog(String.format("You are now signed in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                cacheUserToken(mClient.getCurrentUser());
                createTable();
            } else {
                // sign-in failed, check the error message
                String errorMessage = result.getErrorMessage();
                createAndShowDialog(errorMessage, "Error");
            }
        }
    }
}

Cree la aplicación y pruebe la autenticación mediante una cuenta válida. Ejecútela al menos dos veces. Durante la primera ejecución, debe recibir un mensaje para iniciar sesión y crear la memoria caché del token. Después de eso, cada ejecución intenta cargar la caché de tokens para la autenticación. No es necesario para iniciar sesión.

Pasos siguientes

Ahora que ha completado este tutorial de autenticación básica, considere la posibilidad de continuar con uno de los siguientes tutoriales:

Incorporación de notificaciones push a la aplicación de Android Aprenda a configurar su back-end de Mobile Apps para usar Azure Notification Hubs para enviar notificaciones de inserción.
Habilitación de la sincronización sin conexión para la aplicación móvil de Android Aprenda a agregar compatibilidad sin conexión a una aplicación con un back-end de Mobile Apps. Con la sincronización sin conexión, los usuarios pueden interactuar con una aplicación móvil (ver, agregar o modificar datos), incluso cuando no hay conexión de red.

Compartir a través de