BluetoothOppManager.java revision 1c87133a411302f275440bad23aa04b720dcd753
1/* 2 * Copyright (c) 2008-2009, Motorola, Inc. 3 * 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * - Redistributions of source code must retain the above copyright notice, 10 * this list of conditions and the following disclaimer. 11 * 12 * - Redistributions in binary form must reproduce the above copyright notice, 13 * this list of conditions and the following disclaimer in the documentation 14 * and/or other materials provided with the distribution. 15 * 16 * - Neither the name of the Motorola, Inc. nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33package com.android.bluetooth.opp; 34 35import com.android.bluetooth.R; 36 37import android.bluetooth.BluetoothAdapter; 38import android.bluetooth.BluetoothDevice; 39import android.content.ContentResolver; 40import android.content.ContentValues; 41import android.content.Context; 42import android.content.Intent; 43import android.content.SharedPreferences; 44import android.net.Uri; 45import android.os.Process; 46import android.os.SystemClock; 47import android.text.TextUtils; 48import android.util.Log; 49import android.util.Pair; 50 51import java.util.ArrayList; 52import java.util.Iterator; 53import java.util.List; 54 55/** 56 * This class provides a simplified interface on top of other Bluetooth service 57 * layer components; Also it handles some Opp application level variables. It's 58 * a singleton got from BluetoothOppManager.getInstance(context); 59 */ 60public class BluetoothOppManager { 61 private static final String TAG = "BluetoothOppManager"; 62 private static final boolean V = Constants.VERBOSE; 63 64 private static BluetoothOppManager INSTANCE; 65 66 /** Used when obtaining a reference to the singleton instance. */ 67 private static Object INSTANCE_LOCK = new Object(); 68 69 private boolean mInitialized; 70 71 private Context mContext; 72 73 private BluetoothAdapter mAdapter; 74 75 private String mMimeTypeOfSendingFile; 76 77 private String mUriOfSendingFile; 78 79 private String mMimeTypeOfSendingFiles; 80 81 private ArrayList<Uri> mUrisOfSendingFiles; 82 83 private boolean mIsHandoverInitiated; 84 85 private static final String OPP_PREFERENCE_FILE = "OPPMGR"; 86 87 private static final String SENDING_FLAG = "SENDINGFLAG"; 88 89 private static final String MIME_TYPE = "MIMETYPE"; 90 91 private static final String FILE_URI = "FILE_URI"; 92 93 private static final String MIME_TYPE_MULTIPLE = "MIMETYPE_MULTIPLE"; 94 95 private static final String FILE_URIS = "FILE_URIS"; 96 97 private static final String MULTIPLE_FLAG = "MULTIPLE_FLAG"; 98 99 private static final String ARRAYLIST_ITEM_SEPERATOR = ";"; 100 101 private static final int ALLOWED_INSERT_SHARE_THREAD_NUMBER = 3; 102 103 // used to judge if need continue sending process after received a 104 // ENABLED_ACTION 105 public boolean mSendingFlag; 106 107 public boolean mMultipleFlag; 108 109 private int mfileNumInBatch; 110 111 private int mInsertShareThreadNum = 0; 112 113 // A list of devices that may send files over OPP to this device 114 // without user confirmation. Used for connection handover from forex NFC. 115 private List<Pair<String,Long> > mWhitelist = new ArrayList<Pair<String, Long> >(); 116 117 // The time for which the whitelist entries remain valid. 118 private static final int WHITELIST_DURATION_MS = 15000; 119 120 /** 121 * Get singleton instance. 122 */ 123 public static BluetoothOppManager getInstance(Context context) { 124 synchronized (INSTANCE_LOCK) { 125 if (INSTANCE == null) { 126 INSTANCE = new BluetoothOppManager(); 127 } 128 INSTANCE.init(context); 129 130 return INSTANCE; 131 } 132 } 133 134 /** 135 * init 136 */ 137 private boolean init(Context context) { 138 if (mInitialized) 139 return true; 140 mInitialized = true; 141 142 mContext = context; 143 144 mAdapter = BluetoothAdapter.getDefaultAdapter(); 145 if (mAdapter == null) { 146 if (V) Log.v(TAG, "BLUETOOTH_SERVICE is not started! "); 147 } 148 149 // Restore data from preference 150 restoreApplicationData(); 151 152 return true; 153 } 154 155 156 private void cleanupWhitelist() { 157 // Removes expired entries 158 long curTime = SystemClock.elapsedRealtime(); 159 for (Iterator<Pair<String,Long>> iter = mWhitelist.iterator(); iter.hasNext(); ) { 160 Pair<String,Long> entry = iter.next(); 161 if (curTime - entry.second > WHITELIST_DURATION_MS) { 162 if (V) Log.v(TAG, "Cleaning out whitelist entry " + entry.first); 163 iter.remove(); 164 } 165 } 166 } 167 168 public synchronized void addToWhitelist(String address) { 169 if (address == null) return; 170 // Remove any existing entries 171 for (Iterator<Pair<String,Long>> iter = mWhitelist.iterator(); iter.hasNext(); ) { 172 Pair<String,Long> entry = iter.next(); 173 if (entry.first.equals(address)) { 174 iter.remove(); 175 } 176 } 177 mWhitelist.add(new Pair<String, Long>(address, SystemClock.elapsedRealtime())); 178 } 179 180 public synchronized boolean isWhitelisted(String address) { 181 cleanupWhitelist(); 182 for (Pair<String,Long> entry : mWhitelist) { 183 if (entry.first.equals(address)) return true; 184 } 185 return false; 186 } 187 188 /** 189 * Restore data from preference 190 */ 191 private void restoreApplicationData() { 192 SharedPreferences settings = mContext.getSharedPreferences(OPP_PREFERENCE_FILE, 0); 193 194 // All member vars are not initialized till now 195 mSendingFlag = settings.getBoolean(SENDING_FLAG, false); 196 mMimeTypeOfSendingFile = settings.getString(MIME_TYPE, null); 197 mUriOfSendingFile = settings.getString(FILE_URI, null); 198 mMimeTypeOfSendingFiles = settings.getString(MIME_TYPE_MULTIPLE, null); 199 mMultipleFlag = settings.getBoolean(MULTIPLE_FLAG, false); 200 201 if (V) Log.v(TAG, "restoreApplicationData! " + mSendingFlag + mMultipleFlag 202 + mMimeTypeOfSendingFile + mUriOfSendingFile); 203 204 String strUris = settings.getString(FILE_URIS, null); 205 mUrisOfSendingFiles = new ArrayList<Uri>(); 206 if (strUris != null) { 207 String[] splitUri = strUris.split(ARRAYLIST_ITEM_SEPERATOR); 208 for (int i = 0; i < splitUri.length; i++) { 209 mUrisOfSendingFiles.add(Uri.parse(splitUri[i])); 210 if (V) Log.v(TAG, "Uri in batch: " + Uri.parse(splitUri[i])); 211 } 212 } 213 214 mContext.getSharedPreferences(OPP_PREFERENCE_FILE, 0).edit().clear().apply(); 215 } 216 217 /** 218 * Save application data to preference, need restore these data when service restart 219 */ 220 private void storeApplicationData() { 221 SharedPreferences.Editor editor = mContext.getSharedPreferences(OPP_PREFERENCE_FILE, 0) 222 .edit(); 223 editor.putBoolean(SENDING_FLAG, mSendingFlag); 224 editor.putBoolean(MULTIPLE_FLAG, mMultipleFlag); 225 if (mMultipleFlag) { 226 editor.putString(MIME_TYPE_MULTIPLE, mMimeTypeOfSendingFiles); 227 StringBuilder sb = new StringBuilder(); 228 for (int i = 0, count = mUrisOfSendingFiles.size(); i < count; i++) { 229 Uri uriContent = mUrisOfSendingFiles.get(i); 230 sb.append(uriContent); 231 sb.append(ARRAYLIST_ITEM_SEPERATOR); 232 } 233 String strUris = sb.toString(); 234 editor.putString(FILE_URIS, strUris); 235 236 editor.remove(MIME_TYPE); 237 editor.remove(FILE_URI); 238 } else { 239 editor.putString(MIME_TYPE, mMimeTypeOfSendingFile); 240 editor.putString(FILE_URI, mUriOfSendingFile); 241 242 editor.remove(MIME_TYPE_MULTIPLE); 243 editor.remove(FILE_URIS); 244 } 245 editor.apply(); 246 if (V) Log.v(TAG, "Application data stored to SharedPreference! "); 247 } 248 249 public void saveSendingFileInfo(String mimeType, String uriString, boolean isHandover) 250 throws IllegalArgumentException { 251 synchronized (BluetoothOppManager.this) { 252 mMultipleFlag = false; 253 mMimeTypeOfSendingFile = mimeType; 254 mUriOfSendingFile = uriString; 255 mIsHandoverInitiated = isHandover; 256 Uri uri = Uri.parse(uriString); 257 BluetoothOppUtility.putSendFileInfo(uri, 258 BluetoothOppSendFileInfo.generateFileInfo(mContext, uri, mimeType)); 259 storeApplicationData(); 260 } 261 } 262 263 public void saveSendingFileInfo(String mimeType, ArrayList<Uri> uris, boolean isHandover) 264 throws IllegalArgumentException { 265 synchronized (BluetoothOppManager.this) { 266 mMultipleFlag = true; 267 mMimeTypeOfSendingFiles = mimeType; 268 mUrisOfSendingFiles = uris; 269 mIsHandoverInitiated = isHandover; 270 for (Uri uri : uris) { 271 BluetoothOppUtility.putSendFileInfo(uri, 272 BluetoothOppSendFileInfo.generateFileInfo(mContext, uri, mimeType)); 273 } 274 storeApplicationData(); 275 } 276 } 277 278 /** 279 * Get the current status of Bluetooth hardware. 280 * @return true if Bluetooth enabled, false otherwise. 281 */ 282 public boolean isEnabled() { 283 if (mAdapter != null) { 284 return mAdapter.isEnabled(); 285 } else { 286 if (V) Log.v(TAG, "BLUETOOTH_SERVICE is not available! "); 287 return false; 288 } 289 } 290 291 /** 292 * Enable Bluetooth hardware. 293 */ 294 public void enableBluetooth() { 295 if (mAdapter != null) { 296 mAdapter.enable(); 297 } 298 } 299 300 /** 301 * Disable Bluetooth hardware. 302 */ 303 public void disableBluetooth() { 304 if (mAdapter != null) { 305 mAdapter.disable(); 306 } 307 } 308 309 /** 310 * Get device name per bluetooth address. 311 */ 312 public String getDeviceName(BluetoothDevice device) { 313 String deviceName; 314 315 deviceName = BluetoothOppPreference.getInstance(mContext).getName(device); 316 317 if (deviceName == null && mAdapter != null) { 318 deviceName = device.getName(); 319 } 320 321 if (deviceName == null) { 322 deviceName = mContext.getString(R.string.unknown_device); 323 } 324 325 return deviceName; 326 } 327 328 public int getBatchSize() { 329 synchronized (BluetoothOppManager.this) { 330 return mfileNumInBatch; 331 } 332 } 333 334 /** 335 * Fork a thread to insert share info to db. 336 */ 337 public void startTransfer(BluetoothDevice device) { 338 if (V) Log.v(TAG, "Active InsertShareThread number is : " + mInsertShareThreadNum); 339 InsertShareInfoThread insertThread; 340 synchronized (BluetoothOppManager.this) { 341 if (mInsertShareThreadNum > ALLOWED_INSERT_SHARE_THREAD_NUMBER) { 342 Log.e(TAG, "Too many shares user triggered concurrently!"); 343 344 // Notice user 345 Intent in = new Intent(mContext, BluetoothOppBtErrorActivity.class); 346 in.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 347 in.putExtra("title", mContext.getString(R.string.enabling_progress_title)); 348 in.putExtra("content", mContext.getString(R.string.ErrorTooManyRequests)); 349 mContext.startActivity(in); 350 351 return; 352 } 353 insertThread = new InsertShareInfoThread(device, mMultipleFlag, mMimeTypeOfSendingFile, 354 mUriOfSendingFile, mMimeTypeOfSendingFiles, mUrisOfSendingFiles, 355 mIsHandoverInitiated); 356 if (mMultipleFlag) { 357 mfileNumInBatch = mUrisOfSendingFiles.size(); 358 } 359 } 360 361 insertThread.start(); 362 } 363 364 /** 365 * Thread to insert share info to db. In multiple files (say 100 files) 366 * share case, the inserting share info to db operation would be a time 367 * consuming operation, so need a thread to handle it. This thread allows 368 * multiple instances to support below case: User select multiple files to 369 * share to one device (say device 1), and then right away share to second 370 * device (device 2), we need insert all these share info to db. 371 */ 372 private class InsertShareInfoThread extends Thread { 373 private final BluetoothDevice mRemoteDevice; 374 375 private final String mTypeOfSingleFile; 376 377 private final String mUri; 378 379 private final String mTypeOfMultipleFiles; 380 381 private final ArrayList<Uri> mUris; 382 383 private final boolean mIsMultiple; 384 385 private final boolean mIsHandoverInitiated; 386 387 public InsertShareInfoThread(BluetoothDevice device, boolean multiple, 388 String typeOfSingleFile, String uri, String typeOfMultipleFiles, 389 ArrayList<Uri> uris, boolean handoverInitiated) { 390 super("Insert ShareInfo Thread"); 391 this.mRemoteDevice = device; 392 this.mIsMultiple = multiple; 393 this.mTypeOfSingleFile = typeOfSingleFile; 394 this.mUri = uri; 395 this.mTypeOfMultipleFiles = typeOfMultipleFiles; 396 this.mUris = uris; 397 this.mIsHandoverInitiated = handoverInitiated; 398 399 synchronized (BluetoothOppManager.this) { 400 mInsertShareThreadNum++; 401 } 402 403 if (V) Log.v(TAG, "Thread id is: " + this.getId()); 404 } 405 406 @Override 407 public void run() { 408 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); 409 if (mRemoteDevice == null) { 410 Log.e(TAG, "Target bt device is null!"); 411 return; 412 } 413 if (mIsMultiple) { 414 insertMultipleShare(); 415 } else { 416 insertSingleShare(); 417 } 418 synchronized (BluetoothOppManager.this) { 419 mInsertShareThreadNum--; 420 } 421 } 422 423 /** 424 * Insert multiple sending sessions to db, only used by Opp application. 425 */ 426 private void insertMultipleShare() { 427 int count = mUris.size(); 428 Long ts = System.currentTimeMillis(); 429 for (int i = 0; i < count; i++) { 430 Uri fileUri = mUris.get(i); 431 ContentResolver contentResolver = mContext.getContentResolver(); 432 String contentType = contentResolver.getType(fileUri); 433 if (V) Log.v(TAG, "Got mimetype: " + contentType + " Got uri: " + fileUri); 434 if (TextUtils.isEmpty(contentType)) { 435 contentType = mTypeOfMultipleFiles; 436 } 437 438 ContentValues values = new ContentValues(); 439 values.put(BluetoothShare.URI, fileUri.toString()); 440 values.put(BluetoothShare.MIMETYPE, contentType); 441 values.put(BluetoothShare.DESTINATION, mRemoteDevice.getAddress()); 442 values.put(BluetoothShare.TIMESTAMP, ts); 443 if (mIsHandoverInitiated) { 444 values.put(BluetoothShare.USER_CONFIRMATION, 445 BluetoothShare.USER_CONFIRMATION_HANDOVER_CONFIRMED); 446 } 447 final Uri contentUri = mContext.getContentResolver().insert( 448 BluetoothShare.CONTENT_URI, values); 449 if (V) Log.v(TAG, "Insert contentUri: " + contentUri + " to device: " 450 + getDeviceName(mRemoteDevice)); 451 } 452 } 453 454 /** 455 * Insert single sending session to db, only used by Opp application. 456 */ 457 private void insertSingleShare() { 458 ContentValues values = new ContentValues(); 459 values.put(BluetoothShare.URI, mUri); 460 values.put(BluetoothShare.MIMETYPE, mTypeOfSingleFile); 461 values.put(BluetoothShare.DESTINATION, mRemoteDevice.getAddress()); 462 if (mIsHandoverInitiated) { 463 values.put(BluetoothShare.USER_CONFIRMATION, 464 BluetoothShare.USER_CONFIRMATION_HANDOVER_CONFIRMED); 465 } 466 final Uri contentUri = mContext.getContentResolver().insert(BluetoothShare.CONTENT_URI, 467 values); 468 if (V) Log.v(TAG, "Insert contentUri: " + contentUri + " to device: " 469 + getDeviceName(mRemoteDevice)); 470 } 471 } 472 473 void cleanUpSendingFileInfo() { 474 synchronized (BluetoothOppManager.this) { 475 if (V) Log.v(TAG, "cleanUpSendingFileInfo: mMultipleFlag = " + mMultipleFlag); 476 if (!mMultipleFlag && (mUriOfSendingFile != null)) { 477 Uri uri = Uri.parse(mUriOfSendingFile); 478 BluetoothOppUtility.closeSendFileInfo(uri); 479 } else if (mUrisOfSendingFiles != null) { 480 for (Uri uri : mUrisOfSendingFiles) { 481 BluetoothOppUtility.closeSendFileInfo(uri); 482 } 483 } 484 } 485 } 486} 487