コード例 #1
0
/** @author Kir */
public class JabberTransport implements Transport, ConnectionListener, Disposable {
  @NonNls private static final Logger LOG = Logger.getLogger(JabberTransport.class);

  private static final int RESPONSE_TIMEOUT = 120 * 1000;
  @NonNls public static final String CODE = "Jabber";

  private final JabberUI myUI;
  private final JabberFacade myFacade;
  private final UserModel myUserModel;
  private final IDEtalkListener myUserModelListener = new MyUserModelListener();
  private final AsyncMessageDispatcher myDispatcher;

  private RosterListener myRosterListener;
  private PacketListener mySubscribeListener;
  private PacketListener myMessageListener;
  private final JabberUserFinder myUserFinder;
  private final IDEFacade myIdeFacade;

  private final String myThreadIdPrefix = StringUtils.randomString(5);
  private int myCurrentThreadId;
  private boolean myIgnoreUserEvents;
  private PresenceMode myPresenceMode;

  private final Map<User, UserPresence> myUser2Presence = new HashMap<>();
  private final Set<String> myIDEtalkUsers = new HashSet<>();
  private final Map<String, String> myUser2Thread =
      Collections.synchronizedMap(new HashMap<String, String>());

  @NonNls private static final String RESPONSE = "response";
  private final IgnoreList myIgnoreList;

  // negative value disables reconnect
  private int myReconnectTimeout =
      Integer.parseInt(System.getProperty("ideTalk.reconnect", "30")) * 1000;
  private Future<?> myReconnectProcess;

  public JabberTransport(
      JabberUI UI,
      JabberFacade facade,
      UserModel userModel,
      AsyncMessageDispatcher messageDispatcher,
      JabberUserFinder userFinder) {
    Roster.setDefaultSubscriptionMode(Roster.SubscriptionMode.manual);

    // XMPPConnection.DEBUG_ENABLED = true;
    JDOMExtension.init();

    myUI = UI;
    myFacade = facade;
    myUserModel = userModel;
    myDispatcher = messageDispatcher;
    myUserFinder = userFinder;
    myIdeFacade = messageDispatcher.getIdeFacade();
    myIgnoreList = new IgnoreList(myIdeFacade);

    myFacade.addConnectionListener(this);
    getBroadcaster().addListener(myUserModelListener);
  }

  private EventBroadcaster getBroadcaster() {
    return myUserModel.getBroadcaster();
  }

  @Override
  public String getName() {
    return CODE;
  }

  @Override
  public void initializeProject(String projectName, MutablePicoContainer projectLevelContainer) {
    myUI.initPerProject(projectLevelContainer);
    myIdeFacade.runOnPooledThread(() -> myFacade.connect());
  }

  @Override
  public User[] findUsers(ProgressIndicator progressIndicator) {
    if (isOnline()) {
      return myUserFinder.findUsers(progressIndicator);
    }
    return new User[0];
  }

  @Override
  public Class<? extends NamedUserCommand> getSpecificFinderClass() {
    return FindByJabberIdCommand.class;
  }

  @Override
  public boolean isOnline() {
    return myFacade.isConnectedAndAuthenticated();
  }

  @Override
  public UserPresence getUserPresence(User user) {
    UserPresence presence = myUser2Presence.get(user);
    if (presence == null) {
      presence = new UserPresence(false);
      myUser2Presence.put(user, presence);
    }
    return presence;
  }

  private UserPresence _getUserPresence(User user) {
    Presence presence = _getPresence(user);
    if (presence != null && presence.getType() == Presence.Type.available) {
      Presence.Mode mode = presence.getMode();
      final PresenceMode presenceMode;
      //noinspection IfStatementWithTooManyBranches
      if (mode == Presence.Mode.away) {
        presenceMode = PresenceMode.AWAY;
      } else if (mode == Presence.Mode.dnd) {
        presenceMode = PresenceMode.DND;
      } else if (mode == Presence.Mode.xa) {
        presenceMode = PresenceMode.EXTENDED_AWAY;
      } else {
        presenceMode = PresenceMode.AVAILABLE;
      }

      return new UserPresence(presenceMode);
    }
    return new UserPresence(false);
  }

  @Override
  @NonNls
  public Icon getIcon(UserPresence userPresence) {
    return UIUtil.getIcon(
        userPresence, IdetalkCoreIcons.IdeTalk.Jabber, IdetalkCoreIcons.IdeTalk.Jabber_dnd);
  }

  @Override
  public boolean isSelf(User user) {
    return myFacade.isConnectedAndAuthenticated()
        && getSimpleId(myFacade.getConnection().getUser()).equals(user.getName());
  }

  @Override
  public String[] getProjects(User user) {
    return ArrayUtil.EMPTY_STRING_ARRAY;
  }

  @Override
  @Nullable
  public String getAddressString(User user) {
    return null;
  }

  @Override
  public synchronized void sendXmlMessage(User user, final XmlMessage xmlMessage) {
    if (!myUI.connectAndLogin(null)) {
      return;
    }

    final String threadId = getThreadId(user);
    final PacketCollector packetCollector =
        myFacade.getConnection().createPacketCollector(new ThreadFilter(threadId));
    doSendMessage(xmlMessage, user, threadId);

    if (xmlMessage.needsResponse()) {
      //noinspection HardCodedStringLiteral
      final Runnable responseWaiterRunnable =
          () -> {
            try {
              processResponse(xmlMessage, packetCollector);
            } finally {
              packetCollector.cancel();
            }
          };
      myIdeFacade.runOnPooledThread(responseWaiterRunnable);
    } else {
      packetCollector.cancel();
    }
  }

