Zu Play Spieledienste V2 (Java oder Kotlin) migrieren

In diesem Dokument wird beschrieben, wie Sie vorhandene Spiele vom Games v1-SDK zum Games v2-SDK migrieren.

Hinweis

Sie können für die Migration Ihres Spiels jede beliebige IDE verwenden, z. B. Android Studio. Führen Sie die folgenden Schritte aus, bevor Sie zu Games v2 migrieren:

Abhängigkeiten aktualisieren

  1. Suchen Sie in der Datei build.gradle Ihres Moduls in den Abhängigkeiten auf Modulebene nach der folgenden Zeile:

    implementation "com.google.android.gms:play-services-games:+"

    Ersetzen Sie sie durch den folgenden Code:

    implementation "com.google.android.gms:play-services-games-v2:version"

    Geben Sie statt version die Nummer der neuesten Version des Games-SDK ein.

  2. Nachdem Sie die Abhängigkeiten aktualisiert haben, müssen Sie alle Schritte in diesem Dokument ausführen.

Projekt-ID definieren

So fügen Sie Ihrer App die Projekt-ID des Play-Spieldienste-SDK hinzu:

  1. Fügen Sie in der Datei AndroidManifest.xml dem Element <application> das folgende <meta-data>-Element und die folgenden Attribute hinzu:

    <manifest>
  <application>
    <meta-data android:name="com.google.android.gms.games.APP_ID"
               android:value="@string/game_services_project_id"/>
  </application>
</manifest>

    Definieren Sie den Verweis auf die String-Ressource @string/game_services_project_id mit der Spieldienste-Projekt-ID Ihres Spiels als Wert. Die Spieldienste-Projekt-ID finden Sie in der Google Play Console auf der Seite Konfiguration unter dem Namen Ihres Spiels.

  2. Fügen Sie in der Datei res/values/strings.xml einen Verweis auf die String-Ressource hinzu und legen Sie Ihre Projekt-ID als Wert fest. Beispiel:

    <!-- res/values/strings.xml -->
<resources>
  <!-- Replace 0000000000 with your game’s project id. Example value shown above.  -->
  <string translatable="false"  name="game_services_project_id"> 0000000000 </string>
</resources>

Vom eingestellten Google Log-in migrieren

Ersetzen Sie die Klasse GoogleSignInClient durch die Klasse GamesSignInClient.

Java

Suchen Sie die Dateien mit der Klasse GoogleSignInClient.

import com.google.android.gms.auth.api.signin.GoogleSignIn;
import com.google.android.gms.auth.api.signin.GoogleSignInClient;
import com.google.android.gms.auth.api.signin.GoogleSignInOptions;

// ... existing code

@Override
public void onCreate(@Nullable Bundle bundle) {
    super.onCreate(bundle);

    // ... existing code

    GoogleSignInOptions signInOption =
        new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN).build();
    
    // Client used to sign in to Google services
    GoogleSignInClient googleSignInClient =
        GoogleSignIn.getClient(this, signInOptions);
}

Aktualisieren Sie sie auf Folgendes:

import com.google.android.gms.games.PlayGamesSdk;
import com.google.android.gms.games.PlayGames;
import com.google.android.gms.games.GamesSignInClient;

// ... existing code

@Override
public void onCreate(){
    super.onCreate();
    PlayGamesSdk.initialize(this);
    // Client used to sign in to Google services
    GamesSignInClient gamesSignInClient =
        PlayGames.getGamesSignInClient(getActivity());
}

Kotlin

Suchen Sie die Dateien mit der Klasse GoogleSignInClient.

import com.google.android.gms.auth.api.signin.GoogleSignIn
import com.google.android.gms.auth.api.signin.GoogleSignInClient
import com.google.android.gms.auth.api.signin.GoogleSignInOptions

// ... existing code

val signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN

// ... existing code

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val googleSignInClient: GoogleSignInClient =
        GoogleSignIn.getClient(this, signInOptions)
}

Aktualisieren Sie sie auf Folgendes:

import com.google.android.gms.games.PlayGames
import com.google.android.gms.games.PlayGamesSdk
import com.google.android.gms.games.GamesSignInClient

