@@ -58,43 +58,6 @@ void Engine::InitGooglePlayGameServices() {
              // Check status code and update UI to signed-in state
              OnAuthActionFinished(op, status);
            })
-          .SetOnMultiplayerInvitationEvent([this](
-               gpg::MultiplayerEvent event, std::string match_id,
-               gpg::MultiplayerInvitation invitation) {
-             // Invoked when invitation has been received
-             // It can be received from the Play Game app, a notification, or
-             // live while the app is running.
-             // (e.g. Though PlayGam app, while the app is running)
-             LOGI("MultiplayerInvitationEvent callback");
-
-             if (event ==
-                 gpg::MultiplayerEvent::UPDATED_FROM_APP_LAUNCH) {
-
-               // In this case, an invitation has been accepted already
-               // in notification or in Play game app
-               gpg::RealTimeMultiplayerManager::RealTimeRoomResponse result =
-                   service_->RealTimeMultiplayer().AcceptInvitationBlocking(
-                       invitation, this);
-               if (gpg::IsSuccess(result.status)) {
-                 room_ = result.room;
-                 service_->RealTimeMultiplayer().ShowWaitingRoomUI(
-                     room_, MIN_PLAYERS,
-                     [this](gpg::RealTimeMultiplayerManager::
-                                WaitingRoomUIResponse const &waitResult) {
-                       EnableUI(true);
-                       if (gpg::IsSuccess(waitResult.status)) {
-                         PlayGame();
-                       }
-                     });
-               } else {
-                 LeaveGame();
-               }
-             } else {
-               // Otherwise, show default inbox and let players to accept an
-               // invitation
-               ShowRoomInbox();
-             }
-           })
           .Create(platform_configuration);
 }
 
@@ -150,193 +113,6 @@ void Engine::OnAuthActionFinished(gpg::AuthOperation op,
   });
 }
 