  String getThreadId(User user) {
    String id = myUser2Thread.get(user.getName());
    if (id == null) {
      id = myThreadIdPrefix + myCurrentThreadId++;
      myUser2Thread.put(user.getName(), id);
    }
    return id;
  }

  @Override
  public void setOwnPresence(UserPresence userPresence) {
    if (isOnline() && !userPresence.isOnline()) {
      myFacade.disconnect();
    } else if (!isOnline() && userPresence.isOnline()) {
      myUI.connectAndLogin(null);
    }

    if (isOnline() && presenceModeChanged(userPresence.getPresenceMode())) {
      myFacade.setOnlinePresence(userPresence);
      myPresenceMode = userPresence.getPresenceMode();
    }
  }

  @Override
  public boolean hasIdeTalkClient(User user) {
    return myIDEtalkUsers.contains(user.getName());
  }

  private boolean presenceModeChanged(PresenceMode presenceMode) {
    return myPresenceMode == null || myPresenceMode != presenceMode;
  }

  private static void processResponse(XmlMessage xmlMessage, PacketCollector collector) {
    boolean gotResponse = false;

    while (!gotResponse) {

      Message response = (Message) collector.nextResult(RESPONSE_TIMEOUT);
      if (response == null) break;

      final Collection<PacketExtension> extensions = response.getExtensions();
      for (PacketExtension o : extensions) {
        if (o instanceof JDOMExtension) {
          JDOMExtension extension = (JDOMExtension) o;
          if (RESPONSE.equals(extension.getElement().getName())) {
            xmlMessage.processResponse(extension.getElement());
            gotResponse = true;
            break;
          }
        }
      }
    }
  }

  private Message doSendMessage(XmlMessage xmlMessage, User user, String threadId) {
    Element element = new Element(xmlMessage.getTagName(), xmlMessage.getTagNamespace());
    xmlMessage.fillRequest(element);

    Message message = createBaseMessage(user, element.getText());
    message.setThread(threadId);
    message.addExtension(new JDOMExtension(element));
    myFacade.getConnection().sendPacket(message);

    return message;
  }

  static Message createBaseMessage(User user, String message) {
    Message msg = new Message(user.getName(), Message.Type.CHAT);
    msg.setBody(message);
    return msg;
  }

  @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 void authenticated() {
    LOG.info("Jabber authenticated: " + myFacade.getConnection().getUser());
    if (myRosterListener == null) {
      myRosterListener = new MyRosterListener();
      getRoster().addRosterListener(myRosterListener);
    }
    myUserFinder.registerForProject(myFacade.getMyAccount().getJabberId());

    if (!hasJabberContacts()) {
      synchronizeRoster(false);
    }
  }

  private boolean hasJabberContacts() {
    User[] users = myUserModel.getAllUsers();
    for (User user : users) {
      if (user.getTransportCode().equals(getName())) return true;
    }
    return false;
  }

  @Override
  public void disconnected(boolean onError) {
    final XMPPConnection connection = myFacade.getConnection();

    LOG.info("Jabber disconnected: " + connection.getUser());
    connection.removePacketListener(mySubscribeListener);
    mySubscribeListener = null;
    connection.removePacketListener(myMessageListener);
    myMessageListener = null;

    final Roster roster = connection.getRoster();
    if (roster != null) {
      roster.removeRosterListener(myRosterListener);
    }
    myRosterListener = null;

    myIDEtalkUsers.clear();
    myUser2Presence.clear();
    myUser2Thread.clear();

    if (onError && reconnectEnabledAndNotStarted()) {
      LOG.warn(getMsg("jabber.server.was.disconnected", myReconnectTimeout / 1000));
      myReconnectProcess = myIdeFacade.runOnPooledThread(new MyReconnectRunnable());
    }
  }

  private boolean reconnectEnabledAndNotStarted() {
    return (myReconnectProcess == null || myReconnectProcess.isDone()) && myReconnectTimeout >= 0;
  }

  @Override
  public void dispose() {
    getBroadcaster().removeListener(myUserModelListener);
    myFacade.removeConnectionListener(this);
  }

  private void updateUserPresence(String jabberId) {
    LOG.debug("Presence changed for " + jabberId);
    final User user = myUserModel.findUser(getSimpleId(jabberId), getName());
    if (user != null) {
      updateIsIDEtalkClient(jabberId, user);

      final UserPresence presence = _getUserPresence(user);
      IDEtalkEvent event = createPresenceChangeEvent(user, presence);
      if (event != null) {
        getBroadcaster().doChange(event, () -> myUser2Presence.put(user, presence));
      }
    }
  }

  private void updateIsIDEtalkClient(String jabberId, User user) {
    if (getResource(jabberId)
        .toLowerCase()
        .startsWith(JabberFacade.IDETALK_RESOURCE.toLowerCase())) {
      myIDEtalkUsers.add(user.getName());
    } else {
      myIDEtalkUsers.remove(user.getName());
    }
  }

  @Nullable
  private IDEtalkEvent createPresenceChangeEvent(User user, UserPresence newPresence) {
    UserPresence oldPresence = getUserPresence(user);
    if (!newPresence.equals(oldPresence)) {
      if (newPresence.isOnline() ^ oldPresence.isOnline()) {
        return newPresence.isOnline() ? new UserEvent.Online(user) : new UserEvent.Offline(user);
      } else {
        return new UserEvent.Updated(
            user, PRESENCE, oldPresence.getPresenceMode(), newPresence.getPresenceMode());
      }
    }
    return null;
  }