// ... existing code

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    PlayGamesSdk.initialize(this)
    // client used to sign in to Google services
    val gamesSignInClient: GamesSignInClient =
        PlayGames.getGamesSignInClient(this)
}

GoogleSignIn-Code aktualisieren

Die GoogleSignIn API wird im Games v2-SDK nicht unterstützt. Ersetzen Sie den GoogleSignIn-API-Code durch die GamesSignInClient-API, wie im folgenden Beispiel gezeigt.

Verwenden Sie die Methode GamesSignInClient.requestServerSideAccess(), um ein serverseitiges Zugriffstoken anzufordern. Weitere Informationen finden Sie unter Serverseitige Zugriffsklassen aktualisieren.

Java

Suchen Sie die Dateien mit der Klasse GoogleSignIn.

// Request code used when invoking an external activity.
private static final int RC_SIGN_IN = 9001;

private boolean isSignedIn() {
    GoogleSignInAccount account = GoogleSignIn.getLastSignedInAccount(this);
    GoogleSignInOptions signInOptions =
    GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
    return GoogleSignIn.hasPermissions(account, signInOptions.getScopeArray());
}

private void signInSilently() {
    GoogleSignInOptions signInOptions =
        GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
    GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOptions);
    signInClient
        .silentSignIn()
        .addOnCompleteListener(
            this,
            task -> {
            if (task.isSuccessful()) {
                // The signed-in account is stored in the task's result.
                GoogleSignInAccount signedInAccount = task.getResult();
                showSignInPopup();
            } else {
                // Perform interactive sign in.
                startSignInIntent();
            }
        });
}

private void startSignInIntent() {
    GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
        GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
    Intent intent = signInClient.getSignInIntent();
    startActivityForResult(intent, RC_SIGN_IN);
}

@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.isSuccess()) {
            // The signed-in account is stored in the result.
            GoogleSignInAccount signedInAccount = result.getSignInAccount();
            showSignInPopup();
        } else {
            String message = result.getStatus().getStatusMessage();
            if (message == null || message.isEmpty()) {
                message = getString(R.string.signin_other_error);
        }
        new AlertDialog.Builder(this).setMessage(message)
            .setNeutralButton(android.R.string.ok, null).show();
        }
    }
}

private void showSignInPopup() {
Games.getGamesClient(requireContext(), signedInAccount)
    .setViewForPopups(contentView)
    .addOnCompleteListener(
        task -> {
            if (task.isSuccessful()) {
                logger.atInfo().log("SignIn successful");
            } else {
                logger.atInfo().log("SignIn failed");
            }
        });
  }

Aktualisieren Sie sie auf Folgendes:

private void signInSilently() {
    gamesSignInClient.isAuthenticated().addOnCompleteListener(isAuthenticatedTask -> {
    boolean isAuthenticated =
        (isAuthenticatedTask.isSuccessful() &&
            isAuthenticatedTask.getResult().isAuthenticated());
        if (isAuthenticated) {
            // Continue with Play Games Services
        } else {
            // If authentication fails, either disable Play Games Services
            // integration or
            // display a login button to prompt players to sign in.
            // Use`gamesSignInClient.signIn()` when the login button is clicked.
        }
    });
}

@Override
protected void onResume() {
    super.onResume();
    // When the activity is inactive, the signed-in user's state can change;
    // therefore, silently sign in when the app resumes.
    signInSilently();
}

Kotlin

Suchen Sie die Dateien mit der Klasse GoogleSignIn.

// Request codes we use when invoking an external activity.
private val RC_SIGN_IN = 9001

// ... existing code

private fun isSignedIn(): Boolean {
    val account = GoogleSignIn.getLastSignedInAccount(this)
    val signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN
    return GoogleSignIn.hasPermissions(account, *signInOptions.scopeArray)
}

private fun signInSilently() {
    val signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN
    val signInClient = GoogleSignIn.getClient(this, signInOptions)
    signInClient.silentSignIn().addOnCompleteListener(this) { task ->
        if (task.isSuccessful) {
            // The signed-in account is stored in the task's result.
            val signedInAccount = task.result
            // Pass the account to showSignInPopup.
            showSignInPopup(signedInAccount)
        } else {
            // Perform interactive sign in.
            startSignInIntent()
        }
    }
}

