Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/amazonaws/transform/AbstractErrorUnmarshaller.java

@@ -0,0 +1,20 @@
+package com.amazonaws.transform;
+
+import com.amazonaws.AmazonServiceException;
+
+/* loaded from: classes.dex */
+public abstract class AbstractErrorUnmarshaller<T> implements Unmarshaller<AmazonServiceException, T> {
+    public final Class exceptionClass;
+
+    public AbstractErrorUnmarshaller() {
+        this(AmazonServiceException.class);
+    }
+
+    public AbstractErrorUnmarshaller(Class cls) {
+        this.exceptionClass = cls;
+    }
+
+    public AmazonServiceException newException(String str) {
+        return (AmazonServiceException) this.exceptionClass.getConstructor(String.class).newInstance(str);
+    }
+}

decompiled/sources/com/amazonaws/transform/JsonErrorUnmarshaller.java

@@ -0,0 +1,31 @@
+package com.amazonaws.transform;
+
+import com.amazonaws.AmazonClientException;
+import com.amazonaws.AmazonServiceException;
+import com.amazonaws.http.JsonErrorResponseHandler;
+
+/* loaded from: classes.dex */
+public class JsonErrorUnmarshaller extends AbstractErrorUnmarshaller<JsonErrorResponseHandler.JsonErrorResponse> {
+    public boolean match(JsonErrorResponseHandler.JsonErrorResponse jsonErrorResponse) {
+        return true;
+    }
+
+    public JsonErrorUnmarshaller() {
+    }
+
+    public JsonErrorUnmarshaller(Class cls) {
+        super(cls);
+    }
+
+    @Override // com.amazonaws.transform.Unmarshaller
+    public AmazonServiceException unmarshall(JsonErrorResponseHandler.JsonErrorResponse jsonErrorResponse) {
+        String message = jsonErrorResponse.getMessage();
+        String errorCode = jsonErrorResponse.getErrorCode();
+        if ((message == null || message.isEmpty()) && (errorCode == null || errorCode.isEmpty())) {
+            throw new AmazonClientException("Neither error message nor error code is found in the error response payload.");
+        }
+        AmazonServiceException newException = newException(message);
+        newException.setErrorCode(errorCode);
+        return newException;
+    }
+}

decompiled/sources/com/amazonaws/transform/JsonUnmarshallerContext.java

@@ -0,0 +1,19 @@
+package com.amazonaws.transform;
+
+import com.amazonaws.http.HttpResponse;
+import com.amazonaws.util.json.AwsJsonReader;
+
+/* loaded from: classes.dex */
+public class JsonUnmarshallerContext {
+    public final HttpResponse httpResponse;
+    public final AwsJsonReader reader;
+
+    public AwsJsonReader getReader() {
+        return this.reader;
+    }
+
+    public JsonUnmarshallerContext(AwsJsonReader awsJsonReader, HttpResponse httpResponse) {
+        this.reader = awsJsonReader;
+        this.httpResponse = httpResponse;
+    }
+}

decompiled/sources/com/amazonaws/transform/ListUnmarshaller.java

@@ -0,0 +1,31 @@
+package com.amazonaws.transform;
+
+import com.amazonaws.util.json.AwsJsonReader;
+import com.amazonaws.util.json.AwsJsonToken;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class ListUnmarshaller<T> implements Unmarshaller<List<T>, JsonUnmarshallerContext> {
+    public final Unmarshaller itemUnmarshaller;
+
+    public ListUnmarshaller(Unmarshaller unmarshaller) {
+        this.itemUnmarshaller = unmarshaller;
+    }
+
+    @Override // com.amazonaws.transform.Unmarshaller
+    public List unmarshall(JsonUnmarshallerContext jsonUnmarshallerContext) {
+        AwsJsonReader reader = jsonUnmarshallerContext.getReader();
+        if (reader.peek() == AwsJsonToken.VALUE_NULL) {
+            reader.skipValue();
+            return null;
+        }
+        ArrayList arrayList = new ArrayList();
+        reader.beginArray();
+        while (reader.hasNext()) {
+            arrayList.add(this.itemUnmarshaller.unmarshall(jsonUnmarshallerContext));
+        }
+        reader.endArray();
+        return arrayList;
+    }
+}

