Google Anmelden und Abmelden in Android mit g-plus neuesten API

Question

Ich habe einige der stackoverflow Fragen im Zusammenhang mit der Anmeldung und Abmeldung von Google Plus. Und die meisten von ihnen sind veraltet. Ich kann nicht erreichen, was ich eigentlich will.

Sobald ich mich abmelde, möchte ich bei der nächsten Anmeldung den verfügbaren Google-Account auswählen, um mich erneut anzumelden.

Ich benutze benutzerdefinierten Anmelde- und Abmelde-Button. Und für Abmelde, ich habe zwei Fälle

1. Abmelde kurz vor Anmelde, wenn ein Benutzer bereits in der gleichen Login-Aktivität melden.
2. Abmeldung von der anderen Aktivität.

Hier ist, was ich bisher umgesetzt haben:

public class LoginActivity extends AppCompatActivity implements OnClickListener{ 

    private static final int RC_SIGN_IN = 9001; 
    private GoogleApiClient mGoogleApiClient; 
    private ConnectionResult mGoogleConnectionResult; 
    private Button login; 
    private ProgressDialog mProgressDialog; 
    private Context mContext; 
    private String mUri; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     mContext= LoginActivity.this; 
     requestWindowFeature(Window.FEATURE_NO_TITLE); 
     setContentView(R.layout.login_layout); 

     login= (Button) findViewById(R.id.lg_login_btn); 
     login.setOnClickListener(this); 
    } 

    @Override 
    public void onClick(View v) { 
     if(isOnline(mContext)){ 
      if(v.getId()== R.id.lg_login_btn) { 
       if(mGoogleApiClient!=null){ 
        mGoogleApiClient.disconnect(); 
       } 
      GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN) 
      .requestScopes(new Scope(Scopes.PLUS_LOGIN)) 
      .requestEmail() 
      .build(); 

    mGoogleApiClient = new GoogleApiClient.Builder(mContext.getApplicationContext()) 
      .enableAutoManage(this , mGPlusConnectionFailedListener) 
      .addApi(Auth.GOOGLE_SIGN_IN_API, gso) 
      .addApi(Plus.API) 
      .build(); 

     signOutGPlus(); 
     Intent lSignInIntent= Auth.GoogleSignInApi.getSignInIntent(mGoogleApiClient); 
     startActivityForResult(lSignInIntent, RC_SIGN_IN); 

      } 
     } else{ 
      showAlertDialog(mContext, "Error", "Please check internet connection"); 
     } 
    } 
    @Override 
    protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
     super.onActivityResult(requestCode, resultCode, data); 
     logD("&&onActivityResult", "requestCode: "+requestCode);  // first 

     if (requestCode == RC_SIGN_IN) { 
      if(resultCode == RESULT_OK){ 
       showProgressDialog(); 
       getGPlusUserInfo(data); 
      } else { 
       logD("&&onActivityResult", "requestCode: RESULT_ NOT Ok"+requestCode); 
      } 
     } 
    } 

    GoogleApiClient.OnConnectionFailedListener mGPlusConnectionFailedListener= new GoogleApiClient.OnConnectionFailedListener() { 
     @Override 
     public void onConnectionFailed(@NonNull ConnectionResult connectionResult) { 
      logD("&&mGPlusConnectionFailedListener", "onConnectionFailed"); 
     } 
    }; 

    private void getGPlusUserInfo(Intent data){ 
     GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data); 
     handleSignInResult(result); 
    } 

    private void handleSignInResult(GoogleSignInResult result) { 
     Log.d("&&handleSignInResult", "handleSignInResult:" + result.isSuccess()); 
     if (result.isSuccess()) { 
      // Signed in successfully, show authenticated UI. 
      String lDisplayName=""; 
      String lEmail=""; 
      String lFirstName=""; 
      String lLastName=""; 
      String lGender=""; 

      // G+ 
      if (mGoogleApiClient.hasConnectedApi(Plus.API)) { 
       logD("&&GPlusUserInfo", "&hasConnectedApi--------------------------------"); 
       // Deprecated 
       Person person = Plus.PeopleApi.getCurrentPerson(mGoogleApiClient); 
       if(null != person) { 
        logD("&&GPlusUserInfo", "&--------------------------------"); 
        logD("&&GPlusUserInfo", "&Display Name: " + person.getDisplayName()); 
       lDisplayName= person.getDisplayName(); 
        logD("&&GPlusUserInfo", "Gender: " + person.getGender()); 
        if(person.getGender()< MyHalConstants.GENDER.length){ 
         lGender= MyHalConstants.GENDER[person.getGender()]; 
        } else{ 
         lGender= "Other"; 
        } 
       } 
      } 
      GoogleSignInAccount acct = result.getSignInAccount(); 

      if(null != acct) { 
       if (null != acct.getDisplayName()) { 
        logD("&&GPlusUserInfo", "&Display Name: " + acct.getDisplayName()); 
       } 
       lFirstName= acct.getGivenName(); 
       lLastName= acct.getFamilyName(); 
       // Views inside NavigationView's header 
       Uri uri = acct.getPhotoUrl();     
      } 
     } else { 
      // Signed out, show unauthenticated UI. 
      signOutGPlus(); 
     } 
    } 


    // sign - out 
    private void signOutGPlus(){ 
     logD("&&signOutGPlus", "signOutGPlus"); 
     if(null != mGoogleApiClient){ 
      mGoogleApiClient.connect(); 
      mGoogleApiClient.registerConnectionCallbacks(new GoogleApiClient.ConnectionCallbacks() { 

       @Override 
       public void onConnected(@Nullable Bundle bundle) { 
        if(mGoogleApiClient.isConnected()) { 
         logD("&&signOutGPlus", "inside"); 
        Auth.GoogleSignInApi.signOut(mGoogleApiClient).setResultCallback(
          new ResultCallback<Status>() { 
            @Override 
            public void onResult(@NonNull Status status) { 
             logD("&&signOutGPlus", "onResult"); 
             if(mGoogleApiClient.isConnected()){ 
             mGoogleApiClient.clearDefaultAccountAndReconnect(); 
              mGoogleApiClient.disconnect(); 
            } 
            // Deprecated 
            /*Plus.AccountApi.clearDefaultAccount(mGoogleApiClient); 
            //Plus.AccountApi.revokeAccessAndDisconnect(mGoogleApiClient); 
            //revokeAccess();*/ 
            } 
           } 
        ); 
        } 
       } 

       @Override 
       public void onConnectionSuspended(int i) { 

       } 
      }); 
     } 
    } 

