@Override
 public void connected(XMPPConnection connection) {
   LOG.info("Jabber connected");
   if (mySubscribeListener == null) {
     mySubscribeListener = new MySubscribeListener();
     connection.addPacketListener(mySubscribeListener, new PacketTypeFilter(Presence.class));
   }
   if (myMessageListener == null) {
     myMessageListener = new MyMessageListener();
     connection.addPacketListener(myMessageListener, new PacketTypeFilter(Message.class));
   }
 }
  @Override
  public boolean login() throws RemoteException {
    if (mAdaptee.isAuthenticated()) return true;
    if (!mAdaptee.isConnected()) return false;
    try {

      this.initFeatures(); // pour declarer les features xmpp qu'on
      // supporte

      PacketFilter filter =
          new PacketFilter() {

            @Override
            public boolean accept(Packet packet) {
              if (packet instanceof Presence) {
                Presence pres = (Presence) packet;
                if (pres.getType() == Presence.Type.subscribe) return true;
              }
              return false;
            }
          };

      mAdaptee.addPacketListener(mSubscribePacketListener, filter);

      filter = new PacketTypeFilter(PingExtension.class);
      mAdaptee.addPacketListener(mPingListener, filter);

      mAdaptee.login(mLogin, mPassword, mResource);
      mUserInfo = new UserInfo(mAdaptee.getUser());

      mChatManager = new BeemChatManager(mAdaptee.getChatManager(), mService, mAdaptee.getRoster());
      // nikita: I commented this line because of the logs provided in
      // http://www.beem-project.com/issues/321
      // Also, since the privacylistmanager isn't finished and used, it will be safer to not
      // initialize it
      // mPrivacyListManager = new
      // PrivacyListManagerAdapter(PrivacyListManager.getInstanceFor(mAdaptee));
      mService.initJingle(mAdaptee);
      discoverServerFeatures();

      mRoster = new RosterAdapter(mAdaptee.getRoster(), mService, mAvatarManager);
      mApplication.setConnected(true);
      int mode = mPref.getInt(BeemApplication.STATUS_KEY, 0);
      String status = mPref.getString(BeemApplication.STATUS_TEXT_KEY, "");
      changeStatus(mode, status);
      return true;
    } catch (XMPPException e) {
      Log.e(TAG, "Error while connecting", e);
      mErrorMsg = mService.getString(R.string.error_login_authentication);
      return false;
    }
  }
Пример #3
0
 /**
  * Creates a file transfer manager to initiate and receive file transfers.
  *
  * @param connection The XMPPConnection that the file transfers will use.
  */
 private FileTransferManager(XMPPConnection connection) {
   super(connection);
   this.fileTransferNegotiator = FileTransferNegotiator.getInstanceFor(connection);
   connection.addPacketListener(
       new PacketListener() {
         public void processPacket(Packet packet) {
           StreamInitiation si = (StreamInitiation) packet;
           final FileTransferRequest request =
               new FileTransferRequest(FileTransferManager.this, si);
           for (final FileTransferListener listener : listeners) {
             // Those listeners need to be called asynchronously, in
             // order to not block further processing of incoming
             // stanzas. They also may send further requests, whose
             // responses are not processed if we do not call them
             // asynchronously.
             Async.go(
                 new Runnable() {
                   public void run() {
                     listener.fileTransferRequest(request);
                   }
                 });
           }
         }
       },
       new AndFilter(new PacketTypeFilter(StreamInitiation.class), IQTypeFilter.SET));
 }
Пример #4
0
 @Override
 public void run() {
   if (connection != null && connection.isConnected()) {
     disconnect = true;
     Ping ping = new Ping();
     ping.setFrom(ApplicationUtil.getXmppConnectionUserName(PreferencesUtil.getMyId()));
     try {
       connection.sendPacket(ping);
     } catch (Exception e) {
       clearTimer();
       // Application.getNotificationManager().startNotificationService();
     }
     connection.addPacketListener(
         new PacketListener() {
           public void processPacket(Packet packet) {
             disconnect = false;
           }
         },
         new IQTypeFilter(Type.RESULT));
     try {
       Thread.sleep(PERIOD);
     } catch (InterruptedException e) {
     }
     if (disconnect) {
       LaijiaoliuApp.getNotificationManager().startNotificationService();
       clearTimer();
     }
   }
 }
Пример #5
0
  /** Creates a destination for a service that receives XMPP messages. */
  public Destination getDestination(EndpointInfo endpointInfo) throws IOException {
    // The node name is the full name of the service.
    String nodeName = endpointInfo.getService().getName().toString();
    pepProvider.registerPEPParserExtension(nodeName, soapProvider);

    PEPDestination dest = new PEPDestination(endpointInfo);

    try {
      XMPPConnection conn = destinationConnectionFactory.login(endpointInfo);

      // Advertise interest in receiving information.
      ServiceDiscoveryManager disco = ServiceDiscoveryManager.getInstanceFor(conn);
      disco.addFeature(nodeName + "+notify");

      // Create destination.
      dest.setXmppConnection(conn);
      conn.addPacketListener(
          dest, new PacketExtensionFilter("event", "http://jabber.org/protocol/pubsub#event"));

    } catch (XMPPException e) {
      throw new IOException(e);
    }

    return dest;
  }
