RosterGroup.java

  1. /**
  2.  *
  3.  * Copyright 2003-2007 Jive Software.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */

  18. package org.jivesoftware.smack.roster;

  20. import java.util.ArrayList;
  21. import java.util.LinkedHashSet;
  22. import java.util.List;
  23. import java.util.Locale;
  24. import java.util.Set;

  26. import org.jivesoftware.smack.PacketCollector;
  27. import org.jivesoftware.smack.XMPPConnection;
  28. import org.jivesoftware.smack.SmackException.NoResponseException;
  29. import org.jivesoftware.smack.SmackException.NotConnectedException;
  30. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  31. import org.jivesoftware.smack.packet.IQ;
  32. import org.jivesoftware.smack.roster.packet.RosterPacket;
  33. import org.jxmpp.util.XmppStringUtils;

  35. /**
  36.  * A group of roster entries.
  37.  *
  38.  * @see Roster#getGroup(String)
  39.  * @author Matt Tucker
  40.  */
  41. public class RosterGroup {

  43.     private final String name;
  44.     private final XMPPConnection connection;
  45.     private final Set<RosterEntry> entries;

  47.     /**
  48.      * Creates a new roster group instance.
  49.      *
  50.      * @param name the name of the group.
  51.      * @param connection the connection the group belongs to.
  52.      */
  53.     RosterGroup(String name, XMPPConnection connection) {
  54.         this.name = name;
  55.         this.connection = connection;
  56.         entries = new LinkedHashSet<RosterEntry>();
  57.     }

  59.     /**
  60.      * Returns the name of the group.
  61.      *
  62.      * @return the name of the group.
  63.      */
  64.     public String getName() {
  65.         return name;
  66.     }

  68.     /**
  69.      * Sets the name of the group. Changing the group's name is like moving all the group entries
  70.      * of the group to a new group specified by the new name. Since this group won't have entries 
  71.      * it will be removed from the roster. This means that all the references to this object will 
  72.      * be invalid and will need to be updated to the new group specified by the new name.
  73.      *
  74.      * @param name the name of the group.
  75.      * @throws NotConnectedException 
  76.      * @throws XMPPErrorException 
  77.      * @throws NoResponseException 
  78.      * @throws InterruptedException 
  79.      */
  80.     public void setName(String name) throws NotConnectedException, NoResponseException, XMPPErrorException, InterruptedException {
  81.         synchronized (entries) {
  82.             for (RosterEntry entry : entries) {
  83.                 RosterPacket packet = new RosterPacket();
  84.                 packet.setType(IQ.Type.set);
  85.                 RosterPacket.Item item = RosterEntry.toRosterItem(entry);
  86.                 item.removeGroupName(this.name);
  87.                 item.addGroupName(name);
  88.                 packet.addRosterItem(item);
  89.                 connection.createPacketCollectorAndSend(packet).nextResultOrThrow();
  90.             }
  91.         }
  92.     }

  94.     /**
  95.      * Returns the number of entries in the group.
  96.      *
  97.      * @return the number of entries in the group.
  98.      */
  99.     public int getEntryCount() {
  100.         synchronized (entries) {
  101.             return entries.size();
  102.         }
  103.     }

  105.     /**
  106.      * Returns an copied list of all entries in the group.
  107.      *
  108.      * @return all entries in the group.
  109.      */
  110.     public List<RosterEntry> getEntries() {
  111.         synchronized (entries) {
  112.             return new ArrayList<RosterEntry>(entries);
  113.         }
  114.     }

  116.     /**
  117.      * Returns the roster entry associated with the given XMPP address or
  118.      * <tt>null</tt> if the user is not an entry in the group.
  119.      *
  120.      * @param user the XMPP address of the user (eg "jsmith@example.com").
  121.      * @return the roster entry or <tt>null</tt> if it does not exist in the group.
  122.      */
  123.     public RosterEntry getEntry(String user) {
  124.         if (user == null) {
  125.             return null;
  126.         }
  127.         // Roster entries never include a resource so remove the resource
  128.         // if it's a part of the XMPP address.
  129.         user = XmppStringUtils.parseBareJid(user);
  130.         String userLowerCase = user.toLowerCase(Locale.US);
  131.         synchronized (entries) {
  132.             for (RosterEntry entry : entries) {
  133.                 if (entry.getUser().equals(userLowerCase)) {
  134.                     return entry;
  135.                 }
  136.             }
  137.         }
  138.         return null;
  139.     }

  141.     /**
  142.      * Returns true if the specified entry is part of this group.
  143.      *
  144.      * @param entry a roster entry.
  145.      * @return true if the entry is part of this group.
  146.      */
  147.     public boolean contains(RosterEntry entry) {
  148.         synchronized (entries) {
  149.             return entries.contains(entry);
  150.         }
  151.     }

  153.     /**
  154.      * Returns true if the specified XMPP address is an entry in this group.
  155.      *
  156.      * @param user the XMPP address of the user.
  157.      * @return true if the XMPP address is an entry in this group.
  158.      */
  159.     public boolean contains(String user) {
  160.         return getEntry(user) != null;
  161.     }

  163.     /**
  164.      * Adds a roster entry to this group. If the entry was unfiled then it will be removed from 
  165.      * the unfiled list and will be added to this group.
  166.      * Note that this is a synchronous call -- Smack must wait for the server
  167.      * to receive the updated roster.
  168.      *
  169.      * @param entry a roster entry.
  170.      * @throws XMPPErrorException if an error occured while trying to add the entry to the group.
  171.      * @throws NoResponseException if there was no response from the server.
  172.      * @throws NotConnectedException 
  173.      * @throws InterruptedException 
  174.      */
  175.     public void addEntry(RosterEntry entry) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  176.         PacketCollector collector = null;
  177.         // Only add the entry if it isn't already in the list.
  178.         synchronized (entries) {
  179.             if (!entries.contains(entry)) {
  180.                 RosterPacket packet = new RosterPacket();
  181.                 packet.setType(IQ.Type.set);
  182.                 RosterPacket.Item item = RosterEntry.toRosterItem(entry);
  183.                 item.addGroupName(getName());
  184.                 packet.addRosterItem(item);
  185.                 // Wait up to a certain number of seconds for a reply from the server.
  186.                 collector = connection.createPacketCollectorAndSend(packet);
  187.             }
  188.         }
  189.         if (collector != null) {
  190.             collector.nextResultOrThrow();
  191.         }
  192.     }

  194.     /**
  195.      * Removes a roster entry from this group. If the entry does not belong to any other group 
  196.      * then it will be considered as unfiled, therefore it will be added to the list of unfiled 
  197.      * entries.
  198.      * Note that this is a synchronous call -- Smack must wait for the server
  199.      * to receive the updated roster.
  200.      *
  201.      * @param entry a roster entry.
  202.      * @throws XMPPErrorException if an error occurred while trying to remove the entry from the group. 
  203.      * @throws NoResponseException if there was no response from the server.
  204.      * @throws NotConnectedException 
  205.      * @throws InterruptedException 
  206.      */
  207.     public void removeEntry(RosterEntry entry) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  208.         PacketCollector collector = null;
  209.         // Only remove the entry if it's in the entry list.
  210.         // Remove the entry locally, if we wait for RosterPacketListenerprocess>>Packet(Packet)
  211.         // to take place the entry will exist in the group until a packet is received from the 
  212.         // server.
  213.         synchronized (entries) {
  214.             if (entries.contains(entry)) {
  215.                 RosterPacket packet = new RosterPacket();
  216.                 packet.setType(IQ.Type.set);
  217.                 RosterPacket.Item item = RosterEntry.toRosterItem(entry);
  218.                 item.removeGroupName(this.getName());
  219.                 packet.addRosterItem(item);
  220.                 // Wait up to a certain number of seconds for a reply from the server.
  221.                 collector = connection.createPacketCollectorAndSend(packet);
  222.             }
  223.         }
  224.         if (collector != null) {
  225.             collector.nextResultOrThrow();
  226.         }
  227.     }

  229.     void addEntryLocal(RosterEntry entry) {
  230.         // Update the entry if it is already in the list
  231.         synchronized (entries) {
  232.             entries.remove(entry);
  233.             entries.add(entry);
  234.         }
  235.     }

  237.     void removeEntryLocal(RosterEntry entry) {
  238.          // Only remove the entry if it's in the entry list.
  239.         synchronized (entries) {
  240.             if (entries.contains(entry)) {
  241.                 entries.remove(entry);
  242.             }
  243.         }
  244.     }
  245. }
Created with JaCoCo 0.7.4.201502262128