Java RosterPacket类代码示例

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
/**
 * Removes a roster entry from the roster. The roster entry will also be removed from the
 * unfiled entries or from any roster group where it could belong and will no longer be part
 * of the roster. Note that this is an asynchronous call -- Smack must wait for the server
 * to send an updated subscription status.
 *
 * @param entry a roster entry.
 * @throws XMPPException if an XMPP error occurs.
 */
public void removeEntry(RosterEntry entry) throws XMPPException {
    // Only remove the entry if it's in the entry list.
    // The actual removal logic takes place in RosterPacketListenerprocess>>Packet(Packet)
    if (!entries.containsKey(entry.getUser())) {
        return;
    }
    RosterPacket packet = new RosterPacket();
    packet.setType(IQ.Type.SET);
    RosterPacket.Item item = RosterEntry.toRosterItem(entry);
    // Set the item type as REMOVE so that the server will delete the entry
    item.setItemType(RosterPacket.ItemType.remove);
    packet.addRosterItem(item);
    PacketCollector collector = connection.createPacketCollector(
            new PacketIDFilter(packet.getPacketID()));
    connection.sendPacket(packet);
    IQ response = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
    collector.cancel();
    if (response == null) {
        throw new XMPPException("No response from the server.");
    }
    // If the server replied with an error, throw an exception.
    else if (response.getType() == IQ.Type.ERROR) {
        throw new XMPPException(response.getError());
    }
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
public void processPacket(Packet packet) {
	if(packet instanceof IQ){
		IQ result = (IQ)packet;
		if(result.getType().equals(IQ.Type.RESULT) && result.getExtensions().isEmpty()){
			Collection<String> addedEntries = new ArrayList<String>();
            Collection<String> updatedEntries = new ArrayList<String>();
            Collection<String> deletedEntries = new ArrayList<String>();
            if(persistentStorage!=null){
            	for(RosterPacket.Item item : persistentStorage.getEntries()){
            		insertRosterItem(item,addedEntries,updatedEntries,deletedEntries);
            	}
            	synchronized (Roster.this) {
                    rosterInitialized = true;
                    Roster.this.notifyAll();
                }
            	fireRosterChangedEvent(addedEntries,updatedEntries,deletedEntries);
            }
		}
	}
	connection.removePacketListener(this);
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
/**
 * Reloads the entire roster from the server. This is an asynchronous operation,
 * which means the method will return immediately, and the roster will be
 * reloaded at a later point when the server responds to the reload request.
 * 
 * @throws IllegalStateException if connection is not logged in or logged in anonymously
 */
public void reload() {
    if (!connection.isAuthenticated()) {
        throw new IllegalStateException("Not logged in to server.");
    }
    if (connection.isAnonymous()) {
        throw new IllegalStateException("Anonymous users can't have a roster.");
    }

	RosterPacket packet = new RosterPacket();
	if(persistentStorage!=null){
		packet.setVersion(persistentStorage.getRosterVersion());
	}
	requestPacketId = packet.getPacketID();
	PacketFilter idFilter = new PacketIDFilter(requestPacketId);
	connection.addPacketListener(new RosterResultListener(), idFilter);
    connection.sendPacket(packet);
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
public void processPacket(Packet packet) {
    if (packet instanceof IQ) {
        IQ result = (IQ) packet;
        if (result.getType().equals(IQ.Type.RESULT) && result.getExtensions().isEmpty()) {
            Collection<String> addedEntries = new ArrayList<String>();
            Collection<String> updatedEntries = new ArrayList<String>();
            Collection<String> deletedEntries = new ArrayList<String>();
            if (persistentStorage != null) {
                for (RosterPacket.Item item : persistentStorage.getEntries()) {
                    insertRosterItem(item, addedEntries, updatedEntries, deletedEntries);
                }
            }
            fireRosterChangedEvent(addedEntries, updatedEntries, deletedEntries);
        }
    }
    connection.removePacketListener(this);
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
/**
 * Sends a subscription request to the username answers are handled by the method
 * 
 * @param uname
 * @param groupname
 */
protected void subscribeToUser(final String uname, final String groupname) {
    final Presence presence = new Presence(Presence.Type.subscribe);
    presence.setTo(uname + "@" + jabberServer);
    try {
        connection.sendPacket(presence);

        final RosterPacket rosterPacket = new RosterPacket();
        rosterPacket.setType(IQ.Type.SET);
        final RosterPacket.Item item = new RosterPacket.Item(uname + "@" + jabberServer, uname);
        item.addGroupName(groupname);
        item.setItemType(RosterPacket.ItemType.both);
        rosterPacket.addRosterItem(item);
        connection.sendPacket(rosterPacket);
    } catch (final RuntimeException e) {
        log.warn("Error while trying to send Instant Messaging packet.", e);
    }
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
/**
 * Reloads the entire roster from the server. This is an asynchronous
 * operation, which means the method will return immediately, and the roster
 * will be reloaded at a later point when the server responds to the reload
 * request.
 * 
 * @throws IllegalStateException
 *             if connection is not logged in or logged in anonymously
 */
public void reload() {
	if (!connection.isAuthenticated()) {
		throw new IllegalStateException("Not logged in to server.");
	}
	if (connection.isAnonymous()) {
		throw new IllegalStateException(
				"Anonymous users can't have a roster.");
	}

	RosterPacket packet = new RosterPacket();
	if (persistentStorage != null) {
		packet.setVersion(persistentStorage.getRosterVersion());
	}
	requestPacketId = packet.getPacketID();
	PacketFilter idFilter = new PacketIDFilter(requestPacketId);
	connection.addPacketListener(new RosterResultListener(), idFilter);
	connection.sendPacket(packet);
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
public void processPacket(Packet packet) {
	if (packet instanceof IQ) {
		IQ result = (IQ) packet;
		if (result.getType().equals(IQ.Type.RESULT)
				&& result.getExtensions().isEmpty()) {
			Collection<String> addedEntries = new ArrayList<String>();
			Collection<String> updatedEntries = new ArrayList<String>();
			Collection<String> deletedEntries = new ArrayList<String>();
			if (persistentStorage != null) {
				for (RosterPacket.Item item : persistentStorage
						.getEntries()) {
					insertRosterItem(item, addedEntries,
							updatedEntries, deletedEntries);
				}
			}
			synchronized (Roster.this) {
				rosterInitialized = true;
				Roster.this.notifyAll();
			}
			fireRosterChangedEvent(addedEntries, updatedEntries,
					deletedEntries);
		}
	}
	connection.removePacketListener(this);
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
@Override
public void processPacket(Packet packet) {
    RosterPacket p = (RosterPacket) packet;
    Intent i = new Intent(ACTION_ROSTER);
    i.putExtra(EXTRA_FROM, p.getFrom());
    i.putExtra(EXTRA_TO, p.getTo());
    // here we are not using() because Type is a class, not an enum
    i.putExtra(EXTRA_TYPE, p.getType().toString());
    i.putExtra(EXTRA_PACKET_ID, p.getPacketID());

    Collection<RosterPacket.Item> items = p.getRosterItems();
    String[] list = new String[items.size()];

    int index = 0;
    for (Iterator<RosterPacket.Item> iter = items.iterator(); iter.hasNext(); ) {
        RosterPacket.Item item = iter.next();
        list[index] = item.getUser();
        index++;
    }

    i.putExtra(EXTRA_JIDLIST, list);

    sendBroadcast(i);
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
public Buddy rosterEntry2Buddy(RosterEntry entry, String ownerJid, Context context, byte serviceId){
	if (entry == null){
		return null;
	}
	Buddy buddy = new Buddy(normalizeJID(entry.getUser()), ownerJid, XMPPApiConstants.PROTOCOL_NAME, serviceId);
	buddy.setName(entry.getName());
	buddy.setId(entry.getUser().hashCode());
	buddy.setGroupId((entry.getGroups() != null && entry.getGroups().size() > 0) ? entry.getGroups().iterator().next().getName() : ApiConstants.NO_GROUP_ID);
	//buddy.clientId = getClientId(entry.getUser());
	
	if (entry.getStatus()!=null && entry.getStatus().equals(RosterPacket.ItemStatus.SUBSCRIPTION_PENDING)){
		//buddy.visibility = Buddy.VIS_NOT_AUTHORIZED;
	}
	
	return buddy;
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
public void processPacket(Packet packet) {
	if(packet instanceof IQ){
		IQ result = (IQ)packet;
		if(result.getType().equals(IQ.Type.RESULT) && result.getExtensions().isEmpty()){
			Collection<String> addedEntries = new ArrayList<String>();
            Collection<String> updatedEntries = new ArrayList<String>();
            Collection<String> deletedEntries = new ArrayList<String>();
            if(persistentStorage!=null){
            	for(RosterPacket.Item item : persistentStorage.getEntries()){
            		insertRosterItem(item,addedEntries,updatedEntries,deletedEntries);
            	}
                          }
            synchronized (Roster.this) {
                rosterInitialized = true;
                Roster.this.notifyAll();
            }
            fireRosterChangedEvent(addedEntries,updatedEntries,deletedEntries);
	    }
	}
	connection.removePacketListener(this);
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
/**
 * Creates a new roster entry.
 *
 * @param user the user.
 * @param name the nickname for the entry.
 * @param type the subscription type.
 * @param status the subscription status (related to subscriptions pending to be approbed).
 * @param connection a connection to the XMPP server.
 */
RosterEntry(String user, String name, RosterPacket.ItemType type,
            RosterPacket.ItemStatus status, Roster roster, Connection connection) {
    this.user = user;
    this.name = name;
    this.type = type;
    this.status = status;
    this.roster = roster;
    this.connection = connection;
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
/**
 * Sets the name associated with this entry.
 *
 * @param name the name.
 */
public void setName(String name) {
    // Do nothing if the name hasn't changed.
    if (name != null && name.equals(this.name)) {
        return;
    }
    this.name = name;
    RosterPacket packet = new RosterPacket();
    packet.setType(IQ.Type.SET);
    packet.addRosterItem(toRosterItem(this));
    connection.sendPacket(packet);
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
static RosterPacket.Item toRosterItem(RosterEntry entry) {
    RosterPacket.Item item = new RosterPacket.Item(entry.getUser(), entry.getName());
    item.setItemType(entry.getType());
    item.setItemStatus(entry.getStatus());
    // Set the correct group names for the item.
    for (RosterGroup group : entry.getGroups()) {
        item.addGroupName(group.getName());
    }
    return item;
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
/**
 * Reloads the entire roster from the server. This is an asynchronous operation,
 * which means the method will return immediately, and the roster will be
 * reloaded at a later point when the server responds to the reload request.
 * 
 * @throws IllegalStateException if connection is not logged in or logged in anonymously
 */
public void reload() {
    if (!connection.isAuthenticated()) {
        throw new IllegalStateException("Not logged in to server.");
    }
    if (connection.isAnonymous()) {
        throw new IllegalStateException("Anonymous users can't have a roster.");
    }

    connection.sendPacket(new RosterPacket());
}
 

import org.jivesoftware.smack.packet.RosterPacket; //导入依赖的package包/类
/**
 * Creates a new roster entry and presence subscription. The server will asynchronously
 * update the roster with the subscription status.
 *
 * @param user   the user. (e.g. [email protected])
 * @param name   the nickname of the user.
 * @param groups the list of group names the entry will belong to, or <tt>null</tt> if the
 *               the roster entry won't belong to a group.
 * @throws XMPPException if an XMPP exception occurs.
 * @throws IllegalStateException if connection is not logged in or logged in anonymously
 */
public void createEntry(String user, String name, String[] groups) throws XMPPException {
    if (!connection.isAuthenticated()) {
        throw new IllegalStateException("Not logged in to server.");
    }
    if (connection.isAnonymous()) {
        throw new IllegalStateException("Anonymous users can't have a roster.");
    }

    // Create and send roster entry creation packet.
    RosterPacket rosterPacket = new RosterPacket();
    rosterPacket.setType(IQ.Type.SET);
    RosterPacket.Item item = new RosterPacket.Item(user, name);
    if (groups != null) {
        for (String group : groups) {
            if (group != null && group.trim().length() > 0) {
                item.addGroupName(group);
            }
        }
    }
    rosterPacket.addRosterItem(item);
    // Wait up to a certain number of seconds for a reply from the server.
    PacketCollector collector = connection.createPacketCollector(
            new PacketIDFilter(rosterPacket.getPacketID()));
    connection.sendPacket(rosterPacket);
    IQ response = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
    collector.cancel();
    if (response == null) {
        throw new XMPPException("No response from the server.");
    }
    // If the server replied with an error, throw an exception.
    else if (response.getType() == IQ.Type.ERROR) {
        throw new XMPPException(response.getError());
    }

    // Create a presence subscription packet and send.
    Presence presencePacket = new Presence(Presence.Type.subscribe);
    presencePacket.setTo(user);
    connection.sendPacket(presencePacket);
}