Android: Bluetooth Application Manager Interaction

Java Class for Bluetooth Application Manager Interaction

This below Java class in Android Application Development is to interact with Bluetooth Application Manager

Java Class for Bluetooth Application Manager Interaction


/*
* Copyright (c) 2008-2009, Motorola, Inc.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of the Motorola, Inc. nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

package com.android.bluetooth.opp;

import android.content.ContentProvider;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.database.SQLException;
import android.content.UriMatcher;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteQueryBuilder;
import android.net.Uri;
import android.provider.LiveFolders;
import android.util.Log;

import java.util.HashMap;

/**
* This provider allows application to interact with Bluetooth OPP manager
*/

public final class BluetoothOppProvider extends ContentProvider {

private static final String TAG = "BluetoothOppProvider";
private static final boolean D = Constants.DEBUG;
private static final boolean V = Constants.VERBOSE;

/** Database filename */
private static final String DB_NAME = "btopp.db";

/** Current database version */
private static final int DB_VERSION = 1;

/** Database version from which upgrading is a nop */
private static final int DB_VERSION_NOP_UPGRADE_FROM = 0;

/** Database version to which upgrading is a nop */
private static final int DB_VERSION_NOP_UPGRADE_TO = 1;

/** Name of table in the database */
private static final String DB_TABLE = "btopp";

/** MIME type for the entire share list */
private static final String SHARE_LIST_TYPE = "vnd.android.cursor.dir/vnd.android.btopp";

/** MIME type for an individual share */
private static final String SHARE_TYPE = "vnd.android.cursor.item/vnd.android.btopp";

/** URI matcher used to recognize URIs sent by applications */
private static final UriMatcher sURIMatcher = new UriMatcher(
UriMatcher.NO_MATCH);

/** URI matcher constant for the URI of the entire share list */
private static final int SHARES = 1;

/** URI matcher constant for the URI of an individual share */
private static final int SHARES_ID = 2;

/** URI matcher constant for the URI of live folder */
private static final int LIVE_FOLDER_RECEIVED_FILES = 3;
static {
sURIMatcher
.addURI("com.android.bluetooth.opp", "btopp", SHARES);
sURIMatcher.addURI("com.android.bluetooth.opp", "btopp/#",
SHARES_ID);
sURIMatcher.addURI("com.android.bluetooth.opp",
"live_folders/received", LIVE_FOLDER_RECEIVED_FILES);
}

private static final HashMap<String, String> LIVE_FOLDER_PROJECTION_MAP;
static {
LIVE_FOLDER_PROJECTION_MAP = new HashMap<String, String>();
LIVE_FOLDER_PROJECTION_MAP.put(LiveFolders._ID,
BluetoothShare._ID + " AS " + LiveFolders._ID);
LIVE_FOLDER_PROJECTION_MAP.put(LiveFolders.NAME,
BluetoothShare.FILENAME_HINT + " AS "
+ LiveFolders.NAME);
}

/** The database that lies underneath this content provider */
private SQLiteOpenHelper mOpenHelper = null;

/**
* Creates and updated database on demand when opening it. Helper class to
* create database the first time the provider is initialized and upgrade it
* when a new version of the provider needs an updated version of the
* database.
*/
private final class DatabaseHelper extends SQLiteOpenHelper {

public DatabaseHelper(final Context context) {
super (context, DB_NAME, null, DB_VERSION);
}

/**
* Creates database the first time we try to open it.
*/
@Override
public void onCreate(final SQLiteDatabase db) {
if (V)
Log.v(TAG, "populating new database");
createTable(db);
}

//TODO: use this function to check garbage transfer left in db, for example,
// a crash incoming file
/*
* (not a javadoc comment) Checks data integrity when opening the
* database.
*/
/*
* @Override public void onOpen(final SQLiteDatabase db) {
* super.onOpen(db); }
*/

/**
* Updates the database format when a content provider is used with a
* database that was created with a different format.
*/
// Note: technically, this could also be a downgrade, so if we want
// to gracefully handle upgrades we should be careful about
// what to do on downgrades.
@Override
public void onUpgrade(final SQLiteDatabase db, int oldV,
final int newV) {
if (oldV == DB_VERSION_NOP_UPGRADE_FROM) {
if (newV == DB_VERSION_NOP_UPGRADE_TO) { // that's a no-op
// upgrade.
return;
}
// NOP_FROM and NOP_TO are identical, just in different
// codelines. Upgrading
// from NOP_FROM is the same as upgrading from NOP_TO.
oldV = DB_VERSION_NOP_UPGRADE_TO;
}
Log.i(TAG, "Upgrading downloads database from version "
+ oldV + " to " + newV
+ ", which will destroy all old data");
dropTable(db);
createTable(db);
}

}

private void createTable(SQLiteDatabase db) {
try {
db.execSQL("CREATE TABLE " + DB_TABLE + "("
+ BluetoothShare._ID
+ " INTEGER PRIMARY KEY AUTOINCREMENT,"
+ BluetoothShare.URI + " TEXT, "
+ BluetoothShare.FILENAME_HINT + " TEXT, "
+ BluetoothShare._DATA + " TEXT, "
+ BluetoothShare.MIMETYPE + " TEXT, "
+ BluetoothShare.DIRECTION + " INTEGER, "
+ BluetoothShare.DESTINATION + " TEXT, "
+ BluetoothShare.VISIBILITY + " INTEGER, "
+ BluetoothShare.USER_CONFIRMATION + " INTEGER, "
+ BluetoothShare.STATUS + " INTEGER, "
+ BluetoothShare.TOTAL_BYTES + " INTEGER, "
+ BluetoothShare.CURRENT_BYTES + " INTEGER, "
+ BluetoothShare.TIMESTAMP + " INTEGER,"
+ Constants.MEDIA_SCANNED + " INTEGER); ");
} catch (SQLException ex) {
Log.e(TAG, "couldn't create table in downloads database");
throw ex;
}
}

private void dropTable(SQLiteDatabase db) {
try {
db.execSQL("DROP TABLE IF EXISTS " + DB_TABLE);
} catch (SQLException ex) {
Log.e(TAG, "couldn't drop table in downloads database");
throw ex;
}
}

@Override
public String getType(Uri uri) {
int match = sURIMatcher.match(uri);
switch (match) {
case SHARES: {
return SHARE_LIST_TYPE;
}
case SHARES_ID: {
return SHARE_TYPE;
}
default: {
if (D)
Log.d(TAG, "calling getType on an unknown URI: " + uri);
throw new IllegalArgumentException("Unknown URI: " + uri);
}
}
}

private static final void copyString(String key,
ContentValues from, ContentValues to) {
String s = from.getAsString(key);
if (s != null) {
to.put(key, s);
}
}

private static final void copyInteger(String key,
ContentValues from, ContentValues to) {
Integer i = from.getAsInteger(key);
if (i != null) {
to.put(key, i);
}
}

@Override
public Uri insert(Uri uri, ContentValues values) {
SQLiteDatabase db = mOpenHelper.getWritableDatabase();

if (sURIMatcher.match(uri) != SHARES) {
if (D)
Log.d(TAG, "calling insert on an unknown/invalid URI: "
+ uri);
throw new IllegalArgumentException("Unknown/Invalid URI "
+ uri);
}

ContentValues filteredValues = new ContentValues();

copyString(BluetoothShare.URI, values, filteredValues);
copyString(BluetoothShare.FILENAME_HINT, values, filteredValues);
copyString(BluetoothShare.MIMETYPE, values, filteredValues);
copyString(BluetoothShare.DESTINATION, values, filteredValues);

copyInteger(BluetoothShare.VISIBILITY, values, filteredValues);
copyInteger(BluetoothShare.TOTAL_BYTES, values, filteredValues);

if (values.getAsInteger(BluetoothShare.VISIBILITY) == null) {
filteredValues.put(BluetoothShare.VISIBILITY,
BluetoothShare.VISIBILITY_VISIBLE);
}
Integer dir = values.getAsInteger(BluetoothShare.DIRECTION);
Integer con = values
.getAsInteger(BluetoothShare.USER_CONFIRMATION);

if (values.getAsInteger(BluetoothShare.DIRECTION) == null) {
dir = BluetoothShare.DIRECTION_OUTBOUND;
}
if (dir == BluetoothShare.DIRECTION_OUTBOUND && con == null) {
con = BluetoothShare.USER_CONFIRMATION_AUTO_CONFIRMED;
}
if (dir == BluetoothShare.DIRECTION_INBOUND && con == null) {
con = BluetoothShare.USER_CONFIRMATION_PENDING;
}
filteredValues.put(BluetoothShare.USER_CONFIRMATION, con);
filteredValues.put(BluetoothShare.DIRECTION, dir);

filteredValues.put(BluetoothShare.STATUS,
BluetoothShare.STATUS_PENDING);
filteredValues.put(Constants.MEDIA_SCANNED, 0);

Long ts = values.getAsLong(BluetoothShare.TIMESTAMP);
if (ts == null) {
ts = System.currentTimeMillis();
}
filteredValues.put(BluetoothShare.TIMESTAMP, ts);

Context context = getContext();
context.startService(new Intent(context,
BluetoothOppService.class));

long rowID = db.insert(DB_TABLE, null, filteredValues);

Uri ret = null;

if (rowID != -1) {
context.startService(new Intent(context,
BluetoothOppService.class));
ret = Uri.parse(BluetoothShare.CONTENT_URI + "/" + rowID);
context.getContentResolver().notifyChange(uri, null);
} else {
if (D)
Log.d(TAG, "couldn't insert into btopp database");
}

return ret;
}

@Override
public boolean onCreate() {
mOpenHelper = new DatabaseHelper(getContext());
return true;
}

@Override
public Cursor query(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sortOrder) {
SQLiteDatabase db = mOpenHelper.getReadableDatabase();

SQLiteQueryBuilder qb = new SQLiteQueryBuilder();

int match = sURIMatcher.match(uri);
switch (match) {
case SHARES: {
qb.setTables(DB_TABLE);
break;
}
case SHARES_ID: {
qb.setTables(DB_TABLE);
qb.appendWhere(BluetoothShare._ID + "=");
qb.appendWhere(uri.getPathSegments().get(1));
break;
}
case LIVE_FOLDER_RECEIVED_FILES: {
qb.setTables(DB_TABLE);
qb.setProjectionMap(LIVE_FOLDER_PROJECTION_MAP);
qb.appendWhere(BluetoothShare.DIRECTION + "="
+ BluetoothShare.DIRECTION_INBOUND + " AND "
+ BluetoothShare.STATUS + "="
+ BluetoothShare.STATUS_SUCCESS);
sortOrder = "_id DESC, " + sortOrder;
break;
}
default: {
if (D)
Log.d(TAG, "querying unknown URI: " + uri);
throw new IllegalArgumentException("Unknown URI: " + uri);
}
}

if (V) {
java.lang.StringBuilder sb = new java.lang.StringBuilder();
sb.append("starting query, database is ");
if (db != null) {
sb.append("not ");
}
sb.append("null; ");
if (projection == null) {
sb.append("projection is null; ");
} else if (projection.length == 0) {
sb.append("projection is empty; ");
} else {
for (int i = 0; i < projection.length; ++i) {
sb.append("projection[");
sb.append(i);
sb.append("] is ");
sb.append(projection[i]);
sb.append("; ");
}
}
sb.append("selection is ");
sb.append(selection);
sb.append("; ");
if (selectionArgs == null) {
sb.append("selectionArgs is null; ");
} else if (selectionArgs.length == 0) {
sb.append("selectionArgs is empty; ");
} else {
for (int i = 0; i < selectionArgs.length; ++i) {
sb.append("selectionArgs[");
sb.append(i);
sb.append("] is ");
sb.append(selectionArgs[i]);
sb.append("; ");
}
}
sb.append("sort is ");
sb.append(sortOrder);
sb.append(".");
Log.v(TAG, sb.toString());
}

Cursor ret = qb.query(db, projection, selection, selectionArgs,
null, null, sortOrder);

if (ret != null) {
ret.setNotificationUri(getContext().getContentResolver(),
uri);
if (V)
Log.v(TAG, "created cursor " + ret + " on behalf of ");// +
} else {
if (D)
Log.d(TAG, "query failed in downloads database");
}

return ret;
}

@Override
public int update(Uri uri, ContentValues values, String selection,
String[] selectionArgs) {
SQLiteDatabase db = mOpenHelper.getWritableDatabase();

int count;
long rowId = 0;

int match = sURIMatcher.match(uri);
switch (match) {
case SHARES:
case SHARES_ID: {
String myWhere;
if (selection != null) {
if (match == SHARES) {
myWhere = "( " + selection + " )";
} else {
myWhere = "( " + selection + " ) AND ";
}
} else {
myWhere = "";
}
if (match == SHARES_ID) {
String segment = uri.getPathSegments().get(1);
rowId = Long.parseLong(segment);
myWhere += " ( " + BluetoothShare._ID + " = " + rowId
+ " ) ";
}

if (values.size() > 0) {
count = db.update(DB_TABLE, values, myWhere,
selectionArgs);
} else {
count = 0;
}
break;
}
default: {
if (D)
Log.d(TAG, "updating unknown/invalid URI: " + uri);
throw new UnsupportedOperationException(
"Cannot update URI: " + uri);
}
}
getContext().getContentResolver().notifyChange(uri, null);

return count;
}

@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
SQLiteDatabase db = mOpenHelper.getWritableDatabase();
int count;
int match = sURIMatcher.match(uri);
switch (match) {
case SHARES:
case SHARES_ID: {
String myWhere;
if (selection != null) {
if (match == SHARES) {
myWhere = "( " + selection + " )";
} else {
myWhere = "( " + selection + " ) AND ";
}
} else {
myWhere = "";
}
if (match == SHARES_ID) {
String segment = uri.getPathSegments().get(1);
long rowId = Long.parseLong(segment);
myWhere += " ( " + BluetoothShare._ID + " = " + rowId
+ " ) ";
}

count = db.delete(DB_TABLE, myWhere, selectionArgs);
break;
}
default: {
if (D)
Log.d(TAG, "deleting unknown/invalid URI: " + uri);
throw new UnsupportedOperationException(
"Cannot delete URI: " + uri);
}
}
getContext().getContentResolver().notifyChange(uri, null);
return count;
}
}


Related Topic Android: Blutooth Share Manager Constants
Android API Libraries for Developing Applications
Android SDK Emulator, Dalvik, Debug Bridge
Android: Java Class for Bluetooth Application Manager
Java Class for Android Bluetooth Transfer Notification Manager

nScraps.com 2011   Privacy Policy  Terms of Service  Feedback