private fun startSignInIntent() {
    val signInClient = GoogleSignIn.getClient(this, GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
    val intent = signInClient.signInIntent
    startActivityForResult(intent, RC_SIGN_IN)
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode == RC_SIGN_IN) {
        val result = Auth.GoogleSignInApi.getSignInResultFromIntent(data)
        if (result.isSuccess) {
            // The signed-in account is stored in the result.
            val signedInAccount = result.signInAccount
            showSignInPopup(signedInAccount) // Pass the account to showSignInPopup.
        } else {
            var message = result.status.statusMessage
            if (message == null || message.isEmpty()) {
                message = getString(R.string.signin_other_error)
        }
        AlertDialog.Builder(this)
            .setMessage(message)
            .setNeutralButton(android.R.string.ok, null)
            .show()
        }
    }
}

private fun showSignInPopup(signedInAccount: GoogleSignInAccount) {
    // Add signedInAccount parameter.
    Games.getGamesClient(this, signedInAccount)
        .setViewForPopups(contentView) // Assuming contentView is defined.
        .addOnCompleteListener { task ->
        if (task.isSuccessful) {
            logger.atInfo().log("SignIn successful")
        } else {
            logger.atInfo().log("SignIn failed")
        }
    }
}

Aktualisieren Sie sie auf Folgendes:

private fun signInSilently() {
    gamesSignInClient.isAuthenticated.addOnCompleteListener { isAuthenticatedTask ->
        val isAuthenticated = isAuthenticatedTask.isSuccessful &&
        isAuthenticatedTask.result.isAuthenticated
        if (isAuthenticated) {
            // Continue with Play Games Services
        } else {
            // To handle a user who is not signed in, either disable Play Games Services integration
            // or display a login button. Selecting this button calls `gamesSignInClient.signIn()`.
        }
    }
}

override fun onResume() {
    super.onResume()
    // Since the state of the signed in user can change when the activity is
    // not active it is recommended to try and sign in silently from when the
    // app resumes.
    signInSilently()
}

GamesSignInClient-Code hinzufügen

Wenn sich der Spieler erfolgreich angemeldet hat, entfernen Sie die Schaltfläche für die Anmeldung über die Play-Spieldienste aus Ihrem Spiel. Wenn sich der Nutzer beim Start des Spiels nicht anmeldet, wird weiterhin eine Schaltfläche mit dem Play-Spieldienste-Symbol angezeigt und der Anmeldevorgang wird mit GamesSignInClient.signIn() gestartet.

Java

private void startSignInIntent() {
    gamesSignInClient
        .signIn()
        .addOnCompleteListener( task -> {
            if (task.isSuccessful() && task.getResult().isAuthenticated()) {
                // sign in successful
            } else {
                // sign in failed
            }
        });
  }

Kotlin

private fun startSignInIntent() {
    gamesSignInClient
        .signIn()
        .addOnCompleteListener { task ->
            if (task.isSuccessful && task.result.isAuthenticated) {
                // sign in successful
            } else {
                // sign in failed
            }
        }
  }

Abmeldecode entfernen

Entfernen Sie den Code für GoogleSignInClient.signOut.

Entfernen Sie den im folgenden Beispiel gezeigten Code:

Java

// ... existing code

private void signOut() {
    GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
    GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
    signInClient.signOut().addOnCompleteListener(this,
    new OnCompleteListener() {
        @Override
        public void onComplete(@NonNull Task task) {
           // At this point, the user is signed out.
        }
    });
}

Kotlin

// ... existing code

