Sie können das Objekt GoogleApiClient („Google API-Client“) verwenden, um auf die Google APIs zuzugreifen, die in der Mediathek der Google Play-Dienste wie Google Log-in, Spiele und Drive bereitgestellt werden. Der Google API-Client bietet einen gemeinsamen Einstiegspunkt für Google Play-Dienste und verwaltet die Netzwerkverbindung zwischen dem Gerät des Nutzers und den einzelnen Google-Diensten.
Die neuere GoogleApi-Oberfläche und ihre Implementierungen sind jedoch einfacher zu verwenden und die bevorzugte Methode für den Zugriff auf die Play Services APIs.
Weitere Informationen
In diesem Leitfaden wird erläutert, wie Sie
- Die Verbindung zu den Google Play-Diensten wird automatisch verwaltet.
- Synchrone und asynchrone API-Aufrufe an alle Google Play-Dienste ausführen
- In den seltenen Fällen, in denen dies erforderlich ist, sollten Sie Ihre Verbindung zu Google Play-Diensten manuell verwalten. Weitere Informationen finden Sie unter Manuelle Verbindungen verwalten.
Installieren Sie zuerst die Google Play-Dienste-Bibliothek (Version 15 oder höher) für Ihr Android SDK. Folgen Sie der Anleitung unter Google Play Services SDK einrichten, falls Sie dies noch nicht getan haben.
Automatisch verwaltete Verbindung starten
Nachdem Ihr Projekt mit der Google Play-Dienste-Bibliothek verknüpft wurde, erstellen Sie eine Instanz von GoogleApiClient mit den GoogleApiClient.Builder APIs in der Methode onCreate() Ihrer Aktivität. Die Klasse GoogleApiClient.Builder bietet Methoden, mit denen Sie die zu verwendenden Google APIs und die gewünschten OAuth 2.0-Bereiche angeben können. Im folgenden Codebeispiel wird eine GoogleApiClient-Instanz erstellt, die eine Verbindung zum Google Drive-Dienst herstellt:
GoogleApiClient mGoogleApiClient = new GoogleApiClient.Builder(this)
.enableAutoManage(this /* FragmentActivity */,
this /* OnConnectionFailedListener */)
.addApi(Drive.API)
.addScope(Drive.SCOPE_FILE)
.build();
Sie können dem API GoogleApiClient mehrere APIs und mehrere Bereiche hinzufügen. Dazu hängen Sie zusätzliche Aufrufe an addApi() und addScope() an.
Wichtig:Wenn Sie die Wearable API zusammen mit anderen APIs zu einer GoogleApiClient hinzufügen, können auf Geräten, auf denen die Wear OS App nicht installiert ist, Clientverbindungsfehler auftreten. Um Verbindungsfehler zu vermeiden, rufen Sie die Methode addApiIfAvailable() auf und übergeben Sie die Wearable API. Dadurch kann Ihr Client die fehlende API ordnungsgemäß verarbeiten. Weitere Informationen finden Sie unter Auf die Wearable API zugreifen.
Damit eine automatisch verwaltete Verbindung gestartet wird, müssen Sie eine Implementierung der Schnittstelle OnConnectionFailedListener angeben, um nicht behebbare Verbindungsfehler zu erhalten. Wenn Ihre automatisch verwaltete GoogleApiClient-Instanz versucht, eine Verbindung zu Google APIs herzustellen, wird automatisch die UI angezeigt, um auflösbare Verbindungsfehler zu beheben (z. B. wenn Google Play-Dienste aktualisiert werden müssen). Wenn ein Fehler auftritt, der nicht behoben werden kann, erhalten Sie einen Aufruf an onConnectionFailed().
Sie können auch eine optionale Implementierung für die ConnectionCallbacks-Schnittstelle angeben, wenn Ihre App wissen muss, wann die automatisch verwaltete Verbindung hergestellt oder gesperrt wird. Wenn Ihre Anwendung beispielsweise Aufrufe sendet, um Daten in Google APIs zu schreiben, sollten diese erst aufgerufen werden, nachdem die Methode onConnected() aufgerufen wurde.
Hier ist eine Beispielaktivität, in der die Callback-Schnittstellen implementiert und dem Google API-Client hinzugefügt werden:
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener;
import gms.drive.*;
import android.support.v4.app.FragmentActivity;
public class MyActivity extends FragmentActivity
implements OnConnectionFailedListener {
private GoogleApiClient mGoogleApiClient;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Create a GoogleApiClient instance
mGoogleApiClient = new GoogleApiClient.Builder(this)
.enableAutoManage(this /* FragmentActivity */,
this /* OnConnectionFailedListener */)
.addApi(Drive.API)
.addScope(Drive.SCOPE_FILE)
.build();
// ...
}
@Override
public void onConnectionFailed(ConnectionResult result) {
// An unresolvable error has occurred and a connection to Google APIs
// could not be established. Display an error message, or handle
// the failure silently
// ...
}
}
Die GoogleApiClient-Instanz stellt automatisch eine Verbindung her, sobald Ihre Aktivitätsaufrufe onStart() aufgerufen wurden, und die Verbindung wird nach dem Aufrufen von onStop() getrennt.
Ihre Anwendung kann sofort nach dem Erstellen von GoogleApiClient Leseanfragen an Google APIs senden, ohne auf die Verbindung warten zu müssen.
Mit Google-Diensten kommunizieren
Nach dem Verbinden kann Ihr Client Lese- und Schreibvorgänge mit den dienstspezifischen APIs ausführen, für die Ihre Anwendung autorisiert ist. Dies ist durch die APIs und Bereiche angegeben, die Sie Ihrer GoogleApiClient-Instanz hinzugefügt haben.
Hinweis:Bevor du bestimmte Google-Dienste aufrufst, musst du deine App möglicherweise in der Google Developer Console registrieren. Anleitungen finden Sie im entsprechenden Startleitfaden für die verwendete API, z. B. Google Drive oder Google Log-in.
Wenn Sie mit GoogleApiClient eine Lese- oder Schreibanfrage ausführen, gibt der API-Client ein PendingResult-Objekt zurück, das die Anfrage darstellt.
Dies geschieht sofort, bevor die Anfrage an den Google-Dienst gesendet wird, den Ihre App aufruft.
Hier ein Beispiel für eine Anfrage zum Lesen einer Datei aus Google Drive, die ein PendingResult-Objekt enthält:
Query query = new Query.Builder()
.addFilter(Filters.eq(SearchableField.TITLE, filename));
PendingResult<DriveApi.MetadataBufferResult> result = Drive.DriveApi.query(mGoogleApiClient, query);
Nachdem Ihre App ein PendingResult-Objekt hat, kann sie angeben, ob die Anfrage als asynchroner oder synchroner Aufruf verarbeitet wird.
Tipp:Ihre App kann Leseanfragen in die Warteschlange stellen, wenn keine Verbindung zu Google Play-Diensten besteht. Ihre App kann beispielsweise Methoden aufrufen, um eine Datei aus Google Drive zu lesen, unabhängig davon, ob Ihre GoogleApiClient-Instanz noch verbunden ist. Nachdem eine Verbindung hergestellt wurde, werden Leseanfragen in der Warteschlange ausgeführt. Schreibanfragen generieren einen Fehler, wenn deine App Schreibmethoden für Google Play-Dienste aufruft, während dein Google API-Client nicht verbunden ist.
Asynchrone Aufrufe verwenden
Um die Anfrage asynchron zu machen, rufen Sie setResultCallback() für PendingResult auf und implementieren Sie die Schnittstelle ResultCallback. Hier sehen Sie ein Beispiel für die asynchrone Ausführung der Anfrage:
private void loadFile(String filename) {
// Create a query for a specific filename in Drive.
Query query = new Query.Builder()
.addFilter(Filters.eq(SearchableField.TITLE, filename))
.build();
// Invoke the query asynchronously with a callback method
Drive.DriveApi.query(mGoogleApiClient, query)
.setResultCallback(new ResultCallback<DriveApi.MetadataBufferResult>() {
@Override
public void onResult(DriveApi.MetadataBufferResult result) {
// Success! Handle the query result.
// ...
}
});
}
Wenn Ihre App ein Result-Objekt im onResult()-Callback empfängt, wird sie als Instanz der entsprechenden Unterklasse entsprechend der von der API verwendeten API bereitgestellt, z. B. DriveApi.MetadataBufferResult.
Synchrone Aufrufe verwenden
Wenn der Code in einer streng definierten Reihenfolge ausgeführt werden soll, z. B. weil das Ergebnis eines Aufrufs als Argument für einen anderen erforderlich ist, können Sie die Anfrage synchron machen. Dazu rufen Sie await() für PendingResult auf. Dadurch wird der Thread blockiert und das Result-Objekt zurückgegeben, wenn die Anfrage abgeschlossen ist. Dieses Objekt wird als Instanz der entsprechenden Unterklasse bereitgestellt, die von der verwendeten API angegeben wird, z. B. DriveApi.MetadataBufferResult.
Da durch Aufrufen von await() der Thread blockiert wird, bis das Ergebnis eingeht, sollte die Anwendung nie synchrone Anfragen an Google APIs im UI-Thread senden. Die Anwendung kann mit einem AsyncTask-Objekt einen neuen Thread erstellen und diesen Thread für die synchrone Anfrage verwenden.
Im folgenden Beispiel wird gezeigt, wie Sie eine Dateianfrage als synchronen Aufruf an Google Drive senden:
private void loadFile(String filename) {
new GetFileTask().execute(filename);
}
private class GetFileTask extends AsyncTask {
protected void doInBackground(String filename) {
Query query = new Query.Builder()
.addFilter(Filters.eq(SearchableField.TITLE, filename))
.build();
// Invoke the query synchronously
DriveApi.MetadataBufferResult result =
Drive.DriveApi.query(mGoogleApiClient, query).await();
// Continue doing other stuff synchronously
// ...
}
}
Auf die Wearable API zugreifen
Die Wearable API bietet einen Kommunikationskanal für Apps, die auf Handheld- und Wearable-Geräten ausgeführt werden. Die API besteht aus einer Reihe von Datenobjekten, die das System senden und synchronisieren kann, und Listenern, die Ihre Apps über eine Datenschicht über wichtige Ereignisse benachrichtigen. Die Wearable API ist auf Geräten mit Android 4.3 (API-Level 18) oder höher verfügbar, wenn ein Wearable-Gerät verbunden ist und die Wear OS-Companion-App auf dem Gerät installiert ist.
Eigenständige Wearable API verwenden
Wenn Ihre App die Wearable API, aber keine anderen Google APIs verwendet, können Sie die API durch Aufrufen der Methode addApi() hinzufügen. Das folgende Beispiel zeigt, wie Sie die Wearable API Ihrer GoogleApiClient-Instanz hinzufügen:
GoogleApiClient mGoogleApiClient = new GoogleApiClient.Builder(this)
.enableAutoManage(this /* FragmentActivity */,
this /* OnConnectionFailedListener */)
.addApi(Wearable.API)
.build();
In Fällen, in denen die Wearable API nicht verfügbar ist, schlagen Verbindungsanfragen mit der Wearable API den Fehlercode API_UNAVAILABLE fehl.
Im folgenden Beispiel sehen Sie, wie ermittelt wird, ob die Wearable API verfügbar ist:
// Connection failed listener method for a client that only
// requests access to the Wearable API
@Override
public void onConnectionFailed(ConnectionResult result) {
if (result.getErrorCode() == ConnectionResult.API_UNAVAILABLE) {
// The Wearable API is unavailable
}
// ...
}
Wearable API mit anderen Google APIs verwenden
Wenn Ihre App die Wearable API zusätzlich zu anderen Google APIs verwendet, rufen Sie die addApiIfAvailable()-Methode auf und übergeben Sie die Wearable API, um zu prüfen, ob sie verfügbar ist. Mit dieser Prüfung können Sie in Ihrer App reibungslos reagieren, wenn die API nicht verfügbar ist.
Das folgende Beispiel zeigt, wie Sie zusammen mit der Drive API auf die Wearable API zugreifen können:
// Create a GoogleApiClient instance
mGoogleApiClient = new GoogleApiClient.Builder(this)
.enableAutoManage(this /* FragmentActivity */,
this /* OnConnectionFailedListener */)
.addApi(Drive.API)
.addApiIfAvailable(Wearable.API)
.addScope(Drive.SCOPE_FILE)
.build();
Im Beispiel oben kann mit der GoogleApiClient eine Verbindung zu Google Drive hergestellt werden, ohne dass eine Verbindung zur Wearable API hergestellt wird, falls sie nicht verfügbar ist. Nachdem Sie die GoogleApiClient-Instanz verbunden haben, prüfen Sie, ob die Wearable API verfügbar ist, bevor Sie die API-Aufrufe ausführen:
boolean wearAvailable = mGoogleApiClient.hasConnectedApi(Wearable.API);
API-Verbindungsfehler ignorieren
Wenn Sie addApi() aufrufen und GoogleApiClient keine Verbindung zu dieser API herstellen kann, schlägt der gesamte Verbindungsvorgang für diesen Client fehl und löst den onConnectionFailed()-Callback aus.
Mit addApiIfAvailable() kannst du einen API-Verbindungsfehler registrieren, der ignoriert werden soll. Wenn eine API, die mit addApiIfAvailable() hinzugefügt wurde, aufgrund eines nicht behebbaren Fehlers (z. B. API_UNAVAILABLE für Wear) keine Verbindung herstellen kann, wird diese API aus Ihrer GoogleApiClient entfernt und der Client stellt eine Verbindung zu anderen APIs her. Wenn jedoch eine API-Verbindung aufgrund eines reparierbaren Fehlers (z. B. ein Intent zur Lösung der OAuth-Einwilligung) fehlschlägt, schlägt der Clientverbindungsvorgang fehl. Wenn Sie eine automatisch verwaltete Verbindung verwenden, versucht der GoogleApiClient, solche Fehler nach Möglichkeit zu beheben. Wenn Sie eine manuell verwaltete Verbindung verwenden, wird ein ConnectionResult mit einem Intent für die Auflösung an den onConnectionFailed()-Callback gesendet. API-Verbindungsfehler werden nur ignoriert, wenn es keine Lösung für den Fehler gibt und die API mit addApiIfAvailable() hinzugefügt wurde.
Informationen zum Implementieren einer manuellen Verbindungsfehlerbehandlung finden Sie unter Verbindungsfehler beheben.
Da APIs, die mit addApiIfAvailable() hinzugefügt wurden, möglicherweise nicht immer in der verbundenen GoogleApiClient-Instanz vorhanden sind, sollten Sie Aufrufe dieser APIs mit einer Prüfung mithilfe von hasConnectedApi() schützen. Um herauszufinden, warum eine bestimmte API keine Verbindung herstellen konnte, wenn der gesamte Verbindungsvorgang für den Client erfolgreich war, rufen Sie getConnectionResult() auf und rufen Sie den Fehlercode aus dem ConnectionResult-Objekt ab. Wenn Ihr Client eine API aufruft, während er nicht mit dem Client verbunden ist, schlägt der Aufruf mit dem Statuscode API_NOT_AVAILABLE fehl.
Wenn die API, die Sie über addApiIfAvailable() hinzufügen, einen oder mehrere Bereiche erfordert, fügen Sie diese Bereiche als Parameter im addApiIfAvailable()-Methodenaufruf ein, anstatt die Methode addScope() zu verwenden. Bereiche, die mit diesem Ansatz hinzugefügt werden, werden möglicherweise nicht angefordert, wenn die API-Verbindung fehlschlägt, bevor sie die OAuth-Einwilligung erhalten. Bereiche, die mit addScope() hinzugefügt werden, werden jedoch immer angefordert.
Manuell verwaltete Verbindungen
Im Großteil dieses Leitfadens erfahren Sie, wie Sie mit der Methode enableAutoManage eine automatisch verwaltete Verbindung mit automatisch behobenen Fehlern initiieren. In den meisten Fällen ist dies die beste und einfachste Methode, um sich über Ihre Android-App mit Google APIs zu verbinden. In bestimmten Situationen empfiehlt es sich jedoch, eine manuell verwaltete Verbindung zu Google APIs in Ihrer App zu verwenden:
- Um auf Google APIs außerhalb einer Aktivität zuzugreifen oder die Kontrolle über die API-Verbindung zu behalten
- Zur Anpassung und Behebung von Verbindungsfehlern
Dieser Abschnitt enthält Beispiele für diese und weitere erweiterte Anwendungsfälle.
Manuell verwaltete Verbindung starten
Wenn Sie eine manuell verwaltete Verbindung zu GoogleApiClient initiieren möchten, müssen Sie eine Implementierung für die Callback-Schnittstellen ConnectionCallbacks und OnConnectionFailedListener angeben.
Diese Schnittstellen empfangen Callbacks als Reaktion auf die asynchrone Methode connect(), wenn die Verbindung zu den Google Play-Diensten erfolgreich, gescheitert oder ausgesetzt wird.
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addApi(Drive.API)
.addScope(Drive.SCOPE_FILE)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.build()
Wenn Sie eine Verbindung manuell verwalten, müssen Sie die Methoden connect() und disconnect() an den richtigen Stellen im Lebenszyklus Ihrer Anwendung aufrufen. In einem Aktivitätskontext sollten Sie connect() in der Methode onStart() Ihrer Aktivität und disconnect() in der Methode onStop() Ihrer Aktivität aufrufen.
Die Methoden connect() und disconnect() werden bei Verwendung einer automatisch verwalteten Verbindung automatisch aufgerufen.
Wenn Sie mit GoogleApiClient eine Verbindung zu APIs herstellen, für die eine Authentifizierung erforderlich ist, z. B. Google Drive oder Google Play Spiele, schlägt der erste Verbindungsversuch wahrscheinlich fehl. Außerdem erhält die App dann einen Aufruf an onConnectionFailed() mit dem Fehler SIGN_IN_REQUIRED, da das Nutzerkonto nicht angegeben wurde.
Umgang mit Verbindungsfehlern
Wenn Ihre App einen Aufruf an den onConnectionFailed()-Callback empfängt, sollten Sie hasResolution() für das bereitgestellte ConnectionResult-Objekt aufrufen. Wenn sie auf „true“ gesetzt ist, kann Ihre App anfordern, dass der Nutzer sofort aktiv wird, um den Fehler zu beheben. Dazu ruft er startResolutionForResult() für das ConnectionResult-Objekt auf.
Die Methode startResolutionForResult() verhält sich in dieser Situation genauso wie startActivityForResult() und startet eine Aktivität, die dem Kontext entspricht, mit dem der Fehler behoben werden kann (z. B. eine Aktivität, mit der der Nutzer ein Konto auswählen kann).
Wenn hasResolution() „false“ zurückgibt, sollte Ihre Anwendung GoogleApiAvailability.getErrorDialog() aufrufen und den Fehlercode an diese Methode übergeben. Dadurch wird ein Dialog-Wert von Google Play-Diensten zurückgegeben, der für den Fehler geeignet ist. Möglicherweise wird im Dialogfeld eine Fehlermeldung angezeigt, oder es wird eine Aktion gestartet, mit der der Fehler behoben werden kann, z. B. wenn der Nutzer eine neuere Version der Google Play-Dienste installieren muss.
Die Callback-Methode onConnectionFailed() sollte jetzt so aussehen:
public class MyActivity extends Activity
implements ConnectionCallbacks, OnConnectionFailedListener {
// Request code to use when launching the resolution activity
private static final int REQUEST_RESOLVE_ERROR = 1001;
// Unique tag for the error dialog fragment
private static final String DIALOG_ERROR = "dialog_error";
// Bool to track whether the app is already resolving an error
private boolean mResolvingError = false;
// ...
@Override
public void onConnectionFailed(ConnectionResult result) {
if (mResolvingError) {
// Already attempting to resolve an error.
return;
} else if (result.hasResolution()) {
try {
mResolvingError = true;
result.startResolutionForResult(this, REQUEST_RESOLVE_ERROR);
} catch (SendIntentException e) {
// There was an error with the resolution intent. Try again.
mGoogleApiClient.connect();
}
} else {
// Show dialog using GoogleApiAvailability.getErrorDialog()
showErrorDialog(result.getErrorCode());
mResolvingError = true;
}
}
// The rest of this code is all about building the error dialog
/* Creates a dialog for an error message */
private void showErrorDialog(int errorCode) {
// Create a fragment for the error dialog
ErrorDialogFragment dialogFragment = new ErrorDialogFragment();
// Pass the error that should be displayed
Bundle args = new Bundle();
args.putInt(DIALOG_ERROR, errorCode);
dialogFragment.setArguments(args);
dialogFragment.show(getSupportFragmentManager(), "errordialog");
}
/* Called from ErrorDialogFragment when the dialog is dismissed. */
public void onDialogDismissed() {
mResolvingError = false;
}
/* A fragment to display an error dialog */
public static class ErrorDialogFragment extends DialogFragment {
public ErrorDialogFragment() { }
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
// Get the error code and retrieve the appropriate dialog
int errorCode = this.getArguments().getInt(DIALOG_ERROR);
return GoogleApiAvailability.getInstance().getErrorDialog(
this.getActivity(), errorCode, REQUEST_RESOLVE_ERROR);
}
@Override
public void onDismiss(DialogInterface dialog) {
((MyActivity) getActivity()).onDialogDismissed();
}
}
}
Nachdem der Nutzer das von startResolutionForResult() bereitgestellte Dialogfeld ausgeführt oder die von GoogleApiAvailability.getErrorDialog() bereitgestellte Nachricht geschlossen hat, erhält Ihre Aktivität den Callback onActivityResult() mit dem Ergebniscode RESULT_OK.
Ihre App kann dann connect() noch einmal aufrufen.
Beispiel:
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == REQUEST_RESOLVE_ERROR) {
mResolvingError = false;
if (resultCode == RESULT_OK) {
// Make sure the app is not already connected or attempting to connect
if (!mGoogleApiClient.isConnecting() &&
!mGoogleApiClient.isConnected()) {
mGoogleApiClient.connect();
}
}
}
}
Im Code oben ist Ihnen wahrscheinlich der boolesche Wert mResolvingError aufgefallen. So wird der App-Status erfasst, während der Nutzer den Fehler behebt, um wiederholte Versuche zur Behebung desselben Fehlers zu vermeiden. Das Kontodialogfeld wird beispielsweise angezeigt, um dem Nutzer bei der Behebung des Fehlers SIGN_IN_REQUIRED zu helfen. Er kann aber den Bildschirm drehen. Dadurch werden Ihre Aktivitäten neu erstellt und die Methode onStart() wird noch einmal aufgerufen. Dadurch wird connect() noch einmal aufgerufen. Dies führt zu einem weiteren Aufruf von startResolutionForResult(), wodurch ein weiteres Dialogfeld für die Kontoauswahl erstellt wird.
Dieser boolesche Wert wird nur dann verwendet, wenn er über die Aktivitätsinstanzen hinweg bestehen bleibt. Im nächsten Abschnitt wird erläutert, wie Sie den Fehlerbehandlungsstatus Ihrer App trotz anderer Nutzeraktionen oder Ereignisse auf dem Gerät aufrechterhalten können.
Status beim Beheben eines Fehlers beibehalten
Damit der Code in onConnectionFailed() nicht ausgeführt wird, während ein vorheriger Versuch zur Behebung eines Fehlers ausgeführt wird, müssen Sie einen booleschen Wert beibehalten. Damit wird erfasst, ob die Anwendung bereits versucht, einen Fehler zu beheben.
Wie im Codebeispiel oben gezeigt wird, sollte Ihre Anwendung jedes Mal einen booleschen Wert auf true festlegen, wenn startResolutionForResult() aufgerufen oder das Dialogfeld von GoogleApiAvailability.getErrorDialog() angezeigt wird.
Wenn Ihre Anwendung dann RESULT_OK im onActivityResult()-Callback empfängt, legen Sie den booleschen Wert auf false fest.
Damit Sie den booleschen Wert bei wiederholten Aktivitäten, z. B. wenn der Nutzer den Bildschirm dreht, im Blick behalten, können Sie den booleschen Wert in der gespeicherten Instanzdaten der Aktivität mit onSaveInstanceState() speichern:
private static final String STATE_RESOLVING_ERROR = "resolving_error";
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putBoolean(STATE_RESOLVING_ERROR, mResolvingError);
}
Stellen Sie dann den gespeicherten Status während onCreate() wieder her:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// ...
mResolvingError = savedInstanceState != null
&& savedInstanceState.getBoolean(STATE_RESOLVING_ERROR, false);
}
Jetzt können Sie Ihre App sicher ausführen und sich manuell mit den Google Play-Diensten verbinden.