/* * Copyright (C) 2015 Samsung System LSI * 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.sdp; import android.bluetooth.BluetoothDevice; import android.bluetooth.SdpMasRecord; import android.bluetooth.SdpMnsRecord; import android.bluetooth.SdpOppOpsRecord; import android.bluetooth.SdpPseRecord; import android.bluetooth.SdpSapsRecord; import android.bluetooth.SdpRecord; import android.content.Intent; import android.os.Handler; import android.os.Message; import android.os.ParcelUuid; import android.os.Parcelable; import android.util.Log; import com.android.bluetooth.Utils; import com.android.bluetooth.btservice.AbstractionLayer; import com.android.bluetooth.btservice.AdapterService; import java.util.ArrayList; import java.util.Arrays; public class SdpManager { private static final boolean D = true; private static final boolean V = false; private static final String TAG="SdpManager"; // TODO: When changing PBAP to use this new API. // Move the defines to the profile (PBAP already have the feature bits) /* PBAP repositories */ public static final byte PBAP_REPO_LOCAL = 0x01<<0; public static final byte PBAP_REPO_SIM = 0x01<<1; public static final byte PBAP_REPO_SPEED_DAIL = 0x01<<2; public static final byte PBAP_REPO_FAVORITES = 0x01<<3; // TODO: When changing OPP to use this new API. // Move the defines to the profile /* Object Push formats */ public static final byte OPP_FORMAT_VCARD21 = 0x01; public static final byte OPP_FORMAT_VCARD30 = 0x02; public static final byte OPP_FORMAT_VCAL10 = 0x03; public static final byte OPP_FORMAT_ICAL20 = 0x04; public static final byte OPP_FORMAT_VNOTE = 0x05; public static final byte OPP_FORMAT_VMESSAGE = 0x06; public static final byte OPP_FORMAT_ANY_TYPE_OF_OBJ = (byte)0xFF; public static final byte[] OPP_FORMAT_ALL= { OPP_FORMAT_VCARD21, OPP_FORMAT_VCARD30, OPP_FORMAT_VCAL10, OPP_FORMAT_ICAL20, OPP_FORMAT_VNOTE, OPP_FORMAT_VMESSAGE, OPP_FORMAT_ANY_TYPE_OF_OBJ}; /* Variables to keep track of ongoing and queued search requests. * mTrackerLock must be held, when using/changing sSdpSearchTracker * and mSearchInProgress. */ static SdpSearchTracker sSdpSearchTracker; static boolean mSearchInProgress = false; static Object mTrackerLock = new Object(); /* The timeout to wait for reply from native. Should never fire. */ private static final int SDP_INTENT_DELAY = 6000; private static final int MESSAGE_SDP_INTENT = 2; // We need a reference to the adapter service, to be able to send intents private static AdapterService sAdapterService; private static boolean sNativeAvailable; // This object is a singleton private static SdpManager sSdpManager = null; static { classInitNative(); } private native static void classInitNative(); private native void initializeNative(); private native void cleanupNative(); private native boolean sdpSearchNative(byte[] address, byte[] uuid); private native int sdpCreateMapMasRecordNative(String serviceName, int masId, int rfcommChannel, int l2capPsm, int version, int msgTypes, int features); private native int sdpCreateMapMnsRecordNative(String serviceName, int rfcommChannel, int l2capPsm, int version, int features); private native int sdpCreatePbapPseRecordNative(String serviceName, int rfcommChannel, int l2capPsm, int version, int repositories, int features); private native int sdpCreateOppOpsRecordNative(String serviceName, int rfcommChannel, int l2capPsm, int version, byte[] formats_list); private native int sdpCreateSapsRecordNative(String serviceName, int rfcommChannel, int version); private native boolean sdpRemoveSdpRecordNative(int record_id); /* Inner class used for wrapping sdp search instance data */ private class SdpSearchInstance { private final BluetoothDevice mDevice; private final ParcelUuid mUuid; private int mStatus = 0; private boolean mSearching; /* TODO: If we change the API to use another mechanism than intents for * delivering the results, this would be the place to keep a list * of the objects to deliver the results to. */ public SdpSearchInstance(int status, BluetoothDevice device, ParcelUuid uuid){ this.mDevice = device; this.mUuid = uuid; this.mStatus = status; mSearching = true; } public BluetoothDevice getDevice() { return mDevice; } public ParcelUuid getUuid() { return mUuid; } public int getStatus(){ return mStatus; } public void setStatus(int status) { this.mStatus = status; } public void startSearch() { mSearching = true; Message message = mHandler.obtainMessage(MESSAGE_SDP_INTENT, this); mHandler.sendMessageDelayed(message, SDP_INTENT_DELAY); } public void stopSearch() { if(mSearching) { mHandler.removeMessages(MESSAGE_SDP_INTENT, this); } mSearching = false; } public boolean isSearching() { return mSearching; } } /* We wrap the ArrayList class to decorate with functionality to * find an instance based on UUID AND device address. * As we use a mix of byte[] and object instances, this is more * efficient than implementing comparable. */ class SdpSearchTracker { private final ArrayList list = new ArrayList(); void clear() { list.clear(); } boolean add(SdpSearchInstance inst){ return list.add(inst); } boolean remove(SdpSearchInstance inst) { return list.remove(inst); } SdpSearchInstance getNext() { if(list.size() > 0) { return list.get(0); } return null; } SdpSearchInstance getSearchInstance(byte[] address, byte[] uuidBytes) { String addressString = Utils.getAddressStringFromByte(address); ParcelUuid uuid = Utils.byteArrayToUuid(uuidBytes)[0]; for (SdpSearchInstance inst : list) { if (inst.getDevice().getAddress().equals(addressString) && inst.getUuid().equals(uuid)) { return inst; } } return null; } boolean isSearching(BluetoothDevice device, ParcelUuid uuid) { String addressString = device.getAddress(); for (SdpSearchInstance inst : list) { if (inst.getDevice().getAddress().equals(addressString) && inst.getUuid().equals(uuid)) { return inst.isSearching(); } } return false; } } private SdpManager(AdapterService adapterService) { sSdpSearchTracker = new SdpSearchTracker(); /* This is only needed until intents are no longer used */ sAdapterService = adapterService; initializeNative(); sNativeAvailable=true; } public static SdpManager init(AdapterService adapterService) { sSdpManager = new SdpManager(adapterService); return sSdpManager; } public static SdpManager getDefaultManager() { return sSdpManager; } public void cleanup() { if (sSdpSearchTracker !=null) { synchronized(mTrackerLock) { sSdpSearchTracker.clear(); } } if (sNativeAvailable) { cleanupNative(); sNativeAvailable=false; } sSdpManager = null; } void sdpMasRecordFoundCallback(int status, byte[] address, byte[] uuid, int masInstanceId, int l2capPsm, int rfcommCannelNumber, int profileVersion, int supportedFeatures, int supportedMessageTypes, String serviceName, boolean moreResults) { synchronized(mTrackerLock) { SdpSearchInstance inst = sSdpSearchTracker.getSearchInstance(address, uuid); SdpMasRecord sdpRecord = null; if (inst == null) { Log.e(TAG, "sdpRecordFoundCallback: Search instance is NULL"); return; } inst.setStatus(status); if(status == AbstractionLayer.BT_STATUS_SUCCESS) { sdpRecord = new SdpMasRecord(masInstanceId, l2capPsm, rfcommCannelNumber, profileVersion, supportedFeatures, supportedMessageTypes, serviceName); } if(D) Log.d(TAG, "UUID: " + Arrays.toString(uuid)); if(D) Log.d(TAG, "UUID in parcel: " + ((Utils.byteArrayToUuid(uuid))[0]).toString()); sendSdpIntent(inst, sdpRecord, moreResults); } } void sdpMnsRecordFoundCallback(int status, byte[] address, byte[] uuid, int l2capPsm, int rfcommCannelNumber, int profileVersion, int supportedFeatures, String serviceName, boolean moreResults) { synchronized(mTrackerLock) { SdpSearchInstance inst = sSdpSearchTracker.getSearchInstance(address, uuid); SdpMnsRecord sdpRecord = null; if (inst == null) { Log.e(TAG, "sdpRecordFoundCallback: Search instance is NULL"); return; } inst.setStatus(status); if(status == AbstractionLayer.BT_STATUS_SUCCESS) { sdpRecord = new SdpMnsRecord(l2capPsm, rfcommCannelNumber, profileVersion, supportedFeatures, serviceName); } if(D) Log.d(TAG, "UUID: " + Arrays.toString(uuid)); if(D) Log.d(TAG, "UUID in parcel: " + ((Utils.byteArrayToUuid(uuid))[0]).toString()); sendSdpIntent(inst, sdpRecord, moreResults); } } void sdpPseRecordFoundCallback(int status, byte[] address, byte[] uuid, int l2capPsm, int rfcommCannelNumber, int profileVersion, int supportedFeatures, int supportedRepositories, String serviceName, boolean moreResults) { synchronized(mTrackerLock) { SdpSearchInstance inst = sSdpSearchTracker.getSearchInstance(address, uuid); SdpPseRecord sdpRecord = null; if (inst == null) { Log.e(TAG, "sdpRecordFoundCallback: Search instance is NULL"); return; } inst.setStatus(status); if(status == AbstractionLayer.BT_STATUS_SUCCESS) { sdpRecord = new SdpPseRecord(l2capPsm, rfcommCannelNumber, profileVersion, supportedFeatures, supportedRepositories, serviceName); } if(D) Log.d(TAG, "UUID: " + Arrays.toString(uuid)); if(D) Log.d(TAG, "UUID in parcel: " + ((Utils.byteArrayToUuid(uuid))[0]).toString()); sendSdpIntent(inst, sdpRecord, moreResults); } } void sdpOppOpsRecordFoundCallback(int status, byte[] address, byte[] uuid, int l2capPsm, int rfcommCannelNumber, int profileVersion, String serviceName, byte[] formatsList, boolean moreResults) { synchronized(mTrackerLock) { SdpSearchInstance inst = sSdpSearchTracker.getSearchInstance(address, uuid); SdpOppOpsRecord sdpRecord = null; if (inst == null) { Log.e(TAG, "sdpOppOpsRecordFoundCallback: Search instance is NULL"); return; } inst.setStatus(status); if(status == AbstractionLayer.BT_STATUS_SUCCESS) { sdpRecord = new SdpOppOpsRecord(serviceName, rfcommCannelNumber, l2capPsm, profileVersion, formatsList); } if(D) Log.d(TAG, "UUID: " + Arrays.toString(uuid)); if(D) Log.d(TAG, "UUID in parcel: " + ((Utils.byteArrayToUuid(uuid))[0]).toString()); sendSdpIntent(inst, sdpRecord, moreResults); } } void sdpSapsRecordFoundCallback(int status, byte[] address, byte[] uuid, int rfcommCannelNumber, int profileVersion, String serviceName, boolean moreResults) { synchronized(mTrackerLock) { SdpSearchInstance inst = sSdpSearchTracker.getSearchInstance(address, uuid); SdpSapsRecord sdpRecord = null; if (inst == null) { Log.e(TAG, "sdpSapsRecordFoundCallback: Search instance is NULL"); return; } inst.setStatus(status); if (status == AbstractionLayer.BT_STATUS_SUCCESS) { sdpRecord = new SdpSapsRecord(rfcommCannelNumber, profileVersion, serviceName); } if (D) Log.d(TAG, "UUID: " + Arrays.toString(uuid)); if (D) Log.d(TAG, "UUID in parcel: " + ((Utils.byteArrayToUuid(uuid))[0]).toString()); sendSdpIntent(inst, sdpRecord, moreResults); } } /* TODO: Test or remove! */ void sdpRecordFoundCallback(int status, byte[] address, byte[] uuid, int size_record, byte[] record) { synchronized(mTrackerLock) { SdpSearchInstance inst = sSdpSearchTracker.getSearchInstance(address, uuid); SdpRecord sdpRecord = null; if (inst == null) { Log.e(TAG, "sdpRecordFoundCallback: Search instance is NULL"); return; } inst.setStatus(status); if(status == AbstractionLayer.BT_STATUS_SUCCESS) { if(D) Log.d(TAG, "sdpRecordFoundCallback: found a sdp record of size " + size_record ); if(D) Log.d(TAG, "Record:"+ Arrays.toString(record)); sdpRecord = new SdpRecord(size_record, record); } if(D) Log.d(TAG, "UUID: " + Arrays.toString(uuid)); if(D) Log.d(TAG, "UUID in parcel: " + ((Utils.byteArrayToUuid(uuid))[0]).toString()); sendSdpIntent(inst, sdpRecord, false); } } public void sdpSearch(BluetoothDevice device, ParcelUuid uuid) { if (sNativeAvailable == false) { Log.e(TAG, "Native not initialized!"); return; } synchronized (mTrackerLock) { if (sSdpSearchTracker.isSearching(device, uuid)) { /* Search already in progress */ return; } SdpSearchInstance inst = new SdpSearchInstance(0, device, uuid); sSdpSearchTracker.add(inst); // Queue the request startSearch(); // Start search if not busy } } /* Caller must hold the mTrackerLock */ private void startSearch() { SdpSearchInstance inst = sSdpSearchTracker.getNext(); if((inst != null) && (mSearchInProgress == false)) { if(D) Log.d(TAG, "Starting search for UUID: "+ inst.getUuid()); mSearchInProgress = true; inst.startSearch(); // Trigger timeout message sdpSearchNative(Utils.getBytesFromAddress(inst.getDevice().getAddress()), Utils.uuidToByteArray(inst.getUuid())); } // Else queue is empty. else { if(D) Log.d(TAG, "startSearch(): nextInst = " + inst + " mSearchInProgress = " + mSearchInProgress + " - search busy or queue empty."); } } /* Caller must hold the mTrackerLock */ private void sendSdpIntent(SdpSearchInstance inst, Parcelable record, boolean moreResults) { inst.stopSearch(); Intent intent = new Intent(BluetoothDevice.ACTION_SDP_RECORD); intent.putExtra(BluetoothDevice.EXTRA_DEVICE, inst.getDevice()); intent.putExtra(BluetoothDevice.EXTRA_SDP_SEARCH_STATUS, inst.getStatus()); if (record != null) intent.putExtra(BluetoothDevice.EXTRA_SDP_RECORD, record); intent.putExtra(BluetoothDevice.EXTRA_UUID, inst.getUuid()); /* TODO: BLUETOOTH_ADMIN_PERM was private... change to callback interface. * Keep in mind that the MAP client needs to use this as well, * hence to make it call-backs, the MAP client profile needs to be * part of the Bluetooth APK. */ sAdapterService.sendBroadcast(intent, AdapterService.BLUETOOTH_ADMIN_PERM); if(moreResults == false) { //Remove the outstanding UUID request sSdpSearchTracker.remove(inst); mSearchInProgress = false; startSearch(); } } private final Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case MESSAGE_SDP_INTENT: SdpSearchInstance msgObj = (SdpSearchInstance)msg.obj; Log.w(TAG, "Search timedout for UUID " + msgObj.getUuid()); synchronized (mTrackerLock) { sendSdpIntent(msgObj, null, false); } break; } } }; /** * Create a server side Message Access Profile Service Record. * Create the record once, and reuse it for all connections. * If changes to a record is needed remove the old record using {@link removeSdpRecord} * and then create a new one. * @param serviceName The textual name of the service * @param masId The MAS ID to associate with this SDP record * @param rfcommChannel The RFCOMM channel that clients can connect to * (obtain from BluetoothServerSocket) * @param l2capPsm The L2CAP PSM channel that clients can connect to * (obtain from BluetoothServerSocket) * Supply -1 to omit the L2CAP PSM from the record. * @param version The Profile version number (As specified in the Bluetooth * MAP specification) * @param msgTypes The supported message types bit mask (As specified in * the Bluetooth MAP specification) * @param features The feature bit mask (As specified in the Bluetooth * MAP specification) * @return a handle to the record created. The record can be removed again * using {@link removeSdpRecord}(). The record is not linked to the * creation/destruction of BluetoothSockets, hence SDP record cleanup * is a separate process. */ public int createMapMasRecord(String serviceName, int masId, int rfcommChannel, int l2capPsm, int version, int msgTypes, int features) { if(sNativeAvailable == false) { throw new RuntimeException(TAG + " sNativeAvailable == false - native not initialized"); } return sdpCreateMapMasRecordNative(serviceName, masId, rfcommChannel, l2capPsm, version, msgTypes, features); } /** * Create a client side Message Access Profile Service Record. * Create the record once, and reuse it for all connections. * If changes to a record is needed remove the old record using {@link removeSdpRecord} * and then create a new one. * @param serviceName The textual name of the service * @param rfcommChannel The RFCOMM channel that clients can connect to * (obtain from BluetoothServerSocket) * @param l2capPsm The L2CAP PSM channel that clients can connect to * (obtain from BluetoothServerSocket) * Supply -1 to omit the L2CAP PSM from the record. * @param version The Profile version number (As specified in the Bluetooth * MAP specification) * @param features The feature bit mask (As specified in the Bluetooth * MAP specification) * @return a handle to the record created. The record can be removed again * using {@link removeSdpRecord}(). The record is not linked to the * creation/destruction of BluetoothSockets, hence SDP record cleanup * is a separate process. */ public int createMapMnsRecord(String serviceName, int rfcommChannel, int l2capPsm, int version, int features) { if(sNativeAvailable == false) { throw new RuntimeException(TAG + " sNativeAvailable == false - native not initialized"); } return sdpCreateMapMnsRecordNative(serviceName, rfcommChannel, l2capPsm, version, features); } /** * Create a Server side Phone Book Access Profile Service Record. * Create the record once, and reuse it for all connections. * If changes to a record is needed remove the old record using {@link removeSdpRecord} * and then create a new one. * @param serviceName The textual name of the service * @param rfcommChannel The RFCOMM channel that clients can connect to * (obtain from BluetoothServerSocket) * @param l2capPsm The L2CAP PSM channel that clients can connect to * (obtain from BluetoothServerSocket) * Supply -1 to omit the L2CAP PSM from the record. * @param version The Profile version number (As specified in the Bluetooth * PBAP specification) * @param repositories The supported repositories bit mask (As specified in * the Bluetooth PBAP specification) * @param features The feature bit mask (As specified in the Bluetooth * PBAP specification) * @return a handle to the record created. The record can be removed again * using {@link removeSdpRecord}(). The record is not linked to the * creation/destruction of BluetoothSockets, hence SDP record cleanup * is a separate process. */ public int createPbapPseRecord(String serviceName, int rfcommChannel, int l2capPsm, int version, int repositories, int features) { if(sNativeAvailable == false) { throw new RuntimeException(TAG + " sNativeAvailable == false - native not initialized"); } return sdpCreatePbapPseRecordNative(serviceName, rfcommChannel, l2capPsm, version, repositories, features); } /** * Create a Server side Object Push Profile Service Record. * Create the record once, and reuse it for all connections. * If changes to a record is needed remove the old record using {@link removeSdpRecord} * and then create a new one. * @param serviceName The textual name of the service * @param rfcommChannel The RFCOMM channel that clients can connect to * (obtain from BluetoothServerSocket) * @param l2capPsm The L2CAP PSM channel that clients can connect to * (obtain from BluetoothServerSocket) * Supply -1 to omit the L2CAP PSM from the record. * @param version The Profile version number (As specified in the Bluetooth * OPP specification) * @param formatsList A list of the supported formats (As specified in * the Bluetooth OPP specification) * @return a handle to the record created. The record can be removed again * using {@link removeSdpRecord}(). The record is not linked to the * creation/destruction of BluetoothSockets, hence SDP record cleanup * is a separate process. */ public int createOppOpsRecord(String serviceName, int rfcommChannel, int l2capPsm, int version, byte[] formatsList) { if(sNativeAvailable == false) { throw new RuntimeException(TAG + " sNativeAvailable == false - native not initialized"); } return sdpCreateOppOpsRecordNative(serviceName, rfcommChannel, l2capPsm, version, formatsList); } /** * Create a server side Sim Access Profile Service Record. * Create the record once, and reuse it for all connections. * If changes to a record is needed remove the old record using {@link removeSdpRecord} * and then create a new one. * @param serviceName The textual name of the service * @param rfcommChannel The RFCOMM channel that clients can connect to * (obtain from BluetoothServerSocket) * @param version The Profile version number (As specified in the Bluetooth * SAP specification) * @return a handle to the record created. The record can be removed again * using {@link removeSdpRecord}(). The record is not linked to the * creation/destruction of BluetoothSockets, hence SDP record cleanup * is a separate process. */ public int createSapsRecord(String serviceName, int rfcommChannel, int version) { if (sNativeAvailable == false) { throw new RuntimeException(TAG + " sNativeAvailable == false - native not initialized"); } return sdpCreateSapsRecordNative(serviceName, rfcommChannel, version); } /** * Remove a SDP record. * When Bluetooth is disabled all records will be deleted, hence there * is no need to call this function when bluetooth is disabled. * @param recordId The Id returned by on of the createXxxXxxRecord() functions. * @return TRUE if the record removal was initiated successfully. FALSE if the record * handle is not known/have already been removed. */ public boolean removeSdpRecord(int recordId){ if(sNativeAvailable == false) { throw new RuntimeException(TAG + " sNativeAvailable == false - native not initialized"); } return sdpRemoveSdpRecordNative(recordId); } }