private fun signOut() {
    val signInClient = GoogleSignIn.getClient(this, GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
    signInClient.signOut().addOnCompleteListener(this) {
    // At this point, the user is signed out.
    }
}

Erfolgreiche automatische Anmeldung prüfen

Fügen Sie den folgenden Code ein, um zu prüfen, ob Sie automatisch angemeldet sind, und fügen Sie die benutzerdefinierte Logik hinzu, falls sie verfügbar ist.

Java

private void checkIfAutomaticallySignedIn() {
gamesSignInClient.isAuthenticated().addOnCompleteListener(isAuthenticatedTask -> {
boolean isAuthenticated =
    (isAuthenticatedTask.isSuccessful() &&
    isAuthenticatedTask.getResult().isAuthenticated());

    if (isAuthenticated) {
        // Continue with Play Games Services
        // If your game requires specific actions upon successful sign-in,
        // you can add your custom logic here.
        // For example, fetching player data or updating UI elements.
    } else {
        // Disable your integration with Play Games Services or show a
        // login button to ask  players to sign-in. Clicking it should
        // call GamesSignInClient.signIn().
        }
    });
}

Kotlin

private void checkIfAutomaticallySignedIn() {
gamesSignInClient.isAuthenticated()
    .addOnCompleteListener { task ->
    val isAuthenticated = task.isSuccessful && task.result?.isAuthenticated ?: false

        if (isAuthenticated) {
            // Continue with Play Games Services
        } else {
            // Disable your integration or show a login button
        }
    }
}

Clientklassennamen und -methoden aktualisieren

Wenn Sie zu Games v2 migrieren, sind die Methoden zum Abrufen der Clientklassennamen anders. Verwenden Sie statt Games.getxxxClient()-Methoden die entsprechenden PlayGames.getxxxClient()-Methoden.

Verwenden Sie beispielsweise für LeaderboardsClient anstelle der Methode Games.getLeaderboardsClient() die Methode PlayGames.getLeaderboardsClient().

Entfernen Sie jeglichen Code, der sich auf die Klassen GamesClient und GamesMetadataClient bezieht, da es in Games v2 keine entsprechenden Ersatzklassen gibt.

Java

Suchen Sie den Code für LeaderboardsClient.

import com.google.android.gms.games.LeaderboardsClient;
import com.google.android.gms.games.Games;

@Override
public void onCreate(@Nullable Bundle bundle) {
    super.onCreate(bundle);
        // Get the leaderboards client using Play Games services.
    LeaderboardsClient leaderboardsClient = Games.getLeaderboardsClient(this,
        GoogleSignIn.getLastSignedInAccount(this));
}

Aktualisieren Sie ihn auf Folgendes:

import com.google.android.gms.games.LeaderboardsClient;
import com.google.android.gms.games.PlayGames;

 @Override
public void onCreate(@Nullable Bundle bundle) {
    super.onCreate(bundle);
        // Get the leaderboards client using Play Games services.
        LeaderboardsClient leaderboardsClient = PlayGames.getLeaderboardsClient(getActivity());
}

Kotlin

Suchen Sie den Code für LeaderboardsClient.

import com.google.android.gms.games.LeaderboardsClient
import com.google.android.gms.games.Games
// Initialize the variables.
private lateinit var leaderboardsClient: LeaderboardsClient

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    leaderboardsClient = Games.getLeaderboardsClient(this,
        GoogleSignIn.getLastSignedInAccount(this))
}

Aktualisieren Sie ihn auf Folgendes:

import com.google.android.gms.games.LeaderboardsClient
import com.google.android.gms.games.PlayGames
    // Initialize the variables.
private lateinit var leaderboardsClient: LeaderboardsClient

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    leaderboardsClient = PlayGames.getLeaderboardsClient(this)
}

Verwenden Sie für die folgenden Clients die entsprechenden Methoden: AchievementsClient, EventsClient, GamesSignInClient, PlayerStatsClient, RecallClient, SnapshotsClient oder PlayersClient.

Serverseitige Zugriffsklassen aktualisieren

Um ein serverseitiges Zugriffstoken anzufordern, verwenden Sie statt der Methode GoogleSignInAccount.getServerAuthCode() die Methode GamesSignInClient.requestServerSideAccess().

Weitere Informationen finden Sie unter Server-Autorisierungscode senden.

Im folgenden Beispiel wird gezeigt, wie ein serverseitiges Zugriffstoken angefordert wird.

Java

