Esempio n. 1
0
 @Override
 public void run() {
   Log.i(LOGTAG, "ConnectTask.run()...");
   XmppManager xmppManager = getXmppManager();
   if (!xmppManager.isConnected()) {
     ConnectionConfiguration connCfg =
         new ConnectionConfiguration(xmppManager.getXmppHost(), xmppManager.getXmppPort());
     connCfg.setSecurityMode(SecurityMode.required);
     connCfg.setSASLAuthenticationEnabled(false);
     connCfg.setCompressionEnabled(false);
     XMPPConnection connection = new XMPPConnection(connCfg);
     xmppManager.setConnection(connection);
     try {
       connection.connect();
       ProviderManager.getInstance()
           .addIQProvider(
               "notification", Constants.NOTIFICATION_NAMESPACE, new NotificationIQProvider());
       Log.i(LOGTAG, "XMPP connected successfully");
       xmppManager.getContext().sendBroadcast(new Intent(Constants.ACTION_CONNECT_SUCCESS));
     } catch (XMPPException e) {
       Log.e(LOGTAG, "XMPP connection failed", e);
       xmppManager.getContext().sendBroadcast(new Intent(Constants.ACTION_CONNECT_FAIL));
     }
     xmppManager.runTask();
   } else {
     Log.i(LOGTAG, "XMPP connected already");
     xmppManager.runTask();
   }
 }
Esempio n. 2
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);
  }