-/*
- * Show room inbox
- */
-void Engine::ShowRoomInbox() {
-  service_->RealTimeMultiplayer().ShowRoomInboxUI([this](
-      gpg::RealTimeMultiplayerManager::RoomInboxUIResponse const &response) {
-    if (gpg::IsSuccess(response.status)) {
-      gpg::RealTimeMultiplayerManager::RealTimeRoomResponse result =
-          service_->RealTimeMultiplayer().AcceptInvitationBlocking(
-              response.invitation, this);
-      if (gpg::IsSuccess(result.status)) {
-        room_ = result.room;
-        service_->RealTimeMultiplayer().ShowWaitingRoomUI(
-            room_, MIN_PLAYERS,
-            [this](
-                gpg::RealTimeMultiplayerManager::WaitingRoomUIResponse const &
-                    waitResult) {
-              EnableUI(true);
-              if (gpg::IsSuccess(waitResult.status)) {
-                PlayGame();
-              }
-            });
-      } else
-        EnableUI(true);  // Go back to original state for retry
-    } else {
-      LOGI("Invalid response status");
-      EnableUI(true);  // Go back to original state for retry
-    }
-  });
-  EnableUI(false);
-}
-
-/*
- * Quick match
- * - Create a match with minimal setting and play the game
- */
-void Engine::QuickMatch() {
-  gpg::RealTimeRoomConfig config =
-      gpg::RealTimeRoomConfig::Builder()
-          .SetMinimumAutomatchingPlayers(MIN_PLAYERS)
-          .SetMaximumAutomatchingPlayers(MAX_PLAYERS)
-          .Create();
-
-  service_->RealTimeMultiplayer().CreateRealTimeRoom(
-      config, this,
-      [this](gpg::RealTimeMultiplayerManager::RealTimeRoomResponse const &
-                 response) {
-        LOGI("created a room %d", response.status);
-        if (gpg::IsSuccess(response.status)) {
-          room_ = response.room;
-          service_->RealTimeMultiplayer().ShowWaitingRoomUI(
-              room_, MIN_PLAYERS,
-              [this](
-                  gpg::RealTimeMultiplayerManager::WaitingRoomUIResponse const &
-                      waitResult) {
-                EnableUI(true);
-                if (gpg::IsSuccess(waitResult.status)) {
-                  PlayGame();
-                }
-              });
-        } else
-          EnableUI(true);  // Go back to original state for retry
-      });
-  EnableUI(false);
-}
-
-/*
- * Invite friends
- * - Show Player Select UI via ShowPlayerSelectUI,
- * - When the UI is finished, create match and show game UI
- */
-void Engine::InviteFriend() {
-  service_->RealTimeMultiplayer().ShowPlayerSelectUI(
-      MIN_PLAYERS, MAX_PLAYERS, true,
-      [this](gpg::RealTimeMultiplayerManager::PlayerSelectUIResponse const &
-                 response) {
-        LOGI("inviting friends %d", response.status);
-        if (gpg::IsSuccess(response.status)) {
-          // Create room
-          gpg::RealTimeRoomConfig config =
-              gpg::RealTimeRoomConfig::Builder()
-                  .PopulateFromPlayerSelectUIResponse(response)
-                  .Create();
-
-          auto roomResponse =
-              service_->RealTimeMultiplayer().CreateRealTimeRoomBlocking(config,
-                                                                         this);
-          if (gpg::IsSuccess(roomResponse.status)) {
-            room_ = roomResponse.room;
-            service_->RealTimeMultiplayer().ShowWaitingRoomUI(
-                room_, MIN_PLAYERS,
-                [this](gpg::RealTimeMultiplayerManager::
-                           WaitingRoomUIResponse const &waitResult) {
-                  EnableUI(true);
-                  if (gpg::IsSuccess(waitResult.status)) {
-                    PlayGame();
-                  }
-                });
-          } else
-            EnableUI(true);  // Go back to original state for retry
-        } else
-          EnableUI(true);  // Go back to original state for retry
-      });
-  EnableUI(false);
-}
-
-/*
- * Broadcast my score to peers
- */
-void Engine::BroadcastScore(bool bFinal) {
-  std::vector<uint8_t> v;
-  if (!bFinal) {
-    v.push_back('U');
-    v.push_back(static_cast<uint8_t>(score_counter_));
-    service_->RealTimeMultiplayer().SendUnreliableMessageToOthers(room_, v);
-  } else {
-    v.push_back('F');
-    v.push_back(static_cast<uint8_t>(score_counter_));
-
-    const std::vector<gpg::MultiplayerParticipant> participants =
-        room_.Participants();
-    for (gpg::MultiplayerParticipant participant : participants) {
-      service_->RealTimeMultiplayer().SendReliableMessage(
-          room_, participant, v, [](gpg::MultiplayerStatus const &) {});
-    }
-  }
-}
-
-/*
- * Got message from peers
- * room : The room which from_participant is in.
- * from_participant : The participant who sent the data.
- * data : The data which was received.
- * is_reliable : Whether the data was sent using the unreliable or
- *                    reliable mechanism.
- * In this app, packet format is defined as:
- * 1 byte: indicate score type 'F': final score 'U' updating score
- * 1 byte: score
- */
-void Engine::OnDataReceived(gpg::RealTimeRoom const &room,
-                            gpg::MultiplayerParticipant const &from_participant,
-                            std::vector<uint8_t> data, bool is_reliable) {
-  if (data[0] == 'F' && is_reliable) {
-    // Got final score
-    players_score_[from_participant.Id()].score = data[1];
-    players_score_[from_participant.Id()].finished = true;
-    LOGI("Got final data from name:%s ID:%s",
-         from_participant.DisplayName().c_str(), from_participant.Id().c_str());
-  } else if (data[0] == 'U' && !is_reliable) {
-    // Got current score
-    uint8_t score = players_score_[from_participant.Id()].score;
-    players_score_[from_participant.Id()].score = std::max(score, data[1]);
-    LOGI("Got data from name:%s ID:%s",
-         from_participant.DisplayName().c_str(), from_participant.Id().c_str());
-  }
-  UpdateScore();
-}
-
-/*
- * Room status change callback
- */
-void Engine::OnRoomStatusChanged(gpg::RealTimeRoom const &room) {
-  room_ = room;
-}
-
-/*
- * Invoked when participant status changed
- */
-void Engine::OnParticipantStatusChanged(
-    gpg::RealTimeRoom const &room,
-    gpg::MultiplayerParticipant const &participant) {
-
-  // Update participant status
-  LOGI("Participant %s status changed: %d", participant.Id().c_str(),
-       participant.Status());
-
-  if (participant.Status() != gpg::ParticipantStatus::JOINED) {
-    {
-      std::lock_guard<std::mutex> lock(mutex_);
-      if (players_score_.find(participant.Id()) != players_score_.end()) {
-        players_score_[participant.Id()].finished = true;
-      }
-    }
-    UpdateScore();
-  }
-}
-
 /*
  * Play games UI that is in your turn
  */
@@ -380,9 +156,6 @@ void Engine::PlayGame() {
           score_counter_++;
           UpdateScore();
           UpdateTime();
-
-          // Broadcast my score to others via unreliable protocol
-          BroadcastScore(false);
         }
       }
     });
@@ -432,9 +205,6 @@ void Engine::PlayGame() {
                     std::chrono::milliseconds d(100);
                     std::this_thread::sleep_for(d);
                   }
