2

我正在移植一个游戏以使用支持多人游戏的 Google Play 游戏服务。我正在使用 RealTimeSocket 而不是实时消息，因为游戏已经支持套接字。

为了获得套接字，我调用 GamesClient.getRealTimeSocketForParticipant，然后我可以获得输入和输出流，就像将它用作普通套接字一样。

我的问题是，如果设备在调用 getRealTimeSocketForParticipant 之前接收到数据，我将无法读取这些数据。例如：

设备 A 调用 getRealTimeSocketForParticipant。
设备 A 发送“Hello”。
设备 B 调用 getRealTimeSocketForParticipant。
设备 B 什么也没有收到。
设备 A 发送“世界”。
设备 B 接收“世界”。

我已经修改了一个示例项目（ButtonClicker）并在此处复制了该问题。我修改了代码以使用实时套接字，并将 startGame 方法修改为：

String mReceivedData = "";
byte mNextByteToSend = 0;

void startGame(boolean multiplayer)
{
    mMultiplayer = multiplayer;
    updateScoreDisplay();
    switchToScreen(R.id.screen_game);

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

    GamesClient client = getGamesClient();

    String myid = mActiveRoom.getParticipantId(client.getCurrentPlayerId());
    ArrayList<String> ids = mActiveRoom.getParticipantIds();
    String remoteId = null;
    for(int i=0; i<ids.size(); i++)
    {
        String test = ids.get(i);
        if( !test.equals(myid) )
        {
            remoteId = test;
            break;
        }
    }

    //One of devices should sleep in 5 seconds before start
    if( myid.compareTo(remoteId) > 0 )
    {
        try
        {
            //The device that sleeps will loose the first bytes.
            Log.d(TAG, "Sleeping in 5 seconds...");
            Thread.sleep(5*1000);
        }
        catch(Exception e)
        {

        }
    }
    else
    {
        Log.d(TAG, "No sleep, getting socket now.");
    }

    try
    {
        final RealTimeSocket rts = client.getRealTimeSocketForParticipant(mRoomId, remoteId);
        final InputStream inStream = rts.getInputStream();
        final OutputStream outStream = rts.getOutputStream();

        final TextView textView =((TextView) findViewById(R.id.score0));
        //Thread.sleep(5*1000); Having a sleep here instead minimizes the risk to get the problem.

        final Handler h = new Handler();
        h.postDelayed(new Runnable()
        {
            @Override
            public void run()
            {
                try
                {
                    int byteToRead = inStream.available();

                    for(int i=0; i<byteToRead; i++)
                    {
                        mReceivedData += " " + inStream.read(); 
                    }

                    if( byteToRead > 0 )
                    {
                        Log.d(TAG, "Received data: " + mReceivedData);
                        textView.setText(mReceivedData);
                    }

                    Log.d(TAG, "Sending: " + mNextByteToSend);
                    outStream.write(mNextByteToSend);
                    mNextByteToSend++;

                    h.postDelayed(this, 1000);
                }
                catch(Exception e)
                {

                }
            }
        }, 1000);
    }
    catch(Exception e)
    {
        Log.e(TAG, "Some error: " + e.getMessage(), e);
    }
}

该代码确保两个设备之一在调用 getRealTimeSocketForParticipant 之前休眠 5 秒。对于不休眠的设备，输出将类似于：

不睡觉，现在正在获取插座。
发送：0
发送：1
发送：2
发送：3
发送：4
接收数据：0
发送：5
接收数据：0 1
发送：6
接收数据：0 1 2

这是预期的，没有数据丢失。但是对于其他设备，我得到了这个：

睡5秒...
接收数据：4
发送：0
接收数据：4 5
发送：1
接收数据：4 5 6
发送：2
接收数据：4 5 6 7
发送：3

第一个字节丢失。有没有办法避免这种情况？

4

1 回答 1

2

如果我正确理解 API，通过实时套接字交换的消息是不真实的，所以你不能总是保证所有玩家都收到了你发送的所有消息。我找不到有关 使用的网络协议的信息RealTimeSocket，但我怀疑它是 UDP。

如果真是这样，恐怕除了自己实施某种握手之外，您无能为力。选择一个设备（例如：具有最低 ID 的设备）作为“同步器”，并让它与其他所有设备创建一个集合。每秒发送一条消息（“SYN”），例如“你在哪里？xy z”（当然不是字面意思），直到其他人回复“我在这里！（y）”（“ACK”）。从集合中删除发送响应的设备，直到集合为空。此时，给大家发一句“游戏开始！” 继续。

请注意，这些消息中的任何一个都可能丢失：如果“ACK”丢失，则下次发送“SYN”时，设备应再次应答。如果“游戏开始”消息丢失，运气不好，设备将一直等待，直到收到不同的消息，此时它应该认为自己可以开始（尽管延迟）。

最后一点：即使底层协议是 TCP，它仍然不是 100% 可靠的，没有协议是。如果您还不知道这个事实，请参阅此问题以获取更多信息。

于 2013-06-16T18:47:31.097 回答