  private void updateJabberUsers(boolean removeUsersNotInRoster) {
    LOG.debug("Roster changed - update user model");
    Set<User> currentUsers = new HashSet<>(Arrays.asList(myUserModel.getAllUsers()));
    for (RosterEntry rosterEntry : getRoster().getEntries()) {
      User user = addJabberUserToUserModelOrUpdateInfo(rosterEntry);
      currentUsers.remove(user);
    }

    if (removeUsersNotInRoster) {
      removeUsers(currentUsers);
    }

    if (LOG.isDebugEnabled()) {
      LOG.debug("Roster synchronized: " + Arrays.asList(myUserModel.getAllUsers()));
    }
  }

  private void removeUsers(Set<User> currentUsers) {
    for (User user : currentUsers) {
      myUserModel.removeUser(user);
    }
  }

  private User addJabberUserToUserModelOrUpdateInfo(RosterEntry rosterEntry) {
    //    System.out.println("rosterEntry.getName() = " + rosterEntry.getName());
    //    System.out.println("rosterEntry.getUser() = " + rosterEntry.getUser());
    User user = myUserModel.createUser(getSimpleId(rosterEntry.getUser()), getName());
    String newGroup = getUserGroup(rosterEntry);
    if (newGroup != null) {
      user.setGroup(newGroup, myUserModel);
    }
    user.setDisplayName(rosterEntry.getName(), myUserModel);
    myUserModel.addUser(user);
    String jabberId = getCurrentJabberID(user, rosterEntry);
    updateIsIDEtalkClient(jabberId, user);
    return user;
  }

  private String getCurrentJabberID(User user, RosterEntry rosterEntry) {
    Presence presence = _getPresence(user);
    String jabberId = null;
    if (presence != null) {
      jabberId = presence.getFrom();
    }
    if (jabberId == null) jabberId = rosterEntry.getUser();
    if (jabberId == null) jabberId = rosterEntry.getName();
    return jabberId;
  }

  static String getResource(String userName) {
    int lastSlash = userName.indexOf('/');
    if (lastSlash != -1) {
      return userName.substring(lastSlash + 1);
    }
    return "";
  }

  static String getSimpleId(String userName) {
    String id = userName;
    int lastSlash = id.indexOf('/');
    if (lastSlash != -1) {
      id = id.substring(0, lastSlash);
    }
    return id;
  }

  @Nullable
  private static String getUserGroup(RosterEntry rosterEntry) {
    String group = null;
    for (RosterGroup rosterGroup : rosterEntry.getGroups()) {
      group = rosterGroup.getName();
    }
    return group;
  }

  private Roster getRoster() {
    final Roster roster = myFacade.getConnection().getRoster();
    assert roster != null;
    return roster;
  }

  public JabberFacade getFacade() {
    return myFacade;
  }

  boolean isUserInMyContactListAndActive(String userName) {
    User user = myUserModel.findUser(getSimpleId(userName), getName());
    return user != null && user.isOnline();
  }

  @Nullable
  private Presence _getPresence(User user) {
    if (!isOnline()) return null;
    return getRoster().getPresence(user.getName());
  }

  private User self() {
    return myUserModel.createUser(myFacade.getMyAccount().getJabberId(), getName());
  }

  public static JabberTransport getInstance() {
    return (JabberTransport) Pico.getInstance().getComponentInstanceOfType(JabberTransport.class);
  }

  public void synchronizeRoster(boolean removeUsersNotInRoster) {
    updateJabberUsers(removeUsersNotInRoster);
  }

  public void runIngnoringUserEvents(Runnable runnable) {
    try {
      myIgnoreUserEvents = true;
      runnable.run();
    } finally {
      myIgnoreUserEvents = false;
    }
  }

  /** -1 disables reconnect */
  public void setReconnectTimeout(int milliseconds) {
    myReconnectTimeout = milliseconds;
  }

  private class MyRosterListener implements RosterListener {
    @Override
    public void entriesAdded(Collection addresses) {
      updateJabberUsers(false);
    }

    @Override
    public void entriesUpdated(Collection addresses) {
      updateJabberUsers(false);
    }

    @Override
    public void entriesDeleted(Collection addresses) {
      updateJabberUsers(false);
    }

    @Override
    public void presenceChanged(final String string) {
      updateUserPresence(string);
    }
  }

  @SuppressWarnings({"RefusedBequest"})
  private class MyUserModelListener extends TransportUserListener {

    MyUserModelListener() {
      super(JabberTransport.this);
    }

    @Override
    protected void processBeforeChange(UserEvent event) {
      super.processBeforeChange(event);
      event.accept(
          new EventVisitor() {
            @Override
            public void visitUserAdded(UserEvent.Added event) {
              event.getUser().setCanAccessMyFiles(false, myUserModel);
            }
          });
    }

    @Override
    protected void processAfterChange(UserEvent event) {
      if (myIgnoreUserEvents) return;

      event.accept(
          new EventVisitor() {
            @Override
            public void visitUserRemoved(UserEvent.Removed event) {
              synchronizeWithJabberIfPossible(event);
            }

            @Override
            public void visitUserUpdated(UserEvent.Updated event) {
              if (GROUP.equals(event.getPropertyName())
                  || DISPLAY_NAME.equals(event.getPropertyName())) {
                synchronizeWithJabberIfPossible(event);
              }
            }
          });
    }

    private void synchronizeWithJabberIfPossible(UserEvent event) {
      if (event.getUser().getTransportCode().equals(getName())
          && myFacade.isConnectedAndAuthenticated()) {
        myDispatcher.sendNow(self(), new JabberSyncUserMessage(event));
      }
    }
  }

