1 files changed, 182 insertions, 0 deletions
diff --git a/src/java/com/android/ims/rcs/uce/presence/pidfparser/capabilities/Duplex.java b/src/java/com/android/ims/rcs/uce/presence/pidfparser/capabilities/Duplex.java
new file mode 100644
index 00000000..af55a424
--- /dev/null
+++ b/src/java/com/android/ims/rcs/uce/presence/pidfparser/capabilities/Duplex.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.ims.rcs.uce.presence.pidfparser.capabilities;
+
+import android.annotation.StringDef;
+import android.text.TextUtils;
+
+import com.android.ims.rcs.uce.presence.pidfparser.ElementBase;
+
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlSerializer;
+
+/**
+ * The "duplex" element indicates how the communication service send and receive media. It can
+ * contain two elements: "supported" and "notsupported." The supported and
+ * nonsupported elements can contains four elements: "full", "half", "receive-only" and
+ * "send-only".
+ */
+public class Duplex extends ElementBase {
+    /** The name of the duplex element */
+    public static final String ELEMENT_NAME = "duplex";
+
+    /** The name of the supported element */
+    public static final String ELEMENT_SUPPORTED = "supported";
+
+    /** The name of the notsupported element */
+    public static final String ELEMENT_NOT_SUPPORTED = "notsupported";
+
+    /** The device can simultaneously send and receive media */
+    public static final String DUPLEX_FULL = "full";
+
+    /** The service can alternate between sending and receiving media.*/
+    public static final String DUPLEX_HALF = "half";
+
+    /** The service can only receive media */
+    public static final String DUPLEX_RECEIVE_ONLY = "receive-only";
+
+    /** The service can only send media */
+    public static final String DUPLEX_SEND_ONLY = "send-only";
+
+    @StringDef(value = {
+            DUPLEX_FULL,
+            DUPLEX_HALF,
+            DUPLEX_RECEIVE_ONLY,
+            DUPLEX_SEND_ONLY})
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface DuplexType {}
+
+    private final List<String> mSupportedTypeList = new ArrayList<>();
+    private final List<String> mNotSupportedTypeList = new ArrayList<>();
+
+    public Duplex() {
+    }
+
+    @Override
+    protected String initNamespace() {
+        return CapsConstant.NAMESPACE;
+    }
+
+    @Override
+    protected String initElementName() {
+        return ELEMENT_NAME;
+    }
+
+    public void addSupportedType(@DuplexType String type) {
+        mSupportedTypeList.add(type);
+    }
+
+    public List<String> getSupportedTypes() {
+        return Collections.unmodifiableList(mSupportedTypeList);
+    }
+
+    public void addNotSupportedType(@DuplexType String type) {
+        mNotSupportedTypeList.add(type);
+    }
+
+    public List<String> getNotSupportedTypes() {
+        return Collections.unmodifiableList(mNotSupportedTypeList);
+    }
+
+    @Override
+    public void serialize(XmlSerializer serializer) throws IOException {
+        if (mSupportedTypeList.isEmpty() && mNotSupportedTypeList.isEmpty()) {
+            return;
+        }
+        String namespace = getNamespace();
+        String elementName = getElementName();
+        serializer.startTag(namespace, elementName);
+        for (String supportedType : mSupportedTypeList) {
+            serializer.startTag(namespace, ELEMENT_SUPPORTED);
+            serializer.startTag(namespace, supportedType);
+            serializer.endTag(namespace, supportedType);
+            serializer.endTag(namespace, ELEMENT_SUPPORTED);
+        }
+        for (String notSupportedType : mNotSupportedTypeList) {
+            serializer.startTag(namespace, ELEMENT_NOT_SUPPORTED);
+            serializer.startTag(namespace, notSupportedType);
+            serializer.endTag(namespace, notSupportedType);
+            serializer.endTag(namespace, ELEMENT_NOT_SUPPORTED);
+        }
+        serializer.endTag(namespace, elementName);
+    }
+
+    @Override
+    public void parse(XmlPullParser parser) throws IOException, XmlPullParserException {
+        String namespace = parser.getNamespace();
+        String name = parser.getName();
+
+        if (!verifyParsingElement(namespace, name)) {
+            throw new XmlPullParserException("Incorrect element: " + namespace + ", " + name);
+        }
+
+        // Move to the next event.
+        int eventType = parser.next();
+
+        while(!(eventType == XmlPullParser.END_TAG
+                && getNamespace().equals(parser.getNamespace())
+                && getElementName().equals(parser.getName()))) {
+
+            if (eventType == XmlPullParser.START_TAG) {
+                String tagName = parser.getName();
+
+                if (ELEMENT_SUPPORTED.equals(tagName)) {
+                    String duplexType = getDuplexType(parser);
+                    if (!TextUtils.isEmpty(duplexType)) {
+                        addSupportedType(duplexType);
+                    }
+                } else if (ELEMENT_NOT_SUPPORTED.equals(tagName)) {
+                    String duplexType = getDuplexType(parser);
+                    if (!TextUtils.isEmpty(duplexType)) {
+                        addNotSupportedType(duplexType);
+                    }
+                }
+            }
+
+            eventType = parser.next();
+
+            // Leave directly if the event type is the end of the document.
+            if (eventType == XmlPullParser.END_DOCUMENT) {
+                return;
+            }
+        }
+    }
+
+    private String getDuplexType(XmlPullParser parser) throws IOException, XmlPullParserException {
+        // Move to the next event
+        int eventType = parser.next();
+
+        String name = parser.getName();
+        if (eventType == XmlPullParser.START_TAG) {
+            if (DUPLEX_FULL.equals(name) ||
+                    DUPLEX_HALF.equals(name) ||
+                    DUPLEX_RECEIVE_ONLY.equals(name) ||
+                    DUPLEX_SEND_ONLY.equals(name)) {
+                return name;
+            }
+        }
+        return null;
+    }
+}