// Not used 
    private void revokeAccess() { 
    logD("&&revokeAccess", "revokeAccess"); 
    Auth.GoogleSignInApi.revokeAccess(mGoogleApiClient).setResultCallback(
      new ResultCallback<Status>() { 
        @Override 
        public void onResult(Status status) { 
         // ... 
        } 
       }); 
    } 

    private void showProgressDialog() { 
     if (mProgressDialog == null) { 
      mProgressDialog = new ProgressDialog(this); 
      mProgressDialog.setMessage(getString(R.string.loading)); 
      mProgressDialog.setIndeterminate(true); 
     } 

     mProgressDialog.show(); 
    } 

    private void hideProgressDialog() { 
     if (mProgressDialog != null && mProgressDialog.isShowing()) { 
      mProgressDialog.hide(); 
     } 
    } 

    private void showAlertDialog(Context pContext, String pTitle, String pMessage){ 
     AlertDialog.Builder ldialogBuilder= new AlertDialog.Builder(pContext); 
     ldialogBuilder.setTitle(pTitle) 
      .setMessage(pMessage) 
     .setPositiveButton("Ok", null); 
     ldialogBuilder.show(); 
    } 

    private void dismissDialog(){ 
     if(null != mProgressDialog){ 
      mProgressDialog.dismiss(); 
      mProgressDialog= null; 
     } 
    } 
} 

Was Abmelde aus verschiedenen Aktivitäten, keine der Antworten, die ich über kam definieren, wie mGoogleApiClient in der neuen Aktivität initilaize .

Für die Abmelde wenn ich implementieren den Code unten:

private GoogleApiClient mGoogleApiClient; 

