package asmack.org.jivesoftware.smackx.muc;
import asmack.org.jivesoftware.smack.Chat;
import asmack.org.jivesoftware.smack.Connection;
import asmack.org.jivesoftware.smack.ConnectionCreationListener;
import asmack.org.jivesoftware.smack.ConnectionListener;
import asmack.org.jivesoftware.smack.MessageListener;
import asmack.org.jivesoftware.smack.PacketCollector;
import asmack.org.jivesoftware.smack.PacketInterceptor;
import asmack.org.jivesoftware.smack.PacketListener;
import asmack.org.jivesoftware.smack.SmackConfiguration;
import asmack.org.jivesoftware.smack.XMPPException;
import asmack.org.jivesoftware.smack.filter.AndFilter;
import asmack.org.jivesoftware.smack.filter.FromMatchesFilter;
import asmack.org.jivesoftware.smack.filter.MessageTypeFilter;
import asmack.org.jivesoftware.smack.filter.PacketExtensionFilter;
import asmack.org.jivesoftware.smack.filter.PacketFilter;
import asmack.org.jivesoftware.smack.filter.PacketIDFilter;
import asmack.org.jivesoftware.smack.filter.PacketTypeFilter;
import asmack.org.jivesoftware.smack.packet.IQ;
import asmack.org.jivesoftware.smack.packet.Message;
import asmack.org.jivesoftware.smack.packet.Packet;
import asmack.org.jivesoftware.smack.packet.Presence;
import asmack.org.jivesoftware.smack.packet.Registration;
import asmack.org.jivesoftware.smack.util.StringUtils;
import asmack.org.jivesoftware.smackx.Form;
import asmack.org.jivesoftware.smackx.GroupChatInvitation;
import asmack.org.jivesoftware.smackx.NodeInformationProvider;
import asmack.org.jivesoftware.smackx.ServiceDiscoveryManager;
import asmack.org.jivesoftware.smackx.packet.DiscoverInfo;
import asmack.org.jivesoftware.smackx.packet.DiscoverItems;
import asmack.org.jivesoftware.smackx.packet.MUCAdmin;
import asmack.org.jivesoftware.smackx.packet.MUCInitialPresence;
import asmack.org.jivesoftware.smackx.packet.MUCOwner;
import asmack.org.jivesoftware.smackx.packet.MUCUser;
import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;
public class MultiUserChat {
private static final String discoNamespace = "http://jabber.org/protocol/muc";
private static final String discoNode = "http://jabber.org/protocol/muc#rooms";
private static Map<Connection, List<String>> joinedRooms = new WeakHashMap();
private Connection connection;
private List<PacketListener> connectionListeners = new ArrayList();
private final List<InvitationRejectionListener> invitationRejectionListeners = new ArrayList();
private boolean joined = false;
private ConnectionDetachedPacketCollector messageCollector;
private PacketFilter messageFilter;
private String nickname = null;
private Map<String, Presence> occupantsMap = new ConcurrentHashMap();
private final List<ParticipantStatusListener> participantStatusListeners = new ArrayList();
private PacketFilter presenceFilter;
private List<PacketInterceptor> presenceInterceptors = new ArrayList();
private String room;
private RoomListenerMultiplexor roomListenerMultiplexor;
private String subject;
private final List<SubjectUpdatedListener> subjectUpdatedListeners = new ArrayList();
private final List<UserStatusListener> userStatusListeners = new ArrayList();
private static class InvitationsMonitor implements ConnectionListener {
private static final Map<Connection, WeakReference<InvitationsMonitor>> monitors = new WeakHashMap();
private Connection connection;
private PacketFilter invitationFilter;
private PacketListener invitationPacketListener;
private final List<InvitationListener> invitationsListeners = new ArrayList();
private InvitationsMonitor(Connection connection2) {
this.connection = connection2;
}
private void cancel() {
this.connection.removePacketListener(this.invitationPacketListener);
this.connection.removeConnectionListener(this);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void fireInvitationListeners(String str, String str2, String str3, String str4, Message message) {
InvitationListener[] invitationListenerArr;
synchronized (this.invitationsListeners) {
invitationListenerArr = new InvitationListener[this.invitationsListeners.size()];
this.invitationsListeners.toArray(invitationListenerArr);
}
for (InvitationListener invitationListener : invitationListenerArr) {
invitationListener.invitationReceived(this.connection, str, str2, str3, str4, message);
}
}
public static InvitationsMonitor getInvitationsMonitor(Connection connection2) {
InvitationsMonitor invitationsMonitor;
synchronized (monitors) {
if (!monitors.containsKey(connection2)) {
monitors.put(connection2, new WeakReference<>(new InvitationsMonitor(connection2)));
}
invitationsMonitor = monitors.get(connection2).get();
}
return invitationsMonitor;
}
private void init() {
this.invitationFilter = new PacketExtensionFilter(GroupChatInvitation.ELEMENT_NAME, "http://jabber.org/protocol/muc#user");
this.invitationPacketListener = new PacketListener() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.InvitationsMonitor.AnonymousClass1 */
@Override // asmack.org.jivesoftware.smack.PacketListener
public void processPacket(Packet packet) {
MUCUser mUCUser = (MUCUser) packet.getExtension(GroupChatInvitation.ELEMENT_NAME, "http://jabber.org/protocol/muc#user");
if (mUCUser.getInvite() != null) {
Message message = (Message) packet;
if (message.getType() != Message.Type.error) {
InvitationsMonitor.this.fireInvitationListeners(packet.getFrom(), mUCUser.getInvite().getFrom(), mUCUser.getInvite().getReason(), mUCUser.getPassword(), message);
}
}
}
};
this.connection.addPacketListener(this.invitationPacketListener, this.invitationFilter);
this.connection.addConnectionListener(this);
}
public void addInvitationListener(InvitationListener invitationListener) {
synchronized (this.invitationsListeners) {
if (this.invitationsListeners.size() == 0) {
init();
}
if (!this.invitationsListeners.contains(invitationListener)) {
this.invitationsListeners.add(invitationListener);
}
}
}
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void connectionClosed() {
cancel();
}
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void connectionClosedOnError(Exception exc) {
}
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void reconnectingIn(int i) {
}
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void reconnectionFailed(Exception exc) {
}
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void reconnectionSuccessful() {
}
public void removeInvitationListener(InvitationListener invitationListener) {
synchronized (this.invitationsListeners) {
if (this.invitationsListeners.contains(invitationListener)) {
this.invitationsListeners.remove(invitationListener);
}
if (this.invitationsListeners.size() == 0) {
cancel();
}
}
}
}
static {
Connection.addConnectionCreationListener(new ConnectionCreationListener() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass1 */
@Override // asmack.org.jivesoftware.smack.ConnectionCreationListener
public void connectionCreated(final Connection connection) {
ServiceDiscoveryManager.getInstanceFor(connection).addFeature(MultiUserChat.discoNamespace);
ServiceDiscoveryManager.getInstanceFor(connection).setNodeInformationProvider(MultiUserChat.discoNode, new NodeInformationProvider() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass1.AnonymousClass1 */
@Override // asmack.org.jivesoftware.smackx.NodeInformationProvider
public List<String> getNodeFeatures() {
return null;
}
@Override // asmack.org.jivesoftware.smackx.NodeInformationProvider
public List<DiscoverInfo.Identity> getNodeIdentities() {
return null;
}
@Override // asmack.org.jivesoftware.smackx.NodeInformationProvider
public List<DiscoverItems.Item> getNodeItems() {
ArrayList arrayList = new ArrayList();
Iterator joinedRooms = MultiUserChat.getJoinedRooms(connection);
while (joinedRooms.hasNext()) {
arrayList.add(new DiscoverItems.Item((String) joinedRooms.next()));
}
return arrayList;
}
});
}
});
}
public MultiUserChat(Connection connection2, String str) {
this.connection = connection2;
this.room = str.toLowerCase();
init(false);
}
public MultiUserChat(Connection connection2, String str, boolean z) {
this.connection = connection2;
this.room = str.toLowerCase();
init(z);
}
public static void addInvitationListener(Connection connection2, InvitationListener invitationListener) {
InvitationsMonitor.getInvitationsMonitor(connection2).addInvitationListener(invitationListener);
}
private void changeAffiliationByAdmin(String str, String str2, String str3) throws XMPPException {
MUCAdmin mUCAdmin = new MUCAdmin();
mUCAdmin.setTo(this.room);
mUCAdmin.setType(IQ.Type.SET);
MUCAdmin.Item item = new MUCAdmin.Item(str2, null);
item.setJid(str);
item.setReason(str3);
mUCAdmin.addItem(item);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCAdmin.getPacketID()));
this.connection.sendPacket(mUCAdmin);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getError() != null) {
throw new XMPPException(iq.getError());
}
}
private void changeAffiliationByAdmin(Collection<String> collection, String str) throws XMPPException {
MUCAdmin mUCAdmin = new MUCAdmin();
mUCAdmin.setTo(this.room);
mUCAdmin.setType(IQ.Type.SET);
for (String str2 : collection) {
MUCAdmin.Item item = new MUCAdmin.Item(str, null);
item.setJid(str2);
mUCAdmin.addItem(item);
}
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCAdmin.getPacketID()));
this.connection.sendPacket(mUCAdmin);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getError() != null) {
throw new XMPPException(iq.getError());
}
}
private void changeAffiliationByOwner(String str, String str2) throws XMPPException {
MUCOwner mUCOwner = new MUCOwner();
mUCOwner.setTo(this.room);
mUCOwner.setType(IQ.Type.SET);
MUCOwner.Item item = new MUCOwner.Item(str2);
item.setJid(str);
mUCOwner.addItem(item);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCOwner.getPacketID()));
this.connection.sendPacket(mUCOwner);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getError() != null) {
throw new XMPPException(iq.getError());
}
}
private void changeAffiliationByOwner(Collection<String> collection, String str) throws XMPPException {
MUCOwner mUCOwner = new MUCOwner();
mUCOwner.setTo(this.room);
mUCOwner.setType(IQ.Type.SET);
for (String str2 : collection) {
MUCOwner.Item item = new MUCOwner.Item(str);
item.setJid(str2);
mUCOwner.addItem(item);
}
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCOwner.getPacketID()));
this.connection.sendPacket(mUCOwner);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getError() != null) {
throw new XMPPException(iq.getError());
}
}
private void changeRole(String str, String str2, String str3) throws XMPPException {
MUCAdmin mUCAdmin = new MUCAdmin();
mUCAdmin.setTo(this.room);
mUCAdmin.setType(IQ.Type.SET);
MUCAdmin.Item item = new MUCAdmin.Item(null, str2);
item.setNick(str);
item.setReason(str3);
mUCAdmin.addItem(item);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCAdmin.getPacketID()));
this.connection.sendPacket(mUCAdmin);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getError() != null) {
throw new XMPPException(iq.getError());
}
}
private void changeRole(Collection<String> collection, String str) throws XMPPException {
MUCAdmin mUCAdmin = new MUCAdmin();
mUCAdmin.setTo(this.room);
mUCAdmin.setType(IQ.Type.SET);
for (String str2 : collection) {
MUCAdmin.Item item = new MUCAdmin.Item(null, str);
item.setNick(str2);
mUCAdmin.addItem(item);
}
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCAdmin.getPacketID()));
this.connection.sendPacket(mUCAdmin);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getError() != null) {
throw new XMPPException(iq.getError());
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
/* JADX WARNING: Removed duplicated region for block: B:25:0x005d */
/* JADX WARNING: Removed duplicated region for block: B:34:0x007f */
/* JADX WARNING: Removed duplicated region for block: B:41:0x0096 */
/* JADX WARNING: Removed duplicated region for block: B:48:? A[ADDED_TO_REGION, RETURN, SYNTHETIC] */
private void checkAffiliationModifications(String str, String str2, boolean z, String str3) {
String str4;
ArrayList arrayList;
String str5;
ArrayList arrayList2;
if ("owner".equals(str) && !"owner".equals(str2)) {
str5 = "ownershipRevoked";
if (!z) {
arrayList2 = new ArrayList();
arrayList2.add(str3);
fireParticipantStatusListeners(str5, arrayList2);
if ("owner".equals(str)) {
}
if ("admin".equals(str)) {
}
if (!"member".equals(str)) {
}
}
} else if (!"admin".equals(str) || "admin".equals(str2)) {
if ("member".equals(str) && !"member".equals(str2)) {
str5 = "membershipRevoked";
if (!z) {
arrayList2 = new ArrayList();
arrayList2.add(str3);
fireParticipantStatusListeners(str5, arrayList2);
}
}
if ("owner".equals(str) && "owner".equals(str2)) {
str4 = "ownershipGranted";
if (!z) {
arrayList = new ArrayList();
arrayList.add(str3);
fireParticipantStatusListeners(str4, arrayList);
return;
}
} else if ("admin".equals(str) && "admin".equals(str2)) {
str4 = "adminGranted";
if (!z) {
arrayList = new ArrayList();
arrayList.add(str3);
fireParticipantStatusListeners(str4, arrayList);
return;
}
} else if (!"member".equals(str) && "member".equals(str2)) {
str4 = "membershipGranted";
if (!z) {
arrayList = new ArrayList();
arrayList.add(str3);
fireParticipantStatusListeners(str4, arrayList);
return;
}
} else {
return;
}
fireUserStatusListeners(str4, new Object[0]);
return;
} else {
str5 = "adminRevoked";
if (!z) {
arrayList2 = new ArrayList();
arrayList2.add(str3);
fireParticipantStatusListeners(str5, arrayList2);
if ("owner".equals(str)) {
}
if ("admin".equals(str)) {
}
if (!"member".equals(str)) {
return;
}
return;
}
}
fireUserStatusListeners(str5, new Object[0]);
if ("owner".equals(str)) {
}
if ("admin".equals(str)) {
}
if (!"member".equals(str)) {
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void checkPresenceCode(String str, boolean z, MUCUser mUCUser, String str2) {
String str3;
ArrayList arrayList;
Object[] objArr;
if ("307".equals(str)) {
str3 = "kicked";
if (z) {
this.joined = false;
objArr = new Object[]{mUCUser.getItem().getActor(), mUCUser.getItem().getReason()};
} else {
arrayList = new ArrayList();
arrayList.add(str2);
arrayList.add(mUCUser.getItem().getActor());
arrayList.add(mUCUser.getItem().getReason());
fireParticipantStatusListeners(str3, arrayList);
return;
}
} else if ("301".equals(str)) {
str3 = "banned";
if (z) {
this.joined = false;
objArr = new Object[]{mUCUser.getItem().getActor(), mUCUser.getItem().getReason()};
} else {
arrayList = new ArrayList();
arrayList.add(str2);
arrayList.add(mUCUser.getItem().getActor());
arrayList.add(mUCUser.getItem().getReason());
fireParticipantStatusListeners(str3, arrayList);
return;
}
} else if ("321".equals(str)) {
if (z) {
this.joined = false;
fireUserStatusListeners("membershipRevoked", new Object[0]);
this.occupantsMap.clear();
this.nickname = null;
userHasLeft();
}
return;
} else if ("303".equals(str)) {
ArrayList arrayList2 = new ArrayList();
arrayList2.add(str2);
arrayList2.add(mUCUser.getItem().getNick());
fireParticipantStatusListeners("nicknameChanged", arrayList2);
return;
} else {
return;
}
fireUserStatusListeners(str3, objArr);
this.occupantsMap.clear();
this.nickname = null;
userHasLeft();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void checkRoleModifications(String str, String str2, boolean z, String str3) {
String str4;
ArrayList arrayList;
if (("visitor".equals(str) || "none".equals(str)) && "participant".equals(str2)) {
if (z) {
fireUserStatusListeners("voiceGranted", new Object[0]);
} else {
ArrayList arrayList2 = new ArrayList();
arrayList2.add(str3);
fireParticipantStatusListeners("voiceGranted", arrayList2);
}
} else if ("participant".equals(str) && ("visitor".equals(str2) || "none".equals(str2))) {
if (z) {
fireUserStatusListeners("voiceRevoked", new Object[0]);
} else {
ArrayList arrayList3 = new ArrayList();
arrayList3.add(str3);
fireParticipantStatusListeners("voiceRevoked", arrayList3);
}
}
if (!"moderator".equals(str) && "moderator".equals(str2)) {
if ("visitor".equals(str) || "none".equals(str)) {
if (z) {
fireUserStatusListeners("voiceGranted", new Object[0]);
} else {
ArrayList arrayList4 = new ArrayList();
arrayList4.add(str3);
fireParticipantStatusListeners("voiceGranted", arrayList4);
}
}
str4 = "moderatorGranted";
if (!z) {
arrayList = new ArrayList();
arrayList.add(str3);
fireParticipantStatusListeners(str4, arrayList);
return;
}
} else if ("moderator".equals(str) && !"moderator".equals(str2)) {
if ("visitor".equals(str2) || "none".equals(str2)) {
if (z) {
fireUserStatusListeners("voiceRevoked", new Object[0]);
} else {
ArrayList arrayList5 = new ArrayList();
arrayList5.add(str3);
fireParticipantStatusListeners("voiceRevoked", arrayList5);
}
}
str4 = "moderatorRevoked";
if (!z) {
arrayList = new ArrayList();
arrayList.add(str3);
fireParticipantStatusListeners(str4, arrayList);
return;
}
} else {
return;
}
fireUserStatusListeners(str4, new Object[0]);
}
public static void decline(Connection connection2, String str, String str2, String str3) {
Packet message = new Message(str);
MUCUser mUCUser = new MUCUser();
MUCUser.Decline decline = new MUCUser.Decline();
decline.setTo(str2);
decline.setReason(str3);
mUCUser.setDecline(decline);
message.addExtension(mUCUser);
connection2.sendPacket(message);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void fireInvitationRejectionListeners(String str, String str2) {
InvitationRejectionListener[] invitationRejectionListenerArr;
synchronized (this.invitationRejectionListeners) {
invitationRejectionListenerArr = new InvitationRejectionListener[this.invitationRejectionListeners.size()];
this.invitationRejectionListeners.toArray(invitationRejectionListenerArr);
}
for (InvitationRejectionListener invitationRejectionListener : invitationRejectionListenerArr) {
invitationRejectionListener.invitationDeclined(str, str2);
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void fireParticipantStatusListeners(String str, List<String> list) {
ParticipantStatusListener[] participantStatusListenerArr;
synchronized (this.participantStatusListeners) {
participantStatusListenerArr = new ParticipantStatusListener[this.participantStatusListeners.size()];
this.participantStatusListeners.toArray(participantStatusListenerArr);
}
try {
Class[] clsArr = new Class[list.size()];
for (int i = 0; i < list.size(); i++) {
clsArr[i] = String.class;
}
Method declaredMethod = ParticipantStatusListener.class.getDeclaredMethod(str, clsArr);
for (ParticipantStatusListener participantStatusListener : participantStatusListenerArr) {
declaredMethod.invoke(participantStatusListener, list.toArray());
}
} catch (NoSuchMethodException e2) {
e2.printStackTrace();
} catch (InvocationTargetException e3) {
e3.printStackTrace();
} catch (IllegalAccessException e4) {
e4.printStackTrace();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void fireSubjectUpdatedListeners(String str, String str2) {
SubjectUpdatedListener[] subjectUpdatedListenerArr;
synchronized (this.subjectUpdatedListeners) {
subjectUpdatedListenerArr = new SubjectUpdatedListener[this.subjectUpdatedListeners.size()];
this.subjectUpdatedListeners.toArray(subjectUpdatedListenerArr);
}
for (SubjectUpdatedListener subjectUpdatedListener : subjectUpdatedListenerArr) {
subjectUpdatedListener.subjectUpdated(str, str2);
}
}
private void fireUserStatusListeners(String str, Object[] objArr) {
UserStatusListener[] userStatusListenerArr;
synchronized (this.userStatusListeners) {
userStatusListenerArr = new UserStatusListener[this.userStatusListeners.size()];
this.userStatusListeners.toArray(userStatusListenerArr);
}
Class[] clsArr = new Class[objArr.length];
for (int i = 0; i < objArr.length; i++) {
clsArr[i] = objArr[i].getClass();
}
try {
Method declaredMethod = UserStatusListener.class.getDeclaredMethod(str, clsArr);
for (UserStatusListener userStatusListener : userStatusListenerArr) {
declaredMethod.invoke(userStatusListener, objArr);
}
} catch (NoSuchMethodException e2) {
e2.printStackTrace();
} catch (InvocationTargetException e3) {
e3.printStackTrace();
} catch (IllegalAccessException e4) {
e4.printStackTrace();
}
}
private Collection<Affiliate> getAffiliatesByAdmin(String str) throws XMPPException {
MUCAdmin mUCAdmin = new MUCAdmin();
mUCAdmin.setTo(this.room);
mUCAdmin.setType(IQ.Type.GET);
mUCAdmin.addItem(new MUCAdmin.Item(str, null));
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCAdmin.getPacketID()));
this.connection.sendPacket(mUCAdmin);
MUCAdmin mUCAdmin2 = (MUCAdmin) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (mUCAdmin2 == null) {
throw new XMPPException("No response from server.");
} else if (mUCAdmin2.getError() == null) {
ArrayList arrayList = new ArrayList();
Iterator items = mUCAdmin2.getItems();
while (items.hasNext()) {
arrayList.add(new Affiliate((MUCAdmin.Item) items.next()));
}
return arrayList;
} else {
throw new XMPPException(mUCAdmin2.getError());
}
}
private Collection<Affiliate> getAffiliatesByOwner(String str) throws XMPPException {
MUCOwner mUCOwner = new MUCOwner();
mUCOwner.setTo(this.room);
mUCOwner.setType(IQ.Type.GET);
mUCOwner.addItem(new MUCOwner.Item(str));
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCOwner.getPacketID()));
this.connection.sendPacket(mUCOwner);
MUCOwner mUCOwner2 = (MUCOwner) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (mUCOwner2 == null) {
throw new XMPPException("No response from server.");
} else if (mUCOwner2.getError() == null) {
ArrayList arrayList = new ArrayList();
Iterator items = mUCOwner2.getItems();
while (items.hasNext()) {
arrayList.add(new Affiliate((MUCOwner.Item) items.next()));
}
return arrayList;
} else {
throw new XMPPException(mUCOwner2.getError());
}
}
public static Collection<HostedRoom> getHostedRooms(Connection connection2, String str) throws XMPPException {
ArrayList arrayList = new ArrayList();
Iterator<DiscoverItems.Item> items = ServiceDiscoveryManager.getInstanceFor(connection2).discoverItems(str).getItems();
while (items.hasNext()) {
arrayList.add(new HostedRoom(items.next()));
}
return arrayList;
}
/* access modifiers changed from: private */
public static Iterator<String> getJoinedRooms(Connection connection2) {
List<String> list = joinedRooms.get(connection2);
return list != null ? list.iterator() : new ArrayList().iterator();
}
public static Iterator<String> getJoinedRooms(Connection connection2, String str) {
try {
ArrayList arrayList = new ArrayList();
Iterator<DiscoverItems.Item> items = ServiceDiscoveryManager.getInstanceFor(connection2).discoverItems(str, discoNode).getItems();
while (items.hasNext()) {
arrayList.add(items.next().getEntityID());
}
return arrayList.iterator();
} catch (XMPPException e2) {
e2.printStackTrace();
return new ArrayList().iterator();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private MUCUser getMUCUserExtension(Packet packet) {
if (packet != null) {
return (MUCUser) packet.getExtension(GroupChatInvitation.ELEMENT_NAME, "http://jabber.org/protocol/muc#user");
}
return null;
}
private Collection<Occupant> getOccupants(String str) throws XMPPException {
MUCAdmin mUCAdmin = new MUCAdmin();
mUCAdmin.setTo(this.room);
mUCAdmin.setType(IQ.Type.GET);
mUCAdmin.addItem(new MUCAdmin.Item(null, str));
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCAdmin.getPacketID()));
this.connection.sendPacket(mUCAdmin);
MUCAdmin mUCAdmin2 = (MUCAdmin) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (mUCAdmin2 == null) {
throw new XMPPException("No response from server.");
} else if (mUCAdmin2.getError() == null) {
ArrayList arrayList = new ArrayList();
Iterator items = mUCAdmin2.getItems();
while (items.hasNext()) {
arrayList.add(new Occupant((MUCAdmin.Item) items.next()));
}
return arrayList;
} else {
throw new XMPPException(mUCAdmin2.getError());
}
}
public static RoomInfo getRoomInfo(Connection connection2, String str) throws XMPPException {
return new RoomInfo(ServiceDiscoveryManager.getInstanceFor(connection2).discoverInfo(str));
}
public static Collection<String> getServiceNames(Connection connection2) throws XMPPException {
ArrayList arrayList = new ArrayList();
ServiceDiscoveryManager instanceFor = ServiceDiscoveryManager.getInstanceFor(connection2);
Iterator<DiscoverItems.Item> items = instanceFor.discoverItems(connection2.getServiceName()).getItems();
while (items.hasNext()) {
DiscoverItems.Item next = items.next();
try {
if (instanceFor.discoverInfo(next.getEntityID()).containsFeature(discoNamespace)) {
arrayList.add(next.getEntityID());
}
} catch (XMPPException unused) {
}
}
return arrayList;
}
private void init(boolean z) {
if (z) {
AnonymousClass4 r8 = new PacketFilter() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass4 */
@Override // asmack.org.jivesoftware.smack.filter.PacketFilter
public boolean accept(Packet packet) {
if (packet.getFrom() == null) {
return false;
}
return MultiUserChat.this.room.equals(StringUtils.parseBareAddress(packet.getFrom()).toLowerCase());
}
};
this.messageFilter = new AndFilter(r8, new MessageTypeFilter(Message.Type.groupchat));
this.messageFilter = new AndFilter(this.messageFilter, new PacketFilter() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass5 */
@Override // asmack.org.jivesoftware.smack.filter.PacketFilter
public boolean accept(Packet packet) {
return ((Message) packet).getBody() != null;
}
});
this.presenceFilter = new AndFilter(r8, new PacketTypeFilter(Presence.class));
this.messageCollector = new ConnectionDetachedPacketCollector();
return;
}
this.messageFilter = new AndFilter(new FromMatchesFilter(this.room), new MessageTypeFilter(Message.Type.groupchat));
this.messageFilter = new AndFilter(this.messageFilter, new PacketFilter() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass6 */
@Override // asmack.org.jivesoftware.smack.filter.PacketFilter
public boolean accept(Packet packet) {
return ((Message) packet).getBody() != null;
}
});
this.presenceFilter = new AndFilter(new FromMatchesFilter(this.room), new PacketTypeFilter(Presence.class));
this.messageCollector = new ConnectionDetachedPacketCollector();
initMultiplexor();
}
public static boolean isServiceEnabled(Connection connection2, String str) {
try {
return ServiceDiscoveryManager.getInstanceFor(connection2).discoverInfo(str).containsFeature(discoNamespace);
} catch (XMPPException e2) {
e2.printStackTrace();
return false;
}
}
public static void removeInvitationListener(Connection connection2, InvitationListener invitationListener) {
InvitationsMonitor.getInvitationsMonitor(connection2).removeInvitationListener(invitationListener);
}
private synchronized void userHasJoined() {
List<String> list = joinedRooms.get(this.connection);
if (list == null) {
list = new ArrayList<>();
joinedRooms.put(this.connection, list);
}
list.clear();
list.add(this.room);
}
private synchronized void userHasLeft() {
List<String> list = joinedRooms.get(this.connection);
if (list != null) {
list.remove(this.room);
}
}
public void addInvitationRejectionListener(InvitationRejectionListener invitationRejectionListener) {
synchronized (this.invitationRejectionListeners) {
if (!this.invitationRejectionListeners.contains(invitationRejectionListener)) {
this.invitationRejectionListeners.add(invitationRejectionListener);
}
}
}
public void addMessageListener(PacketListener packetListener) {
this.connection.addPacketListener(packetListener, this.messageFilter);
this.connectionListeners.add(packetListener);
}
public void addParticipantListener(PacketListener packetListener) {
this.connection.addPacketListener(packetListener, this.presenceFilter);
this.connectionListeners.add(packetListener);
}
public void addParticipantStatusListener(ParticipantStatusListener participantStatusListener) {
synchronized (this.participantStatusListeners) {
if (!this.participantStatusListeners.contains(participantStatusListener)) {
this.participantStatusListeners.add(participantStatusListener);
}
}
}
public void addPresenceInterceptor(PacketInterceptor packetInterceptor) {
this.presenceInterceptors.add(packetInterceptor);
}
public void addSubjectUpdatedListener(SubjectUpdatedListener subjectUpdatedListener) {
synchronized (this.subjectUpdatedListeners) {
if (!this.subjectUpdatedListeners.contains(subjectUpdatedListener)) {
this.subjectUpdatedListeners.add(subjectUpdatedListener);
}
}
}
public void addUserStatusListener(UserStatusListener userStatusListener) {
synchronized (this.userStatusListeners) {
if (!this.userStatusListeners.contains(userStatusListener)) {
this.userStatusListeners.add(userStatusListener);
}
}
}
public void banUser(String str, String str2) throws XMPPException {
changeAffiliationByAdmin(str, "outcast", str2);
}
public void banUsers(Collection<String> collection) throws XMPPException {
changeAffiliationByAdmin(collection, "outcast");
}
public void changeAvailabilityStatus(String str, Presence.Mode mode) {
String str2 = this.nickname;
if (str2 == null || str2.equals("")) {
throw new IllegalArgumentException("Nickname must not be null or blank.");
} else if (this.joined) {
Presence presence = new Presence(Presence.Type.available);
presence.setStatus(str);
presence.setMode(mode);
presence.setTo(String.valueOf(this.room) + "/" + this.nickname);
for (PacketInterceptor packetInterceptor : this.presenceInterceptors) {
packetInterceptor.interceptPacket(presence);
}
this.connection.sendPacket(presence);
} else {
throw new IllegalStateException("Must be logged into the room to change the availability status.");
}
}
public void changeNickname(String str) throws XMPPException {
if (str == null || str.equals("")) {
throw new IllegalArgumentException("Nickname must not be null or blank.");
} else if (this.joined) {
Presence presence = new Presence(Presence.Type.available);
presence.setTo(String.valueOf(this.room) + "/" + str);
for (PacketInterceptor packetInterceptor : this.presenceInterceptors) {
packetInterceptor.interceptPacket(presence);
}
PacketCollector createPacketCollector = this.connection.createPacketCollector(new AndFilter(new FromMatchesFilter(String.valueOf(this.room) + "/" + str), new PacketTypeFilter(Presence.class)));
this.connection.sendPacket(presence);
Presence presence2 = (Presence) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (presence2 == null) {
throw new XMPPException("No response from server.");
} else if (presence2.getError() == null) {
this.nickname = str;
} else {
throw new XMPPException(presence2.getError());
}
} else {
throw new IllegalStateException("Must be logged into the room to change nickname.");
}
}
public void changeSubject(final String str) throws XMPPException {
Message message = new Message(this.room, Message.Type.groupchat);
message.setSubject(str);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new AndFilter(new AndFilter(new FromMatchesFilter(this.room), new PacketTypeFilter(Message.class)), new PacketFilter() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass3 */
@Override // asmack.org.jivesoftware.smack.filter.PacketFilter
public boolean accept(Packet packet) {
return str.equals(((Message) packet).getSubject());
}
}));
this.connection.sendPacket(message);
Message message2 = (Message) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (message2 == null) {
throw new XMPPException("No response from server.");
} else if (message2.getError() != null) {
throw new XMPPException(message2.getError());
}
}
public synchronized void create(String str) throws XMPPException {
if (str != null) {
if (!str.equals("")) {
if (!this.joined) {
Presence presence = new Presence(Presence.Type.available);
presence.setTo(String.valueOf(this.room) + "/" + str);
presence.addExtension(new MUCInitialPresence());
for (PacketInterceptor packetInterceptor : this.presenceInterceptors) {
packetInterceptor.interceptPacket(presence);
}
PacketCollector createPacketCollector = this.connection.createPacketCollector(new AndFilter(new FromMatchesFilter(String.valueOf(this.room) + "/" + str), new PacketTypeFilter(Presence.class)));
this.connection.sendPacket(presence);
Presence presence2 = (Presence) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (presence2 == null) {
throw new XMPPException("No response from server.");
} else if (presence2.getError() == null) {
this.nickname = str;
this.joined = true;
userHasJoined();
MUCUser mUCUserExtension = getMUCUserExtension(presence2);
if (mUCUserExtension == null || mUCUserExtension.getStatus() == null || !"201".equals(mUCUserExtension.getStatus().getCode())) {
leave();
throw new XMPPException("Creation failed - Missing acknowledge of room creation.");
}
} else {
throw new XMPPException(presence2.getError());
}
} else {
throw new IllegalStateException("Creation failed - User already joined the room.");
}
}
}
throw new IllegalArgumentException("Nickname must not be null or blank.");
}
public Message createMessage() {
return new Message(this.room, Message.Type.groupchat);
}
public Chat createPrivateChat(String str, MessageListener messageListener) {
return this.connection.getChatManager().createChat(str, messageListener);
}
public void destroy(String str, String str2) throws XMPPException {
MUCOwner mUCOwner = new MUCOwner();
mUCOwner.setTo(this.room);
mUCOwner.setType(IQ.Type.SET);
MUCOwner.Destroy destroy = new MUCOwner.Destroy();
destroy.setReason(str);
destroy.setJid(str2);
mUCOwner.setDestroy(destroy);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCOwner.getPacketID()));
this.connection.sendPacket(mUCOwner);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getError() == null) {
this.occupantsMap.clear();
this.nickname = null;
this.joined = false;
userHasLeft();
} else {
throw new XMPPException(iq.getError());
}
}
/* access modifiers changed from: protected */
public void finalize() throws Throwable {
List<String> list;
try {
if (this.connection != null && ((list = joinedRooms.get(this.connection)) == null || !list.contains(this.room))) {
this.roomListenerMultiplexor.removeRoom(this.room);
for (PacketListener packetListener : this.connectionListeners) {
this.connection.removePacketListener(packetListener);
}
}
} catch (Exception unused) {
}
super.finalize();
}
public Collection<Affiliate> getAdmins() throws XMPPException {
return getAffiliatesByOwner("admin");
}
public Form getConfigurationForm() throws XMPPException {
MUCOwner mUCOwner = new MUCOwner();
mUCOwner.setTo(this.room);
mUCOwner.setType(IQ.Type.GET);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCOwner.getPacketID()));
this.connection.sendPacket(mUCOwner);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getError() == null) {
return Form.getFormFrom(iq);
} else {
throw new XMPPException(iq.getError());
}
}
public Collection<Affiliate> getMembers() throws XMPPException {
return getAffiliatesByAdmin("member");
}
public Collection<Occupant> getModerators() throws XMPPException {
return getOccupants("moderator");
}
public String getNickname() {
return this.nickname;
}
public Occupant getOccupant(String str) {
Presence presence = this.occupantsMap.get(str);
if (presence != null) {
return new Occupant(presence);
}
return null;
}
public Presence getOccupantPresence(String str) {
return this.occupantsMap.get(str);
}
public Iterator<String> getOccupants() {
return Collections.unmodifiableList(new ArrayList(this.occupantsMap.keySet())).iterator();
}
public int getOccupantsCount() {
return this.occupantsMap.size();
}
public Collection<Affiliate> getOutcasts() throws XMPPException {
return getAffiliatesByAdmin("outcast");
}
public Collection<Affiliate> getOwners() throws XMPPException {
return getAffiliatesByOwner("owner");
}
public Collection<Occupant> getParticipants() throws XMPPException {
return getOccupants("participant");
}
public Form getRegistrationForm() throws XMPPException {
Registration registration = new Registration();
registration.setType(IQ.Type.GET);
registration.setTo(this.room);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new AndFilter(new PacketIDFilter(registration.getPacketID()), new PacketTypeFilter(IQ.class)));
this.connection.sendPacket(registration);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getType() != IQ.Type.ERROR) {
return Form.getFormFrom(iq);
} else {
throw new XMPPException(iq.getError());
}
}
public String getReservedNickname() {
try {
Iterator<DiscoverInfo.Identity> identities = ServiceDiscoveryManager.getInstanceFor(this.connection).discoverInfo(this.room, "x-roomuser-item").getIdentities();
if (identities.hasNext()) {
return identities.next().getName();
}
return null;
} catch (XMPPException e2) {
e2.printStackTrace();
return null;
}
}
public String getRoom() {
return this.room;
}
public String getSubject() {
return this.subject;
}
public void grantAdmin(String str) throws XMPPException {
changeAffiliationByOwner(str, "admin");
}
public void grantAdmin(Collection<String> collection) throws XMPPException {
changeAffiliationByOwner(collection, "admin");
}
public void grantMembership(String str) throws XMPPException {
changeAffiliationByAdmin(str, "member", null);
}
public void grantMembership(Collection<String> collection) throws XMPPException {
changeAffiliationByAdmin(collection, "member");
}
public void grantModerator(String str) throws XMPPException {
changeRole(str, "moderator", null);
}
public void grantModerator(Collection<String> collection) throws XMPPException {
changeRole(collection, "moderator");
}
public void grantOwnership(String str) throws XMPPException {
changeAffiliationByOwner(str, "owner");
}
public void grantOwnership(Collection<String> collection) throws XMPPException {
changeAffiliationByOwner(collection, "owner");
}
public void grantVoice(String str) throws XMPPException {
changeRole(str, "participant", null);
}
public void grantVoice(Collection<String> collection) throws XMPPException {
changeRole(collection, "participant");
}
/* access modifiers changed from: protected */
public void initMultiplexor() {
AnonymousClass7 r0 = new PacketListener() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass7 */
@Override // asmack.org.jivesoftware.smack.PacketListener
public void processPacket(Packet packet) {
Message message = (Message) packet;
MultiUserChat.this.subject = message.getSubject();
MultiUserChat.this.fireSubjectUpdatedListeners(message.getSubject(), message.getFrom());
}
};
PacketMultiplexListener packetMultiplexListener = new PacketMultiplexListener(this.messageCollector, new PacketListener() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass8 */
@Override // asmack.org.jivesoftware.smack.PacketListener
public void processPacket(Packet packet) {
ArrayList arrayList;
MultiUserChat multiUserChat;
String str;
Presence presence = (Presence) packet;
String from = presence.getFrom();
String str2 = String.valueOf(MultiUserChat.this.room) + "/" + MultiUserChat.this.nickname;
boolean equals = presence.getFrom().equals(str2);
if (presence.getType() == Presence.Type.available) {
Presence presence2 = (Presence) MultiUserChat.this.occupantsMap.put(from, presence);
if (presence2 != null) {
MUCUser mUCUserExtension = MultiUserChat.this.getMUCUserExtension(presence2);
String affiliation = mUCUserExtension.getItem().getAffiliation();
String role = mUCUserExtension.getItem().getRole();
MUCUser mUCUserExtension2 = MultiUserChat.this.getMUCUserExtension(presence);
String affiliation2 = mUCUserExtension2.getItem().getAffiliation();
MultiUserChat.this.checkRoleModifications(role, mUCUserExtension2.getItem().getRole(), equals, from);
MultiUserChat.this.checkAffiliationModifications(affiliation, affiliation2, equals, from);
return;
} else if (!equals) {
arrayList = new ArrayList();
arrayList.add(from);
multiUserChat = MultiUserChat.this;
str = "joined";
} else {
return;
}
} else if (presence.getType() == Presence.Type.unavailable) {
MultiUserChat.this.occupantsMap.remove(from);
MUCUser mUCUserExtension3 = MultiUserChat.this.getMUCUserExtension(presence);
if (mUCUserExtension3 != null && mUCUserExtension3.getStatus() != null) {
MultiUserChat.this.checkPresenceCode(mUCUserExtension3.getStatus().getCode(), presence.getFrom().equals(str2), mUCUserExtension3, from);
return;
} else if (!equals) {
arrayList = new ArrayList();
arrayList.add(from);
multiUserChat = MultiUserChat.this;
str = "left";
} else {
return;
}
} else {
return;
}
multiUserChat.fireParticipantStatusListeners(str, arrayList);
}
}, r0, new PacketListener() {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass9 */
@Override // asmack.org.jivesoftware.smack.PacketListener
public void processPacket(Packet packet) {
MUCUser mUCUserExtension = MultiUserChat.this.getMUCUserExtension(packet);
if (mUCUserExtension.getDecline() != null && ((Message) packet).getType() != Message.Type.error) {
MultiUserChat.this.fireInvitationRejectionListeners(mUCUserExtension.getDecline().getFrom(), mUCUserExtension.getDecline().getReason());
}
}
});
this.roomListenerMultiplexor = RoomListenerMultiplexor.getRoomMultiplexor(this.connection);
this.roomListenerMultiplexor.addRoom(this.room, packetMultiplexListener);
}
public void invite(Message message, String str, String str2) {
message.setTo(this.room);
MUCUser mUCUser = new MUCUser();
MUCUser.Invite invite = new MUCUser.Invite();
invite.setTo(str);
invite.setReason(str2);
mUCUser.setInvite(invite);
message.addExtension(mUCUser);
this.connection.sendPacket(message);
}
public void invite(String str, String str2) {
invite(new Message(), str, str2);
}
public boolean isJoined() {
return this.joined;
}
public void join(String str) throws XMPPException {
join(str, null, null, (long) SmackConfiguration.getPacketReplyTimeout());
}
public void join(String str, String str2) throws XMPPException {
join(str, str2, null, (long) SmackConfiguration.getPacketReplyTimeout());
}
public synchronized void join(String str, String str2, DiscussionHistory discussionHistory, long j) throws XMPPException {
if (str != null) {
if (!str.equals("")) {
if (this.joined) {
leave();
}
Packet presence = new Presence(Presence.Type.available);
presence.setTo(String.valueOf(this.room) + "/" + str);
MUCInitialPresence mUCInitialPresence = new MUCInitialPresence();
if (str2 != null) {
mUCInitialPresence.setPassword(str2);
}
if (discussionHistory != null) {
mUCInitialPresence.setHistory(discussionHistory.getMUCHistory());
}
presence.addExtension(mUCInitialPresence);
for (PacketInterceptor packetInterceptor : this.presenceInterceptors) {
packetInterceptor.interceptPacket(presence);
}
PacketCollector packetCollector = null;
try {
packetCollector = this.connection.createPacketCollector(new AndFilter(new FromMatchesFilter(String.valueOf(this.room) + "/" + str), new PacketTypeFilter(Presence.class)));
this.connection.sendPacket(presence);
Presence presence2 = (Presence) packetCollector.nextResult(j);
if (presence2 == null) {
throw new XMPPException("No response from server.");
} else if (presence2.getError() == null) {
this.nickname = str;
this.joined = true;
userHasJoined();
} else {
throw new XMPPException(presence2.getError());
}
} finally {
if (packetCollector != null) {
packetCollector.cancel();
}
}
}
}
throw new IllegalArgumentException("Nickname must not be null or blank.");
}
public synchronized void joinRandom(String str, String str2, DiscussionHistory discussionHistory, long j) throws XMPPException {
if (str != null) {
if (!str.equals("")) {
if (this.joined) {
leave();
}
Presence presence = new Presence(Presence.Type.available);
presence.setTo(String.valueOf(this.room) + "/" + str);
presence.attr.addAttribute("by", "group");
MUCInitialPresence mUCInitialPresence = new MUCInitialPresence();
if (str2 != null) {
mUCInitialPresence.setPassword(str2);
}
if (discussionHistory != null) {
mUCInitialPresence.setHistory(discussionHistory.getMUCHistory());
}
presence.addExtension(mUCInitialPresence);
for (PacketInterceptor packetInterceptor : this.presenceInterceptors) {
packetInterceptor.interceptPacket(presence);
}
PacketCollector packetCollector = null;
try {
packetCollector = this.connection.createPacketCollector(new AndFilter(new PacketTypeFilter(Presence.class)) {
/* class asmack.org.jivesoftware.smackx.muc.MultiUserChat.AnonymousClass2 */
@Override // asmack.org.jivesoftware.smack.filter.PacketFilter, asmack.org.jivesoftware.smack.filter.AndFilter
public boolean accept(Packet packet) {
int lastIndexOf;
if (super.accept(packet) && ((Presence) packet).getType() == Presence.Type.available) {
String from = packet.getFrom();
if (from.contains(MultiUserChat.this.room) && (lastIndexOf = from.lastIndexOf("/")) >= 0) {
MultiUserChat.this.room = from.substring(0, lastIndexOf);
MultiUserChat.this.initMultiplexor();
return true;
}
}
return false;
}
});
this.connection.sendPacket(presence);
Presence presence2 = (Presence) packetCollector.nextResult(j);
if (presence2 == null) {
throw new XMPPException("No response from server.");
} else if (presence2.getError() == null) {
this.nickname = str;
this.joined = true;
userHasJoined();
} else {
throw new XMPPException(presence2.getError());
}
} finally {
if (packetCollector != null) {
packetCollector.cancel();
}
}
}
}
throw new IllegalArgumentException("Nickname must not be null or blank.");
}
public void kickParticipant(String str, String str2) throws XMPPException {
changeRole(str, "none", str2);
}
public synchronized void leave() {
if (this.joined) {
Presence presence = new Presence(Presence.Type.unavailable);
presence.setTo(String.valueOf(this.room) + "/" + this.nickname);
for (PacketInterceptor packetInterceptor : this.presenceInterceptors) {
packetInterceptor.interceptPacket(presence);
}
this.connection.sendPacket(presence);
this.occupantsMap.clear();
this.nickname = null;
this.joined = false;
userHasLeft();
}
}
public Message nextMessage() {
return (Message) this.messageCollector.nextResult();
}
public Message nextMessage(long j) {
return (Message) this.messageCollector.nextResult(j);
}
public Message pollMessage() {
return (Message) this.messageCollector.pollResult();
}
public void removeInvitationRejectionListener(InvitationRejectionListener invitationRejectionListener) {
synchronized (this.invitationRejectionListeners) {
this.invitationRejectionListeners.remove(invitationRejectionListener);
}
}
public void removeMessageListener(PacketListener packetListener) {
this.connection.removePacketListener(packetListener);
this.connectionListeners.remove(packetListener);
}
public void removeParticipantListener(PacketListener packetListener) {
this.connection.removePacketListener(packetListener);
this.connectionListeners.remove(packetListener);
}
public void removeParticipantStatusListener(ParticipantStatusListener participantStatusListener) {
synchronized (this.participantStatusListeners) {
this.participantStatusListeners.remove(participantStatusListener);
}
}
public void removePresenceInterceptor(PacketInterceptor packetInterceptor) {
this.presenceInterceptors.remove(packetInterceptor);
}
public void removeSubjectUpdatedListener(SubjectUpdatedListener subjectUpdatedListener) {
synchronized (this.subjectUpdatedListeners) {
this.subjectUpdatedListeners.remove(subjectUpdatedListener);
}
}
public void removeUserStatusListener(UserStatusListener userStatusListener) {
synchronized (this.userStatusListeners) {
this.userStatusListeners.remove(userStatusListener);
}
}
public void revokeAdmin(String str) throws XMPPException {
changeAffiliationByOwner(str, "member");
}
public void revokeAdmin(Collection<String> collection) throws XMPPException {
changeAffiliationByOwner(collection, "member");
}
public void revokeMembership(String str) throws XMPPException {
changeAffiliationByAdmin(str, "none", null);
}
public void revokeMembership(Collection<String> collection) throws XMPPException {
changeAffiliationByAdmin(collection, "none");
}
public void revokeModerator(String str) throws XMPPException {
changeRole(str, "participant", null);
}
public void revokeModerator(Collection<String> collection) throws XMPPException {
changeRole(collection, "participant");
}
public void revokeOwnership(String str) throws XMPPException {
changeAffiliationByOwner(str, "admin");
}
public void revokeOwnership(Collection<String> collection) throws XMPPException {
changeAffiliationByOwner(collection, "admin");
}
public void revokeVoice(String str) throws XMPPException {
changeRole(str, "visitor", null);
}
public void revokeVoice(Collection<String> collection) throws XMPPException {
changeRole(collection, "visitor");
}
public void sendConfigurationForm(Form form) throws XMPPException {
MUCOwner mUCOwner = new MUCOwner();
mUCOwner.setTo(this.room);
mUCOwner.setType(IQ.Type.SET);
mUCOwner.addExtension(form.getDataFormToSend());
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(mUCOwner.getPacketID()));
this.connection.sendPacket(mUCOwner);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getError() != null) {
throw new XMPPException(iq.getError());
}
}
public void sendMessage(Message message) throws XMPPException {
this.connection.sendPacket(message);
}
public void sendMessage(String str) throws XMPPException {
Message message = new Message(this.room, Message.Type.groupchat);
message.setBody(str);
this.connection.sendPacket(message);
}
public void sendRegistrationForm(Form form) throws XMPPException {
Registration registration = new Registration();
registration.setType(IQ.Type.SET);
registration.setTo(this.room);
registration.addExtension(form.getDataFormToSend());
PacketCollector createPacketCollector = this.connection.createPacketCollector(new AndFilter(new PacketIDFilter(registration.getPacketID()), new PacketTypeFilter(IQ.class)));
this.connection.sendPacket(registration);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from server.");
} else if (iq.getType() == IQ.Type.ERROR) {
throw new XMPPException(iq.getError());
}
}
}