diff --git a/core/java/android/security/net/config/NetworkSecurityTrustManager.java b/core/java/android/security/net/config/NetworkSecurityTrustManager.java
index d9cc82a..029b674 100644
--- a/core/java/android/security/net/config/NetworkSecurityTrustManager.java
+++ b/core/java/android/security/net/config/NetworkSecurityTrustManager.java
@@ -16,16 +16,17 @@
 
 package android.security.net.config;
 
+import android.util.ArrayMap;
+
 import com.android.org.conscrypt.TrustManagerImpl;
 
-import android.util.ArrayMap;
 import java.io.IOException;
 import java.net.Socket;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
 import java.security.GeneralSecurityException;
 import java.security.KeyStore;
 import java.security.MessageDigest;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -105,7 +106,7 @@
 
     /**
      * Hostname aware version of {@link #checkServerTrusted(X509Certificate[], String)}.
-     * This interface is used by conscrypt and android.net.http.X509TrustManagerExtensions do not
+     * This interface is used by Conscrypt and android.net.http.X509TrustManagerExtensions do not
      * modify without modifying those callers.
      */
     public List<X509Certificate> checkServerTrusted(X509Certificate[] certs, String authType,
@@ -115,6 +116,19 @@
         return trustedChain;
     }
 
+    /**
+     * This interface is used by Conscrypt and android.net.http.X509TrustManagerExtensions do not
+     * modify without modifying those callers.
+     */
+    public List<X509Certificate> checkServerTrusted(X509Certificate[] certs,
+            byte[] ocspData, byte[] tlsSctData, String authType,
+            String host) throws CertificateException {
+        List<X509Certificate> trustedChain = mDelegate.checkServerTrusted(
+                certs, ocspData, tlsSctData, authType, host);
+        checkPins(trustedChain);
+        return trustedChain;
+    }
+
     private void checkPins(List<X509Certificate> chain) throws CertificateException {
         PinSet pinSet = mNetworkSecurityConfig.getPins();
         if (pinSet.pins.isEmpty()
diff --git a/core/java/android/security/net/config/OWNERS b/core/java/android/security/net/config/OWNERS
index 85ce3c6..e945ff9 100644
--- a/core/java/android/security/net/config/OWNERS
+++ b/core/java/android/security/net/config/OWNERS
@@ -1,5 +1,6 @@
-# Bug component: 36824
-set noparent
+# Bug component: 1479456
 
-cbrubaker@google.com
+bessiej@google.com
 brambonne@google.com
+sandrom@google.com
+tweek@google.com
diff --git a/core/java/android/security/net/config/RootTrustManager.java b/core/java/android/security/net/config/RootTrustManager.java
index 58dc4ba..a1bdec5 100644
--- a/core/java/android/security/net/config/RootTrustManager.java
+++ b/core/java/android/security/net/config/RootTrustManager.java
@@ -120,7 +120,7 @@
 
     /**
      * Hostname aware version of {@link #checkServerTrusted(X509Certificate[], String)}.
-     * This interface is used by conscrypt and android.net.http.X509TrustManagerExtensions do not
+     * This interface is used by Conscrypt and android.net.http.X509TrustManagerExtensions do not
      * modify without modifying those callers.
      */
     @UnsupportedAppUsage
@@ -134,6 +134,22 @@
         return config.getTrustManager().checkServerTrusted(certs, authType, hostname);
     }
 
+    /**
+     * This interface is used by Conscrypt and android.net.http.X509TrustManagerExtensions do not
+     * modify without modifying those callers.
+     */
+    public List<X509Certificate> checkServerTrusted(X509Certificate[] certs,
+            byte[] ocspData, byte[] tlsSctData, String authType,
+            String hostname) throws CertificateException {
+        if (hostname == null && mConfig.hasPerDomainConfigs()) {
+            throw new CertificateException(
+                    "Domain specific configurations require that the hostname be provided");
+        }
+        NetworkSecurityConfig config = mConfig.getConfigForHostname(hostname);
+        return config.getTrustManager().checkServerTrusted(
+                certs, ocspData, tlsSctData, authType, hostname);
+    }
+
     @Override
     public X509Certificate[] getAcceptedIssuers() {
         // getAcceptedIssuers is meant to be used to determine which trust anchors the server will
diff --git a/core/tests/coretests/src/android/net/http/OWNERS b/core/tests/coretests/src/android/net/http/OWNERS
new file mode 100644
index 0000000..c93a419
--- /dev/null
+++ b/core/tests/coretests/src/android/net/http/OWNERS
@@ -0,0 +1 @@
+include /core/java/android/net/http/OWNERS
diff --git a/native/android/OWNERS b/native/android/OWNERS
index 1fde7d2..3ea2d35 100644
--- a/native/android/OWNERS
+++ b/native/android/OWNERS
@@ -29,6 +29,7 @@
 # Input
 per-file input.cpp = file:/INPUT_OWNERS
 
-# PerformanceHint
+# ADPF
 per-file performance_hint.cpp = file:/ADPF_OWNERS
+per-file system_health.cpp = file:/ADPF_OWNERS
 per-file thermal.cpp = file:/ADPF_OWNERS
diff --git a/nfc/api/system-current.txt b/nfc/api/system-current.txt
index 6bd6072..6e69da1 100644
--- a/nfc/api/system-current.txt
+++ b/nfc/api/system-current.txt
@@ -118,7 +118,7 @@
     method public void onNdefRead(@NonNull java.util.function.Consumer<java.lang.Boolean>);
     method public void onReaderOptionChanged(boolean);
     method public void onRfDiscoveryStarted(boolean);
-    method public void onRfFieldActivated(boolean);
+    method public void onRfFieldDetected(boolean);
     method public void onRoutingChanged(@NonNull java.util.function.Consumer<java.lang.Boolean>);
     method public void onRoutingTableFull();
     method public void onStateUpdated(int);
diff --git a/nfc/java/android/nfc/INfcOemExtensionCallback.aidl b/nfc/java/android/nfc/INfcOemExtensionCallback.aidl
index e5eac0b..357d322 100644
--- a/nfc/java/android/nfc/INfcOemExtensionCallback.aidl
+++ b/nfc/java/android/nfc/INfcOemExtensionCallback.aidl
@@ -45,7 +45,7 @@
    void onHceEventReceived(int action);
    void onReaderOptionChanged(boolean enabled);
    void onCardEmulationActivated(boolean isActivated);
-   void onRfFieldActivated(boolean isActivated);
+   void onRfFieldDetected(boolean isActive);
    void onRfDiscoveryStarted(boolean isDiscoveryStarted);
    void onEeListenActivated(boolean isActivated);
    void onEeUpdated();
diff --git a/nfc/java/android/nfc/NfcOemExtension.java b/nfc/java/android/nfc/NfcOemExtension.java
index b46e343..1fc0786 100644
--- a/nfc/java/android/nfc/NfcOemExtension.java
+++ b/nfc/java/android/nfc/NfcOemExtension.java
@@ -408,12 +408,12 @@
         void onCardEmulationActivated(boolean isActivated);
 
         /**
-        * Notifies the Remote NFC Endpoint RF Field is activated.
+        * Notifies the Remote NFC Endpoint RF Field is detected.
         * NFC Forum NCI-2.3 ch.5.3 specification
         *
-        * @param isActivated true, if RF Field is ON, else RF Field is OFF.
+        * @param isActive true, if RF Field is ON, else RF Field is OFF.
         */
-        void onRfFieldActivated(boolean isActivated);
+        void onRfFieldDetected(boolean isActive);
 
         /**
         * Notifies the NFC RF discovery is started or in the IDLE state.
@@ -596,7 +596,7 @@
             Log.i(TAG, "updateNfCState");
             executor.execute(() -> {
                 callback.onCardEmulationActivated(mCardEmulationActivated);
-                callback.onRfFieldActivated(mRfFieldActivated);
+                callback.onRfFieldDetected(mRfFieldActivated);
                 callback.onRfDiscoveryStarted(mRfDiscoveryStarted);
                 callback.onEeListenActivated(mEeListenActivated);
             });
@@ -936,10 +936,10 @@
         }
 
         @Override
-        public void onRfFieldActivated(boolean isActivated) throws RemoteException {
-            mRfFieldActivated = isActivated;
+        public void onRfFieldDetected(boolean isActive) throws RemoteException {
+            mRfFieldActivated = isActive;
             mCallbackMap.forEach((cb, ex) ->
-                    handleVoidCallback(isActivated, cb::onRfFieldActivated, ex));
+                    handleVoidCallback(isActive, cb::onRfFieldDetected, ex));
         }
 
         @Override
diff --git a/nfc/tests/src/android/nfc/NfcRoutingTableEntryTest.java b/nfc/tests/src/android/nfc/NfcRoutingTableEntryTest.java
new file mode 100644
index 0000000..a90a716
--- /dev/null
+++ b/nfc/tests/src/android/nfc/NfcRoutingTableEntryTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2024 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 android.nfc;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class NfcRoutingTableEntryTest {
+
+    @Test
+    public void testAidEntry_GetAid() {
+        String expectedAid = "A00000061A02";
+        RoutingTableAidEntry entry = new RoutingTableAidEntry(1, expectedAid, 0);
+
+        assertEquals(expectedAid, entry.getAid());
+    }
+
+    @Test
+    public void testProtocolEntry_GetProtocol() {
+        RoutingTableProtocolEntry entry =
+                new RoutingTableProtocolEntry(1, RoutingTableProtocolEntry.PROTOCOL_T1T, 0);
+
+        assertEquals(RoutingTableProtocolEntry.PROTOCOL_T1T, entry.getProtocol());
+    }
+
+    @Test
+    public void testSystemCodeEntry_GetSystemCode() {
+        byte[] expectedSystemCode = {0x01, 0x02, 0x03};
+        RoutingTableSystemCodeEntry entry =
+                new RoutingTableSystemCodeEntry(1, expectedSystemCode, 0);
+
+        assertArrayEquals(expectedSystemCode, entry.getSystemCode());
+    }
+
+    @Test
+    public void testTechnologyEntry_GetTechnology_A() {
+        RoutingTableTechnologyEntry entry =
+                new RoutingTableTechnologyEntry(1, RoutingTableTechnologyEntry.TECHNOLOGY_A, 0);
+
+        assertEquals(RoutingTableTechnologyEntry.TECHNOLOGY_A, entry.getTechnology());
+    }
+}
diff --git a/nfc/tests/src/android/nfc/OemLogItemsTest.java b/nfc/tests/src/android/nfc/OemLogItemsTest.java
new file mode 100644
index 0000000..21ef804
--- /dev/null
+++ b/nfc/tests/src/android/nfc/OemLogItemsTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2024 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 android.nfc;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.time.Instant;
+
+@RunWith(JUnit4.class)
+public final class OemLogItemsTest {
+
+    @Test
+    public void testGetAction() {
+        OemLogItems item = new OemLogItems.Builder(OemLogItems.LOG_ACTION_RF_FIELD_STATE_CHANGED)
+                .build();
+        assertEquals(OemLogItems.LOG_ACTION_RF_FIELD_STATE_CHANGED, item.getAction());
+    }
+
+    @Test
+    public void testGetEvent() {
+        OemLogItems item = new OemLogItems.Builder(OemLogItems.LOG_ACTION_NFC_TOGGLE)
+                .setCallingEvent(OemLogItems.EVENT_ENABLE)
+                .build();
+        assertEquals(OemLogItems.EVENT_ENABLE, item.getEvent());
+    }
+
+    @Test
+    public void testGetCallingPid() {
+        OemLogItems item = new OemLogItems.Builder(OemLogItems.LOG_ACTION_NFC_TOGGLE)
+                .setCallingPid(1234)
+                .build();
+        assertEquals(1234, item.getCallingPid());
+    }
+
+    @Test
+    public void testGetCommandApdu() {
+        byte[] commandApdu = {0x01, 0x02, 0x03};
+        OemLogItems item = new OemLogItems.Builder(OemLogItems.LOG_ACTION_HCE_DATA)
+                .setApduCommand(commandApdu)
+                .build();
+        assertArrayEquals(commandApdu, item.getCommandApdu());
+    }
+
+    @Test
+    public void testGetResponseApdu() {
+        byte[] responseApdu = {0x04, 0x05, 0x06};
+        OemLogItems item = new OemLogItems.Builder(OemLogItems.LOG_ACTION_HCE_DATA)
+                .setApduResponse(responseApdu)
+                .build();
+        assertArrayEquals(responseApdu, item.getResponseApdu());
+    }
+
+    @Test
+    public void testGetRfFieldEventTimeMillis() {
+        Instant expectedTime = Instant.ofEpochSecond(1688768000, 123456789);
+        OemLogItems item = new OemLogItems.Builder(OemLogItems.LOG_ACTION_RF_FIELD_STATE_CHANGED)
+                .setRfFieldOnTime(expectedTime)
+                .build();
+        assertEquals(expectedTime, item.getRfFieldEventTimeMillis());
+    }
+
+    @Test
+    public void testGetTag() {
+        Tag mockTag = mock(Tag.class);
+        OemLogItems item = new OemLogItems.Builder(OemLogItems.LOG_ACTION_TAG_DETECTED)
+                .setTag(mockTag)
+                .build();
+        assertEquals(mockTag, item.getTag());
+    }
+}
diff --git a/nfc/tests/src/android/nfc/cardemulation/CardemulationTest.java b/nfc/tests/src/android/nfc/cardemulation/CardemulationTest.java
index 6be95ad..4863206 100644
--- a/nfc/tests/src/android/nfc/cardemulation/CardemulationTest.java
+++ b/nfc/tests/src/android/nfc/cardemulation/CardemulationTest.java
@@ -18,17 +18,25 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.app.role.RoleManager;
 import android.content.ComponentName;
+import android.content.ContentResolver;
 import android.content.Context;
 import android.content.pm.PackageManager;
+import android.nfc.Constants;
 import android.nfc.INfcCardEmulation;
 import android.nfc.NfcAdapter;
 import android.os.RemoteException;
 import android.os.UserHandle;
+import android.provider.Settings;
 
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 
@@ -43,6 +51,9 @@
 import org.mockito.MockitoSession;
 import org.mockito.quality.Strictness;
 
+import java.util.ArrayList;
+import java.util.List;
+
 @RunWith(AndroidJUnit4.class)
 public class CardemulationTest {
 
@@ -61,6 +72,7 @@
     public void setUp() {
         mMockitoSession = ExtendedMockito.mockitoSession()
                 .mockStatic(NfcAdapter.class)
+                .mockStatic(Settings.Secure.class)
                 .strictness(Strictness.LENIENT)
                 .startMocking();
         MockitoAnnotations.initMocks(this);
@@ -110,4 +122,163 @@
         verify(mINfcCardEmulation).isDefaultServiceForAid(1, componentName,
                 "payment");
     }
+
+    @Test
+    public void testCategoryAllowsForegroundPreference() throws Settings.SettingNotFoundException {
+        when(mContext.createContextAsUser(any(), anyInt())).thenReturn(mContext);
+        RoleManager roleManager = mock(RoleManager.class);
+        when(roleManager.isRoleAvailable(RoleManager.ROLE_WALLET)).thenReturn(false);
+        when(mContext.getSystemService(RoleManager.class)).thenReturn(roleManager);
+        ContentResolver contentResolver = mock(ContentResolver.class);
+        when(mContext.getContentResolver()).thenReturn(contentResolver);
+        when(Settings.Secure.getInt(contentResolver, Constants
+                .SETTINGS_SECURE_NFC_PAYMENT_FOREGROUND)).thenReturn(1);
+        boolean result = mCardEmulation.categoryAllowsForegroundPreference("payment");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void testGetSelectionModeForCategory() throws RemoteException {
+        when(mINfcCardEmulation.isDefaultPaymentRegistered()).thenReturn(true);
+        int result = mCardEmulation.getSelectionModeForCategory("payment");
+        assertThat(result).isEqualTo(0);
+    }
+
+    @Test
+    public void testSetShouldDefaultToObserveModeForService() throws RemoteException {
+        UserHandle userHandle = mock(UserHandle.class);
+        when(userHandle.getIdentifier()).thenReturn(1);
+        when(mContext.getUser()).thenReturn(userHandle);
+        ComponentName componentName = mock(ComponentName.class);
+        when(mINfcCardEmulation.setShouldDefaultToObserveModeForService(1, componentName, true))
+                .thenReturn(true);
+        boolean result = mCardEmulation
+                .setShouldDefaultToObserveModeForService(componentName, true);
+        assertThat(result).isTrue();
+        verify(mINfcCardEmulation).setShouldDefaultToObserveModeForService(1, componentName, true);
+    }
+
+    @Test
+    public void testRegisterPollingLoopFilterForService()throws RemoteException {
+        UserHandle userHandle = mock(UserHandle.class);
+        when(userHandle.getIdentifier()).thenReturn(1);
+        when(mContext.getUser()).thenReturn(userHandle);
+        ComponentName componentName = mock(ComponentName.class);
+        when(mINfcCardEmulation.registerPollingLoopFilterForService(anyInt(),
+                any(), anyString(), anyBoolean())).thenReturn(true);
+        boolean result = mCardEmulation.registerPollingLoopFilterForService(componentName,
+                "A0000000041010", true);
+        assertThat(result).isTrue();
+        verify(mINfcCardEmulation)
+                .registerPollingLoopFilterForService(anyInt(), any(), anyString(), anyBoolean());
+    }
+
+    @Test
+    public void testRemovePollingLoopFilterForService() throws RemoteException {
+        UserHandle userHandle = mock(UserHandle.class);
+        when(userHandle.getIdentifier()).thenReturn(1);
+        when(mContext.getUser()).thenReturn(userHandle);
+        ComponentName componentName = mock(ComponentName.class);
+        when(mINfcCardEmulation.removePollingLoopFilterForService(anyInt(), any(), anyString()))
+                .thenReturn(true);
+        boolean result = mCardEmulation
+                .removePollingLoopFilterForService(componentName, "A0000000041010");
+        assertThat(result).isTrue();
+        verify(mINfcCardEmulation).removePollingLoopFilterForService(anyInt(), any(), anyString());
+    }
+
+    @Test
+    public void testRegisterPollingLoopPatternFilterForService() throws RemoteException {
+        UserHandle userHandle = mock(UserHandle.class);
+        when(userHandle.getIdentifier()).thenReturn(1);
+        when(mContext.getUser()).thenReturn(userHandle);
+        ComponentName componentName = mock(ComponentName.class);
+        when(mINfcCardEmulation.registerPollingLoopPatternFilterForService(anyInt(), any(),
+                anyString(), anyBoolean())).thenReturn(true);
+        boolean result = mCardEmulation.registerPollingLoopPatternFilterForService(componentName,
+                "A0000000041010", true);
+        assertThat(result).isTrue();
+        verify(mINfcCardEmulation).registerPollingLoopPatternFilterForService(anyInt(), any(),
+                anyString(), anyBoolean());
+    }
+
+    @Test
+    public void testRemovePollingLoopPatternFilterForService() throws RemoteException {
+        UserHandle userHandle = mock(UserHandle.class);
+        when(userHandle.getIdentifier()).thenReturn(1);
+        when(mContext.getUser()).thenReturn(userHandle);
+        ComponentName componentName = mock(ComponentName.class);
+        when(mINfcCardEmulation.removePollingLoopPatternFilterForService(anyInt(), any(),
+                anyString())).thenReturn(true);
+        boolean result = mCardEmulation.removePollingLoopPatternFilterForService(componentName,
+                "A0000000041010");
+        assertThat(result).isTrue();
+        verify(mINfcCardEmulation).removePollingLoopPatternFilterForService(anyInt(), any(),
+                anyString());
+    }
+
+    @Test
+    public void testRegisterAidsForService() throws RemoteException {
+        UserHandle userHandle = mock(UserHandle.class);
+        when(userHandle.getIdentifier()).thenReturn(1);
+        when(mContext.getUser()).thenReturn(userHandle);
+        ComponentName componentName = mock(ComponentName.class);
+        when(mINfcCardEmulation.registerAidGroupForService(anyInt(), any(),
+                any())).thenReturn(true);
+        List<String> aids = new ArrayList<>();
+        aids.add("A0000000041010");
+        boolean result = mCardEmulation.registerAidsForService(componentName, "payment",
+                aids);
+        assertThat(result).isTrue();
+        verify(mINfcCardEmulation).registerAidGroupForService(anyInt(), any(),
+                any());
+    }
+
+    @Test
+    public void testUnsetOffHostForService() throws RemoteException {
+        UserHandle userHandle = mock(UserHandle.class);
+        when(userHandle.getIdentifier()).thenReturn(1);
+        when(mContext.getUser()).thenReturn(userHandle);
+        ComponentName componentName = mock(ComponentName.class);
+        when(mINfcCardEmulation.unsetOffHostForService(1, componentName)).thenReturn(true);
+        boolean result = mCardEmulation.unsetOffHostForService(componentName);
+        assertThat(result).isTrue();
+        verify(mINfcCardEmulation).unsetOffHostForService(1, componentName);
+    }
+
+    @Test
+    public void testSetOffHostForService() throws RemoteException {
+        UserHandle userHandle = mock(UserHandle.class);
+        when(userHandle.getIdentifier()).thenReturn(1);
+        when(mContext.getUser()).thenReturn(userHandle);
+        when(NfcAdapter.getDefaultAdapter(any())).thenReturn(mNfcAdapter);
+        List<String> elements = new ArrayList<>();
+        elements.add("eSE");
+        when(mNfcAdapter.getSupportedOffHostSecureElements()).thenReturn(elements);
+        ComponentName componentName = mock(ComponentName.class);
+        when(mINfcCardEmulation.setOffHostForService(anyInt(), any(), anyString()))
+                .thenReturn(true);
+        boolean result = mCardEmulation.setOffHostForService(componentName,
+                "eSE");
+        assertThat(result).isTrue();
+        verify(mINfcCardEmulation).setOffHostForService(anyInt(), any(), anyString());
+    }
+
+    @Test
+    public void testGetAidsForService() throws RemoteException {
+        UserHandle userHandle = mock(UserHandle.class);
+        when(userHandle.getIdentifier()).thenReturn(1);
+        when(mContext.getUser()).thenReturn(userHandle);
+        ComponentName componentName = mock(ComponentName.class);
+        List<String> elements = new ArrayList<>();
+        elements.add("eSE");
+        AidGroup aidGroup = mock(AidGroup.class);
+        when(aidGroup.getAids()).thenReturn(elements);
+        when(mINfcCardEmulation.getAidGroupForService(1, componentName, "payment"))
+                .thenReturn(aidGroup);
+        List<String> result = mCardEmulation.getAidsForService(componentName, "payment");
+        assertThat(result).isNotNull();
+        assertThat(result.size()).isGreaterThan(0);
+        verify(mINfcCardEmulation).getAidGroupForService(1, componentName, "payment");
+    }
 }
diff --git a/nfc/tests/src/android/nfc/dta/NfcDtaTest.java b/nfc/tests/src/android/nfc/dta/NfcDtaTest.java
new file mode 100644
index 0000000..38fb7ef
--- /dev/null
+++ b/nfc/tests/src/android/nfc/dta/NfcDtaTest.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2017 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 android.nfc.dta;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.nfc.INfcDta;
+import android.nfc.NfcAdapter;
+import android.os.RemoteException;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class NfcDtaTest {
+    private final String mServiceName = "serviceName";
+    private final int mServiceSap = 1;
+    private final int mMiu = 1;
+    private final int mRwSize = 1;
+    private final int mTestCaseId = 1;
+    @Mock
+    private NfcAdapter mMockNfcAdapter;
+    @Mock
+    private INfcDta mMockService;
+    @Mock
+    private Context mMockContext;
+
+    private NfcDta mNfcDta;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        when(mMockNfcAdapter.getContext()).thenReturn(mMockContext);
+        when(mMockNfcAdapter.getNfcDtaInterface()).thenReturn(mMockService);
+
+        mNfcDta = NfcDta.getInstance(mMockNfcAdapter);
+    }
+
+    @Test
+    public void testEnableData() throws RemoteException {
+        assertTrue(mNfcDta.enableDta());
+        verify(mMockService).enableDta();
+    }
+
+    @Test
+    public void testEnableDataWithRemoteException() throws RemoteException {
+        doThrow(new RemoteException()).when(mMockService).enableDta();
+
+        assertFalse(mNfcDta.enableDta());
+        verify(mMockService).enableDta();
+    }
+
+    @Test
+    public void testDisableData() throws RemoteException {
+        assertTrue(mNfcDta.disableDta());
+        verify(mMockService).disableDta();
+    }
+
+    @Test
+    public void testDisableDataWithRemoteException() throws RemoteException {
+        doThrow(new RemoteException()).when(mMockService).disableDta();
+
+        assertFalse(mNfcDta.disableDta());
+        verify(mMockService).disableDta();
+    }
+
+    @Test
+    public void testEnableServer() throws RemoteException {
+        when(mMockService.enableServer(mServiceName, mServiceSap, mMiu, mRwSize,
+                mTestCaseId)).thenReturn(true);
+
+        mNfcDta.enableServer(mServiceName, mServiceSap, mMiu, mRwSize, mTestCaseId);
+        verify(mMockService).enableServer(mServiceName, mServiceSap, mMiu, mRwSize, mTestCaseId);
+    }
+
+    @Test
+    public void testEnableServerWithRemoteException() throws RemoteException {
+        doThrow(new RemoteException()).when(mMockService).enableServer(mServiceName, mServiceSap,
+                mMiu,
+                mRwSize, mTestCaseId);
+
+        mNfcDta.enableServer(mServiceName, mServiceSap, mMiu, mRwSize, mTestCaseId);
+        verify(mMockService).enableServer(mServiceName, mServiceSap, mMiu, mRwSize, mTestCaseId);
+    }
+
+    @Test
+    public void testDisableServer() throws RemoteException {
+        assertTrue(mNfcDta.disableServer());
+        verify(mMockService).disableServer();
+    }
+
+    @Test
+    public void testDisableServerWithRemoteException() throws RemoteException {
+        doThrow(new RemoteException()).when(mMockService).disableServer();
+
+        assertFalse(mNfcDta.disableServer());
+        verify(mMockService).disableServer();
+    }
+
+    @Test
+    public void testEnableClient() throws RemoteException {
+        when(mMockService.enableClient(mServiceName, mMiu, mRwSize, mTestCaseId)).thenReturn(true);
+
+        mNfcDta.enableClient(mServiceName, mMiu, mRwSize, mTestCaseId);
+        verify(mMockService).enableClient(mServiceName, mMiu, mRwSize, mTestCaseId);
+    }
+
+    @Test
+    public void testEnableClientWithRemoteException() throws RemoteException {
+        doThrow(new RemoteException()).when(mMockService).enableClient(mServiceName, mMiu, mRwSize,
+                mTestCaseId);
+
+        mNfcDta.enableClient(mServiceName, mMiu, mRwSize, mTestCaseId);
+        verify(mMockService).enableClient(mServiceName, mMiu, mRwSize, mTestCaseId);
+    }
+
+    @Test
+    public void testDisableClient() throws RemoteException {
+        assertTrue(mNfcDta.disableClient());
+        verify(mMockService).disableClient();
+    }
+
+    @Test
+    public void testDisableClientWithRemoteException() throws RemoteException {
+        doThrow(new RemoteException()).when(mMockService).disableClient();
+
+        assertFalse(mNfcDta.disableClient());
+        verify(mMockService).disableClient();
+    }
+
+    @Test
+    public void testRegisterMessageService() throws RemoteException {
+        String msgServiceName = "sampleServiceName";
+        when(mMockService.registerMessageService(msgServiceName)).thenReturn(true);
+
+        mNfcDta.registerMessageService(msgServiceName);
+        verify(mMockService).registerMessageService(msgServiceName);
+    }
+
+    @Test
+    public void testRegisterMessageServiceWithRemoteException() throws RemoteException {
+        String msgServiceName = "sampleServiceName";
+        doThrow(new RemoteException()).when(mMockService).registerMessageService(msgServiceName);
+
+        assertFalse(mNfcDta.registerMessageService(msgServiceName));
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testGetInstanceWithNullPointerException() {
+        NfcDta.getInstance(null);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testGetInstanceWithUnsupportedOperationExceptionForNfcAdapterContext() {
+        when(mMockNfcAdapter.getContext()).thenReturn(null);
+
+        NfcDta.getInstance(mMockNfcAdapter);
+    }
+}
diff --git a/nfc/tests/src/android/nfc/tech/NfcBarcodeTest.java b/nfc/tests/src/android/nfc/tech/NfcBarcodeTest.java
new file mode 100644
index 0000000..3aa4e2c
--- /dev/null
+++ b/nfc/tests/src/android/nfc/tech/NfcBarcodeTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2012 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 android.nfc.tech;
+
+import static android.nfc.tech.NfcBarcode.EXTRA_BARCODE_TYPE;
+import static android.nfc.tech.NfcBarcode.TYPE_KOVIO;
+import static android.nfc.tech.NfcBarcode.TYPE_UNKNOWN;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.nfc.Tag;
+import android.os.Bundle;
+import android.os.RemoteException;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class NfcBarcodeTest {
+    @Mock
+    private Tag mMockTag;
+    @Mock
+    private Bundle mMockBundle;
+    private NfcBarcode mNfcBarcode;
+
+    @Before
+    public void setUp() throws RemoteException {
+        MockitoAnnotations.initMocks(this);
+        when(mMockBundle.getInt(EXTRA_BARCODE_TYPE)).thenReturn(TYPE_KOVIO);
+        when(mMockTag.getTechExtras(TagTechnology.NFC_BARCODE)).thenReturn(mMockBundle);
+
+        mNfcBarcode = new NfcBarcode(mMockTag);
+    }
+
+    @Test
+    public void testGetNfcBarcodeInstance() {
+        Tag mockTag = mock(Tag.class);
+        when(mockTag.hasTech(TagTechnology.NFC_BARCODE)).thenReturn(true);
+        when(mockTag.getTechExtras(TagTechnology.NFC_BARCODE)).thenReturn(mMockBundle);
+
+        assertNotNull(NfcBarcode.get(mockTag));
+        verify(mockTag).hasTech(TagTechnology.NFC_BARCODE);
+        verify(mockTag).getTechExtras(TagTechnology.NFC_BARCODE);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testGetNfcBarcodeInstanceWithException() {
+        Tag mockTag = mock(Tag.class);
+        when(mockTag.hasTech(TagTechnology.NFC_BARCODE)).thenReturn(true);
+        when(mockTag.getTechExtras(TagTechnology.NFC_BARCODE)).thenReturn(null);
+
+        assertNull(NfcBarcode.get(mockTag));
+        verify(mockTag).hasTech(TagTechnology.NFC_BARCODE);
+        verify(mockTag).getTechExtras(TagTechnology.NFC_BARCODE);
+    }
+
+    @Test
+    public void testGetNfcBarcodeWithoutTech() {
+        when(mMockTag.hasTech(TagTechnology.NFC_BARCODE)).thenReturn(false);
+
+        assertNull(NfcBarcode.get(mMockTag));
+    }
+
+    @Test
+    public void testGetType() {
+        int result = mNfcBarcode.getType();
+        assertEquals(TYPE_KOVIO, result);
+    }
+
+    @Test
+    public void testGetBarcodeWithTypeKovio() {
+        byte[] sampleId = "sampleId".getBytes();
+        when(mMockTag.getId()).thenReturn(sampleId);
+
+        assertEquals(sampleId, mNfcBarcode.getBarcode());
+        verify(mMockTag).getId();
+    }
+
+    @Test
+    public void testGetBarCodeTypeUnknown() throws RemoteException {
+        when(mMockBundle.getInt(EXTRA_BARCODE_TYPE)).thenReturn(TYPE_UNKNOWN);
+        when(mMockTag.getTechExtras(TagTechnology.NFC_BARCODE)).thenReturn(mMockBundle);
+        mNfcBarcode = new NfcBarcode(mMockTag);
+
+        assertNull(mNfcBarcode.getBarcode());
+        verify(mMockTag, never()).getId();
+    }
+}
diff --git a/nfc/tests/src/android/nfc/tech/NfcVTest.java b/nfc/tests/src/android/nfc/tech/NfcVTest.java
new file mode 100644
index 0000000..6a99921
--- /dev/null
+++ b/nfc/tests/src/android/nfc/tech/NfcVTest.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2010 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 android.nfc.tech;
+
+import static android.nfc.tech.NfcV.EXTRA_DSFID;
+import static android.nfc.tech.NfcV.EXTRA_RESP_FLAGS;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.nfc.INfcTag;
+import android.nfc.Tag;
+import android.nfc.TransceiveResult;
+import android.os.Bundle;
+import android.os.RemoteException;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.io.IOException;
+
+public class NfcVTest {
+    private final byte mSampleRespFlags = (byte) 1;
+    private final byte mSampleDsfId = (byte) 2;
+    @Mock
+    private Tag mMockTag;
+    @Mock
+    private INfcTag mMockTagService;
+    @Mock
+    private Bundle mMockBundle;
+    private NfcV mNfcV;
+
+    @Before
+    public void setUp() throws RemoteException {
+        MockitoAnnotations.initMocks(this);
+        when(mMockBundle.getByte(EXTRA_RESP_FLAGS)).thenReturn(mSampleRespFlags);
+        when(mMockBundle.getByte(EXTRA_DSFID)).thenReturn(mSampleDsfId);
+        when(mMockTag.getTechExtras(TagTechnology.NFC_V)).thenReturn(mMockBundle);
+
+        mNfcV = new NfcV(mMockTag);
+    }
+
+    @Test
+    public void testGetResponseFlag() {
+        assertEquals(mSampleRespFlags, mNfcV.getResponseFlags());
+    }
+
+    @Test
+    public void testGetDsfId() {
+        assertEquals(mSampleDsfId, mNfcV.getDsfId());
+    }
+
+    @Test
+    public void testGetNfcVInstance() {
+        Tag tag = mock(Tag.class);
+        when(tag.hasTech(TagTechnology.NFC_V)).thenReturn(true);
+        when(tag.getTechExtras(TagTechnology.NFC_V)).thenReturn(mMockBundle);
+
+        assertNotNull(NfcV.get(tag));
+        verify(tag).getTechExtras(TagTechnology.NFC_V);
+        verify(tag).hasTech(TagTechnology.NFC_V);
+    }
+
+    @Test
+    public void testGetNfcVNullInstance() {
+        Tag tag = mock(Tag.class);
+        when(tag.hasTech(TagTechnology.NFC_V)).thenReturn(false);
+
+        assertNull(NfcV.get(tag));
+        verify(tag, never()).getTechExtras(TagTechnology.NFC_V);
+        verify(tag).hasTech(TagTechnology.NFC_V);
+    }
+
+    @Test
+    public void testTransceive() throws IOException, RemoteException {
+        byte[] sampleData = new byte[] {1, 2, 3, 4, 5};
+        TransceiveResult mockTransceiveResult = mock(TransceiveResult.class);
+        when(mMockTag.getConnectedTechnology()).thenReturn(TagTechnology.NFC_V);
+        when(mMockTag.getTagService()).thenReturn(mMockTagService);
+        when(mMockTag.getServiceHandle()).thenReturn(1);
+        when(mMockTagService.transceive(1, sampleData, true))
+                .thenReturn(mockTransceiveResult);
+        when(mockTransceiveResult.getResponseOrThrow()).thenReturn(sampleData);
+
+        mNfcV.transceive(sampleData);
+        verify(mMockTag).getTagService();
+        verify(mMockTag).getServiceHandle();
+    }
+
+    @Test
+    public void testGetMaxTransceiveLength() throws RemoteException {
+        when(mMockTag.getTagService()).thenReturn(mMockTagService);
+        when(mMockTagService.getMaxTransceiveLength(TagTechnology.NFC_V)).thenReturn(1);
+
+        mNfcV.getMaxTransceiveLength();
+        verify(mMockTag).getTagService();
+    }
+}
diff --git a/services/core/java/com/android/server/powerstats/PowerStatsLogger.java b/services/core/java/com/android/server/powerstats/PowerStatsLogger.java
index e80a86d..4fd026a 100644
--- a/services/core/java/com/android/server/powerstats/PowerStatsLogger.java
+++ b/services/core/java/com/android/server/powerstats/PowerStatsLogger.java
@@ -285,14 +285,20 @@
     }
 
     private void updateCacheFile(String cacheFilename, byte[] data) {
+        AtomicFile atomicCachedFile = null;
+        FileOutputStream fos = null;
         try {
-            final AtomicFile atomicCachedFile =
+            atomicCachedFile =
                     new AtomicFile(new File(mDataStoragePath, cacheFilename));
-            final FileOutputStream fos = atomicCachedFile.startWrite();
+            fos = atomicCachedFile.startWrite();
             fos.write(data);
             atomicCachedFile.finishWrite(fos);
         } catch (IOException e) {
             Slog.e(TAG, "Failed to write current data to cached file", e);
+            if (fos != null) {
+                atomicCachedFile.failWrite(fos);
+            }
+            return;
         }
     }