diff --git a/src/com/android/bluetooth/btservice/AdapterService.java b/src/com/android/bluetooth/btservice/AdapterService.java
index d276781..f1be6b2 100644
--- a/src/com/android/bluetooth/btservice/AdapterService.java
+++ b/src/com/android/bluetooth/btservice/AdapterService.java
@@ -167,6 +167,8 @@
 
     private final ArrayList<DiscoveringPackage> mDiscoveringPackages = new ArrayList<>();
 
+    private static final int TYPE_BREDR = 100;
+
     static {
         classInitNative();
     }
@@ -1086,6 +1088,10 @@
             BluetoothAdapter.getDefaultAdapter().disableBluetoothGetStateCache();
         }
 
+        // TODO(b/140404592): Either implement these custom methods, or remove them from IBluetooth.
+        @Override
+        public int getDeviceType(BluetoothDevice device) { return TYPE_BREDR; }
+
         public void cleanup() {
             mService = null;
         }