Пример #6
0
 /**
  * Register a listener for item publication events. This listener will get called whenever an item
  * is published to this node.
  *
  * @param listener The handler for the event
  */
 @SuppressWarnings("unchecked")
 public void addItemEventListener(@SuppressWarnings("rawtypes") ItemEventListener listener) {
   PacketListener conListener = new ItemEventTranslator(listener);
   itemEventToListenerMap.put(listener, conListener);
   con.addPacketListener(
       conListener, new EventContentFilter(EventElementType.items.toString(), "item"));
 }
Пример #7
0
  /**
   * Creates a last activity manager to response last activity requests.
   *
   * @param connection The XMPPConnection that the last activity requests will use.
   */
  private LastActivityManager(XMPPConnection connection) {
    this.connection = connection;

    // Listen to all the sent messages to reset the idle time on each one
    connection.addPacketWriterListener(
        new PacketListener() {
          public void processPacket(Packet packet) {
            resetIdleTime();
          }
        },
        null);

    // Register a listener for a last activity query
    connection.addPacketListener(
        new PacketListener() {

          public void processPacket(Packet packet) {
            LastActivity message = new LastActivity();
            message.setType(IQ.Type.RESULT);
            message.setTo(packet.getFrom());
            message.setFrom(packet.getTo());
            message.setPacketID(packet.getPacketID());
            message.setLastActivity(getIdleTime());

            LastActivityManager.this.connection.sendPacket(message);
          }
        },
        new AndFilter(new IQTypeFilter(IQ.Type.GET), new PacketTypeFilter(LastActivity.class)));
  }
 @Override
 public void run() {
   if (xmppManager.isConnected() && !xmppManager.isAuthenticated() && !xmppManager.isRunning()) {
     XMPPConnection connection = xmppManager.getConnection();
     try {
       xmppManager.setRunning(true);
       xmppManager
           .getConnection()
           .login(xmppManager.getUsername(), xmppManager.getPassword(), XMPP_RESOURCE_NAME);
       Log.d(LOG_TAG, "Loggedn in successfully");
       PacketFilter packetFilter = new PacketTypeFilter(NotificationIQ.class);
       // packet listener
       PacketListener packetListener = xmppManager.getNotificationPacketListener();
       connection.addPacketListener(packetListener, packetFilter);
       callback.onSuccess();
     } catch (Exception e) {
       Log.e(LOG_TAG, "LoginTask.call()... other error");
       Log.e(LOG_TAG, "Failed to login to xmpp server. Caused by: " + e.getMessage(), e);
       callback.onFailed("LoginTask.call()... other error");
     } finally {
       xmppManager.setRunning(false);
     }
   } else {
     Log.w(LOG_TAG, "XMPP is not connected or is running or is authenticated");
     callback.onFailed("XMPP is not connected or is running or is authenticated");
   }
 }
Пример #9
0
 /**
  * Called by Settings dialog when a connection is establised with the XMPP server
  *
  * @param connection
  */
 public void setConnection(XMPPConnection connection) {
   this.connection = connection;
   if (connection != null) {
     // Add a packet listener to get messages sent to us
     PacketFilter filter = new MessageTypeFilter(Message.Type.chat);
     connection.addPacketListener(
         new PacketListener() {
           public void processPacket(Packet packet) {
             Message message = (Message) packet;
             if (message.getBody() != null) {
               String fromName = StringUtils.parseBareAddress(message.getFrom());
               Log.i("XMPPClient", "Got text [" + message.getBody() + "] from [" + fromName + "]");
               messages.add(fromName + ":");
               messages.add(message.getBody());
               // Add the incoming message to the list view
               mHandler.post(
                   new Runnable() {
                     public void run() {
                       setListAdapter();
                     }
                   });
             }
           }
         },
         filter);
   }
 }
Пример #10
0
  /**
   * Register an listener for item delete events. This listener gets called whenever an item is
   * deleted from the node.
   *
   * @param listener The handler for the event
   */
  public void addItemDeleteListener(ItemDeleteListener listener) {
    PacketListener delListener = new ItemDeleteTranslator(listener);
    itemDeleteToListenerMap.put(listener, delListener);
    EventContentFilter deleteItem =
        new EventContentFilter(EventElementType.items.toString(), "retract");
    EventContentFilter purge = new EventContentFilter(EventElementType.purge.toString());

    con.addPacketListener(delListener, new OrFilter(deleteItem, purge));
  }
Пример #11
0
  /**
   * Registers this Manager's listener with <tt>connection</tt>.
   *
   * @param connection the connection that we'd like this manager to register with.
   */
  public void addPacketListener(XMPPConnection connection) {
    PacketFilter filter =
        new AndFilter(
            new PacketTypeFilter(Presence.class),
            new PacketExtensionFilter(
                CapsPacketExtension.ELEMENT_NAME, CapsPacketExtension.NAMESPACE));

    connection.addPacketListener(new CapsPacketListener(), filter);
  }