Suchen Sie den Code für die Klasse GoogleSignInOptions.

    private static final int RC_SIGN_IN = 9001;
    private GoogleSignInClient googleSignInClient;

    private void startSignInForAuthCode() {
        /** Client ID for your backend server. */
        String webClientId = getString(R.string.webclient_id);
        GoogleSignInOptions signInOption = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
            .requestServerAuthCode(webClientId)
            .build();

        GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOption);
        Intent intent = signInClient.getSignInIntent();
        startActivityForResult(intent, RC_SIGN_IN);
    }

    /** Auth code to send to backend server */
    private String mServerAuthCode;

    @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.isSuccess()) {
            mServerAuthCode = result.getSignInAccount().getServerAuthCode();
        } else {
            String message = result.getStatus().getStatusMessage();
            if (message == null || message.isEmpty()) {
                message = getString(R.string.signin_other_error);
            }
            new AlertDialog.Builder(this).setMessage(message)
                .setNeutralButton(android.R.string.ok, null).show();
        }
      }
    }

Aktualisieren Sie ihn auf Folgendes:

  private void startRequestServerSideAccess() {
      GamesSignInClient gamesSignInClient = PlayGames.getGamesSignInClient(this);
      gamesSignInClient
          .requestServerSideAccess(OAUTH_2_WEB_CLIENT_ID,
           /* forceRefreshToken= */ false, /* additional AuthScope */ scopes)
          .addOnCompleteListener(task -> {
              if (task.isSuccessful()) {
                  AuthResponse authresp = task.getResult();
                  // Send the authorization code as a string and a
                  // list of the granted AuthScopes that were granted by the
                  // user. Exchange for an access token.
                  // Verify the player with Play Games Services REST APIs.
              } else {
                // Authentication code retrieval failed.
              }
        });
  }

Kotlin

Suchen Sie den Code für den Kurs GoogleSignInOptions.

  // ... existing code

  private val RC_SIGN_IN = 9001
  private lateinit var googleSignInClient: GoogleSignInClient

  // Auth code to send to backend server.
  private var mServerAuthCode: String? = null

  private fun startSignInForAuthCode() {
      // Client ID for your backend server.
      val webClientId = getString(R.string.webclient_id)

      val signInOption = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
          .requestServerAuthCode(webClientId)
          .build()

      googleSignInClient = GoogleSignIn.getClient(this, signInOption)
      val intent = googleSignInClient.signInIntent
      startActivityForResult(intent, RC_SIGN_IN)
  }

  override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
      super.onActivityResult(requestCode, resultCode, data)
      if (requestCode == RC_SIGN_IN) {
          val result = Auth.GoogleSignInApi.getSignInResultFromIntent(data)
          if (result.isSuccess) {
              mServerAuthCode = result.signInAccount.serverAuthCode
          } else {
              var message = result.status.statusMessage
              if (message == null || message.isEmpty()) {
                  message = getString(R.string.signin_other_error)
              }
              AlertDialog.Builder(this).setMessage(message)
                  .setNeutralButton(android.R.string.ok, null).show()
            }
        }
  }

Aktualisieren Sie ihn auf Folgendes:

  private void startRequestServerSideAccess() {
  GamesSignInClient gamesSignInClient = PlayGames.getGamesSignInClient(this);
      gamesSignInClient
          .requestServerSideAccess(OAUTH_2_WEB_CLIENT_ID, /* forceRefreshToken= */ false,
          /* additional AuthScope */ scopes)
          .addOnCompleteListener(task -> {
              if (task.isSuccessful()) {
                  AuthResponse authresp = task.getResult();
                  // Send the authorization code as a string and a
                  // list of the granted AuthScopes that were granted by the
                  // user. Exchange for an access token.
                  // Verify the player with Play Games Services REST APIs.
              } else {
                // Authentication code retrieval failed.
              }
        });
  }

Von GoogleApiClient migrieren

Bei älteren bestehenden Integrationen hängt Ihr Spiel möglicherweise von der GoogleApiClient-API-Variante des Play-Spieldienste-SDK ab. Diese wurde Ende 2017 eingestellt und durch „verbindungslose“ Clients ersetzt. Für die Migration können Sie die Klasse GoogleApiClient durch ein „verbindungsloses“ Äquivalent ersetzen. In der folgenden Tabelle sind die allgemeinen Klassenzuordnungen von Games v1 zu Games v2 aufgeführt:

