web-dev-qa-db-fra.com

Google+ déconnecter d'une activité différente

J'ai commencé à utiliser le Google+ API pour Android et j'ai créé une application de connexion à la suite de ce tutoriel:

https://developers.google.com/+/mobile/Android/sign-in

Maintenant, le problème est que je veux créer le bouton de déconnexion à partir d'un Activity différent, et ce que j'ai essayé de faire n'a pas vraiment fonctionné .. 

Mon code GPlusLogin (Activité pour la connexion à Google+):

import Android.app.Activity;
import Android.app.ProgressDialog;
import Android.content.Intent;
import Android.content.IntentSender.SendIntentException;
import Android.os.Bundle;
import Android.util.Log;
import Android.view.View;
import Android.view.View.OnClickListener;
import com.google.Android.gms.common.*;
import com.google.Android.gms.common.GooglePlayServicesClient.ConnectionCallbacks;
import com.google.Android.gms.common.GooglePlayServicesClient.OnConnectionFailedListener;
import com.google.Android.gms.plus.PlusClient;

public class GPlusLogin extends Activity implements ConnectionCallbacks, OnConnectionFailedListener{

    private static final int REQUEST_CODE_RESOLVE_ERR = 9000;
    private static final String TAG = "GPlusLogin";

    private ProgressDialog mConnectionProgressDialog;
    private PlusClient mPlusClient;
    private ConnectionResult mConnectionResult;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.gplus_layout);
        mPlusClient = new PlusClient.Builder(this, this, this).setVisibleActivities("http://schemas.google.com/AddActivity", "http://schemas.google.com/BuyActivity").build();
        Bundle extras = getIntent().getExtras();
        mConnectionProgressDialog = new ProgressDialog(this);
        mConnectionProgressDialog.setMessage("Signing in...");

        if(extras!=null){
            if(extras.getString("signout")!=null){
                if (mPlusClient.isConnected()) {
                    mPlusClient.clearDefaultAccount();
                    mPlusClient.disconnect();
                    mPlusClient.connect();
                    finish();
                    startActivity(getIntent());
                }
            }
        }else{

            findViewById(R.id.sign_in_button).setOnClickListener(new OnClickListener() {

                public void onClick(View view) {
                    // TODO Auto-generated method stub
                    if (view.getId() == R.id.sign_in_button && !mPlusClient.isConnected()) {
                        if (mConnectionResult == null) {
                            mConnectionProgressDialog.show();
                        } else {
                            try {
                                mConnectionResult.startResolutionForResult(GPlusLogin.this, REQUEST_CODE_RESOLVE_ERR);
                            } catch (SendIntentException e) {
                                // Try connecting again.
                                mConnectionResult = null;
                                mPlusClient.connect();
                            }
                        }
                    }
                }
            });
        }
    }

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

    @Override
    protected void onStop() {
        // TODO Auto-generated method stub
        super.onStop();
        mPlusClient.disconnect();
    }

    @Override
    public void onConnectionFailed(ConnectionResult result) {
        // TODO Auto-generated method stub
        if (mConnectionProgressDialog.isShowing()) {
            // The user clicked the sign-in button already. Start to resolve
            // connection errors. Wait until onConnected() to dismiss the
            // connection dialog.
            if (result.hasResolution()) {
                try {
                    result.startResolutionForResult(this, REQUEST_CODE_RESOLVE_ERR);
                } catch (SendIntentException e) {
                    mPlusClient.connect();
                }
            }
        }

        mConnectionResult = result;
    }

    @Override
    protected void onActivityResult(int requestCode, int responseCode, Intent intent) {
        if (requestCode == REQUEST_CODE_RESOLVE_ERR && responseCode == RESULT_OK) {
            mConnectionResult = null;
            mPlusClient.connect();
        }
    }

    @Override
    public void onConnected() {
        // TODO Auto-generated method stub
        mConnectionProgressDialog.dismiss();
        Intent main = new Intent(GPlusLogin.this, MainActivity.class);
        main.putExtra("result", true);
        startActivity(main);
    }

    @Override
    public void onDisconnected() {
        // TODO Auto-generated method stub
        Log.d(TAG, "disconnected");
    }

}