Пример #12
0
  @Override
  public void run() {
    Log.i(LOGTAG, "RegisterTask.run()...");
    final XmppManager xmppManager = getXmppManager();
    if (!xmppManager.isRegistered()) {
      String uuid = Util.getDeviceUUID(xmppManager.getContext());
      final String newUsername = uuid;
      final String newPassword = uuid;
      Registration registration = new Registration();
      PacketFilter packetFilter =
          new AndFilter(
              new PacketIDFilter(registration.getPacketID()), new PacketTypeFilter(IQ.class));
      PacketListener packetListener =
          new PacketListener() {
            public void processPacket(Packet packet) {
              Log.d("RegisterTask.PacketListener", "processPacket().....");
              Log.d("RegisterTask.PacketListener", "packet=" + packet.toXML());

              if (packet instanceof IQ) {
                IQ response = (IQ) packet;
                if (response.getType() == IQ.Type.ERROR) {
                  if (!response.getError().toString().contains("409")) {
                    Log.e(
                        LOGTAG,
                        "Unknown error while registering XMPP account! "
                            + response.getError().getCondition());
                  }
                } else if (response.getType() == IQ.Type.RESULT) {
                  xmppManager.setUsername(newUsername);
                  xmppManager.setPassword(newPassword);
                  Log.d(LOGTAG, "username="******"password="******"Account registered successfully");
                  xmppManager.runTask();
                }
              }
            }
          };
      XMPPConnection connection = xmppManager.getConnection();
      connection.addPacketListener(packetListener, packetFilter);
      registration.setType(IQ.Type.SET);
      registration.addAttribute("username", newUsername);
      registration.addAttribute("password", newPassword);
      connection.sendPacket(registration);
    } else {
      Log.i(LOGTAG, "Account registered already");
      xmppManager.runTask();
    }
  }
Пример #13
0
  private void onConnectionEstablished() {
    if (state != State.CONNECTED) {
      processOfflineMessages();

      try {
        con.sendPacket(new Presence(Presence.Type.available));
      } catch (NotConnectedException e) {
      }

      contactHelper = new SmackContactHelper(context, con);
      vCardHelper = new SmackVCardHelper(context, con);

      con.addPacketListener(messagePacketListener, new MessageTypeFilter(Message.Type.chat));
      con.addPacketListener(presencePacketListener, new PacketTypeFilter(Presence.class));
      con.addConnectionListener(createConnectionListener());

      setState(State.CONNECTED);
    }
  }
Пример #14
0
 /**
  * Register a listener for configuration events. This listener will get called whenever the node's
  * configuration changes.
  *
  * @param listener The handler for the event
  */
 public void addConfigurationListener(NodeConfigListener listener) {
   PacketListener conListener = new NodeConfigTranslator(listener);
   configEventToListenerMap.put(listener, conListener);
   con.addPacketListener(
       conListener, new EventContentFilter(EventElementType.configuration.toString()));
 }
Пример #15
0
  public void run() throws XMPPException, IOException, InterruptedException {
    logger.debug("Trying to connect to " + host + ":" + port);
    ConnectionConfiguration configuration = new ConnectionConfiguration(host, port, "gmail.com");
    final XMPPConnection connection = new XMPPConnection(configuration);
    connection.connect();
    logger.debug("...connected");
    SASLAuthentication.supportSASLMechanism("PLAIN", 0);
    logger.debug("Trying to log in with credentials " + login + ":" + password);
    connection.login(login, password, "MyXmppBot");
    logger.debug("...logged in");

    final Process process = Runtime.getRuntime().exec("/bin/bash");
    final InputStream inputStream = process.getInputStream();
    final OutputStream outputStream = process.getOutputStream();

    Thread inputThread =
        new Thread(
            new Runnable() {
              @Override
              public void run() {
                InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
                try {
                  while (true) {
                    String line = bufferedReader.readLine();
                    Message message = new Message(to);
                    message.setBody(line);
                    connection.sendPacket(message);
                  }
                } catch (IOException e) {
                  e.printStackTrace();
                }
              }
            });
    inputThread.start();

    final PrintWriter commandWriter = new PrintWriter(outputStream, true);
    PacketListener listener =
        new PacketListener() {
          @Override
          public void processPacket(Packet packet) {
            if (packet instanceof Message) {
              Message message = (Message) packet;
              to = message.getFrom();
              String command = message.getBody();
              if (command != null) {
                logger.debug("Command received:" + command);
                if (command.equalsIgnoreCase("exit")) {
                  process.destroy();
                  System.exit(0);
                } else {
                  commandWriter.println(command);
                }
              }
            }
          }
        };

    PacketFilter filter = new FromContainsFilter("carlos.prados");
    Thread.sleep(1000);
    connection.addPacketListener(listener, null);
  }
Пример #16
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);
  }
