web-dev-qa-db-fra.com

Comment obtenir l'adresse de messagerie principale du périphérique Android

Comment obtenez-vous l'adresse de messagerie principale d'Android (ou une liste d'adresses de messagerie)?

Si j'ai bien compris, OS 2.0+ prend en charge plusieurs adresses électroniques, mais en dessous de 2.0, vous ne pouvez avoir qu'une seule adresse électronique par appareil.

androidemail
407
Brandon O'Rourke

Il existe plusieurs façons de procéder, présentées ci-dessous.

En guise d'avertissement convivial, soyez vigilant et immédiatement vis-à-vis de l'utilisateur lorsque vous utilisez un compte, un profil et des données de contact. Si vous utilisez abusivement l'adresse électronique d'un utilisateur ou d'autres informations personnelles, de mauvaises choses peuvent arriver.

Méthode A: Utiliser AccountManager (API de niveau 5+)

Vous pouvez utiliser AccountManager.getAccounts ou AccountManager.getAccountsByType pour obtenir la liste de tous les noms de compte du périphérique. Heureusement, pour certains types de compte (y compris com.google), les noms de compte sont des adresses électroniques. Exemple d'extrait ci-dessous.

Pattern emailPattern = Patterns.EMAIL_ADDRESS; // API level 8+
Account[] accounts = AccountManager.get(context).getAccounts();
for (Account account : accounts) {
    if (emailPattern.matcher(account.name).matches()) {
        String possibleEmail = account.name;
        ...
    }
}

Notez que cela nécessite l'autorisation GET_ACCOUNTS:

<uses-permission Android:name="Android.permission.GET_ACCOUNTS" />

Vous trouverez plus d'informations sur l'utilisation de AccountManager dans l'exemple de code Contact Manager dans le SDK.

Méthode B: Utiliser ContactsContract.Profile (API de niveau 14+)

À partir de Android 4.0 (sandwich à la crème glacée), vous pouvez obtenir l'adresse électronique de l'utilisateur en accédant à son profil. L'accès au profil de l'utilisateur est un peu lourd, car il nécessite deux autorisations (plus en détail ci-dessous), mais les adresses électroniques sont des éléments de données assez sensibles; il s'agit donc du prix d'entrée.

Vous trouverez ci-dessous un exemple complet qui utilise un CursorLoader pour récupérer des lignes de données de profil contenant des adresses électroniques.

public class ExampleActivity extends Activity implements LoaderManager.LoaderCallbacks<Cursor> {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLoaderManager().initLoader(0, null, this);
    }

    @Override
    public Loader<Cursor> onCreateLoader(int id, Bundle arguments) {
        return new CursorLoader(this,
                // Retrieve data rows for the device user's 'profile' contact.
                Uri.withAppendedPath(
                        ContactsContract.Profile.CONTENT_URI,
                        ContactsContract.Contacts.Data.CONTENT_DIRECTORY),
                ProfileQuery.PROJECTION,

                // Select only email addresses.
                ContactsContract.Contacts.Data.MIMETYPE + " = ?",
                new String[]{ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE},

                // Show primary email addresses first. Note that there won't be
                // a primary email address if the user hasn't specified one.
                ContactsContract.Contacts.Data.IS_PRIMARY + " DESC");
    }

    @Override
    public void onLoadFinished(Loader<Cursor> cursorLoader, Cursor cursor) {
        List<String> emails = new ArrayList<String>();
        cursor.moveToFirst();
        while (!cursor.isAfterLast()) {
            emails.add(cursor.getString(ProfileQuery.ADDRESS));
            // Potentially filter on ProfileQuery.IS_PRIMARY
            cursor.moveToNext();
        }

        ...
    }

    @Override
    public void onLoaderReset(Loader<Cursor> cursorLoader) {
    }

    private interface ProfileQuery {
        String[] PROJECTION = {
                ContactsContract.CommonDataKinds.Email.ADDRESS,
                ContactsContract.CommonDataKinds.Email.IS_PRIMARY,
        };

        int ADDRESS = 0;
        int IS_PRIMARY = 1;
    }
}

Cela nécessite les autorisations READ_PROFILE et READ_CONTACTS:

<uses-permission Android:name="Android.permission.READ_PROFILE" />
<uses-permission Android:name="Android.permission.READ_CONTACTS" />
743
Roman Nurik

Cela pourrait être utile aux autres:

tiliser AccountPicker pour obtenir l'adresse électronique de l'utilisateur sans autorisation globale et permettre à l'utilisateur de prendre connaissance et d'autoriser ou d'annuler le processus.

54
Jorge Cevallos

Je voudrais utiliser le AccountPicker d'Android, introduit dans ICS.

Intent googlePicker = AccountPicker.newChooseAccountIntent(null, null, new String[]{GoogleAuthUtil.GOOGLE_ACCOUNT_TYPE}, true, null, null, null, null);
startActivityForResult(googlePicker, REQUEST_CODE);

Et puis attendez le résultat:

protected void onActivityResult(final int requestCode, final int resultCode,
                                final Intent data) {
    if (requestCode == REQUEST_CODE && resultCode == RESULT_OK) {
        String accountName = data.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
    }
}
27
SeBsZ
public String getUsername() {
    AccountManager manager = AccountManager.get(this);
    Account[] accounts = manager.getAccountsByType("com.google");
    List<String> possibleEmails = new LinkedList<String>();

    for (Account account : accounts) {
        // TODO: Check possibleEmail against an email regex or treat
        // account.name as an email address only for certain account.type values.
        possibleEmails.add(account.name);
    }

    if (!possibleEmails.isEmpty() && possibleEmails.get(0) != null) {
        String email = possibleEmails.get(0);
        String[] parts = email.split("@");

        if (parts.length > 1)
            return parts[0];
    }
    return null;
}
14
Afzaal Iftikhar

Malheureusement, la réponse ne fonctionne pas.

Je suis en retard, mais voici la solution pour l'application de messagerie interne Android sauf si le contenu de l'URI est modifié par le fournisseur:

Uri EMAIL_ACCOUNTS_DATABASE_CONTENT_URI = 
              Uri.parse("content://com.Android.email.provider/account");

public ArrayList<String> GET_EMAIL_ADDRESSES ()
{
    ArrayList<String> names = new ArrayList<String>();
    ContentResolver cr      = m_context.getContentResolver();
    Cursor cursor           = cr.query(EMAIL_ACCOUNTS_DATABASE_CONTENT_URI ,null, 
                             null, null, null);

    if (cursor == null) {
        Log.e("TEST", "Cannot access email accounts database");
        return null;
    }

    if (cursor.getCount() <= 0) {
        Log.e("TEST", "No accounts");
        return null;
    }

    while (cursor.moveToNext()) {
        names.add(cursor.getString(cursor.getColumnIndex("emailAddress")));
        Log.i("TEST", cursor.getString(cursor.getColumnIndex("emailAddress")));
    }
    return names;
}
7
Burak Day

Il existe une API Android qui permet à l'utilisateur de sélectionner son adresse e-mail sans autorisation. Consultez: https://developers.google.com/identity/smartlock-passwords/Android/retrieve-hints

HintRequest hintRequest = new HintRequest.Builder()
        .setHintPickerConfig(new CredentialPickerConfig.Builder()
                .setShowCancelButton(true)
                .build())
        .setEmailAddressIdentifierSupported(true)
        .setAccountTypes(IdentityProviders.GOOGLE)
        .build();

PendingIntent intent = mCredentialsClient.getHintPickerIntent(hintRequest);
try {
    startIntentSenderForResult(intent.getIntentSender(), RC_HINT, null, 0, 0, 0);
} catch (IntentSender.SendIntentException e) {
    Log.e(TAG, "Could not start hint picker Intent", e);
}

Cela montrera un sélecteur où l'utilisateur peut sélectionner une adresse email. Le résultat sera livré dans onActivityResult()

7
Wirling

C’est assez compliqué à faire dans Android et je ne l’ai pas encore fait. Mais peut-être que ces liens peuvent vous aider:

6
AGrunewald

Utilisez cette méthode:

 public String getUserEmail() {
    AccountManager manager = AccountManager.get(App.getInstance());
    Account[] accounts = manager.getAccountsByType("com.google");
    List<String> possibleEmails = new LinkedList<>();
    for (Account account : accounts) {
        possibleEmails.add(account.name);
    }
    if (!possibleEmails.isEmpty() && possibleEmails.get(0) != null) {
        return possibleEmails.get(0);
    }
    return "";
}

Notez que cela nécessite l'autorisation GET_ACCOUNTS:

