import android.app.Activity;
    import android.content.Intent;
    import android.os.Bundle;
    import android.support.annotation.NonNull;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.view.View;
    import android.view.WindowManager;

    import com.google.android.gms.common.ConnectionResult;
    import com.google.android.gms.common.api.GoogleApiClient;
    import com.google.android.gms.games.Games;
    import com.google.android.gms.games.GamesActivityResultCodes;
    import com.google.android.gms.games.GamesStatusCodes;
    import com.google.android.gms.games.multiplayer.Invitation;
    import com.google.android.gms.games.multiplayer.Multiplayer;
    import com.google.android.gms.games.multiplayer.OnInvitationReceivedListener;
    import com.google.android.gms.games.multiplayer.Participant;
    import com.google.android.gms.games.multiplayer.realtime.RealTimeMessage;
    import com.google.android.gms.games.multiplayer.realtime.RealTimeMessageReceivedListener;
    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.RoomStatusUpdateListener;
    import com.google.android.gms.games.multiplayer.realtime.RoomUpdateListener;

    import java.util.ArrayList;
    import java.util.List;

    public class QuickGame extends AppCompatActivity implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, RoomUpdateListener, RealTimeMessageReceivedListener, RoomStatusUpdateListener {

        // Variable declarations here
        public GoogleApiClient mGoogleApiClient;
        final static int RC_SELECT_PLAYERS = 10000;
        final static int RC_WAITING_ROOM = 10001;
        boolean mPlaying = false;

        // at least 1 players required for our game
        final static int MIN_PLAYERS = 2;
        private String mRoomId = "PokerApp102";
        private Room mRoom;

        boolean mWaitingRoomFinishedFromCode = false;
        private OnInvitationReceivedListener mListener;
        private String TAG = "Chips-in";

        public void onStartMatchClicked(View view) {
            Intent intent = Games.RealTimeMultiplayer.getSelectOpponentsIntent(mGoogleApiClient, 1, 2);
            startActivityForResult(intent, RC_SELECT_PLAYERS);
        }

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_quick_game);
            mGoogleApiClient = new GoogleApiClient.Builder(this)
                    .addConnectionCallbacks(this)
                    .addOnConnectionFailedListener(this)
                    .addApi(Games.API).addScope(Games.SCOPE_GAMES)
                    .build();
            mGoogleApiClient.connect();
        }


        // returns whether there are enough players to start the game - in this case 2
        boolean shouldStartGame(Room room) {
            int connectedPlayers = 0;
            for (Participant p : room.getParticipants()) {
                if (p.isConnectedToRoom()) ++connectedPlayers;
            }
            return connectedPlayers >= MIN_PLAYERS;
        }

        // Returns whether the room is in a state where the game should be cancelled.
        boolean shouldCancelGame(Room room) {
            mRoomId = room.getRoomId();
            mRoom = room;
            return false;
        }

        private void startQuickGame() {
            // auto-matches specified range of players
            Bundle am = RoomConfig.createAutoMatchCriteria(1, 2, 0);
            // Room configuration
            RoomConfig.Builder roomConfigBuilder = makeBasicRoomConfigBuilder();
            roomConfigBuilder.setAutoMatchCriteria(am);
            RoomConfig roomConfig = roomConfigBuilder.build();
            // Create RTM room
            Games.RealTimeMultiplayer.create(mGoogleApiClient, roomConfig);
            // Screen stays on during handshake!
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
            // go to game screen

        }

        @Override
        public void onActivityResult(int request, int response, Intent data) {
            if (request == RC_SELECT_PLAYERS) {
                if (response == Activity.RESULT_OK) {
                    // get the invitee list
                    Bundle extras = data.getExtras();
                    final ArrayList<String> invitees =
                            data.getStringArrayListExtra(Games.EXTRA_PLAYER_IDS);

                    // get auto-match 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) {
                        autoMatchCriteria = RoomConfig.createAutoMatchCriteria(
                                minAutoMatchPlayers, maxAutoMatchPlayers, 0);
                    } else {
                        autoMatchCriteria = null;
                    }

                    // create the room and specify a variant if appropriate
                    RoomConfig.Builder roomConfigBuilder = makeBasicRoomConfigBuilder();
                    roomConfigBuilder.addPlayersToInvite(invitees);
                    if (autoMatchCriteria != null) {
                        roomConfigBuilder.setAutoMatchCriteria(autoMatchCriteria);
                    }
                    RoomConfig roomConfig = roomConfigBuilder.build();
                    Games.RealTimeMultiplayer.create(mGoogleApiClient, roomConfig);

                    // prevent screen from sleeping during handshake
                    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
                }
                else if (response == Activity.RESULT_CANCELED) {
                    // Waiting room was dismissed with the back button. The meaning of this
                    // action is up to the game. You may choose to leave the room and cancel the
                    // match, or do something else like minimize the waiting room and
                    // continue to connect in the background.

                    // in this example, we take the simple approach and just leave the room:
                    Games.RealTimeMultiplayer.leave(mGoogleApiClient, null, mRoomId);
                    getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
                }
                else if (response == GamesActivityResultCodes.RESULT_LEFT_ROOM) {
                    // player wants to leave the room.
                    Games.RealTimeMultiplayer.leave(mGoogleApiClient, null, mRoomId);
                    getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
                }
            }
        }


        // create a RoomConfigBuilder that's appropriate for your implementation
        private RoomConfig.Builder makeBasicRoomConfigBuilder() {
            return RoomConfig.builder(this).setMessageReceivedListener(this).setRoomStatusUpdateListener(this);
        }

        public void onConnected(Bundle connectionHint) {

            if (connectionHint != null) {
                Invitation inv = connectionHint.getParcelable(Multiplayer.EXTRA_INVITATION);

                if (inv != null) {
                    // accept invitation
                    RoomConfig.Builder roomConfigBuilder = makeBasicRoomConfigBuilder();
                    roomConfigBuilder.setInvitationIdToAccept(inv.getInvitationId());
                    Games.RealTimeMultiplayer.join(mGoogleApiClient, roomConfigBuilder.build());

                    // prevent screen from sleeping during handshake
                    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

                    // go to game screen
                }
            }

        }

        @Override
        public void onConnectionSuspended(int i) {
            Log.d(TAG, "onConnectionSuspended() called. Trying to reconnect.");
            mGoogleApiClient.connect();
        }

        // RoomUpdateListener methods:
        // this three methods overridden
        @Override
        public void onRoomCreated(int statusCode, Room room) {
            if (statusCode != GamesStatusCodes.STATUS_OK) {
                // let screen go to sleep
                getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

                // show error message, return to main screen.

                return;
            }
            // get waiting room intent
            Intent i = Games.RealTimeMultiplayer.getWaitingRoomIntent(mGoogleApiClient, room, Integer.MAX_VALUE);
            startActivityForResult(i, RC_WAITING_ROOM);
        }

        @Override
        public void onJoinedRoom(int statusCode, Room room) {
            if (statusCode != GamesStatusCodes.STATUS_OK) {
                // let screen go to sleep
                getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

                // show error message, return to main screen.

                return;
            }
            // get waiting room intent
            Intent i = Games.RealTimeMultiplayer.getWaitingRoomIntent(mGoogleApiClient, room, Integer.MAX_VALUE);
            startActivityForResult(i, RC_WAITING_ROOM);
        }

        @Override
        public void onRoomConnected(int statusCode, Room room) {
            if (statusCode != GamesStatusCodes.STATUS_OK) {
                // let screen go to sleep
                getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

                // show error message, return to main screen.
            }
        }

        // Players Connected overridden methods
        @Override
        public void onPeersConnected(Room room, List<String> peers) {
            if (mPlaying) {
                // add new player to an ongoing game
            } else if (shouldStartGame(room)) {
                // start game!
            }
        }

        @Override
        public void onPeersDisconnected(Room room, List<String> peers) {
            if (mPlaying) {
                // do game-specific handling of this -- remove player's avatar
                // from the screen, etc. If not enough players are left for
                // the game to go on, end the game and leave the room.
            } else if (shouldCancelGame(room)) {
                // cancel the game
                Games.RealTimeMultiplayer.leave(mGoogleApiClient, null, mRoomId);
                getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
            }
        }

        @Override
        public void onPeerLeft(Room room, List<String> peers) {
            // peer left -- see if game should be canceled
            if (!mPlaying && shouldCancelGame(room)) {
                Games.RealTimeMultiplayer.leave(mGoogleApiClient, null, mRoomId);
                getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
            }
        }

        @Override
        public void onPeerDeclined(Room room, List<String> peers) {
            // peer declined invitation -- see if game should be canceled
            if (!mPlaying && shouldCancelGame(room)) {
                Games.RealTimeMultiplayer.leave(mGoogleApiClient, null, mRoomId);
                getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
            }
        }

        @Override
        public void onLeftRoom(int statusCode, String roomId) {
            // we have left the room; return to main screen.
            Log.d(TAG, "onLeftRoom, code " + statusCode);
            switchToMainScreen();
        }

        private void switchToMainScreen() {

        }

        // RealTimeMessage methods
        @Override
        public void onRealTimeMessageReceived(RealTimeMessage realTimeMessage) {

        }

        // RoomStatusUpdateListenerMethods
        @Override
        public void onRoomConnecting(Room room) {

        }

        @Override
        public void onRoomAutoMatching(Room room) {

        }

        @Override
        public void onPeerInvitedToRoom(Room room, List<String> list) {

        }



        @Override
        public void onPeerJoined(Room room, List<String> list) {

        }

        @Override
        public void onConnectedToRoom(Room room) {

        }

        // overridden code
        @Override
        public void onDisconnectedFromRoom(Room room) {
            // leave the room
            Games.RealTimeMultiplayer.leave(mGoogleApiClient, null, mRoomId);

            // clear the flag that keeps the screen on
            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

            // show error message and return to main screen
        }

        @Override
        public void onP2PConnected(String s) {

        }

        @Override
        public void onP2PDisconnected(String s) {

        }

        @Override
        public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {

        }
    }