CarrotChat v2.8.80.240429版本的 MD5 值为：fdf98761f01e715a89df24b85b0d206e
以下内容为反编译后的 PacketParserUtils.java 源代码，内容仅作参考
package org.jivesoftware.smack.util;
import ak.im.module.BaseField;
import com.huawei.hms.push.constant.RemoteMessageConst;
import com.meizu.cloud.pushsdk.constants.PushConstants;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.jivesoftware.smack.compress.packet.Compress;
import org.jivesoftware.smack.packet.EmptyResultIQ;
import org.jivesoftware.smack.packet.ErrorIQ;
import org.jivesoftware.smack.packet.ExtensionElement;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.Mechanisms;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.packet.Session;
import org.jivesoftware.smack.packet.Stanza;
import org.jivesoftware.smack.packet.StartTls;
import org.jivesoftware.smack.packet.StreamError;
import org.jivesoftware.smack.packet.UnparsedIQ;
import org.jivesoftware.smack.packet.XMPPError;
import org.jivesoftware.smack.parsing.StandardExtensionElementProvider;
import org.jivesoftware.smack.provider.ExtensionElementProvider;
import org.jivesoftware.smack.provider.IQProvider;
import org.jivesoftware.smack.provider.ProviderManager;
import org.jivesoftware.smack.sasl.packet.SaslStreamElements;
import org.jxmpp.jid.Jid;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
public class PacketParserUtils {
static final boolean $assertionsDisabled = false;
public static final String FEATURE_XML_ROUNDTRIP = "http://xmlpull.org/v1/doc/features.html#xml-roundtrip";
private static final Logger LOGGER = Logger.getLogger(PacketParserUtils.class.getName());
private static final XmlPullParserFactory XML_PULL_PARSER_FACTORY;
public static final boolean XML_PULL_PARSER_SUPPORTS_ROUNDTRIP;
public static class AnonymousClass1 {
static final int[] $SwitchMap$org$jivesoftware$smack$packet$IQ$Type;
static {
int[] iArr = new int[IQ.Type.values().length];
$SwitchMap$org$jivesoftware$smack$packet$IQ$Type = iArr;
try {
iArr[IQ.Type.error.ordinal()] = 1;
} catch (NoSuchFieldError unused) {
}
try {
$SwitchMap$org$jivesoftware$smack$packet$IQ$Type[IQ.Type.result.ordinal()] = 2;
} catch (NoSuchFieldError unused2) {
}
}
}
static {
boolean z10 = false;
try {
XmlPullParserFactory newInstance = XmlPullParserFactory.newInstance();
XML_PULL_PARSER_FACTORY = newInstance;
try {
newInstance.newPullParser().setFeature(FEATURE_XML_ROUNDTRIP, true);
z10 = true;
} catch (XmlPullParserException e10) {
LOGGER.log(Level.FINEST, "XmlPullParser does not support XML_ROUNDTRIP", (Throwable) e10);
}
XML_PULL_PARSER_SUPPORTS_ROUNDTRIP = z10;
} catch (XmlPullParserException e11) {
throw new AssertionError(e11);
}
}
public static void addExtensionElement(Stanza stanza, XmlPullParser xmlPullParser) throws Exception {
ParserUtils.assertAtStartTag(xmlPullParser);
addExtensionElement(stanza, xmlPullParser, xmlPullParser.getName(), xmlPullParser.getNamespace());
}
@Deprecated
public static void addPacketExtension(Stanza stanza, XmlPullParser xmlPullParser) throws Exception {
addExtensionElement(stanza, xmlPullParser);
}
private static String getLanguageAttribute(XmlPullParser xmlPullParser) {
for (int i10 = 0; i10 < xmlPullParser.getAttributeCount(); i10++) {
String attributeName = xmlPullParser.getAttributeName(i10);
if ("xml:lang".equals(attributeName) || ("lang".equals(attributeName) && "xml".equals(xmlPullParser.getAttributePrefix(i10)))) {
return xmlPullParser.getAttributeValue(i10);
}
}
return null;
}
public static XmlPullParser getParserFor(String str) throws XmlPullParserException, IOException {
return getParserFor(new StringReader(str));
}
public static XmlPullParser newXmppParser() throws XmlPullParserException {
XmlPullParser newPullParser = XmlPullParserFactory.newInstance().newPullParser();
newPullParser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
if (XML_PULL_PARSER_SUPPORTS_ROUNDTRIP) {
try {
newPullParser.setFeature(FEATURE_XML_ROUNDTRIP, true);
} catch (XmlPullParserException e10) {
LOGGER.log(Level.SEVERE, "XmlPullParser does not support XML_ROUNDTRIP, although it was first determined to be supported", (Throwable) e10);
}
}
return newPullParser;
}
public static Compress.Feature parseCompressionFeature(XmlPullParser xmlPullParser) throws IOException, XmlPullParserException {
int depth = xmlPullParser.getDepth();
LinkedList linkedList = new LinkedList();
while (true) {
int next = xmlPullParser.next();
if (next != 2) {
if (next != 3) {
continue;
} else {
String name = xmlPullParser.getName();
name.hashCode();
if (name.equals(Compress.Feature.ELEMENT) && xmlPullParser.getDepth() == depth) {
return new Compress.Feature(linkedList);
}
}
} else {
String name2 = xmlPullParser.getName();
name2.hashCode();
if (name2.equals(PushConstants.MZ_PUSH_MESSAGE_METHOD)) {
linkedList.add(xmlPullParser.nextText());
}
}
}
}
public static CharSequence parseContent(XmlPullParser xmlPullParser) throws XmlPullParserException, IOException {
if (xmlPullParser.isEmptyElementTag()) {
return "";
}
xmlPullParser.next();
return parseContentDepth(xmlPullParser, xmlPullParser.getDepth(), false);
}
public static CharSequence parseContentDepth(XmlPullParser xmlPullParser, int i10) throws XmlPullParserException, IOException {
return parseContentDepth(xmlPullParser, i10, false);
}
private static CharSequence parseContentDepthWithRoundtrip(XmlPullParser xmlPullParser, int i10, boolean z10) throws XmlPullParserException, IOException {
StringBuilder sb2 = new StringBuilder();
int eventType = xmlPullParser.getEventType();
while (true) {
if (eventType != 2 || !xmlPullParser.isEmptyElementTag()) {
CharSequence text = xmlPullParser.getText();
if (eventType == 4) {
text = StringUtils.escapeForXmlText(text.toString());
}
sb2.append(text);
}
if (eventType == 3 && xmlPullParser.getDepth() <= i10) {
return sb2;
}
eventType = xmlPullParser.next();
}
}
private static CharSequence parseContentDepthWithoutRoundtrip(XmlPullParser xmlPullParser, int i10, boolean z10) throws XmlPullParserException, IOException {
XmlStringBuilder xmlStringBuilder = new XmlStringBuilder();
int eventType = xmlPullParser.getEventType();
String str = null;
boolean z11 = false;
while (true) {
if (eventType != 2) {
if (eventType != 3) {
if (eventType == 4) {
xmlStringBuilder.escape(xmlPullParser.getText());
}
} else {
if (z11) {
z11 = false;
} else {
xmlStringBuilder.closeElement(xmlPullParser.getName());
}
if (str != null && str.equals(xmlPullParser.getName())) {
str = null;
}
if (xmlPullParser.getDepth() <= i10) {
return xmlStringBuilder;
}
}
} else {
xmlStringBuilder.halfOpenElement(xmlPullParser.getName());
if (str == null || z10) {
String namespace = xmlPullParser.getNamespace();
if (StringUtils.isNotEmpty(namespace)) {
xmlStringBuilder.attribute("xmlns", namespace);
str = xmlPullParser.getName();
}
}
for (int i11 = 0; i11 < xmlPullParser.getAttributeCount(); i11++) {
xmlStringBuilder.attribute(xmlPullParser.getAttributeName(i11), xmlPullParser.getAttributeValue(i11));
}
if (xmlPullParser.isEmptyElementTag()) {
xmlStringBuilder.closeEmptyElement();
z11 = true;
} else {
xmlStringBuilder.rightAngleBracket();
}
}
eventType = xmlPullParser.next();
}
}
public static Map<String, String> parseDescriptiveTexts(XmlPullParser xmlPullParser, Map<String, String> map) throws XmlPullParserException, IOException {
if (map == null) {
map = new HashMap<>();
}
String languageAttribute = getLanguageAttribute(xmlPullParser);
if (languageAttribute == null) {
languageAttribute = "";
}
map.put(languageAttribute, xmlPullParser.nextText());
return map;
}
public static CharSequence parseElement(XmlPullParser xmlPullParser) throws XmlPullParserException, IOException {
return parseElement(xmlPullParser, false);
}
public static String parseElementText(XmlPullParser xmlPullParser) throws XmlPullParserException, IOException {
String str = "";
if (!xmlPullParser.isEmptyElementTag()) {
int next = xmlPullParser.next();
if (next != 4) {
if (next == 3) {
return "";
}
throw new XmlPullParserException("Non-empty element tag not followed by text, while Mixed Content (XML 3.2.2) is disallowed");
}
str = xmlPullParser.getText();
if (xmlPullParser.next() != 3) {
throw new XmlPullParserException("Non-empty element tag contains child-elements, while Mixed Content (XML 3.2.2) is disallowed");
}
}
return str;
}
public static XMPPError.Builder parseError(XmlPullParser xmlPullParser) throws Exception {
int depth = xmlPullParser.getDepth();
ArrayList arrayList = new ArrayList();
XMPPError.Builder builder = XMPPError.getBuilder();
builder.setType(XMPPError.Type.fromString(xmlPullParser.getAttributeValue("", "type")));
builder.setErrorGenerator(xmlPullParser.getAttributeValue("", "by"));
Map<String, String> map = null;
while (true) {
int next = xmlPullParser.next();
if (next != 2) {
if (next == 3 && xmlPullParser.getDepth() == depth) {
builder.setExtensions(arrayList).setDescriptiveTexts(map);
return builder;
}
} else {
String name = xmlPullParser.getName();
String namespace = xmlPullParser.getNamespace();
namespace.hashCode();
if (!namespace.equals("urn:ietf:params:xml:ns:xmpp-stanzas")) {
addExtensionElement(arrayList, xmlPullParser, name, namespace);
} else {
name.hashCode();
if (!name.equals("text")) {
builder.setCondition(XMPPError.Condition.fromString(name));
if (!xmlPullParser.isEmptyElementTag()) {
builder.setConditionText(xmlPullParser.nextText());
}
} else {
map = parseDescriptiveTexts(xmlPullParser, map);
}
}
}
}
}
public static ExtensionElement parseExtensionElement(String str, String str2, XmlPullParser xmlPullParser) throws Exception {
ParserUtils.assertAtStartTag(xmlPullParser);
ExtensionElementProvider<ExtensionElement> extensionProvider = ProviderManager.getExtensionProvider(str, str2);
if (extensionProvider != null) {
return (ExtensionElement) extensionProvider.parse(xmlPullParser);
}
return (ExtensionElement) StandardExtensionElementProvider.INSTANCE.parse(xmlPullParser);
}
public static IQ parseIQ(XmlPullParser xmlPullParser) throws Exception {
ParserUtils.assertAtStartTag(xmlPullParser);
int depth = xmlPullParser.getDepth();
String attributeValue = xmlPullParser.getAttributeValue("", "id");
Jid jidAttribute = ParserUtils.getJidAttribute(xmlPullParser, "to");
Jid jidAttribute2 = ParserUtils.getJidAttribute(xmlPullParser, "from");
IQ.Type fromString = IQ.Type.fromString(xmlPullParser.getAttributeValue("", "type"));
IQ iq = null;
XMPPError.Builder builder = null;
while (true) {
int next = xmlPullParser.next();
if (next != 2) {
if (next == 3 && xmlPullParser.getDepth() == depth) {
break;
}
} else {
String name = xmlPullParser.getName();
String namespace = xmlPullParser.getNamespace();
name.hashCode();
if (!name.equals("error")) {
IQProvider<IQ> iQProvider = ProviderManager.getIQProvider(name, namespace);
if (iQProvider != null) {
iq = (IQ) iQProvider.parse(xmlPullParser);
} else {
iq = new UnparsedIQ(name, namespace, parseElement(xmlPullParser));
}
} else {
builder = parseError(xmlPullParser);
}
}
}
if (iq == null) {
int i10 = AnonymousClass1.$SwitchMap$org$jivesoftware$smack$packet$IQ$Type[fromString.ordinal()];
if (i10 != 1) {
if (i10 == 2) {
iq = new EmptyResultIQ();
}
} else {
iq = new ErrorIQ(builder);
}
}
iq.setStanzaId(attributeValue);
iq.setTo(jidAttribute);
iq.setFrom(jidAttribute2);
iq.setType(fromString);
iq.setError(builder);
return iq;
}
public static Collection<String> parseMechanisms(XmlPullParser xmlPullParser) throws XmlPullParserException, IOException {
ArrayList arrayList = new ArrayList();
boolean z10 = false;
while (!z10) {
int next = xmlPullParser.next();
if (next == 2) {
if (xmlPullParser.getName().equals("mechanism")) {
arrayList.add(xmlPullParser.nextText());
}
} else if (next == 3 && xmlPullParser.getName().equals(Mechanisms.ELEMENT)) {
z10 = true;
}
}
return arrayList;
}
public static Message parseMessage(XmlPullParser xmlPullParser) throws Exception {
ParserUtils.assertAtStartTag(xmlPullParser);
int depth = xmlPullParser.getDepth();
Message message = new Message();
message.setStanzaId(xmlPullParser.getAttributeValue("", "id"));
message.setTo(ParserUtils.getJidAttribute(xmlPullParser, "to"));
message.setFrom(ParserUtils.getJidAttribute(xmlPullParser, "from"));
String attributeValue = xmlPullParser.getAttributeValue("", "type");
if (attributeValue != null) {
message.setType(Message.Type.fromString(attributeValue));
}
String languageAttribute = getLanguageAttribute(xmlPullParser);
if (languageAttribute != null && !"".equals(languageAttribute.trim())) {
message.setLanguage(languageAttribute);
} else {
languageAttribute = Stanza.getDefaultLanguage();
}
String str = null;
while (true) {
int next = xmlPullParser.next();
char c10 = 3;
if (next != 2) {
if (next == 3 && xmlPullParser.getDepth() == depth) {
message.setThread(str);
return message;
}
} else {
String name = xmlPullParser.getName();
String namespace = xmlPullParser.getNamespace();
name.hashCode();
switch (name.hashCode()) {
case -1867885268:
if (name.equals("subject")) {
c10 = 0;
break;
}
break;
case -874443254:
if (name.equals("thread")) {
c10 = 1;
break;
}
break;
case 3029410:
if (name.equals(Message.BODY)) {
c10 = 2;
break;
}
break;
case 96784904:
break;
}
c10 = 65535;
switch (c10) {
case 0:
String languageAttribute2 = getLanguageAttribute(xmlPullParser);
if (languageAttribute2 == null) {
languageAttribute2 = languageAttribute;
}
String parseElementText = parseElementText(xmlPullParser);
if (message.getSubject(languageAttribute2) != null) {
break;
} else {
message.addSubject(languageAttribute2, parseElementText);
break;
}
case 1:
if (str != null) {
break;
} else {
str = xmlPullParser.nextText();
break;
}
case 2:
String languageAttribute3 = getLanguageAttribute(xmlPullParser);
if (languageAttribute3 == null) {
languageAttribute3 = languageAttribute;
}
String parseElementText2 = parseElementText(xmlPullParser);
if (message.getBody(languageAttribute3) != null) {
break;
} else {
message.addBody(languageAttribute3, parseElementText2);
break;
}
case 3:
message.setError(parseError(xmlPullParser));
break;
default:
addExtensionElement(message, xmlPullParser, name, namespace);
break;
}
}
}
}
@Deprecated
public static ExtensionElement parsePacketExtension(String str, String str2, XmlPullParser xmlPullParser) throws Exception {
return parseExtensionElement(str, str2, xmlPullParser);
}
public static Presence parsePresence(XmlPullParser xmlPullParser) throws Exception {
ParserUtils.assertAtStartTag(xmlPullParser);
int depth = xmlPullParser.getDepth();
Presence.Type type = Presence.Type.available;
String attributeValue = xmlPullParser.getAttributeValue("", "type");
if (attributeValue != null && !attributeValue.equals("")) {
type = Presence.Type.fromString(attributeValue);
}
Presence presence = new Presence(type);
presence.setTo(ParserUtils.getJidAttribute(xmlPullParser, "to"));
presence.setFrom(ParserUtils.getJidAttribute(xmlPullParser, "from"));
presence.setStanzaId(xmlPullParser.getAttributeValue("", "id"));
String languageAttribute = getLanguageAttribute(xmlPullParser);
if (languageAttribute != null && !"".equals(languageAttribute.trim())) {
presence.setLanguage(languageAttribute);
}
while (true) {
int next = xmlPullParser.next();
char c10 = 3;
if (next != 2) {
if (next == 3 && xmlPullParser.getDepth() == depth) {
return presence;
}
} else {
String name = xmlPullParser.getName();
String namespace = xmlPullParser.getNamespace();
name.hashCode();
switch (name.hashCode()) {
case -1165461084:
if (name.equals(RemoteMessageConst.Notification.PRIORITY)) {
c10 = 0;
break;
}
break;
case -892481550:
if (name.equals("status")) {
c10 = 1;
break;
}
break;
case 3529469:
if (name.equals("show")) {
c10 = 2;
break;
}
break;
case 96784904:
break;
}
c10 = 65535;
switch (c10) {
case 0:
presence.setPriority(Integer.parseInt(xmlPullParser.nextText()));
break;
case 1:
presence.setStatus(xmlPullParser.nextText());
break;
case 2:
String nextText = xmlPullParser.nextText();
if (StringUtils.isNotEmpty(nextText)) {
presence.setMode(Presence.Mode.fromString(nextText));
break;
} else {
LOGGER.warning("Empty or null mode text in presence show element form " + ((Object) presence.getFrom()) + " with id '" + presence.getStanzaId() + "' which is invalid according to RFC6121 4.7.2.1");
break;
}
case 3:
presence.setError(parseError(xmlPullParser));
break;
default:
try {
addExtensionElement(presence, xmlPullParser, name, namespace);
break;
} catch (Exception e10) {
LOGGER.warning("Failed to parse extension element in Presence stanza: \"" + e10 + "\" from: '" + ((Object) presence.getFrom()) + " id: '" + presence.getStanzaId() + "'");
break;
}
}
}
}
}
public static SaslStreamElements.SASLFailure parseSASLFailure(XmlPullParser xmlPullParser) throws XmlPullParserException, IOException {
int depth = xmlPullParser.getDepth();
Map<String, String> map = null;
String str = null;
while (true) {
int next = xmlPullParser.next();
if (next != 2) {
if (next == 3 && xmlPullParser.getDepth() == depth) {
return new SaslStreamElements.SASLFailure(str, map);
}
} else if (xmlPullParser.getName().equals("text")) {
map = parseDescriptiveTexts(xmlPullParser, map);
} else {
str = xmlPullParser.getName();
}
}
}
public static Session.Feature parseSessionFeature(XmlPullParser xmlPullParser) throws XmlPullParserException, IOException {
ParserUtils.assertAtStartTag(xmlPullParser);
int depth = xmlPullParser.getDepth();
boolean z10 = false;
if (!xmlPullParser.isEmptyElementTag()) {
while (true) {
int next = xmlPullParser.next();
if (next != 2) {
if (next == 3 && xmlPullParser.getDepth() == depth) {
break;
}
} else {
String name = xmlPullParser.getName();
name.hashCode();
if (name.equals(Session.Feature.OPTIONAL_ELEMENT)) {
z10 = true;
}
}
}
}
return new Session.Feature(z10);
}
public static <S extends Stanza> S parseStanza(String str) throws Exception {
return (S) parseStanza(getParserFor(str));
}
public static StartTls parseStartTlsFeature(XmlPullParser xmlPullParser) throws XmlPullParserException, IOException {
int depth = xmlPullParser.getDepth();
boolean z10 = false;
while (true) {
int next = xmlPullParser.next();
if (next != 2) {
if (next == 3 && xmlPullParser.getDepth() == depth) {
return new StartTls(z10);
}
} else {
String name = xmlPullParser.getName();
name.hashCode();
if (name.equals(BaseField.IS_REQUIRED_KEY)) {
z10 = true;
}
}
}
}
public static StreamError parseStreamError(XmlPullParser xmlPullParser) throws Exception {
int depth = xmlPullParser.getDepth();
ArrayList arrayList = new ArrayList();
StreamError.Condition condition = null;
String str = null;
Map<String, String> map = null;
while (true) {
int next = xmlPullParser.next();
if (next != 2) {
if (next == 3 && xmlPullParser.getDepth() == depth) {
return new StreamError(condition, str, map, arrayList);
}
} else {
String name = xmlPullParser.getName();
String namespace = xmlPullParser.getNamespace();
namespace.hashCode();
if (!namespace.equals(StreamError.NAMESPACE)) {
addExtensionElement(arrayList, xmlPullParser, name, namespace);
} else {
name.hashCode();
if (!name.equals("text")) {
condition = StreamError.Condition.fromString(name);
if (!xmlPullParser.isEmptyElementTag()) {
str = xmlPullParser.nextText();
}
} else {
map = parseDescriptiveTexts(xmlPullParser, map);
}
}
}
}
}
@Deprecated
public static void addPacketExtension(Stanza stanza, XmlPullParser xmlPullParser, String str, String str2) throws Exception {
addExtensionElement(stanza, xmlPullParser, str, str2);
}
public static XmlPullParser getParserFor(Reader reader) throws XmlPullParserException, IOException {
XmlPullParser newXmppParser = newXmppParser(reader);
for (int eventType = newXmppParser.getEventType(); eventType != 2; eventType = newXmppParser.next()) {
if (eventType == 1) {
throw new IllegalArgumentException("Document contains no start tag");
}
}
return newXmppParser;
}
public static CharSequence parseContentDepth(XmlPullParser xmlPullParser, int i10, boolean z10) throws XmlPullParserException, IOException {
if (xmlPullParser.getFeature(FEATURE_XML_ROUNDTRIP)) {
return parseContentDepthWithRoundtrip(xmlPullParser, i10, z10);
}
return parseContentDepthWithoutRoundtrip(xmlPullParser, i10, z10);
}
public static CharSequence parseElement(XmlPullParser xmlPullParser, boolean z10) throws XmlPullParserException, IOException {
return parseContentDepth(xmlPullParser, xmlPullParser.getDepth(), z10);
}
public static Stanza parseStanza(XmlPullParser xmlPullParser) throws Exception {
ParserUtils.assertAtStartTag(xmlPullParser);
String name = xmlPullParser.getName();
name.hashCode();
char c10 = 65535;
switch (name.hashCode()) {
case -1276666629:
if (name.equals(Presence.ELEMENT)) {
c10 = 0;
break;
}
break;
case 3368:
if (name.equals(IQ.IQ_ELEMENT)) {
c10 = 1;
break;
}
break;
case 954925063:
if (name.equals("message")) {
c10 = 2;
break;
}
break;
}
switch (c10) {
case 0:
return parsePresence(xmlPullParser);
case 1:
return parseIQ(xmlPullParser);
case 2:
return parseMessage(xmlPullParser);
default:
throw new IllegalArgumentException("Can only parse message, iq or presence, not " + name);
}
}
public static void addExtensionElement(Stanza stanza, XmlPullParser xmlPullParser, String str, String str2) throws Exception {
stanza.addExtension(parseExtensionElement(str, str2, xmlPullParser));
}
@Deprecated
public static void addPacketExtension(Collection<ExtensionElement> collection, XmlPullParser xmlPullParser) throws Exception {
addExtensionElement(collection, xmlPullParser, xmlPullParser.getName(), xmlPullParser.getNamespace());
}
@Deprecated
public static void addPacketExtension(Collection<ExtensionElement> collection, XmlPullParser xmlPullParser, String str, String str2) throws Exception {
addExtensionElement(collection, xmlPullParser, str, str2);
}
public static void addExtensionElement(Collection<ExtensionElement> collection, XmlPullParser xmlPullParser) throws Exception {
addExtensionElement(collection, xmlPullParser, xmlPullParser.getName(), xmlPullParser.getNamespace());
}
public static void addExtensionElement(Collection<ExtensionElement> collection, XmlPullParser xmlPullParser, String str, String str2) throws Exception {
collection.add(parseExtensionElement(str, str2, xmlPullParser));
}
public static XmlPullParser getParserFor(String str, String str2) throws XmlPullParserException, IOException {
XmlPullParser parserFor = getParserFor(str);
while (true) {
int eventType = parserFor.getEventType();
String name = parserFor.getName();
if (eventType == 2 && name.equals(str2)) {
return parserFor;
}
if (eventType != 1) {
parserFor.next();
} else {
throw new IllegalArgumentException("Could not find start tag '" + str2 + "' in stanza: " + str);
}
}
}
public static XmlPullParser newXmppParser(Reader reader) throws XmlPullParserException {
XmlPullParser newXmppParser = newXmppParser();
newXmppParser.setInput(reader);
return newXmppParser;
}
}