| /****************************************************************************** |
| * |
| * Copyright 2021 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.bluetooth.broadcast; |
| |
| import static android.Manifest.permission.BLUETOOTH_CONNECT; |
| |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothBroadcast; |
| import android.bluetooth.BluetoothA2dp; |
| import android.bluetooth.BluetoothCodecConfig; |
| import android.bluetooth.BluetoothCodecStatus; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.BluetoothProfile; |
| import android.bluetooth.BluetoothUuid; |
| import android.bluetooth.IBluetoothBroadcast; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.media.AudioManager; |
| import android.os.HandlerThread; |
| import android.util.Log; |
| import android.util.StatsLog; |
| import java.nio.charset.Charset; |
| import java.nio.charset.StandardCharsets; |
| |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.os.SystemClock; |
| import android.os.SystemProperties; |
| |
| import com.android.bluetooth.BluetoothMetricsProto; |
| import com.android.bluetooth.Utils; |
| import com.android.bluetooth.avrcp.Avrcp; |
| import com.android.bluetooth.avrcp.Avrcp_ext; |
| import com.android.bluetooth.avrcp.AvrcpTargetService; |
| import com.android.bluetooth.a2dp.A2dpService; |
| import com.android.bluetooth.btservice.AdapterService; |
| import com.android.bluetooth.btservice.MetricsLogger; |
| import com.android.bluetooth.btservice.ProfileService; |
| import com.android.bluetooth.btservice.ServiceFactory; |
| import com.android.bluetooth.ba.BATService; |
| import com.android.bluetooth.gatt.GattService; |
| import com.android.internal.annotations.GuardedBy; |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.bluetooth.hfp.HeadsetService; |
| import android.bluetooth.BluetoothGatt; |
| import android.bluetooth.le.AdvertiseCallback; |
| import android.bluetooth.le.AdvertiseData; |
| import android.bluetooth.le.AdvertiseSettings; |
| import android.bluetooth.le.AdvertisingSet; |
| import android.bluetooth.le.AdvertisingSetCallback; |
| import android.bluetooth.le.AdvertisingSetParameters; |
| import android.bluetooth.le.BluetoothLeAdvertiser; |
| import android.bluetooth.le.PeriodicAdvertisingParameters; |
| import android.media.MediaMetadata; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.ConcurrentMap; |
| import java.util.UUID; |
| import java.util.HashMap; |
| import android.os.ParcelUuid; |
| import java.io.IOException; |
| import java.util.Collections; |
| import java.util.Map; |
| |
| import com.android.bluetooth.apm.ActiveDeviceManagerService; |
| import com.android.bluetooth.apm.ApmConst; |
| import com.android.bluetooth.apm.DeviceProfileMap; |
| import com.android.bluetooth.apm.MediaAudio; |
| |
| /** |
| * Provides Bluetooth Broadcast profile, as a service in the Bluetooth application. |
| * @hide |
| */ |
| public class BroadcastService extends ProfileService { |
| private static final boolean DBG = true; |
| private static final boolean VDBG = true; |
| private static final String TAG = "BroadcastService"; |
| private final Object mBroadcastLock = new Object(); |
| private static BroadcastService sBroadcastService; |
| private AdapterService mAdapterService; |
| @VisibleForTesting |
| BroadcastNativeInterface mBroadcastNativeInterface; |
| @VisibleForTesting |
| ServiceFactory mFactory = new ServiceFactory(); |
| private AudioManager mAudioManager; |
| int mBroadcastState = BluetoothBroadcast.STATE_DISABLED; |
| int mBroadcastAudioState = BluetoothBroadcast.STATE_NOT_PLAYING; |
| private String mEncryptionString; |
| private byte[] mEncKey = new byte[16]; |
| private byte [] BigBroadcastCode = new byte [16]; |
| private byte [] mBroadcastID = new byte[3]; |
| private final int mBroadcastIdLength = 3; |
| private boolean mEncryptionEnabled = true; |
| private boolean mPartialSimulcast = false;//dual quality simulcast |
| private boolean mEncKeyRefreshed = false; |
| private int mEncryptionLength =16; |
| private int mDefaultEncryptionLength = 16; |
| private int [] bis_handles; |
| private int mBIGHandle = -1; |
| private int mNumBises = -1; |
| private int mNumSubGrps = 1; |
| private int mPD = 0; |
| private boolean goingDown = false; |
| private boolean mIsAdvertising = false; |
| private BroadcastMessageHandler mHandler; |
| private AdvertisingSetCallback mCallback; |
| private AdvertisingSet mAdvertisingSet; |
| List <BisInfo> mBisInfo; |
| Map<Integer, MetadataLtv>mMetaInfo = Collections.synchronizedMap(new HashMap<>());; |
| private String mAdvAddress; |
| private int mAdvAddressType; |
| private BluetoothLeAdvertiser mAdvertiser; |
| private BluetoothCodecStatus mCodecStatus; |
| private BluetoothCodecConfig mCodecConfig; |
| private BluetoothCodecConfig mHapCodecConfig; |
| private BroadcastCodecConfig mBroadcastCodecConfig; |
| private BroadcastAdvertiser mBroadcastAdvertiser; |
| private int mBroadcastConfigSettings; |
| private BluetoothAdapter mBluetoothAdapter; |
| private BluetoothDevice mBroadcastDevice = null; |
| private boolean mBroadcastDeviceIsActive = false; |
| TrackMetadata mTrackMetadata; |
| private String mBroadcastAddress = "FA:CE:FA:CE:FA:CE"; |
| ActiveDeviceManagerService mActiveDeviceManager; |
| public static UUID BROADCAST_AUDIO_UUID = UUID.fromString("00001852-0000-1000-8000-00805F9B34FB"); |
| public static UUID BASIC_AUDIO_UUID = UUID.fromString("00001851-0000-1000-8000-00805F9B34FB"); |
| private BroadcastBase mBroadcastBase; |
| private MediaAudio mMediaAudio; |
| private boolean new_codec_id = false; |
| private static int mSecPhy = 1; |
| private static int mTxPowerLevel = 1; |
| private static int mPaInt; |
| private boolean mNewVersion = false; |
| List <String> broadcast_supported_config = new ArrayList<String>(List.of("16_2", "24_2", "48_1", "48_2", "48_3", "48_4", "48_5", "48_6")); |
| private static final int MSG_ENABLE_BROADCAST = 1; |
| private static final int MSG_DISABLE_BROADCAST = 2; |
| private static final int MSG_SET_ENCRYPTION_KEY = 3; |
| private static final int MSG_GET_ENCRYPTION_KEY = 4; |
| private static final int MSG_SET_BROADCAST_ACTIVE = 5; |
| private static final int MSG_UPDATE_BROADCAST_ADV_SET = 6; |
| private static final int MSG_ADV_DATA_SET = 7; |
| private static final int MSG_SET_AUDIO_PATH = 8; |
| private static final int MSG_RESET_ENCRYPTION_FLAG_TIMEOUT = 9; |
| private static final int MSG_FROM_NATIVE_CODEC_STATE = 10; |
| private static final int MSG_FROM_NATIVE_BROADCAST_STATE = 11; |
| private static final int MSG_FROM_NATIVE_ENCRYPTION_KEY = 12; |
| private static final int MSG_FROM_NATIVE_BROADCAST_AUDIO_STATE = 13; |
| private static final int MSG_FROM_NATIVE_SETUP_BIG = 14; |
| private static final int MSG_UPDATE_BROADCAST_STATE = 15; |
| private static final int MSG_FROM_NATIVE_BROADCAST_ID = 16; |
| @Override |
| protected IProfileServiceBinder initBinder() { |
| return new BluetoothBroadcastBinder(this); |
| } |
| |
| @Override |
| protected void create() { |
| Log.i(TAG, "create()"); |
| } |
| |
| @Override |
| protected boolean start() { |
| Log.i(TAG, "start()"); |
| if (sBroadcastService != null) { |
| Log.w(TAG, "Broadcastervice is already running"); |
| return true; |
| } |
| if (mHandler != null) |
| mHandler = null; |
| mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(), |
| "AdapterService cannot be null when A2dpService starts"); |
| |
| mBroadcastNativeInterface = Objects.requireNonNull(mBroadcastNativeInterface.getInstance(), |
| "BroadcastNativeInterface cannot be null when BroadcastService starts"); |
| mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); |
| Objects.requireNonNull(mAudioManager, |
| "AudioManager cannot be null when A2dpService starts"); |
| HandlerThread thread = new HandlerThread("BroadcastHandler"); |
| mBroadcastConfigSettings = SystemProperties.getInt("persist.vendor.btstack.bap_ba_setting", 4); |
| mBroadcastCodecConfig = new BroadcastCodecConfig(); |
| String PartialSimulcast = SystemProperties.get("persist.vendor.btstack.partial_simulcast"); |
| if (!PartialSimulcast.isEmpty() && "true".equals(PartialSimulcast)) { |
| mPartialSimulcast = true; |
| mNumSubGrps = 2; |
| mNumBises = 4; |
| //mHapCodecConfig = new BroadcastCodecConfig(mPartialSimulcast); |
| } |
| String mNewCodecId = SystemProperties.get("persist.vendor.btstack.new_lc3_id"); |
| if (mNewCodecId.isEmpty() || "true".equals(mNewCodecId) || |
| "6".equals(mNewCodecId)) { |
| new_codec_id = true; |
| } |
| /* Property to set seconday advertising phy to 1M or 2M. 2M is selected by default |
| * if propety is not set |
| */ |
| mSecPhy = SystemProperties.getInt("persist.vendor.btstack.secphy", 2); |
| mTxPowerLevel = SystemProperties.getInt("persist.vendor.service.bt.txpower", 9); |
| mPD = SystemProperties.getInt("persist.vendor.service.bt.presentation_delay", 40); |
| mPaInt = SystemProperties.getInt("persist.vendor.btstack.pa_interval", 360); |
| mNewVersion = SystemProperties.getBoolean("persist.vendor.service.bt.new_ba_version", true); |
| int offload_mode = 1; //offload |
| mBroadcastNativeInterface.init(1, mCodecConfig,offload_mode); |
| thread.start(); |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED); |
| mAdapterService.registerReceiver(mBroadcastReceiver, filter); |
| Looper looper = thread.getLooper(); |
| mHandler = new BroadcastMessageHandler(looper); |
| mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); |
| mBroadcastBase = new BroadcastBase(); |
| mBisInfo = new ArrayList<>(); |
| //mBroadcastAdvertiser = new BroadcastAdvertiser(); |
| setBroadcastService(this); |
| mBroadcastDevice = mAdapter.getRemoteDevice(mBroadcastAddress); |
| mTrackMetadata = new TrackMetadata(null); |
| |
| mActiveDeviceManager = ActiveDeviceManagerService.get(this); |
| DeviceProfileMap dpm = DeviceProfileMap.getDeviceProfileMapInstance(); |
| dpm.profileConnectionUpdate(mBroadcastDevice, ApmConst.AudioFeatures.BROADCAST_AUDIO, ApmConst.AudioProfiles.BROADCAST_LE, true); |
| |
| //Get current codec and call native init |
| return true; |
| } |
| private void initialize_advertiser() { |
| Log.d(TAG,"initalize_advertiser"); |
| mBroadcastAdvertiser = new BroadcastAdvertiser(); |
| GetEncryptionKeyFromNative(); |
| } |
| private void startAdvTest() { |
| //Log.d(TAG,"startAdvTest!!!"); |
| boolean ba_test = SystemProperties.getBoolean("persist.vendor.btstack.batest",false); |
| if (ba_test) { |
| Log.d(TAG,"startAdvTest!!!"); |
| EnableBroadcast(null); |
| } |
| } |
| private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) { |
| int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE,BluetoothAdapter.ERROR); |
| Log.d(TAG,"action: " + action + " state: " + state); |
| if (state == BluetoothAdapter.STATE_ON) { |
| initialize_advertiser(); |
| startAdvTest(); |
| } else if (state == BluetoothAdapter.STATE_TURNING_OFF) { |
| if (sBroadcastService != null) |
| cleanup_broadcast(); |
| } |
| } |
| } |
| }; |
| @Override |
| protected boolean stop() { |
| Log.i(TAG, "stop()"); |
| if (sBroadcastService == null) { |
| Log.w(TAG, "stop() called before start()"); |
| return true; |
| } |
| notifyBroadcastEnabled(false); |
| if (mIsAdvertising) { |
| mBroadcastAdvertiser.stopBroadcastAdvertising(); |
| } |
| mAdapterService = null; |
| mBroadcastNativeInterface = null; |
| mAudioManager = null; |
| mIsAdvertising = false; |
| Looper looper = mHandler.getLooper(); |
| if (looper != null) { |
| looper.quit(); |
| } |
| setBroadcastService(null); |
| return true; |
| } |
| |
| @Override |
| protected void cleanup() { |
| Log.i(TAG, "cleanup()"); |
| } |
| public static synchronized BroadcastService getBroadcastService() { |
| if (sBroadcastService == null) { |
| Log.w(TAG, "getBroadcastService(): service is null"); |
| return null; |
| } |
| if (!sBroadcastService.isAvailable()) { |
| Log.w(TAG, "getBroadcastService(): service is not available"); |
| return null; |
| } |
| return sBroadcastService; |
| } |
| |
| /** Handles Broadcast messages. */ |
| private final class BroadcastMessageHandler extends Handler { |
| private BroadcastMessageHandler(Looper looper) { |
| super(looper); |
| } |
| @Override |
| public void handleMessage(Message msg) { |
| Log.v(TAG, "BroadcastMessageHandler: received message=" + msg.what); |
| int prev_state; |
| switch (msg.what) { |
| case MSG_ENABLE_BROADCAST: |
| //int prev_state; |
| synchronized (mBroadcastLock) { |
| if (VDBG) { |
| Log.i(TAG, "Setting broadcast state to ENABLING"); |
| } |
| prev_state = mBroadcastState; |
| mBroadcastState = BluetoothBroadcast.STATE_ENABLING; |
| } |
| broadcastState(mBroadcastState, prev_state); |
| mBroadcastNativeInterface.enableBroadcast(mCodecConfig); |
| break; |
| case MSG_DISABLE_BROADCAST: |
| //int prev_state; |
| goingDown = true; |
| if (!mIsAdvertising) { |
| Log.e(TAG, "Broadcast is not advertising"); |
| break; |
| } |
| synchronized(mBroadcastLock) { |
| if (VDBG) { |
| Log.i(TAG,"Disabling broadcast, setting state to DISABLING"); |
| } |
| prev_state = mBroadcastState; |
| mBroadcastState = BluetoothBroadcast.STATE_DISABLING; |
| } |
| broadcastState(mBroadcastState, prev_state); |
| mBroadcastNativeInterface.disableBroadcast(mAdvertisingSet.getAdvertiserId()); |
| //mBroadcastAdvertiser.stopBroadcastAdvertising(); |
| break; |
| case MSG_SET_ENCRYPTION_KEY: |
| //int length = msg.arg1; |
| mBroadcastNativeInterface.SetEncryptionKey(mEncryptionEnabled, mEncryptionLength); |
| if (mEncryptionLength == 0) { |
| for(int i = 0; i < mDefaultEncryptionLength; i++) { |
| BigBroadcastCode[i] = 0x00; |
| } |
| broadcastEncryptionkeySet(); |
| } |
| break; |
| case MSG_GET_ENCRYPTION_KEY: { |
| mEncryptionString = mBroadcastNativeInterface.GetEncryptionKey(); |
| if (mEncryptionString == null) { |
| Log.e(TAG,"MSG_GET_ENCRYPTION_KEY: mEncryptionString null"); |
| for (int i = 0; i < mDefaultEncryptionLength; i++) { |
| BigBroadcastCode[i] = 0x00; |
| } |
| break; |
| } |
| mEncKey= mEncryptionString.getBytes(); |
| Log.i(TAG, "mEncryptionString: " + mEncryptionString); |
| System.arraycopy(mEncKey, 0, BigBroadcastCode, 0, mEncKey.length); |
| if (mEncKey.length < mDefaultEncryptionLength) { |
| for (int i = mEncKey.length; i < mDefaultEncryptionLength; i++) { |
| BigBroadcastCode[i] = 0x00; |
| } |
| } |
| for (int i = 0;i < mDefaultEncryptionLength/2; i++) { |
| byte temp = BigBroadcastCode[i]; |
| BigBroadcastCode[i] = BigBroadcastCode[(mDefaultEncryptionLength -1) - i]; |
| BigBroadcastCode[(mDefaultEncryptionLength -1) - i] = temp; |
| } |
| for (int i = 0; i < 16; i++) { |
| Log.i(TAG,"BigBroadcastCode["+ i + "] = " + BigBroadcastCode[i]); |
| } |
| //TODO: Stub to test encryption key creation, to be removed |
| //Log.i(TAG,"calling setencryptionkey"); |
| //mBroadcastNativeInterface.SetEncryptionKey(4); |
| broadcastEncryptionkeySet(); |
| } |
| break; |
| case MSG_UPDATE_BROADCAST_ADV_SET: |
| break; |
| case MSG_SET_BROADCAST_ACTIVE: |
| // Call native layer to set broadcast active |
| //mBroadcastNativeInterface.setActiveDevice(true, mAdvertisingSet.getAdvertiserId()); |
| //setActiveDevice(mBroadcastDevice); |
| notifyBroadcastEnabled(true); |
| break; |
| case MSG_RESET_ENCRYPTION_FLAG_TIMEOUT: |
| Log.i(TAG,"Setting mEncKeyRefreshed to false"); |
| mEncKeyRefreshed = false; |
| break; |
| case MSG_FROM_NATIVE_BROADCAST_STATE: |
| synchronized(mBroadcastLock) { |
| prev_state = mBroadcastState; |
| mBroadcastState = msg.arg1; |
| if (VDBG) { |
| Log.i(TAG,"New broadcast state: " + mBroadcastState); |
| } |
| } |
| if (mBroadcastState == BluetoothBroadcast.STATE_DISABLED) { |
| if (goingDown) { |
| notifyBroadcastEnabled(false); |
| } |
| mBIGHandle = -1; |
| mBroadcastAdvertiser.stopBroadcastAdvertising(); |
| break; |
| } |
| if (prev_state != mBroadcastState) |
| broadcastState(mBroadcastState, prev_state); |
| break; |
| case MSG_ADV_DATA_SET: |
| synchronized (mBroadcastLock) { |
| if (VDBG) { |
| Log.i(TAG, "Setting broadcast state to ENABLING"); |
| } |
| prev_state = mBroadcastState; |
| mBroadcastState = BluetoothBroadcast.STATE_ENABLED; |
| } |
| broadcastState(mBroadcastState, prev_state); |
| break; |
| case MSG_SET_AUDIO_PATH: |
| //mBroadcastNativeInterface.SetupAudioPath(true,mAdvertisingSet.getAdvertiserId(),mBIGHandle,mNumBises,bis_handles); |
| break; |
| case MSG_FROM_NATIVE_CODEC_STATE: |
| mCodecStatus = (BluetoothCodecStatus)msg.obj; |
| if (IsCodecConfigChanged(mCodecStatus.getCodecConfig())) { |
| mBroadcastCodecConfig.updateBroadcastCodecConfig(mCodecStatus.getCodecConfig()); |
| mBroadcastBase.populateBase(); |
| mBroadcastAdvertiser.updatePAwithBase(); |
| } |
| broadcastCodecConfig(mCodecStatus); |
| mMediaAudio = MediaAudio.get(); |
| mMediaAudio.onCodecConfigChange(mBroadcastDevice, mCodecStatus, ApmConst.AudioProfiles.BROADCAST_LE); |
| break; |
| case MSG_FROM_NATIVE_ENCRYPTION_KEY: { |
| mEncryptionString = (String)msg.obj; |
| Log.d(TAG,"mEncryptionString: " + mEncryptionString); |
| mEncKey= mEncryptionString.getBytes(); |
| System.arraycopy(mEncKey, 0, BigBroadcastCode, 0, mEncKey.length); |
| if (mEncKey.length < mDefaultEncryptionLength) { |
| for (int i = mEncKey.length; i < mDefaultEncryptionLength; i++) { |
| BigBroadcastCode[i] = 0x00; |
| } |
| } |
| for (int i = 0; i < mEncKey.length; i++) { |
| Log.d(TAG,"mEnc[" + i +"] = " + mEncKey[i]); |
| } |
| for (int i = 0;i < mDefaultEncryptionLength/2; i++) { |
| byte temp = BigBroadcastCode[i]; |
| BigBroadcastCode[i] = BigBroadcastCode[(mDefaultEncryptionLength - 1) - i]; |
| BigBroadcastCode[(mDefaultEncryptionLength - 1) - i] = temp; |
| } |
| //Broadcast encyption key set |
| broadcastEncryptionkeySet(); |
| } |
| break; |
| case MSG_FROM_NATIVE_SETUP_BIG: |
| int setup = msg.arg1; |
| boolean set = (setup == 1); |
| if (set) { |
| Log.d(TAG, "BIG created: " + mBIGHandle + "with no of bises: " + mNumBises); |
| mNumBises = mNumBises * mNumSubGrps; |
| mBroadcastBase.populateBase(); |
| mBroadcastAdvertiser.updatePAwithBase(); |
| } else { |
| Log.d(TAG, "BIG terminated"); |
| mBIGHandle = -1; |
| //Clean up mBisInfo List |
| mBisInfo.clear(); |
| mMetaInfo.clear(); |
| } |
| break; |
| case MSG_FROM_NATIVE_BROADCAST_AUDIO_STATE: |
| int prevState = mBroadcastAudioState; |
| mBroadcastAudioState = msg.arg1; |
| if (prevState != mBroadcastAudioState) |
| broadcastAudioState(mBroadcastAudioState, prevState); |
| break; |
| case MSG_FROM_NATIVE_BROADCAST_ID: |
| if (mBroadcastAdvertiser != null) { |
| mBroadcastAdvertiser.startBroadcastAdvertising(); |
| } else { |
| Log.e(TAG,"Did not receive adatper state change intent, turning off Broadcast"); |
| prev_state = mBroadcastState; |
| mBroadcastState = BluetoothBroadcast.STATE_DISABLED; |
| broadcastState(mBroadcastState, prev_state); |
| } |
| break; |
| case MSG_UPDATE_BROADCAST_STATE: |
| prev_state = msg.arg1; |
| mBroadcastState = BluetoothBroadcast.STATE_DISABLED; |
| Log.d(TAG,"MSG_UPDATE_BROADCAST_STATE"); |
| broadcastState(mBroadcastState, prev_state); |
| break; |
| default: |
| Log.e(TAG,"unknown message msg.what = " + msg.what); |
| break; |
| } |
| Log.d(TAG,"Exit handleMessage"); |
| } |
| } |
| |
| private void updateBroadcastStateToHfp(int state) { |
| if (DBG) { |
| Log.d(TAG,"updateBroadcastStateToHfp"); |
| } |
| HeadsetService hfpService = HeadsetService.getHeadsetService(); |
| if (hfpService != null) { |
| hfpService.updateBroadcastState(state); |
| } |
| } |
| private void broadcastState(int state, int prev_state) { |
| if (DBG) { |
| Log.d(TAG, "Broadcasting broadcastState: " + state); |
| } |
| Intent intent = new Intent(BluetoothBroadcast.ACTION_BROADCAST_STATE_CHANGED); |
| intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, prev_state); |
| intent.putExtra(BluetoothProfile.EXTRA_STATE, state); |
| sendBroadcast(intent, BLUETOOTH_CONNECT, Utils.getTempAllowlistBroadcastOptions()); |
| updateBroadcastStateToHfp(state); |
| } |
| private void broadcastCodecConfig(BluetoothCodecStatus codecStatus) { |
| if (DBG) { |
| Log.d(TAG, "Broacasting broadcastCodecConfig" + codecStatus); |
| } |
| Intent intent = new Intent(BluetoothA2dp.ACTION_CODEC_CONFIG_CHANGED); |
| intent.putExtra(BluetoothCodecStatus.EXTRA_CODEC_STATUS, codecStatus); |
| intent.putExtra(BluetoothDevice.EXTRA_DEVICE, mBroadcastDevice); |
| intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT |
| | Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND); |
| //sendBroadcast(intent, BLUETOOTH_CONNECT); |
| } |
| |
| private void broadcastEncryptionkeySet() { |
| if (DBG) { |
| Log.d(TAG, "broadcastEncryptionkeySet"); |
| } |
| Intent intent = new Intent(BluetoothBroadcast.ACTION_BROADCAST_ENCRYPTION_KEY_GENERATED); |
| intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT |
| | Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND); |
| sendBroadcast(intent, BLUETOOTH_CONNECT, Utils.getTempAllowlistBroadcastOptions()); |
| } |
| |
| private void broadcastAudioState(int newState, int prevState) { |
| Log.d(TAG, "broadcastAudioState: State:" + audioStateToString(prevState) |
| + "->" + audioStateToString(newState)); |
| Intent intent = new Intent(BluetoothBroadcast.ACTION_BROADCAST_AUDIO_STATE_CHANGED); |
| intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, prevState); |
| intent.putExtra(BluetoothProfile.EXTRA_STATE, newState); |
| intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); |
| sendBroadcast(intent, BLUETOOTH_CONNECT, Utils.getTempAllowlistBroadcastOptions()); |
| } |
| |
| private static String audioStateToString(int state) { |
| switch (state) { |
| case BluetoothBroadcast.STATE_PLAYING: |
| return "PLAYING"; |
| case BluetoothBroadcast.STATE_NOT_PLAYING: |
| return "NOT_PLAYING"; |
| default: |
| break; |
| } |
| return Integer.toString(state); |
| } |
| private boolean IsCodecConfigChanged(BluetoothCodecConfig config) { |
| return (mCodecConfig.getSampleRate() != config.getSampleRate() || |
| mCodecConfig.getChannelMode() != config.getChannelMode() || |
| mCodecConfig.getCodecSpecific1() != config.getCodecSpecific1() || |
| mCodecConfig.getCodecSpecific2() != config.getCodecSpecific2()); |
| } |
| private boolean isCodecValid(BluetoothCodecConfig mCodecConfig) { |
| if (mCodecConfig.getCodecType() != BluetoothCodecConfig.SOURCE_CODEC_TYPE_LC3) { |
| return false; |
| } |
| return true; |
| } |
| |
| private boolean isCodecConfigValid(String config_id) { |
| if (broadcast_supported_config.contains(config_id)) { |
| Log.d(TAG,"isCodecConfigValid: config supported"); |
| return true; |
| } |
| Log.d(TAG,"isCodecConfigValid: config not supported"); |
| return false; |
| } |
| |
| private boolean isEncrytionLengthValid(int enc_length) { |
| if (enc_length == 4 || enc_length == 16) { |
| return true; |
| } |
| return false; |
| } |
| |
| private BluetoothCodecConfig buildCodecConfig(String config_id, int channel) { |
| //BluetoothCodecConfig cc; |
| int index = broadcast_supported_config.indexOf(config_id); |
| int sr; |
| long codecspecific1, codecspecific2; |
| String isMono = SystemProperties.get("persist.vendor.btstack.enable.broadcast_mono"); |
| Log.d(TAG,"buildCodecConfig:" + config_id + " index: " + index); |
| switch(index) { |
| case 0: //16_2 |
| sr = BluetoothCodecConfig.SAMPLE_RATE_16000; |
| //ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1001;//32kbps |
| codecspecific2 = 1; |
| break; |
| case 1: //24_2 |
| sr = BluetoothCodecConfig.SAMPLE_RATE_24000; |
| //ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1002;//48kbps |
| codecspecific2 = 1; |
| break; |
| case 2: //48_1 |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| //ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1004;//80kbps |
| codecspecific2 = 0; |
| break; |
| case 3: //48_2 |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| //ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1004;//80kbps |
| codecspecific2 = 1; |
| break; |
| case 4: //48_3 |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| //ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1006;//96kbps |
| codecspecific2 = 0; |
| break; |
| case 5: //48_4 |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| //ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1006;//96kbps |
| codecspecific2 = 1; |
| break; |
| case 6: //48_5 |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| //ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1007;//124kbps |
| codecspecific2 = 0; |
| break; |
| case 7: //48_6 |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| //ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1007;//124kbps |
| codecspecific2 = 1; |
| break; |
| |
| default: |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| //ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1007;//80kbps |
| codecspecific2 = 1; |
| break; |
| } |
| //if (isMono.isEmpty() || isMono.equals("mono")) { |
| // ch_mode = BluetoothCodecConfig.CHANNEL_MODE_MONO; |
| //} |
| BluetoothCodecConfig cc = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LC3, |
| BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT, |
| sr, BluetoothCodecConfig.BITS_PER_SAMPLE_24, |
| channel, codecspecific1, codecspecific2, 0, 0); |
| return cc; |
| } |
| private static synchronized void setBroadcastService(BroadcastService instance) { |
| if (DBG) { |
| Log.d(TAG, "setBroadcastService(): set to: " + instance); |
| } |
| sBroadcastService = instance; |
| } |
| |
| private void cleanup_broadcast() { |
| if (DBG) Log.d (TAG, "cleanup_broadcast"); |
| synchronized (mBroadcastLock) { |
| if (mIsAdvertising) { |
| if (mBroadcastNativeInterface != null) |
| mBroadcastNativeInterface.disableBroadcast(mAdvertisingSet.getAdvertiserId()); |
| mBroadcastAdvertiser.stopBroadcastAdvertising(); |
| int prev_state = mBroadcastState; |
| mBroadcastState = BluetoothBroadcast.STATE_DISABLED; |
| broadcastState(mBroadcastState, prev_state); |
| } |
| } |
| } |
| public boolean EnableBroadcast(String packageName) { |
| if (DBG) Log.d (TAG, "EnableBroadcast"); |
| |
| if (mBroadcastState != BluetoothBroadcast.STATE_DISABLED) { |
| return false; |
| } |
| Message msg = mHandler.obtainMessage(MSG_ENABLE_BROADCAST); |
| mHandler.sendMessage(msg); |
| return true; |
| } |
| public boolean DisableBroadcast(String packageName) { |
| if (DBG) Log.d (TAG, "DisableBroadcast: state " + mBroadcastState); |
| |
| if (mBroadcastState == BluetoothBroadcast.STATE_DISABLING || |
| mBroadcastState == BluetoothBroadcast.STATE_DISABLED) { |
| return true; |
| } else if (mBroadcastState != BluetoothBroadcast.STATE_ENABLED && |
| mBroadcastState != BluetoothBroadcast.STATE_STREAMING) { |
| Log.d(TAG,"Broadcast is not enabled yet"); |
| return false; |
| } |
| Message msg = mHandler.obtainMessage(MSG_DISABLE_BROADCAST); |
| mHandler.sendMessage(msg); |
| return true; |
| } |
| public boolean SetEncryption(boolean enable, int enc_len, |
| boolean use_existing, String packageName) { |
| if (DBG) Log.d (TAG,"SetEncryption"); |
| |
| mEncryptionEnabled = enable; |
| if (enable) { |
| if (!isEncrytionLengthValid(enc_len)) { |
| if (DBG) Log.d (TAG,"SetEncryption: invalid encrytion length requested"); |
| return false; |
| } |
| } else { |
| Log.d(TAG,"Selected unencrypted"); |
| enc_len = 0; |
| } |
| if (!use_existing) { |
| Log.d (TAG,"Generate new ecrytpion key of lenght = " + enc_len); |
| mEncryptionLength = enc_len; |
| if (mBroadcastState == BluetoothBroadcast.STATE_ENABLED || |
| mBroadcastState == BluetoothBroadcast.STATE_STREAMING) { |
| mEncKeyRefreshed = true; |
| Message msg = mHandler.obtainMessage(MSG_RESET_ENCRYPTION_FLAG_TIMEOUT); |
| mHandler.sendMessageDelayed(msg, 1000); |
| } |
| Message msg = mHandler.obtainMessage(MSG_SET_ENCRYPTION_KEY); |
| mHandler.sendMessage(msg); |
| } |
| return true; |
| } |
| |
| public byte[] GetEncryptionKey(String packageName) { |
| if (DBG) Log.d (TAG,"GetBroadcastEncryptionKey: package name = " + packageName); |
| |
| return BigBroadcastCode; |
| } |
| |
| public int GetBroadcastStatus(String packageName) { |
| if (DBG) Log.d (TAG,"GetBroadcastStatus: state = " + mBroadcastState + " package name = " + packageName); |
| return mBroadcastState; |
| } |
| |
| public boolean isBroadcastActive() { |
| if (mBroadcastDeviceIsActive == false) { |
| Log.d (TAG,"isBroadcastActive: Broadcast is turned to off"); |
| return false; |
| } |
| if (DBG) Log.d (TAG,"isBroadcastActive"); |
| return ((mBroadcastState == BluetoothBroadcast.STATE_ENABLED) || |
| (mBroadcastState == BluetoothBroadcast.STATE_STREAMING)); |
| } |
| |
| public BluetoothDevice getBroadcastDevice() { |
| if (DBG) Log.d (TAG,"getBroadcastDevice"); |
| return mBroadcastDevice; |
| } |
| |
| public String getBroadcastAddress() { |
| if (DBG) Log.d (TAG,"getBroadcastAddress"); |
| return mBroadcastAddress; |
| } |
| |
| public byte[] getBroadcastId() { |
| Log.d(TAG,"getBroadcastId: " + mBroadcastID); |
| return mBroadcastID; |
| } |
| |
| public boolean isBroadcastStreamingEncrypted() { |
| return mEncryptionEnabled; |
| } |
| |
| public boolean isBroadcastStreaming() { |
| return (mBroadcastState == BluetoothBroadcast.STATE_STREAMING); |
| } |
| |
| public String BroadcastGetAdvAddress() { |
| if (DBG) Log.d (TAG,"BroadcastGetAdvAddress: " + mAdvAddress); |
| return mAdvAddress; |
| } |
| |
| public int getNumSubGroups() { |
| if (DBG) Log.d (TAG,"getNumSubGroups: " + mNumSubGrps); |
| return mNumSubGrps; |
| } |
| |
| public int BroadcastGetAdvAddrType() { |
| return mAdvAddressType; |
| } |
| |
| public int BroadcatGetAdvHandle() { |
| //check if advertising |
| return mAdvertisingSet.getAdvertiserId(); |
| } |
| |
| public int BroadcastGetAdvInterval() { |
| return mPaInt; |
| } |
| public List<BisInfo> BroadcastGetBisInfo() { |
| if (isBroadcastStreaming()) { |
| return mBisInfo; |
| } |
| Log.d(TAG,"BroadcastGetBisInfo: Broadcast is not active"); |
| return mBisInfo; |
| } |
| |
| public Map<Integer, MetadataLtv> BroadcastGetMetaInfo() { |
| if (isBroadcastStreaming()) { |
| return mMetaInfo; |
| } |
| Log.d(TAG,"BroadcastGetMetaInfo: Broadcast is not active"); |
| return mMetaInfo; |
| } |
| public byte[] BroadcastGetMetadata() { |
| if (isBroadcastStreaming()) { |
| return mBroadcastBase.getMetadataContext(); |
| } |
| Log.d(TAG,"BroadcastGetMetadata: Broadcast is not active"); |
| return mBroadcastBase.getMetadataContext(); |
| } |
| public void setCodecPreference(String config_id, int ch_mode) { |
| if (isCodecConfigValid(config_id)) { |
| setCodecPreference(buildCodecConfig(config_id, ch_mode)); |
| } |
| } |
| public void setCodecPreference(BluetoothCodecConfig newConfig) { |
| if (DBG) Log.d (TAG, "setCodecPreference"); |
| if (newConfig.getCodecType() != BluetoothCodecConfig.SOURCE_CODEC_TYPE_LC3) { |
| Log.e(TAG, "setCodecPreference: Invalid codec for broadcast mode: " + newConfig.getCodecType()); |
| return; |
| } |
| //mBroadcastCodecConfig.updateCodecConfig(newConfig); |
| if (mBroadcastState != BluetoothBroadcast.STATE_DISABLED) |
| mBroadcastNativeInterface.setCodecConfigPreference(mAdvertisingSet.getAdvertiserId(),newConfig); |
| } |
| |
| public void GetEncryptionKeyFromNative() { |
| Log.e(TAG,"GetEncryptionKeyFromNative"); |
| Message msg = mHandler.obtainMessage(MSG_GET_ENCRYPTION_KEY); |
| mHandler.sendMessage(msg); |
| } |
| private void setup_isodatapath(int adv_id, int big_handle,int num_bises, int[] bises) { |
| } |
| /* LE HAP broadcast hooks */ |
| public boolean startHAPBroadcast() { |
| if (isBroadcastActive()) { |
| //TODO: update codec config with HAP HQ mode |
| //Terminate BIG if created |
| //Notify codec config change to stack |
| //Create BIG and update BASE |
| } else { |
| //TODO: update codec config with HAP HQ mode |
| //Start Adv |
| //Existing encryption key will be used for HAP as only music streaming is supported |
| //Announcement content type will not be covered |
| } |
| return true; |
| } |
| public boolean stopHAPBroadcast() { |
| //TODO: DisableAudioPath |
| //Terminate BIG |
| //update state to disabling |
| //stop Adv |
| //reset codec config to default config |
| return true; |
| } |
| public void removeActiveDevice() { |
| if (DBG) Log.d (TAG,"removeActiveDevice"); |
| //int [] bis_handles = {-1, -1}; |
| if (mBroadcastDeviceIsActive == false) { |
| Log.d (TAG,"removeActiveDevice: mBADeviceIsActive is false, already removed"); |
| return; |
| } |
| mBroadcastDeviceIsActive = false; |
| synchronized (mBroadcastLock) { |
| if (mIsAdvertising && |
| (mBroadcastState == BluetoothBroadcast.STATE_ENABLED || |
| mBroadcastState == BluetoothBroadcast.STATE_STREAMING)) { |
| mBroadcastNativeInterface.disableBroadcast(mAdvertisingSet.getAdvertiserId()); |
| //mBroadcastAdvertiser.stopBroadcastAdvertising(); |
| } |
| if (!mBroadcastNativeInterface.setActiveDevice(false, mAdvertisingSet.getAdvertiserId())) { |
| Log.d(TAG,"SetActiveNative failed"); |
| } |
| } |
| //notifyBroadcastEnabled(false); |
| } |
| |
| public BluetoothCodecStatus getCodecStatus() { |
| if (DBG) Log.d (TAG,"getCodecStatus"); |
| BluetoothCodecConfig[] mBroadcastCodecConfig = {mCodecConfig}; |
| return (new BluetoothCodecStatus(mCodecConfig, mBroadcastCodecConfig, mBroadcastCodecConfig)); |
| } |
| public int setActiveDevice(BluetoothDevice device) { |
| if (DBG) Log.d (TAG,"setActiveDevice"); |
| if (device == null) { |
| removeActiveDevice(); |
| return ActiveDeviceManagerService.SHO_SUCCESS; |
| } |
| if (!Objects.equals(device, mBroadcastDevice)) { |
| Log.d(TAG,"setActiveDevice: Not a Broadcast device"); |
| return ActiveDeviceManagerService.SHO_FAILED; |
| } |
| if (!mBroadcastNativeInterface.setActiveDevice(true, mAdvertisingSet.getAdvertiserId())) { |
| Log.d(TAG,"SetActiveNative failed"); |
| return ActiveDeviceManagerService.SHO_FAILED; |
| } |
| mBroadcastDeviceIsActive = true; |
| |
| return ActiveDeviceManagerService.SHO_SUCCESS; |
| } |
| |
| public void notifyBroadcastEnabled(boolean enabled) { |
| if (DBG) Log.d (TAG,"notifyBroadcastEnabled: " + enabled); |
| ActiveDeviceManagerService activeDeviceManager = ActiveDeviceManagerService.get(); |
| if(activeDeviceManager == null) { |
| Log.e(TAG,"ActiveDeviceManagerService not started. Return"); |
| return; |
| } |
| if (enabled) |
| activeDeviceManager.enableBroadcast(mBroadcastDevice); |
| else |
| activeDeviceManager.disableBroadcast(); |
| } |
| |
| public void updateMetadataFromAvrcp(MediaMetadata data) { |
| if (DBG) Log.d (TAG,"updateMetadataFromAvrcp"); |
| mTrackMetadata = new TrackMetadata(data); |
| } |
| public void messageFromNative(BroadcastStackEvent event) { |
| if (DBG) Log.d (TAG,"messageFromNative: event " + event); |
| switch(event.type) { |
| case BroadcastStackEvent.EVENT_TYPE_BROADCAST_STATE_CHANGED: |
| { |
| Message msg = |
| mHandler.obtainMessage(MSG_FROM_NATIVE_BROADCAST_STATE, |
| event.valueInt, event.advHandle); |
| mHandler.sendMessage(msg); |
| } |
| break; |
| case BroadcastStackEvent.EVENT_TYPE_BROADCAST_AUDIO_STATE_CHANGED: |
| { |
| Message msg = |
| mHandler.obtainMessage(MSG_FROM_NATIVE_BROADCAST_AUDIO_STATE, |
| event.valueInt, event.advHandle); |
| mHandler.sendMessage(msg); |
| } |
| break; |
| case BroadcastStackEvent.EVENT_TYPE_CODEC_CONFIG_CHANGED: |
| { |
| Message msg = |
| mHandler.obtainMessage(MSG_FROM_NATIVE_CODEC_STATE); |
| msg.obj = event.codecStatus; |
| mHandler.sendMessage(msg); |
| } |
| break; |
| case BroadcastStackEvent.EVENT_TYPE_ENC_KEY_GENERATED: |
| { |
| Message msg = |
| mHandler.obtainMessage(MSG_FROM_NATIVE_ENCRYPTION_KEY); |
| msg.obj = event.key; |
| mHandler.sendMessage(msg); |
| } |
| break; |
| case BroadcastStackEvent.EVENT_TYPE_SETUP_BIG: |
| { |
| mBIGHandle = event.bigHandle; |
| if (event.valueInt == 1) |
| mNumBises = event.NumBises; |
| Message msg = |
| mHandler.obtainMessage(MSG_FROM_NATIVE_SETUP_BIG,event.valueInt, event.advHandle); |
| mHandler.sendMessage(msg); |
| } |
| break; |
| case BroadcastStackEvent.EVENT_TYPE_BROADCAST_ID_GENERATED: |
| { |
| Message msg = |
| mHandler.obtainMessage(MSG_FROM_NATIVE_BROADCAST_ID); |
| for (int i = 0; i < mBroadcastIdLength; i++) { |
| mBroadcastID[i] = (byte)event.BroadcastId[i]; |
| Log.d(TAG,"mBroadcastID["+i+"]" + " = " + mBroadcastID[i]); |
| } |
| mHandler.sendMessage(msg); |
| } |
| break; |
| default: |
| Log.e (TAG,"messageFromNative: Invalid"); |
| } |
| } |
| class TrackMetadata { |
| private String title; |
| private String artistName; |
| private String albumName; |
| private String genre; |
| private long playingTimeMs; |
| |
| public TrackMetadata(MediaMetadata data) { |
| if (data == null) return; |
| artistName = stringOrBlank(data.getString(MediaMetadata.METADATA_KEY_ARTIST)); |
| albumName = stringOrBlank(data.getString(MediaMetadata.METADATA_KEY_ALBUM)); |
| title = data.getString(MediaMetadata.METADATA_KEY_TITLE); |
| genre = stringOrBlank(data.getString(MediaMetadata.METADATA_KEY_GENRE)); |
| playingTimeMs = data.getLong(MediaMetadata.METADATA_KEY_DURATION); |
| } |
| private String stringOrBlank(String s) { |
| return s == null ? new String() : s; |
| } |
| } |
| class BroadcastAdvertiser { |
| public BroadcastAdvertiser() { |
| Log.i(TAG,"BroadcastAdvertiser"); |
| mCallback = new BroadcastAdvertiserCallback(); |
| mAdvertiser = mBluetoothAdapter.getBluetoothLeAdvertiser(); |
| if (mAdvertiser == null) { |
| Log.e(TAG, "BroadcastAdvertiser: mAdvertiser is null"); |
| } |
| } |
| public void startBroadcastAdvertising() { |
| Log.i(TAG,"startBroadcastAdvertising"); |
| if (mAdvertiser == null) { |
| Log.e(TAG,"startBroadcastAdvertising: Advertiser is null"); |
| int prev_state = mBroadcastState; |
| mBroadcastState = BluetoothBroadcast.STATE_DISABLED; |
| broadcastState(mBroadcastState, prev_state); |
| return; |
| } |
| AdvertisingSetParameters.Builder adv_param = |
| new AdvertisingSetParameters.Builder(); |
| adv_param.setLegacyMode(false); |
| adv_param.setConnectable(false); |
| adv_param.setScannable(false); |
| adv_param.setInterval(AdvertisingSetParameters.INTERVAL_MIN); //100msec |
| adv_param.setTxPowerLevel(mTxPowerLevel); |
| adv_param.setPrimaryPhy(1); |
| adv_param.setSecondaryPhy(mSecPhy); |
| AdvertiseData AdvData = new AdvertiseData.Builder() |
| .setIncludeDeviceName(true) |
| .addServiceData(new ParcelUuid(BROADCAST_AUDIO_UUID), mBroadcastID).build(); |
| PeriodicAdvertisingParameters.Builder periodic_param = new PeriodicAdvertisingParameters.Builder(); |
| periodic_param.setIncludeTxPower(true); |
| periodic_param.setInterval(mPaInt); |
| AdvertiseData PeriodicData = new AdvertiseData.Builder().addServiceData(new ParcelUuid(BASIC_AUDIO_UUID), new byte[0]).build(); |
| Log.i(TAG,"Calling startAdvertisingSet"); |
| mAdvertiser.startAdvertisingSet(adv_param.build(), AdvData, null, periodic_param.build(), PeriodicData, 0, 0, mCallback); |
| } |
| public void stopBroadcastAdvertising() { |
| Log.i(TAG,"stopBroadcastAdvertising"); |
| if (mAdvertiser != null) |
| mAdvertiser.stopAdvertisingSet(mCallback); |
| } |
| |
| public void updatePAwithBase() { |
| Log.i(TAG,"updatePAwithBase"); |
| AdvertiseData PeriodicData = new AdvertiseData.Builder().addServiceData(new ParcelUuid(BASIC_AUDIO_UUID), mBroadcastBase.getBroadcastBaseInfo()).build(); |
| mAdvertisingSet.setPeriodicAdvertisingData(PeriodicData); |
| } |
| } |
| |
| private class BroadcastAdvertiserCallback extends AdvertisingSetCallback { |
| @Override |
| public void onAdvertisingSetStarted(AdvertisingSet advertisingSet, int txPower, |
| int status) { |
| Log.i(TAG, "onAdvertisingSetStarted status " + status |
| + " advertisingSet: " + advertisingSet + " txPower " + txPower); |
| if (status != BluetoothGatt.GATT_SUCCESS) { |
| Log.e(TAG,"Failed to start Broadcast Advertisement"); |
| int prev_state = mBroadcastState; |
| mBroadcastState = BluetoothBroadcast.STATE_DISABLED; |
| broadcastState(mBroadcastState,prev_state); |
| } |
| if (status == BluetoothGatt.GATT_SUCCESS) { |
| mAdvertisingSet = advertisingSet; |
| mIsAdvertising = true; |
| int prev_state = mBroadcastState; |
| mBroadcastState = BluetoothBroadcast.STATE_ENABLED; |
| Log.i(TAG,"onAdvertisingSetStarted: adv_id = " + advertisingSet.getAdvertiserId() + "copied id = " + mAdvertisingSet.getAdvertiserId()); |
| broadcastState(mBroadcastState,prev_state); |
| if (mHandler.hasMessages(MSG_RESET_ENCRYPTION_FLAG_TIMEOUT)) { |
| Message msg = |
| mHandler.obtainMessage(MSG_SET_BROADCAST_ACTIVE); |
| mHandler.sendMessageDelayed(msg,600); |
| } else { |
| notifyBroadcastEnabled(true); |
| } |
| int mChMode = mCodecConfig.getChannelMode(); |
| switch (mChMode) { |
| case BluetoothCodecConfig.CHANNEL_MODE_MONO: |
| case BluetoothCodecConfig.CHANNEL_MODE_JOINT_STEREO: |
| mNumBises = 1 * mNumSubGrps; |
| break; |
| case BluetoothCodecConfig.CHANNEL_MODE_STEREO: |
| mNumBises = 2 * mNumSubGrps; |
| break; |
| default: |
| Log.e(TAG,"channel mode unknown"); |
| } |
| mBroadcastBase.populateBase(); |
| mBroadcastAdvertiser.updatePAwithBase(); |
| mAdvertisingSet.getOwnAddress(); |
| } |
| } |
| |
| @Override |
| public void onAdvertisingSetStopped(AdvertisingSet advertisingSet) { |
| Log.i(TAG, "onAdvertisingSetStopped advertisingSet: " + advertisingSet); |
| mIsAdvertising = false; |
| int prev_state = mBroadcastState; |
| if (!goingDown && mBroadcastDeviceIsActive) { |
| Log.d(TAG,"onAdvertisingSetStopped: Unexpected Broadcast turn off"); |
| notifyBroadcastEnabled(false); |
| } |
| if (goingDown) { |
| Message msg = mHandler.obtainMessage(MSG_UPDATE_BROADCAST_STATE, |
| BluetoothBroadcast.STATE_DISABLING); |
| mHandler.sendMessageDelayed(msg,500); |
| goingDown = false; |
| } else { |
| mBroadcastState = BluetoothBroadcast.STATE_DISABLED; |
| broadcastState(mBroadcastState, prev_state); |
| } |
| } |
| |
| @Override |
| public void onAdvertisingEnabled(AdvertisingSet advertisingSet, boolean enable, |
| int status) { |
| Log.i(TAG, "onAdvertisingEnabled advertisingSet: " + advertisingSet |
| + " status " + status + " enable: " + enable); |
| } |
| |
| @Override |
| public void onAdvertisingDataSet(AdvertisingSet advertisingSet, int status) { |
| Log.i(TAG, "onAdvertisingDataSet advertisingSet: " + advertisingSet |
| + " status " + status); |
| if (status == BluetoothGatt.GATT_SUCCESS) { |
| Log.i(TAG, "onAdvertisingDataSet: Base Info updated"); |
| } |
| } |
| @Override |
| public void onAdvertisingParametersUpdated(AdvertisingSet advertisingSet, |
| int txPower, int status) { |
| Log.i(TAG, "onAdvertisingParametersUpdated advertisingSet: " + advertisingSet |
| + " status " + status + " txPower " + txPower); |
| } |
| |
| @Override |
| public void onOwnAddressRead(AdvertisingSet advertisingSet, int addressType, |
| String address) { |
| Log.i(TAG, "onOwnAddressRead advertisingSet: " + advertisingSet |
| + " address " + address + " addressType " + addressType); |
| mAdvAddress = address; |
| mAdvAddressType = addressType; |
| } |
| |
| } |
| class BroadcastBase { |
| private final int LC3_SAMPLE_RATE_8000 = 0x01; |
| private final int LC3_SAMPLE_RATE_16000 = 0x02; |
| private final int LC3_SAMPLE_RATE_24000 = 0x03; |
| private final int LC3_SAMPLE_RATE_32000 = 0x04; |
| private final int LC3_SAMPLE_RATE_44100 = 0x05; |
| private final int LC3_SAMPLE_RATE_48000 = 0x06; |
| |
| int presentationDelay = 0x009C40; |
| byte [] mPresentationDelay = new byte[3]; |
| byte [] mCodecId = new byte[5]; |
| byte [] mCodecSpecificLength = new byte[1]; |
| byte [] mCodecSpecificSampleRate = new byte[3]; |
| byte [] mCodecSpecificFrameDuration = new byte[3]; |
| byte [] mCodecSpecificAudioLocation = new byte[6]; |
| byte [] mCodecSpecificOctetsPerFrame = new byte[3]; |
| byte [] mCodecSpecificBlocksPerSdu = new byte[3]; |
| byte [] mCodecSpecificLengthL2 = new byte[1]; |
| byte [] mCodecSpecificSampleRateL2 = new byte[3]; |
| byte [] mCodecSpecificFrameDurationL2 = new byte[3]; |
| byte [] mCodecSpecificAudioLocationL2 = new byte[6]; |
| byte [] mCodecSpecificOctetsPerFrameL2 = new byte[3]; |
| byte [] mCodecSpecificBlocksPerSduL2 = new byte[3]; |
| byte [] mMetadataLength = new byte[1]; |
| byte [] mMetadataContext = new byte[3]; |
| byte [] mNumSubgroups = new byte[1]; |
| byte [] mL2CodecID = new byte[1]; |
| byte [] mL2CodecSpecificLength = new byte[1]; |
| byte [] mL2mMetadataLength = new byte[1]; |
| byte [] mL2NumBises = new byte[1]; |
| byte [] mL2BisIndices = new byte[2]; |
| byte [] mL3BisIndex = new byte[1]; |
| byte [] mL3CodecSpecificLength = new byte[1]; |
| byte [] mL3CodecSpecificAudioLocation = new byte[6]; |
| byte mSampleRateLength = 2; |
| byte mSampleRateType = 0x01; |
| byte mFrameDurationLength = 2; |
| byte mFrameDurationType = 0x02; |
| byte mFrameDuration_7_5 = 0x00;//7.5 msec |
| byte mFrameDuration_10 = 0x01;//10msec |
| byte mAudioLocationLength = 5; |
| byte mAudioLocationType = 0x03; |
| byte mAudioLocationLeft = 0x01; |
| byte mAudioLocationRight = 0x02; |
| byte mAudioLocationCentre = 0x04; |
| byte mOctetsPerFrameLength = 3; |
| byte mOctestPerFrameType = 0x04; |
| byte mBlocksPerSduLength = 2; |
| byte mBlocksPerSduType = 0x05; |
| long LC3_CODEC_ID_OLD = 0x0000000001; |
| long LC3_CODEC_ID = 0x0000000006; |
| byte mCodecConfigLength = 0x10; //to be changed |
| byte mMediaContextType = 0x10; |
| byte [] BroadcastBaseArray = null; |
| //Metadata AD type |
| //Metadata |
| public BroadcastBase() { |
| //mccid = 0; |
| //int presentationDelay = 0x000014; |
| if (mPD == 20) { |
| Log.d(TAG,"Presentation Delay is set to 20msec"); |
| presentationDelay = 0x004E20; |
| } |
| if (mNewVersion) { |
| mPresentationDelay = intTobyteArray(presentationDelay, 3); |
| mNumSubgroups[0] = (byte)mNumSubGrps; |
| } else { |
| mPresentationDelay = intTobyteArray(presentationDelay, 3); |
| if (new_codec_id) { |
| mCodecId = longTobyteArray(LC3_CODEC_ID,5); |
| } else { |
| mCodecId = longTobyteArray(LC3_CODEC_ID_OLD,5); |
| } |
| mCodecSpecificLength[0] = mCodecConfigLength; |
| mCodecSpecificSampleRate = updateSampleRate(); |
| mCodecSpecificFrameDuration = updateFrameDuration(); |
| mCodecSpecificAudioLocation = updateAudioLocation(0); |
| mCodecSpecificOctetsPerFrame = updateOctetsPerFrame(); |
| mMetadataLength[0] = (byte)0x03; |
| int index = 0; |
| mMetadataContext[index++] = (byte)0x02; //length |
| mMetadataContext[index++] = (byte)mMediaContextType; //Type |
| mMetadataContext[index++] = (byte)0x01; //Value Music |
| mNumSubgroups[0] = (byte)mNumSubGrps; // only one set of broadcast is supported. |
| } |
| } |
| public byte [] getBroadcastBaseInfo() { |
| return BroadcastBaseArray; |
| } |
| public void updateBIGhandle(int handle) { |
| mBIGHandle = handle; |
| } |
| |
| public byte[] getMetadataContext() { |
| return mMetadataContext; |
| } |
| |
| public int getNumSubGroups() { |
| return mNumSubgroups[0]; |
| } |
| public byte [] updateSampleRate() { |
| int SR = mCodecConfig.getSampleRate(); |
| byte bytevalue; |
| switch (SR) { |
| case BluetoothCodecConfig.SAMPLE_RATE_48000: |
| if (mNewVersion) { |
| bytevalue = (byte)0x08; |
| } else { |
| bytevalue = (byte)0x06; |
| } |
| break; |
| case BluetoothCodecConfig.SAMPLE_RATE_44100: |
| if (mNewVersion) { |
| bytevalue = (byte)0x07; |
| } else { |
| bytevalue = (byte)0x05; |
| } |
| break; |
| case BluetoothCodecConfig.SAMPLE_RATE_32000: |
| if (mNewVersion) { |
| bytevalue = (byte)0x06; |
| } else { |
| bytevalue = (byte)0x04; |
| } |
| break; |
| case BluetoothCodecConfig.SAMPLE_RATE_24000: |
| if (mNewVersion) { |
| bytevalue = (byte)0x05; |
| } else { |
| bytevalue = (byte)0x03; |
| } |
| break; |
| case BluetoothCodecConfig.SAMPLE_RATE_16000: |
| if (mNewVersion) { |
| bytevalue = (byte)0x03; |
| } else { |
| bytevalue = (byte)0x02; |
| } |
| break; |
| case BluetoothCodecConfig.SAMPLE_RATE_8000: |
| bytevalue = (byte)0x01; |
| break; |
| default: |
| if (mNewVersion) { |
| bytevalue = (byte)0x08; |
| } else { |
| bytevalue = (byte)0x06; |
| } |
| } |
| byte [] ltv = {mSampleRateLength, mSampleRateType, bytevalue}; |
| return ltv; |
| } |
| public byte[] updateOctetsPerFrame() { |
| long bitrate = (int) mCodecConfig.getCodecSpecific1(); |
| long frameDuration = (int) mCodecConfig.getCodecSpecific2(); |
| byte bytevalue; |
| //Update OctetsPerFrame based on frame duration |
| switch ((int)bitrate) { |
| case 1001: |
| if (frameDuration == 0) { //7.5msec |
| bytevalue = (byte)30; |
| } else { //10msec |
| bytevalue = (byte)40; |
| } |
| break; |
| case 1002: |
| if (frameDuration == 0) { |
| bytevalue = (byte)45; |
| } else { |
| bytevalue = (byte)60; |
| } |
| break; |
| case 1004: |
| if (frameDuration == 0) { |
| bytevalue = (byte)75; |
| } else { |
| bytevalue = (byte)100; |
| } |
| break; |
| case 1006: |
| if (frameDuration == 0) { |
| bytevalue = (byte)90; |
| } else { |
| bytevalue = (byte)120; |
| } |
| break; |
| case 1007: |
| if (frameDuration == 0) { |
| bytevalue = (byte)117; |
| } else { |
| bytevalue = (byte)155; |
| } |
| break; |
| default: |
| bytevalue = (byte)100; |
| } |
| Log.d(TAG,"updateOctetsPerFrame: " + bytevalue); |
| byte [] ltv = {mOctetsPerFrameLength, mOctestPerFrameType, bytevalue, 0x00}; |
| return ltv; |
| } |
| private byte[] updateBlocksPerSdu() { |
| byte[] ltv = {mBlocksPerSduLength, mBlocksPerSduType,0x01}; |
| return ltv; |
| } |
| |
| public byte [] updateHAPSampleRate() { |
| int SR = mCodecConfig.getSampleRate(); |
| byte bytevalue; |
| switch (SR) { |
| case BluetoothCodecConfig.SAMPLE_RATE_16000: |
| bytevalue = (byte)0x02; |
| break; |
| case BluetoothCodecConfig.SAMPLE_RATE_24000: |
| bytevalue = (byte)0x03; |
| default: |
| bytevalue = (byte)0x02; |
| } |
| byte[] ltv = {mSampleRateLength, mSampleRateType, bytevalue}; |
| return ltv; |
| } |
| public byte [] updateHapOctetsPerFrame() { |
| long bitrate = mCodecConfig.getCodecSpecific1(); |
| long frameDuration = (int) mCodecConfig.getCodecSpecific2(); |
| byte bytevalue; |
| //Update OctetsPerFrame based on frame duration |
| switch((int)bitrate) { |
| case 1001: |
| if (frameDuration == 0) { //7.5msec |
| bytevalue = (byte)30; |
| } else { //10msec |
| bytevalue = (byte)40; |
| } |
| break; |
| case 1002: |
| if (frameDuration == 0) { |
| bytevalue = (byte)45; |
| } else { |
| bytevalue = (byte)60; |
| } |
| break; |
| default: |
| bytevalue = (byte)40; |
| } |
| byte [] ltv = {mOctetsPerFrameLength, mOctestPerFrameType, bytevalue, 0x00}; |
| return ltv; |
| } |
| public byte [] updateAudioLocation(int bis_index) { |
| int ch_mode = mCodecConfig.getChannelMode(); |
| byte ch = 0; |
| if (bis_index == 0) { |
| // stereo |
| if (ch_mode == BluetoothCodecConfig.CHANNEL_MODE_STEREO || |
| ch_mode == BluetoothCodecConfig.CHANNEL_MODE_JOINT_STEREO) |
| ch = (byte)0x03; |
| else if (ch_mode == BluetoothCodecConfig.CHANNEL_MODE_MONO) |
| ch = (byte)0x00; |
| } else { |
| if (ch_mode == BluetoothCodecConfig.CHANNEL_MODE_STEREO) { |
| int bises = (mNumBises/((int)mNumSubgroups[0])); |
| ch = (byte)(mAudioLocationRight - (bis_index % bises)); |
| } else if (ch_mode == BluetoothCodecConfig.CHANNEL_MODE_JOINT_STEREO) { |
| ch = (byte)0x03; |
| } else if (ch_mode == BluetoothCodecConfig.CHANNEL_MODE_MONO) { |
| ch = (byte)0x00; |
| } |
| } |
| byte [] loc = {mAudioLocationLength, mAudioLocationType, ch, 0x00, 0x00, 0x00}; |
| return loc; |
| } |
| public byte[] updateFrameDuration() { |
| byte mFD = mFrameDuration_10; |
| if (mCodecConfig.getCodecSpecific2() == 0) { |
| Log.d(TAG,"updateFrameDuration: 7.5msec"); |
| mFD = mFrameDuration_7_5; |
| } else { |
| Log.d(TAG,"updateFrameDuration: 10 msec"); |
| } |
| byte[] ltv = {mFrameDurationLength,mFrameDurationType,mFD}; |
| return ltv; |
| } |
| public byte[] intTobyteArray(int intValue, int bytelen) { |
| byte [] val = new byte[bytelen]; |
| for (int i = 0; i < bytelen; i++) { |
| val[(bytelen - 1) -i] = (byte)((intValue >> (8 *(bytelen - (i + 1)))) & 0x000000FF); |
| } |
| return val; |
| } |
| public byte [] longTobyteArray(long longValue, int bytelen) { |
| byte [] val = new byte[bytelen]; |
| for (int i = 0; i < bytelen; i++) { |
| val[(bytelen - 1) -i] = (byte)((longValue >> (8 *(bytelen - (i + 1)))) & 0x00000000000000FF); |
| } |
| return val; |
| } |
| public int calculateBisPerGroup() { |
| int mChMode = mCodecConfig.getChannelMode(); |
| int numbis = 2; |
| switch (mChMode) { |
| case BluetoothCodecConfig.CHANNEL_MODE_MONO: |
| case BluetoothCodecConfig.CHANNEL_MODE_JOINT_STEREO: |
| Log.d(TAG,"BisPerGroup is 1"); |
| numbis = 1; |
| break; |
| case BluetoothCodecConfig.CHANNEL_MODE_STEREO: |
| Log.d(TAG,"BisPerGroup is 2"); |
| numbis = 2; |
| break; |
| default: |
| Log.e(TAG,"channel mode unknown"); |
| } |
| return numbis; |
| } |
| public void populateBase() { |
| if (DBG) Log.d(TAG,"populateBase"); |
| byte [] baseL1 = populate_level1_base(); |
| byte [] baseL2 = populate_level2_base(); |
| ByteArrayOutputStream ByteStr = new ByteArrayOutputStream(); |
| ByteStr.write(baseL1, 0, baseL1.length); |
| ByteStr.write(baseL2, 0, baseL2.length); |
| if (!mNewVersion) { |
| byte [] baseL3 = populate_level3_base(); |
| ByteStr.write(baseL3, 0, baseL3.length); |
| } |
| BroadcastBaseArray = ByteStr.toByteArray(); |
| } |
| private byte [] populate_level1_base() { |
| ByteArrayOutputStream ByteStr = new ByteArrayOutputStream(); |
| if (mNewVersion) { |
| mPresentationDelay = intTobyteArray(presentationDelay, 3); |
| mNumSubgroups[0] = (byte)mNumSubGrps;//calculate based on num bises and channel mode |
| ByteStr.write(mPresentationDelay, 0, mPresentationDelay.length); |
| ByteStr.write(mNumSubgroups, 0, mNumSubgroups.length); |
| } else { |
| mPresentationDelay = intTobyteArray(presentationDelay, 3); |
| if (new_codec_id) { |
| mCodecId = longTobyteArray(LC3_CODEC_ID,5); |
| } else { |
| mCodecId = longTobyteArray(LC3_CODEC_ID_OLD,5); |
| } |
| mCodecSpecificLength[0] = mCodecConfigLength; |
| mCodecSpecificSampleRate = updateSampleRate(); |
| mCodecSpecificFrameDuration = updateFrameDuration(); |
| mCodecSpecificAudioLocation = updateAudioLocation(0); |
| mCodecSpecificOctetsPerFrame = updateOctetsPerFrame(); |
| mMetadataLength[0] = (byte)0x03; |
| byte [] mediacontext = {2, mMediaContextType, (byte)0x01}; |
| mNumSubgroups[0] = (byte)mNumSubGrps;//calculate based on num bises and channel mode |
| |
| ByteStr.write(mPresentationDelay, 0, mPresentationDelay.length); |
| ByteStr.write(mCodecId, 0, mCodecId.length); |
| ByteStr.write(mCodecSpecificLength, 0, mCodecSpecificLength.length); |
| ByteStr.write(mCodecSpecificSampleRate, 0, mCodecSpecificSampleRate.length); |
| ByteStr.write(mCodecSpecificFrameDuration, 0, mCodecSpecificFrameDuration.length); |
| ByteStr.write(mCodecSpecificAudioLocation, 0, mCodecSpecificAudioLocation.length); |
| ByteStr.write(mCodecSpecificOctetsPerFrame, 0, mCodecSpecificOctetsPerFrame.length); |
| ByteStr.write(mMetadataLength, 0, mMetadataLength.length); |
| ByteStr.write(mMetadataContext, 0, mMetadataContext.length); |
| ByteStr.write(mNumSubgroups, 0, mNumSubgroups.length); |
| } |
| return ByteStr.toByteArray(); |
| } |
| private byte [] populate_level2_base() { |
| Log.d(TAG,"populate_level2_base, subgroup = " + mNumSubgroups[0]); |
| ByteArrayOutputStream ByteStr = new ByteArrayOutputStream(); |
| byte [] metalength = new byte[1]; |
| int bisPerGroup = calculateBisPerGroup();//mNumBises/mNumSubGrps; |
| byte [] numBises = new byte[1]; |
| numBises = intTobyteArray(bisPerGroup,1); |
| byte [] bisInd = new byte[bisPerGroup]; |
| if (mNewVersion) { |
| byte[] mcid = new byte[1]; |
| if (new_codec_id) { |
| mcid = longTobyteArray(LC3_CODEC_ID,5); |
| } else { |
| mcid = longTobyteArray(LC3_CODEC_ID_OLD,5); |
| } |
| mMetadataLength[0] = (byte)0x04; |
| byte [] mediacontext = {3, 2, (byte)0x04, (byte)0x00}; |
| int codecConfigLength = 0x13; |
| mCodecSpecificLength = intTobyteArray(codecConfigLength, 1); |
| for (int i = 0; i < mNumSubgroups[0]; i++) { |
| if (mPartialSimulcast) { |
| if (i < (mNumSubgroups[0] / 2)) { |
| //High quality |
| ByteStr.write(numBises, 0, numBises.length); |
| ByteStr.write(mcid, 0, mcid.length); |
| mCodecSpecificSampleRate = updateSampleRate(); |
| mCodecSpecificFrameDuration = updateFrameDuration(); |
| mCodecSpecificAudioLocation = updateAudioLocation(0); |
| mCodecSpecificOctetsPerFrame = updateOctetsPerFrame(); |
| mCodecSpecificBlocksPerSdu= updateBlocksPerSdu(); |
| ByteStr.write(mCodecSpecificLength, 0, mCodecSpecificLength.length); |
| ByteStr.write(mCodecSpecificSampleRate, 0, mCodecSpecificSampleRate.length); |
| ByteStr.write(mCodecSpecificFrameDuration, 0, mCodecSpecificFrameDuration.length); |
| ByteStr.write(mCodecSpecificAudioLocation, 0, mCodecSpecificAudioLocation.length); |
| ByteStr.write(mCodecSpecificOctetsPerFrame, 0, mCodecSpecificOctetsPerFrame.length); |
| ByteStr.write(mCodecSpecificBlocksPerSdu, 0, mCodecSpecificBlocksPerSdu.length); |
| ByteStr.write(mMetadataLength, 0, mMetadataLength.length); |
| ByteStr.write(mediacontext, 0, mediacontext.length); |
| byte[] level3 = populate_level3_new_base(i, mcid, mCodecSpecificSampleRate, |
| mCodecSpecificFrameDuration, |
| mCodecSpecificOctetsPerFrame, |
| mCodecSpecificBlocksPerSdu, |
| mediacontext); |
| ByteStr.write(level3, 0, level3.length); |
| mMetaInfo.put(i,new MetadataLtv(mediacontext)); |
| } else { |
| //Low quality |
| ByteStr.write(numBises, 0, numBises.length); |
| ByteStr.write(mcid, 0, mcid.length); |
| mCodecSpecificSampleRateL2= updateHAPSampleRate(); |
| mCodecSpecificFrameDurationL2= updateFrameDuration(); |
| mCodecSpecificAudioLocationL2= updateAudioLocation(0); |
| mCodecSpecificOctetsPerFrameL2= updateHapOctetsPerFrame(); |
| mCodecSpecificBlocksPerSduL2= updateBlocksPerSdu(); |
| ByteStr.write(mCodecSpecificLength, 0, mCodecSpecificLength.length); |
| ByteStr.write(mCodecSpecificSampleRateL2, 0, mCodecSpecificSampleRateL2.length); |
| ByteStr.write(mCodecSpecificFrameDurationL2, 0, mCodecSpecificFrameDurationL2.length); |
| ByteStr.write(mCodecSpecificAudioLocationL2, 0, mCodecSpecificAudioLocationL2.length); |
| ByteStr.write(mCodecSpecificOctetsPerFrameL2, 0, mCodecSpecificOctetsPerFrameL2.length); |
| ByteStr.write(mCodecSpecificBlocksPerSduL2, 0, mCodecSpecificBlocksPerSduL2.length); |
| ByteStr.write(mMetadataLength, 0, mMetadataLength.length); |
| ByteStr.write(mediacontext, 0, mediacontext.length); |
| byte[] level3 = populate_level3_new_base(i, mcid, mCodecSpecificSampleRateL2, |
| mCodecSpecificFrameDurationL2, |
| mCodecSpecificOctetsPerFrameL2, |
| mCodecSpecificBlocksPerSduL2, |
| mediacontext); |
| ByteStr.write(level3, 0, level3.length); |
| mMetaInfo.put(i,new MetadataLtv(mediacontext)); |
| } |
| } else { |
| ByteStr.write(numBises, 0, numBises.length); |
| ByteStr.write(mcid, 0, mcid.length); |
| mCodecSpecificLengthL2 = intTobyteArray(codecConfigLength, 1); |
| mCodecSpecificSampleRateL2 = updateSampleRate(); |
| mCodecSpecificFrameDurationL2 = updateFrameDuration(); |
| mCodecSpecificAudioLocationL2 = updateAudioLocation(0); |
| mCodecSpecificOctetsPerFrameL2 = updateOctetsPerFrame(); |
| mCodecSpecificBlocksPerSduL2 = updateBlocksPerSdu(); |
| |
| ByteStr.write(mCodecSpecificLengthL2, 0, mCodecSpecificLengthL2.length); |
| ByteStr.write(mCodecSpecificSampleRateL2, 0, mCodecSpecificSampleRateL2.length); |
| ByteStr.write(mCodecSpecificFrameDurationL2, 0, mCodecSpecificFrameDurationL2.length); |
| ByteStr.write(mCodecSpecificAudioLocationL2, 0, mCodecSpecificAudioLocationL2.length); |
| ByteStr.write(mCodecSpecificOctetsPerFrameL2, 0, mCodecSpecificOctetsPerFrameL2.length); |
| ByteStr.write(mCodecSpecificBlocksPerSduL2, 0, mCodecSpecificBlocksPerSduL2.length); |
| ByteStr.write(mMetadataLength, 0, mMetadataLength.length); |
| ByteStr.write(mediacontext, 0, mediacontext.length); |
| byte[] level3 = populate_level3_new_base(0, mcid, mCodecSpecificSampleRateL2, |
| mCodecSpecificFrameDurationL2, |
| mCodecSpecificOctetsPerFrameL2, |
| mCodecSpecificBlocksPerSduL2, |
| mediacontext); |
| ByteStr.write(level3, 0, level3.length); |
| mMetaInfo.put(i,new MetadataLtv(mediacontext)); |
| } |
| } |
| } else { |
| for (int i = 0; i < mNumSubgroups[0]; i++) { |
| if (mPartialSimulcast) { |
| if (i < (mNumSubgroups[0] / 2)) { |
| //High quality |
| byte[] mcid = new byte[1]; |
| mcid = intTobyteArray(0xFE,1); |
| mL2CodecSpecificLength = intTobyteArray(0,1);//(byte) 0; |
| ByteStr.write(mcid, 0, mcid.length); |
| ByteStr.write(mL2CodecSpecificLength, 0, mL2CodecSpecificLength.length); |
| } else { |
| //Low quality |
| byte[] mcid = new byte[5]; |
| if (new_codec_id) { |
| mcid = longTobyteArray(LC3_CODEC_ID,5); |
| } else { |
| mcid = longTobyteArray(LC3_CODEC_ID_OLD,5); |
| } |
| mCodecSpecificLengthL2 = intTobyteArray(mCodecConfigLength, 1); |
| mCodecSpecificSampleRateL2 = updateHAPSampleRate(); |
| mCodecSpecificFrameDurationL2 = updateFrameDuration(); |
| mCodecSpecificAudioLocationL2 = updateAudioLocation(0); |
| mCodecSpecificOctetsPerFrameL2 = updateHapOctetsPerFrame(); |
| ByteStr.write(mcid, 0, mcid.length); |
| ByteStr.write(mL2CodecSpecificLength, 0, mL2CodecSpecificLength.length); |
| ByteStr.write(mCodecSpecificSampleRateL2, 0, mCodecSpecificSampleRateL2.length); |
| ByteStr.write(mCodecSpecificFrameDurationL2, 0, mCodecSpecificFrameDurationL2.length); |
| ByteStr.write(mCodecSpecificAudioLocationL2, 0, mCodecSpecificAudioLocationL2.length); |
| ByteStr.write(mCodecSpecificOctetsPerFrameL2, 0, mCodecSpecificOctetsPerFrameL2.length); |
| } |
| metalength = intTobyteArray(0, 1);//(byte)0; |
| for (int j = 0; j < bisPerGroup;j++) { |
| bisInd[j] = (byte)(1 + (bisPerGroup * i) + j); |
| } |
| ByteStr.write(metalength, 0, metalength.length); |
| ByteStr.write(numBises, 0, numBises.length); |
| ByteStr.write(bisInd, 0, bisInd.length); |
| } else { |
| byte [] mcid = new byte[1]; |
| mcid = intTobyteArray(0xFE,1);//(byte)0xFE; |
| mL2CodecSpecificLength = intTobyteArray(0,1);//(byte)0; |
| metalength = intTobyteArray(0,1);//(byte)0; |
| for (int j = 0; j < bisPerGroup;j++) { |
| bisInd[j] = (byte)(1 + (bisPerGroup * i) + j); |
| } |
| ByteStr.write(mcid, 0, mcid.length); |
| ByteStr.write(mL2CodecSpecificLength, 0, mL2CodecSpecificLength.length); |
| ByteStr.write(metalength, 0, metalength.length); |
| ByteStr.write(numBises, 0, numBises.length); |
| ByteStr.write(bisInd, 0, bisInd.length); |
| } |
| } |
| } |
| return ByteStr.toByteArray(); |
| } |
| private byte[] populate_level3_base() { |
| ByteArrayOutputStream ByteStr = new ByteArrayOutputStream(); |
| for (int i = 0; i < mNumBises; i++) { |
| byte[] index = new byte[1]; |
| byte [] configlength = new byte[1]; |
| index[0] = (byte)(1 + i); //fetch from mAdvertisingSet |
| configlength[0] = (byte)6; |
| byte [] config = updateAudioLocation(i+1); |
| ByteStr.write(index, 0, index.length); |
| ByteStr.write(configlength,0, configlength.length); |
| ByteStr.write(config, 0, config.length); |
| mBisInfo.add(new BisInfo((int)index[0], mCodecId, mCodecSpecificSampleRate, mCodecSpecificFrameDuration, |
| config, mCodecSpecificOctetsPerFrame, mMetadataContext)); |
| } |
| return ByteStr.toByteArray(); |
| } |
| private byte[] populate_level3_new_base(int subGroupId, byte[] codecId, byte[] SampleRate, |
| byte[] frameDuration, byte[] octetsPerFrame, byte[] BlocksPerSdu, |
| byte[] mMetadata) { |
| ByteArrayOutputStream ByteStr = new ByteArrayOutputStream(); |
| int bisPerGroup = calculateBisPerGroup(); |
| for (int i = 0; i < bisPerGroup; i++) { |
| byte[] index = new byte[1]; |
| byte [] configlength = new byte[1]; |
| index[0] = (byte)(1 + i + (bisPerGroup * subGroupId)); |
| configlength[0] = (byte)6; |
| byte [] config = updateAudioLocation(i+1); |
| ByteStr.write(index, 0, index.length); |
| ByteStr.write(configlength,0, configlength.length); |
| ByteStr.write(config, 0, config.length); |
| mBisInfo.add(new BisInfo((int)index[0], codecId, SampleRate, frameDuration, config, |
| octetsPerFrame, BlocksPerSdu, mMetadata, subGroupId)); |
| } |
| return ByteStr.toByteArray(); |
| } |
| } |
| public class BisInfo { |
| public int BisIndex; |
| public byte [] mCodecId = new byte[5]; |
| public CodecConfigLtv BisCodecConfig; |
| public MetadataLtv BisMetadata; |
| public int mSubGroupId; |
| public BisInfo(int index, byte[] codecId, byte[] CodecSpecificSampleRate, byte[] CodecSpecificFrameDuration, |
| byte[] CodecSpecificAudioLocation, byte[] CodecSpecificOctetsPerFrame, byte[] AudioContext) { |
| BisIndex = index; |
| mCodecId = codecId; |
| BisCodecConfig = new CodecConfigLtv(CodecSpecificSampleRate, CodecSpecificFrameDuration, |
| CodecSpecificAudioLocation, CodecSpecificOctetsPerFrame); |
| BisMetadata = new MetadataLtv(AudioContext); |
| mSubGroupId = -1; |
| } |
| public BisInfo (int index, byte[] codecId, byte[] CodecSpecificSampleRate, byte[] CodecSpecificFrameDuration, |
| byte[] CodecSpecificAudioLocation, byte[] CodecSpecificOctetsPerFrame, |
| byte[] CodecSpecificBlocksPerSdu, byte[] AudioContext, int subGroupId) { |
| BisIndex = index; |
| mCodecId = codecId; |
| BisCodecConfig = new CodecConfigLtv(CodecSpecificSampleRate, CodecSpecificFrameDuration, |
| CodecSpecificAudioLocation, CodecSpecificBlocksPerSdu, |
| CodecSpecificOctetsPerFrame); |
| BisMetadata = new MetadataLtv(AudioContext); |
| mSubGroupId = subGroupId; |
| } |
| } |
| public class CodecConfigLtv{ |
| byte [] mCodecSpecificSampleRate; |
| byte [] mCodecSpecificFrameDuration; |
| byte [] mCodecSpecificAudioLocation; |
| byte [] mCodecSpecificOctetsPerFrame; |
| byte [] mCodecSpecificBlocksPerSdu; |
| public CodecConfigLtv(byte[] CodecSpecificSampleRate, |
| byte[] CodecSpecificFrameDuration, |
| byte[] CodecSpecificAudioLocation, |
| byte[] CodecSpecificOctetsPerFrame) { |
| mCodecSpecificSampleRate = CodecSpecificSampleRate; |
| mCodecSpecificFrameDuration = CodecSpecificFrameDuration; |
| mCodecSpecificAudioLocation = CodecSpecificAudioLocation; |
| mCodecSpecificOctetsPerFrame = CodecSpecificOctetsPerFrame; |
| } |
| public CodecConfigLtv(byte[] CodecSpecificSampleRate, |
| byte[] CodecSpecificFrameDuration, |
| byte[] CodecSpecificAudioLocation, |
| byte[] CodecSpecificOctetsPerFrame, |
| byte [] CodecSpecificBlocksPerSdu) { |
| mCodecSpecificSampleRate = CodecSpecificSampleRate; |
| mCodecSpecificFrameDuration = CodecSpecificFrameDuration; |
| mCodecSpecificAudioLocation = CodecSpecificAudioLocation; |
| mCodecSpecificOctetsPerFrame = CodecSpecificOctetsPerFrame; |
| mCodecSpecificBlocksPerSdu = CodecSpecificBlocksPerSdu; |
| } |
| public byte[] getByteArray() { |
| ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); |
| try { |
| outputStream.write(mCodecSpecificSampleRate); |
| outputStream.write(mCodecSpecificFrameDuration); |
| outputStream.write(mCodecSpecificAudioLocation); |
| outputStream.write(mCodecSpecificOctetsPerFrame); |
| if (mNewVersion) { |
| outputStream.write(mCodecSpecificBlocksPerSdu); |
| } |
| } catch (IOException e) { |
| Log.e(TAG, "getBytes: ioexception caught!" + e); |
| return null; |
| } |
| return outputStream.toByteArray( ); |
| } |
| } |
| public class MetadataLtv { |
| byte[] mAudioContext; |
| public MetadataLtv(byte[] audiocontext) { |
| mAudioContext = audiocontext; |
| } |
| public byte[] getByteArray() { |
| return mAudioContext; |
| } |
| } |
| class BroadcastCodecConfig { |
| public BroadcastCodecConfig() { |
| //Default configuration |
| int sr, ch_mode; |
| long codecspecific1; |
| switch(mBroadcastConfigSettings) { |
| case 1: |
| sr = BluetoothCodecConfig.SAMPLE_RATE_16000; |
| ch_mode = BluetoothCodecConfig.CHANNEL_MODE_MONO; |
| codecspecific1 = 1001;//32kbps |
| break; |
| case 2: |
| sr = BluetoothCodecConfig.SAMPLE_RATE_16000; |
| ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1001;//32kbps |
| break; |
| case 3: |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| ch_mode = BluetoothCodecConfig.CHANNEL_MODE_MONO; |
| codecspecific1 = 1004;//80kbps |
| break; |
| case 4: |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1004;//80kbps |
| break; |
| case 5: |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| ch_mode = BluetoothCodecConfig.CHANNEL_MODE_MONO; |
| codecspecific1 = 1006;//96kbps |
| break; |
| case 6: |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1006;//96 |
| break; |
| case 7: |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| ch_mode = BluetoothCodecConfig.CHANNEL_MODE_MONO; |
| codecspecific1 = 1007;//124 |
| break; |
| case 8: |
| default: |
| sr = BluetoothCodecConfig.SAMPLE_RATE_48000; |
| ch_mode = BluetoothCodecConfig.CHANNEL_MODE_STEREO; |
| codecspecific1 = 1007; |
| break; |
| |
| } |
| mCodecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LC3, |
| BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT, |
| sr, BluetoothCodecConfig.BITS_PER_SAMPLE_24, |
| ch_mode, codecspecific1, 1, 0, 0); |
| if (mPartialSimulcast) { |
| mHapCodecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LC3, |
| BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT, |
| BluetoothCodecConfig.SAMPLE_RATE_16000, |
| BluetoothCodecConfig.BITS_PER_SAMPLE_24, |
| BluetoothCodecConfig.CHANNEL_MODE_STEREO, |
| 1000, 1, 0, 0); |
| |
| } |
| } |
| public void updateBroadcastCodecConfig(BluetoothCodecConfig newConfig) { |
| if (DBG) Log.d(TAG, "updateBroadcastCodecConfig: " + newConfig); |
| mCodecConfig = newConfig; |
| int mChMode = mCodecConfig.getChannelMode(); |
| switch (mChMode) { |
| case BluetoothCodecConfig.CHANNEL_MODE_MONO: |
| case BluetoothCodecConfig.CHANNEL_MODE_JOINT_STEREO: |
| mNumBises = 1 * mNumSubGrps; |
| break; |
| case BluetoothCodecConfig.CHANNEL_MODE_STEREO: |
| mNumBises = 2 * mNumSubGrps; |
| break; |
| default: |
| Log.e(TAG,"channel mode unknown"); |
| } |
| } |
| } |
| |
| /** |
| * Binder object: must be a static class or memory leak may occur. |
| */ |
| @VisibleForTesting |
| static class BluetoothBroadcastBinder extends IBluetoothBroadcast.Stub |
| implements IProfileServiceBinder { |
| private BroadcastService mService; |
| |
| private BroadcastService getService() { |
| if (!Utils.checkCallerIsSystemOrActiveUser(TAG)) { |
| return null; |
| } |
| |
| if (mService != null && mService.isAvailable()) { |
| return mService; |
| } |
| return null; |
| } |
| |
| BluetoothBroadcastBinder(BroadcastService svc) { |
| mService = svc; |
| } |
| |
| @Override |
| public void cleanup() { |
| mService = null; |
| } |
| @Override |
| public boolean SetBroadcast(boolean enable, String packageName) { |
| BroadcastService service = getService(); |
| if (service == null) { |
| return false; |
| } |
| if (enable) { |
| return service.EnableBroadcast(packageName); |
| } |
| else { |
| return service.DisableBroadcast(packageName); |
| } |
| //return false; |
| } |
| |
| @Override |
| public boolean SetEncryption(boolean enable, int enc_len, boolean use_existing, |
| String packageName) { |
| BroadcastService service = getService(); |
| if (service == null) { |
| return false; |
| } |
| return service.SetEncryption(enable, enc_len, use_existing, packageName); |
| } |
| |
| @Override |
| public byte[] GetEncryptionKey(String packageName) { |
| BroadcastService service = getService(); |
| if (service == null) { |
| return null; |
| } |
| return service.GetEncryptionKey(packageName); |
| } |
| @Override |
| public int GetBroadcastStatus(String packageName) { |
| BroadcastService service = getService(); |
| if (service == null) { |
| return BluetoothBroadcast.STATE_DISABLED; |
| } |
| return service.GetBroadcastStatus(packageName); |
| } |
| } |
| } |