Пример #17
0
  /**
   * Creates a new ServiceDiscoveryManager for a given XMPPConnection. This means that the service
   * manager will respond to any service discovery request that the connection may receive.
   *
   * @param connection the connection to which a ServiceDiscoveryManager is going to be created.
   */
  private ServiceDiscoveryManager(XMPPConnection connection) {
    super(connection);

    addFeature(DiscoverInfo.NAMESPACE);
    addFeature(DiscoverItems.NAMESPACE);

    // Listen for disco#items requests and answer with an empty result
    PacketListener packetListener =
        new PacketListener() {
          public void processPacket(Packet packet) throws NotConnectedException {
            DiscoverItems discoverItems = (DiscoverItems) packet;
            DiscoverItems response = new DiscoverItems();
            response.setType(IQ.Type.result);
            response.setTo(discoverItems.getFrom());
            response.setPacketID(discoverItems.getPacketID());
            response.setNode(discoverItems.getNode());

            // Add the defined items related to the requested node. Look for
            // the NodeInformationProvider associated with the requested node.
            NodeInformationProvider nodeInformationProvider =
                getNodeInformationProvider(discoverItems.getNode());
            if (nodeInformationProvider != null) {
              // Specified node was found, add node items
              response.addItems(nodeInformationProvider.getNodeItems());
              // Add packet extensions
              response.addExtensions(nodeInformationProvider.getNodePacketExtensions());
            } else if (discoverItems.getNode() != null) {
              // Return <item-not-found/> error since client doesn't contain
              // the specified node
              response.setType(IQ.Type.error);
              response.setError(new XMPPError(XMPPError.Condition.item_not_found));
            }
            connection().sendPacket(response);
          }
        };
    connection.addPacketListener(packetListener, GET_DISCOVER_ITEMS);

    // Listen for disco#info requests and answer the client's supported features
    // To add a new feature as supported use the #addFeature message
    packetListener =
        new PacketListener() {
          public void processPacket(Packet packet) throws NotConnectedException {
            DiscoverInfo discoverInfo = (DiscoverInfo) packet;
            // Answer the client's supported features if the request is of the GET type
            DiscoverInfo response = new DiscoverInfo();
            response.setType(IQ.Type.result);
            response.setTo(discoverInfo.getFrom());
            response.setPacketID(discoverInfo.getPacketID());
            response.setNode(discoverInfo.getNode());
            // Add the client's identity and features only if "node" is null
            // and if the request was not send to a node. If Entity Caps are
            // enabled the client's identity and features are may also added
            // if the right node is chosen
            if (discoverInfo.getNode() == null) {
              addDiscoverInfoTo(response);
            } else {
              // Disco#info was sent to a node. Check if we have information of the
              // specified node
              NodeInformationProvider nodeInformationProvider =
                  getNodeInformationProvider(discoverInfo.getNode());
              if (nodeInformationProvider != null) {
                // Node was found. Add node features
                response.addFeatures(nodeInformationProvider.getNodeFeatures());
                // Add node identities
                response.addIdentities(nodeInformationProvider.getNodeIdentities());
                // Add packet extensions
                response.addExtensions(nodeInformationProvider.getNodePacketExtensions());
              } else {
                // Return <item-not-found/> error since specified node was not found
                response.setType(IQ.Type.error);
                response.setError(new XMPPError(XMPPError.Condition.item_not_found));
              }
            }
            connection().sendPacket(response);
          }
        };
    connection.addPacketListener(packetListener, GET_DISCOVER_INFO);
  }