games v2 (aktuell) games v1 (Legacy)
com.google.android.gms.games.AchievementsClient com.google.android.gms.games.achievement.Achievements
com.google.android.gms.games.LeaderboardsClient com.google.android.gms.games.leaderboard.Leaderboard
com.google.android.gms.games.SnapshotsClient com.google.android.gms.games.snapshot.Snapshots
com.google.android.gms.games.PlayerStatsClient com.google.android.gms.games.stats.PlayerStats
com.google.android.gms.games.PlayersClient com.google.android.gms.games.Players
com.google.android.gms.games.GamesClientStatusCodes com.google.android.gms.games.GamesStatusCodes

Spiel erstellen und ausführen

Informationen zum Erstellen und Ausführen in Android Studio finden Sie unter App erstellen und ausführen.

Spiel testen

Testen Sie Ihr Spiel, um sicherzustellen, dass es wie vorgesehen funktioniert. Welche Tests Sie durchführen hängt von den Funktionen Ihres Spiels ab.

Im Folgenden finden Sie eine Liste mit häufig durchgeführten Tests.

  1. Erfolgreiche Anmeldung

    1. Die automatische Anmeldung funktioniert. Der Nutzer sollte beim Starten des Spiels in den Play-Spieldiensten angemeldet werden.

    2. Das Begrüßungs-Pop-up wird angezeigt.

      Beispiel für ein Willkommens-Pop-up
      Beispiel für ein Begrüßungs-Pop-up (zum Vergrößern klicken)

    3. Meldungen über eine erfolgreiche Anmeldung werden angezeigt. Führen Sie im Terminal den folgenden Befehl aus:

      adb logcat | grep com.google.android.

      Im folgenden Beispiel sehen Sie eine erfolgreiche Logmeldung:

      [$PlaylogGamesSignInAction$SignInPerformerSource@e1cdecc
number=1 name=GAMES_SERVICE_BROKER>], returning true for shouldShowWelcomePopup.
[CONTEXT service_id=1 ]

  2. Einheitlichkeit der UI-Komponenten sicherstellen

    1. Pop-ups, Bestenlisten und Erfolge werden in der Benutzeroberfläche der Play-Spieldienste auf verschiedenen Bildschirmgrößen und in verschiedenen Ausrichtungen korrekt und einheitlich angezeigt.

    2. Die Abmeldeoption ist in der Benutzeroberfläche der Play-Spieldienste nicht sichtbar.

    3. Prüfen Sie, ob Sie die Spieler-ID abrufen können und ob die serverseitigen Funktionen wie erwartet funktionieren.

    4. Wenn das Spiel die serverseitige Authentifizierung verwendet, testen Sie den requestServerSideAccess-Ablauf gründlich. Achten Sie darauf, dass der Server den Authentifizierungscode empfängt und ihn gegen ein Zugriffstoken eintauschen kann. Testen Sie sowohl Erfolgs- als auch Fehlerszenarien für Netzwerkfehler und ungültige client ID-Szenarien.

Wenn in Ihrem Spiel eine der folgenden Funktionen verwendet wurde, testen Sie sie, um sicherzustellen, dass sie wie vor der Migration funktionieren:

  • Bestenlisten: Punktzahlen senden und Bestenlisten ansehen. Prüfen Sie, ob die Namen der Spieler, die Rangfolge und die Punkte richtig angezeigt werden.
  • Erfolge: Entsperren Sie Erfolge und prüfen Sie, ob sie in der Play Spiele-Benutzeroberfläche richtig aufgezeichnet und angezeigt werden.
  • Gespeicherte Spiele: Wenn das Spiel gespeicherte Spiele verwendet, muss das Speichern und Laden des Spielfortschritts einwandfrei funktionieren. Dies ist besonders wichtig, wenn Sie die Funktion auf mehreren Geräten und nach App-Updates testen.

Aufgaben nach der Migration

Führen Sie die folgenden Schritte aus, nachdem Sie Ihr Spiel zu Games v2 migriert haben.

Spiel veröffentlichen

Erstellen Sie die APKs und veröffentlichen Sie das Spiel in der Play Console.

  1. Wählen Sie im Android Studio-Menü Build > Build Bundle(s) / APK(s) > Build APK(s) aus.
  2. Veröffentlichen Sie Ihr Spiel. Weitere Informationen finden Sie unter Private Apps über die Play Console veröffentlichen.