-                  // Broadcast my score to others via reliable protocol
-                  BroadcastScore(true);
-
                   UpdateScore();
                   helper.DetachCurrentThread();
                 }).detach();
@@ -458,32 +228,6 @@ void Engine::UpdateScore() {
            playing_ ? "" : "*");
   std::string allstr(str);
 
-  // Append other player
-  std::vector<gpg::MultiplayerParticipant> participants = room_.Participants();
-  for (gpg::MultiplayerParticipant participant : participants) {
-    LOGI("Participant name:%s ID:%s", participant.DisplayName().c_str(),
-         participant.Id().c_str());
-    if (participant.HasPlayer())
-      LOGI("self:%s PlayerID:%s", self_id_.c_str(),
-           participant.Player().Id().c_str());
-
-    if (participant.HasPlayer() &&
-        participant.Player().Id().compare(self_id_) == 0)
-      continue;  // Skip local player
-
-    int32_t score = 0;
-    bool finished = false;
-    if (players_score_.find(participant.Id()) != players_score_.end()) {
-      score = players_score_[participant.Id()].score;
-      finished = players_score_[participant.Id()].finished;
-    }
-
-    LOGI("Status %d", participant.Status());
-    snprintf(str, SIZE, "%s: %03d %s\n", participant.DisplayName().c_str(),
-             score, finished ? "*" : "");
-    allstr += str;
-  }
-
   // Update game UI, UI update needs to be performed in UI thread
   ndk_helper::JNIHelper::GetInstance()
       ->RunOnUiThread([this, str_myscore, allstr]() {
@@ -543,14 +287,11 @@ void Engine::InitializeGame() {
  * Leave game
  */
 void Engine::LeaveGame() {
-  // Lock mutex
-  std::lock_guard<std::mutex> lock(mutex_);
-
-  service_->RealTimeMultiplayer().LeaveRoom(
-      room_, [](gpg::ResponseStatus const &status) {});
+    // Lock mutex
+    std::lock_guard<std::mutex> lock(mutex_);
 
-  LOGI("Game is over");
-  playing_ = false;
+    LOGI("Game is over");
+    playing_ = false;
 }
 
 /*
@@ -599,36 +340,6 @@ void Engine::InitUI() {
 
   jui_helper::JUIWindow::GetInstance()->AddView(button_sign_in_);
 
-  button_quick_match_ = new jui_helper::JUIButton("Quick match");
-  SetParameters(button_quick_match_, button_sign_in_);
-  button_quick_match_->SetCallback([this](jui_helper::JUIView *view,
-                                          const int32_t message) {
-    if (message == jui_helper::JUICALLBACK_BUTTON_UP) {
-      QuickMatch();
-    }
-  });
-  jui_helper::JUIWindow::GetInstance()->AddView(button_quick_match_);
-
-  button_invite_ = new jui_helper::JUIButton("Invite Friends!");
-  SetParameters(button_invite_, button_quick_match_);
-  button_invite_->SetCallback([this](jui_helper::JUIView *view,
-                                     const int32_t message) {
-    if (message == jui_helper::JUICALLBACK_BUTTON_UP) {
-      InviteFriend();
-    }
-  });
-  jui_helper::JUIWindow::GetInstance()->AddView(button_invite_);
-
-  button_matches_ = new jui_helper::JUIButton("All my invitations");
-  SetParameters(button_matches_, button_invite_);
-  button_matches_->SetCallback([this](jui_helper::JUIView *view,
-                                      const int32_t message) {
-    if (message == jui_helper::JUICALLBACK_BUTTON_UP) {
-      ShowRoomInbox();
-    }
-  });
-  jui_helper::JUIWindow::GetInstance()->AddView(button_matches_);
-
   status_text_ = new jui_helper::JUITextView(
       service_->IsAuthorized() ? "Signed In." : "Signed Out.");
   status_text_->AddRule(jui_helper::LAYOUT_PARAMETER_ALIGN_PARENT_BOTTOM,
@@ -670,12 +381,6 @@ void Engine::SetParameters(jui_helper::JUIButton *button,
 void Engine::EnableUI(bool enable) {
   ndk_helper::JNIHelper::GetInstance()->RunOnUiThread([this, enable]() {
     button_sign_in_->SetAttribute("Enabled", enable);
-
-    bool b = enable;
-    if (service_->IsAuthorized() == false) b = false;
-    button_quick_match_->SetAttribute("Enabled", b);
-    button_invite_->SetAttribute("Enabled", b);
-    button_matches_->SetAttribute("Enabled", b);
   });
 }