RemoteDevices.java revision fd1da115cbf09b7dd9bca3c7d3a4fb816a835dc5 
1/*
2 * Copyright (C) 2012 Google Inc.
3 */
4
5package com.android.bluetooth.btservice;
6
7import android.bluetooth.BluetoothAdapter;
8import android.bluetooth.BluetoothClass;
9import android.bluetooth.BluetoothDevice;
10import android.content.Context;
11import android.content.Intent;
12import android.os.Handler;
13import android.os.Message;
14import android.os.ParcelUuid;
15import android.util.Log;
16
17import com.android.bluetooth.Utils;
18import com.android.bluetooth.btservice.RemoteDevices.DeviceProperties;
19
20import java.util.ArrayList;
21import java.util.HashMap;
22import java.util.LinkedList;
23
24
25final class RemoteDevices {
26    private static final boolean DBG = false;
27    private static final String TAG = "BluetoothRemoteDevices";
28
29
30    private static BluetoothAdapter mAdapter;
31    private static AdapterService mAdapterService;
32    private static ArrayList<BluetoothDevice> mSdpTracker;
33
34    private Object mObject = new Object();
35
36    private static final int UUID_INTENT_DELAY = 6000;
37    private static final int MESSAGE_UUID_INTENT = 1;
38
39    private HashMap<BluetoothDevice, DeviceProperties> mDevices;
40
41    RemoteDevices(AdapterService service) {
42        mAdapter = BluetoothAdapter.getDefaultAdapter();
43        mAdapterService = service;
44        mSdpTracker = new ArrayList<BluetoothDevice>();
45        mDevices = new HashMap<BluetoothDevice, DeviceProperties>();
46    }
47
48
49    void cleanup() {
50        if (mSdpTracker !=null)
51            mSdpTracker.clear();
52
53        if (mDevices != null)
54            mDevices.clear();
55    }
56
57    public Object Clone() throws CloneNotSupportedException {
58        throw new CloneNotSupportedException();
59    }
60
61    DeviceProperties getDeviceProperties(BluetoothDevice device) {
62        synchronized (mDevices) {
63            return mDevices.get(device);
64        }
65    }
66
67    BluetoothDevice getDevice(byte[] address) {
68        for (BluetoothDevice dev : mDevices.keySet()) {
69            if (dev.getAddress().equals(Utils.getAddressStringFromByte(address))) {
70                return dev;
71            }
72        }
73        return null;
74    }
75
76    DeviceProperties addDeviceProperties(byte[] address) {
77        synchronized (mDevices) {
78            DeviceProperties prop = new DeviceProperties();
79            BluetoothDevice device =
80                    mAdapter.getRemoteDevice(Utils.getAddressStringFromByte(address));
81            prop.mAddress = address;
82            mDevices.put(device, prop);
83            return prop;
84        }
85    }
86
87    class DeviceProperties {
88        private String mName;
89        private byte[] mAddress;
90        private int mBluetoothClass;
91        private short mRssi;
92        private ParcelUuid[] mUuids;
93        private int mDeviceType;
94        private String mAlias;
95        private int mBondState;
96
97        DeviceProperties() {
98            mBondState = BluetoothDevice.BOND_NONE;
99        }
100
101        /**
102         * @return the mName
103         */
104        String getName() {
105            synchronized (mObject) {
106                return mName;
107            }
108        }
109
110        /**
111         * @return the mClass
112         */
113        int getBluetoothClass() {
114            synchronized (mObject) {
115                return mBluetoothClass;
116            }
117        }
118
119        /**
120         * @return the mUuids
121         */
122        ParcelUuid[] getUuids() {
123            synchronized (mObject) {
124                return mUuids;
125            }
126        }
127
128        /**
129         * @return the mAddress
130         */
131        byte[] getAddress() {
132            synchronized (mObject) {
133                return mAddress;
134            }
135        }
136
137        /**
138         * @return mRssi
139         */
140        short getRssi() {
141            synchronized (mObject) {
142                return mRssi;
143            }
144        }
145
146        /**
147         *
148         * @return mDeviceType
149         */
150        int getDeviceType() {
151            synchronized (mObject) {
152                return mDeviceType;
153            }
154        }
155
156        /**
157         * @return the mAlias
158         */
159        String getAlias() {
160            synchronized (mObject) {
161                return mAlias;
162            }
163        }
164
165        /**
166         * @param mAlias the mAlias to set
167         */
168        void setAlias(String mAlias) {
169            synchronized (mObject) {
170                mAdapterService.setDevicePropertyNative(mAddress,
171                    AbstractionLayer.BT_PROPERTY_REMOTE_FRIENDLY_NAME, mAlias.getBytes());
172            }
173        }
174
175        /**
176         * @param mBondState the mBondState to set
177         */
178        void setBondState(int mBondState) {
179            synchronized (mObject) {
180                this.mBondState = mBondState;
181                if (mBondState == BluetoothDevice.BOND_NONE)
182                {
183                    /* Clearing the Uuids local copy when the device is unpaired. If not cleared,
184                    cachedBluetoothDevice issued a connect using the local cached copy of uuids,
185                    without waiting for the ACTION_UUID intent.
186                    This was resulting in multiple calls to connect().*/
187                    mUuids = null;
188                }
189            }
190        }
191
192        /**
193         * @return the mBondState
194         */
195        int getBondState() {
196            synchronized (mObject) {
197                return mBondState;
198            }
199        }
200    }
201
202
203    private void sendUuidIntent(BluetoothDevice device) {
204        DeviceProperties prop = getDeviceProperties(device);
205        Intent intent = new Intent(BluetoothDevice.ACTION_UUID);
206        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
207        intent.putExtra(BluetoothDevice.EXTRA_UUID, prop == null? null: prop.mUuids);
208        mAdapterService.sendBroadcast(intent, AdapterService.BLUETOOTH_ADMIN_PERM);
209
210        //Remove the outstanding UUID request
211        mSdpTracker.remove(device);
212    }
213
214    private void sendDisplayPinIntent(byte[] address, int pin) {
215        Intent intent = new Intent(BluetoothDevice.ACTION_PAIRING_REQUEST);
216        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, getDevice(address));
217        intent.putExtra(BluetoothDevice.EXTRA_PAIRING_KEY, pin);
218        intent.putExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT,
219                    BluetoothDevice.PAIRING_VARIANT_DISPLAY_PIN);
220        mAdapterService.sendBroadcast(intent, mAdapterService.BLUETOOTH_ADMIN_PERM);
221    }
222
223    void devicePropertyChangedCallback(byte[] address, int[] types, byte[][] values) {
224        Intent intent;
225        byte[] val;
226        int type;
227        BluetoothDevice bdDevice = getDevice(address);
228        DeviceProperties device;
229        if (bdDevice == null) {
230            device = addDeviceProperties(address);
231            bdDevice = getDevice(address);
232        } else {
233            device = getDeviceProperties(bdDevice);
234        }
235
236        for (int j = 0; j < types.length; j++) {
237            type = types[j];
238            val = values[j];
239            if(val.length <= 0)
240                errorLog("devicePropertyChangedCallback: bdDevice: " + bdDevice + ", value is empty for type: " + type);
241            else {
242                synchronized(mObject) {
243                    switch (type) {
244                        case AbstractionLayer.BT_PROPERTY_BDNAME:
245                            device.mName = new String(val);
246                            intent = new Intent(BluetoothDevice.ACTION_NAME_CHANGED);
247                            intent.putExtra(BluetoothDevice.EXTRA_DEVICE, bdDevice);
248                            intent.putExtra(BluetoothDevice.EXTRA_NAME, device.mName);
249                            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
250                            mAdapterService.sendBroadcast(intent, mAdapterService.BLUETOOTH_PERM);
251                            debugLog("Remote Device name is: " + device.mName);
252                            break;
253                        case AbstractionLayer.BT_PROPERTY_REMOTE_FRIENDLY_NAME:
254                            if (device.mAlias != null) {
255                                System.arraycopy(val, 0, device.mAlias, 0, val.length);
256                            }
257                            else {
258                                device.mAlias = new String(val);
259                            }
260                            break;
261                        case AbstractionLayer.BT_PROPERTY_BDADDR:
262                            device.mAddress = val;
263                            debugLog("Remote Address is:" + Utils.getAddressStringFromByte(val));
264                            break;
265                        case AbstractionLayer.BT_PROPERTY_CLASS_OF_DEVICE:
266                            device.mBluetoothClass =  Utils.byteArrayToInt(val);
267                            intent = new Intent(BluetoothDevice.ACTION_CLASS_CHANGED);
268                            intent.putExtra(BluetoothDevice.EXTRA_DEVICE, bdDevice);
269                            intent.putExtra(BluetoothDevice.EXTRA_CLASS,
270                                    new BluetoothClass(device.mBluetoothClass));
271                            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
272                            mAdapterService.sendBroadcast(intent, mAdapterService.BLUETOOTH_PERM);
273                            debugLog("Remote class is:" + device.mBluetoothClass);
274                            break;
275                        case AbstractionLayer.BT_PROPERTY_UUIDS:
276                            int numUuids = val.length/AbstractionLayer.BT_UUID_SIZE;
277                            device.mUuids = Utils.byteArrayToUuid(val);
278                            sendUuidIntent(bdDevice);
279                            break;
280                        case AbstractionLayer.BT_PROPERTY_TYPE_OF_DEVICE:
281                            device.mDeviceType = Utils.byteArrayToInt(val);
282                            break;
283                        case AbstractionLayer.BT_PROPERTY_REMOTE_RSSI:
284                            device.mRssi = Utils.byteArrayToShort(val);
285                            break;
286                    }
287                }
288            }
289        }
290    }
291
292    void deviceFoundCallback(byte[] address) {
293        // The device properties are already registered - we can send the intent
294        // now
295        BluetoothDevice device = getDevice(address);
296        debugLog("deviceFoundCallback: Remote Address is:" + device);
297        DeviceProperties deviceProp = getDeviceProperties(device);
298        if (deviceProp == null) {
299            errorLog("Device Properties is null for Device:" + device);
300            return;
301        }
302
303        Intent intent = new Intent(BluetoothDevice.ACTION_FOUND);
304        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
305        intent.putExtra(BluetoothDevice.EXTRA_CLASS,
306                new BluetoothClass(Integer.valueOf(deviceProp.mBluetoothClass)));
307        intent.putExtra(BluetoothDevice.EXTRA_RSSI, deviceProp.mRssi);
308        intent.putExtra(BluetoothDevice.EXTRA_NAME, deviceProp.mName);
309
310        mAdapterService.sendBroadcast(intent, mAdapterService.BLUETOOTH_PERM);
311    }
312
313    void pinRequestCallback(byte[] address, byte[] name, int cod) {
314        //TODO(BT): Get wakelock and update name and cod
315        BluetoothDevice bdDevice = getDevice(address);
316        if (bdDevice == null) {
317            addDeviceProperties(address);
318        }
319        BluetoothClass btClass = bdDevice.getBluetoothClass();
320        int btDeviceClass = btClass.getDeviceClass();
321        if (btDeviceClass == BluetoothClass.Device.PERIPHERAL_KEYBOARD ||
322            btDeviceClass == BluetoothClass.Device.PERIPHERAL_KEYBOARD_POINTING) {
323            // Its a keyboard. Follow the HID spec recommendation of creating the
324            // passkey and displaying it to the user. If the keyboard doesn't follow
325            // the spec recommendation, check if the keyboard has a fixed PIN zero
326            // and pair.
327            //TODO: Add sFixedPinZerosAutoPairKeyboard() and maintain list of devices that have fixed pin
328            /*if (mAdapterService.isFixedPinZerosAutoPairKeyboard(address)) {
329                               mAdapterService.setPin(address, BluetoothDevice.convertPinToBytes("0000"));
330                               return;
331                     }*/
332            // Generate a variable PIN. This is not truly random but good enough.
333            int pin = (int) Math.floor(Math.random() * 1000000);
334            sendDisplayPinIntent(address, pin);
335            return;
336        }
337        infoLog("pinRequestCallback: " + address + " name:" + name + " cod:" +
338                cod);
339        Intent intent = new Intent(BluetoothDevice.ACTION_PAIRING_REQUEST);
340        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, getDevice(address));
341        intent.putExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT,
342                BluetoothDevice.PAIRING_VARIANT_PIN);
343        mAdapterService.sendBroadcast(intent, mAdapterService.BLUETOOTH_ADMIN_PERM);
344        return;
345    }
346
347    void sspRequestCallback(byte[] address, byte[] name, int cod, int pairingVariant,
348            int passkey) {
349        //TODO(BT): Get wakelock and update name and cod
350        BluetoothDevice bdDevice = getDevice(address);
351        if (bdDevice == null) {
352            addDeviceProperties(address);
353        }
354
355        infoLog("sspRequestCallback: " + address + " name: " + name + " cod: " +
356                cod + " pairingVariant " + pairingVariant + " passkey: " + passkey);
357        int variant;
358        boolean displayPasskey = false;
359        if (pairingVariant == AbstractionLayer.BT_SSP_VARIANT_PASSKEY_CONFIRMATION) {
360            variant = BluetoothDevice.PAIRING_VARIANT_PASSKEY_CONFIRMATION;
361            displayPasskey = true;
362        } else if (pairingVariant == AbstractionLayer.BT_SSP_VARIANT_CONSENT) {
363            variant = BluetoothDevice.PAIRING_VARIANT_CONSENT;
364        } else if (pairingVariant == AbstractionLayer.BT_SSP_VARIANT_PASSKEY_ENTRY) {
365            variant = BluetoothDevice.PAIRING_VARIANT_PASSKEY;
366        } else if (pairingVariant == AbstractionLayer.BT_SSP_VARIANT_PASSKEY_NOTIFICATION) {
367            variant = BluetoothDevice.PAIRING_VARIANT_DISPLAY_PASSKEY;
368	    displayPasskey = true;
369        } else {
370            errorLog("SSP Pairing variant not present");
371            return;
372        }
373        BluetoothDevice device = getDevice(address);
374        if (device == null) {
375           warnLog("Device is not known for:" + Utils.getAddressStringFromByte(address));
376           addDeviceProperties(address);
377           device = getDevice(address);
378        }
379        Intent intent = new Intent(BluetoothDevice.ACTION_PAIRING_REQUEST);
380        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
381        if (displayPasskey) {
382            intent.putExtra(BluetoothDevice.EXTRA_PAIRING_KEY, passkey);
383        }
384        intent.putExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, variant);
385        mAdapterService.sendBroadcast(intent, mAdapterService.BLUETOOTH_ADMIN_PERM);
386    }
387
388    void aclStateChangeCallback(int status, byte[] address, int newState) {
389        BluetoothDevice device = getDevice(address);
390
391        if (device == null) {
392            errorLog("aclStateChangeCallback: Device is NULL");
393            return;
394        }
395
396        Intent intent = null;
397        if (newState == AbstractionLayer.BT_ACL_STATE_CONNECTED) {
398            intent = new Intent(BluetoothDevice.ACTION_ACL_CONNECTED);
399            debugLog("aclStateChangeCallback: State:Connected to Device:" + device);
400        } else {
401            intent = new Intent(BluetoothDevice.ACTION_ACL_DISCONNECTED);
402            debugLog("aclStateChangeCallback: State:DisConnected to Device:" + device);
403        }
404        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
405        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
406        mAdapterService.sendBroadcast(intent, mAdapterService.BLUETOOTH_PERM);
407    }
408
409    void fetchUuids(BluetoothDevice device) {
410        if (mSdpTracker.contains(device)) return;
411        mSdpTracker.add(device);
412
413        Message message = mHandler.obtainMessage(MESSAGE_UUID_INTENT);
414        message.obj = device;
415        mHandler.sendMessageDelayed(message, UUID_INTENT_DELAY);
416
417        //mAdapterService.getDevicePropertyNative(Utils.getBytesFromAddress(device.getAddress()), AbstractionLayer.BT_PROPERTY_UUIDS);
418        mAdapterService.getRemoteServicesNative(Utils.getBytesFromAddress(device.getAddress()));
419    }
420
421    private final Handler mHandler = new Handler() {
422        @Override
423        public void handleMessage(Message msg) {
424            switch (msg.what) {
425            case MESSAGE_UUID_INTENT:
426                BluetoothDevice device = (BluetoothDevice)msg.obj;
427                if (device != null) {
428                    sendUuidIntent(device);
429                }
430                break;
431            }
432        }
433    };
434
435    private void errorLog(String msg) {
436        Log.e(TAG, msg);
437    }
438
439    private void debugLog(String msg) {
440        if (DBG) Log.d(TAG, msg);
441    }
442
443    private void infoLog(String msg) {
444        if (DBG) Log.i(TAG, msg);
445    }
446
447    private void warnLog(String msg) {
448        Log.w(TAG, msg);
449    }
450
451}
452