Mon code de déconnexion sur MainActivity:

import Android.os.Bundle;
import Android.app.Activity;
import Android.content.Intent;
import Android.view.Menu;
import Android.view.View;
import Android.view.View.OnClickListener;
import Android.widget.Button;
import Android.widget.TextView;


public class MainActivity extends Activity{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Bundle extras = getIntent().getExtras();
        if(extras==null){
            Intent intent = new Intent(this, GPlusLogin.class);
            startActivity(intent);
        }
        TextView text1 = (TextView) findViewById(R.id.text1);
        text1.setText("You Are Connected :D");

        Button SignOut = (Button) findViewById(R.id.sign_out_gplus);
        SignOut.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View view) {
                // TODO Auto-generated method stub
                Intent intent = new Intent(MainActivity.this, GPlusLogin.class);
                intent.putExtra("signout", true);
                startActivity(intent);
            }
        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }


}
androidapigoogle-apiandroid-activitygoogle-plus
31
arielschon12

Ajoutez simplement ceci sur votre nouvelle activité, où vous voulez que votre bouton de déconnexion pour google + soit présent:

@Override
protected void onStart() {
    GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestEmail()
            .build();
    mGoogleApiClient = new GoogleApiClient.Builder(this)
            .addApi(Auth.GOOGLE_SIGN_IN_API, gso)
            .build();
    mGoogleApiClient.connect();
    super.onStart();
}

et ensuite:

 signout.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          Auth.GoogleSignInApi.signOut(mGoogleApiClient).setResultCallback(
                  new ResultCallback<Status>() {
                      @Override
                      public void onResult(Status status) {
                          // ...
                          Toast.makeText(getApplicationContext(),"Logged Out",Toast.LENGTH_SHORT).show();
                          Intent i=new Intent(getApplicationContext(),MainActivity.class);
                          startActivity(i);
                      }
                  });
      }
  });
25
sommesh

Hey j'ai résolu ce problème par moi-même, travaillant comme un charme

Quel est le problème: Google plus se connecte à une activité mais doit se déconnecter d'une autre activité

Solution:

Mon activité de déconnexion Google-plus est la suivante:

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

   GoogleApiClient mGoogleApiClient;
   boolean mSignInClicked;

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

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

     //copy this code on "Logout" Onclick
  logout.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
             if (mGoogleApiClient.isConnected()) {
            Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
            mGoogleApiClient.disconnect();
            mGoogleApiClient.connect();
            // updateUI(false);
            System.err.println("LOG OUT ^^^^^^^^^^^^^^^^^^^^ SUCESS");
        } 

        }
    });

}
@Override
public void onConnected(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();
    // updateUI(false);
}

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

}

protected void onStart() {
    super.onStart();
    mGoogleApiClient.connect();
}

protected void onStop() {
    super.onStop();
    if (mGoogleApiClient.isConnected()) {
        mGoogleApiClient.disconnect();
    }
}

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

}

Description de la solution:

Pour un seul paquet, Google + API génère un jeton et une session.Il suffit de créer une session supplémentaire dans la page de déconnexion également.Vous pouvez facilement vous déconnecter de la session maintenant 

J'ai essayé beaucoup de choses sur ce problème, pour me déconnecter de la session en cours, essayez ceci. Il fonctionnera certainement. aucun doute laissez-moi savoir

18
madhu sudhan

Il serait probablement plus facile de créer une classe de base et d'hériter des méthodes de connexion/déconnexion. Photohunt, notre échantillon complet, documente cette conception en détail.

DocsCode

6
jonathanberi

Après avoir lutté pendant plus d'une semaine pour trouver la réponse. Je l'ai fait, Après avoir ouvert la sauvegarde, utilisez booléen isSignedIn dans les préférences partagées comme étant true.

