Login d'Android – Authentificateur de compte vs Authentification manuelle

Je suis sur le point d'implémenter la connexion avec l'authentification des utilisateurs dans mon application.

Ma première idée était de le faire manuellement, enregistrer le nom d'utilisateur et le mot de passe avec le serveur, obtenir le jeton d'authentification, l'enregistrer et l'utiliser dans les demandes ultérieures.

  • Comment convertir une décharge de tas dans le format Android vers l'éclipse
  • Android For loop
  • Ai-je besoin des trois constructeurs pour une vue personnalisée Android?
  • Menu de tiroir secondaire de la bibliothèque de support de conception Android
  • Afficher le dialogue avec une animation qui croît d'un point
  • Que représentent les couleurs de l'élément d'arbre de référence HPROF de Android Studio?
  • Après avoir parcouru, j'ai compris que la façon correcte de le faire sur Android utilisait Account Authenticator. J'ai vu quelques exemples de sa mise en œuvre, mais je ne comprends pas l'avantage de le faire de cette façon? Est-ce parce que je peux avoir plus d'un compte stocké? Est-ce en raison de la synchronisation des problèmes? J'apprécierais que quelqu'un m'ait expliqué cela. Cela me permettrait de mieux comprendre le code pour le mieux et pourquoi il fait ce qu'il est.

  • Période d'image apparaissant même après Ellipsize dans Android textView
  • Bitmap recycle avec wideHeap activé
  • Modification des attributs imbriqués sur une mise en page incluse
  • L'accès à SharedPreferences devrait-il être supprimé de la thread UI?
  • Comment terminer une activité à partir d'un adaptateur ...?
  • Mettre en œuvre une base de feu à l'intérieur d'une bibliothèque
  • 3 Solutions collect form web for “Login d'Android – Authentificateur de compte vs Authentification manuelle”

    Je peux avoir plus d'un compte stocké?

    Oui. Voyez comment Google ou Facebook le font.

    Est-ce en raison de la synchronisation des problèmes?

    Oui, vous avez besoin d'un compte pour utiliser le mécanisme de synchronisation comme SyncAdapter

    Pourquoi devriez-vous utiliser AccountAuthenticator ?

    • Prise en charge du mécanisme de synchronisation de fond comme SyncAdapter ;

    • Mode standard pour authentifier les utilisateurs;

    • Soutenir différents jetons;

    • Partage de compte avec différents privilèges

    Qu'avez-vous besoin de faire?

    1). Créer un Authenticator ;

    2). Créer une Activity pour la connexion utilisateur;

    3). Créer un Service pour communiquer avec le compte.

    Termes.

    AccountManager – il gère le compte sur le périphérique. Demander les jetons d'authentification que vous devriez utiliser AccountManager .

    AbstractAccountAuthenticator – composant pour travailler avec les types de compte. Il contient toute la logique pour travailler avec le compte (autorisation, droits d'accès, etc.) Un AbstractAccountAuthenticator peut être utilisé par une application différente (comme Google compte pour Gmail, Calendar, Drive etc.)

    AccountAuthenticatorActivity – base Activity , pour autoriser / créer un compte. AccountManager appelle ce compte s'il est nécessaire d'identifier un compte (le jeton n'existe pas ou n'a pas expiré)

    Comment cela fonctionne-t-il? Regardez l'image ci-dessous:

    Diagramme de gestion de compte Android

    Pas.

    1). Créer un Authenticator ;

    Vous devez étendre les méthodes AbstractAccountAuthenticator et override 7:

    • Bundle editProperties(AccountAuthenticatorResponse response, String accountType)
    • Bundle addAccount(AccountAuthenticatorResponse response, String accountType, String authTokenType, String[] requiredFeatures, Bundle options)
    • Bundle confirmCredentials(AccountAuthenticatorResponse response, Account account, Bundle options)
    • Bundle getAuthToken(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle options)
    • String getAuthTokenLabel(String authTokenType) lien
    • Bundle updateCredentials(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle options) link
    • Bundle hasFeatures(AccountAuthenticatorResponse response, Account account, String[] features) link

    Exemple:

     public class LodossAuthenticator extends AbstractAccountAuthenticator { private static final String LOG_TAG = LodossAuthenticator.class.getSimpleName(); private final Context mContext; public LodossAuthenticator(Context context) { super(context); mContext = context; } @Override public Bundle editProperties(AccountAuthenticatorResponse response, String accountType) { return null; } @Override public Bundle addAccount(AccountAuthenticatorResponse response, String accountType, String authTokenType, String[] requiredFeatures, Bundle options) throws NetworkErrorException { final Intent intent = new Intent(mContext, CustomServerAuthenticatorSigninActivity.class); intent.putExtra(Config.ARG_ACCOUNT_TYPE, accountType); intent.putExtra(Config.ARG_AUTH_TYPE, authTokenType); intent.putExtra(Config.ARG_IS_ADDING_NEW_ACCOUNT, true); intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response); final Bundle bundle = new Bundle(); bundle.putParcelable(AccountManager.KEY_INTENT, intent); return bundle; } @Override public Bundle confirmCredentials(AccountAuthenticatorResponse response, Account account, Bundle options) throws NetworkErrorException { return null; } @Override public Bundle getAuthToken(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle options) throws NetworkErrorException { // If the caller requested an authToken type we don't support, then // return an error if (!authTokenType.equals(AccountGeneral.AUTHTOKEN_TYPE_READ_ONLY) && !authTokenType.equals(AccountGeneral.AUTHTOKEN_TYPE_FULL_ACCESS)) { final Bundle result = new Bundle(); result.putString(AccountManager.KEY_ERROR_MESSAGE, "invalid authTokenType"); return result; } // Extract the username and password from the Account Manager, and ask // the server for an appropriate AuthToken. final AccountManager am = AccountManager.get(mContext); String authToken = am.peekAuthToken(account, authTokenType); // Lets give another try to authenticate the user if (TextUtils.isEmpty(authToken)) { final String password = am.getPassword(account); if (password != null) { try { authToken = sServerAuthenticate.userSignIn(account.name, password, authTokenType); } catch (Exception e) { e.printStackTrace(); } } } // If we get an authToken - we return it if (!TextUtils.isEmpty(authToken)) { final Bundle result = new Bundle(); result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name); result.putString(AccountManager.KEY_ACCOUNT_TYPE, account.type); result.putString(AccountManager.KEY_AUTHTOKEN, authToken); return result; } // If we get here, then we couldn't access the user's password - so we // need to re-prompt them for their credentials. We do that by creating // an intent to display our AuthenticatorActivity. final Intent intent = new Intent(mContext, AuthenticatorActivity.class); intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response); intent.putExtra(com.lodoss.authlib.Config.ARG_ACCOUNT_TYPE, account.type); intent.putExtra(com.lodoss.authlib.Config.ARG_AUTH_TYPE, authTokenType); intent.putExtra(Config.ARG_ACCOUNT_NAME, account.name); final Bundle bundle = new Bundle(); bundle.putParcelable(AccountManager.KEY_INTENT, intent); return bundle; } @Override public String getAuthTokenLabel(String authTokenType) { if (AccountGeneral.AUTHTOKEN_TYPE_FULL_ACCESS.equals(authTokenType)) return AccountGeneral.AUTHTOKEN_TYPE_FULL_ACCESS_LABEL; else if (AccountGeneral.AUTHTOKEN_TYPE_READ_ONLY.equals(authTokenType)) return AccountGeneral.AUTHTOKEN_TYPE_READ_ONLY_LABEL; else return authTokenType + " (Label)"; } @Override public Bundle updateCredentials(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle options) throws NetworkErrorException { return null; } @Override public Bundle hasFeatures(AccountAuthenticatorResponse response, Account account, String[] features) throws NetworkErrorException { final Bundle result = new Bundle(); result.putBoolean(KEY_BOOLEAN_RESULT, false); return result; } } 

    Explication:

    Donc, vous devez voir seulement 2 méthodes: addAccount , getAuthToken .

    Dans addAccount j'ai ajouté certains paramètres de configuration, qui seront utilisés par mon Activity pour la connexion d'utilisateur. Le point principal ici est intent.putExtra(Config.ARG_ACCOUNT_TYPE, accountType); – vous devez spécifier le type de compte ici. D'autres manipulations ne sont pas nécessaires.

    Dans getAuthTokenLisez les commentaires s'il vous plaît . J'ai copié cette méthode avec UdinicAuthenticator.java

    De plus, vous aurez besoin des autorisations suivantes dans votre AndroidManifest.xml:

     <uses-permission android:name="android.permission.GET_ACCOUNTS" /> <uses-permission android:name="android.permission.MANAGE_ACCOUNTS" /> <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" /> <uses-permission android:name="android.permission.USE_CREDENTIALS" /> 

    Résumé des méthodes addAccount et getAuthToken

    Essayez d'obtenir un jeton, si le jeton existe un résultat de retour, sinon vous verrez Activity pour l'autorisation

    2). Créer une Activity pour la connexion utilisateur;

    Voir AuthenticatorActivity

    Brève explication: Créez un formulaire avec UserId et Password. En utilisant les données UserId & Password, obtenez le jeton auth du serveur, puis exécutez l'étape suivante:

     mAccountManager.addAccountExplicitly(account, accountPassword, null); mAccountManager.setAuthToken(account, authtokenType, authtoken); 

    3). Créer un Service pour communiquer avec le compte.

    Voir UdinicAuthenticatorService

    N'oubliez pas d'ajouter cette ligne dans AndroidManifest.xml au Service :

      <intent-filter> <action android:name="android.accounts.AccountAuthenticator" /> </intent-filter> <meta-data android:name="android.accounts.AccountAuthenticator" android:resource="@xml/authenticator" /> 

    Et aussi dans res/xml add file authenticator.xml :

     <?xml version="1.0" encoding="utf-8"?> <account-authenticator xmlns:android="http://schemas.android.com/apk/res/android" android:accountType="com.mediamanagment.app" android:icon="@drawable/ic_launcher" android:smallIcon="@drawable/ic_launcher" android:label="@string/authenticator_label"/> 

    C'est tout. Vous pouvez utiliser votre AccountAuthenticator .

    Pour les matériaux sources grâce à

    Le AccountManager est bon pour les raisons suivantes:

    • Premièrement, il faut stocker plusieurs noms de comptes avec différents niveaux d'accès aux fonctionnalités de l'application sous un seul type de compte. Par exemple, dans une application de diffusion vidéo, on peut avoir deux noms de compte: l'un avec un accès de démonstration à un nombre limité de vidéos et l'autre avec un accès complet à toutes les vidéos. Ce n'est pas la principale raison de l'utilisation des Accounts , cependant, puisque vous pouvez facilement gérer cela dans votre application sans avoir besoin de cette apparence fantastique …
    • L'autre avantage de l'utilisation de Accounts est de se débarrasser de l'autorisation traditionnelle avec le nom d'utilisateur et le mot de passe chaque fois qu'une personne autorisée demande une fonctionnalité autorisée, car l'authentification a lieu en arrière-plan et l'utilisateur ne demande son mot de passe que dans certaines conditions, Que je vais y parvenir plus tard.
    • L'utilisation de la fonctionnalité Accounts dans Android supprime également la nécessité de définir son propre type de compte. Vous avez probablement rencontré les applications à l'aide des comptes Google pour obtenir l'autorisation, ce qui permet d'économiser le souci de créer un nouveau compte et de se souvenir de ses informations d'identification pour l'utilisateur.
    • Accounts peuvent être ajoutés de manière indépendante via Paramètres → Comptes
    • L'autorisation utilisateur multiplate-forme peut être facilement gérée à l'aide de Accounts . Par exemple, le client peut accéder au matériel protégé en même temps dans son appareil Android et son PC sans avoir besoin de connexion récurrente.
    • Du point de vue de la sécurité, l'utilisation du même mot de passe dans toutes les requêtes vers le serveur permet une écoute possible dans des connexions non sécurisées. Le cryptage par mot de passe n'est pas suffisant ici pour éviter le vol de mot de passe.
    • Enfin, une raison importante pour utiliser la fonctionnalité Accounts dans Android est de séparer les deux parties impliquées dans toute entreprise dépendant des Accounts , appelée authentique et propriétaire de ressources, sans compromettre les informations d'identification du client (utilisateur). Les termes peuvent sembler plutôt vagues, mais n'abandonnez pas jusqu'à lire le paragraphe suivant … 😉

    Permettez-moi de préciser ce dernier avec un exemple d'application de diffusion vidéo. La société A est titulaire d'une entreprise de streaming vidéo en contrat avec la société B pour fournir à certains membres des services premium de diffusion. La société B utilise une méthode de nom d'utilisateur et de mot de passe pour reconnaître son utilisateur. Pour que la société A reconnaisse les membres premium de B, l'une des façons serait d'obtenir la liste de celles-ci de B et d'utiliser un mécanisme d'appariement de nom d'utilisateur / mot de passe similaire. De cette façon, l'authentificateur et le propriétaire de la ressource sont les mêmes (Société A). Outre l'obligation des utilisateurs de se souvenir d'un deuxième mot de passe, il est très probable qu'ils fixent le même mot de passe que le profil de leur société B pour l'utilisation des services de A. Ceci n'est évidemment pas favorable.

    Pour apaiser les lacunes ci-dessus, OAuth a été présentée. En tant que norme ouverte pour l'autorisation, dans l'exemple ci-dessus, OAuth exige que l'autorisation soit effectuée par la société B (authentificateur) en émettant un jeton appelé Token d'accès pour les utilisateurs éligibles (tiers), puis en fournissant à la Société A (propriétaire de la ressource) Le jeton. Donc, aucun jeton ne signifie aucune éligibilité.

    J'ai développé plus sur ceci et plus sur AccountManager sur mon site Web ici

    Dans les paramètres d'Android, vous avez un compte pour votre type de compte et vous pouvez ajouter un compte à partir de là. AccountManager est également un endroit central pour stocker les informations d'identification, de sorte que vous ne vous connectez que pour chaque vendeur. Si vous téléchargez une autre application Google ou accédez à une application à plusieurs reprises, vous ne saisissez que les informations d'identification une fois

    coAndroid est un fan Android de Google, tout sur les téléphones Android, Android Wear, Android Dev et Android Games Apps.