Die Option zum Starten der Wiedergabe wird nicht angezeigt, wenn ich Games.RealTimeMultiplayer.getWaitingRoomIntent anrufe

Question

Ich versuche, die Google Play-Spieldienste zu lernen und habe Probleme mit Games.RealTimeMultiplayer.getWaitingRoomIntent. Soll es die Absicht auf alle eingeladenen Benutzer zeigen?

Ich bin in der Lage, die Spielerauswahl angezeigt werden und nach einem Spieler der Auswahl, nenne ich

Intent intent = Games.RealTimeMultiplayer.getWaitingRoomIntent(mGoogleApiClient, room, 1); 
     startActivityForResult(intent, RC_WAITING_ROOM); 

innerhalb onRoomCreated, und die Standard-Wartezimmer Absicht ist auch, aber nur auf dem Gerät des Spielers angezeigt, die erstellt das Zimmer. Aber danach bekomme ich von keinem der Callbacks etwas.

Hier ist mein Code:

protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main); 

    textView = (TextView) findViewById(R.id.textView); 
    textViewMessages = (TextView) findViewById(R.id.textViewMessages); 

    buttonStartMatch = (Button) findViewById(R.id.buttonStartMatch); 
    buttonStartMatch.setOnClickListener(new View.OnClickListener() { 
     @Override 
     public void onClick(View view) { 
      switch (view.getId()) { 
       case R.id.buttonStartMatch: 
        Intent intent = Games.RealTimeMultiplayer.getSelectOpponentsIntent(mGoogleApiClient, 1, 7, true); 
        startActivityForResult(intent, RC_SELECT_OPPONENT); 
        break; 
      } 
     } 
    }); 

    // Create the Google Api Client with access to the Play Games services 
    mGoogleApiClient = new GoogleApiClient.Builder(this) 
      .addConnectionCallbacks(this) 
      .addOnConnectionFailedListener(this) 
      .addApi(Games.API) 
      .addScope(Games.SCOPE_GAMES) 
      .build(); 
} 



@Override 
protected void onStart() { 
    super.onStart(); 
    mGoogleApiClient.connect(); 
} 

@Override 
protected void onStop() { 
    super.onStop(); 
    mGoogleApiClient.disconnect(); 
} 



protected void onActivityResult(int requestCode, int resultCode, 
           Intent data) { 
    switch (requestCode) { 
     case RC_SIGN_IN: 
      mSignInClicked = false; 
      mResolvingConnectionFailure = false; 
      if (resultCode == RESULT_OK) { 
       Log.i("RC_SIGN_IN", "OK"); 
       mGoogleApiClient.connect(); 
      } else { 
       Log.i("RC_SIGN_IN", "FAILED"); 
      } 
      break; 
     case RC_RESOLVE_ERROR: 
      if (resultCode == RESULT_OK) { 
       Log.i("RC_RESOLVE_ERROR", "OK"); 
       textView.setText(""); 
       mGoogleApiClient.connect(); 
      } 
      else { 
       Log.i("RC_RESOLVE_ERROR", "FAILED"); 
      } 
      break; 
     case RC_SELECT_OPPONENT: 
      if (resultCode != Activity.RESULT_OK) { 
       // user canceled 
       return; 
      } 

      // get the invitee list 
      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); 

      break; 

     case RC_WAITING_ROOM: 
      if (resultCode == RESULT_OK) { 
       Log.i("RC_WAITING_ROOM", "START GAME!!!!"); 
      } 
      else if (resultCode == RESULT_CANCELED) { 
       Log.i("RC_WAITING_ROOM", "USER CANCELLED"); 
      } 
      else if (resultCode == GamesActivityResultCodes.RESULT_LEFT_ROOM) { 
       Log.i("RC_WAITING_ROOM", "USER LEFT THE ROOM"); 
      } 
      break; 
    } 
} 











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






private class OnRoomUpdateListener implements RoomUpdateListener { 
    @Override 
    public void onRoomCreated(int statusCode, Room room) { 
     Log.i("ROOM CREATED", room.toString()); 
     if (statusCode != GamesStatusCodes.STATUS_OK) { 
      Log.i("ROOM CREATED ERROR", statusCode + ""); 
     } 

     Intent intent = Games.RealTimeMultiplayer.getWaitingRoomIntent(mGoogleApiClient, room, 1); 
     startActivityForResult(intent, RC_WAITING_ROOM); 
    } 