  private class MySubscribeListener implements PacketListener {
    @Override
    public void processPacket(Packet packet) {
      final Presence presence = ((Presence) packet);
      if (presence.getType() != Presence.Type.subscribe) return;
      LOG.info("Subscribe request from " + presence.getFrom());

      if (myIgnoreList.isIgnored(presence.getFrom())) {
        LOG.info(presence.getFrom() + " in ignore list");
        return;
      }

      if (isUserInMyContactListAndActive(presence.getFrom()) || Pico.isUnitTest()) {
        acceptSubscription(presence, true);
        return;
      }

      UIUtil.invokeLater(
          () -> acceptSubscription(presence, myUI.shouldAcceptSubscriptionRequest(presence)));
    }

    private void acceptSubscription(final Presence presence, boolean subscribe) {
      if (!isOnline()) return;

      myFacade.changeSubscription(presence.getFrom(), subscribe);

      if (subscribe) {
        String from = getSimpleId(presence.getFrom());
        LOG.info("Add " + from + " to the roster");

        try {
          getRoster().createEntry(from, from, new String[] {UserModel.DEFAULT_GROUP});
        } catch (XMPPException e) {
          LOG.warn(e);
        }
      }
    }
  }

  private class MyMessageListener implements PacketListener {

    @Override
    public void processPacket(Packet packet) {
      try {
        doProcessPacket(packet);
      } catch (Throwable e) {
        LOG.error(e.getMessage(), e);
      }
    }

    private void doProcessPacket(Packet packet) {
      final Message message = ((Message) packet);
      if (message.getType() == Message.Type.ERROR) {
        UIUtil.invokeLater(
            () -> {
              String from =
                  (message.getFrom() != null) ? getMsg("from.0.lf", message.getFrom()) : "";
              LOG.warn(
                  getMsg(
                      "jabber.error.text",
                      from,
                      (message.getError() == null ? "N/A" : message.getError().toString())));
            });
        return;
      }

      if (myIgnoreList.isIgnored(packet.getFrom())) {
        return;
      }

      Element element = null;
      for (PacketExtension o : message.getExtensions()) {
        if (o instanceof JDOMExtension) {
          element = ((JDOMExtension) o).getElement();
        }
      }

      if (element != null && !RESPONSE.equals(element.getName())) {
        processAndSendResponse(element, message);
      } else if (element == null && message.getBody() != null) {
        // Some simple Jabber Message
        MessageEvent event =
            EventFactory.createMessageEvent(
                JabberTransport.this, getFrom(message), message.getBody());
        if (message.getThread() != null) {
          myUser2Thread.put(getFrom(message), message.getThread());
        }

        getBroadcaster().fireEvent(event);
      }
    }

    private void processAndSendResponse(Element element, Message message) {
      Element response = new Element(RESPONSE, Transport.NAMESPACE);
      XmlResponseProvider provider = XmlResponseProvider.getProvider(element, getBroadcaster());
      if (provider.processAndFillResponse(
          response, element, JabberTransport.this, getFrom(message))) {
        Message responseMessage = new Message(getFrom(message));
        responseMessage.addExtension(new JDOMExtension(response));
        responseMessage.setThread(message.getThread());
        myFacade.getConnection().sendPacket(responseMessage);
      }
    }

    private String getFrom(Message message) {
      return getSimpleId(message.getFrom());
    }
  }

  private class MyReconnectRunnable implements Runnable {
    @Override
    public void run() {
      try {
        Thread.sleep(myReconnectTimeout);

        if (myFacade.connect() != null && myFacade.getMyAccount().isLoginAllowed()) {
          myReconnectProcess = myIdeFacade.runOnPooledThread(this);
        }
      } catch (InterruptedException ignored) {
        // return
      }
    }
  }
}
コード例 #2
0
 /**
  * Returns the supported features by this XMPP entity.
  *
  * @return an Iterator on the supported features by this XMPP entity.
  */
 public Iterator<String> getFeatures() {
   synchronized (features) {
     return Collections.unmodifiableList(new ArrayList<String>(features)).iterator();
   }
 }
コード例 #3
0
 /**
  * Returns all identities of this client as unmodifiable Collection
  *
  * @return
  */
 public Set<DiscoverInfo.Identity> getIdentities() {
   Set<Identity> res = new HashSet<Identity>(identities);
   // Add the default identity that must exist
   res.add(defaultIdentity);
   return Collections.unmodifiableSet(res);
 }
コード例 #4
0
/**
 * Manages discovery of services in XMPP entities. This class provides:
 *
 * <ol>
 *   <li>A registry of supported features in this XMPP entity.
 *   <li>Automatic response when this XMPP entity is queried for information.
 *   <li>Ability to discover items and information of remote XMPP entities.
 *   <li>Ability to publish publicly available items.
 * </ol>
 *
 * @author Gaston Dombiak
 */
public class ServiceDiscoveryManager {

  private static final String DEFAULT_IDENTITY_NAME = "Smack";
  private static final String DEFAULT_IDENTITY_CATEGORY = "client";
  private static final String DEFAULT_IDENTITY_TYPE = "pc";
  private static DiscoverInfo.Identity defaultIdentity =
      new Identity(DEFAULT_IDENTITY_CATEGORY, DEFAULT_IDENTITY_NAME, DEFAULT_IDENTITY_TYPE);

  private Set<DiscoverInfo.Identity> identities = new HashSet<DiscoverInfo.Identity>();
  private DiscoverInfo.Identity identity = defaultIdentity;

  private EntityCapsManager capsManager;

  private static Map<Connection, ServiceDiscoveryManager> instances =
      Collections.synchronizedMap(new WeakHashMap<Connection, ServiceDiscoveryManager>());