Esempio n. 3
0
  public void prepareSession(String domain) {
    System.out.printf("Initializing connection to server %1$s:%2$d\n", domain, port);
    SmackConfiguration.setPacketReplyTimeout(PACKET_REPLY_TIMEOUT);

    config = new ConnectionConfiguration(domain, port);
    config.setSASLAuthenticationEnabled(true);
    config.setSecurityMode(SecurityMode.disabled);
  }
  /** Called when the activity is first created. */
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    final EditText et = (EditText) findViewById(R.id.editText1);

    final TextView tv = (TextView) findViewById(R.id.textView1);

    tv.setMovementMethod(new ScrollingMovementMethod());

    Button startButton = (Button) findViewById(R.id.button1);
    startButton.setOnClickListener(
        new OnClickListener() {

          public void onClick(View v) {

            tv.append("ME: " + et.getText().toString() + "\n");

            Message msg = new Message();
            // msg.setTo("*****@*****.**");
            // msg.setTo("*****@*****.**");
            msg.setTo("*****@*****.**");
            msg.setBody(et.getText().toString());

            ((XMPPConnection) connection).sendPacket(msg);
          }
        });

    try {
      // ConnectionConfiguration config = new ConnectionConfiguration("chat.facebook.com", 5222);
      // ConnectionConfiguration config = new ConnectionConfiguration("chatme.im", 5222);
      ConnectionConfiguration config = new ConnectionConfiguration("ppl.eln.uniroma2.it", 5222);
      config.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled);
      connection = (Connection) new XMPPConnection(config);
      ((XMPPConnection) connection).connect();
      // ((org.jivesoftware.smack.Connection) connection).login("mattiapan","totti10");
      // ((org.jivesoftware.smack.Connection) connection).login("admin5551","admin5551");
      ((org.jivesoftware.smack.Connection) connection).login("panattoni", "mattia");
    } catch (XMPPException e) {
      // Log.e("paolo", "try catch error connection");
      e.printStackTrace();
    }

    ((org.jivesoftware.smack.Connection) connection)
        .addPacketListener(
            new PacketListener() {
              @Override
              public void processPacket(Packet pkt) {
                Message msg = (Message) pkt;
                String from = msg.getFrom();
                String body = msg.getBody();
                tv.append(from + " : " + body + "\n");
              }
            },
            new MessageTypeFilter(Message.Type.normal));
  }
  /**
   * Represents a single connection to a League of Legends chatserver.
   *
   * @param server The chatserver of the region you want to connect to
   * @param friendRequestPolicy Determines how new Friend requests are treated.
   * @param riotApiKey Your apiKey used to convert summonerId's to name. You can get your key here
   *     <a href="https://developer.riotgames.com/">developer .riotgames.com</a>
   * @see LolChat#setFriendRequestPolicy(FriendRequestPolicy)
   * @see LolChat#setFriendRequestListener(FriendRequestListener)
   */
  public LolChat(
      ChatServer server, FriendRequestPolicy friendRequestPolicy, RiotApiKey riotApiKey) {
    this.friendRequestPolicy = friendRequestPolicy;
    this.server = server;
    if (riotApiKey != null && server.api != null) {
      this.riotApi = RiotApi.build(riotApiKey, server);
    }
    Roster.setDefaultSubscriptionMode(SubscriptionMode.manual);
    final ConnectionConfiguration config =
        new ConnectionConfiguration(server.host, 5223, "pvp.net");
    config.setSecurityMode(ConnectionConfiguration.SecurityMode.enabled);
    config.setSocketFactory(SSLSocketFactory.getDefault());
    config.setCompressionEnabled(true);
    connection = new XMPPTCPConnection(config);

    addListeners();
  }
  public void onClick(View v) {
    host = getText(R.id.host);
    port = getText(R.id.port);
    service = getText(R.id.service);
    username = getText(R.id.userid);
    password = getText(R.id.password);
    // Log.i("FYI", host+port+service+username+password);
    // Create connection

    connectionConfig = new ConnectionConfiguration(host, Integer.parseInt(port), service);

    connectionConfig.setSecurityMode(
        ConnectionConfiguration.SecurityMode.enabled); // -\__ Required for OpenFire login
    connectionConfig.setSocketFactory(new DummySSLSocketFactory()); // _/

    // connectionConfig.setSASLAuthenticationEnabled(false); // required for talk.google.com
    // connectionConfig.setTruststoreType("BKS");            // required for talk.google.com
    connection = new XMPPConnection(connectionConfig);
    new ConnectToXmpp().execute();
  }
    @Override
    public void run() {
      if (!xmppManager.isConnected() && !xmppManager.isRunning()) {
        try {
          xmppManager.setRunning(true);
          // Create the configuration for this new connection
          ConnectionConfiguration connConfig =
              new ConnectionConfiguration(xmppManager.getXmppHost(), xmppManager.getXmppPort());
          connConfig.setSecurityMode(SecurityMode.disabled);
          // connConfig.setSecurityMode(SecurityMode.required);
          connConfig.setSASLAuthenticationEnabled(false);
          connConfig.setCompressionEnabled(false);

          XMPPConnection connection = new XMPPConnection(connConfig);
          xmppManager.setConnection(connection);
          // Connect to the server
          connection.connect();
          // packet provider
          connection.addConnectionListener(xmppManager.getConnectionListener());

          ProviderManager.getInstance()
              .addIQProvider(
                  "notification",
                  "androidpn:iq:notification",
                  xmppManager.getNotificationIQProvider());
          Log.i(LOG_TAG, "XMPP connected successfully");
          callback.onSuccess();
        } catch (Exception e) {
          Log.e(LOG_TAG, "XMPP connection failed", e);
          callback.onFailed("XMPP connection failed");
        } finally {
          xmppManager.setRunning(false);
        }
      } else {
        Log.w(LOG_TAG, "XMPP is connected or is running");
        callback.onFailed("XMPP is connected or is running");
      }
    }
  /** Constructor for XMPPNotificationManager. */
  protected XMPPNotificationManager() {

    Map<String, String> mdc = Logging.getCopyOfContextMap();
    try {
      mdc.put(Logging.PREFIX_KEY, LOG4J_CATEGORY);

      // Load up some properties

      File config = null;
      try {
        config = ConfigFileConstants.getFile(ConfigFileConstants.XMPP_CONFIG_FILE_NAME);
      } catch (IOException e) {
        LOG.warn("{} not readable", ConfigFileConstants.XMPP_CONFIG_FILE_NAME, e);
      }
      if (Boolean.getBoolean("useSystemXMPPConfig") || !config.canRead()) {
        this.props.putAll(System.getProperties());
      } else {
        FileInputStream fis = null;
        try {
          fis = new FileInputStream(config);
          this.props.load(fis);
        } catch (FileNotFoundException e) {
          LOG.warn("unable to load {}", config, e);
        } catch (IOException e) {
          LOG.warn("unable to load {}", config, e);
        } finally {
          IOUtils.closeQuietly(fis);
        }
      }

      xmppServer = this.props.getProperty("xmpp.server");
      String xmppServiceName = this.props.getProperty("xmpp.servicename", xmppServer);
      xmppUser = this.props.getProperty("xmpp.user");
      xmppPassword = this.props.getProperty("xmpp.pass");
      xmppPort = Integer.valueOf(this.props.getProperty("xmpp.port", XMPP_PORT));

      ConnectionConfiguration xmppConfig =
          new ConnectionConfiguration(xmppServer, xmppPort, xmppServiceName);

      boolean debuggerEnabled = Boolean.parseBoolean(props.getProperty("xmpp.debuggerEnabled"));
      xmppConfig.setDebuggerEnabled(debuggerEnabled);

      xmppConfig.setSASLAuthenticationEnabled(
          Boolean.parseBoolean(props.getProperty("xmpp.SASLEnabled", "true")));
      xmppConfig.setSelfSignedCertificateEnabled(
          Boolean.parseBoolean(props.getProperty("xmpp.selfSignedCertificateEnabled")));

      if (Boolean.parseBoolean(props.getProperty("xmpp.TLSEnabled"))) {
        xmppConfig.setSecurityMode(SecurityMode.enabled);
      } else {
        xmppConfig.setSecurityMode(SecurityMode.disabled);
      }
      if (this.props.containsKey("xmpp.truststorePassword")) {
        xmppConfig.setTruststorePassword(this.props.getProperty("xmpp.truststorePassword"));
      } else {
        xmppConfig.setTruststorePassword(TRUST_STORE_PASSWORD);
      }

      LOG.debug("XMPP Manager connection config: {}", xmppConfig.toString());

      xmpp = new XMPPConnection(xmppConfig);

      // Connect to xmpp server
      connectToServer();
    } finally {
      Logging.setContextMap(mdc);
    }
  }
  /**
   * 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);
  }
Esempio n. 10
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);
  }
  /** Constructor for XMPPNotificationManager. */
  protected XMPPNotificationManager() {

    // get the category logger
    String oldPrefix = ThreadCategory.getPrefix();
    ThreadCategory.setPrefix(LOG4J_CATEGORY);

    try {
      // Load up some properties

      File config = null;
      try {
        config = ConfigFileConstants.getFile(ConfigFileConstants.XMPP_CONFIG_FILE_NAME);
      } catch (IOException e) {
        log().warn(ConfigFileConstants.XMPP_CONFIG_FILE_NAME + " not readable", e);
      }
      if (Boolean.getBoolean("useSystemXMPPConfig") || !config.canRead()) {
        this.props.putAll(System.getProperties());
      } else {
        FileInputStream fis = null;
        try {
          fis = new FileInputStream(config);
          this.props.load(fis);
        } catch (FileNotFoundException e) {
          log().warn("unable to load " + config, e);
        } catch (IOException e) {
          log().warn("unable to load " + config, e);
        } finally {
          IOUtils.closeQuietly(fis);
        }
      }

      xmppServer = this.props.getProperty("xmpp.server");
      xmppServiceName = this.props.getProperty("xmpp.servicename", xmppServer);
      xmppUser = this.props.getProperty("xmpp.user");
      xmppPassword = this.props.getProperty("xmpp.pass");
      xmppPort = Integer.valueOf(this.props.getProperty("xmpp.port", XMPP_PORT));

      xmppConfig = new ConnectionConfiguration(xmppServer, xmppPort, xmppServiceName);

      boolean debuggerEnabled = Boolean.parseBoolean(props.getProperty("xmpp.debuggerEnabled"));
      xmppConfig.setDebuggerEnabled(debuggerEnabled);
      if (debuggerEnabled) {
        log().setLevel(ThreadCategory.Level.DEBUG);
      }

      xmppConfig.setSASLAuthenticationEnabled(
          Boolean.parseBoolean(props.getProperty("xmpp.SASLEnabled", "true")));
      xmppConfig.setSelfSignedCertificateEnabled(
          Boolean.parseBoolean(props.getProperty("xmpp.selfSignedCertificateEnabled")));

      if (Boolean.parseBoolean(props.getProperty("xmpp.TLSEnabled"))) {
        xmppConfig.setSecurityMode(SecurityMode.enabled);
      } else {
        xmppConfig.setSecurityMode(SecurityMode.disabled);
      }
      if (this.props.containsKey("xmpp.truststorePassword")) {
        xmppConfig.setTruststorePassword(this.props.getProperty("xmpp.truststorePassword"));
      } else {
        xmppConfig.setTruststorePassword(TRUST_STORE_PASSWORD);
      }

      if (log().isDebugEnabled()) {
        log().debug("XMPP Manager connection config: " + xmppConfig.toString());
      }

      xmpp = new XMPPConnection(xmppConfig);

      // Connect to xmpp server
      connectToServer();
    } finally {
      ThreadCategory.setPrefix(oldPrefix);
    }
  }