decompiled/sources/com/amazonaws/transform/SimpleTypeJsonUnmarshallers$1.java

@@ -0,0 +1,23 @@
+package com.amazonaws.transform;
+
+/* loaded from: classes.dex */
+abstract /* synthetic */ class SimpleTypeJsonUnmarshallers$1 {
+    public static final /* synthetic */ int[] $SwitchMap$com$amazonaws$transform$TimestampFormat;
+
+    static {
+        int[] iArr = new int[TimestampFormat.values().length];
+        $SwitchMap$com$amazonaws$transform$TimestampFormat = iArr;
+        try {
+            iArr[TimestampFormat.ISO_8601.ordinal()] = 1;
+        } catch (NoSuchFieldError unused) {
+        }
+        try {
+            $SwitchMap$com$amazonaws$transform$TimestampFormat[TimestampFormat.RFC_822.ordinal()] = 2;
+        } catch (NoSuchFieldError unused2) {
+        }
+        try {
+            $SwitchMap$com$amazonaws$transform$TimestampFormat[TimestampFormat.UNIX_TIMESTAMP.ordinal()] = 3;
+        } catch (NoSuchFieldError unused3) {
+        }
+    }
+}

decompiled/sources/com/amazonaws/transform/SimpleTypeJsonUnmarshallers$DateJsonUnmarshaller.java

@@ -0,0 +1,49 @@
+package com.amazonaws.transform;
+
+import com.amazonaws.AmazonClientException;
+import com.amazonaws.util.DateUtils;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.util.Date;
+import java.util.Locale;
+
+/* loaded from: classes.dex */
+public class SimpleTypeJsonUnmarshallers$DateJsonUnmarshaller implements Unmarshaller<Date, JsonUnmarshallerContext> {
+    public static SimpleTypeJsonUnmarshallers$DateJsonUnmarshaller instance;
+    public final TimestampFormat format;
+
+    public SimpleTypeJsonUnmarshallers$DateJsonUnmarshaller(TimestampFormat timestampFormat) {
+        this.format = timestampFormat;
+    }
+
+    @Override // com.amazonaws.transform.Unmarshaller
+    public Date unmarshall(JsonUnmarshallerContext jsonUnmarshallerContext) {
+        String nextString = jsonUnmarshallerContext.getReader().nextString();
+        if (nextString == null) {
+            return null;
+        }
+        try {
+            int i = SimpleTypeJsonUnmarshallers$1.$SwitchMap$com$amazonaws$transform$TimestampFormat[this.format.ordinal()];
+            if (i == 1) {
+                return DateUtils.parseISO8601Date(nextString);
+            }
+            if (i == 2) {
+                return DateUtils.parseRFC822Date(nextString);
+            }
+            return new Date(NumberFormat.getInstance(new Locale("en")).parse(nextString).longValue() * 1000);
+        } catch (IllegalArgumentException e) {
+            e = e;
+            throw new AmazonClientException("Unable to parse date '" + nextString + "':  " + e.getMessage(), e);
+        } catch (ParseException e2) {
+            e = e2;
+            throw new AmazonClientException("Unable to parse date '" + nextString + "':  " + e.getMessage(), e);
+        }
+    }
+
+    public static SimpleTypeJsonUnmarshallers$DateJsonUnmarshaller getInstance() {
+        if (instance == null) {
+            instance = new SimpleTypeJsonUnmarshallers$DateJsonUnmarshaller(TimestampFormat.UNIX_TIMESTAMP);
+        }
+        return instance;
+    }
+}