  private WeakReference<Connection> connection;
  private final Set<String> features = new HashSet<String>();
  private DataForm extendedInfo = null;
  private Map<String, NodeInformationProvider> nodeInformationProviders =
      new ConcurrentHashMap<String, NodeInformationProvider>();

  // Create a new ServiceDiscoveryManager on every established connection
  static {
    Connection.addConnectionCreationListener(
        new ConnectionCreationListener() {
          public void connectionCreated(Connection connection) {
            getInstanceFor(connection);
          }
        });
  }

  /**
   * Set the default identity all new connections will have. If unchanged the default identity is an
   * identity where category is set to 'client', type is set to 'pc' and name is set to 'Smack'.
   *
   * @param identity
   */
  public static void setDefaultIdentity(DiscoverInfo.Identity identity) {
    defaultIdentity = identity;
  }

  /**
   * Creates a new ServiceDiscoveryManager for a given Connection. 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(Connection connection) {
    this.connection = new WeakReference<Connection>(connection);

    // Register the new instance and associate it with the connection
    instances.put(connection, this);

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

    // 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) {
            Connection connection = ServiceDiscoveryManager.this.connection.get();
            if (connection == null) return;
            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, 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, 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) {
            Connection connection = ServiceDiscoveryManager.this.connection.get();
            if (connection == null) return;
            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
              // 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, packetFilter);
  }

  /**
   * Returns the name of the client that will be returned when asked for the client identity in a
   * disco request. The name could be any value you need to identity this client.
   *
   * @return the name of the client that will be returned when asked for the client identity in a
   *     disco request.
   */
  public String getIdentityName() {
    return identity.getName();
  }

  /**
   * Sets the name of the client that will be returned when asked for the client identity in a disco
   * request. The name could be any value you need to identity this client.
   *
   * @param name the name of the client that will be returned when asked for the client identity in
   *     a disco request.
   */
  public void setIdentityName(String name) {
    identity.setName(name);
    renewEntityCapsVersion();
  }

  /**
   * Returns the type of client that will be returned when asked for the client identity in a disco
   * request. The valid types are defined by the category client. Follow this link to learn the
   * possible types: <a
   * href="http://xmpp.org/registrar/disco-categories.html#client">Jabber::Registrar</a>.
   *
   * @return the type of client that will be returned when asked for the client identity in a disco
   *     request.
   */
  public String getIdentityType() {
    return identity.getType();
  }

  /**
   * Sets the type of client that will be returned when asked for the client identity in a disco
   * request. The valid types are defined by the category client. Follow this link to learn the
   * possible types: <a
   * href="http://xmpp.org/registrar/disco-categories.html#client">Jabber::Registrar</a>.
   *
   * @param type the type of client that will be returned when asked for the client identity in a
   *     disco request.
   */
  @SuppressWarnings("deprecation")
  public void setIdentityType(String type) {
    identity.setType(type);
    renewEntityCapsVersion();
  }

  /**
   * Add an identity to the client.
   *
   * @param identity
   */
  public void addIdentity(DiscoverInfo.Identity identity) {
    identities.add(identity);
    renewEntityCapsVersion();
  }

  /**
   * Remove an identity from the client. Note that the client needs at least one identity, the
   * default identity, which can not be removed.
   *
   * @param identity
   * @return true, if successful. Otherwise the default identity was given.
   */
  public boolean removeIdentity(DiscoverInfo.Identity identity) {
    if (identity.equals(this.identity)) return false;
    identities.remove(identity);
    renewEntityCapsVersion();
    return true;
  }

  /**
   * Returns all identities of this client as unmodifiable Collection
   *
   * @return
   */
  public Set<DiscoverInfo.Identity> getIdentities() {
    Set<Identity> res = new HashSet<Identity>(identities);
    // Add the default identity that must exist
    res.add(defaultIdentity);
    return Collections.unmodifiableSet(res);
  }

  /**
   * Returns the ServiceDiscoveryManager instance associated with a given Connection.
   *
   * @param connection the connection used to look for the proper ServiceDiscoveryManager.
   * @return the ServiceDiscoveryManager associated with a given Connection.
   */
  public static synchronized ServiceDiscoveryManager getInstanceFor(Connection connection) {
    ServiceDiscoveryManager sdm = instances.get(connection);
    if (sdm == null) {
      sdm = new ServiceDiscoveryManager(connection);
    }
    return sdm;
  }

  /**
   * Add discover info response data.
   *
   * @see <a href="http://xmpp.org/extensions/xep-0030.html#info-basic">XEP-30 Basic Protocol;
   *     Example 2</a>
   * @param response the discover info response packet
   */
  public void addDiscoverInfoTo(DiscoverInfo response) {
    // First add the identities of the connection
    response.addIdentities(getIdentities());

    // Add the registered features to the response
    synchronized (features) {
      for (Iterator<String> it = getFeatures(); it.hasNext(); ) {
        response.addFeature(it.next());
      }
      response.addExtension(extendedInfo);
    }
  }

  /**
   * Returns the NodeInformationProvider responsible for providing information (ie items) related to
   * a given node or <tt>null</null> if none.
   *
   * <p>In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the
   * NodeInformationProvider will provide information about the rooms where the user has joined.
   *
   * @param node the node that contains items associated with an entity not addressable as a JID.
   * @return the NodeInformationProvider responsible for providing information related to a given
   *     node.
   */
  private NodeInformationProvider getNodeInformationProvider(String node) {
    if (node == null) {
      return null;
    }
    return nodeInformationProviders.get(node);
  }

