我已经为 Android 应用程序和 Web 服务器之间的双向消息实现了新的 GCM CCS。下游消息(网络设备)完美运行。不幸的是，服务器上没有收到上游消息(设备网络)。它们似乎是在客户端发送的(请参阅下面的 Android 应用程序日志消息)，但服务器没有收到任何内容。

D/GCM﹕ GcmService start Intent { act=com.google.android.gcm.intent.SEND flg=0x10 pkg=com.google.android.gms cmp=com.google.android.gms/.gcm.GcmService (has extras) } com.google.android.gcm.intent.SEND

我认为 Android 端没有问题，但服务器端没有问题。问题是，我无法找出问题所在，因为连接仍然存在，而且我确实从 GCM 服务器收到了一些消息，比如 ACK。那么为什么没有收到正常的消息呢？有人知道吗？

其他一些值得一提的细节是所使用的 Web 服务器是 Glassfish 并且我在 Servlet 中启动了 XMPP 连接。下面是一些片段。

编辑:正如我在回答中所述，阻止任何服务器接收消息的主要问题已经解决。但是，仍然有相当多的消息没有收到(大约 50%)。

例如，每当用户在 Android 应用程序中进行更改时(按下按钮，因此每批 2 条消息之间至少有几秒钟的时间)，我会在后台线程上一个接一个地立即发送 2 条消息.有时我在服务器上收到两条消息，有时我只收到其中一条，有时甚至什么都没有发生……这是一个严重的问题，特别是对于核心依赖该技术的应用程序。任何人都可以提供进一步的帮助来解决这个问题吗？

更多信息:我很确定这与客户端不相关，因为每条消息都在发送，就像您在上面的 logcat 日志中看到的那样，我也收到了“事件:已发送”GCM 会在一段时间后广播(虽然不是立即，可能是 5 分钟)。所以它必须是基于 GCM 或基于服务器的东西。

public class CcsServlet extends HttpServlet
{
    private static Logger logger = Logger.getLogger(CcsServlet.class.getName());


    public void init(ServletConfig config) throws ServletException
    {
        CcsManager ccsManager = CcsManager.getInstance();
        try
        {
            ccsManager.connect();
        }
        catch (Exception e)
        {
            logger.warning("Cannot connect to CCS server.");
            e.printStackTrace();
        }
    }
}


public class CcsManager
{
    private static XMPPConnection connection;
    private static Logger logger = Logger.getLogger(CcsManager.class.getName());


    public static final String GCM_SERVER = "gcm.googleapis.com";
    public static final int GCM_PORT = 5235;

    private static CcsManager sInstance = null;
    private static final String USERNAME = "xxxxxxxxxx" + "@gcm.googleapis.com";
    private static final String PASSWORD = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";




        public CcsManager()
        {
            // Add GcmPacketExtension
            ProviderManager.getInstance().addExtensionProvider(
                    GcmPacketExtension.GCM_ELEMENT_NAME,
                    GcmPacketExtension.GCM_NAMESPACE, new PacketExtensionProvider()
                    {
                        public PacketExtension parseExtension(XmlPullParser parser) throws Exception
                        {
                            String json = parser.nextText();
                            return new GcmPacketExtension(json);
                        }
                    });
        }