decompiled/sources/com/amazonaws/transform/SimpleTypeJsonUnmarshallers$IntegerJsonUnmarshaller.java

@@ -0,0 +1,22 @@
+package com.amazonaws.transform;
+
+/* loaded from: classes.dex */
+public class SimpleTypeJsonUnmarshallers$IntegerJsonUnmarshaller implements Unmarshaller<Integer, JsonUnmarshallerContext> {
+    public static SimpleTypeJsonUnmarshallers$IntegerJsonUnmarshaller instance;
+
+    @Override // com.amazonaws.transform.Unmarshaller
+    public Integer unmarshall(JsonUnmarshallerContext jsonUnmarshallerContext) {
+        String nextString = jsonUnmarshallerContext.getReader().nextString();
+        if (nextString == null) {
+            return null;
+        }
+        return Integer.valueOf(Integer.parseInt(nextString));
+    }
+
+    public static SimpleTypeJsonUnmarshallers$IntegerJsonUnmarshaller getInstance() {
+        if (instance == null) {
+            instance = new SimpleTypeJsonUnmarshallers$IntegerJsonUnmarshaller();
+        }
+        return instance;
+    }
+}

decompiled/sources/com/amazonaws/transform/SimpleTypeJsonUnmarshallers$StringJsonUnmarshaller.java

@@ -0,0 +1,18 @@
+package com.amazonaws.transform;
+
+/* loaded from: classes.dex */
+public class SimpleTypeJsonUnmarshallers$StringJsonUnmarshaller implements Unmarshaller<String, JsonUnmarshallerContext> {
+    public static SimpleTypeJsonUnmarshallers$StringJsonUnmarshaller instance;
+
+    @Override // com.amazonaws.transform.Unmarshaller
+    public String unmarshall(JsonUnmarshallerContext jsonUnmarshallerContext) {
+        return jsonUnmarshallerContext.getReader().nextString();
+    }
+
+    public static SimpleTypeJsonUnmarshallers$StringJsonUnmarshaller getInstance() {
+        if (instance == null) {
+            instance = new SimpleTypeJsonUnmarshallers$StringJsonUnmarshaller();
+        }
+        return instance;
+    }
+}

decompiled/sources/com/amazonaws/transform/SimpleTypeStaxUnmarshallers.java

@@ -0,0 +1,72 @@
+package com.amazonaws.transform;
+
+import com.amazonaws.logging.Log;
+import com.amazonaws.logging.LogFactory;
+import com.amazonaws.util.DateUtils;
+import java.util.Date;
+
+/* loaded from: classes.dex */
+public abstract class SimpleTypeStaxUnmarshallers {
+    public static Log log = LogFactory.getLog(SimpleTypeStaxUnmarshallers.class);
+
+    public static class StringStaxUnmarshaller implements Unmarshaller<String, StaxUnmarshallerContext> {
+        public static StringStaxUnmarshaller instance;
+
+        @Override // com.amazonaws.transform.Unmarshaller
+        public String unmarshall(StaxUnmarshallerContext staxUnmarshallerContext) {
+            return staxUnmarshallerContext.readText();
+        }
+
+        public static StringStaxUnmarshaller getInstance() {
+            if (instance == null) {
+                instance = new StringStaxUnmarshaller();
+            }
+            return instance;
+        }
+    }
+
+    public static class IntegerStaxUnmarshaller implements Unmarshaller<Integer, StaxUnmarshallerContext> {
+        public static IntegerStaxUnmarshaller instance;
+
+        @Override // com.amazonaws.transform.Unmarshaller
+        public Integer unmarshall(StaxUnmarshallerContext staxUnmarshallerContext) {
+            String readText = staxUnmarshallerContext.readText();
+            if (readText == null) {
+                return null;
+            }
+            return Integer.valueOf(Integer.parseInt(readText));
+        }
+
+        public static IntegerStaxUnmarshaller getInstance() {
+            if (instance == null) {
+                instance = new IntegerStaxUnmarshaller();
+            }
+            return instance;
+        }
+    }
+
+    public static class DateStaxUnmarshaller implements Unmarshaller<Date, StaxUnmarshallerContext> {
+        public static DateStaxUnmarshaller instance;
+
+        @Override // com.amazonaws.transform.Unmarshaller
+        public Date unmarshall(StaxUnmarshallerContext staxUnmarshallerContext) {
+            String readText = staxUnmarshallerContext.readText();
+            if (readText == null) {
+                return null;
+            }
+            try {
+                return DateUtils.parseISO8601Date(readText);
+            } catch (Exception e) {
+                SimpleTypeStaxUnmarshallers.log.warn("Unable to parse date '" + readText + "':  " + e.getMessage(), e);
+                return null;
+            }
+        }
+
+        public static DateStaxUnmarshaller getInstance() {
+            if (instance == null) {
+                instance = new DateStaxUnmarshaller();
+            }
+            return instance;
+        }
+    }
+}

