Merge "Do not delete the DB if the received document is malformed/corrupt" am: 3263fd22ef am: 0b25267de2 am: 921b824036 am: 6340dacb4e

Original change: https://android-review.googlesource.com/c/platform/frameworks/opt/net/ims/+/2058847

Change-Id: Ib67273c4daf825e09d63ce6888c670245049c3ae
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

10 files changed, 412 insertions, 29 deletions

diff --git a/src/java/com/android/ims/rcs/uce/presence/pidfparser/PidfParser.java b/src/java/com/android/ims/rcs/uce/presence/pidfparser/PidfParser.java
index 1b0bdaed..10b43a56 100644
--- a/src/java/com/android/ims/rcs/uce/presence/pidfparser/PidfParser.java
+++ b/src/java/com/android/ims/rcs/uce/presence/pidfparser/PidfParser.java
@@ -21,10 +21,10 @@ import android.net.Uri;
 import android.telephony.ims.RcsContactPresenceTuple;
 import android.telephony.ims.RcsContactPresenceTuple.ServiceCapabilities;
 import android.telephony.ims.RcsContactUceCapability;
-import android.telephony.ims.RcsContactUceCapability.PresenceBuilder;
 import android.text.TextUtils;
 import android.util.Log;
 
+
 import com.android.ims.rcs.uce.presence.pidfparser.capabilities.Audio;
 import com.android.ims.rcs.uce.presence.pidfparser.capabilities.CapsConstant;
 import com.android.ims.rcs.uce.presence.pidfparser.capabilities.Duplex;
@@ -35,6 +35,7 @@ import com.android.ims.rcs.uce.presence.pidfparser.pidf.Basic;
 import com.android.ims.rcs.uce.presence.pidfparser.pidf.PidfConstant;
 import com.android.ims.rcs.uce.presence.pidfparser.pidf.Presence;
 import com.android.ims.rcs.uce.presence.pidfparser.pidf.Tuple;
+import com.android.ims.rcs.uce.presence.pidfparser.RcsContactUceCapabilityWrapper;
 import com.android.ims.rcs.uce.util.UceUtils;
 import com.android.internal.annotations.VisibleForTesting;
 
@@ -120,11 +121,12 @@ public class PidfParser {
     }
 
     /**
-     * Get the RcsContactUceCapability from the given PIDF xml format.
+     * Get the RcsContactUceCapabilityWrapper from the given PIDF xml format.
      */