Пример #18
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);
  }
  /**
   * Called by Settings dialog when a connection is establised with the XMPP server
   *
   * @param connection
   */
  public void setConnection(XMPPConnection connection) {
    Util.connection = connection;
    if (connection != null) {
      // Add a packet listener to get messages sent to us
      PacketFilter filter = new MessageTypeFilter(Message.Type.chat);
      connection.addPacketListener(
          new PacketListener() {
            @Override
            public void processPacket(Packet packet) {
              Message message = (Message) packet;
              if (message.getBody() != null) {
                String fromName = StringUtils.parseBareAddress(message.getFrom());
                DataBaseHandler datebasehandler = new DataBaseHandler(RegisterNormal.this);
                ConversationsModel checkConversations = new ConversationsModel();
                checkConversations = datebasehandler.checkConversationID(fromName);

                if (checkConversations == null) {

                  ConversationsModel conversions = new ConversationsModel();
                  conversions.setLast_message(message.getBody());
                  conversions.setEnd_time("endtime");
                  conversions.setLast_message_direction("in");
                  conversions.setLogin_user_display_name(fromName);
                  conversions.setLogin_user_id(Integer.parseInt(Util.USER_ID));
                  conversions.setLogin_user_jid(Util.CHAT_LOGIN_JID);
                  conversions.setLogin_user_resource("mobile");
                  conversions.setWith_user_display_name(fromName);
                  conversions.setWith_user_id(0);
                  conversions.setWith_user_jid(fromName);
                  conversions.setWith_user_profilepicurl("message.getFrom()");
                  conversions.setWith_user_resource("mobile");
                  conversions.setStart_time("starttime");
                  conversions.setMessage_iseen("no");
                  conversions.setMessage_isseen_count("1");
                  datebasehandler.insertConversions(conversions);
                  //
                  // getting the latest conversation id
                  checkConversations = datebasehandler.checkConversationID(fromName);
                  if (checkConversations == null) {

                  } else {
                    ConversationsMessagesModel messageModel = new ConversationsMessagesModel();
                    messageModel.setConvmessage_type("Chat");
                    messageModel.setConvmessage_direction("in");
                    messageModel.setConvmessage_time("time");
                    messageModel.setConvmessage_message(message.getBody());
                    messageModel.setConversation_id(checkConversations.getConversation_id());

                    if (isApplicationSentToBackground(context)) {
                      NotificationCompat.Builder mBuilder =
                          new NotificationCompat.Builder(RegisterNormal.this)
                              .setSmallIcon(R.drawable.ic_launcher)
                              .setContentTitle(checkConversations.getWith_user_display_name())
                              .setContentText(1 + " new messages");
                      // Creates an explicit intent for an Activity in your app
                      Intent resultIntent =
                          new Intent(RegisterNormal.this, ChatConversationsActivity.class);

                      resultIntent.putExtra(
                          "Conversation_Name", checkConversations.getWith_user_display_name());
                      resultIntent.putExtra(
                          "Conversations_Name_Image",
                          checkConversations.getWith_user_profilepicurl());
                      resultIntent.putExtra(
                          "Connversation_ID", checkConversations.getConversation_id());
                      resultIntent.putExtra(
                          "Connversation_JID", checkConversations.getWith_user_jid());

                      // The stack builder object will contain an artificial back stack for the
                      // started Activity.
                      // This ensures that navigating backward from the Activity leads out of
                      // your application to the Home screen.
                      TaskStackBuilder stackBuilder = TaskStackBuilder.create(RegisterNormal.this);
                      // Adds the back stack for the Intent (but not the Intent itself)
                      stackBuilder.addParentStack(SplashScreen.class);
                      // Adds the Intent that starts the Activity to the top of the stack
                      stackBuilder.addNextIntent(resultIntent);
                      PendingIntent resultPendingIntent =
                          stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
                      mBuilder.setContentIntent(resultPendingIntent);

                      mBuilder.setAutoCancel(true);
                      mBuilder.setSound(Settings.System.DEFAULT_NOTIFICATION_URI);
                      // Vibration
                      mBuilder.setVibrate(new long[] {1000, 1000, 1000, 1000, 1000});

                      // LED
                      mBuilder.setLights(Color.RED, 3000, 3000);

                      NotificationManager mNotificationManager =
                          (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
                      // mId allows you to update the notification later on.
                      mNotificationManager.notify(101, mBuilder.build());
                    }

                    try {
                      datebasehandler.insertConversionsMessages(messageModel);
                    } catch (Exception e) {
                    } finally {
                      datebasehandler.close();
                    }
                  }
                } else {
                  ConversationsMessagesModel messageModel = new ConversationsMessagesModel();
                  messageModel.setConvmessage_type("Chat");
                  messageModel.setConvmessage_direction("in");
                  messageModel.setConvmessage_time("time");
                  messageModel.setConvmessage_message(message.getBody());
                  messageModel.setConversation_id(checkConversations.getConversation_id());
                  try {

                    datebasehandler.insertConversionsMessages(messageModel);
                    int getCount = Integer.valueOf(checkConversations.getMessage_isseen_count());
                    getCount = getCount + 1;
                    datebasehandler.updateLastMessageinConversations(
                        String.valueOf(checkConversations.getConversation_id()),
                        message.getBody(),
                        "time",
                        "in",
                        "no",
                        Integer.toString(getCount));

                    int countformessage =
                        Integer.parseInt(checkConversations.getMessage_isseen_count()) + 1;

                    if (isApplicationSentToBackground(context)) {
                      NotificationCompat.Builder mBuilder =
                          new NotificationCompat.Builder(RegisterNormal.this)
                              .setSmallIcon(R.drawable.ic_launcher)
                              .setContentTitle(checkConversations.getWith_user_display_name())
                              .setContentText(countformessage + " new messages");
                      // Creates an explicit intent for an Activity in your app
                      Intent resultIntent =
                          new Intent(RegisterNormal.this, ChatConversationsActivity.class);

                      resultIntent.putExtra(
                          "Conversation_Name", checkConversations.getWith_user_display_name());
                      resultIntent.putExtra(
                          "Conversations_Name_Image",
                          checkConversations.getWith_user_profilepicurl());
                      resultIntent.putExtra(
                          "Connversation_ID", checkConversations.getConversation_id());
                      resultIntent.putExtra(
                          "Connversation_JID", checkConversations.getWith_user_jid());

                      // The stack builder object will contain an artificial back stack for the
                      // started Activity.
                      // This ensures that navigating backward from the Activity leads out of
                      // your application to the Home screen.
                      TaskStackBuilder stackBuilder = TaskStackBuilder.create(RegisterNormal.this);
                      // Adds the back stack for the Intent (but not the Intent itself)
                      stackBuilder.addParentStack(SplashScreen.class);
                      // Adds the Intent that starts the Activity to the top of the stack
                      stackBuilder.addNextIntent(resultIntent);
                      PendingIntent resultPendingIntent =
                          stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
                      mBuilder.setContentIntent(resultPendingIntent);

                      mBuilder.setAutoCancel(true);
                      mBuilder.setSound(Settings.System.DEFAULT_NOTIFICATION_URI);
                      // Vibration
                      mBuilder.setVibrate(new long[] {1000, 1000, 1000, 1000, 1000});

                      // LED
                      mBuilder.setLights(Color.RED, 3000, 3000);

                      NotificationManager mNotificationManager =
                          (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
                      // mId allows you to update the notification later on.
                      mNotificationManager.notify(101, mBuilder.build());
                    }

                  } catch (Exception e) {
                  } finally {
                    datebasehandler.close();
                  }
                }
                Util.IncomingChatMessage = true;
              }
            }
          },
          filter);
    }
  }
Пример #20
0
 /** 登陆XMPP服务器 */
 public boolean login() throws RemoteException {
   // 未建立XMPP连接
   if (!connection.isConnected()) {
     return false;
   }
   // 应经登陆过
   if (connection.isAuthenticated()) {
     return true;
   } else {
     // 开始登陆
     try {
       connection.login(account, password, imService.getString(R.string.app_name));
       if (messageListener == null) {
         messageListener = new MessageListener();
       }
       // 添加消息监听器
       connection.addPacketListener(messageListener, new PacketTypeFilter(Message.class));
       Roster roster = connection.getRoster();
       if (rosterListener == null) {
         rosterListener = new IMClientRosterListener();
       }
       // 添加花名册监听器
       roster.addRosterListener(rosterListener);
       // 获取花名册
       if (roster != null && roster.getEntries().size() > 0) {
         Uri uri = null;
         for (RosterEntry entry : roster.getEntries()) {
           // 获取联系人名片信息
           VCard vCard = new VCard();
           vCard.load(connection, entry.getUser());
           // 用户名称
           String userName = StringUtils.parseName(entry.getUser());
           // 用户备注
           String remarks = entry.getName();
           // 通讯录的名称
           String name = "";
           // 名称与备注判断
           if (userName.equals(remarks) && vCard != null) {
             // 使用联系人的昵称
             name = vCard.getNickName();
           } else {
             // 使用备注
             name = remarks;
           }
           if (vCard != null) {
             IM.saveAvatar(vCard.getAvatar(), StringUtils.parseName(entry.getUser()));
           }
           ContentValues values = new ContentValues();
           values.put(ContactsProvider.ContactColumns.ACCOUNT, entry.getUser());
           values.put(ContactsProvider.ContactColumns.NAME, name);
           String sortStr = PinYin.getPinYin(name);
           values.put(ContactsProvider.ContactColumns.SORT, sortStr);
           values.put(
               ContactsProvider.ContactColumns.SECTION,
               sortStr.substring(0, 1).toUpperCase(Locale.ENGLISH));
           // 储存联系人
           if (imService
                   .getContentResolver()
                   .update(
                       ContactsProvider.CONTACT_URI,
                       values,
                       ContactsProvider.ContactColumns.ACCOUNT + " = ?",
                       new String[] {entry.getUser()})
               == 0) {
             uri = imService.getContentResolver().insert(ContactsProvider.CONTACT_URI, values);
           }
         }
         // 发生改变,通知刷新
         if (uri != null) {
           imService.getContentResolver().notifyChange(uri, null);
         }
       }
     } catch (XMPPException e) {
       e.printStackTrace();
     } catch (SmackException e) {
       e.printStackTrace();
     } catch (IOException e) {
       e.printStackTrace();
     }
     return true;
   }
 }
  /**
   * Initializes the packet listeners of the connection that will answer to any service discovery
   * request.
   */
  private void init() {
    // Register the new instance and associate it with the connection
    instances.put(connection, this);
    // Add a listener to the connection that removes the registered instance when
    // the connection is closed
    connection.addConnectionListener(
        new ConnectionListener() {
          public void connectionClosed() {
            // Unregister this instance since the connection has been closed
            instances.remove(connection);
          }

          public void connectionClosedOnError(Exception e) {
            // ignore
          }

          public void reconnectionFailed(Exception e) {
            // ignore
          }

          public void reconnectingIn(int seconds) {
            // ignore
          }

          public void reconnectionSuccessful() {
            // ignore
          }
        });

    // Listen for disco#items requests and answer with an empty result
    PacketFilter packetFilter = new PacketTypeFilter(DiscoverItems.class);
    PacketListener packetListener =
        new PacketListener() {
          public void processPacket(Packet packet) {
            DiscoverItems discoverItems = (DiscoverItems) packet;
            // Send back the items defined in the client if the request is of type GET
            if (discoverItems != null && discoverItems.getType() == IQ.Type.GET) {
              DiscoverItems response = new DiscoverItems();
              response.setType(IQ.Type.RESULT);
              response.setTo(discoverItems.getFrom());
              response.setPacketID(discoverItems.getPacketID());
              response.setNode(discoverItems.getNode());

              // Add the defined items related to the requested node. Look for
              // the NodeInformationProvider associated with the requested node.
              NodeInformationProvider nodeInformationProvider =
                  getNodeInformationProvider(discoverItems.getNode());
              if (nodeInformationProvider != null) {
                // Specified node was found
                List<DiscoverItems.Item> items = nodeInformationProvider.getNodeItems();
                if (items != null) {
                  for (DiscoverItems.Item item : items) {
                    response.addItem(item);
                  }
                }
              } else if (discoverItems.getNode() != null) {
                // Return <item-not-found/> error since client doesn't contain
                // the specified node
                response.setType(IQ.Type.ERROR);
                response.setError(new XMPPError(XMPPError.Condition.item_not_found));
              }
              connection.sendPacket(response);
            }
          }
        };
    connection.addPacketListener(packetListener, packetFilter);

    // Listen for disco#info requests and answer the client's supported features
    // To add a new feature as supported use the #addFeature message
    packetFilter = new PacketTypeFilter(DiscoverInfo.class);
    packetListener =
        new PacketListener() {
          public void processPacket(Packet packet) {
            DiscoverInfo discoverInfo = (DiscoverInfo) packet;
            // Answer the client's supported features if the request is of the GET type
            if (discoverInfo != null && discoverInfo.getType() == IQ.Type.GET) {
              DiscoverInfo response = new DiscoverInfo();
              response.setType(IQ.Type.RESULT);
              response.setTo(discoverInfo.getFrom());
              response.setPacketID(discoverInfo.getPacketID());
              response.setNode(discoverInfo.getNode());
              // Add the client's identity and features only if "node" is null
              if (discoverInfo.getNode() == null) {
                // Set this client identity
                DiscoverInfo.Identity identity =
                    new DiscoverInfo.Identity("client", getIdentityName());
                identity.setType(getIdentityType());
                response.addIdentity(identity);
                // Add the registered features to the response
                synchronized (features) {
                  for (Iterator<String> it = getFeatures(); it.hasNext(); ) {
                    response.addFeature(it.next());
                  }
                }
              } else {
                // Disco#info was sent to a node. Check if we have information of the
                // specified node
                NodeInformationProvider nodeInformationProvider =
                    getNodeInformationProvider(discoverInfo.getNode());
                if (nodeInformationProvider != null) {
                  // Node was found. Add node features
                  List<String> features = nodeInformationProvider.getNodeFeatures();
                  if (features != null) {
                    for (String feature : features) {
                      response.addFeature(feature);
                    }
                  }
                  // Add node identities
                  List<DiscoverInfo.Identity> identities =
                      nodeInformationProvider.getNodeIdentities();
                  if (identities != null) {
                    for (DiscoverInfo.Identity identity : identities) {
                      response.addIdentity(identity);
                    }
                  }
                } else {
                  // Return <item-not-found/> error since specified node was not found
                  response.setType(IQ.Type.ERROR);
                  response.setError(new XMPPError(XMPPError.Condition.item_not_found));
                }
              }
              connection.sendPacket(response);
            }
          }
        };
    connection.addPacketListener(packetListener, packetFilter);
  }
  private void addListeners() {
    connection.addConnectionListener(
        new org.jivesoftware.smack.ConnectionListener() {

          public void authenticated(XMPPConnection connection) {
            // do nothing
          }

          public void connected(XMPPConnection connection) {
            // do nothing
          }

          public void connectionClosed() {
            for (final ConnectionListener l : connectionListeners) {
              l.connectionClosed();
            }
          }

          public void connectionClosedOnError(Exception e) {
            for (final ConnectionListener l : connectionListeners) {
              l.connectionClosedOnError(e);
            }
          }

          public void reconnectingIn(int seconds) {
            for (final ConnectionListener l : connectionListeners) {
              l.reconnectingIn(seconds);
            }
          }

          public void reconnectionFailed(Exception e) {
            for (final ConnectionListener l : connectionListeners) {
              l.reconnectionFailed(e);
            }
          }

          public void reconnectionSuccessful() {
            updateStatus();
            for (final ConnectionListener l : connectionListeners) {
              l.reconnectionSuccessful();
            }
          }
        });
    connection
        .getRoster()
        .addRosterListener(leagueRosterListener = new LeagueRosterListener(this, connection));
    connection.addPacketListener(
        leaguePacketListener = new LeaguePacketListener(this, connection),
        new PacketFilter() {
          public boolean accept(Packet packet) {
            if (packet instanceof Presence) {
              final Presence presence = (Presence) packet;
              if (presence.getType().equals(Presence.Type.subscribed)
                  || presence.getType().equals(Presence.Type.subscribe)
                  || presence.getType().equals(Presence.Type.unsubscribed)
                  || presence.getType().equals(Presence.Type.unsubscribe)) {
                return true;
              }
            }
            return false;
          }
        });
    ChatManager.getInstanceFor(connection)
        .addChatListener(
            new ChatManagerListener() {

              @Override
              public void chatCreated(Chat c, boolean locally) {
                final Friend friend = getFriendById(c.getParticipant());
                if (friend != null) {
                  c.addMessageListener(
                      new MessageListener() {

                        @Override
                        public void processMessage(Chat chat, Message msg) {
                          for (final ChatListener c : chatListeners) {
                            if (msg.getType() == Message.Type.chat) {
                              c.onMessage(friend, msg.getBody());
                            }
                          }
                        }
                      });
                }
              }
            });
  }
    @Override
    public void connectionCreated(XMPPConnection connection) {
      if (XMPPFriendConnectionImpl.this.connection != connection) {
        return;
      }

      if (LOG.isDebugEnabled()) {
        LOG.debug("connection created for " + connection.toString());
      }
      connection.addConnectionListener(this);

      synchronized (ProviderManager.getInstance()) {
        if (ProviderManager.getInstance().getIQProvider("address", "jabber:iq:lw-address")
            == null) {
          ProviderManager.getInstance()
              .addIQProvider(
                  "address", "jabber:iq:lw-address", new AddressIQProvider(addressFactory));
        }
        if (ProviderManager.getInstance()
                .getIQProvider("file-transfer", "jabber:iq:lw-file-transfer")
            == null) {
          ProviderManager.getInstance()
              .addIQProvider(
                  "file-transfer", "jabber:iq:lw-file-transfer", FileTransferIQ.getIQProvider());
        }
        if (ProviderManager.getInstance().getIQProvider("auth-token", "jabber:iq:lw-auth-token")
            == null) {
          ProviderManager.getInstance()
              .addIQProvider("auth-token", "jabber:iq:lw-auth-token", new AuthTokenIQProvider());
        }
        if (ProviderManager.getInstance()
                .getIQProvider("library-changed", "jabber:iq:lw-lib-change")
            == null) {
          ProviderManager.getInstance()
              .addIQProvider(
                  "library-changed", "jabber:iq:lw-lib-change", LibraryChangedIQ.getIQProvider());
        }
        if (ProviderManager.getInstance()
                .getIQProvider(ConnectBackRequestIQ.ELEMENT_NAME, ConnectBackRequestIQ.NAME_SPACE)
            == null) {
          ProviderManager.getInstance()
              .addIQProvider(
                  ConnectBackRequestIQ.ELEMENT_NAME,
                  ConnectBackRequestIQ.NAME_SPACE,
                  new ConnectBackRequestIQProvider());
        }
        if (ProviderManager.getInstance().getIQProvider(NoSaveIQ.ELEMENT_NAME, NoSaveIQ.NAME_SPACE)
            == null) {
          ProviderManager.getInstance()
              .addIQProvider(NoSaveIQ.ELEMENT_NAME, NoSaveIQ.NAME_SPACE, NoSaveIQ.getIQProvider());
        }
      }

      ChatStateManager.getInstance(connection);

      discoInfoListener =
          new DiscoInfoListener(XMPPFriendConnectionImpl.this, connection, featureRegistry);
      discoInfoListener.addListeners(connectionMulticaster, friendPresenceSupport);

      addressIQListener =
          addressIQListenerFactory.create(XMPPFriendConnectionImpl.this, addressFactory);
      connection.addPacketListener(addressIQListener, addressIQListener.getPacketFilter());

      fileTransferIQListener = fileTransferIQListenerFactory.create(XMPPFriendConnectionImpl.this);
      connection.addPacketListener(
          fileTransferIQListener, fileTransferIQListener.getPacketFilter());

      authTokenIQListener = authTokenIQListenerFactory.create(XMPPFriendConnectionImpl.this);
      connection.addPacketListener(authTokenIQListener, authTokenIQListener.getPacketFilter());

      libraryChangedIQListener =
          libraryChangedIQListenerFactory.create(XMPPFriendConnectionImpl.this);
      connection.addPacketListener(
          libraryChangedIQListener, libraryChangedIQListener.getPacketFilter());

      connectRequestIQListener =
          connectBackRequestIQListenerFactory.create(XMPPFriendConnectionImpl.this);
      connection.addPacketListener(
          connectRequestIQListener, connectRequestIQListener.getPacketFilter());

      new LimewireFeatureInitializer().register(featureRegistry);

      noSaveFeatureInitializer =
          new NoSaveFeatureInitializer(
              connection, XMPPFriendConnectionImpl.this, rosterListeners, friendPresenceSupport);
      noSaveFeatureInitializer.register(featureRegistry);

      SubscriptionListener sub = new SubscriptionListener(connection, friendRequestBroadcaster);
      connection.addPacketListener(sub, sub);

      for (URI feature : featureRegistry.getPublicFeatureUris()) {
        ServiceDiscoveryManager.getInstanceFor(connection).addFeature(feature.toASCIIString());
      }
      if (xmppActivityListener == null) {
        xmppActivityListener = new XmppActivityEventListener();
      }
      xmppActivitySupport.addListener(xmppActivityListener);

      if (idleStatusMonitor == null) {
        idleStatusMonitor = idleStatusMonitorFactory.create();
      }
      idleStatusMonitor.start();
    }