decompiled/sources/com/amazonaws/transform/StandardErrorUnmarshaller.java

@@ -0,0 +1,37 @@
+package com.amazonaws.transform;
+
+import com.amazonaws.AmazonServiceException;
+import com.amazonaws.util.XpathUtils;
+import org.w3c.dom.Node;
+
+/* loaded from: classes.dex */
+public class StandardErrorUnmarshaller extends AbstractErrorUnmarshaller<Node> {
+    public StandardErrorUnmarshaller() {
+    }
+
+    public StandardErrorUnmarshaller(Class cls) {
+        super(cls);
+    }
+
+    @Override // com.amazonaws.transform.Unmarshaller
+    public AmazonServiceException unmarshall(Node node) {
+        String parseErrorCode = parseErrorCode(node);
+        String asString = XpathUtils.asString("ErrorResponse/Error/Type", node);
+        String asString2 = XpathUtils.asString("ErrorResponse/RequestId", node);
+        AmazonServiceException newException = newException(XpathUtils.asString("ErrorResponse/Error/Message", node));
+        newException.setErrorCode(parseErrorCode);
+        newException.setRequestId(asString2);
+        if (asString == null) {
+            newException.setErrorType(AmazonServiceException.ErrorType.Unknown);
+        } else if ("Receiver".equalsIgnoreCase(asString)) {
+            newException.setErrorType(AmazonServiceException.ErrorType.Service);
+        } else if ("Sender".equalsIgnoreCase(asString)) {
+            newException.setErrorType(AmazonServiceException.ErrorType.Client);
+        }
+        return newException;
+    }
+
+    public String parseErrorCode(Node node) {
+        return XpathUtils.asString("ErrorResponse/Error/Code", node);
+    }
+}

decompiled/sources/com/amazonaws/transform/StaxUnmarshallerContext.java