// sign - out 
private void signOutGPlusFromDifferentActivity(){ 
    logD("&&signOutGPlus", "signOutGPlus"); 
    GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN) 
      .requestScopes(new Scope(Scopes.PLUS_LOGIN)) 
      .requestEmail() 
      .build(); 

    mGoogleApiClient = new GoogleApiClient.Builder(mContext.getApplicationContext()) 
      .addApi(Auth.GOOGLE_SIGN_IN_API, gso) 
      .addApi(Plus.API) 
      .build(); 
    if(null != mGoogleApiClient){ 
     mGoogleApiClient.connect(); 
     mGoogleApiClient.registerConnectionCallbacks(new GoogleApiClient.ConnectionCallbacks() { 
      @Override 
      public void onConnected(@Nullable Bundle bundle) { 
       if(mGoogleApiClient.isConnected()) { 
        logD("&&signOutGPlus", "inside"); 
        Auth.GoogleSignInApi.signOut(mGoogleApiClient).setResultCallback(
          new ResultCallback<Status>() { 
           @Override 
           public void onResult(@NonNull Status status) { 
            logD("&&signOutGPlus", "onResult"); 
            if(mGoogleApiClient.isConnected()){ 
             mGoogleApiClient.clearDefaultAccountAndReconnect(); 
             mGoogleApiClient.disconnect(); 
            } 
           } 
          } 
        ); 
       } 
      } 
      @Override 
      public void onConnectionSuspended(int i) { 

      } 
     }); 
    } 
} 

Es Fehler wirft.

Durch das Entfernen des Abmeldeteils von der Login-Aktivität kann ich mich ordnungsgemäß bei GPlus anmelden.

Gradle:

compile 'com.google.android.gms:play-services-auth:9.2.1' 
compile 'com.google.android.gms:play-services:9.2.1' 

HINWEIS: von der Anmeldeaktivität kann ich entweder von Google anmelden plus oder face-book.

Aktivität A (Anmeldung von g + oder fb).

Nach der Anmeldung wird der Benutzer zu Aktivität B geleitet, von Aktivität B kann sich der Benutzer aus dem entsprechenden Portal abmelden (g + oder fb).

Facebook-Teil ist fertig. Nur übrig bleibt g +.

Bitte helfen Sie bei der Abmeldung in beiden Fällen durch die Verwendung von aktualisierten GOOGLE LOGIN LOGOUT APIs.

Answer 1

Tun Sie dies in Ihrer zweite Aktivität Wenn Sie irgendeine Präferenz sparen bezüglich Login in der ersten Aktivität dann klar, dass es auf Abmelde klicken

package com.ccc.bbbb; 

import com.google.android.gms.common.ConnectionResult; 
import com.google.android.gms.common.api.GoogleApiClient; 
import com.google.android.gms.common.api.GoogleApiClient.ConnectionCallbacks; 
import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener; 
import com.google.android.gms.common.api.ResultCallback; 
import com.google.android.gms.plus.People; 
import com.google.android.gms.plus.People.LoadPeopleResult; 
import com.google.android.gms.plus.Plus; 



//implement ConnectionCallbacks, OnConnectionFailedListener,ResultCallback<People.LoadPeopleResult> 