private SharedPreferences.Editor editor;
private SharedPreferences prefs;

editor = getSharedPreferences(getString(R.string.userDetails), MODE_PRIVATE).edit();
editor.putBoolean(getString(R.string.isSignedIn), true);
editor.apply();`

Désormais, quelle que soit l'activité lorsque l'utilisateur clique sur la déconnexion, définissez le booléen sur false.

Dans votre activité de connexion où googleApiClient est construit. Dans sa méthode onStart . Vérifiez si isSignedIn est faux.

@Override
public void onStart() {
super.onStart();
if (!prefs.getBoolean(getString(R.string.isSignedIn), false)) {
    signOut();
    }     
}

Faites la même chose dans onConnected

@Override
public void onConnected(Bundle connectionHint) {
    if (mGoogleApiClient.isConnected()) {
        Log.i(TAG, "onConnected: " + "yes it is connected");
        if (!prefs.getBoolean(getString(R.string.isSignedIn), false)) {
            signOut();
        }
    }
}

Cela va déconnecter et revokeAccess.

public void signOut() {
    if (mGoogleApiClient != null) {
        Log.e(TAG, "signOut: " + mGoogleApiClient + mGoogleApiClient.isConnected());
        Auth.GoogleSignInApi.signOut(mGoogleApiClient).setResultCallback(
        if (mGoogleApiClient.isConnected()) {
                    new ResultCallback<Status>() {
                        @Override
                        public void onResult(Status status) {
                            // ...
                            Log.i(TAG, "onResult: " + mGoogleApiClient);
                        }
                    });
         Auth.GoogleSignInApi.revokeAccess(mGoogleApiClient).setResultCallback(
                    new ResultCallback<Status>() {
                        @Override
                        public void onResult(Status status) {
                            Log.i(TAG, "onResult: Revoke Access status:" + status.getStatus());
                        }
                    });
        }
    }
}
2
niranjan kurambhatti

Jonathan a raison de dire qu'une classe de base ou un fragment vous faciliterait la vie. Cela dit, le code ici pourrait fonctionner - le problème est que vous vérifiez si le PlusClient est connecté dans onCreate() - mais vous ne le connectez pas avant onStart(). Vous devrez probablement vérifier l’intention dans la méthode onConnected() et procéder à la signature.

1
Ian Barber

Vous pouvez obtenir une instance de FirebaseAuth n'importe où depuis l'application, car FirebaseAuth est une classe singleton.

 mAuth = FirebaseAuth.getInstance();
 mAuth.signOut();
1
Joyal

Une fois que vous cliquez sur la déconnexion d'une autre activité, essayez d'envoyer une intention avec extra pour indiquer que le bouton de déconnexion est cliqué. Puis sur l'activité de connexion

if (Intent.Extras != null && Intent.Extras.ContainsKey("LogoutAction")) {
    _logoutRequest = Intent.Extras.GetBoolean("LogoutAction");
}
if (_logoutRequest) {
    await PlusClass.AccountApi.RevokeAccessAndDisconnect(_apiClient);
    _apiClient.Disconnect();
    _apiClient.Connect ();
    _logoutRequest = false;
}

Autre activité

var intent = new Intent(this.Activity,typeof(LoginActivity));
intent.PutExtra("LogoutAction",true);
1
Lee Yeong Guang

La réponse de sommesh est parfaite, mais pour moins de code, vous pouvez utiliser "Méthode statique publique" comme ceci:

public static GoogleApiClient mGoogleApiClient;
...
...
public static void signOutFromGoogle() {
    Auth.GoogleSignInApi.signOut(mGoogleApiClient).setResultCallback(
            new ResultCallback<Status>() {
                @Override
                public void onResult(Status status) {
                    //...
                }
            });
}

Et sur votre autre activité, appelez-le:

Your_Google_Activity.mGoogleApiClient.connect();
btnSignOut.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {            
        Your_Google_Activity.signOutFromGoogle();
    }
});
0
Ali_dev