diff --git a/apps/CtsVerifier/src/com/android/cts/verifier/p2p/testcase/DnsSdTxtRecordListenerTest.java b/apps/CtsVerifier/src/com/android/cts/verifier/p2p/testcase/DnsSdTxtRecordListenerTest.java
index 1250818..a342be4 100644
--- a/apps/CtsVerifier/src/com/android/cts/verifier/p2p/testcase/DnsSdTxtRecordListenerTest.java
+++ b/apps/CtsVerifier/src/com/android/cts/verifier/p2p/testcase/DnsSdTxtRecordListenerTest.java
@@ -17,9 +17,10 @@
 package com.android.cts.verifier.p2p.testcase;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
-import android.net.nsd.DnsSdTxtRecord;
 import android.net.wifi.p2p.WifiP2pDevice;
 import android.net.wifi.p2p.WifiP2pManager.DnsSdTxtRecordListener;
 import android.util.Log;
@@ -60,7 +61,7 @@
 
     @Override
     public void onDnsSdTxtRecordAvailable(String fullDomainName,
-            DnsSdTxtRecord record, WifiP2pDevice srcDevice) {
+            Map<String, String> record, WifiP2pDevice srcDevice) {
         Log.d(TAG, fullDomainName + " " + record + " received from "
                 + srcDevice.deviceAddress);
 
@@ -77,10 +78,10 @@
         String ippDomainName = "myprinter._ipp._tcp.local.";
         String afpDomainName = "example._afpovertcp._tcp.local.";
 
-        DnsSdTxtRecord IppTxtRecord = new DnsSdTxtRecord();
-        DnsSdTxtRecord afpTxtRecord = new DnsSdTxtRecord();
-        IppTxtRecord.set("txtvers", "1");
-        IppTxtRecord.set("pdl", "application/postscript");
+        HashMap<String, String> IppTxtRecord = new HashMap<String, String>();
+        HashMap<String, String> afpTxtRecord = new HashMap<String, String>();
+        IppTxtRecord.put("txtvers", "1");
+        IppTxtRecord.put("pdl", "application/postscript");
 
         IPP_DNS_TXT.add(new Argument(ippDomainName, IppTxtRecord));
         AFP_DNS_TXT.add(new Argument(afpDomainName, afpTxtRecord));
@@ -94,14 +95,14 @@
     static class Argument extends ListenerArgument {
 
         private String mFullDomainName;
-        private DnsSdTxtRecord mRecord;
+        private Map<String, String> mRecord;
 
         /**
          * Set the argument of {@link #onDnsSdTxtRecordAvailable}.
          * @param fullDomainName full domain name.
          * @param record txt record.
          */
-        Argument(String fullDomainName, DnsSdTxtRecord record) {
+        Argument(String fullDomainName, Map<String, String> record) {
             mFullDomainName = fullDomainName;
             mRecord = record;
         }
@@ -126,7 +127,7 @@
             return s1.equals(s2);
         }
 
-        private boolean equals(DnsSdTxtRecord s1, DnsSdTxtRecord s2) {
+        private boolean equals(Map<String, String> s1, Map<String, String> s2) {
             if (s1 == null && s2 == null) {
                 return true;
             }
diff --git a/apps/CtsVerifier/src/com/android/cts/verifier/p2p/testcase/ServRespTestCase.java b/apps/CtsVerifier/src/com/android/cts/verifier/p2p/testcase/ServRespTestCase.java
index dc4cb86..e71d12f 100644
--- a/apps/CtsVerifier/src/com/android/cts/verifier/p2p/testcase/ServRespTestCase.java
+++ b/apps/CtsVerifier/src/com/android/cts/verifier/p2p/testcase/ServRespTestCase.java
@@ -16,12 +16,12 @@
 package com.android.cts.verifier.p2p.testcase;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Timer;
 import java.util.TimerTask;
 
 import android.content.Context;
-import android.net.nsd.DnsSdTxtRecord;
 import android.net.wifi.p2p.nsd.WifiP2pDnsSdServiceInfo;
 import android.net.wifi.p2p.nsd.WifiP2pServiceInfo;
 import android.net.wifi.p2p.nsd.WifiP2pUpnpServiceInfo;
@@ -139,9 +139,9 @@
      * @return
      */
     private WifiP2pServiceInfo createIppService() {
-        DnsSdTxtRecord txtRecord = new DnsSdTxtRecord();
-        txtRecord.set("txtvers", "1");
-        txtRecord.set("pdl", "application/postscript");
+        HashMap<String, String> txtRecord = new HashMap<String, String>();
+        txtRecord.put("txtvers", "1");
+        txtRecord.put("pdl", "application/postscript");
         return WifiP2pDnsSdServiceInfo.newInstance("MyPrinter",
                 "_ipp._tcp", txtRecord);
     }
