Mit dem Objekt GoogleApiClient („Google API-Client“) können Sie auf die in der Bibliothek der Google Play-Dienste bereitgestellten Google APIs wie Google Log-in, Spiele und Drive zugreifen. Der Google API-Client bietet einen gemeinsamen Einstiegspunkt für Google Play-Dienste und verwaltet die Netzwerkverbindung zwischen dem Gerät des Nutzers und jedem Google-Dienst.
Die neuere GoogleApi-Schnittstelle und ihre Implementierungen sind jedoch einfacher zu verwenden und die bevorzugte Methode, um auf Play-Dienste-APIs zuzugreifen.
Siehe Auf Google APIs zugreifen.
In diesem Leitfaden erfahren Sie, wie Sie:
- Sie können Ihre Verbindung zu Google Play-Diensten automatisch verwalten lassen.
- Synchrone und asynchrone API-Aufrufe an einen der Google Play-Dienste ausführen
- Verwalten Sie Ihre Verbindung zu Google Play-Diensten in den seltenen Fällen, in denen dies erforderlich ist, manuell. Weitere Informationen finden Sie unter Manuell verwaltete Verbindungen.
Zuerst müssen Sie die Google Play-Dienste-Bibliothek (Version 15 oder höher) für Ihr Android SDK installieren. 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 mithilfe der GoogleApiClient.Builder-APIs in der Methode onCreate() Ihrer Aktivität eine Instanz von GoogleApiClient. Die Klasse GoogleApiClient.Builder bietet Methoden, mit denen Sie die Google APIs, die Sie verwenden möchten, und die gewünschten OAuth 2.0-Bereiche angeben können. Mit dem 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 einem GoogleApiClient mehrere APIs und Bereiche hinzufügen, indem Sie zusätzliche Aufrufe an addApi() und addScope() anhängen.
Wichtig:Wenn du die Wearable API zusammen mit anderen APIs zu einem GoogleApiClient hinzufügst, 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, damit der Client die fehlende API ordnungsgemäß verarbeiten kann. Weitere Informationen finden Sie unter Auf die Wearable API zugreifen.
Zum Herstellen einer automatisch verwalteten Verbindung müssen Sie eine Implementierung für die OnConnectionFailedListener-Schnittstelle angeben, die nicht behebbare Verbindungsfehler empfängt. Wenn Ihre automatisch verwaltete GoogleApiClient-Instanz versucht, eine Verbindung zu Google APIs herzustellen, wird automatisch eine UI angezeigt, über die versucht wird, behebbare 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 Anwendung wissen muss, wann die automatisch verwaltete Verbindung hergestellt oder gesperrt wird. Wenn Ihre Anwendung beispielsweise Aufrufe zum Schreiben von Daten in Google APIs sendet, sollten diese erst aufgerufen werden, nachdem die Methode onConnected() aufgerufen wurde.
Hier sehen Sie eine Beispielaktivität, bei 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
// ...
}
}
Ihre GoogleApiClient-Instanz stellt nach dem Aufrufen von onStart() für Aktivitäten automatisch eine Verbindung her und nach dem Aufrufen von onStop() wird die Verbindung getrennt.
Ihre Anwendung kann sofort nach dem Erstellen von GoogleApiClient Leseanfragen an Google APIs senden, ohne warten zu müssen, bis die Verbindung hergestellt ist.
Mit Google-Diensten kommunizieren
Nachdem die Verbindung hergestellt wurde, kann Ihr Client mit den dienstspezifischen APIs, für die Ihre Anwendung autorisiert ist, Lese- und Schreibaufrufe ausführen, wie in den APIs und Bereichen angegeben, die Sie der Instanz GoogleApiClient hinzugefügt haben.
Hinweis: Bevor Sie bestimmte Google-Dienste aufrufen, müssen Sie Ihre App möglicherweise zuerst in der Google Developer Console registrieren. Anleitungen dazu findest du im entsprechenden Startleitfaden für die von dir verwendete API, z. B. für Google Drive oder Google Log-in.
Wenn Sie eine Lese- oder Schreibanfrage mit GoogleApiClient ausführen, gibt der API-Client ein PendingResult-Objekt zurück, das die Anfrage darstellt.
Dies erfolgt unmittelbar, bevor die Anfrage an den Google-Dienst gesendet wird, den Ihre App aufruft.
Hier ist beispielsweise 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 Anwendung 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 sie nicht mit den Google Play-Diensten verbunden ist. Beispielsweise kann Ihre Anwendung Methoden zum Lesen einer Datei aus Google Drive aufrufen, 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 Ihre App Schreibmethoden für Google Play-Dienste aufruft, während der Google API-Client nicht verbunden ist.
Asynchrone Aufrufe verwenden
Damit die Anfrage asynchron wird, rufen Sie setResultCallback() im PendingResult auf und geben Sie eine Implementierung der ResultCallback-Schnittstelle an. Die folgende Anfrage wird beispielsweise asynchron ausgeführt:
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 Anwendung im onResult()-Callback ein Result-Objekt empfängt, wird es als Instanz der entsprechenden abgeleiteten Klasse bereitgestellt, wie von der verwendeten API angegeben, z. B. DriveApi.MetadataBufferResult.
Synchrone Aufrufe verwenden
Wenn Sie möchten, dass Ihr Code in einer genau definierten Reihenfolge ausgeführt wird, z. B. weil das Ergebnis eines Aufrufs als Argument für einen anderen benötigt wird, können Sie die Anfrage synchron ausführen. Rufen Sie dazu await() für PendingResult auf. Dadurch wird der Thread blockiert und das Objekt Result wird zurückgegeben, wenn die Anfrage abgeschlossen ist. Dieses Objekt wird als Instanz der entsprechenden Unterklasse bereitgestellt, wie von der verwendeten API angegeben, z. B. DriveApi.MetadataBufferResult.
Da der Aufruf von await() den Thread bis zum Eintreffen des Ergebnisses blockiert, sollte Ihre Anwendung keine synchronen Anfragen an Google APIs im UI-Thread senden. Ihre Anwendung kann mit einem AsyncTask-Objekt einen neuen Thread erstellen und diesen für die synchrone Anfrage verwenden.
Das folgende Beispiel zeigt, 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 Anwendungen mithilfe einer Datenschicht über wichtige Ereignisse informieren. 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 und die Wearable-Companion-App auf dem Gerät installiert ist.
Wearable API eigenständig verwenden
Wenn deine App die Wearable API, aber keine anderen Google APIs verwendet, kannst du diese API durch Aufrufen der Methode addApi() hinzufügen. Das folgende Beispiel zeigt, wie du die Wearable API deiner GoogleApiClient-Instanz hinzufügst:
GoogleApiClient mGoogleApiClient = new GoogleApiClient.Builder(this)
.enableAutoManage(this /* FragmentActivity */,
this /* OnConnectionFailedListener */)
.addApi(Wearable.API)
.build();
Wenn die Wearable API nicht verfügbar ist, schlagen Verbindungsanfragen, die die Wearable API enthalten, mit dem Fehlercode API_UNAVAILABLE fehl.
Das folgende Beispiel zeigt, wie Sie feststellen können, 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 Methode addApiIfAvailable() auf und übergeben Sie die Wearable API, um zu prüfen, ob sie verfügbar ist. Mit dieser Prüfung können Sie Ihrer App dabei helfen, auch Fälle zu verarbeiten, in denen die API nicht verfügbar ist.
Das folgende Beispiel zeigt, wie Sie auf die Wearable API mit der Drive API zugreifen:
// 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 eine Verbindung zwischen dem GoogleApiClient und Google Drive hergestellt werden, ohne dass eine Verbindung zur Wearable API hergestellt werden kann, falls diese nicht verfügbar ist. Nachdem du eine Verbindung zu deiner GoogleApiClient-Instanz hergestellt hast, muss die Wearable API verfügbar sein, bevor du die API-Aufrufe tätigst:
boolean wearAvailable = mGoogleApiClient.hasConnectedApi(Wearable.API);
Ignorieren von API-Verbindungsfehlern
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.
Sie können mit addApiIfAvailable() festlegen, dass ein API-Verbindungsfehler ignoriert werden soll. Wenn eine mit addApiIfAvailable() hinzugefügte API aufgrund eines nicht behebbaren Fehlers (z. B. API_UNAVAILABLE für Wear) keine Verbindung herstellen kann, wird diese API von GoogleApiClient gelöscht und der Client stellt eine Verbindung zu anderen APIs her. Wenn jedoch eine API-Verbindung aufgrund eines behebbaren Fehlers fehlschlägt (z. B. bei einem OAuth-Intent der Einwilligungsauflösung), schlägt die Clientverbindung fehl. Bei Verwendung einer automatisch verwalteten Verbindung versucht GoogleApiClient, solche Fehler nach Möglichkeit zu beheben. Bei Verwendung einer manuell verwalteten Verbindung wird ein ConnectionResult mit einem Lösungsabsicht an den onConnectionFailed()-Callback gesendet. API-Verbindungsfehler werden nur ignoriert, wenn sich der Fehler nicht beheben lässt und die API mit addApiIfAvailable() hinzugefügt wurde.
Informationen zum Implementieren des manuellen Umgangs mit Verbindungsfehlern finden Sie unter Verbindungsfehler beheben.
Da mit addApiIfAvailable() hinzugefügte APIs möglicherweise nicht immer in der verbundenen GoogleApiClient-Instanz vorhanden sind, sollten Sie Aufrufe dieser APIs schützen, indem Sie mit hasConnectedApi() eine Prüfung hinzufügen. Wenn Sie herausfinden möchten, warum eine bestimmte API keine Verbindung herstellen konnte, obwohl der gesamte Verbindungsvorgang für den Client erfolgreich war, rufen Sie getConnectionResult() auf und rufen Sie den Fehlercode vom ConnectionResult-Objekt ab. Wenn Ihr Client eine API aufruft, ohne mit dem Client verbunden zu sein, schlägt der Aufruf mit dem Statuscode API_NOT_AVAILABLE fehl.
Wenn für die API, die Sie über addApiIfAvailable() hinzufügen, ein oder mehrere Bereiche erforderlich sind, fügen Sie diese Bereiche als Parameter im Methodenaufruf addApiIfAvailable() hinzu, anstatt die Methode addScope() zu verwenden. Bereiche, die mit diesem Ansatz hinzugefügt werden, werden möglicherweise nicht angefordert, wenn die API-Verbindung vor dem Einholen der OAuth-Einwilligung fehlschlägt. Mit addScope() hinzugefügte Bereiche werden hingegen immer angefordert.
Manuell verwaltete Verbindungen
In diesem Leitfaden erfahren Sie, wie Sie mithilfe der Methode enableAutoManage eine automatisch verwaltete Verbindung mit automatisch behobenen Fehlern initiieren. In fast allen Fällen ist dies die beste und einfachste Methode, um von Ihrer Android-App aus eine Verbindung zu Google APIs herzustellen. Es gibt jedoch Situationen, in denen Sie in Ihrer App eine manuell verwaltete Verbindung zu Google APIs verwenden sollten:
- Auf Google APIs außerhalb einer Aktivität zugreifen oder die Kontrolle über die API-Verbindung behalten
- So passen Sie die Verarbeitung und Lösung von Verbindungsfehlern an:
In diesem Abschnitt finden Sie Beispiele für diese und andere erweiterte Anwendungsfälle.
Manuell verwaltete Verbindung starten
Zum Initiieren einer manuell verwalteten Verbindung zu GoogleApiClient müssen Sie eine Implementierung für die Callback-Schnittstellen ConnectionCallbacks und OnConnectionFailedListener angeben.
Diese Schnittstellen empfangen Callbacks als Antwort auf die asynchrone connect()-Methode, wenn die Verbindung mit Google Play-Diensten erfolgreich ist, fehlschlägt oder unterbrochen 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 Punkten im Lebenszyklus Ihrer Anwendung aufrufen. Im Kontext einer Aktivität empfiehlt es sich, connect() in der onStart()-Methode Ihrer Aktivität und disconnect() in der onStop()-Methode Ihrer Aktivität aufzurufen.
Die Methoden connect() und disconnect() werden automatisch aufgerufen, wenn eine automatisch verwaltete Verbindung verwendet wird.
Wenn Sie GoogleApiClient verwenden, um eine Verbindung zu APIs herzustellen, die eine Authentifizierung erfordern, wie Google Drive oder Google Play Spiele, schlägt Ihr erster Verbindungsversuch wahrscheinlich fehl und die App erhält einen Aufruf an onConnectionFailed() mit dem Fehler SIGN_IN_REQUIRED, da das Nutzerkonto nicht angegeben wurde.
Verbindungsfehler beheben
Wenn deine App einen Aufruf an den onConnectionFailed()-Callback empfängt, musst du hasResolution() für das angegebene ConnectionResult-Objekt aufrufen. Wird „true“ zurückgegeben, kann Ihre App den Nutzer auffordern, sofort eine Maßnahme zu ergreifen, um den Fehler zu beheben. Dazu ruft er startResolutionForResult() für das ConnectionResult-Objekt auf.
Die Methode startResolutionForResult() verhält sich in diesem Fall genauso wie startActivityForResult() und startet eine Aktivität, die dem Kontext entspricht und dem Nutzer hilft, den Fehler zu beheben. Dies kann beispielsweise eine Aktivität sein, die dem Nutzer bei der Auswahl eines Kontos hilft.
Wenn hasResolution() „false“ zurückgibt, sollte die Anwendung GoogleApiAvailability.getErrorDialog() aufrufen und den Fehlercode an diese Methode übergeben. Dadurch wird ein von Google Play-Diensten bereitgestelltes Dialog zurückgegeben, das für den Fehler geeignet ist. Das Dialogfeld kann einfach eine Nachricht zur Erläuterung des Fehlers enthalten oder auch eine Aktion zum Starten einer Aktivität, 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 beispielsweise 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üllt oder die von GoogleApiAvailability.getErrorDialog() bereitgestellte Nachricht geschlossen hat, empfängt deine Aktivität den onActivityResult()-Callback mit dem Ergebniscode RESULT_OK.
Deine 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. Dadurch wird der Anwendungsstatus erfasst, während der Nutzer den Fehler löst, um wiederholte Versuche zu vermeiden, den gleichen Fehler zu beheben. Wenn beispielsweise das Dialogfeld für die Kontoauswahl angezeigt wird, um den Fehler SIGN_IN_REQUIRED zu beheben, kann der Nutzer den Bildschirm drehen. Dadurch wird die Aktivität neu erstellt und die Methode onStart() wird noch einmal aufgerufen, die dann connect() noch einmal aufruft. Dies führt zu einem weiteren Aufruf von startResolutionForResult(), bei dem ein weiteres Dialogfeld zur Kontoauswahl vor dem vorhandenen Dialogfeld erstellt wird.
Dieser boolesche Wert erfüllt nur dann seinen beabsichtigten Zweck, wenn er über alle Aktivitätsinstanzen hinweg beibehalten wird. Im nächsten Abschnitt wird erläutert, wie Sie den Fehlerbehandlungsstatus Ihrer App trotz anderer Nutzeraktionen oder Ereignisse auf dem Gerät beibehalten können.
Status beim Beheben eines Fehlers beibehalten
Damit der Code nicht in onConnectionFailed() ausgeführt wird, während ein vorheriger Versuch zur Behebung eines Fehlers ausgeführt wird, müssen Sie einen booleschen Wert beibehalten, der verfolgt, ob Ihre Anwendung bereits versucht, einen Fehler zu beheben.
Wie im obigen Codebeispiel gezeigt, sollte Ihre App bei jedem Aufrufen von
startResolutionForResult()
oder Anzeigen des Dialogfelds von
GoogleApiAvailability.getErrorDialog() einen booleschen Wert auf true festlegen.
Wenn die Anwendung dann RESULT_OK im onActivityResult()-Callback empfängt, legen Sie den booleschen Wert auf false fest.
Wenn Sie den booleschen Wert bei Aktivitätsneustarts im Blick behalten möchten (z. B. wenn der Nutzer den Bildschirm dreht), speichern Sie den booleschen Wert mit onSaveInstanceState() in den gespeicherten Instanzdaten der Aktivität:
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 kannst du deine App sicher ausführen und manuell eine Verbindung zu den Google Play-Diensten herstellen.