BluetoothPan.java revision 6090995951c6e2e4dcf38102f01793f8a94166e1
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package android.bluetooth; 18 19import android.annotation.SdkConstant; 20import android.annotation.SdkConstant.SdkConstantType; 21import android.content.ComponentName; 22import android.content.Context; 23import android.content.Intent; 24import android.content.ServiceConnection; 25import android.os.IBinder; 26import android.os.RemoteException; 27import android.util.Log; 28 29import java.util.ArrayList; 30import java.util.List; 31 32/** 33 * This class provides the APIs to control the Bluetooth Pan 34 * Profile. 35 * 36 *<p>BluetoothPan is a proxy object for controlling the Bluetooth 37 * Service via IPC. Use {@link BluetoothAdapter#getProfileProxy} to get 38 * the BluetoothPan proxy object. 39 * 40 *<p>Each method is protected with its appropriate permission. 41 *@hide 42 */ 43public final class BluetoothPan implements BluetoothProfile { 44 private static final String TAG = "BluetoothPan"; 45 private static final boolean DBG = true; 46 private static final boolean VDBG = false; 47 48 /** 49 * Intent used to broadcast the change in connection state of the Pan 50 * profile. 51 * 52 * <p>This intent will have 4 extras: 53 * <ul> 54 * <li> {@link #EXTRA_STATE} - The current state of the profile. </li> 55 * <li> {@link #EXTRA_PREVIOUS_STATE}- The previous state of the profile.</li> 56 * <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote device. </li> 57 * <li> {@link #EXTRA_LOCAL_ROLE} - Which local role the remote device is 58 * bound to. </li> 59 * </ul> 60 * 61 * <p>{@link #EXTRA_STATE} or {@link #EXTRA_PREVIOUS_STATE} can be any of 62 * {@link #STATE_DISCONNECTED}, {@link #STATE_CONNECTING}, 63 * {@link #STATE_CONNECTED}, {@link #STATE_DISCONNECTING}. 64 * 65 * <p> {@link #EXTRA_LOCAL_ROLE} can be one of {@link #LOCAL_NAP_ROLE} or 66 * {@link #LOCAL_PANU_ROLE} 67 * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission to 68 * receive. 69 */ 70 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 71 public static final String ACTION_CONNECTION_STATE_CHANGED = 72 "android.bluetooth.pan.profile.action.CONNECTION_STATE_CHANGED"; 73 74 /** 75 * Extra for {@link #ACTION_CONNECTION_STATE_CHANGED} intent 76 * The local role of the PAN profile that the remote device is bound to. 77 * It can be one of {@link #LOCAL_NAP_ROLE} or {@link #LOCAL_PANU_ROLE}. 78 */ 79 public static final String EXTRA_LOCAL_ROLE = "android.bluetooth.pan.extra.LOCAL_ROLE"; 80 81 public static final int PAN_ROLE_NONE = 0; 82 /** 83 * The local device is acting as a Network Access Point. 84 */ 85 public static final int LOCAL_NAP_ROLE = 1; 86 public static final int REMOTE_NAP_ROLE = 1; 87 88 /** 89 * The local device is acting as a PAN User. 90 */ 91 public static final int LOCAL_PANU_ROLE = 2; 92 public static final int REMOTE_PANU_ROLE = 2; 93 94 /** 95 * Return codes for the connect and disconnect Bluez / Dbus calls. 96 * @hide 97 */ 98 public static final int PAN_DISCONNECT_FAILED_NOT_CONNECTED = 1000; 99 100 /** 101 * @hide 102 */ 103 public static final int PAN_CONNECT_FAILED_ALREADY_CONNECTED = 1001; 104 105 /** 106 * @hide 107 */ 108 public static final int PAN_CONNECT_FAILED_ATTEMPT_FAILED = 1002; 109 110 /** 111 * @hide 112 */ 113 public static final int PAN_OPERATION_GENERIC_FAILURE = 1003; 114 115 /** 116 * @hide 117 */ 118 public static final int PAN_OPERATION_SUCCESS = 1004; 119 120 private Context mContext; 121 private ServiceListener mServiceListener; 122 private BluetoothAdapter mAdapter; 123 private IBluetoothPan mPanService; 124 125 /** 126 * Create a BluetoothPan proxy object for interacting with the local 127 * Bluetooth Service which handles the Pan profile 128 * 129 */ 130 /*package*/ BluetoothPan(Context context, ServiceListener l) { 131 mContext = context; 132 mServiceListener = l; 133 mAdapter = BluetoothAdapter.getDefaultAdapter(); 134 try { 135 mAdapter.getBluetoothManager().registerStateChangeCallback(mStateChangeCallback); 136 } catch (RemoteException re) { 137 Log.w(TAG,"Unable to register BluetoothStateChangeCallback",re); 138 } 139 if (VDBG) Log.d(TAG, "BluetoothPan() call bindService"); 140 doBind(); 141 if (VDBG) Log.d(TAG, "BluetoothPan(), bindService called"); 142 } 143 144 boolean doBind() { 145 Intent intent = new Intent(IBluetoothPan.class.getName()); 146 ComponentName comp = intent.resolveSystemService(mContext.getPackageManager(), 0); 147 intent.setComponent(comp); 148 if (comp == null || !mContext.bindService(intent, mConnection, 0)) { 149 Log.e(TAG, "Could not bind to Bluetooth Pan Service with " + intent); 150 return false; 151 } 152 return true; 153 } 154 155 /*package*/ void close() { 156 if (VDBG) log("close()"); 157 158 IBluetoothManager mgr = mAdapter.getBluetoothManager(); 159 if (mgr != null) { 160 try { 161 mgr.unregisterStateChangeCallback(mStateChangeCallback); 162 } catch (RemoteException re) { 163 Log.w(TAG,"Unable to unregister BluetoothStateChangeCallback",re); 164 } 165 } 166 167 synchronized (mConnection) { 168 if (mPanService != null) { 169 try { 170 mPanService = null; 171 mContext.unbindService(mConnection); 172 } catch (Exception re) { 173 Log.e(TAG,"",re); 174 } 175 } 176 } 177 mServiceListener = null; 178 } 179 180 protected void finalize() { 181 close(); 182 } 183 184 final private IBluetoothStateChangeCallback mStateChangeCallback = new IBluetoothStateChangeCallback.Stub() { 185 186 @Override 187 public void onBluetoothStateChange(boolean on) throws RemoteException { 188 //Handle enable request to bind again. 189 if (on) { 190 Log.d(TAG, "onBluetoothStateChange(on) call bindService"); 191 doBind(); 192 if (VDBG) Log.d(TAG, "BluetoothPan(), bindService called"); 193 } else { 194 if (VDBG) Log.d(TAG,"Unbinding service..."); 195 synchronized (mConnection) { 196 try { 197 mPanService = null; 198 mContext.unbindService(mConnection); 199 } catch (Exception re) { 200 Log.e(TAG,"",re); 201 } 202 } 203 } 204 } 205 }; 206 207 /** 208 * Initiate connection to a profile of the remote bluetooth device. 209 * 210 * <p> This API returns false in scenarios like the profile on the 211 * device is already connected or Bluetooth is not turned on. 212 * When this API returns true, it is guaranteed that 213 * connection state intent for the profile will be broadcasted with 214 * the state. Users can get the connection state of the profile 215 * from this intent. 216 * 217 * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} 218 * permission. 219 * 220 * @param device Remote Bluetooth Device 221 * @return false on immediate error, 222 * true otherwise 223 * @hide 224 */ 225 public boolean connect(BluetoothDevice device) { 226 if (DBG) log("connect(" + device + ")"); 227 if (mPanService != null && isEnabled() && 228 isValidDevice(device)) { 229 try { 230 return mPanService.connect(device); 231 } catch (RemoteException e) { 232 Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); 233 return false; 234 } 235 } 236 if (mPanService == null) Log.w(TAG, "Proxy not attached to service"); 237 return false; 238 } 239 240 /** 241 * Initiate disconnection from a profile 242 * 243 * <p> This API will return false in scenarios like the profile on the 244 * Bluetooth device is not in connected state etc. When this API returns, 245 * true, it is guaranteed that the connection state change 246 * intent will be broadcasted with the state. Users can get the 247 * disconnection state of the profile from this intent. 248 * 249 * <p> If the disconnection is initiated by a remote device, the state 250 * will transition from {@link #STATE_CONNECTED} to 251 * {@link #STATE_DISCONNECTED}. If the disconnect is initiated by the 252 * host (local) device the state will transition from 253 * {@link #STATE_CONNECTED} to state {@link #STATE_DISCONNECTING} to 254 * state {@link #STATE_DISCONNECTED}. The transition to 255 * {@link #STATE_DISCONNECTING} can be used to distinguish between the 256 * two scenarios. 257 * 258 * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} 259 * permission. 260 * 261 * @param device Remote Bluetooth Device 262 * @return false on immediate error, 263 * true otherwise 264 * @hide 265 */ 266 public boolean disconnect(BluetoothDevice device) { 267 if (DBG) log("disconnect(" + device + ")"); 268 if (mPanService != null && isEnabled() && 269 isValidDevice(device)) { 270 try { 271 return mPanService.disconnect(device); 272 } catch (RemoteException e) { 273 Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); 274 return false; 275 } 276 } 277 if (mPanService == null) Log.w(TAG, "Proxy not attached to service"); 278 return false; 279 } 280 281 /** 282 * {@inheritDoc} 283 */ 284 public List<BluetoothDevice> getConnectedDevices() { 285 if (VDBG) log("getConnectedDevices()"); 286 if (mPanService != null && isEnabled()) { 287 try { 288 return mPanService.getConnectedDevices(); 289 } catch (RemoteException e) { 290 Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); 291 return new ArrayList<BluetoothDevice>(); 292 } 293 } 294 if (mPanService == null) Log.w(TAG, "Proxy not attached to service"); 295 return new ArrayList<BluetoothDevice>(); 296 } 297 298 /** 299 * {@inheritDoc} 300 */ 301 public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) { 302 if (VDBG) log("getDevicesMatchingStates()"); 303 if (mPanService != null && isEnabled()) { 304 try { 305 return mPanService.getDevicesMatchingConnectionStates(states); 306 } catch (RemoteException e) { 307 Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); 308 return new ArrayList<BluetoothDevice>(); 309 } 310 } 311 if (mPanService == null) Log.w(TAG, "Proxy not attached to service"); 312 return new ArrayList<BluetoothDevice>(); 313 } 314 315 /** 316 * {@inheritDoc} 317 */ 318 public int getConnectionState(BluetoothDevice device) { 319 if (VDBG) log("getState(" + device + ")"); 320 if (mPanService != null && isEnabled() 321 && isValidDevice(device)) { 322 try { 323 return mPanService.getConnectionState(device); 324 } catch (RemoteException e) { 325 Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); 326 return BluetoothProfile.STATE_DISCONNECTED; 327 } 328 } 329 if (mPanService == null) Log.w(TAG, "Proxy not attached to service"); 330 return BluetoothProfile.STATE_DISCONNECTED; 331 } 332 333 public void setBluetoothTethering(boolean value) { 334 if (DBG) log("setBluetoothTethering(" + value + ")"); 335 try { 336 mPanService.setBluetoothTethering(value); 337 } catch (RemoteException e) { 338 Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); 339 } 340 } 341 342 public boolean isTetheringOn() { 343 if (VDBG) log("isTetheringOn()"); 344 try { 345 return mPanService.isTetheringOn(); 346 } catch (RemoteException e) { 347 Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); 348 } 349 return false; 350 } 351 352 private final ServiceConnection mConnection = new ServiceConnection() { 353 public void onServiceConnected(ComponentName className, IBinder service) { 354 if (DBG) Log.d(TAG, "BluetoothPAN Proxy object connected"); 355 mPanService = IBluetoothPan.Stub.asInterface(service); 356 357 if (mServiceListener != null) { 358 mServiceListener.onServiceConnected(BluetoothProfile.PAN, 359 BluetoothPan.this); 360 } 361 } 362 public void onServiceDisconnected(ComponentName className) { 363 if (DBG) Log.d(TAG, "BluetoothPAN Proxy object disconnected"); 364 mPanService = null; 365 if (mServiceListener != null) { 366 mServiceListener.onServiceDisconnected(BluetoothProfile.PAN); 367 } 368 } 369 }; 370 371 private boolean isEnabled() { 372 if (mAdapter.getState() == BluetoothAdapter.STATE_ON) return true; 373 return false; 374 } 375 376 private boolean isValidDevice(BluetoothDevice device) { 377 if (device == null) return false; 378 379 if (BluetoothAdapter.checkBluetoothAddress(device.getAddress())) return true; 380 return false; 381 } 382 383 private static void log(String msg) { 384 Log.d(TAG, msg); 385 } 386} 387