    @Override 
    public void onJoinedRoom(int statusCode, Room room) { 
     Log.i("JOINED ROOM", "JOINED ROOM"); 
     if (statusCode != GamesStatusCodes.STATUS_OK) { 
      Log.i("JOINED ROOM ERROR", statusCode + ""); 
     } 

     Intent intent = Games.RealTimeMultiplayer.getWaitingRoomIntent(mGoogleApiClient, room, 1); 
     startActivityForResult(intent, RC_WAITING_ROOM); 
    } 

    @Override 
    public void onLeftRoom(int statusCode, String s) { 
     Log.i("LEFT ROOM", "LEFT ROOM"); 
     if (statusCode != GamesStatusCodes.STATUS_OK) { 
      Log.i("LEFT ROOM ERROR", statusCode + ""); 
     } 
    } 

    @Override 
    public void onRoomConnected(int statusCode, Room room) { 
     Log.i("ROOM CONNECTED", "ROOM CONNECTED"); 
     if (statusCode != GamesStatusCodes.STATUS_OK) { 
      Log.i("ROOM CONNECTED ERROR", statusCode + ""); 
     } 
    } 
} 






private class OnRoomStatusUpdateListener implements RoomStatusUpdateListener { 

    @Override 
    public void onRoomConnecting(Room room) { 
     Log.i("ROOM CONNECTING", "ROOM CONNECTING"); 
    } 

    @Override 
    public void onRoomAutoMatching(Room room) { 
     Log.i("AUTO MATCHING", "AUTO MATCHING"); 
    } 

    @Override 
    public void onPeerInvitedToRoom(Room room, List<String> list) { 
     Log.i("PEER INVITED", "PEER INVITED"); 
    } 

    @Override 
    public void onPeerDeclined(Room room, List<String> list) { 
     Log.i("PEER DECLINED", "PEER DECLINED"); 
    } 

    @Override 
    public void onPeerJoined(Room room, List<String> list) { 
     Log.i("PEER JOINED", "PEER JOINED"); 
    } 

    @Override 
    public void onPeerLeft(Room room, List<String> list) { 
     Log.i("PEER LEFT", "PEER LEFT"); 
    } 

    @Override 
    public void onConnectedToRoom(Room room) { 
     Log.i("CONNECTED TO ROOM", "CONNECTED TO ROOM"); 
    } 

    @Override 
    public void onDisconnectedFromRoom(Room room) { 
     Log.i("DISCONNECTED FROM ROOM", "DISCONNECTED FROM ROOM"); 
    } 

    @Override 
    public void onPeersConnected(Room room, List<String> list) { 
     Log.i("PEERS CONNECTED", "PEERS CONNECTED"); 
    } 

    @Override 
    public void onPeersDisconnected(Room room, List<String> list) { 
     Log.i("PEERS DISCONNECTED", "PEERS DISCONNECTED"); 
    } 

    @Override 
    public void onP2PConnected(String s) { 
     Log.i("P2P CONNECTED", "P2P CONNECTED"); 
    } 

    @Override 
    public void onP2PDisconnected(String s) { 
     Log.i("P2P DISCONNECTED", "P2P DISCONNECTED"); 
    } 
} 





private class OnMessageReceivedListener implements RealTimeMessageReceivedListener { 

    @Override 
    public void onRealTimeMessageReceived(RealTimeMessage realTimeMessage) { 
     Log.i("REAL TIME MESSAGE", realTimeMessage.toString()); 
    } 
} 

Answer 1

Wie in Optional: Adding a waiting room UI erwähnt,

Der zweite Parameter in getWaitingRoomIntent() die Anzahl der Spieler gibt, die im Raum verbunden werden müssen, bevor die starten Option spielen wird angezeigt. In dem Beispiel geben wir MAX_VALUE an, was anzeigt, dass die Option zum Starten der Wiedergabe nie angezeigt wird. Stattdessen wird die Warteraum-Benutzeroberfläche automatisch beendet, sobald alle Spieler verbunden sind.

Weitere Informationen und Beispielcodes können in Adding Real-time Multiplayer Support to Your Android Game und gehen durch RealTimeMultiplayer wird hilfreich zu finden sein.