MainActivity.java

/* Copyright (C) 2013 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.example.games.bc;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.NonNull;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.WindowManager;
import android.widget.TextView;

import com.google.android.gms.auth.api.signin.GoogleSignIn;
import com.google.android.gms.auth.api.signin.GoogleSignInAccount;
import com.google.android.gms.auth.api.signin.GoogleSignInClient;
import com.google.android.gms.auth.api.signin.GoogleSignInOptions;
import com.google.android.gms.common.api.ApiException;
import com.google.android.gms.games.Games;
import com.google.android.gms.games.GamesActivityResultCodes;
import com.google.android.gms.games.GamesCallbackStatusCodes;
import com.google.android.gms.games.GamesClient;
import com.google.android.gms.games.GamesClientStatusCodes;
import com.google.android.gms.games.InvitationsClient;
import com.google.android.gms.games.Player;
import com.google.android.gms.games.PlayersClient;
import com.google.android.gms.games.RealTimeMultiplayerClient;
import com.google.android.gms.games.multiplayer.Invitation;
import com.google.android.gms.games.multiplayer.InvitationCallback;
import com.google.android.gms.games.multiplayer.Multiplayer;
import com.google.android.gms.games.multiplayer.Participant;
import com.google.android.gms.games.multiplayer.realtime.OnRealTimeMessageReceivedListener;
import com.google.android.gms.games.multiplayer.realtime.RealTimeMessage;
import com.google.android.gms.games.multiplayer.realtime.Room;
import com.google.android.gms.games.multiplayer.realtime.RoomConfig;
import com.google.android.gms.games.multiplayer.realtime.RoomStatusUpdateCallback;
import com.google.android.gms.games.multiplayer.realtime.RoomUpdateCallback;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.android.gms.tasks.Task;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Button Clicker 2000. A minimalistic game showing the multiplayer features of
 * the Google Play game services API. The objective of this game is clicking a
 * button. Whoever clicks the button the most times within a 20 second interval
 * wins. It's that simple. This game can be played with 2, 3 or 4 players. The
 * code is organized in sections in order to make understanding as clear as
 * possible. We start with the integration section where we show how the game
 * is integrated with the Google Play game services API, then move on to
 * game-specific UI and logic.
 * <p>
 * INSTRUCTIONS: To run this sample, please set up
 * a project in the Developer Console. Then, place your app ID on
 * res/values/ids.xml. Also, change the package name to the package name you
 * used to create the client ID in Developer Console. Make sure you sign the
 * APK with the certificate whose fingerprint you entered in Developer Console
 * when creating your Client Id.
 *
 * @author Bruno Oliveira (btco), 2013-04-26
 */