  /**
   * Sets the NodeInformationProvider responsible for providing information (ie items) related to a
   * given node. Every time this client receives a disco request regarding the items of a given
   * node, the provider associated to that node will be the responsible for providing the requested
   * information.
   *
   * <p>In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the
   * NodeInformationProvider will provide information about the rooms where the user has joined.
   *
   * @param node the node whose items will be provided by the NodeInformationProvider.
   * @param listener the NodeInformationProvider responsible for providing items related to the
   *     node.
   */
  public void setNodeInformationProvider(String node, NodeInformationProvider listener) {
    nodeInformationProviders.put(node, listener);
  }

  /**
   * Removes the NodeInformationProvider responsible for providing information (ie items) related to
   * a given node. This means that no more information will be available for the specified node.
   *
   * <p>In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the
   * NodeInformationProvider will provide information about the rooms where the user has joined.
   *
   * @param node the node to remove the associated NodeInformationProvider.
   */
  public void removeNodeInformationProvider(String node) {
    nodeInformationProviders.remove(node);
  }

  /**
   * Returns the supported features by this XMPP entity.
   *
   * @return an Iterator on the supported features by this XMPP entity.
   */
  public Iterator<String> getFeatures() {
    synchronized (features) {
      return Collections.unmodifiableList(new ArrayList<String>(features)).iterator();
    }
  }

  /**
   * Returns the supported features by this XMPP entity.
   *
   * @return a copy of the List on the supported features by this XMPP entity.
   */
  public List<String> getFeaturesList() {
    synchronized (features) {
      return new LinkedList<String>(features);
    }
  }

  /**
   * Registers that a new feature is supported by this XMPP entity. When this client is queried for
   * its information the registered features will be answered.
   *
   * <p>Since no packet is actually sent to the server it is safe to perform this operation before
   * logging to the server. In fact, you may want to configure the supported features before logging
   * to the server so that the information is already available if it is required upon login.
   *
   * @param feature the feature to register as supported.
   */
  public void addFeature(String feature) {
    synchronized (features) {
      features.add(feature);
      renewEntityCapsVersion();
    }
  }

  /**
   * Removes the specified feature from the supported features by this XMPP entity.
   *
   * <p>Since no packet is actually sent to the server it is safe to perform this operation before
   * logging to the server.
   *
   * @param feature the feature to remove from the supported features.
   */
  public void removeFeature(String feature) {
    synchronized (features) {
      features.remove(feature);
      renewEntityCapsVersion();
    }
  }

  /**
   * Returns true if the specified feature is registered in the ServiceDiscoveryManager.
   *
   * @param feature the feature to look for.
   * @return a boolean indicating if the specified featured is registered or not.
   */
  public boolean includesFeature(String feature) {
    synchronized (features) {
      return features.contains(feature);
    }
  }

  /**
   * Registers extended discovery information of this XMPP entity. When this client is queried for
   * its information this data form will be returned as specified by XEP-0128.
   *
   * <p>Since no packet is actually sent to the server it is safe to perform this operation before
   * logging to the server. In fact, you may want to configure the extended info before logging to
   * the server so that the information is already available if it is required upon login.
   *
   * @param info the data form that contains the extend service discovery information.
   */
  public void setExtendedInfo(DataForm info) {
    extendedInfo = info;
    renewEntityCapsVersion();
  }

  /**
   * Returns the data form that is set as extended information for this Service Discovery instance
   * (XEP-0128)
   *
   * @see <a href="http://xmpp.org/extensions/xep-0128.html">XEP-128: Service Discovery
   *     Extensions</a>
   * @return
   */
  public DataForm getExtendedInfo() {
    return extendedInfo;
  }

  /**
   * Returns the data form as List of PacketExtensions, or null if no data form is set. This
   * representation is needed by some classes (e.g. EntityCapsManager, NodeInformationProvider)
   *
   * @return
   */
  public List<PacketExtension> getExtendedInfoAsList() {
    List<PacketExtension> res = null;
    if (extendedInfo != null) {
      res = new ArrayList<PacketExtension>(1);
      res.add(extendedInfo);
    }
    return res;
  }

  /**
   * Removes the data form containing extended service discovery information from the information
   * returned by this XMPP entity.
   *
   * <p>Since no packet is actually sent to the server it is safe to perform this operation before
   * logging to the server.
   */
  public void removeExtendedInfo() {
    extendedInfo = null;
    renewEntityCapsVersion();
  }

  /**
   * Returns the discovered information of a given XMPP entity addressed by its JID. Use null as
   * entityID to query the server
   *
   * @param entityID the address of the XMPP entity or null.
   * @return the discovered information.
   * @throws XMPPException if the operation failed for some reason.
   */
  public DiscoverInfo discoverInfo(String entityID) throws XMPPException {
    if (entityID == null) return discoverInfo(null, null);

    // Check if the have it cached in the Entity Capabilities Manager
    DiscoverInfo info = EntityCapsManager.getDiscoverInfoByUser(entityID);

    if (info != null) {
      // We were able to retrieve the information from Entity Caps and
      // avoided a disco request, hurray!
      return info;
    }

    // Try to get the newest node#version if it's known, otherwise null is
    // returned
    EntityCapsManager.NodeVerHash nvh = EntityCapsManager.getNodeVerHashByJid(entityID);

    // Discover by requesting the information from the remote entity
    // Note that wee need to use NodeVer as argument for Node if it exists
    info = discoverInfo(entityID, nvh != null ? nvh.getNodeVer() : null);

    // If the node version is known, store the new entry.
    if (nvh != null) {
      if (EntityCapsManager.verifyDiscoverInfoVersion(nvh.getVer(), nvh.getHash(), info))
        EntityCapsManager.addDiscoverInfoByNode(nvh.getNodeVer(), info);
    }

    return info;
  }

