it-swarm.com.de

So erhalten Sie die primäre E-Mail-Adresse des Android Geräts

Wie erhält man die primäre E-Mail-Adresse von Android (oder eine Liste von E-Mail-Adressen)?

Unter OS 2.0+ werden meines Erachtens mehrere E-Mail-Adressen unterstützt, unter 2.0 kann jedoch nur eine E-Mail-Adresse pro Gerät angegeben werden.

407

Hierfür gibt es verschiedene Möglichkeiten (siehe unten).

Seien Sie als freundliche Warnung dem Benutzer gegenüber vorsichtig und offen im Umgang mit Konto-, Profil- und Kontaktdaten. Wenn Sie die E-Mail-Adresse eines Benutzers oder andere persönliche Informationen missbrauchen, können schlimme Dinge passieren.

Methode A: Verwenden Sie AccountManager (API Level 5+)

Sie können AccountManager.getAccounts oder AccountManager.getAccountsByType, um eine Liste aller Kontonamen auf dem Gerät abzurufen. Zum Glück für bestimmte Kontotypen (einschließlich com.google) sind die Kontonamen E-Mail-Adressen. Beispiel-Snippet unten.

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;
        ...
    }
}

Beachten Sie, dass hierfür das GET_ACCOUNTS Genehmigung:

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

Weitere Informationen zur Verwendung von AccountManager finden Sie im Beispielcode Contact Manager im SDK.

Methode B: Verwenden Sie ContactsContract.Profile (API-Ebene 14+)

Ab Android 4.0 (Ice Cream Sandwich)) können Sie die E-Mail-Adressen des Benutzers abrufen, indem Sie auf sein Profil zugreifen. Der Zugriff auf das Benutzerprofil ist etwas schwer, da zwei Berechtigungen erforderlich sind (mehr dazu weiter unten). Da es sich bei E-Mail-Adressen jedoch um sensible Daten handelt, ist dies der Eintrittspreis.

Unten finden Sie ein vollständiges Beispiel, in dem ein CursorLoader zum Abrufen von Profildatenzeilen mit E-Mail-Adressen verwendet wird.

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;
    }
}

Dies erfordert sowohl die READ_PROFILE und READ_CONTACTS Berechtigungen:

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

Dies könnte für andere nützlich sein:

Verwenden von AccountPicker, um die E-Mail-Adresse des Benutzers abzurufen ohne globale Berechtigungen, und dem Benutzer ermöglichen, den Vorgang zu kennen und zu autorisieren oder abzubrechen.

54
Jorge Cevallos

Ich würde Android AccountPicker verwenden, eingeführt in ICS.

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

Und dann warten Sie auf das Ergebnis:

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

Leider funktioniert die akzeptierte Antwort nicht.

Ich bin spät dran, aber hier ist die Lösung für die interne Android E-Mail-Anwendung, es sei denn, die Inhalts-URL wird vom Anbieter geändert:

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

Es gibt eine Android api, mit der der Nutzer seine E-Mail-Adresse ohne Erlaubnis auswählen kann. Schauen Sie sich Folgendes an: https://developers.google.com/identity/Smartlock-Passwörter/Android/Abrufhinweise

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);
}

Dies zeigt eine Auswahl, in der der Benutzer eine E-Mail-Adresse auswählen kann. Das Ergebnis wird in onActivityResult() geliefert.

7
Wirling
6
AGrunewald

Verwenden Sie diese Methode:

 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 "";
}

Beachten Sie, dass hierfür das GET_ACCOUNTS Genehmigung:

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

Dann:

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

Android gesperrt GET_ACCOUNTS In letzter Zeit haben einige der Antworten bei mir nicht funktioniert. Ich habe dies auf Android 7.0 mit dem Vorbehalt, dass Ihre Benutzer einen Berechtigungsdialog ertragen müssen.

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

In Marshmallow-Betriebssystem arbeiten

    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