<uses-permission Android:name="Android.permission.GET_ACCOUNTS" />

Ensuite:

editTextEmailAddress.setText(getUserEmail());
1
Iman Marashi

Android verrouillé GET_ACCOUNTS récemment afin que certaines des réponses ne fonctionnent pas pour moi. Je travaille sur Android 7.0 avec l'avertissement que vos utilisateurs doivent supporter un dialogue d'autorisation.

AndroidManifest.xml

<uses-permission Android:name="Android.permission.GET_ACCOUNTS"/>

MainActivity.Java

package com.example.patrick.app2;
import Android.content.pm.PackageManager;
import Android.support.v4.app.ActivityCompat;
import Android.support.v4.content.ContextCompat;
import Android.support.v7.app.AppCompatActivity;
import Android.os.Bundle;
import Android.accounts.AccountManager;
import Android.accounts.Account;
import Android.app.AlertDialog;
import Android.content.DialogInterface;
import Android.content.*;

public class MainActivity extends AppCompatActivity {

    final static int requestcode = 4; //arbitrary constant less than 2^16

    private static String getEmailId(Context context) {
        AccountManager accountManager = AccountManager.get(context);
        Account[] accounts = accountManager.getAccountsByType("com.google");
        Account account;
        if (accounts.length > 0) {
            account = accounts[0];
        } else {
            return "length is zero";
        }
        return account.name;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case requestcode:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                    String emailAddr = getEmailId(getApplicationContext());
                    ShowMessage(emailAddr);

                } else {
                    ShowMessage("Permission Denied");
                }
        }
    }

    public void ShowMessage(String email)
    {
        AlertDialog alertDialog = new AlertDialog.Builder(MainActivity.this).create();
        alertDialog.setTitle("Alert");
        alertDialog.setMessage(email);
        alertDialog.setButton(AlertDialog.BUTTON_NEUTRAL, "OK",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                    }
                });
        alertDialog.show();
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Context context = getApplicationContext();

        if ( ContextCompat.checkSelfPermission( context, Android.Manifest.permission.GET_ACCOUNTS )
                != PackageManager.PERMISSION_GRANTED )
        {
            ActivityCompat.requestPermissions( this, new String[]
                            {  Android.Manifest.permission.GET_ACCOUNTS  },requestcode );
        }
        else
        {
            String possibleEmail = getEmailId(getApplicationContext());
            ShowMessage(possibleEmail);
        }
    }
}
0
astronought

Travailler dans le système d'exploitation Marshmallow

    btn_click=(Button) findViewById(R.id.btn_click);

    btn_click.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View arg0)
        {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
            {
                int permissionCheck = ContextCompat.checkSelfPermission(PermissionActivity.this,
                        Android.Manifest.permission.CAMERA);
                if (permissionCheck == PackageManager.PERMISSION_GRANTED)
                {
                    //showing dialog to select image
                    String possibleEmail=null;

                     Pattern emailPattern = Patterns.EMAIL_ADDRESS; // API level 8+
                     Account[] accounts = AccountManager.get(PermissionActivity.this).getAccounts();
                     for (Account account : accounts) {
                         if (emailPattern.matcher(account.name).matches()) {
                             possibleEmail = account.name;
                             Log.e("keshav","possibleEmail"+possibleEmail);
                         }
                     }

                    Log.e("keshav","possibleEmail gjhh->"+possibleEmail);
                    Log.e("permission", "granted Marshmallow O/S");

                } else {                        ActivityCompat.requestPermissions(PermissionActivity.this,
                            new String[]{Android.Manifest.permission.READ_EXTERNAL_STORAGE,
                                    Android.Manifest.permission.READ_PHONE_STATE,
                                    Manifest.permission.GET_ACCOUNTS,
                                    Android.Manifest.permission.CAMERA}, 1);
                }
            } else {
// Lower then Marshmallow

                    String possibleEmail=null;

                     Pattern emailPattern = Patterns.EMAIL_ADDRESS; // API level 8+
                     Account[] accounts = AccountManager.get(PermissionActivity.this).getAccounts();
                     for (Account account : accounts) {
                         if (emailPattern.matcher(account.name).matches()) {
                             possibleEmail = account.name;
                             Log.e("keshav","possibleEmail"+possibleEmail);
                     }

                    Log.e("keshav","possibleEmail gjhh->"+possibleEmail);


            }
        }
    });
0
Keshav Gera