Exemplo n.º 1
0
  @SuppressLint("TrulyRandom")
  private XMPPConnection createConnection() {
    ConnectionConfiguration config =
        new ConnectionConfiguration(PreferenceUtils.getServerHost(context), PORT);

    SSLContext sc = null;
    MemorizingTrustManager mtm = null;
    try {
      mtm = new MemorizingTrustManager(context);
      sc = SSLContext.getInstance("TLS");
      sc.init(null, new X509TrustManager[] {mtm}, new SecureRandom());
    } catch (NoSuchAlgorithmException e) {
      throw new IllegalStateException(e);
    } catch (KeyManagementException e) {
      throw new IllegalStateException(e);
    }

    config.setCustomSSLContext(sc);
    config.setHostnameVerifier(
        mtm.wrapHostnameVerifier(new org.apache.http.conn.ssl.StrictHostnameVerifier()));
    config.setSecurityMode(SecurityMode.required);
    config.setReconnectionAllowed(false);
    config.setSendPresence(false);

    return new XMPPTCPConnection(config);
  }
Exemplo n.º 2
0
  // this code runs a DNS resolver, might be blocking
  private synchronized void initXMPPConnection() {
    // allow custom server / custom port to override SRV record
    if (mConfig.customServer.length() > 0)
      mXMPPConfig = new ConnectionConfiguration(mConfig.customServer, mConfig.port, mConfig.server);
    else mXMPPConfig = new ConnectionConfiguration(mConfig.server); // use SRV
    mXMPPConfig.setReconnectionAllowed(false);
    mXMPPConfig.setSendPresence(false);
    mXMPPConfig.setCompressionEnabled(false); // disable for now
    mXMPPConfig.setDebuggerEnabled(mConfig.smackdebug);
    if (mConfig.require_ssl)
      this.mXMPPConfig.setSecurityMode(ConnectionConfiguration.SecurityMode.required);

    // register MemorizingTrustManager for HTTPS
    try {
      SSLContext sc = SSLContext.getInstance("TLS");
      sc.init(
          null,
          new X509TrustManager[] {YaximApplication.getApp(mService).mMTM},
          new java.security.SecureRandom());
      this.mXMPPConfig.setCustomSSLContext(sc);
    } catch (java.security.GeneralSecurityException e) {
      debugLog("initialize MemorizingTrustManager: " + e);
    }

    this.mXMPPConnection = new XmppStreamHandler.ExtXMPPConnection(mXMPPConfig);
    this.mStreamHandler = new XmppStreamHandler(mXMPPConnection, mConfig.smackdebug);
    mStreamHandler.addAckReceivedListener(
        new XmppStreamHandler.AckReceivedListener() {
          public void ackReceived(long handled, long total) {
            gotServerPong("" + handled);
          }
        });
    mConfig.reconnect_required = false;

    initServiceDiscovery();
  }
Exemplo n.º 3
0
  // this code runs a DNS resolver, might be blocking
  private synchronized void initXMPPConnection() {
    // allow custom server / custom port to override SRV record
    if (configuration.customServer.length() > 0)
      connectionConfiguration =
          new ConnectionConfiguration(
              configuration.customServer, configuration.port, configuration.server);
    else connectionConfiguration = new ConnectionConfiguration(configuration.server); // use SRV
    connectionConfiguration.setReconnectionAllowed(false);
    connectionConfiguration.setSendPresence(false);
    connectionConfiguration.setCompressionEnabled(false); // disable for now
    connectionConfiguration.setDebuggerEnabled(configuration.smackdebug);
    if (configuration.require_ssl)
      this.connectionConfiguration.setSecurityMode(ConnectionConfiguration.SecurityMode.required);
    try {
      SSLContext sc = SSLContext.getInstance(Constant.TLS);
      MemorizingTrustManager mtm = JApplication.getApp(service).memorizingTrustManager;
      sc.init(null, new X509TrustManager[] {mtm}, new java.security.SecureRandom());
      this.connectionConfiguration.setCustomSSLContext(sc);
      this.connectionConfiguration.setHostnameVerifier(
          mtm.wrapHostnameVerifier(new org.apache.http.conn.ssl.StrictHostnameVerifier()));
    } catch (java.security.GeneralSecurityException e) {
      Log.d(TAG, "initialize MemorizingTrustManager: " + e);
    }

    this.extXMPPConnection = new StreamHandler.ExtXMPPConnection(connectionConfiguration);
    this.streamHandler = new StreamHandler(extXMPPConnection, configuration.smackdebug);
    streamHandler.addAckReceivedListener(
        new StreamHandler.AckReceivedListener() {
          public void ackReceived(long handled, long total) {
            gotServerPong("" + handled);
          }
        });
    configuration.reconnect_required = false;

    initServiceDiscovery();
  }
Exemplo n.º 4
0
  /**
   * Connects to GCM Cloud Connection Server using the supplied credentials.
   *
   * @throws XMPPException
   */
  public void connect() throws XMPPException {
    config = new ConnectionConfiguration(Properties.GCM_SERVER, Properties.GCM_PORT);
    config.setSecurityMode(SecurityMode.enabled);
    config.setReconnectionAllowed(true);
    config.setRosterLoadedAtLogin(false);
    config.setSendPresence(false);
    config.setSocketFactory(SSLSocketFactory.getDefault());

    // NOTE: Set to true to launch a window with information about packets sent and received
    config.setDebuggerEnabled(false);

    // -Dsmack.debugEnabled=true
    XMPPConnection.DEBUG_ENABLED = 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 %d secs", seconds);
          }

          public void connectionClosedOnError(Exception e) {
            logger.log(Level.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(Properties.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(Properties.userName, Properties.password);
  }
Exemplo n.º 5
0
  /**
   * Connects to GCM Cloud Connection Server using the supplied credentials.
   *
   * @param senderId Your GCM project number
   * @param apiKey API Key of your project
   */
  public void connect(long senderId, String apiKey)
      throws XMPPException, IOException, SmackException {
    ConnectionConfiguration config = new ConnectionConfiguration(GCM_SERVER, GCM_PORT);
    config.setSecurityMode(SecurityMode.enabled);
    config.setReconnectionAllowed(true);
    config.setRosterLoadedAtLogin(false);
    config.setSendPresence(false);
    config.setSocketFactory(SSLSocketFactory.getDefault());

    connection = new XMPPTCPConnection(config);
    connection.connect();

    connection.addConnectionListener(new LoggingConnectionListener());

    // Handle incoming packets
    connection.addPacketListener(
        new PacketListener() {

          @Override
          public void processPacket(Packet packet) {
            logger.log(Level.INFO, "Received: " + packet.toXML());
            Message incomingMessage = (Message) packet;
            GcmPacketExtension gcmPacket =
                (GcmPacketExtension) incomingMessage.getExtension(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
                handleUpstreamMessage(jsonObject);

                // Send ACK to CCS
                String messageId = (String) jsonObject.get("message_id");
                String from = (String) jsonObject.get("from");
                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 if ("control".equals(messageType.toString())) {
                // Process control message
                handleControlMessage(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, "Failed to process packet", e);
            }
          }
        },
        new PacketTypeFilter(Message.class));

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

    connection.login(senderId + "@gcm.googleapis.com", apiKey);
  }