        public static CcsManager getInstance()
        {
            if (sInstance == null)
                sInstance = new CcsManager();
            return sInstance;
        }

/**
 * Connects to GCM Cloud Connection Server
 */
public void connect() throws IOException, XMPPException
{
    ConnectionConfiguration config = new ConnectionConfiguration(GCM_SERVER, GCM_PORT);
    config.setSecurityMode(ConnectionConfiguration.SecurityMode.enabled);
    config.setReconnectionAllowed(true);
    config.setRosterLoadedAtLogin(false);
    config.setSendPresence(false);
    config.setSocketFactory(SSLSocketFactory.getDefault());
    config.setDebuggerEnabled(false);
    connection = new XMPPConnection(config);
    connection.connect();
    connection.addConnectionListener(new ConnectionListener()
    {
        public void reconnectionSuccessful()
        {
            logger.info("Reconnecting..");
        }

        public void reconnectionFailed(Exception e)
        {
            logger.log(Level.INFO, "Reconnection failed.. ", e);
        }

        public void reconnectingIn(int seconds)
        {
            logger.log(Level.INFO, "Reconnecting in %s secs", seconds);
        }

        public void connectionClosedOnError(Exception e)
        {
            logger.info("Connection closed on error.");
        }

        public void connectionClosed()
        {
            logger.info("Connection closed.");
        }
    });

    // Handle incoming packets
    connection.addPacketListener(new PacketListener()
    {
        public void processPacket(Packet packet)
        {
            logger.log(Level.INFO, "Received: " + packet.toXML());
            Message incomingMessage = (Message) packet;
            GcmPacketExtension gcmPacket =
                    (GcmPacketExtension) incomingMessage.getExtension(GcmPacketExtension.GCM_NAMESPACE);
            String json = gcmPacket.getJson();
            try
            {
                @SuppressWarnings("unchecked")
                Map<String, Object> jsonObject =
                        (Map<String, Object>) JSONValue.parseWithException(json);

                // present for "ack"/"nack", null otherwise
                Object messageType = jsonObject.get("message_type");

                if (messageType == null)
                {
                    // Normal upstream data message
                    handleIncomingDataMessage(jsonObject);

                    // Send ACK to CCS
                    String messageId = jsonObject.get("message_id").toString();
                    String from = jsonObject.get("from").toString();
                    String ack = createJsonAck(from, messageId);
                    send(ack);
                }
                else if ("ack".equals(messageType.toString()))
                {
                    // Process Ack
                    handleAckReceipt(jsonObject);
                }
                else if ("nack".equals(messageType.toString()))
                {
                    // Process Nack
                    handleNackReceipt(jsonObject);
                }
                else
                {
                    logger.log(Level.WARNING, "Unrecognized message type (%s)",
                            messageType.toString());
                }
            }
            catch (ParseException e)
            {
                logger.log(Level.SEVERE, "Error parsing JSON " + json, e);
            }
            catch (Exception e)
            {
                logger.log(Level.SEVERE, "Couldn't send echo.", e);
            }
        }
    }, new PacketTypeFilter(Message.class));


    // Log all outgoing packets
    connection.addPacketInterceptor(new PacketInterceptor()
    {
        public void interceptPacket(Packet packet)
        {
            logger.log(Level.INFO, "Sent: {0}",  packet.toXML());
        }
    }, new PacketTypeFilter(Message.class));

    connection.login(USERNAME, PASSWORD);
}
    }

最佳答案

Web 应用程序似乎在服务器上部署了两次。这导致创建 XMPP 连接的 servlet 被初始化一次，然后销毁，然后再次初始化。这个序列对于连接到 GCM (dho..) 可能不是一件好事。

只需确保 servlet 只初始化一次。通过在其 init() 和 destroy() 方法中使用记录器来检查这一点。如果确实调用了不止一次，尝试将web模块分配给特定的虚拟服务器进行部署。我相信这因 Web 服务器而异。对于 Glassfish，您需要在管理控制台 (localhost:4848) 中执行此操作。

这解决了更大的问题。我遇到的另一个问题是上游消息传递根本不可靠。有时来自同一设备的多个连续上行消息完美无缺地工作，只是为了尝试另一个根本没有推送到服务器的消息。还没有找到解决这个问题的任何模式...如果我发现其他问题，我会回来的。

编辑:显然在本地服务器上使用该实现时出现问题。移至远程服务器(暂存 VPS)，问题似乎消失了。服务器接收每条消息。如果问题仍然存在，我会回来，但我对此表示怀疑。我认为本地问题是由于我的 ISP，或者甚至是我的本地 Wi-Fi 连接造成的。对于究竟是什么原因造成的，我没有一个完整的答案，但至少它在登台服务器上运行得很好。

关于java - GCM CCS 服务器实现未接收上游消息，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/23366588/