public class HomeActivity extends Activity implements OnClickListener ,ConnectionCallbacks, OnConnectionFailedListener, 
ResultCallback<People.LoadPeopleResult> 
{ 

    public static boolean isLogout=false; 
    GoogleApiClient mGoogleApiClient; 


    @Override 
    protected void onCreate(Bundle savedInstanceState) 
    { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_home); 

     mGoogleApiClient = new GoogleApiClient.Builder(this) 
     .addConnectionCallbacks(this) 
     .addOnConnectionFailedListener(this).addApi(Plus.API) 
     .addScope(Plus.SCOPE_PLUS_LOGIN).build(); 

      //Logout button click 


        if(networkCheck.isNetworkAvailable(HomeActivity.this)) 
        { 
         Log.d(TAG, "logout if condition working...."); 


          isLogout=true; 

          if(mGoogleApiClient.isConnected()) 
          { 
           Plus.AccountApi.clearDefaultAccount(mGoogleApiClient); 
           mGoogleApiClient.disconnect(); 
           mGoogleApiClient.connect(); 
          } 
          Toast.makeText(HomeActivity.this, "you are logged out", Toast.LENGTH_SHORT).show(); 

          Intent intent=new Intent(HomeActivity.this,MainActivity.class); 
          startActivity(intent); 
          finish(); 

         } 



//override below methods and copy those codes 

     @Override 
     public void onResult(@NonNull LoadPeopleResult arg0) { 
      // TODO Auto-generated method stub 

     } 


     @Override 
     public void onConnectionFailed(@NonNull ConnectionResult arg0) { 
      // TODO Auto-generated method stub 

     } 


     @Override 
     public void onConnected(@Nullable Bundle arg0) { 
      // TODO Auto-generated method stub 
      mSignInClicked = false; 

      // updateUI(true); 
      Plus.PeopleApi.loadVisible(mGoogleApiClient, null).setResultCallback(
        this); 

     } 


     @Override 
     public void onConnectionSuspended(int arg0) { 
      // TODO Auto-generated method stub 
      mGoogleApiClient.connect(); 

     } 

     @Override 
     protected void onStart() { 
      // TODO Auto-generated method stub 
      super.onStart(); 
      mGoogleApiClient.connect(); 

     } 
     @Override 
     protected void onStop() 
     { 
      // TODO Auto-generated method stub 
      super.onStop(); 
      if (mGoogleApiClient.isConnected()) { 
       mGoogleApiClient.disconnect(); 
      } 
      if (mDialog.isShowing()) { 
       mDialog.dismiss(); 
      } 

     } 




} 

Answer 2

Einmal Ich habe mich abgemeldet. Wenn ich mich das nächste Mal anmelde, möchte ich, dass der Nutzer das verfügbare Google-Konto auswählt, um sich erneut anzumelden.

Der Trick ist, clearDefaultAccountAndReconnect die GoogleApiClient kurz nach der Benutzer klickt auf der Google-Schaltfläche Anmelden anmelden. Dadurch wird sichergestellt, dass alle verfügbaren Google-Konten immer angezeigt werden, wenn Sie auf die Schaltfläche "Anmelden" klicken.

Schritt 1: GoogleAPIClient initialisieren und setzen OnClickListener zu googleSignInButton in Aktivität onCreate()

private GoogleApiClient mApiClient; 

private void initializeGoogleSignIn() { 
    GoogleSignInOptions signInOptions = new GoogleSignInOptions 
      .Builder(GoogleSignInOptions.DEFAULT_SIGN_IN) 
      .requestProfile() 
      .build(); 

    mApiClient = new GoogleApiClient.Builder(this) 
      .enableAutoManage(this, this) 
      .addApi(Auth.GOOGLE_SIGN_IN_API, signInOptions) 
      .build(); 

    SignInButton googleSignInButton = (SignInButton) findViewById(R.id.google_sign_in); 

    googleSignInButton.setOnClickListener(this); 
} 

SCHRITT 2: Behandeln Sie die Google Anmeldung durch Ihre onClick() -Methode

@Override 
public void onClick(View v) { 

    switch (v.getId()) { 
     case R.id.google_sign_in: 

      if (mApiClient.isConnected()) { 
       mApiClient.clearDefaultAccountAndReconnect(); 
      } else { 
       mApiClient.connect(); 
      } 

      Intent signInIntent = Auth.GoogleSignInApi.getSignInIntent(mApiClient); 
      startActivityForResult(signInIntent, RC_SIGN_IN); 

      break; 
    } 
} 

MISCALLANEOUS

// Make sure you connect and disconnect the GoogleApiClient in onStart and onStop lifecycle methods 
@Override 
protected void onStart() { 
    super.onStart(); 
    mApiClient.connect(); 
} 

@Override 
protected void onStop() { 
    super.onStop(); 
    if (mApiClient.isConnected()) 
     mApiClient.disconnect(); 
} 