  /**
   * Returns the discovered information of a given XMPP entity addressed by its JID and note
   * attribute. Use this message only when trying to query information which is not directly
   * addressable.
   *
   * @see <a href="http://xmpp.org/extensions/xep-0030.html#info-basic">XEP-30 Basic Protocol</a>
   * @see <a href="http://xmpp.org/extensions/xep-0030.html#info-nodes">XEP-30 Info Nodes</a>
   * @param entityID the address of the XMPP entity.
   * @param node the optional attribute that supplements the 'jid' attribute.
   * @return the discovered information.
   * @throws XMPPException if the operation failed for some reason.
   */
  public DiscoverInfo discoverInfo(String entityID, String node) throws XMPPException {
    Connection connection = ServiceDiscoveryManager.this.connection.get();
    if (connection == null) throw new XMPPException("Connection instance already gc'ed");

    // Discover the entity's info
    DiscoverInfo disco = new DiscoverInfo();
    disco.setType(IQ.Type.GET);
    disco.setTo(entityID);
    disco.setNode(node);

    Packet result = connection.createPacketCollectorAndSend(disco).nextResultOrThrow();

    return (DiscoverInfo) result;
  }

  /**
   * Returns the discovered items of a given XMPP entity addressed by its JID.
   *
   * @param entityID the address of the XMPP entity.
   * @return the discovered information.
   * @throws XMPPException if the operation failed for some reason.
   */
  public DiscoverItems discoverItems(String entityID) throws XMPPException {
    return discoverItems(entityID, null);
  }

  /**
   * Returns the discovered items of a given XMPP entity addressed by its JID and note attribute.
   * Use this message only when trying to query information which is not directly addressable.
   *
   * @param entityID the address of the XMPP entity.
   * @param node the optional attribute that supplements the 'jid' attribute.
   * @return the discovered items.
   * @throws XMPPException if the operation failed for some reason.
   */
  public DiscoverItems discoverItems(String entityID, String node) throws XMPPException {
    Connection connection = ServiceDiscoveryManager.this.connection.get();
    if (connection == null) throw new XMPPException("Connection instance already gc'ed");

    // Discover the entity's items
    DiscoverItems disco = new DiscoverItems();
    disco.setType(IQ.Type.GET);
    disco.setTo(entityID);
    disco.setNode(node);

    Packet result = connection.createPacketCollectorAndSend(disco).nextResultOrThrow();
    return (DiscoverItems) result;
  }

  /**
   * Returns true if the server supports publishing of items. A client may wish to publish items to
   * the server so that the server can provide items associated to the client. These items will be
   * returned by the server whenever the server receives a disco request targeted to the bare
   * address of the client (i.e. [email protected]).
   *
   * @param entityID the address of the XMPP entity.
   * @return true if the server supports publishing of items.
   * @throws XMPPException if the operation failed for some reason.
   */
  public boolean canPublishItems(String entityID) throws XMPPException {
    DiscoverInfo info = discoverInfo(entityID);
    return canPublishItems(info);
  }

  /**
   * Returns true if the server supports publishing of items. A client may wish to publish items to
   * the server so that the server can provide items associated to the client. These items will be
   * returned by the server whenever the server receives a disco request targeted to the bare
   * address of the client (i.e. [email protected]).
   *
   * @param DiscoverInfo the discover info packet to check.
   * @return true if the server supports publishing of items.
   */
  public static boolean canPublishItems(DiscoverInfo info) {
    return info.containsFeature("http://jabber.org/protocol/disco#publish");
  }

  /**
   * Publishes new items to a parent entity. The item elements to publish MUST have at least a 'jid'
   * attribute specifying the Entity ID of the item, and an action attribute which specifies the
   * action being taken for that item. Possible action values are: "update" and "remove".
   *
   * @param entityID the address of the XMPP entity.
   * @param discoverItems the DiscoveryItems to publish.
   * @throws XMPPException if the operation failed for some reason.
   */
  public void publishItems(String entityID, DiscoverItems discoverItems) throws XMPPException {
    publishItems(entityID, null, discoverItems);
  }

  /**
   * Publishes new items to a parent entity and node. The item elements to publish MUST have at
   * least a 'jid' attribute specifying the Entity ID of the item, and an action attribute which
   * specifies the action being taken for that item. Possible action values are: "update" and
   * "remove".
   *
   * @param entityID the address of the XMPP entity.
   * @param node the attribute that supplements the 'jid' attribute.
   * @param discoverItems the DiscoveryItems to publish.
   * @throws XMPPException if the operation failed for some reason.
   */
  public void publishItems(String entityID, String node, DiscoverItems discoverItems)
      throws XMPPException {
    Connection connection = ServiceDiscoveryManager.this.connection.get();
    if (connection == null) throw new XMPPException("Connection instance already gc'ed");

    discoverItems.setType(IQ.Type.SET);
    discoverItems.setTo(entityID);
    discoverItems.setNode(node);

    connection.createPacketCollectorAndSend(discoverItems).nextResultOrThrow();
  }

  /** Entity Capabilities */

  /**
   * Loads the ServiceDiscoveryManager with an EntityCapsManger that speeds up certain lookups
   *
   * @param manager
   */
  public void setEntityCapsManager(EntityCapsManager manager) {
    capsManager = manager;
  }

