Qti-bt

core/java/android/bluetooth/BluetoothAdapter.java

@@ -84,6 +84,9 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.lang.reflect.Method;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 
 /**
  * Represents the local device Bluetooth adapter. The {@link BluetoothAdapter}
@@ -2004,6 +2007,22 @@ public boolean setActiveDevice(@NonNull BluetoothDevice device,
         return false;
     }
 
+    /** @hide */
+    @RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
+    public boolean isBroadcastActive() {
+        try {
+            mServiceLock.readLock().lock();
+            if (mService != null) {
+                return mService.isBroadcastActive(mAttributionSource);
+            }
+        } catch (RemoteException e) {
+            Log.e(TAG, "", e);
+        } finally {
+            mServiceLock.readLock().unlock();
+        }
+        return false;
+    }
+
     /**
      * Connects all enabled and supported bluetooth profiles between the local and remote device.
      * Connection is asynchronous and you should listen to each profile's broadcast intent
@@ -2987,6 +3006,92 @@ public Pair<byte[], byte[]> readOutOfBandData() {
         return null;
     }
 
+    private void closeBCProfile(BluetoothProfile proxy) {
+        Class<?> bshClass = null;
+        Method bshClose = null;
+        try {
+            bshClass = Class.forName("android.bluetooth.BluetoothSyncHelper");
+        } catch (ClassNotFoundException ex) {
+            Log.e(TAG, "no BSH: exists");
+            bshClass = null;
+        }
+        if (bshClass != null) {
+            Log.d(TAG, "Able to get BSH class handle");
+            try {
+                bshClose =  bshClass.getDeclaredMethod("close", null);
+            } catch (NoSuchMethodException e) {
+                Log.e(TAG, "no BSH:isSupported method exists");
+            }
+            if (bshClose != null) {
+                try {
+                   bshClose.invoke(proxy, null);
+                } catch(IllegalAccessException e) {
+                   Log.e(TAG, "bshClose IllegalAccessException");
+                } catch (InvocationTargetException e) {
+                   Log.e(TAG, "bshClose InvocationTargetException");
+                }
+            }
+        }
+        Log.d(TAG, "CloseBCProfile returns");
+    }
+
+    private boolean getBCProfile(Context context, BluetoothProfile.ServiceListener sl) {
+        boolean ret = true;
+        boolean isProfileSupported = false;
+        Class<?> bshClass = null;
+        Method bshSupported = null;
+        Constructor bshCons = null;
+        Object bshObj = null;
+        try {
+            bshClass = Class.forName("android.bluetooth.BluetoothSyncHelper");
+        } catch (ClassNotFoundException ex) {
+            Log.e(TAG, "no BSH: exists");
+            bshClass = null;
+        }
+        if (bshClass != null) {
+            Log.d(TAG, "Able to get BSH class handle");
+            try {
+                bshSupported =  bshClass.getDeclaredMethod("isSupported", null);
+            } catch (NoSuchMethodException e) {
+                Log.e(TAG, "no BSH:isSupported method exists: gdm");
+            }
+            try {
+                bshCons =
+                  bshClass.getDeclaredConstructor(
+                    new Class[]{Context.class,
+                        BluetoothProfile.ServiceListener.class});
+            } catch (NoSuchMethodException ex) {
+                Log.e(TAG, "bshCons: NoSuchMethodException: gdm" + ex);
+            }
+        }
+        if (bshClass != null && bshSupported != null && bshCons != null) {
+            try {
+                isProfileSupported = (boolean)bshSupported.invoke(null, null);
+            } catch(IllegalAccessException e) {
+                Log.e(TAG, "BSH:isSupported IllegalAccessException");
+            } catch (InvocationTargetException e) {
+                Log.e(TAG, "BSH:isSupported InvocationTargetException");
+            }
+            if (isProfileSupported) {
+                try {
+                    bshObj = bshCons.newInstance(
+                                       context, sl);
+                } catch (InstantiationException ex) {
+                    Log.e(TAG, "bshCons InstantiationException:" + ex);
+                } catch (IllegalAccessException ex) {
+                    Log.e(TAG, "bshCons InstantiationException:" + ex);
+                } catch (InvocationTargetException ex) {
+                    Log.e(TAG, "bshCons InvocationTargetException:" + ex);
+                }
+             }
+        }
+        if (bshObj == null) {
+            ret = false;
+        }
+        Log.d(TAG, "getBCService returns" + ret);
+        return ret;
+    }
+
     /**
      * Get the profile proxy object associated with the profile.
      *
@@ -3056,6 +3161,10 @@ public boolean getProfileProxy(Context context, BluetoothProfile.ServiceListener
         } else if (profile == BluetoothProfile.HID_DEVICE) {
             BluetoothHidDevice hidDevice = new BluetoothHidDevice(context, listener, this);
             return true;
+        } else if (profile == BluetoothProfile.BROADCAST) {
+            return getBroadcastProfile(context, listener);
+        } else if (profile == BluetoothProfile.BC_PROFILE) {
+            return getBCProfile(context, listener);
         } else if (profile == BluetoothProfile.HEARING_AID) {
             if (isHearingAidProfileSupported()) {
                 BluetoothHearingAid hearingAid = new BluetoothHearingAid(context, listener, this);
@@ -3065,6 +3174,12 @@ public boolean getProfileProxy(Context context, BluetoothProfile.ServiceListener
         } else if (profile == BluetoothProfile.LE_AUDIO) {
             BluetoothLeAudio leAudio = new BluetoothLeAudio(context, listener, this);
             return true;
+        } else if (profile == BluetoothProfile.GROUP_CLIENT) {
+            BluetoothDeviceGroup groupClient = new BluetoothDeviceGroup(context, listener);
+            return true;
+        } else if (profile == BluetoothProfile.VCP) {
+            BluetoothVcp vcp = new BluetoothVcp(context, listener);
+            return true;
         } else {
             return false;
         }
@@ -3150,13 +3265,85 @@ public void closeProfileProxy(int profile, BluetoothProfile proxy) {
                 BluetoothHidDevice hidDevice = (BluetoothHidDevice) proxy;
                 hidDevice.close();
                 break;
+            case BluetoothProfile.BROADCAST:
+                closeBroadcastProfile(proxy);
+                break;
+            case BluetoothProfile.BC_PROFILE:
+                closeBCProfile(proxy);
+                break;
             case BluetoothProfile.HEARING_AID:
                 BluetoothHearingAid hearingAid = (BluetoothHearingAid) proxy;
                 hearingAid.close();
                 break;
             case BluetoothProfile.LE_AUDIO:
                 BluetoothLeAudio leAudio = (BluetoothLeAudio) proxy;
                 leAudio.close();
+            case BluetoothProfile.GROUP_CLIENT:
+                BluetoothDeviceGroup groupClient = (BluetoothDeviceGroup) proxy;
+                groupClient.close();
+                break;
+            case BluetoothProfile.VCP:
+                BluetoothVcp vcp = (BluetoothVcp) proxy;
+                vcp.close();
+                break;
+        }
+    }
+
+    private boolean getBroadcastProfile(Context context,
+                                      BluetoothProfile.ServiceListener listener) {
+        boolean ret = true;
+        Class<?> broadcastClass = null;
+        Constructor bcastConstructor = null;
+        Object broadcastObj = null;
+        try {
+            broadcastClass = Class.forName("android.bluetooth.BluetoothBroadcast");
+        } catch (ClassNotFoundException ex) {
+            Log.e(TAG, "no BluetoothBroadcast: exists");
+        }
+        if (broadcastClass != null) {
+            try {
+               bcastConstructor =
+                            broadcastClass.getDeclaredConstructor(new Class[]{Context.class,
+                                                  BluetoothProfile.ServiceListener.class});
+            } catch (NoSuchMethodException ex) {
+               Log.e(TAG, "bcastConstructor: NoSuchMethodException: gdm" + ex);
+            }
+        }
+        if (bcastConstructor != null) {
+            try {
+                broadcastObj = bcastConstructor.newInstance(context, listener);
+            } catch (InstantiationException | IllegalAccessException |
+                InvocationTargetException ex) {
+                ex.printStackTrace();
+            }
+        }
+        if (broadcastObj == null) {
+            return false;
+        }
+        return true;
+    }
+
+    private void closeBroadcastProfile(BluetoothProfile proxy) {
+        Class<?> broadcastClass = null;
+        Method broadcastClose = null;
+        try {
+            broadcastClass = Class.forName("android.bluetooth.BluetootBroadcast");
+        } catch (ClassNotFoundException ex) {
+            Log.e(TAG, "no BluetoothBroadcast: exists");
+        }
+        if (broadcastClass != null) {
+            try {
+                broadcastClose =  broadcastClass.getDeclaredMethod("close", null);
+            } catch (NoSuchMethodException e) {
+                Log.e(TAG, "no Broadcast:close method exists");
+            }
+            if (broadcastClose != null) {
+                try {
+                    broadcastClose.invoke(proxy, null);
+                } catch(IllegalAccessException | InvocationTargetException ex) {
+                    ex.printStackTrace();
+                }
+            }
         }
     }
 
@@ -3497,6 +3684,22 @@ public void onBluetoothStateChange(boolean on) {
         }
     }
 
+    /**
+     * @hide
+     */
+    public void unregisterAdapter() {
+        try {
+            //mServiceLock.writeLock().lock();
+            if (mManagerService != null){
+                mManagerService.unregisterAdapter(mManagerCallback);
+            }
+        } catch (RemoteException e) {
+            Log.e(TAG, "", e);
+        } finally {
+            //mServiceLock.writeLock().unlock();
+        }
+    }
+
     private Set<BluetoothDevice> toDeviceSet(List<BluetoothDevice> devices) {
         Set<BluetoothDevice> deviceSet = new HashSet<BluetoothDevice>(devices);
         return Collections.unmodifiableSet(deviceSet);

core/java/android/bluetooth/BluetoothClass.java

@@ -119,6 +119,11 @@ public static final class Service {
         private static final int BITMASK = 0xFFE000;
 
         public static final int LIMITED_DISCOVERABILITY = 0x002000;
+        /**
+          * @hide
+          */
+        public static final int GROUP = 0x004000;
+
         public static final int POSITIONING = 0x010000;
         public static final int NETWORKING = 0x020000;
         public static final int RENDER = 0x040000;

core/java/android/bluetooth/BluetoothCodecConfig.java

@@ -46,7 +46,9 @@ public final class BluetoothCodecConfig implements Parcelable {
             SOURCE_CODEC_TYPE_APTX,
             SOURCE_CODEC_TYPE_APTX_HD,
             SOURCE_CODEC_TYPE_LDAC,
-            SOURCE_CODEC_TYPE_MAX,
+            SOURCE_CODEC_TYPE_APTX_ADAPTIVE,
+            SOURCE_CODEC_TYPE_APTX_TWSP,
+            SOURCE_QVA_CODEC_TYPE_MAX,
             SOURCE_CODEC_TYPE_INVALID
     })
     @Retention(RetentionPolicy.SOURCE)
@@ -70,6 +72,24 @@ public final class BluetoothCodecConfig implements Parcelable {
     @UnsupportedAppUsage
     public static final int SOURCE_CODEC_TYPE_MAX = 5;
 
+    @UnsupportedAppUsage
+    public static final int SOURCE_CODEC_TYPE_APTX_ADAPTIVE = SOURCE_CODEC_TYPE_MAX;
+
+    @UnsupportedAppUsage
+    public static final int SOURCE_CODEC_TYPE_APTX_TWSP = SOURCE_CODEC_TYPE_MAX + 1;
+
+    @UnsupportedAppUsage
+    public static final int SOURCE_QVA_CODEC_TYPE_MAX = SOURCE_CODEC_TYPE_MAX + 2;
+
+    /* CELT is not an A2DP Codec and only used to fetch encoder
+    ** format for BA usecase, moving out of a2dp codec value list
+    */
+    @UnsupportedAppUsage
+    public static final int SOURCE_CODEC_TYPE_CELT = 8;
+
+    @UnsupportedAppUsage
+    public static final int SOURCE_CODEC_TYPE_LC3 = 9;
+
     @UnsupportedAppUsage
     public static final int SOURCE_CODEC_TYPE_INVALID = 1000 * 1000;
 
@@ -126,6 +146,17 @@ public final class BluetoothCodecConfig implements Parcelable {
     @UnsupportedAppUsage
     public static final int SAMPLE_RATE_192000 = 0x1 << 5;
 
+    @UnsupportedAppUsage
+    public static final int SAMPLE_RATE_16000 = 0x1 << 6;
+
+    @UnsupportedAppUsage
+    public static final int SAMPLE_RATE_24000 = 0x1 << 7;
+
+    @UnsupportedAppUsage
+    public static final int SAMPLE_RATE_32000 = 0x1 << 8;
+
+    @UnsupportedAppUsage
+    public static final int SAMPLE_RATE_8000 = 0x1 << 9;
 
     /** @hide */
     @IntDef(prefix = "BITS_PER_SAMPLE_", value = {
@@ -168,6 +199,9 @@ public final class BluetoothCodecConfig implements Parcelable {
     @UnsupportedAppUsage
     public static final int CHANNEL_MODE_STEREO = 0x1 << 1;
 
+    @UnsupportedAppUsage
+    public static final int CHANNEL_MODE_JOINT_STEREO = 0x1 << 2;
+
     private final @SourceCodecType int mCodecType;
     private @CodecPriority int mCodecPriority;
     private final @SampleRate int mSampleRate;
@@ -403,6 +437,10 @@ public void writeToParcel(Parcel out, int flags) {
                 return "aptX HD";
             case SOURCE_CODEC_TYPE_LDAC:
                 return "LDAC";
+            case SOURCE_CODEC_TYPE_APTX_ADAPTIVE:
+                return "aptX Adaptive";
+            case SOURCE_CODEC_TYPE_APTX_TWSP:
+                return "aptX TWS+";
             case SOURCE_CODEC_TYPE_INVALID:
                 return "INVALID CODEC";
             default:
@@ -652,6 +690,10 @@ public boolean sameCodecSpecificParameters(BluetoothCodecConfig other) {
                 if (mCodecSpecific1 != other.mCodecSpecific1) {
                     return false;
                 }
+            case SOURCE_CODEC_TYPE_APTX_ADAPTIVE:
+                if (other.mCodecSpecific4 > 0) {
+                    return false;
+                }
                 // fall through
             default:
                 return true;