@@ -0,0 +1,125 @@
+package com.amazonaws.transform;
+
+import csdk.gluads.Consts;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import org.xmlpull.v1.XmlPullParser;
+
+/* loaded from: classes.dex */
+public class StaxUnmarshallerContext {
+    public int currentEventType;
+    public final Map headers;
+    public final XmlPullParser xpp;
+    public final Deque stack = new LinkedList();
+    public String stackString = "";
+    public Map metadata = new HashMap();
+    public List metadataExpressions = new ArrayList();
+
+    public Map getMetadata() {
+        return this.metadata;
+    }
+
+    public boolean isStartOfDocument() {
+        return this.currentEventType == 0;
+    }
+
+    public StaxUnmarshallerContext(XmlPullParser xmlPullParser, Map map) {
+        this.xpp = xmlPullParser;
+        this.headers = map;
+    }
+
+    public String readText() {
+        String nextText = this.xpp.nextText();
+        if (this.xpp.getEventType() != 3) {
+            this.xpp.next();
+        }
+        this.currentEventType = this.xpp.getEventType();
+        updateContext();
+        return nextText;
+    }
+
+    public int getCurrentDepth() {
+        return this.stack.size();
+    }
+
+    public boolean testExpression(String str, int i) {
+        if (Consts.STRING_PERIOD.equals(str)) {
+            return true;
+        }
+        int i2 = -1;
+        while (true) {
+            i2 = str.indexOf("/", i2 + 1);
+            if (i2 <= -1) {
+                break;
+            }
+            if (str.charAt(i2 + 1) != '@') {
+                i++;
+            }
+        }
+        if (getCurrentDepth() == i) {
+            if (this.stackString.endsWith("/" + str)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int nextEvent() {
+        int next = this.xpp.next();
+        this.currentEventType = next;
+        if (next == 4) {
+            this.currentEventType = this.xpp.next();
+        }
+        updateContext();
+        if (this.currentEventType == 2) {
+            Iterator it = this.metadataExpressions.iterator();
+            while (true) {
+                if (!it.hasNext()) {
+                    break;
+                }
+                MetadataExpression metadataExpression = (MetadataExpression) it.next();
+                if (testExpression(metadataExpression.expression, metadataExpression.targetDepth)) {
+                    this.metadata.put(metadataExpression.key, readText());
+                    break;
+                }
+            }
+        }
+        return this.currentEventType;
+    }
+
+    public void registerMetadataExpression(String str, int i, String str2) {
+        this.metadataExpressions.add(new MetadataExpression(str, i, str2));
+    }
+
+    public static class MetadataExpression {
+        public String expression;
+        public String key;
+        public int targetDepth;
+
+        public MetadataExpression(String str, int i, String str2) {
+            this.expression = str;
+            this.targetDepth = i;
+            this.key = str2;
+        }
+    }
+
+    public final void updateContext() {
+        int i = this.currentEventType;
+        if (i != 2) {
+            if (i == 3) {
+                this.stack.pop();
+                this.stackString = this.stack.isEmpty() ? "" : (String) this.stack.peek();
+                return;
+            }
+            return;
+        }
+        String str = this.stackString + "/" + this.xpp.getName();
+        this.stackString = str;
+        this.stack.push(str);
+    }
+}

decompiled/sources/com/amazonaws/transform/TimestampFormat.java

@@ -0,0 +1,8 @@
+package com.amazonaws.transform;
+
+/* loaded from: classes.dex */
+public enum TimestampFormat {
+    UNIX_TIMESTAMP,
+    ISO_8601,
+    RFC_822
+}

decompiled/sources/com/amazonaws/transform/Unmarshaller.java

@@ -0,0 +1,6 @@
+package com.amazonaws.transform;
+
+/* loaded from: classes.dex */
+public interface Unmarshaller<T, R> {
+    Object unmarshall(Object obj);
+}

decompiled/sources/com/amazonaws/transform/VoidJsonUnmarshaller.java

@@ -0,0 +1,9 @@
+package com.amazonaws.transform;
+
+/* loaded from: classes.dex */
+public class VoidJsonUnmarshaller<T> implements Unmarshaller<T, JsonUnmarshallerContext> {
+    @Override // com.amazonaws.transform.Unmarshaller
+    public Object unmarshall(JsonUnmarshallerContext jsonUnmarshallerContext) {
+        return null;
+    }
+}

decompiled/sources/com/amazonaws/transform/VoidStaxUnmarshaller.java

@@ -0,0 +1,11 @@
+package com.amazonaws.transform;
+
+/* loaded from: classes.dex */
+public class VoidStaxUnmarshaller<T> implements Unmarshaller<T, StaxUnmarshallerContext> {
+    @Override // com.amazonaws.transform.Unmarshaller
+    public Object unmarshall(StaxUnmarshallerContext staxUnmarshallerContext) {
+        while (staxUnmarshallerContext.nextEvent() != 1) {
+        }
+        return null;
+    }
+}