import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void quickMatch() {
	Bundle autoMatchCriteria = RoomConfig.createAutoMatchCriteria(
			1, 1, 0);

	TurnBasedMatchConfig tbmc = TurnBasedMatchConfig.builder()
			.setAutoMatchCriteria(autoMatchCriteria).build();

	

	// Start the match
	ResultCallback<TurnBasedMultiplayer.InitiateMatchResult> cb = new ResultCallback<TurnBasedMultiplayer.InitiateMatchResult>() {
		@Override
		public void onResult(TurnBasedMultiplayer.InitiateMatchResult result) {
			processResult(result);
		}
	};
	Games.TurnBasedMultiplayer.createMatch(gameHelper.getApiClient(), tbmc).setResultCallback(cb);
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void takeTurn(GameModel data) {
	String nextParticipantId = getNextParticipantId();
	// Create the next turn
       mTurnData = new GameModelWrapper(data);

	

	Games.TurnBasedMultiplayer.takeTurn(gameHelper.getApiClient(), mMatch.getMatchId(),
			mTurnData.convertToByteArray(), nextParticipantId).setResultCallback(
			new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
					processResult(result);
				}
			});

	mTurnData = null;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void startMatch(TurnBasedMatch match) {
	System.out.println("Started match");

	mTurnData = new GameModelWrapper();

	mMatch = match;

	String playerId = Games.Players.getCurrentPlayerId(gameHelper.getApiClient());
	String myParticipantId = mMatch.getParticipantId(playerId);

	Games.TurnBasedMultiplayer.takeTurn(gameHelper.getApiClient(), match.getMatchId(),
			mTurnData.convertToByteArray(), myParticipantId).setResultCallback(
			new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
					processResult(result);
				}
			});
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void onQuickMatchClicked(View view) {

        Bundle autoMatchCriteria = RoomConfig.createAutoMatchCriteria(
                1, 1, 0);

        TurnBasedMatchConfig tbmc = TurnBasedMatchConfig.builder()
                .setAutoMatchCriteria(autoMatchCriteria).build();

        showSpinner();

        // Start the match
        ResultCallback<TurnBasedMultiplayer.InitiateMatchResult> cb = new ResultCallback<TurnBasedMultiplayer.InitiateMatchResult>() {
            @Override
            public void onResult(TurnBasedMultiplayer.InitiateMatchResult result) {
                processResult(result);
            }
        };
        Games.TurnBasedMultiplayer.createMatch(mGoogleApiClient, tbmc).setResultCallback(cb);
    }
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void onDoneClicked(View view) {
    showSpinner();

    String nextParticipantId = getNextParticipantId();
    // Create the next turn
    mTurnData.turnCounter += 1;
    mTurnData.data = mDataView.getText().toString();

    showSpinner();

    Games.TurnBasedMultiplayer.takeTurn(mGoogleApiClient, mMatch.getMatchId(),
            mTurnData.persist(), nextParticipantId).setResultCallback(
            new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
        @Override
        public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
            processResult(result);
        }
    });

    mTurnData = null;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void startMatch(TurnBasedMatch match) {
    mTurnData = new SkeletonTurn();
    // Some basic turn data
    mTurnData.data = "First turn";

    mMatch = match;

    String playerId = Games.Players.getCurrentPlayerId(mGoogleApiClient);
    String myParticipantId = mMatch.getParticipantId(playerId);

    showSpinner();

    Games.TurnBasedMultiplayer.takeTurn(mGoogleApiClient, match.getMatchId(),
            mTurnData.persist(), myParticipantId).setResultCallback(
            new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
                @Override
                public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
                    processResult(result);
                }
            });
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
private void processResult(TurnBasedMultiplayer.InitiateMatchResult result) {
    TurnBasedMatch match = result.getMatch();
    dismissSpinner();

    if (!checkStatusCode(match, result.getStatus().getStatusCode())) {
        return;
    }

    if (match.getData() != null) {
        // This is a game that has already started, so I'll just start
        updateMatch(match);
        return;
    }

    startMatch(match);
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public TurnBasedMultiplayer.LoadMatchesResult G(final Status paramStatus)
{
  return new TurnBasedMultiplayer.LoadMatchesResult()
  {
    public LoadMatchesResponse getMatches()
    {
      return new LoadMatchesResponse(new Bundle());
    }

    public Status getStatus()
    {
      return paramStatus;
    }

    public void release()
    {
    }
  };
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public boolean publishRemoteGameState(GameData gameData) {
  if (googleApiClient.isConnected()) {
    Log.d(TAG, "publishRemoteGameState: " + gameData);
    String turnParticipantId = gameDatas.getCurrentPlayer(gameData).getId();
    byte[] gameDataBytes = gameData.toByteArray();
    Log.d(TAG, "takeTurn " + turnParticipantId);
    TurnBasedMultiplayer.takeTurn(googleApiClient, gameData.getMatchId(), gameDataBytes, turnParticipantId);
    if (gameData.getPhase() == Phase.FINISHED) {
      TurnBasedMultiplayer.finishMatch(googleApiClient, gameData.getMatchId());
      fireGameSelected(gameData);
    }
    return true;
  } else {
    gameCache.putUnpublished(gameData.getMatchId(), IGNORED_VALUE);
    return false;
  }
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void checkGames() {
	if(isSignedIn()) {
		Intent intent = Games.TurnBasedMultiplayer.getInboxIntent(gameHelper.getApiClient());
		startActivityForResult(intent, RC_LOOK_AT_MATCHES);
	}
	else
		signIn();
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void takeLastTurn(GameModel data) {
	
	mTurnData = new GameModelWrapper(data);

	Games.TurnBasedMultiplayer.finishMatch(gameHelper.getApiClient(), mMatch.getMatchId(), mTurnData.convertToByteArray())
			.setResultCallback(new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
					processResult(result);
				}
			});

	isDoingTurn = false;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void finishMatch() {
	Games.TurnBasedMultiplayer.finishMatch(gameHelper.getApiClient(), mMatch.getMatchId())
			.setResultCallback(new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
					processResult(result);
				}
			});

	isDoingTurn = false;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void rematch() {
	Games.TurnBasedMultiplayer.rematch(gameHelper.getApiClient(), mMatch.getMatchId()).setResultCallback(
			new ResultCallback<TurnBasedMultiplayer.InitiateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.InitiateMatchResult result) {
					processResult(result);
				}
			});
	mMatch = null;
	isDoingTurn = false;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
private void processResult(TurnBasedMultiplayer.CancelMatchResult result) {
	if (!checkStatusCode(null, result.getStatus().getStatusCode())) {
		return;
	}

	isDoingTurn = false;

	showWarning("Match",
			"This match is canceled.  All other players will have their game ended.");
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void onConnected(Bundle connectionHint) {
	Log.d(TAG, "onConnected(): Connection successful");

	// Retrieve the TurnBasedMatch from the connectionHint
	if (connectionHint != null) {
		mTurnBasedMatch = connectionHint.getParcelable(Multiplayer.EXTRA_TURN_BASED_MATCH);

		if (mTurnBasedMatch != null) {
			if (gameHelper.getApiClient() == null || !gameHelper.getApiClient().isConnected()) {
				Log.d(TAG, "Warning: accessing TurnBasedMatch when not connected");
			}

			updateMatch(mTurnBasedMatch);
			return;
		}
	}


	// As a demonstration, we are registering this activity as a handler for
	// invitation and match events.

	// This is *NOT* required; if you do not register a handler for
	// invitation events, you will get standard notifications instead.
	// Standard notifications may be preferable behavior in many cases.
	Games.Invitations.registerInvitationListener(gameHelper.getApiClient(), this);

	// Likewise, we are registering the optional MatchUpdateListener, which
	// will replace notifications you would get otherwise. You do *NOT* have
	// to register a MatchUpdateListener.
	Games.TurnBasedMultiplayer.registerMatchUpdateListener(gameHelper.getApiClient(), this);
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void onResult(TurnBasedMultiplayer.InitiateMatchResult result) {
    // Check if the status code is not success.
    Status status = result.getStatus();
    if (!status.isSuccess()) {
        Log.d("##MACHINITIATEDCALLBACK","errore!");
        return;
    }

    TurnBasedMatch match = result.getMatch();

    // If this player is not the first player in this match, continue.
    if (match.getData() != null) {
        Log.d("##MACHINITIATEDCALLBACK","WAITING FOR MY TURN");
        return;
    }

    // Otherwise, this is the first player. Initialize the game state.
    Log.d("##MACHINITIATEDCALLBACK","GAME STARTED");
    //initGame(match);



    // Let the player take the first turn
    Log.d("##MACHINITIATEDCALLBACK","showTurnUi");
    //showTurnUI(match);

}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void onConnected(Bundle connectionHint) {
    Log.d(TAG, "onConnected(): Connection successful");

    // Retrieve the TurnBasedMatch from the connectionHint
    if (connectionHint != null) {
        mTurnBasedMatch = connectionHint.getParcelable(Multiplayer.EXTRA_TURN_BASED_MATCH);

        if (mTurnBasedMatch != null) {
            if (mGoogleApiClient == null || !mGoogleApiClient.isConnected()) {
                Log.d(TAG, "Warning: accessing TurnBasedMatch when not connected");
            }

            updateMatch(mTurnBasedMatch);
            return;
        }
    }

    setViewVisibility();

    // As a demonstration, we are registering this activity as a handler for
    // invitation and match events.

    // This is *NOT* required; if you do not register a handler for
    // invitation events, you will get standard notifications instead.
    // Standard notifications may be preferable behavior in many cases.
    Games.Invitations.registerInvitationListener(mGoogleApiClient, this);

    // Likewise, we are registering the optional MatchUpdateListener, which
    // will replace notifications you would get otherwise. You do *NOT* have
    // to register a MatchUpdateListener.
    Games.TurnBasedMultiplayer.registerMatchUpdateListener(mGoogleApiClient, this);
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void onCancelClicked(View view) {
    showSpinner();
    Games.TurnBasedMultiplayer.cancelMatch(mGoogleApiClient, mMatch.getMatchId())
            .setResultCallback(new ResultCallback<TurnBasedMultiplayer.CancelMatchResult>() {
                @Override
                public void onResult(TurnBasedMultiplayer.CancelMatchResult result) {
                    processResult(result);
                }
            });
    isDoingTurn = false;
    setViewVisibility();
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void onLeaveClicked(View view) {
    showSpinner();
    String nextParticipantId = getNextParticipantId();

    Games.TurnBasedMultiplayer.leaveMatchDuringTurn(mGoogleApiClient, mMatch.getMatchId(),
            nextParticipantId).setResultCallback(
                new ResultCallback<TurnBasedMultiplayer.LeaveMatchResult>() {
        @Override
        public void onResult(TurnBasedMultiplayer.LeaveMatchResult result) {
            processResult(result);
        }
    });
    setViewVisibility();
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void onFinishClicked(View view) {
    showSpinner();
    Games.TurnBasedMultiplayer.finishMatch(mGoogleApiClient, mMatch.getMatchId())
            .setResultCallback(new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
                @Override
                public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
                    processResult(result);
                }
            });

    isDoingTurn = false;
    setViewVisibility();
}