  /** Updates the Entity Capabilities Verification String if EntityCaps is enabled */
  private void renewEntityCapsVersion() {
    if (capsManager != null && capsManager.entityCapsEnabled()) capsManager.updateLocalEntityCaps();
  }
}
コード例 #5
0
ファイル: XmppManager.java プロジェクト: hanzhankang/IMClient
/**
 * XMPP连接管理
 *
 * @author JerSuen
 */
public class XmppManager extends IXmppManager.Stub {

  private XMPPConnection connection;
  private String account, password;
  private ConnectionListener connectionListener;
  private RosterListener rosterListener;
  private IMService imService;
  private PacketListener messageListener;
  private Map<String, Chat> jidChats = Collections.synchronizedMap(new HashMap<String, Chat>());

  public XmppManager(
      ConnectionConfiguration config, String account, String password, IMService imService) {
    this(new XMPPTCPConnection(config), account, password, imService);
  }

  public XmppManager(
      XMPPConnection connection, String account, String password, IMService imService) {
    this.connection = connection;
    this.account = account;
    this.password = password;
    this.imService = imService;
  }

  /** 建立XMPP连接 */
  public boolean connect() throws RemoteException {
    // 已经连接
    if (connection.isConnected()) {
      return true;
    } else {
      try {
        // 开始连接
        connection.connect();
        if (connectionListener == null) {
          // 添加一个连接监听器
          connectionListener = new IMClientConnectListener();
        }
        connection.addConnectionListener(connectionListener);
        return true;
      } catch (SmackException e) {
        e.printStackTrace();
      } catch (IOException e) {
        e.printStackTrace();
      } catch (XMPPException e) {
        e.printStackTrace();
      }
    }
    return false;
  }

  /** 登陆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;
    }
  }

  /** 关闭XMPP连接 */
  public boolean disconnect() throws RemoteException {
    if (connection != null && connection.isConnected()) {
      connection.disconnect();
    }
    return true;
  }

  /** 发送消息 */
  public void sendMessage(String sessionJID, String sessionName, String message, String type)
      throws RemoteException {
    ChatManager chatManager = ChatManager.getInstanceFor(connection);
    Chat chat;
    // 查找Chat对策
    if (jidChats.containsKey(sessionJID)) {
      chat = jidChats.get(sessionJID);
      // 创建Chat
    } else {
      chat = chatManager.createChat(sessionJID, null);
      // 添加到集合
      jidChats.put(sessionJID, chat);
    }

    if (chat != null) {
      try {
        // 发送消息
        chat.sendMessage(message);

        // 保存聊天记录
        ContentValues values = new ContentValues();
        values.put(SMSProvider.SMSColumns.BODY, message);
        values.put(SMSProvider.SMSColumns.TYPE, type);
        values.put(SMSProvider.SMSColumns.TIME, System.currentTimeMillis());

        values.put(SMSProvider.SMSColumns.WHO_ID, IM.getString(IM.ACCOUNT_JID));

        values.put(SMSProvider.SMSColumns.SESSION_ID, sessionJID);
        values.put(SMSProvider.SMSColumns.SESSION_NAME, sessionName);

        imService.getContentResolver().insert(SMSProvider.SMS_URI, values);

      } catch (XMPPException e) {
        e.printStackTrace();
      } catch (SmackException.NotConnectedException e) {
        e.printStackTrace();
      }
    }
  }

  /** XMPP连接监听器 */
  private class IMClientConnectListener implements ConnectionListener {

    public void connected(XMPPConnection connection) {}

    public void authenticated(XMPPConnection connection) {}

    public void connectionClosed() {}

    public void connectionClosedOnError(Exception e) {}

    public void reconnectingIn(int seconds) {}

    public void reconnectionSuccessful() {}

    public void reconnectionFailed(Exception e) {}
  }

  /** 花名册监听器 */
  private class IMClientRosterListener implements RosterListener {

    public void entriesAdded(Collection<String> strings) {}

    public void entriesUpdated(Collection<String> strings) {}

    public void entriesDeleted(Collection<String> strings) {}

    public void presenceChanged(Presence presence) {}
  }

  /** 消息监听器 */
  private class MessageListener implements PacketListener {

    public void processPacket(Packet packet) throws SmackException.NotConnectedException {
      if (packet instanceof Message) {
        Message message = (Message) packet;
        // 聊天消息
        if (message.getType() == Message.Type.chat) {
          String whoAccountStr = StringUtils.parseBareAddress(message.getFrom());
          String whoNameStr = "";

          // 查询联系人的名称
          Cursor cursor =
              imService
                  .getContentResolver()
                  .query(
                      ContactsProvider.CONTACT_URI,
                      null,
                      ContactsProvider.ContactColumns.ACCOUNT + " = ?",
                      new String[] {whoAccountStr},
                      null);
          if (cursor != null && cursor.moveToFirst()) {
            cursor.moveToPosition(0);
            whoNameStr =
                cursor.getString(cursor.getColumnIndex(ContactsProvider.ContactColumns.NAME));
          }

          String bodyStr = message.getBody();
          String typeStr = "chat";

          // 插入消息
          ContentValues values = new ContentValues();
          values.put(SMSProvider.SMSColumns.BODY, bodyStr);
          values.put(SMSProvider.SMSColumns.TYPE, typeStr);
          values.put(SMSProvider.SMSColumns.TIME, System.currentTimeMillis());

          values.put(SMSProvider.SMSColumns.WHO_ID, whoAccountStr);

          values.put(SMSProvider.SMSColumns.SESSION_ID, whoAccountStr);
          values.put(SMSProvider.SMSColumns.SESSION_NAME, whoNameStr);

          imService.getContentResolver().insert(SMSProvider.SMS_URI, values);
        }
      }
    }
  }
}