-    public static @Nullable RcsContactUceCapability getRcsContactUceCapability(String pidf) {
+    public static @Nullable RcsContactUceCapabilityWrapper getRcsContactUceCapabilityWrapper(
+            String pidf) {
         if (TextUtils.isEmpty(pidf)) {
-            Log.w(LOG_TAG, "getRcsContactUceCapability: The given pidf is empty");
+            Log.w(LOG_TAG, "getRcsContactUceCapabilityWrapper: The given pidf is empty");
             return null;
         }
 
@@ -132,7 +134,7 @@ public class PidfParser {
         Matcher matcher = PIDF_PATTERN.matcher(pidf);
         String formattedPidf = matcher.replaceAll("");
         if (TextUtils.isEmpty(formattedPidf)) {
-            Log.w(LOG_TAG, "getRcsContactUceCapability: The formatted pidf is empty");
+            Log.w(LOG_TAG, "getRcsContactUceCapabilityWrapper: The formatted pidf is empty");
             return null;
         }
 
@@ -147,7 +149,7 @@ public class PidfParser {
             // Start parsing
             Presence presence = parsePidf(parser);
 
-            // Convert from the Presence to the RcsContactUceCapability
+            // Convert from the Presence to the RcsContactUceCapabilityWrapper
             return convertToRcsContactUceCapability(presence);
 
         } catch (XmlPullParserException | IOException e) {
@@ -168,10 +170,12 @@ public class PidfParser {
             XmlPullParserException {
         Presence presence = null;
         int nextType = parser.next();
+        boolean findPresenceTag = false;
         do {
             // Find the Presence start tag
             if (nextType == XmlPullParser.START_TAG
                     && Presence.ELEMENT_NAME.equals(parser.getName())) {
+                findPresenceTag = true;
                 presence = new Presence();
                 presence.parse(parser);
                 break;
@@ -179,13 +183,18 @@ public class PidfParser {
             nextType = parser.next();
         } while(nextType != XmlPullParser.END_DOCUMENT);
 
+        if (!findPresenceTag) {
+            Log.w(LOG_TAG, "parsePidf: The presence start tag not found.");
+        }
+
         return presence;
     }
 
     /*
-     * Convert the given Presence to the RcsContactUceCapability
+     * Convert the given Presence to the RcsContactUceCapabilityWrapper
      */
-    private static RcsContactUceCapability convertToRcsContactUceCapability(Presence presence) {
+    private static RcsContactUceCapabilityWrapper convertToRcsContactUceCapability(
+            Presence presence) {
         if (presence == null) {
             Log.w(LOG_TAG, "convertToRcsContactUceCapability: The presence is null");
             return null;
@@ -195,19 +204,24 @@ public class PidfParser {
             return null;
         }
 
-        PresenceBuilder presenceBuilder = new PresenceBuilder(Uri.parse(presence.getEntity()),
-                RcsContactUceCapability.SOURCE_TYPE_NETWORK,
+        RcsContactUceCapabilityWrapper uceCapabilityWrapper = new RcsContactUceCapabilityWrapper(
+                Uri.parse(presence.getEntity()), RcsContactUceCapability.SOURCE_TYPE_NETWORK,
                 RcsContactUceCapability.REQUEST_RESULT_FOUND);
 
         // Add all the capability tuples of this contact
         presence.getTupleList().forEach(tuple -> {
-            RcsContactPresenceTuple capabilityTuple = getRcsContactPresenceTuple(tuple);
-            if (capabilityTuple != null) {
-                presenceBuilder.addCapabilityTuple(capabilityTuple);
+            // The tuple that fails parsing is invalid data, so discard it.
+            if (!tuple.getMalformed()) {
+                RcsContactPresenceTuple capabilityTuple = getRcsContactPresenceTuple(tuple);
+                if (capabilityTuple != null) {
+                    uceCapabilityWrapper.addCapabilityTuple(capabilityTuple);
+                }
+            } else {
+                uceCapabilityWrapper.setMalformedContents();
             }
         });
-        presenceBuilder.setEntityUri(Uri.parse(presence.getEntity()));
-        return presenceBuilder.build();
+        uceCapabilityWrapper.setEntityUri(Uri.parse(presence.getEntity()));
+        return uceCapabilityWrapper;
     }
 
     /*
diff --git a/src/java/com/android/ims/rcs/uce/presence/pidfparser/PidfParserUtils.java b/src/java/com/android/ims/rcs/uce/presence/pidfparser/PidfParserUtils.java
index f2b21bd0..d43819ec 100644
--- a/src/java/com/android/ims/rcs/uce/presence/pidfparser/PidfParserUtils.java
+++ b/src/java/com/android/ims/rcs/uce/presence/pidfparser/PidfParserUtils.java
@@ -284,6 +284,16 @@ public class PidfParserUtils {
     }
 
     /**
+     * Get the malformed status from the given tuple.
+     */
+    public static boolean getTupleMalformedStatus(Tuple tuple) {
+        if (tuple == null) {
+            return false;
+        }
+        return tuple.getMalformed();
+    }
+
+    /**
      * Get the terminated capability which disable all the capabilities.
      */
     public static RcsContactUceCapability getTerminatedCapability(Uri contact, String reason) {
diff --git a/src/java/com/android/ims/rcs/uce/presence/pidfparser/RcsContactUceCapabilityWrapper.java b/src/java/com/android/ims/rcs/uce/presence/pidfparser/RcsContactUceCapabilityWrapper.java
new file mode 100644
index 00000000..3b2f163f
--- /dev/null
+++ b/src/java/com/android/ims/rcs/uce/presence/pidfparser/RcsContactUceCapabilityWrapper.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2022 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;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.net.Uri;
+
+import android.telephony.ims.RcsContactPresenceTuple;
+import android.telephony.ims.RcsContactUceCapability;
+import android.telephony.ims.RcsContactUceCapability.PresenceBuilder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A wrapper class that uses the parsed information to construct {@link RcsContactUceCapability}
+ * instances.
+ */
+
+public class RcsContactUceCapabilityWrapper {
+    private final Uri mContactUri;
+    private final int mSourceType;
+    private final int mRequestResult;
+    private boolean mIsMalformed;
+    private final List<RcsContactPresenceTuple> mPresenceTuples = new ArrayList<>();
+    private Uri mEntityUri;
+
+    /**
+     * Create the wrapper, which can be used to set UCE capabilities as well as custom
+     * capability extensions.
+     * @param contact The contact URI that the capabilities are attached to.
+     * @param sourceType The type where the capabilities of this contact were retrieved from.
+     * @param requestResult the request result
+     */
+    public RcsContactUceCapabilityWrapper(@NonNull Uri contact, int sourceType, int requestResult) {
+        mContactUri = contact;
+        mSourceType = sourceType;
+        mRequestResult = requestResult;
+        mIsMalformed = false;
+    }
+
+    /**
+     * Add the {@link RcsContactPresenceTuple} into the presence tuple list.
+     * @param tuple The {@link RcsContactPresenceTuple} to be added into.
+     */
+    public void addCapabilityTuple(@NonNull RcsContactPresenceTuple tuple) {
+        mPresenceTuples.add(tuple);
+    }
+
+    /**
+     * This flag is set if at least one tuple could not be parsed due to malformed contents.
+     */
+    public void setMalformedContents() {
+        mIsMalformed = true;
+    }
+
+    /**
+     * Set the entity URI related to the contact whose capabilities were requested.
+     * @param entityUri the 'pres' URL of the PRESENTITY publishing presence document.
+     */
+    public void setEntityUri(@NonNull Uri entityUri) {
+        mEntityUri = entityUri;
+    }
+
+    /**
+     * Whether the XML is malformed.
+     * @return {@code true} if all of the presence tuple information associated with
+     * the entity URI ({@link #getEntityUri}) is malformed and there is no tuple info
+     * available. If one or more of the tuples are still well-formed after parsing the
+     * XML, this method will return {@code false}.
+     */
+    public boolean isMalformed() {
+        if (mIsMalformed == false) {
+            return false;
+        }
+        if (mPresenceTuples.isEmpty()) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Retrieve the entity URI of the contact whose presence information is being requested for.
+     * @return the URI representing the 'pres' URL of the PRESENTITY publishing presence document
+     * or {@code null} if the entity uri does not exist in the presence document.
+     */
+    public @Nullable Uri getEntityUri() {
+        return mEntityUri;
+    }
+
+    /**
+     * @return a new RcsContactUceCapability instance from the contents of this wrapper.
+     */
+    public @NonNull RcsContactUceCapability toRcsContactUceCapability() {
+
+        PresenceBuilder presenceBuilder = new PresenceBuilder(mContactUri,
+                mSourceType, mRequestResult);
+
+        // Add all the capability tuples of this contact
+        presenceBuilder.addCapabilityTuples(mPresenceTuples);
+        presenceBuilder.setEntityUri(mEntityUri);
+        return presenceBuilder.build();
+    }
+}
diff --git a/src/java/com/android/ims/rcs/uce/presence/pidfparser/pidf/Presence.java b/src/java/com/android/ims/rcs/uce/presence/pidfparser/pidf/Presence.java
index e9a40a84..b2173145 100644
--- a/src/java/com/android/ims/rcs/uce/presence/pidfparser/pidf/Presence.java
+++ b/src/java/com/android/ims/rcs/uce/presence/pidfparser/pidf/Presence.java
@@ -18,8 +18,11 @@ package com.android.ims.rcs.uce.presence.pidfparser.pidf;
 
 import android.annotation.NonNull;
 import android.net.Uri;
+import android.text.TextUtils;
+import android.util.Log;
 
 import com.android.ims.rcs.uce.presence.pidfparser.ElementBase;
+import com.android.ims.rcs.uce.util.UceUtils;
 import com.android.internal.annotations.VisibleForTesting;
 
 import org.xmlpull.v1.XmlPullParser;
@@ -41,6 +44,7 @@ public class Presence extends ElementBase {
      * 2: Any number (including 0) of <note> elements
      * 3: Any number of OPTIONAL extension elements from other namespaces.
      */
+    private static final String LOG_TAG = UceUtils.getLogPrefix() + "Presence";
 
     /** The name of this element */
     public static final String ELEMENT_NAME = "presence";
@@ -133,6 +137,9 @@ public class Presence extends ElementBase {
         }
 
         mEntity = parser.getAttributeValue(XmlPullParser.NO_NAMESPACE, ATTRIBUTE_NAME_ENTITY);
+        if (TextUtils.isEmpty(mEntity)) {
+            throw new XmlPullParserException("Entity uri of presence is empty");
+        }
 
         // Move to the next event.
         int eventType = parser.next();
@@ -146,11 +153,24 @@ public class Presence extends ElementBase {
 
                 if (isTupleElement(eventType, tagName)) {
                     Tuple tuple = new Tuple();
-                    tuple.parse(parser);
+                    try {
+                        // If one tuple encounters an xml exception, we must parse the other tuple
+                        // and store valid information.
+                        tuple.parse(parser);
+                    } catch (XmlPullParserException e) {
+                        e.printStackTrace();
+                        Log.w(LOG_TAG, "parse: Exception occurred during Tuple parsing.");
+                        tuple.setMalformed(true);
+                    }
                     mTupleList.add(tuple);
                 } else if (isNoteElement(eventType, tagName)) {
                     Note note = new Note();
-                    note.parse(parser);
+                    try {
+                        note.parse(parser);
+                    } catch (XmlPullParserException e) {
+                        e.printStackTrace();
+                        Log.w(LOG_TAG, "parse: Exception occurred during Note parsing.");
+                    }
                     mNoteList.add(note);
                 }
             }
diff --git a/src/java/com/android/ims/rcs/uce/presence/pidfparser/pidf/Tuple.java b/src/java/com/android/ims/rcs/uce/presence/pidfparser/pidf/Tuple.java
index 014dbed0..e2744660 100644
--- a/src/java/com/android/ims/rcs/uce/presence/pidfparser/pidf/Tuple.java
+++ b/src/java/com/android/ims/rcs/uce/presence/pidfparser/pidf/Tuple.java
@@ -59,8 +59,11 @@ public class Tuple extends ElementBase {
     private List<Note> mNoteList = new ArrayList<>();
     private Timestamp mTimestamp;
 
+    private boolean mMalformed;
+
     public Tuple() {
         mId = getTupleId();
+        mMalformed = false;
     }
 
     @Override
@@ -121,6 +124,14 @@ public class Tuple extends ElementBase {
         return mTimestamp;
     }
 
+    public void setMalformed(boolean malformed) {
+        mMalformed = malformed;
+    }
+
+    public boolean getMalformed() {
+        return mMalformed;
+    }
+
     @Override
     public void serialize(XmlSerializer serializer) throws IOException {
         String namespace = getNamespace();
diff --git a/src/java/com/android/ims/rcs/uce/request/SubscribeRequest.java b/src/java/com/android/ims/rcs/uce/request/SubscribeRequest.java
index 2b5e91a9..bee71771 100644
--- a/src/java/com/android/ims/rcs/uce/request/SubscribeRequest.java
+++ b/src/java/com/android/ims/rcs/uce/request/SubscribeRequest.java
@@ -25,12 +25,15 @@ import android.telephony.ims.RcsUceAdapter;
 import android.telephony.ims.aidl.ISubscribeResponseCallback;
 import android.telephony.ims.stub.RcsCapabilityExchangeImplBase.CommandCode;
 
+import com.android.ims.rcs.uce.eab.EabCapabilityResult;
 import com.android.ims.rcs.uce.presence.pidfparser.PidfParser;
 import com.android.ims.rcs.uce.presence.pidfparser.PidfParserUtils;
+import com.android.ims.rcs.uce.presence.pidfparser.RcsContactUceCapabilityWrapper;
 import com.android.ims.rcs.uce.presence.subscribe.SubscribeController;
 import com.android.ims.rcs.uce.request.UceRequestManager.RequestManagerCallback;
 import com.android.internal.annotations.VisibleForTesting;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
@@ -189,30 +192,59 @@ public class SubscribeRequest extends CapabilityRequest {
             pidfXml = Collections.EMPTY_LIST;
         }
 
-        // Convert from the pidf xml to the list of RcsContactUceCapability
-        List<RcsContactUceCapability> capabilityList = pidfXml.stream()
-                .map(pidf -> PidfParser.getRcsContactUceCapability(pidf))
+        // Convert from the pidf xml to the list of RcsContactUceCapabilityWrapper
+        List<RcsContactUceCapabilityWrapper> capabilityList = pidfXml.stream()
+                .map(pidf -> PidfParser.getRcsContactUceCapabilityWrapper(pidf))
                 .filter(Objects::nonNull)
                 .collect(Collectors.toList());
 
         // When the given PIDF xml is empty, set the contacts who have not received the
         // capabilities updated as non-RCS user.
+        List<RcsContactUceCapability> notReceivedCapabilityList = new ArrayList<>();
         if (capabilityList.isEmpty()) {
             logd("onCapabilitiesUpdate: The capabilities list is empty, Set to non-RCS user.");
             List<Uri> notReceiveCapUpdatedContactList =
                     mRequestResponse.getNotReceiveCapabilityUpdatedContact();
-            capabilityList = notReceiveCapUpdatedContactList.stream()
+            notReceivedCapabilityList = notReceiveCapUpdatedContactList.stream()
                     .map(PidfParserUtils::getNotFoundContactCapabilities)
                     .filter(Objects::nonNull)
                     .collect(Collectors.toList());
         }
 
+        List<RcsContactUceCapability> updateCapabilityList = new ArrayList<>();
+        List<Uri> malformedListWithEntityURI = new ArrayList<>();
+        for (RcsContactUceCapabilityWrapper capability : capabilityList) {
+            if (!capability.isMalformed()) {
+                updateCapabilityList.add(capability.toRcsContactUceCapability());
+            } else {
+                logw("onCapabilitiesUpdate: malformed capability was found and not saved.");
+                malformedListWithEntityURI.add(capability.getEntityUri());
+            }
+        }
         logd("onCapabilitiesUpdate: PIDF size=" + pidfXml.size()
-                + ", contact capability size=" + capabilityList.size());
+                + ", not received capability size=" + notReceivedCapabilityList.size()
+                + ", normal capability size=" + updateCapabilityList.size()
+                + ", malformed but entity uri is valid capability size="
+                + malformedListWithEntityURI.size());
+
+        for (RcsContactUceCapability emptyCapability : notReceivedCapabilityList) {
+            updateCapabilityList.add(emptyCapability);
+        }
 
+        // All tuples in received xml are malformed but entity uri is valid.
+        // The capability should be get from the DB and report it to callback.
+        List<EabCapabilityResult> cachedCapabilityList =
+                mRequestManagerCallback.getCapabilitiesFromCache(malformedListWithEntityURI);
+        for (EabCapabilityResult cacheEabCapability : cachedCapabilityList) {
+            RcsContactUceCapability cachedCapability = cacheEabCapability.getContactCapabilities();
+            if (cachedCapability != null) {
+                updateCapabilityList.add(cachedCapability);
+            }
+        }
         // Add these updated RcsContactUceCapability into the RequestResponse and notify
         // the RequestManager to process the RcsContactUceCapabilities updated.
-        mRequestResponse.addUpdatedCapabilities(capabilityList);
+        logd("onCapabilitiesUpdate: updatedCapability size=" + updateCapabilityList.size());
+        mRequestResponse.addUpdatedCapabilities(updateCapabilityList);
         mRequestManagerCallback.notifyCapabilitiesUpdated(mCoordinatorId, mTaskId);
     }
 
diff --git a/tests/src/com/android/ims/rcs/uce/presence/pidfparser/PidfParserTest.java b/tests/src/com/android/ims/rcs/uce/presence/pidfparser/PidfParserTest.java
index fc21f75e..fd29d5b3 100644
--- a/tests/src/com/android/ims/rcs/uce/presence/pidfparser/PidfParserTest.java
+++ b/tests/src/com/android/ims/rcs/uce/presence/pidfparser/PidfParserTest.java
@@ -93,7 +93,10 @@ public class PidfParserTest extends ImsTestBase {
                 isVideoSupported);
 
         // Convert to the class RcsContactUceCapability
-        RcsContactUceCapability capabilities = PidfParser.getRcsContactUceCapability(pidfData);
+        RcsContactUceCapabilityWrapper capabilitiesWrapper =
+                PidfParser.getRcsContactUceCapabilityWrapper(pidfData);
+        assertNotNull(capabilitiesWrapper);
+        RcsContactUceCapability capabilities = capabilitiesWrapper.toRcsContactUceCapability();
         assertNotNull(capabilities);
         assertEquals(Uri.parse(contact), capabilities.getContactUri());
         assertEquals(Uri.parse(contact), capabilities.getEntityUri());
@@ -168,7 +171,10 @@ public class PidfParserTest extends ImsTestBase {
         String pidfData = getPidfDataWithNewlineAndWhitespaceCharacters();
 
         // Convert to the class RcsContactUceCapability
-        RcsContactUceCapability capabilities = PidfParser.getRcsContactUceCapability(pidfData);
+        RcsContactUceCapabilityWrapper capabilitiesWrapper =
+                PidfParser.getRcsContactUceCapabilityWrapper(pidfData);
+        assertNotNull(capabilitiesWrapper);
+        RcsContactUceCapability capabilities = capabilitiesWrapper.toRcsContactUceCapability();
 
         assertNotNull(capabilities);
         assertEquals(Uri.parse(contact), capabilities.getContactUri());
@@ -235,7 +241,10 @@ public class PidfParserTest extends ImsTestBase {
                 serviceId2, serviceDescription2, isAudioSupported, isVideoSupported);
 
         // Convert to the class RcsContactUceCapability
-        RcsContactUceCapability capabilities = PidfParser.getRcsContactUceCapability(pidfData);
+        RcsContactUceCapabilityWrapper capabilitiesWrapper =
+                PidfParser.getRcsContactUceCapabilityWrapper(pidfData);
+        assertNotNull(capabilitiesWrapper);
+        RcsContactUceCapability capabilities = capabilitiesWrapper.toRcsContactUceCapability();
 
         assertNotNull(capabilities);
         assertEquals(Uri.parse(contact), capabilities.getContactUri());
@@ -277,8 +286,11 @@ public class PidfParserTest extends ImsTestBase {
         final String pidf = PidfParser.convertToPidf(capability);
 
         // Restore to the RcsContactUceCapability from the pidf
+        RcsContactUceCapabilityWrapper capabilitiesWrapper =
+                PidfParser.getRcsContactUceCapabilityWrapper(pidf);
+        assertNotNull(capabilitiesWrapper);
         final RcsContactUceCapability restoredCapability =
-                PidfParser.getRcsContactUceCapability(pidf);
+                capabilitiesWrapper.toRcsContactUceCapability();
 
         assertEquals(capability.getContactUri(), restoredCapability.getContactUri());
         assertEquals(capability.getCapabilityMechanism(),
diff --git a/tests/src/com/android/ims/rcs/uce/presence/pidfparser/RcsContactUceCapabilityWrapperTest.java b/tests/src/com/android/ims/rcs/uce/presence/pidfparser/RcsContactUceCapabilityWrapperTest.java
new file mode 100644
index 00000000..9497e198
--- /dev/null
+++ b/tests/src/com/android/ims/rcs/uce/presence/pidfparser/RcsContactUceCapabilityWrapperTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2022 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;
+
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import android.net.Uri;
+import android.telephony.ims.RcsContactPresenceTuple;
+import android.telephony.ims.RcsContactUceCapability;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.SmallTest;
+
+import com.android.ims.ImsTestBase;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class RcsContactUceCapabilityWrapperTest extends ImsTestBase {
+
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+    }
+
+    @Test
+    @SmallTest
+    public void testMalformedStatus() throws Exception {
+        RcsContactUceCapabilityWrapper capabilityWrapper = getRcsContactUceCapabilityWrapper();
+        capabilityWrapper.setMalformedContents();
+
+        assertTrue(capabilityWrapper.isMalformed());
+
+        RcsContactPresenceTuple.Builder tupleBuilder = new RcsContactPresenceTuple.Builder(
+                "open", "test", "1.0");
+
+        capabilityWrapper.addCapabilityTuple(tupleBuilder.build());
+        assertFalse(capabilityWrapper.isMalformed());
+    }
+
+    private RcsContactUceCapabilityWrapper getRcsContactUceCapabilityWrapper() {
+        final Uri contact = Uri.fromParts("sip", "test", null);
+        RcsContactUceCapabilityWrapper wrapper = new RcsContactUceCapabilityWrapper(contact,
+                RcsContactUceCapability.SOURCE_TYPE_NETWORK,
+                RcsContactUceCapability.REQUEST_RESULT_FOUND);
+
+        return wrapper;
+    }
+}
diff --git a/tests/src/com/android/ims/rcs/uce/presence/pidfparser/pidf/PresenceTest.java b/tests/src/com/android/ims/rcs/uce/presence/pidfparser/pidf/PresenceTest.java
index 99606f90..3a4c9f93 100644
--- a/tests/src/com/android/ims/rcs/uce/presence/pidfparser/pidf/PresenceTest.java
+++ b/tests/src/com/android/ims/rcs/uce/presence/pidfparser/pidf/PresenceTest.java
@@ -49,7 +49,6 @@ import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
 import org.xmlpull.v1.XmlPullParserFactory;
 import org.xmlpull.v1.XmlSerializer;
-
 @RunWith(AndroidJUnit4.class)
 public class PresenceTest extends ImsTestBase {
 
@@ -171,6 +170,95 @@ public class PresenceTest extends ImsTestBase {
         assertEquals(contact, PidfParserUtils.getTupleContact(tuple));
     }
 
+    @Test
+    @SmallTest
+    public void testMalformedParsing() throws Exception {
+        final String contact = Uri.fromParts("sip", "test", null).toString();
+        final String serviceId = "service_id_01";
+        final String version = "1.0";
+        final String description = "description_test";
+        final String serviceId2 = "service_id_02";
+        final String version2 = "2.0";
+        final String description2 = "description_test2";
+        final String serviceId3 = "service_id_03";
+        final String version3 = "3.0";
+        final String description3 = "description_test3";
+
+        StringBuilder presenceExample = new StringBuilder();
+        presenceExample.append("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>")
+                .append("<presence entity=\"").append(contact).append("\"")
+                .append(" xmlns=\"urn:ietf:params:xml:ns:pidf\"")
+                .append(" xmlns:op=\"urn:oma:xml:prs:pidf:oma-pres\"")
+                .append(" xmlns:caps=\"urn:ietf:params:xml:ns:pidf:caps\">")
+                .append("<tuple id=\"tid0\"><status><basic>open</basic></status>")
+                .append("<op:service-description>")
+                .append("<op:service-id>").append(serviceId).append("</op:service-id>")
+                .append("<op:version>").append(version).append("</op:version>")
+                .append("<op:description>").append(description).append("</op:description>")
+                .append("</op:service-description>")
+                .append("<contact>sip:test</contact></tuple>")
+                .append("<tuple id=\"tid1\"><status><basic>open</basic></status>")
+                .append("<op:service-ddescription>")
+                .append("<op:service-id>").append(serviceId2).append("</op:service-id>")
+                .append("<op:version>").append(version2).append("</op:version>")
+                .append("<op:description>").append(description2).append("</op:description>")
+                .append("</op:service-description>")
+                .append("<contact>sip:test</contact></tuple>")
+                .append("<tuple id=\"tid3\"><status><basic>open</basic></status>")
+                .append("<op:service-description>")
+                .append("<op:service-id>").append(serviceId3).append("</op:service-id>")
+                .append("<op:version>").append(version3).append("</op:version>")
+                .append("<op:description>").append(description3).append("</op:description>")
+                .append("</op:service-description>")
+                .append("<contact>sip:test</contact></tuple></presence>");
+
+        XmlPullParser parser = XmlPullParserFactory.newInstance().newPullParser();
+        parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
+        Reader reader = new StringReader(presenceExample.toString());
+        parser.setInput(reader);
+
+        Presence presence = null;
+        int nextType = parser.next();
+
+        // Find the start tag
+        do {
+            if (nextType == XmlPullParser.START_TAG
+                    && Presence.ELEMENT_NAME.equals(parser.getName())) {
+                presence = new Presence();
+                presence.parse(parser);
+                break;
+            }
+            nextType = parser.next();
+        } while(nextType != XmlPullParser.END_DOCUMENT);
+
+        reader.close();
+
+        assertNotNull(presence);
+        assertEquals(contact, presence.getEntity());
+
+        List<Tuple> tupleList = presence.getTupleList();
+        assertNotNull(tupleList);
+        assertEquals(3, tupleList.size());
+        assertNotNull(tupleList.get(0)); // tuple of tid0
+        assertNotNull(tupleList.get(1)); // tuple of tid1. tid1 is a tuple that failed to parse.
+        assertNotNull(tupleList.get(2)); // tuple of tid2.
+
+        Tuple tuple = tupleList.get(0);
+        assertEquals(contact, PidfParserUtils.getTupleContact(tuple));
+
+        assertEquals(serviceId, PidfParserUtils.getTupleServiceId(tuple));
+        assertEquals(version, PidfParserUtils.getTupleServiceVersion(tuple));
+        assertEquals(description, PidfParserUtils.getTupleServiceDescription(tuple));
+
+        Tuple tuple1 = tupleList.get(1);
+        assertTrue(PidfParserUtils.getTupleMalformedStatus(tuple1));
+
+        Tuple tuple3 = tupleList.get(2);
+        assertEquals(serviceId3, PidfParserUtils.getTupleServiceId(tuple3));
+        assertEquals(version3, PidfParserUtils.getTupleServiceVersion(tuple3));
+        assertEquals(description3, PidfParserUtils.getTupleServiceDescription(tuple3));
+    }
+
     private Tuple getTuple(String statusValue, String serviceIdValue, String descValue,
             String contactValue) {
         Basic basic = new Basic(statusValue);
diff --git a/tests/src/com/android/ims/rcs/uce/presence/pidfparser/pidf/TupleTest.java b/tests/src/com/android/ims/rcs/uce/presence/pidfparser/pidf/TupleTest.java
index 3c44bd2b..dc5edaa8 100644
--- a/tests/src/com/android/ims/rcs/uce/presence/pidfparser/pidf/TupleTest.java
+++ b/tests/src/com/android/ims/rcs/uce/presence/pidfparser/pidf/TupleTest.java
@@ -218,7 +218,10 @@ public class TupleTest extends ImsTestBase {
         String resultNote = null;
         List<Note> noteList = tuple.getNoteList();
         if (noteList != null && !noteList.isEmpty()) {
-            resultNote = noteList.get(0).getNote();
+            Note eachNote = noteList.get(0);
+            if (eachNote != null) {
+                resultNote = eachNote.getNote();
+            }
         }
 
         assertTrue(note.equals(resultNote));