public class MainActivity extends Activity implements
    View.OnClickListener {

    /*
     * API INTEGRATION SECTION. This section contains the code that integrates
     * the game with the Google Play game services API.
     */

  final static String TAG = "ButtonClicker2000";

  // Request codes for the UIs that we show with startActivityForResult:
  final static int RC_SELECT_PLAYERS = 10000;
  final static int RC_INVITATION_INBOX = 10001;
  final static int RC_WAITING_ROOM = 10002;

  // Request code used to invoke sign in user interactions.
  private static final int RC_SIGN_IN = 9001;

  // Client used to sign in with Google APIs
  private GoogleSignInClient mGoogleSignInClient = null;

  // Client used to interact with the real time multiplayer system.
  private RealTimeMultiplayerClient mRealTimeMultiplayerClient = null;

  // Client used to interact with the Invitation system.
  private InvitationsClient mInvitationsClient = null;

  // Room ID where the currently active game is taking place; null if we're
  // not playing.
  String mRoomId = null;

  // Holds the configuration of the current room.
  RoomConfig mRoomConfig;

  // Are we playing in multiplayer mode?
  boolean mMultiplayer = false;

  // The participants in the currently active game
  ArrayList<Participant> mParticipants = null;

  // My participant ID in the currently active game
  String mMyId = null;

  // If non-null, this is the id of the invitation we received via the
  // invitation listener
  String mIncomingInvitationId = null;

  // Message buffer for sending messages
  byte[] mMsgBuf = new byte[2];

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

    // Create the client used to sign in.
    mGoogleSignInClient = GoogleSignIn.getClient(this, GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);

    // set up a click listener for everything we care about
    for (int id : CLICKABLES) {
      findViewById(id).setOnClickListener(this);
    }

    switchToMainScreen();
    checkPlaceholderIds();
  }

  // Check the sample to ensure all placeholder ids are are updated with real-world values.
  // This is strictly for the purpose of the samples; you don't need this in a production
  // application.
  private void checkPlaceholderIds() {
    StringBuilder problems = new StringBuilder();

    if (getPackageName().startsWith("com.google.")) {
      problems.append("- Package name start with com.google.*\n");
    }

    for (Integer id : new Integer[]{R.string.app_id}) {

      String value = getString(id);

      if (value.startsWith("YOUR_")) {
        // needs replacing
        problems.append("- Placeholders(YOUR_*) in ids.xml need updating\n");
        break;
      }
    }

    if (problems.length() > 0) {
      problems.insert(0, "The following problems were found:\n\n");

      problems.append("\nThese problems may prevent the app from working properly.");
      problems.append("\n\nSee the TODO window in Android Studio for more information");
      (new AlertDialog.Builder(this)).setMessage(problems.toString())
          .setNeutralButton(android.R.string.ok, null).create().show();
    }
  }

  @Override
  protected void onResume() {
    super.onResume();
    Log.d(TAG, "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();
  }

  @Override
  protected void onPause() {
    super.onPause();

    // unregister our listeners.  They will be re-registered via onResume->signInSilently->onConnected.
    if (mInvitationsClient != null) {
      mInvitationsClient.unregisterInvitationCallback(mInvitationCallback);
    }
  }

  @Override
  public void onClick(View v) {
    switch (v.getId()) {
      case R.id.button_single_player:
      case R.id.button_single_player_2:
        // play a single-player game
        resetGameVars();
        startGame(false);
        break;
      case R.id.button_sign_in:
        // start the sign-in flow
        Log.d(TAG, "Sign-in button clicked");
        startSignInIntent();
        break;
      case R.id.button_sign_out:
        // user wants to sign out
        // sign out.
        Log.d(TAG, "Sign-out button clicked");
        signOut();
        switchToScreen(R.id.screen_sign_in);
        break;
      case R.id.button_invite_players:
        switchToScreen(R.id.screen_wait);

        // show list of invitable players
        mRealTimeMultiplayerClient.getSelectOpponentsIntent(1, 3).addOnSuccessListener(
            new OnSuccessListener<Intent>() {
              @Override
              public void onSuccess(Intent intent) {
                startActivityForResult(intent, RC_SELECT_PLAYERS);
              }
            }
        ).addOnFailureListener(createFailureListener("There was a problem selecting opponents."));
        break;
      case R.id.button_see_invitations:
        switchToScreen(R.id.screen_wait);

        // show list of pending invitations
        mInvitationsClient.getInvitationInboxIntent().addOnSuccessListener(
            new OnSuccessListener<Intent>() {
              @Override
              public void onSuccess(Intent intent) {
                startActivityForResult(intent, RC_INVITATION_INBOX);
              }
            }
        ).addOnFailureListener(createFailureListener("There was a problem getting the inbox."));
        break;
      case R.id.button_accept_popup_invitation:
        // user wants to accept the invitation shown on the invitation popup
        // (the one we got through the OnInvitationReceivedListener).
        acceptInviteToRoom(mIncomingInvitationId);
        mIncomingInvitationId = null;
        break;
      case R.id.button_quick_game:
        // user wants to play against a random opponent right now
        startQuickGame();
        break;
      case R.id.button_click_me:
        // (gameplay) user clicked the "click me" button
        scoreOnePoint();
        break;
    }
  }

  void startQuickGame() {
    // quick-start a game with 1 randomly selected opponent
    final int MIN_OPPONENTS = 1, MAX_OPPONENTS = 1;
    Bundle autoMatchCriteria = RoomConfig.createAutoMatchCriteria(MIN_OPPONENTS,
        MAX_OPPONENTS, 0);
    switchToScreen(R.id.screen_wait);
    keepScreenOn();
    resetGameVars();

    mRoomConfig = RoomConfig.builder(mRoomUpdateCallback)
        .setOnMessageReceivedListener(mOnRealTimeMessageReceivedListener)
        .setRoomStatusUpdateCallback(mRoomStatusUpdateCallback)
        .setAutoMatchCriteria(autoMatchCriteria)
        .build();
    mRealTimeMultiplayerClient.create(mRoomConfig);
  }

  /**
   * Start a sign in activity.  To properly handle the result, call tryHandleSignInResult from
   * your Activity's onActivityResult function
   */
  public void startSignInIntent() {
    startActivityForResult(mGoogleSignInClient.getSignInIntent(), RC_SIGN_IN);
  }

  /**
   * Try to sign in without displaying dialogs to the user.
   * <p>
   * If the user has already signed in previously, it will not show dialog.
   */
  public void signInSilently() {
    Log.d(TAG, "signInSilently()");

    mGoogleSignInClient.silentSignIn().addOnCompleteListener(this,
        new OnCompleteListener<GoogleSignInAccount>() {
          @Override
          public void onComplete(@NonNull Task<GoogleSignInAccount> task) {
            if (task.isSuccessful()) {
              Log.d(TAG, "signInSilently(): success");
              onConnected(task.getResult());
            } else {
              Log.d(TAG, "signInSilently(): failure", task.getException());
              onDisconnected();
            }
          }
        });
  }

  public void signOut() {
    Log.d(TAG, "signOut()");

    mGoogleSignInClient.signOut().addOnCompleteListener(this,
        new OnCompleteListener<Void>() {
          @Override
          public void onComplete(@NonNull Task<Void> task) {

            if (task.isSuccessful()) {
              Log.d(TAG, "signOut(): success");
            } else {
              handleException(task.getException(), "signOut() failed!");
            }

            onDisconnected();
          }
        });
  }

  /**
   * Since a lot of the operations use tasks, we can use a common handler for whenever one fails.
   *
   * @param exception The exception to evaluate.  Will try to display a more descriptive reason for the exception.
   * @param details   Will display alongside the exception if you wish to provide more details for why the exception
   *                  happened
   */
  private void handleException(Exception exception, String details) {
    int status = 0;

    if (exception instanceof ApiException) {
      ApiException apiException = (ApiException) exception;
      status = apiException.getStatusCode();
    }

    String errorString = null;
    switch (status) {
      case GamesCallbackStatusCodes.OK:
        break;
      case GamesClientStatusCodes.MULTIPLAYER_ERROR_NOT_TRUSTED_TESTER:
        errorString = getString(R.string.status_multiplayer_error_not_trusted_tester);
        break;
      case GamesClientStatusCodes.MATCH_ERROR_ALREADY_REMATCHED:
        errorString = getString(R.string.match_error_already_rematched);
        break;
      case GamesClientStatusCodes.NETWORK_ERROR_OPERATION_FAILED:
        errorString = getString(R.string.network_error_operation_failed);
        break;
      case GamesClientStatusCodes.INTERNAL_ERROR:
        errorString = getString(R.string.internal_error);
        break;
      case GamesClientStatusCodes.MATCH_ERROR_INACTIVE_MATCH:
        errorString = getString(R.string.match_error_inactive_match);
        break;
      case GamesClientStatusCodes.MATCH_ERROR_LOCALLY_MODIFIED:
        errorString = getString(R.string.match_error_locally_modified);
        break;
      default:
        errorString = getString(R.string.unexpected_status, GamesClientStatusCodes.getStatusCodeString(status));
        break;
    }

    if (errorString == null) {
      return;
    }

    String message = getString(R.string.status_exception_error, details, status, exception);

    new AlertDialog.Builder(MainActivity.this)
        .setTitle("Error")
        .setMessage(message + "\n" + errorString)
        .setNeutralButton(android.R.string.ok, null)
        .show();
  }

  @Override
  public void onActivityResult(int requestCode, int resultCode, Intent intent) {

    if (requestCode == RC_SIGN_IN) {

      Task<GoogleSignInAccount> task =
          GoogleSignIn.getSignedInAccountFromIntent(intent);

      try {
        GoogleSignInAccount account = task.getResult(ApiException.class);
        onConnected(account);
      } catch (ApiException apiException) {
        String message = apiException.getMessage();
        if (message == null || message.isEmpty()) {
          message = getString(R.string.signin_other_error);
        }

        onDisconnected();

        new AlertDialog.Builder(this)
            .setMessage(message)
            .setNeutralButton(android.R.string.ok, null)
            .show();
      }
    } else if (requestCode == RC_SELECT_PLAYERS) {
      // we got the result from the "select players" UI -- ready to create the room
      handleSelectPlayersResult(resultCode, intent);

    } else if (requestCode == RC_INVITATION_INBOX) {
      // we got the result from the "select invitation" UI (invitation inbox). We're
      // ready to accept the selected invitation:
      handleInvitationInboxResult(resultCode, intent);

    } else if (requestCode == RC_WAITING_ROOM) {
      // we got the result from the "waiting room" UI.
      if (resultCode == Activity.RESULT_OK) {
        // ready to start playing
        Log.d(TAG, "Starting game (waiting room returned OK).");
        startGame(true);
      } else if (resultCode == GamesActivityResultCodes.RESULT_LEFT_ROOM) {
        // player indicated that they want to leave the room
        leaveRoom();
      } else if (resultCode == Activity.RESULT_CANCELED) {
        // Dialog was cancelled (user pressed back key, for instance). In our game,
        // this means leaving the room too. In more elaborate games, this could mean
        // something else (like minimizing the waiting room UI).
        leaveRoom();
      }
    }
    super.onActivityResult(requestCode, resultCode, intent);
  }

  // Handle the result of the "Select players UI" we launched when the user clicked the
  // "Invite friends" button. We react by creating a room with those players.

  private void handleSelectPlayersResult(int response, Intent data) {
    if (response != Activity.RESULT_OK) {
      Log.w(TAG, "*** select players UI cancelled, " + response);
      switchToMainScreen();
      return;
    }

    Log.d(TAG, "Select players UI succeeded.");

    // get the invitee list
    final ArrayList<String> invitees = data.getStringArrayListExtra(Games.EXTRA_PLAYER_IDS);
    Log.d(TAG, "Invitee count: " + invitees.size());

    // get the automatch criteria
    Bundle autoMatchCriteria = null;
    int minAutoMatchPlayers = data.getIntExtra(Multiplayer.EXTRA_MIN_AUTOMATCH_PLAYERS, 0);
    int maxAutoMatchPlayers = data.getIntExtra(Multiplayer.EXTRA_MAX_AUTOMATCH_PLAYERS, 0);
    if (minAutoMatchPlayers > 0 || maxAutoMatchPlayers > 0) {
      autoMatchCriteria = RoomConfig.createAutoMatchCriteria(
          minAutoMatchPlayers, maxAutoMatchPlayers, 0);
      Log.d(TAG, "Automatch criteria: " + autoMatchCriteria);
    }

    // create the room
    Log.d(TAG, "Creating room...");
    switchToScreen(R.id.screen_wait);
    keepScreenOn();
    resetGameVars();

    mRoomConfig = RoomConfig.builder(mRoomUpdateCallback)
        .addPlayersToInvite(invitees)
        .setOnMessageReceivedListener(mOnRealTimeMessageReceivedListener)
        .setRoomStatusUpdateCallback(mRoomStatusUpdateCallback)
        .setAutoMatchCriteria(autoMatchCriteria).build();
    mRealTimeMultiplayerClient.create(mRoomConfig);
    Log.d(TAG, "Room created, waiting for it to be ready...");
  }

  // Handle the result of the invitation inbox UI, where the player can pick an invitation
  // to accept. We react by accepting the selected invitation, if any.
  private void handleInvitationInboxResult(int response, Intent data) {
    if (response != Activity.RESULT_OK) {
      Log.w(TAG, "*** invitation inbox UI cancelled, " + response);
      switchToMainScreen();
      return;
    }

    Log.d(TAG, "Invitation inbox UI succeeded.");
    Invitation invitation = data.getExtras().getParcelable(Multiplayer.EXTRA_INVITATION);

    // accept invitation
    if (invitation != null) {
      acceptInviteToRoom(invitation.getInvitationId());
    }
  }

  // Accept the given invitation.
  void acceptInviteToRoom(String invitationId) {
    // accept the invitation
    Log.d(TAG, "Accepting invitation: " + invitationId);

    mRoomConfig = RoomConfig.builder(mRoomUpdateCallback)
        .setInvitationIdToAccept(invitationId)
        .setOnMessageReceivedListener(mOnRealTimeMessageReceivedListener)
        .setRoomStatusUpdateCallback(mRoomStatusUpdateCallback)
        .build();

    switchToScreen(R.id.screen_wait);
    keepScreenOn();
    resetGameVars();

    mRealTimeMultiplayerClient.join(mRoomConfig)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
          @Override
          public void onSuccess(Void aVoid) {
            Log.d(TAG, "Room Joined Successfully!");
          }
        });
  }

  // Activity is going to the background. We have to leave the current room.
  @Override
  public void onStop() {
    Log.d(TAG, "**** got onStop");

    // if we're in a room, leave it.
    leaveRoom();

    // stop trying to keep the screen on
    stopKeepingScreenOn();

    switchToMainScreen();

    super.onStop();
  }

  // Handle back key to make sure we cleanly leave a game if we are in the middle of one
  @Override
  public boolean onKeyDown(int keyCode, KeyEvent e) {
    if (keyCode == KeyEvent.KEYCODE_BACK && mCurScreen == R.id.screen_game) {
      leaveRoom();
      return true;
    }
    return super.onKeyDown(keyCode, e);
  }

  // Leave the room.
  void leaveRoom() {
    Log.d(TAG, "Leaving room.");
    mSecondsLeft = 0;
    stopKeepingScreenOn();
    if (mRoomId != null) {
      mRealTimeMultiplayerClient.leave(mRoomConfig, mRoomId)
          .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
              mRoomId = null;
              mRoomConfig = null;
            }
          });
      switchToScreen(R.id.screen_wait);
    } else {
      switchToMainScreen();
    }
  }

  // Show the waiting room UI to track the progress of other players as they enter the
  // room and get connected.
  void showWaitingRoom(Room room) {
    // minimum number of players required for our game
    // For simplicity, we require everyone to join the game before we start it
    // (this is signaled by Integer.MAX_VALUE).
    final int MIN_PLAYERS = Integer.MAX_VALUE;
    mRealTimeMultiplayerClient.getWaitingRoomIntent(room, MIN_PLAYERS)
        .addOnSuccessListener(new OnSuccessListener<Intent>() {
          @Override
          public void onSuccess(Intent intent) {
            // show waiting room UI
            startActivityForResult(intent, RC_WAITING_ROOM);
          }
        })
        .addOnFailureListener(createFailureListener("There was a problem getting the waiting room!"));
  }

  private InvitationCallback mInvitationCallback = new InvitationCallback() {
    // Called when we get an invitation to play a game. We react by showing that to the user.
    @Override
    public void onInvitationReceived(@NonNull Invitation invitation) {
      // We got an invitation to play a game! So, store it in
      // mIncomingInvitationId
      // and show the popup on the screen.
      mIncomingInvitationId = invitation.getInvitationId();
      ((TextView) findViewById(R.id.incoming_invitation_text)).setText(
          invitation.getInviter().getDisplayName() + " " +
              getString(R.string.is_inviting_you));
      switchToScreen(mCurScreen); // This will show the invitation popup
    }

    @Override
    public void onInvitationRemoved(@NonNull String invitationId) {

      if (mIncomingInvitationId.equals(invitationId) && mIncomingInvitationId != null) {
        mIncomingInvitationId = null;
        switchToScreen(mCurScreen); // This will hide the invitation popup
      }
    }
  };

    /*
     * CALLBACKS SECTION. This section shows how we implement the several games
     * API callbacks.
     */

  private String mPlayerId;

  // The currently signed in account, used to check the account has changed outside of this activity when resuming.
  GoogleSignInAccount mSignedInAccount = null;

  private void onConnected(GoogleSignInAccount googleSignInAccount) {
    Log.d(TAG, "onConnected(): connected to Google APIs");
    if (mSignedInAccount != googleSignInAccount) {

      mSignedInAccount = googleSignInAccount;

      // update the clients
      mRealTimeMultiplayerClient = Games.getRealTimeMultiplayerClient(this, googleSignInAccount);
      mInvitationsClient = Games.getInvitationsClient(MainActivity.this, googleSignInAccount);

      // get the playerId from the PlayersClient
      PlayersClient playersClient = Games.getPlayersClient(this, googleSignInAccount);
      playersClient.getCurrentPlayer()
          .addOnSuccessListener(new OnSuccessListener<Player>() {
            @Override
            public void onSuccess(Player player) {
              mPlayerId = player.getPlayerId();

              switchToMainScreen();
            }
          })
          .addOnFailureListener(createFailureListener("There was a problem getting the player id!"));
    }

    // register listener so we are notified if we receive an invitation to play
    // while we are in the game
    mInvitationsClient.registerInvitationCallback(mInvitationCallback);

    // get the invitation from the connection hint
    // Retrieve the TurnBasedMatch from the connectionHint
    GamesClient gamesClient = Games.getGamesClient(MainActivity.this, googleSignInAccount);
    gamesClient.getActivationHint()
        .addOnSuccessListener(new OnSuccessListener<Bundle>() {
          @Override
          public void onSuccess(Bundle hint) {
            if (hint != null) {
              Invitation invitation =
                  hint.getParcelable(Multiplayer.EXTRA_INVITATION);

              if (invitation != null && invitation.getInvitationId() != null) {
                // retrieve and cache the invitation ID
                Log.d(TAG, "onConnected: connection hint has a room invite!");
                acceptInviteToRoom(invitation.getInvitationId());
              }
            }
          }
        })
        .addOnFailureListener(createFailureListener("There was a problem getting the activation hint!"));
  }

  private OnFailureListener createFailureListener(final String string) {
    return new OnFailureListener() {
      @Override
      public void onFailure(@NonNull Exception e) {
        handleException(e, string);
      }
    };
  }

  public void onDisconnected() {
    Log.d(TAG, "onDisconnected()");

    mRealTimeMultiplayerClient = null;
    mInvitationsClient = null;

    switchToMainScreen();
  }

  private RoomStatusUpdateCallback mRoomStatusUpdateCallback = new RoomStatusUpdateCallback() {
    // Called when we are connected to the room. We're not ready to play yet! (maybe not everybody
    // is connected yet).
    @Override
    public void onConnectedToRoom(Room room) {
      Log.d(TAG, "onConnectedToRoom.");

      //get participants and my ID:
      mParticipants = room.getParticipants();
      mMyId = room.getParticipantId(mPlayerId);

      // save room ID if its not initialized in onRoomCreated() so we can leave cleanly before the game starts.
      if (mRoomId == null) {
        mRoomId = room.getRoomId();
      }

      // print out the list of participants (for debug purposes)
      Log.d(TAG, "Room ID: " + mRoomId);
      Log.d(TAG, "My ID " + mMyId);
      Log.d(TAG, "<< CONNECTED TO ROOM>>");
    }

    // Called when we get disconnected from the room. We return to the main screen.
    @Override
    public void onDisconnectedFromRoom(Room room) {
      mRoomId = null;
      mRoomConfig = null;
      showGameError();
    }


    // We treat most of the room update callbacks in the same way: we update our list of
    // participants and update the display. In a real game we would also have to check if that
    // change requires some action like removing the corresponding player avatar from the screen,
    // etc.
    @Override
    public void onPeerDeclined(Room room, @NonNull List<String> arg1) {
      updateRoom(room);
    }

    @Override
    public void onPeerInvitedToRoom(Room room, @NonNull List<String> arg1) {
      updateRoom(room);
    }

    @Override
    public void onP2PDisconnected(@NonNull String participant) {
    }

    @Override
    public void onP2PConnected(@NonNull String participant) {
    }

    @Override
    public void onPeerJoined(Room room, @NonNull List<String> arg1) {
      updateRoom(room);
    }

    @Override
    public void onPeerLeft(Room room, @NonNull List<String> peersWhoLeft) {
      updateRoom(room);
    }

    @Override
    public void onRoomAutoMatching(Room room) {
      updateRoom(room);
    }

    @Override
    public void onRoomConnecting(Room room) {
      updateRoom(room);
    }

    @Override
    public void onPeersConnected(Room room, @NonNull List<String> peers) {
      updateRoom(room);
    }

    @Override
    public void onPeersDisconnected(Room room, @NonNull List<String> peers) {
      updateRoom(room);
    }
  };

  // Show error message about game being cancelled and return to main screen.
  void showGameError() {
    new AlertDialog.Builder(this)
        .setMessage(getString(R.string.game_problem))
        .setNeutralButton(android.R.string.ok, null).create();

    switchToMainScreen();
  }

  private RoomUpdateCallback mRoomUpdateCallback = new RoomUpdateCallback() {

    // Called when room has been created
    @Override
    public void onRoomCreated(int statusCode, Room room) {
      Log.d(TAG, "onRoomCreated(" + statusCode + ", " + room + ")");
      if (statusCode != GamesCallbackStatusCodes.OK) {
        Log.e(TAG, "*** Error: onRoomCreated, status " + statusCode);
        showGameError();
        return;
      }

      // save room ID so we can leave cleanly before the game starts.
      mRoomId = room.getRoomId();

      // show the waiting room UI
      showWaitingRoom(room);
    }

    // Called when room is fully connected.
    @Override
    public void onRoomConnected(int statusCode, Room room) {
      Log.d(TAG, "onRoomConnected(" + statusCode + ", " + room + ")");
      if (statusCode != GamesCallbackStatusCodes.OK) {
        Log.e(TAG, "*** Error: onRoomConnected, status " + statusCode);
        showGameError();
        return;
      }
      updateRoom(room);
    }

    @Override
    public void onJoinedRoom(int statusCode, Room room) {
      Log.d(TAG, "onJoinedRoom(" + statusCode + ", " + room + ")");
      if (statusCode != GamesCallbackStatusCodes.OK) {
        Log.e(TAG, "*** Error: onRoomConnected, status " + statusCode);
        showGameError();
        return;
      }

      // show the waiting room UI
      showWaitingRoom(room);
    }

    // Called when we've successfully left the room (this happens a result of voluntarily leaving
    // via a call to leaveRoom(). If we get disconnected, we get onDisconnectedFromRoom()).
    @Override
    public void onLeftRoom(int statusCode, @NonNull String roomId) {
      // we have left the room; return to main screen.
      Log.d(TAG, "onLeftRoom, code " + statusCode);
      switchToMainScreen();
    }
  };

  void updateRoom(Room room) {
    if (room != null) {
      mParticipants = room.getParticipants();
    }
    if (mParticipants != null) {
      updatePeerScoresDisplay();
    }
  }

    /*
     * GAME LOGIC SECTION. Methods that implement the game's rules.
     */

  // Current state of the game:
  int mSecondsLeft = -1; // how long until the game ends (seconds)
  final static int GAME_DURATION = 20; // game duration, seconds.
  int mScore = 0; // user's current score

  // Reset game variables in preparation for a new game.
  void resetGameVars() {
    mSecondsLeft = GAME_DURATION;
    mScore = 0;
    mParticipantScore.clear();
    mFinishedParticipants.clear();
  }

  // Start the gameplay phase of the game.
  void startGame(boolean multiplayer) {
    mMultiplayer = multiplayer;
    updateScoreDisplay();
    broadcastScore(false);
    switchToScreen(R.id.screen_game);

    findViewById(R.id.button_click_me).setVisibility(View.VISIBLE);

    // run the gameTick() method every second to update the game.
    final Handler h = new Handler();
    h.postDelayed(new Runnable() {
      @Override
      public void run() {
        if (mSecondsLeft <= 0) {
          return;
        }
        gameTick();
        h.postDelayed(this, 1000);
      }
    }, 1000);
  }

  // Game tick -- update countdown, check if game ended.
  void gameTick() {
    if (mSecondsLeft > 0) {
      --mSecondsLeft;
    }

    // update countdown
    ((TextView) findViewById(R.id.countdown)).setText("0:" +
        (mSecondsLeft < 10 ? "0" : "") + String.valueOf(mSecondsLeft));

    if (mSecondsLeft <= 0) {
      // finish game
      findViewById(R.id.button_click_me).setVisibility(View.GONE);
      broadcastScore(true);
    }
  }

  // indicates the player scored one point
  void scoreOnePoint() {
    if (mSecondsLeft <= 0) {
      return; // too late!
    }
    ++mScore;
    updateScoreDisplay();
    updatePeerScoresDisplay();

    // broadcast our new score to our peers
    broadcastScore(false);
  }

    /*
     * COMMUNICATIONS SECTION. Methods that implement the game's network
     * protocol.
     */

  // Score of other participants. We update this as we receive their scores
  // from the network.
  Map<String, Integer> mParticipantScore = new HashMap<>();

  // Participants who sent us their final score.
  Set<String> mFinishedParticipants = new HashSet<>();

  // Called when we receive a real-time message from the network.
  // Messages in our game are made up of 2 bytes: the first one is 'F' or 'U'
  // indicating
  // whether it's a final or interim score. The second byte is the score.
  // There is also the
  // 'S' message, which indicates that the game should start.
  OnRealTimeMessageReceivedListener mOnRealTimeMessageReceivedListener = new OnRealTimeMessageReceivedListener() {
    @Override
    public void onRealTimeMessageReceived(@NonNull RealTimeMessage realTimeMessage) {
      byte[] buf = realTimeMessage.getMessageData();
      String sender = realTimeMessage.getSenderParticipantId();
      Log.d(TAG, "Message received: " + (char) buf[0] + "/" + (int) buf[1]);

      if (buf[0] == 'F' || buf[0] == 'U') {
        // score update.
        int existingScore = mParticipantScore.containsKey(sender) ?
            mParticipantScore.get(sender) : 0;
        int thisScore = (int) buf[1];
        if (thisScore > existingScore) {
          // this check is necessary because packets may arrive out of
          // order, so we
          // should only ever consider the highest score we received, as
          // we know in our
          // game there is no way to lose points. If there was a way to
          // lose points,
          // we'd have to add a "serial number" to the packet.
          mParticipantScore.put(sender, thisScore);
        }

        // update the scores on the screen
        updatePeerScoresDisplay();

        // if it's a final score, mark this participant as having finished
        // the game
        if ((char) buf[0] == 'F') {
          mFinishedParticipants.add(realTimeMessage.getSenderParticipantId());
        }
      }
    }
  };

  // Broadcast my score to everybody else.
  void broadcastScore(boolean finalScore) {
    if (!mMultiplayer) {
      // playing single-player mode
      return;
    }

    // First byte in message indicates whether it's a final score or not
    mMsgBuf[0] = (byte) (finalScore ? 'F' : 'U');

    // Second byte is the score.
    mMsgBuf[1] = (byte) mScore;

    // Send to every other participant.
    for (Participant p : mParticipants) {
      if (p.getParticipantId().equals(mMyId)) {
        continue;
      }
      if (p.getStatus() != Participant.STATUS_JOINED) {
        continue;
      }
      if (finalScore) {
        // final score notification must be sent via reliable message
        mRealTimeMultiplayerClient.sendReliableMessage(mMsgBuf,
            mRoomId, p.getParticipantId(), new RealTimeMultiplayerClient.ReliableMessageSentCallback() {
              @Override
              public void onRealTimeMessageSent(int statusCode, int tokenId, String recipientParticipantId) {
                Log.d(TAG, "RealTime message sent");
                Log.d(TAG, "  statusCode: " + statusCode);
                Log.d(TAG, "  tokenId: " + tokenId);
                Log.d(TAG, "  recipientParticipantId: " + recipientParticipantId);
              }
            })
            .addOnSuccessListener(new OnSuccessListener<Integer>() {
              @Override
              public void onSuccess(Integer tokenId) {
                Log.d(TAG, "Created a reliable message with tokenId: " + tokenId);
              }
            });
      } else {
        // it's an interim score notification, so we can use unreliable
        mRealTimeMultiplayerClient.sendUnreliableMessage(mMsgBuf, mRoomId,
            p.getParticipantId());
      }
    }
  }

    /*
     * UI SECTION. Methods that implement the game's UI.
     */

  // This array lists everything that's clickable, so we can install click
  // event handlers.
  final static int[] CLICKABLES = {
      R.id.button_accept_popup_invitation, R.id.button_invite_players,
      R.id.button_quick_game, R.id.button_see_invitations, R.id.button_sign_in,
      R.id.button_sign_out, R.id.button_click_me, R.id.button_single_player,
      R.id.button_single_player_2
  };

  // This array lists all the individual screens our game has.
  final static int[] SCREENS = {
      R.id.screen_game, R.id.screen_main, R.id.screen_sign_in,
      R.id.screen_wait
  };
  int mCurScreen = -1;

  void switchToScreen(int screenId) {
    // make the requested screen visible; hide all others.
    for (int id : SCREENS) {
      findViewById(id).setVisibility(screenId == id ? View.VISIBLE : View.GONE);
    }
    mCurScreen = screenId;

    // should we show the invitation popup?
    boolean showInvPopup;
    if (mIncomingInvitationId == null) {
      // no invitation, so no popup
      showInvPopup = false;
    } else if (mMultiplayer) {
      // if in multiplayer, only show invitation on main screen
      showInvPopup = (mCurScreen == R.id.screen_main);
    } else {
      // single-player: show on main screen and gameplay screen
      showInvPopup = (mCurScreen == R.id.screen_main || mCurScreen == R.id.screen_game);
    }
    findViewById(R.id.invitation_popup).setVisibility(showInvPopup ? View.VISIBLE : View.GONE);
  }

  void switchToMainScreen() {
    if (mRealTimeMultiplayerClient != null) {
      switchToScreen(R.id.screen_main);
    } else {
      switchToScreen(R.id.screen_sign_in);
    }
  }

  // updates the label that shows my score
  void updateScoreDisplay() {
    ((TextView) findViewById(R.id.my_score)).setText(formatScore(mScore));
  }

  // formats a score as a three-digit number
  String formatScore(int i) {
    if (i < 0) {
      i = 0;
    }
    String s = String.valueOf(i);
    return s.length() == 1 ? "00" + s : s.length() == 2 ? "0" + s : s;
  }

  // updates the screen with the scores from our peers
  void updatePeerScoresDisplay() {
    ((TextView) findViewById(R.id.score0)).setText(
        getString(R.string.score_label, formatScore(mScore)));
    int[] arr = {
        R.id.score1, R.id.score2, R.id.score3
    };
    int i = 0;

    if (mRoomId != null) {
      for (Participant p : mParticipants) {
        String pid = p.getParticipantId();
        if (pid.equals(mMyId)) {
          continue;
        }
        if (p.getStatus() != Participant.STATUS_JOINED) {
          continue;
        }
        int score = mParticipantScore.containsKey(pid) ? mParticipantScore.get(pid) : 0;
        ((TextView) findViewById(arr[i])).setText(formatScore(score) + " - " +
            p.getDisplayName());
        ++i;
      }
    }

    for (; i < arr.length; ++i) {
      ((TextView) findViewById(arr[i])).setText("");
    }
  }

    /*
     * MISC SECTION. Miscellaneous methods.
     */


  // Sets the flag to keep this screen on. It's recommended to do that during
  // the
  // handshake when setting up a game, because if the screen turns off, the
  // game will be
  // cancelled.
  void keepScreenOn() {
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  }

  // Clears the flag that keeps the screen on.
  void stopKeepingScreenOn() {
    getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  }
}