Accéder à google plus de client à partir de plusieurs activités

0. TL;DR

Pour les impatients codeur, une version de travail de la mise en œuvre suivantes peuvent être trouvés sur GitHub. C'est la même réponse écrite sur un autre Un Débordement de pile post.

Après la réécriture de l'activité de connexion code plusieurs fois dans de nombreuses applications différentes, le plus facile (et pas très élégant) la solution a été de créer l'API Google client comme une Application de classe de l'objet. Mais, étant donné l'état de la connexion incidence sur les UX de flux, je n'ai jamais été heureux avec cette approche.

Réduire notre problème seulement pour les concept de raccordement, nous pouvons considérer que:

1. Il cache l'API Google client.
2. Il a états finis.
3. C'est une (plutôt) unique.
4. L'état actuel affecter le comportement de l'application.

1. Modèle De Proxy

Depuis le Connection encapsule le GoogleApiClient, il mettra en œuvre la ConnectionCallbacks et OnConnectionFailedListener:

@Override
public void onConnected(Bundle hint) {
    changeState(State.OPENED);
}

@Override
public void onConnectionSuspended(int cause) {
    changeState(State.CLOSED);
    connect();
}

@Override
public void onConnectionFailed(ConnectionResult result) {
    if (currentState.equals(State.CLOSED) && result.hasResolution()) {
        changeState(State.CREATED);
        connectionResult = result;
    } else {
        connect();
    }
}

Activités peuvent communiquer à la classe de Connexion à travers les méthodes connect, disconnect, et revoke, mais leurs comportements sont décidées par l'état actuel. Les méthodes suivantes sont requises par l'état de la machine:

protected void onSignIn() {
    if (!googleApiClient.isConnected() && !googleApiClient.isConnecting()) {
        googleApiClient.connect();
    }
}

protected void onSignOut() {
    if (googleApiClient.isConnected()) {
        Plus.AccountApi.clearDefaultAccount(googleApiClient);
        googleApiClient.disconnect();
        googleApiClient.connect();
        changeState(State.CLOSED);
    }
}

protected void onSignUp() {
    Activity activity = activityWeakReference.get();
    try {
        changeState(State.OPENING);
        connectionResult.startResolutionForResult(activity, REQUEST_CODE);
    } catch (IntentSender.SendIntentException e) {
        changeState(State.CREATED);
        googleApiClient.connect();
    }
}

protected void onRevoke() {
    Plus.AccountApi.clearDefaultAccount(googleApiClient);
    Plus.AccountApi.revokeAccessAndDisconnect(googleApiClient);
    googleApiClient = googleApiClientBuilder.build();
    googleApiClient.connect();
    changeState(State.CLOSED);
}

2. État Modèle

C'est un modèle de comportement de la permettre à un objet à modifier son comportement lors de son état interne change. Le GoF Modèles de Conception de livre décrit la façon dont une connexion TCP peut être représenter par ce modèle (qui est aussi notre cas).

Un état à partir d'une machine d'état doit être un singleton, et de loin la méthode la plus simple de le faire en Java était de créer Enum nommé State comme suit:

public enum State {
    CREATED {
        @Override
        void connect(Connection connection) {
            connection.onSignUp();
        }
        @Override
        void disconnect(Connection connection) {
            connection.onSignOut();
        }
    },
    OPENING {},
    OPENED {
        @Override
        void disconnect(Connection connection) {
            connection.onSignOut();
        }
        @Override
        void revoke(Connection connection) {
            connection.onRevoke();
        }
    },
    CLOSED {
        @Override
        void connect(Connection connection) {
            connection.onSignIn();
        }
    };

void connect(Connection connection) {}
void disconnect(Connection connection) {}
void revoke(Connection connection) {}

La Connection classe contient le contexte, c'est à dire l'état actuel, qui définit la façon dont le Connection méthodes connect, disconnect, et revoke va se comporter:

public void connect() {
    currentState.connect(this);
}

public void disconnect() {
    currentState.disconnect(this);
}

public void revoke() {
    currentState.revoke(this);
}

private void changeState(State state) {
    currentState = state;
    setChanged();
    notifyObservers(state);
}

3. Le Pattern Singleton

Car il n'est pas besoin de recréer cette classe à plusieurs reprises, nous offrir comme un singleton:

public static Connection getInstance(Activity activity) {
    if (null == sConnection) {
        sConnection = new Connection(activity);
    }

    return sConnection;
}

public void onActivityResult(int result) {
    if (result == Activity.RESULT_OK) {
        changeState(State.CREATED);
    } else {
        changeState(State.CLOSED);
    }
    onSignIn();
}

private Connection(Activity activity) {
    activityWeakReference = new WeakReference<>(activity);

    googleApiClientBuilder = new GoogleApiClient
           .Builder(activity)
           .addConnectionCallbacks(this)
           .addOnConnectionFailedListener(this)
           .addApi(Plus.API, Plus.PlusOptions.builder().build())
           .addScope(new Scope("email"));

    googleApiClient = googleApiClientBuilder.build();
    currentState = State.CLOSED;
}

4. Motif Observable

La Connection classe étend Java Observable, donc 1 ou plusieurs activités peuvent observer les changements d'état:

@Override
protected void onCreate(Bundle bundle) {
    connection = Connection.getInstance(this);
    connection.addObserver(this);
}

@Override
protected void onStart() {
    connection.connect();
}

@Override
protected void onDestroy() {
    connection.deleteObserver(this);
    connection.disconnect();
}

@Override
protected void onActivityResult(int request, int result, Intent data) {
    if (Connection.REQUEST_CODE == request) {
        connection.onActivityResult(result);
    }
}

@Override
public void update(Observable observable, Object data) {
    if (observable != connection) {
        return;
    }
    //Your presentation logic goes here...
}