@Override 
    protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
     super.onActivityResult(requestCode, resultCode, data); 
     if (requestCode == RC_SIGN_IN) { 
      GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data); 

      if (result != null && result.isSuccess()) { 

       GoogleSignInAccount account = result.getSignInAccount(); 

       setAppPreferenceData(account.getId(), account.getEmail(), String.valueOf(account.getPhotoUrl()), account.getDisplayName()); 

       startActivity(new Intent(this, NavigationActivity.class)); 


       finish(); 
      } else { 
       mProgressLayout.setVisibility(View.GONE); 

       if (Utils.isNetworkAvailable(this)) 
        Toast.makeText(this, "Google Authentication Failed! Please try again", Toast.LENGTH_SHORT).show(); 
       else 
        Toast.makeText(this, "Network Error! Please connect to your wifi.", Toast.LENGTH_LONG).show(); 
      } 
     } 
    } 

Warum brauchen Sie so viele Callback-Methoden in Ihrem Code? Ich nehme an, du hast deinen Code etwas kompliziert. Der Haupttrick besteht darin, das Standardkonto zu trennen und zu löschen, wenn der Benutzer versucht, sich einzuloggen, um sicherzustellen, dass ihm immer eine Liste gültiger Google-Konten angezeigt wird. Ich habe das gleiche Verfahren verwendet, es ist erprobt, getestet und funktioniert.

Nur eine Rückrufmethode für den in meiner App verwendeten Anmeldestatus.

public class SignInActivity extends AppCompatActivity implements 
     GoogleApiClient.OnConnectionFailedListener { 
} 

@Override 
public void onConnectionFailed(ConnectionResult connectionResult) { 
    Toast.makeText(SignInActivity.this, "Google Play connection error", Toast.LENGTH_SHORT).show(); 
    mProgressLayout.setVisibility(View.GONE); 
} 

Answer 3

Sobald ich Abmelde haben, ich das nächste Mal sich anmelden, würde ich den Benutzer mag die verfügbaren Google-Konto zu wählen, wieder melden.

Einfach den Benutzer abmelden und den Zugriff widerrufen, wenn der Benutzer auf die Schaltfläche zum Abmelden klickt. Wenn die Nutzer das nächste Mal versuchen, sich anzumelden, werden sie aufgefordert, ihr bevorzugtes Google-Konto auszuwählen.

Da Sie sich bei verschiedenen Aktivitäten an- und abmelden, erhalten Sie doppelten Code. Anstatt den Code zu duplizieren, verwenden Sie einfach eine Hilfsklasse und initialisieren Sie die Google SignIn-Option und den Google API-Client. Wann immer Sie den Google API-Client verwenden möchten, können Sie die Hilfsklasse initialisieren.

Fall 1. Wenn Sie sich vor dem Anmelden abmelden möchten, verwenden Sie clearDefaultAccountAndReconnect.

Fall 2. Verwenden Sie Auth.GoogleSignInApi.signOut(mGoogleApiClient).setResultCallback zum Abmelden des Benutzers (unabhängig von der Aktivität).

Hier ist die github link zum Projekt. Sie können einen Blick darauf werfen, wenn Sie noch Zweifel haben.

Answer 4

Für Sign-out Sie folgende Methode verwenden:

private void signOut() { 
    Auth.GoogleSignInApi.signOut(googleApiClient).setResultCallback(
      new ResultCallback<Status>() { 
       @Override 
       public void onResult(Status status) { 
        Timber.d("Logged out"); 
       } 
      }); 
} 

Für Sign-in Sie können diese Methoden folgen:

public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) { 
    this.activity = activity; 
    if (requestCode == RC_SIGN_IN) { 
     GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data); 
     handleSignInResult(result); 
    } 

    /*For inintializing googleapiclient*/ 
    private void initGoogleClient() { 

    gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN) 
      .requestEmail() 
      .build(); 

    googleApiClient = new GoogleApiClient.Builder(activity) 
      .enableAutoManage((FragmentActivity) activity /* FragmentActivity */, this /* OnConnectionFailedListener */) 
      .addApi(Auth.GOOGLE_SIGN_IN_API, gso) 
      .addOnConnectionFailedListener(this) 
      .addApi(Plus.API) 
      .addScope(new Scope(Scopes.PROFILE)) 
      .build(); 
} 

private void signIn() { 
    Intent signInIntent = Auth.GoogleSignInApi.getSignInIntent(googleApiClient); 
    activity.startActivityForResult(signInIntent, RC_SIGN_IN); 
}