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.Set;

  25. import org.jivesoftware.smack.Manager;
  26. import org.jivesoftware.smack.SmackException.NoResponseException;
  27. import org.jivesoftware.smack.SmackException.NotConnectedException;
  28. import org.jivesoftware.smack.XMPPConnection;
  29. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  30. import org.jivesoftware.smack.packet.IQ;
  31. import org.jivesoftware.smack.roster.packet.RosterPacket;

  33. import org.jxmpp.jid.Jid;

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

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

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

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

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

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

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

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

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

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

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

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

  219.     void addEntryLocal(RosterEntry entry) {
  220.         // Update the entry if it is already in the list
  221.         synchronized (entries) {
  222.             entries.remove(entry);
  223.             entries.add(entry);
  224.         }
  225.     }

  227.     void removeEntryLocal(RosterEntry entry) {
  228.          // Only remove the entry if it's in the entry list.
  229.         synchronized (entries) {
  230.             if (entries.contains(entry)) {
  231.                 entries.remove(entry);
  232.             }
  233.         }
  234.     }
  235. }
Created with JaCoCo 0.8.6.202009150832