diff options
Diffstat (limited to 'core/java/android/bluetooth')
17 files changed, 3397 insertions, 0 deletions
diff --git a/core/java/android/bluetooth/AtCommandHandler.java b/core/java/android/bluetooth/AtCommandHandler.java new file mode 100644 index 0000000..8de2133 --- /dev/null +++ b/core/java/android/bluetooth/AtCommandHandler.java @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * 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 android.bluetooth; + +import android.bluetooth.AtCommandResult; + +/** + * Handler Interface for {@link AtParser}.<p> + * @hide + */ +public abstract class AtCommandHandler { + + /** + * Handle Basic commands "ATA".<p> + * These are single letter commands such as ATA and ATD. Anything following + * the single letter command ('A' and 'D' respectively) will be passed as + * 'arg'.<p> + * For example, "ATDT1234" would result in the call + * handleBasicCommand("T1234").<p> + * @param arg Everything following the basic command character. + * @return The result of this command. + */ + public AtCommandResult handleBasicCommand(String arg) { + return new AtCommandResult(AtCommandResult.ERROR); + } + + /** + * Handle Actions command "AT+FOO".<p> + * Action commands are part of the Extended command syntax, and are + * typically used to signal an action on "FOO".<p> + * @return The result of this command. + */ + public AtCommandResult handleActionCommand() { + return new AtCommandResult(AtCommandResult.ERROR); + } + + /** + * Handle Read command "AT+FOO?".<p> + * Read commands are part of the Extended command syntax, and are + * typically used to read the value of "FOO".<p> + * @return The result of this command. + */ + public AtCommandResult handleReadCommand() { + return new AtCommandResult(AtCommandResult.ERROR); + } + + /** + * Handle Set command "AT+FOO=...".<p> + * Set commands are part of the Extended command syntax, and are + * typically used to set the value of "FOO". Multiple arguments can be + * sent.<p> + * AT+FOO=[<arg1>[,<arg2>[,...]]]<p> + * Each argument will be either numeric (Integer) or String. + * handleSetCommand is passed a generic Object[] array in which each + * element will be an Integer (if it can be parsed with parseInt()) or + * String.<p> + * Missing arguments ",," are set to empty Strings.<p> + * @param args Array of String and/or Integer's. There will always be at + * least one element in this array. + * @return The result of this command. + */ + // Typically used to set this paramter + public AtCommandResult handleSetCommand(Object[] args) { + return new AtCommandResult(AtCommandResult.ERROR); + } + + /** + * Handle Test command "AT+FOO=?".<p> + * Test commands are part of the Extended command syntax, and are typically + * used to request an indication of the range of legal values that "FOO" + * can take.<p> + * By defualt we return an OK result, to indicate that this command is at + * least recognized.<p> + * @return The result of this command. + */ + public AtCommandResult handleTestCommand() { + return new AtCommandResult(AtCommandResult.OK); + } +} diff --git a/core/java/android/bluetooth/AtCommandResult.java b/core/java/android/bluetooth/AtCommandResult.java new file mode 100644 index 0000000..638be2d --- /dev/null +++ b/core/java/android/bluetooth/AtCommandResult.java @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * 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 android.bluetooth; + +import java.util.*; + +/** + * The result of execution of an single AT command.<p> + * + * + * This class can represent the final response to an AT command line, and also + * intermediate responses to a single command within a chained AT command + * line.<p> + * + * The actual responses that are intended to be send in reply to the AT command + * line are stored in a string array. The final response is stored as an + * int enum, converted to a string when toString() is called. Only a single + * final response is sent from multiple commands chained into a single command + * line.<p> + * @hide + */ +public class AtCommandResult { + // Result code enumerations + public static final int OK = 0; + public static final int ERROR = 1; + public static final int UNSOLICITED = 2; + + private static final String OK_STRING = "OK"; + private static final String ERROR_STRING = "ERROR"; + + private int mResultCode; // Result code + private StringBuilder mResponse; // Response with CRLF line breaks + + /** + * Construct a new AtCommandResult with given result code, and an empty + * response array. + * @param resultCode One of OK, ERROR or UNSOLICITED. + */ + public AtCommandResult(int resultCode) { + mResultCode = resultCode; + mResponse = new StringBuilder(); + } + + /** + * Construct a new AtCommandResult with result code OK, and the specified + * single line response. + * @param response The single line response. + */ + public AtCommandResult(String response) { + this(OK); + addResponse(response); + } + + public int getResultCode() { + return mResultCode; + } + + /** + * Add another line to the response. + */ + public void addResponse(String response) { + appendWithCrlf(mResponse, response); + } + + /** + * Add the given result into this AtCommandResult object.<p> + * Used to combine results from multiple commands in a single command line + * (command chaining). + * @param result The AtCommandResult to add to this result. + */ + public void addResult(AtCommandResult result) { + if (result != null) { + appendWithCrlf(mResponse, result.mResponse.toString()); + mResultCode = result.mResultCode; + } + } + + /** + * Generate the string response ready to send + */ + public String toString() { + StringBuilder result = new StringBuilder(mResponse.toString()); + switch (mResultCode) { + case OK: + appendWithCrlf(result, OK_STRING); + break; + case ERROR: + appendWithCrlf(result, ERROR_STRING); + break; + } + return result.toString(); + } + + /** Append a string to a string builder, joining with a double + * CRLF. Used to create multi-line AT command replies + */ + public static void appendWithCrlf(StringBuilder str1, String str2) { + if (str1.length() > 0 && str2.length() > 0) { + str1.append("\r\n\r\n"); + } + str1.append(str2); + } +}; diff --git a/core/java/android/bluetooth/AtParser.java b/core/java/android/bluetooth/AtParser.java new file mode 100644 index 0000000..1ea3150 --- /dev/null +++ b/core/java/android/bluetooth/AtParser.java @@ -0,0 +1,370 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * 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 android.bluetooth; + +import android.bluetooth.AtCommandHandler; +import android.bluetooth.AtCommandResult; + +import java.util.*; + +/** + * An AT (Hayes command) Parser based on (a subset of) the ITU-T V.250 standard. + * <p> + * + * Conforment with the subset of V.250 required for implementation of the + * Bluetooth Headset and Handsfree Profiles, as per Bluetooth SIP + * specifications. Also implements some V.250 features not required by + * Bluetooth - such as chained commands.<p> + * + * Command handlers are registered with an AtParser object. These handlers are + * invoked when command lines are processed by AtParser's process() method.<p> + * + * The AtParser object accepts a new command line to parse via its process() + * method. It breaks each command line into one or more commands. Each command + * is parsed for name, type, and (optional) arguments, and an appropriate + * external handler method is called through the AtCommandHandler interface. + * + * The command types are<ul> + * <li>Basic Command. For example "ATDT1234567890". Basic command names are a + * single character (e.g. "D"), and everything following this character is + * passed to the handler as a string argument (e.g. "T1234567890"). + * <li>Action Command. For example "AT+CIMI". The command name is "CIMI", and + * there are no arguments for action commands. + * <li>Read Command. For example "AT+VGM?". The command name is "VGM", and there + * are no arguments for get commands. + * <li>Set Command. For example "AT+VGM=14". The command name is "VGM", and + * there is a single integer argument in this case. In the general case then + * can be zero or more arguments (comma deliminated) each of integer or string + * form. + * <li>Test Command. For example "AT+VGM=?. No arguments. + * </ul> + * + * In V.250 the last four command types are known as Extended Commands, and + * they are used heavily in Bluetooth.<p> + * + * Basic commands cannot be chained in this implementation. For Bluetooth + * headset/handsfree use this is acceptable, because they only use the basic + * commands ATA and ATD, which are not allowed to be chained. For general V.250 + * use we would need to improve this class to allow Basic command chaining - + * however its tricky to get right becuase there is no deliminator for Basic + * command chaining.<p> + * + * Extended commands can be chained. For example:<p> + * AT+VGM?;+VGM=14;+CIMI<p> + * This is equivalent to:<p> + * AT+VGM? + * AT+VGM=14 + * AT+CIMI + * Except that only one final result code is return (although several + * intermediate responses may be returned), and as soon as one command in the + * chain fails the rest are abandonded.<p> + * + * Handlers are registered by there command name via register(Char c, ...) or + * register(String s, ...). Handlers for Basic command should be registered by + * the basic command character, and handlers for Extended commands should be + * registered by String.<p> + * + * Refer to:<ul> + * <li>ITU-T Recommendation V.250 + * <li>ETSI TS 127.007 (AT Comannd set for User Equipment, 3GPP TS 27.007) + * <li>Bluetooth Headset Profile Spec (K6) + * <li>Bluetooth Handsfree Profile Spec (HFP 1.5) + * </ul> + * @hide + */ +public class AtParser { + + // Extended command type enumeration, only used internally + private static final int TYPE_ACTION = 0; // AT+FOO + private static final int TYPE_READ = 1; // AT+FOO? + private static final int TYPE_SET = 2; // AT+FOO= + private static final int TYPE_TEST = 3; // AT+FOO=? + + private HashMap<String, AtCommandHandler> mExtHandlers; + private HashMap<Character, AtCommandHandler> mBasicHandlers; + + private String mLastInput; // for "A/" (repeat last command) support + + /** + * Create a new AtParser.<p> + * No handlers are registered. + */ + public AtParser() { + mBasicHandlers = new HashMap<Character, AtCommandHandler>(); + mExtHandlers = new HashMap<String, AtCommandHandler>(); + mLastInput = ""; + } + + /** + * Register a Basic command handler.<p> + * Basic command handlers are later called via their + * <code>handleBasicCommand(String args)</code> method. + * @param command Command name - a single character + * @param handler Handler to register + */ + public void register(Character command, AtCommandHandler handler) { + mBasicHandlers.put(command, handler); + } + + /** + * Register an Extended command handler.<p> + * Extended command handlers are later called via:<ul> + * <li><code>handleActionCommand()</code> + * <li><code>handleGetCommand()</code> + * <li><code>handleSetCommand()</code> + * <li><code>handleTestCommand()</code> + * </ul> + * Only one method will be called for each command processed. + * @param command Command name - can be multiple characters + * @param handler Handler to register + */ + public void register(String command, AtCommandHandler handler) { + mExtHandlers.put(command, handler); + } + + + /** + * Strip input of whitespace and force Uppercase - except sections inside + * quotes. Also fixes unmatched quotes (by appending a quote). Double + * quotes " are the only quotes allowed by V.250 + */ + static private String clean(String input) { + StringBuilder out = new StringBuilder(input.length()); + + for (int i = 0; i < input.length(); i++) { + char c = input.charAt(i); + if (c == '"') { + int j = input.indexOf('"', i + 1 ); // search for closing " + if (j == -1) { // unmatched ", insert one. + out.append(input.substring(i, input.length())); + out.append('"'); + break; + } + out.append(input.substring(i, j + 1)); + i = j; + } else if (c != ' ') { + out.append(Character.toUpperCase(c)); + } + } + + return out.toString(); + } + + static private boolean isAtoZ(char c) { + return (c >= 'A' && c <= 'Z'); + } + + /** + * Find a character ch, ignoring quoted sections. + * Return input.length() if not found. + */ + static private int findChar(char ch, String input, int fromIndex) { + for (int i = fromIndex; i < input.length(); i++) { + char c = input.charAt(i); + if (c == '"') { + i = input.indexOf('"', i + 1); + if (i == -1) { + return input.length(); + } + } else if (c == ch) { + return i; + } + } + return input.length(); + } + + /** + * Break an argument string into individual arguments (comma deliminated). + * Integer arguments are turned into Integer objects. Otherwise a String + * object is used. + */ + static private Object[] generateArgs(String input) { + int i = 0; + int j; + ArrayList<Object> out = new ArrayList<Object>(); + while (i <= input.length()) { + j = findChar(',', input, i); + + String arg = input.substring(i, j); + try { + out.add(new Integer(arg)); + } catch (NumberFormatException e) { + out.add(arg); + } + + i = j + 1; // move past comma + } + return out.toArray(); + } + + /** + * Return the index of the end of character after the last characeter in + * the extended command name. Uses the V.250 spec for allowed command + * names. + */ + static private int findEndExtendedName(String input, int index) { + for (int i = index; i < input.length(); i++) { + char c = input.charAt(i); + + // V.250 defines the following chars as legal extended command + // names + if (isAtoZ(c)) continue; + if (c >= '0' && c <= '9') continue; + switch (c) { + case '!': + case '%': + case '-': + case '.': + case '/': + case ':': + case '_': + continue; + default: + return i; + } + } + return input.length(); + } + + /** + * Processes an incoming AT command line.<p> + * This method will invoke zero or one command handler methods for each + * command in the command line.<p> + * @param raw_input The AT input, without EOL deliminator (e.g. <CR>). + * @return Result object for this command line. This can be + * converted to a String[] response with toStrings(). + */ + public AtCommandResult process(String raw_input) { + String input = clean(raw_input); + + // Handle "A/" (repeat previous line) + if (input.regionMatches(0, "A/", 0, 2)) { + input = new String(mLastInput); + } else { + mLastInput = new String(input); + } + + // Handle empty line - no response necessary + if (input.equals("")) { + // Return [] + return new AtCommandResult(AtCommandResult.UNSOLICITED); + } + + // Anything else deserves an error + if (!input.regionMatches(0, "AT", 0, 2)) { + // Return ["ERROR"] + return new AtCommandResult(AtCommandResult.ERROR); + } + + // Ok we have a command that starts with AT. Process it + int index = 2; + AtCommandResult result = + new AtCommandResult(AtCommandResult.UNSOLICITED); + while (index < input.length()) { + char c = input.charAt(index); + + if (isAtoZ(c)) { + // Option 1: Basic Command + // Pass the rest of the line as is to the handler. Do not + // look for any more commands on this line. + String args = input.substring(index + 1); + if (mBasicHandlers.containsKey((Character)c)) { + result.addResult(mBasicHandlers.get( + (Character)c).handleBasicCommand(args)); + return result; + } else { + // no handler + result.addResult( + new AtCommandResult(AtCommandResult.ERROR)); + return result; + } + // control never reaches here + } + + if (c == '+') { + // Option 2: Extended Command + // Search for first non-name character. Shortcircuit if we dont + // handle this command name. + int i = findEndExtendedName(input, index + 1); + String commandName = input.substring(index, i); + if (!mExtHandlers.containsKey(commandName)) { + // no handler + result.addResult( + new AtCommandResult(AtCommandResult.ERROR)); + return result; + } + AtCommandHandler handler = mExtHandlers.get(commandName); + + // Search for end of this command - this is usually the end of + // line + int endIndex = findChar(';', input, index); + + // Determine what type of command this is. + // Default to TYPE_ACTION if we can't find anything else + // obvious. + int type; + + if (i >= endIndex) { + type = TYPE_ACTION; + } else if (input.charAt(i) == '?') { + type = TYPE_READ; + } else if (input.charAt(i) == '=') { + if (i + 1 < endIndex) { + if (input.charAt(i + 1) == '?') { + type = TYPE_TEST; + } else { + type = TYPE_SET; + } + } else { + type = TYPE_SET; + } + } else { + type = TYPE_ACTION; + } + + // Call this command. Short-circuit as soon as a command fails + switch (type) { + case TYPE_ACTION: + result.addResult(handler.handleActionCommand()); + break; + case TYPE_READ: + result.addResult(handler.handleReadCommand()); + break; + case TYPE_TEST: + result.addResult(handler.handleTestCommand()); + break; + case TYPE_SET: + Object[] args = + generateArgs(input.substring(i + 1, endIndex)); + result.addResult(handler.handleSetCommand(args)); + break; + } + if (result.getResultCode() != AtCommandResult.OK) { + return result; // short-circuit + } + + index = endIndex; + } else { + // Can't tell if this is a basic or extended command. + // Push forwards and hope we hit something. + index++; + } + } + // Finished processing (and all results were ok) + return result; + } +} diff --git a/core/java/android/bluetooth/BluetoothAudioGateway.java b/core/java/android/bluetooth/BluetoothAudioGateway.java new file mode 100644 index 0000000..f3afd2a --- /dev/null +++ b/core/java/android/bluetooth/BluetoothAudioGateway.java @@ -0,0 +1,190 @@ +package android.bluetooth; + +import java.lang.Thread; + +import android.os.Message; +import android.os.Handler; +import android.util.Log; + +/** + * Listen's for incoming RFCOMM connection for the headset / handsfree service. + * + * This class is planned for deletion, in favor of a generic Rfcomm class. + * + * @hide + */ +public class BluetoothAudioGateway { + private static final String TAG = "BT Audio Gateway"; + private static final boolean DBG = false; + + private int mNativeData; + static { classInitNative(); } + + private BluetoothDevice mBluetooth; + + /* in */ + private int mHandsfreeAgRfcommChannel = -1; + private int mHeadsetAgRfcommChannel = -1; + + /* out */ + private String mConnectingHeadsetAddress; + private int mConnectingHeadsetRfcommChannel; /* -1 when not connected */ + private int mConnectingHeadsetSocketFd; + private String mConnectingHandsfreeAddress; + private int mConnectingHandsfreeRfcommChannel; /* -1 when not connected */ + private int mConnectingHandsfreeSocketFd; + private int mTimeoutRemainingMs; /* in/out */ + + public static final int DEFAULT_HF_AG_CHANNEL = 10; + public static final int DEFAULT_HS_AG_CHANNEL = 11; + + public BluetoothAudioGateway(BluetoothDevice bluetooth) { + this(bluetooth, DEFAULT_HF_AG_CHANNEL, DEFAULT_HS_AG_CHANNEL); + } + + public BluetoothAudioGateway(BluetoothDevice bluetooth, + int handsfreeAgRfcommChannel, + int headsetAgRfcommChannel) { + mBluetooth = bluetooth; + mHandsfreeAgRfcommChannel = handsfreeAgRfcommChannel; + mHeadsetAgRfcommChannel = headsetAgRfcommChannel; + initializeNativeDataNative(); + } + + private Thread mConnectThead; + private volatile boolean mInterrupted; + private static final int SELECT_WAIT_TIMEOUT = 1000; + + private Handler mCallback; + + public class IncomingConnectionInfo { + IncomingConnectionInfo(BluetoothDevice bluetooth, String address, int socketFd, + int rfcommChan) { + mBluetooth = bluetooth; + mAddress = address; + mSocketFd = socketFd; + mRfcommChan = rfcommChan; + } + + public BluetoothDevice mBluetooth; + public String mAddress; + public int mSocketFd; + public int mRfcommChan; + } + + public static final int MSG_INCOMING_HEADSET_CONNECTION = 100; + public static final int MSG_INCOMING_HANDSFREE_CONNECTION = 101; + + public synchronized boolean start(Handler callback) { + + if (mConnectThead == null) { + mCallback = callback; + mConnectThead = new Thread(TAG) { + public void run() { + if (DBG) log("Connect Thread starting"); + while (!mInterrupted) { + //Log.i(TAG, "waiting for connect"); + mConnectingHeadsetRfcommChannel = -1; + mConnectingHandsfreeRfcommChannel = -1; + if (waitForHandsfreeConnectNative(SELECT_WAIT_TIMEOUT) == false) { + if (mTimeoutRemainingMs > 0) { + try { + Log.i(TAG, "select thread timed out, but " + + mTimeoutRemainingMs + "ms of waiting remain."); + Thread.sleep(mTimeoutRemainingMs); + } catch (InterruptedException e) { + Log.i(TAG, "select thread was interrupted (2), exiting"); + mInterrupted = true; + } + } + } + else { + Log.i(TAG, "connect notification!"); + /* A device connected (most likely just one, but + it is possible for two separate devices, one + a headset and one a handsfree, to connect + simultaneously. + */ + if (mConnectingHeadsetRfcommChannel >= 0) { + Log.i(TAG, "Incoming connection from headset " + + mConnectingHeadsetAddress + " on channel " + + mConnectingHeadsetRfcommChannel); + Message msg = Message.obtain(mCallback); + msg.what = MSG_INCOMING_HEADSET_CONNECTION; + msg.obj = + new IncomingConnectionInfo( + mBluetooth, + mConnectingHeadsetAddress, + mConnectingHeadsetSocketFd, + mConnectingHeadsetRfcommChannel); + msg.sendToTarget(); + } + if (mConnectingHandsfreeRfcommChannel >= 0) { + Log.i(TAG, "Incoming connection from handsfree " + + mConnectingHandsfreeAddress + " on channel " + + mConnectingHandsfreeRfcommChannel); + Message msg = Message.obtain(); + msg.setTarget(mCallback); + msg.what = MSG_INCOMING_HANDSFREE_CONNECTION; + msg.obj = + new IncomingConnectionInfo( + mBluetooth, + mConnectingHandsfreeAddress, + mConnectingHandsfreeSocketFd, + mConnectingHandsfreeRfcommChannel); + msg.sendToTarget(); + } + } + } + if (DBG) log("Connect Thread finished"); + } + }; + + if (setUpListeningSocketsNative() == false) { + Log.e(TAG, "Could not set up listening socket, exiting"); + return false; + } + + mInterrupted = false; + mConnectThead.start(); + } + + return true; + } + + public synchronized void stop() { + if (mConnectThead != null) { + if (DBG) log("stopping Connect Thread"); + mInterrupted = true; + try { + mConnectThead.interrupt(); + if (DBG) log("waiting for thread to terminate"); + mConnectThead.join(); + mConnectThead = null; + mCallback = null; + tearDownListeningSocketsNative(); + } catch (InterruptedException e) { + Log.w(TAG, "Interrupted waiting for Connect Thread to join"); + } + } + } + + protected void finalize() throws Throwable { + try { + cleanupNativeDataNative(); + } finally { + super.finalize(); + } + } + + private static native void classInitNative(); + private native void initializeNativeDataNative(); + private native void cleanupNativeDataNative(); + private native boolean waitForHandsfreeConnectNative(int timeoutMs); + private native boolean setUpListeningSocketsNative(); + private native void tearDownListeningSocketsNative(); + + private static void log(String msg) { + Log.d(TAG, msg); + } +} diff --git a/core/java/android/bluetooth/BluetoothDevice.java b/core/java/android/bluetooth/BluetoothDevice.java new file mode 100644 index 0000000..0b24db6 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothDevice.java @@ -0,0 +1,601 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * 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 android.bluetooth; + +import android.os.RemoteException; +import android.util.Log; + +import java.io.UnsupportedEncodingException; + +/** + * The Android Bluetooth API is not finalized, and *will* change. Use at your + * own risk. + * + * Manages the local Bluetooth device. Scan for devices, create bondings, + * power up and down the adapter. + * + * @hide + */ +public class BluetoothDevice { + public static final int MODE_UNKNOWN = -1; + public static final int MODE_OFF = 0; + public static final int MODE_CONNECTABLE = 1; + public static final int MODE_DISCOVERABLE = 2; + + public static final int RESULT_FAILURE = -1; + public static final int RESULT_SUCCESS = 0; + + private static final String TAG = "BluetoothDevice"; + + private final IBluetoothDevice mService; + /** + * @hide - hide this because it takes a parameter of type + * IBluetoothDevice, which is a System private class. + * Also note that Context.getSystemService is a factory that + * returns a BlueToothDevice. That is the right way to get + * a BluetoothDevice. + */ + public BluetoothDevice(IBluetoothDevice service) { + mService = service; + } + + /** + * Get the current status of Bluetooth hardware. + * + * @return true if Bluetooth enabled, false otherwise. + */ + public boolean isEnabled() { + try { + return mService.isEnabled(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * Enable the Bluetooth device. + * Turn on the underlying hardware. + * This is an asynchronous call, BluetoothIntent.ENABLED_ACTION will be + * sent if and when the device is successfully enabled. + * @return false if we cannot enable the Bluetooth device. True does not + * imply the device was enabled, it only implies that so far there were no + * problems. + */ + public boolean enable() { + return enable(null); + } + + /** + * Enable the Bluetooth device. + * Turns on the underlying hardware. + * This is an asynchronous call. onEnableResult() of your callback will be + * called when the call is complete, with either RESULT_SUCCESS or + * RESULT_FAILURE. + * + * Your callback will be called from a binder thread, not the main thread. + * + * In addition to the callback, BluetoothIntent.ENABLED_ACTION will be + * broadcast if the device is successfully enabled. + * + * @param callback Your callback, null is ok. + * @return true if your callback was successfully registered, or false if + * there was an error, implying your callback will never be called. + */ + public boolean enable(IBluetoothDeviceCallback callback) { + try { + return mService.enable(callback); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * Disable the Bluetooth device. + * This turns off the underlying hardware. + * + * @return true if successful, false otherwise. + */ + public boolean disable() { + try { + return mService.disable(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + public String getAddress() { + try { + return mService.getAddress(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + /** + * Get the friendly Bluetooth name of this device. + * + * This name is visible to remote Bluetooth devices. Currently it is only + * possible to retrieve the Bluetooth name when Bluetooth is enabled. + * + * @return the Bluetooth name, or null if there was a problem. + */ + public String getName() { + try { + return mService.getName(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + /** + * Set the friendly Bluetooth name of this device. + * + * This name is visible to remote Bluetooth devices. The Bluetooth Service + * is responsible for persisting this name. + * + * @param name the name to set + * @return true, if the name was successfully set. False otherwise. + */ + public boolean setName(String name) { + try { + return mService.setName(name); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + public String getMajorClass() { + try { + return mService.getMajorClass(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getMinorClass() { + try { + return mService.getMinorClass(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getVersion() { + try { + return mService.getVersion(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getRevision() { + try { + return mService.getRevision(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getManufacturer() { + try { + return mService.getManufacturer(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getCompany() { + try { + return mService.getCompany(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + public int getMode() { + try { + return mService.getMode(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return MODE_UNKNOWN; + } + public void setMode(int mode) { + try { + mService.setMode(mode); + } catch (RemoteException e) {Log.e(TAG, "", e);} + } + + public int getDiscoverableTimeout() { + try { + return mService.getDiscoverableTimeout(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return -1; + } + public void setDiscoverableTimeout(int timeout) { + try { + mService.setDiscoverableTimeout(timeout); + } catch (RemoteException e) {Log.e(TAG, "", e);} + } + + public boolean startDiscovery() { + return startDiscovery(true); + } + public boolean startDiscovery(boolean resolveNames) { + try { + return mService.startDiscovery(resolveNames); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + public void cancelDiscovery() { + try { + mService.cancelDiscovery(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + } + + public boolean isDiscovering() { + try { + return mService.isDiscovering(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + public boolean startPeriodicDiscovery() { + try { + return mService.startPeriodicDiscovery(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + public boolean stopPeriodicDiscovery() { + try { + return mService.stopPeriodicDiscovery(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + public boolean isPeriodicDiscovery() { + try { + return mService.isPeriodicDiscovery(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + public String[] listRemoteDevices() { + try { + return mService.listRemoteDevices(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + /** + * List remote devices that have a low level (ACL) connection. + * + * RFCOMM, SDP and L2CAP are all built on ACL connections. Devices can have + * an ACL connection even when not paired - this is common for SDP queries + * or for in-progress pairing requests. + * + * In most cases you probably want to test if a higher level protocol is + * connected, rather than testing ACL connections. + * + * @return bluetooth hardware addresses of remote devices with a current + * ACL connection. Array size is 0 if no devices have a + * connection. Null on error. + */ + public String[] listAclConnections() { + try { + return mService.listAclConnections(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + /** + * Check if a specified remote device has a low level (ACL) connection. + * + * RFCOMM, SDP and L2CAP are all built on ACL connections. Devices can have + * an ACL connection even when not paired - this is common for SDP queries + * or for in-progress pairing requests. + * + * In most cases you probably want to test if a higher level protocol is + * connected, rather than testing ACL connections. + * + * @param address the Bluetooth hardware address you want to check. + * @return true if there is an ACL connection, false otherwise and on + * error. + */ + public boolean isAclConnected(String address) { + try { + return mService.isAclConnected(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * Perform a low level (ACL) disconnection of a remote device. + * + * This forcably disconnects the ACL layer connection to a remote device, + * which will cause all RFCOMM, SDP and L2CAP connections to this remote + * device to close. + * + * @param address the Bluetooth hardware address you want to disconnect. + * @return true if the device was disconnected, false otherwise and on + * error. + */ + public boolean disconnectRemoteDeviceAcl(String address) { + try { + return mService.disconnectRemoteDeviceAcl(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * Create a bonding with a remote bluetooth device. + * + * This is an asynchronous call. BluetoothIntent.BONDING_CREATED_ACTION + * will be broadcast if and when the remote device is successfully bonded. + * + * @param address the remote device Bluetooth address. + * @return false if we cannot create a bonding to that device, true if + * there were no problems beginning the bonding process. + */ + public boolean createBonding(String address) { + return createBonding(address, null); + } + + /** + * Create a bonding with a remote bluetooth device. + * + * This is an asynchronous call. onCreateBondingResult() of your callback + * will be called when the call is complete, with either RESULT_SUCCESS or + * RESULT_FAILURE. + * + * In addition to the callback, BluetoothIntent.BONDING_CREATED_ACTION will + * be broadcast if the remote device is successfully bonded. + * + * @param address The remote device Bluetooth address. + * @param callback Your callback, null is ok. + * @return true if your callback was successfully registered, or false if + * there was an error, implying your callback will never be called. + */ + public boolean createBonding(String address, IBluetoothDeviceCallback callback) { + try { + return mService.createBonding(address, callback); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + public boolean cancelBondingProcess(String address) { + try { + return mService.cancelBondingProcess(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * List remote devices that are bonded (paired) to the local device. + * + * Bonding (pairing) is the process by which the user enters a pin code for + * the device, which generates a shared link key, allowing for + * authentication and encryption of future connections. In Android we + * require bonding before RFCOMM or SCO connections can be made to a remote + * device. + * + * This function lists which remote devices we have a link key for. It does + * not cause any RF transmission, and does not check if the remote device + * still has it's link key with us. If the other side no longer has its + * link key then the RFCOMM or SCO connection attempt will result in an + * error. + * + * This function does not check if the remote device is in range. + * + * @return bluetooth hardware addresses of remote devices that are + * bonded. Array size is 0 if no devices are bonded. Null on error. + */ + public String[] listBondings() { + try { + return mService.listBondings(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + /** + * Check if a remote device is bonded (paired) to the local device. + * + * Bonding (pairing) is the process by which the user enters a pin code for + * the device, which generates a shared link key, allowing for + * authentication and encryption of future connections. In Android we + * require bonding before RFCOMM or SCO connections can be made to a remote + * device. + * + * This function checks if we have a link key with the remote device. It + * does not cause any RF transmission, and does not check if the remote + * device still has it's link key with us. If the other side no longer has + * a link key then the RFCOMM or SCO connection attempt will result in an + * error. + * + * This function does not check if the remote device is in range. + * + * @param address Bluetooth hardware address of the remote device to check. + * @return true if bonded, false otherwise and on error. + */ + public boolean hasBonding(String address) { + try { + return mService.hasBonding(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + public boolean removeBonding(String address) { + try { + return mService.removeBonding(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + public String getRemoteName(String address) { + try { + return mService.getRemoteName(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + public String getRemoteAlias(String address) { + try { + return mService.getRemoteAlias(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public boolean setRemoteAlias(String address, String alias) { + try { + return mService.setRemoteAlias(address, alias); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + public boolean clearRemoteAlias(String address) { + try { + return mService.clearRemoteAlias(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + public String getRemoteVersion(String address) { + try { + return mService.getRemoteVersion(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getRemoteRevision(String address) { + try { + return mService.getRemoteRevision(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getRemoteManufacturer(String address) { + try { + return mService.getRemoteManufacturer(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getRemoteCompany(String address) { + try { + return mService.getRemoteCompany(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getRemoteMajorClass(String address) { + try { + return mService.getRemoteMajorClass(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String getRemoteMinorClass(String address) { + try { + return mService.getRemoteMinorClass(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String[] getRemoteServiceClasses(String address) { + try { + return mService.getRemoteServiceClasses(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + /** + * Returns the RFCOMM channel associated with the 16-byte UUID on + * the remote Bluetooth address. + * + * Performs a SDP ServiceSearchAttributeRequest transaction. The provided + * uuid is verified in the returned record. If there was a problem, or the + * specified uuid does not exist, -1 is returned. + */ + public boolean getRemoteServiceChannel(String address, short uuid16, + IBluetoothDeviceCallback callback) { + try { + return mService.getRemoteServiceChannel(address, uuid16, callback); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + public int getRemoteClass(String address) { + try { + return mService.getRemoteClass(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return DeviceClass.CLASS_UNKNOWN; + } + public byte[] getRemoteFeatures(String address) { + try { + return mService.getRemoteFeatures(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String lastSeen(String address) { + try { + return mService.lastSeen(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + public String lastUsed(String address) { + try { + return mService.lastUsed(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + public boolean setPin(String address, byte[] pin) { + try { + return mService.setPin(address, pin); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + public boolean cancelPin(String address) { + try { + return mService.cancelPin(address); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * Check that a pin is valid and convert to byte array. + * + * Bluetooth pin's are 1 to 16 bytes of UTF8 characters. + * @param pin pin as java String + * @return the pin code as a UTF8 byte array, or null if it is an invalid + * Bluetooth pin. + */ + public static byte[] convertPinToBytes(String pin) { + if (pin == null) { + return null; + } + byte[] pinBytes; + try { + pinBytes = pin.getBytes("UTF8"); + } catch (UnsupportedEncodingException uee) { + Log.e(TAG, "UTF8 not supported?!?"); // this should not happen + return null; + } + if (pinBytes.length <= 0 || pinBytes.length > 16) { + return null; + } + return pinBytes; + } + + + /* Sanity check a bluetooth address, such as "00:43:A8:23:10:F0" */ + private static final int ADDRESS_LENGTH = 17; + public static boolean checkBluetoothAddress(String address) { + if (address == null || address.length() != ADDRESS_LENGTH) { + return false; + } + for (int i = 0; i < ADDRESS_LENGTH; i++) { + char c = address.charAt(i); + switch (i % 3) { + case 0: + case 1: + if (Character.digit(c, 16) != -1) { + break; // hex character, OK + } + return false; + case 2: + if (c == ':') { + break; // OK + } + return false; + } + } + return true; + } +} diff --git a/core/java/android/bluetooth/BluetoothHeadset.java b/core/java/android/bluetooth/BluetoothHeadset.java new file mode 100644 index 0000000..90db39b --- /dev/null +++ b/core/java/android/bluetooth/BluetoothHeadset.java @@ -0,0 +1,198 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * 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 android.bluetooth; + +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.os.RemoteException; +import android.os.IBinder; +import android.util.Log; + +/** + * The Android Bluetooth API is not finalized, and *will* change. Use at your + * own risk. + * + * Public API for controlling the Bluetooth Headset Service. + * + * BluetoothHeadset is a proxy object for controlling the Bluetooth Headset + * Service. + * + * Creating a BluetoothHeadset object will create a binding with the + * BluetoothHeadset service. Users of this object should call close() when they + * are finished with the BluetoothHeadset, so that this proxy object can unbind + * from the service. + * + * BlueoothHeadset objects are not guarenteed to be connected to the + * BluetoothHeadsetService at all times. Calls on this object while not + * connected to the service will result in default error return values. Even + * after object construction, there is a short delay (~10ms) before this proxy + * object is actually connected to the Service. + * + * Android only supports one connected Bluetooth Headset at a time. + * + * Note that in this context, Headset includes both Bluetooth Headset's and + * Handsfree devices. + * + * @hide + */ +public class BluetoothHeadset { + + private final static String TAG = "BluetoothHeadset"; + + private final Context mContext; + private IBluetoothHeadset mService; + + /** There was an error trying to obtain the state */ + public static final int STATE_ERROR = -1; + /** No headset currently connected */ + public static final int STATE_DISCONNECTED = 0; + /** Connection attempt in progress */ + public static final int STATE_CONNECTING = 1; + /** A headset is currently connected */ + public static final int STATE_CONNECTED = 2; + + public static final int RESULT_FAILURE = 0; + public static final int RESULT_SUCCESS = 1; + /** Connection cancelled before completetion. */ + public static final int RESULT_CANCELLED = 2; + + private ServiceConnection mConnection = new ServiceConnection() { + public void onServiceConnected(ComponentName className, IBinder service) { + mService = IBluetoothHeadset.Stub.asInterface(service); + Log.i(TAG, "Proxy object is now connected to Bluetooth Headset Service"); + } + public void onServiceDisconnected(ComponentName className) { + mService = null; + } + }; + + /** + * Create a BluetoothHeadset proxy object. + * Remeber to call close() when you are done with this object, so that it + * can unbind from the BluetoothHeadsetService. + */ + public BluetoothHeadset(Context context) { + mContext = context; + if (!context.bindService( + new Intent(IBluetoothHeadset.class.getName()), mConnection, 0)) { + Log.e(TAG, "Could not bind to Bluetooth Headset Service"); + } + } + + protected void finalize() throws Throwable { + try { + close(); + } finally { + super.finalize(); + } + } + + /** + * Close the connection to the backing service. + * Other public functions of BluetoothHeadset will return default error + * results once close() has been called. Multiple invocations of close() + * are ok. + */ + public synchronized void close() { + if (mConnection != null) { + mContext.unbindService(mConnection); + mConnection = null; + } + } + + /** + * Get the current state of the Bluetooth Headset service. + * @return One of the STATE_ return codes, or STATE_ERROR if this proxy + * object is currently not connected to the Headset service. + */ + public int getState() { + if (mService != null) { + try { + return mService.getState(); + } catch (RemoteException e) {Log.e(TAG, e.toString());} + } + return BluetoothHeadset.STATE_ERROR; + } + + /** + * Get the Bluetooth address of the current headset. + * @return The Bluetooth address, or null if not in connected or connecting + * state, or if this proxy object is not connected to the Headset + * service. + */ + public String getHeadsetAddress() { + if (mService != null) { + try { + return mService.getHeadsetAddress(); + } catch (RemoteException e) {Log.e(TAG, e.toString());} + } + return null; + } + + /** + * Request to initiate a connection to a headset. + * This call does not block. Fails if a headset is already connecting + * or connected. + * Will connect to the last connected headset if address is null. + * @param address The Bluetooth Address to connect to, or null to connect + * to the last connected headset. + * @param callback A callback with onCreateBondingResult() defined, or + * null. + * @return False if there was a problem initiating the connection + * procedure, and your callback will not be used. True if + * the connection procedure was initiated, in which case + * your callback is guarenteed to be called. + */ + public boolean connectHeadset(String address, IBluetoothHeadsetCallback callback) { + if (mService != null) { + try { + return mService.connectHeadset(address, callback); + } catch (RemoteException e) {Log.e(TAG, e.toString());} + } + return false; + } + + /** + * Returns true if the specified headset is connected (does not include + * connecting). Returns false if not connected, or if this proxy object + * if not currently connected to the headset service. + */ + public boolean isConnected(String address) { + if (mService != null) { + try { + return mService.isConnected(address); + } catch (RemoteException e) {Log.e(TAG, e.toString());} + } + return false; + } + + /** + * Disconnects the current headset. Currently this call blocks, it may soon + * be made asynchornous. Returns false if this proxy object is + * not currently connected to the Headset service. + */ + public boolean disconnectHeadset() { + if (mService != null) { + try { + mService.disconnectHeadset(); + } catch (RemoteException e) {Log.e(TAG, e.toString());} + } + return false; + } +} diff --git a/core/java/android/bluetooth/BluetoothIntent.java b/core/java/android/bluetooth/BluetoothIntent.java new file mode 100644 index 0000000..8e22791 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothIntent.java @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * 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 android.bluetooth; + +import android.annotation.SdkConstant; +import android.annotation.SdkConstant.SdkConstantType; + +/** + * The Android Bluetooth API is not finalized, and *will* change. Use at your + * own risk. + * + * Manages the local Bluetooth device. Scan for devices, create bondings, + * power up and down the adapter. + * + * @hide + */ +public interface BluetoothIntent { + public static final String MODE = + "android.bluetooth.intent.MODE"; + public static final String ADDRESS = + "android.bluetooth.intent.ADDRESS"; + public static final String NAME = + "android.bluetooth.intent.NAME"; + public static final String ALIAS = + "android.bluetooth.intent.ALIAS"; + public static final String RSSI = + "android.bluetooth.intent.RSSI"; + public static final String CLASS = + "android.bluetooth.intent.CLASS"; + public static final String HEADSET_STATE = + "android.bluetooth.intent.HEADSET_STATE"; + public static final String HEADSET_PREVIOUS_STATE = + "android.bluetooth.intent.HEADSET_PREVIOUS_STATE"; + + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String ENABLED_ACTION = + "android.bluetooth.intent.action.ENABLED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String DISABLED_ACTION = + "android.bluetooth.intent.action.DISABLED"; + + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String NAME_CHANGED_ACTION = + "android.bluetooth.intent.action.NAME_CHANGED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String MODE_CHANGED_ACTION = + "android.bluetooth.intent.action.MODE_CHANGED"; + + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String DISCOVERY_STARTED_ACTION = + "android.bluetooth.intent.action.DISCOVERY_STARTED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String DISCOVERY_COMPLETED_ACTION = + "android.bluetooth.intent.action.DISCOVERY_COMPLETED"; + + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String PAIRING_REQUEST_ACTION = + "android.bluetooth.intent.action.PAIRING_REQUEST"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String PAIRING_CANCEL_ACTION = + "android.bluetooth.intent.action.PAIRING_CANCEL"; + + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_DEVICE_FOUND_ACTION = + "android.bluetooth.intent.action.REMOTE_DEVICE_FOUND"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_DEVICE_DISAPPEARED_ACTION = + "android.bluetooth.intent.action.REMOTE_DEVICE_DISAPPEARED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_DEVICE_CLASS_UPDATED_ACTION = + "android.bluetooth.intent.action.REMOTE_DEVICE_DISAPPEARED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_DEVICE_CONNECTED_ACTION = + "android.bluetooth.intent.action.REMOTE_DEVICE_CONNECTED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_DEVICE_DISCONNECT_REQUESTED_ACTION = + "android.bluetooth.intent.action.REMOTE_DEVICE_DISCONNECT_REQUESTED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_DEVICE_DISCONNECTED_ACTION = + "android.bluetooth.intent.action.REMOTE_DEVICE_DISCONNECTED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_NAME_UPDATED_ACTION = + "android.bluetooth.intent.action.REMOTE_NAME_UPDATED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_NAME_FAILED_ACTION = + "android.bluetooth.intent.action.REMOTE_NAME_FAILED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_ALIAS_CHANGED_ACTION = + "android.bluetooth.intent.action.REMOTE_ALIAS_CHANGED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String REMOTE_ALIAS_CLEARED_ACTION = + "android.bluetooth.intent.action.REMOTE_ALIAS_CLEARED"; + + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String BONDING_CREATED_ACTION = + "android.bluetooth.intent.action.BONDING_CREATED"; + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String BONDING_REMOVED_ACTION = + "android.bluetooth.intent.action.BONDING_REMOVED"; + + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String HEADSET_STATE_CHANGED_ACTION = + "android.bluetooth.intent.action.HEADSET_STATE_CHANGED"; +} diff --git a/core/java/android/bluetooth/Database.java b/core/java/android/bluetooth/Database.java new file mode 100644 index 0000000..fef641a --- /dev/null +++ b/core/java/android/bluetooth/Database.java @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * 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 android.bluetooth; + +import android.bluetooth.RfcommSocket; + +import android.util.Log; + +import java.io.*; +import java.util.*; + +/** + * The Android Bluetooth API is not finalized, and *will* change. Use at your + * own risk. + * + * A low-level API to the Service Discovery Protocol (SDP) Database. + * + * Allows service records to be added to the local SDP database. Once added, + * these services will be advertised to remote devices when they make SDP + * queries on this device. + * + * Currently this API is a thin wrapper to the bluez SDP Database API. See: + * http://wiki.bluez.org/wiki/Database + * http://wiki.bluez.org/wiki/HOWTO/ManagingServiceRecords + * @hide + */ +public final class Database { + private static Database mInstance; + + private static final String sLogName = "android.bluetooth.Database"; + + /** + * Class load time initialization + */ + static { + classInitNative(); + } + private native static void classInitNative(); + + /** + * Private to enforce singleton property + */ + private Database() { + initializeNativeDataNative(); + } + private native void initializeNativeDataNative(); + + protected void finalize() throws Throwable { + try { + cleanupNativeDataNative(); + } finally { + super.finalize(); + } + } + private native void cleanupNativeDataNative(); + + /** + * Singelton accessor + * @return The singleton instance of Database + */ + public static synchronized Database getInstance() { + if (mInstance == null) { + mInstance = new Database(); + } + return mInstance; + } + + /** + * Advertise a service with an RfcommSocket. + * + * This adds the service the SDP Database with the following attributes + * set: Service Name, Protocol Descriptor List, Service Class ID List + * TODO: Construct a byte[] record directly, rather than via XML. + * @param socket The rfcomm socket to advertise (by channel). + * @param serviceName A short name for this service + * @param uuid + * Unique identifier for this service, by which clients + * can search for your service + * @return Handle to the new service record + */ + public int advertiseRfcommService(RfcommSocket socket, + String serviceName, + UUID uuid) throws IOException { + String xmlRecord = + "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + + "<record>\n" + + " <attribute id=\"0x0001\">\n" + // ServiceClassIDList + " <sequence>\n" + + " <uuid value=\"" + + uuid.toString() + // UUID for this service + "\"/>\n" + + " </sequence>\n" + + " </attribute>\n" + + " <attribute id=\"0x0004\">\n" + // ProtocolDescriptorList + " <sequence>\n" + + " <sequence>\n" + + " <uuid value=\"0x0100\"/>\n" + // L2CAP + " </sequence>\n" + + " <sequence>\n" + + " <uuid value=\"0x0003\"/>\n" + // RFCOMM + " <uint8 value=\"" + + socket.getPort() + // RFCOMM port + "\" name=\"channel\"/>\n" + + " </sequence>\n" + + " </sequence>\n" + + " </attribute>\n" + + " <attribute id=\"0x0100\">\n" + // ServiceName + " <text value=\"" + serviceName + "\"/>\n" + + " </attribute>\n" + + "</record>\n"; + Log.i(sLogName, xmlRecord); + return addServiceRecordFromXml(xmlRecord); + } + + + /** + * Add a new service record. + * @param record The byte[] record + * @return A handle to the new record + */ + public synchronized int addServiceRecord(byte[] record) throws IOException { + int handle = addServiceRecordNative(record); + Log.i(sLogName, "Added SDP record: " + Integer.toHexString(handle)); + return handle; + } + private native int addServiceRecordNative(byte[] record) + throws IOException; + + /** + * Add a new service record, using XML. + * @param record The record as an XML string + * @return A handle to the new record + */ + public synchronized int addServiceRecordFromXml(String record) throws IOException { + int handle = addServiceRecordFromXmlNative(record); + Log.i(sLogName, "Added SDP record: " + Integer.toHexString(handle)); + return handle; + } + private native int addServiceRecordFromXmlNative(String record) + throws IOException; + + /** + * Update an exisiting service record. + * @param handle Handle to exisiting record + * @param record The updated byte[] record + */ + public synchronized void updateServiceRecord(int handle, byte[] record) { + try { + updateServiceRecordNative(handle, record); + } catch (IOException e) { + Log.e(getClass().toString(), e.getMessage()); + } + } + private native void updateServiceRecordNative(int handle, byte[] record) + throws IOException; + + /** + * Update an exisiting record, using XML. + * @param handle Handle to exisiting record + * @param record The record as an XML string. + */ + public synchronized void updateServiceRecordFromXml(int handle, String record) { + try { + updateServiceRecordFromXmlNative(handle, record); + } catch (IOException e) { + Log.e(getClass().toString(), e.getMessage()); + } + } + private native void updateServiceRecordFromXmlNative(int handle, String record) + throws IOException; + + /** + * Remove a service record. + * It is only possible to remove service records that were added by the + * current connection. + * @param handle Handle to exisiting record to be removed + */ + public synchronized void removeServiceRecord(int handle) { + try { + removeServiceRecordNative(handle); + } catch (IOException e) { + Log.e(getClass().toString(), e.getMessage()); + } + } + private native void removeServiceRecordNative(int handle) throws IOException; +} diff --git a/core/java/android/bluetooth/DeviceClass.java b/core/java/android/bluetooth/DeviceClass.java new file mode 100644 index 0000000..36035ca --- /dev/null +++ b/core/java/android/bluetooth/DeviceClass.java @@ -0,0 +1,131 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * 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 android.bluetooth; + +/** + * The Android Bluetooth API is not finalized, and *will* change. Use at your + * own risk. + * + * Static helper methods and constants to decode the device class bit vector + * returned by the Bluetooth API. + * + * The Android Bluetooth API returns a 32-bit integer to represent the device + * class. This is actually a bit vector, the format defined at + * http://www.bluetooth.org/Technical/AssignedNumbers/baseband.htm + * (login required). This class provides static helper methods and constants to + * determine what Service Class(es), Major Class, and Minor Class are encoded + * in a 32-bit device class. + * + * Each of the helper methods takes the 32-bit integer device class as an + * argument. + * + * @hide + */ +public class DeviceClass { + + // Baseband class information + // See http://www.bluetooth.org/Technical/AssignedNumbers/baseband.htm + + public static final int SERVICE_CLASS_BITMASK = 0xFFE000; + public static final int SERVICE_CLASS_LIMITED_DISCOVERABILITY = 0x002000; + public static final int SERVICE_CLASS_POSITIONING = 0x010000; + public static final int SERVICE_CLASS_NETWORKING = 0x020000; + public static final int SERVICE_CLASS_RENDER = 0x040000; + public static final int SERVICE_CLASS_CAPTURE = 0x080000; + public static final int SERVICE_CLASS_OBJECT_TRANSFER = 0x100000; + public static final int SERVICE_CLASS_AUDIO = 0x200000; + public static final int SERVICE_CLASS_TELEPHONY = 0x400000; + public static final int SERVICE_CLASS_INFORMATION = 0x800000; + + public static final int MAJOR_CLASS_BITMASK = 0x001F00; + public static final int MAJOR_CLASS_MISC = 0x000000; + public static final int MAJOR_CLASS_COMPUTER = 0x000100; + public static final int MAJOR_CLASS_PHONE = 0x000200; + public static final int MAJOR_CLASS_NETWORKING = 0x000300; + public static final int MAJOR_CLASS_AUDIO_VIDEO = 0x000400; + public static final int MAJOR_CLASS_PERIPHERAL = 0x000500; + public static final int MAJOR_CLASS_IMAGING = 0x000600; + public static final int MAJOR_CLASS_WEARABLE = 0x000700; + public static final int MAJOR_CLASS_TOY = 0x000800; + public static final int MAJOR_CLASS_MEDICAL = 0x000900; + public static final int MAJOR_CLASS_UNCATEGORIZED = 0x001F00; + + // Minor classes for the AUDIO_VIDEO major class + public static final int MINOR_CLASS_AUDIO_VIDEO_BITMASK = 0x0000FC; + public static final int MINOR_CLASS_AUDIO_VIDEO_UNCATEGORIZED = 0x000000; + public static final int MINOR_CLASS_AUDIO_VIDEO_HEADSET = 0x000004; + public static final int MINOR_CLASS_AUDIO_VIDEO_HANDSFREE = 0x000008; + public static final int MINOR_CLASS_AUDIO_VIDEO_MICROPHONE = 0x000010; + public static final int MINOR_CLASS_AUDIO_VIDEO_LOUDSPEAKER = 0x000014; + public static final int MINOR_CLASS_AUDIO_VIDEO_HEADPHONES = 0x000018; + public static final int MINOR_CLASS_AUDIO_VIDEO_PORTABLE_AUDIO = 0x00001C; + public static final int MINOR_CLASS_AUDIO_VIDEO_CAR_AUDIO = 0x000020; + public static final int MINOR_CLASS_AUDIO_VIDEO_SET_TOP_BOX = 0x000024; + public static final int MINOR_CLASS_AUDIO_VIDEO_HIFI_AUDIO = 0x000028; + public static final int MINOR_CLASS_AUDIO_VIDEO_VCR = 0x00002C; + public static final int MINOR_CLASS_AUDIO_VIDEO_VIDEO_CAMERA = 0x000030; + public static final int MINOR_CLASS_AUDIO_VIDEO_CAMCORDER = 0x000034; + public static final int MINOR_CLASS_AUDIO_VIDEO_VIDEO_MONITOR = 0x000038; + public static final int MINOR_CLASS_AUDIO_VIDEO_VIDEO_DISPLAY_AND_LOUDSPEAKER = 0x00003C; + public static final int MINOR_CLASS_AUDIO_VIDEO_VIDEO_CONFERENCING = 0x000040; + public static final int MINOR_CLASS_AUDIO_VIDEO_VIDEO_GAMING_TOY = 0x000048; + + // Indicates the Bluetooth API could not retrieve the class + public static final int CLASS_UNKNOWN = 0xFF000000; + + /** Returns true if the given device class supports the given Service Class. + * A bluetooth device can claim to support zero or more service classes. + * @param deviceClass The bluetooth device class. + * @param serviceClassType The service class constant to test for. For + * example, DeviceClass.SERVICE_CLASS_AUDIO. This + * must be one of the SERVICE_CLASS_xxx constants, + * results of this function are undefined + * otherwise. + * @return If the deviceClass claims to support the serviceClassType. + */ + public static boolean hasServiceClass(int deviceClass, int serviceClassType) { + if (deviceClass == CLASS_UNKNOWN) { + return false; + } + return ((deviceClass & SERVICE_CLASS_BITMASK & serviceClassType) != 0); + } + + /** Returns the Major Class of a bluetooth device class. + * Values returned from this function can be compared with the constants + * MAJOR_CLASS_xxx. A bluetooth device can only be associated + * with one major class. + */ + public static int getMajorClass(int deviceClass) { + if (deviceClass == CLASS_UNKNOWN) { + return CLASS_UNKNOWN; + } + return (deviceClass & MAJOR_CLASS_BITMASK); + } + + /** Returns the Minor Class of a bluetooth device class. + * Values returned from this function can be compared with the constants + * MINOR_CLASS_xxx_yyy, where xxx is the Major Class. A bluetooth + * device can only be associated with one minor class within its major + * class. + */ + public static int getMinorClass(int deviceClass) { + if (deviceClass == CLASS_UNKNOWN) { + return CLASS_UNKNOWN; + } + return (deviceClass & MINOR_CLASS_AUDIO_VIDEO_BITMASK); + } +} diff --git a/core/java/android/bluetooth/HeadsetBase.java b/core/java/android/bluetooth/HeadsetBase.java new file mode 100644 index 0000000..bce3388 --- /dev/null +++ b/core/java/android/bluetooth/HeadsetBase.java @@ -0,0 +1,310 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * 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 android.bluetooth; + +import android.os.Handler; +import android.os.PowerManager; +import android.os.PowerManager.WakeLock; +import android.util.Log; + +import java.io.IOException; +import java.lang.Thread; + +/** + * The Android Bluetooth API is not finalized, and *will* change. Use at your + * own risk. + * + * The base RFCOMM (service) connection for a headset or handsfree device. + * + * In the future this class will be removed. + * + * @hide + */ +public class HeadsetBase { + private static final String TAG = "Bluetooth HeadsetBase"; + private static final boolean DBG = false; + + public static final int RFCOMM_DISCONNECTED = 1; + + public static final int DIRECTION_INCOMING = 1; + public static final int DIRECTION_OUTGOING = 2; + + private final BluetoothDevice mBluetooth; + private final String mAddress; + private final int mRfcommChannel; + private int mNativeData; + private Thread mEventThread; + private volatile boolean mEventThreadInterrupted; + private Handler mEventThreadHandler; + private int mTimeoutRemainingMs; + private final int mDirection; + private final long mConnectTimestamp; + + protected AtParser mAtParser; + + private WakeLock mWakeLock; // held while processing an AT command + + private native static void classInitNative(); + static { + classInitNative(); + } + + protected void finalize() throws Throwable { + try { + cleanupNativeDataNative(); + releaseWakeLock(); + } finally { + super.finalize(); + } + } + + private native void cleanupNativeDataNative(); + + public HeadsetBase(PowerManager pm, BluetoothDevice bluetooth, String address, + int rfcommChannel) { + mDirection = DIRECTION_OUTGOING; + mConnectTimestamp = System.currentTimeMillis(); + mBluetooth = bluetooth; + mAddress = address; + mRfcommChannel = rfcommChannel; + mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "HeadsetBase"); + mWakeLock.setReferenceCounted(false); + initializeAtParser(); + // Must be called after this.mAddress is set. + initializeNativeDataNative(-1); + } + + /* Create from an already exisiting rfcomm connection */ + public HeadsetBase(PowerManager pm, BluetoothDevice bluetooth, String address, int socketFd, + int rfcommChannel, Handler handler) { + mDirection = DIRECTION_INCOMING; + mConnectTimestamp = System.currentTimeMillis(); + mBluetooth = bluetooth; + mAddress = address; + mRfcommChannel = rfcommChannel; + mEventThreadHandler = handler; + mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "HeadsetBase"); + mWakeLock.setReferenceCounted(false); + initializeAtParser(); + // Must be called after this.mAddress is set. + initializeNativeDataNative(socketFd); + } + + private native void initializeNativeDataNative(int socketFd); + + /* Process an incoming AT command line + */ + protected synchronized void handleInput(String input) { + acquireWakeLock(); + long timestamp; + + if (DBG) timestamp = System.currentTimeMillis(); + AtCommandResult result = mAtParser.process(input); + if (DBG) Log.d(TAG, "Processing " + input + " took " + + (System.currentTimeMillis() - timestamp) + " ms"); + + if (result.getResultCode() == AtCommandResult.ERROR) { + Log.i(TAG, "Error pocessing <" + input + ">"); + } + + sendURC(result.toString()); + + releaseWakeLock(); + } + + /** + * Register AT commands that are common to all Headset / Handsets. This + * function is called by the HeadsetBase constructor. + */ + protected void initializeAtParser() { + mAtParser = new AtParser(); + + // Microphone Gain + mAtParser.register("+VGM", new AtCommandHandler() { + @Override + public AtCommandResult handleSetCommand(Object[] args) { + // AT+VGM=<gain> in range [0,15] + // Headset/Handsfree is reporting its current gain setting + //TODO: sync to android UI + //TODO: Send unsolicited +VGM when volume changed on AG + return new AtCommandResult(AtCommandResult.OK); + } + }); + + // Speaker Gain + mAtParser.register("+VGS", new AtCommandHandler() { + @Override + public AtCommandResult handleSetCommand(Object[] args) { + // AT+VGS=<gain> in range [0,15] + // Headset/Handsfree is reporting its current gain to Android + //TODO: sync to AG UI + //TODO: Send unsolicited +VGS when volume changed on AG + return new AtCommandResult(AtCommandResult.OK); + } + }); + } + + public AtParser getAtParser() { + return mAtParser; + } + + public void startEventThread() { + mEventThread = + new Thread("HeadsetBase Event Thread") { + public void run() { + int last_read_error; + while (!mEventThreadInterrupted) { + String input = readNative(500); + if (input != null) { + handleInput(input); + } + else { + last_read_error = getLastReadStatusNative(); + if (last_read_error != 0) { + Log.i(TAG, "headset read error " + last_read_error); + if (mEventThreadHandler != null) { + mEventThreadHandler.obtainMessage(RFCOMM_DISCONNECTED) + .sendToTarget(); + } + disconnectNative(); + break; + } + } + } + } + }; + mEventThreadInterrupted = false; + mEventThread.start(); + } + + + + private native String readNative(int timeout_ms); + private native int getLastReadStatusNative(); + + private void stopEventThread() { + mEventThreadInterrupted = true; + mEventThread.interrupt(); + try { + mEventThread.join(); + } catch (java.lang.InterruptedException e) { + // FIXME: handle this, + } + mEventThread = null; + } + + public boolean connect(Handler handler) { + if (mEventThread == null) { + if (!connectNative()) return false; + mEventThreadHandler = handler; + } + return true; + } + private native boolean connectNative(); + + /* + * Returns true when either the asynchronous connect is in progress, or + * the connect is complete. Call waitForAsyncConnect() to find out whether + * the connect is actually complete, or disconnect() to cancel. + */ + + public boolean connectAsync() { + return connectAsyncNative(); + } + private native boolean connectAsyncNative(); + + public int getRemainingAsyncConnectWaitingTimeMs() { + return mTimeoutRemainingMs; + } + + /* + * Returns 1 when an async connect is complete, 0 on timeout, and -1 on + * error. On error, handler will be called, and you need to re-initiate + * the async connect. + */ + public int waitForAsyncConnect(int timeout_ms, Handler handler) { + int res = waitForAsyncConnectNative(timeout_ms); + if (res > 0) { + mEventThreadHandler = handler; + } + return res; + } + private native int waitForAsyncConnectNative(int timeout_ms); + + public void disconnect() { + if (mEventThread != null) { + stopEventThread(); + } + disconnectNative(); + } + private native void disconnectNative(); + + + /* + * Note that if a remote side disconnects, this method will still return + * true until disconnect() is called. You know when a remote side + * disconnects because you will receive the intent + * IBluetoothService.REMOTE_DEVICE_DISCONNECTED_ACTION. If, when you get + * this intent, method isConnected() returns true, you know that the + * disconnect was initiated by the remote device. + */ + + public boolean isConnected() { + return mEventThread != null; + } + + public String getAddress() { + return mAddress; + } + + public String getName() { + return mBluetooth.getRemoteName(mAddress); + } + + public int getDirection() { + return mDirection; + } + + public long getConnectTimestamp() { + return mConnectTimestamp; + } + + public synchronized boolean sendURC(String urc) { + if (urc.length() > 0) { + boolean ret = sendURCNative(urc); + return ret; + } + return true; + } + private native boolean sendURCNative(String urc); + + private void acquireWakeLock() { + if (!mWakeLock.isHeld()) { + mWakeLock.acquire(); + } + } + + private void releaseWakeLock() { + if (mWakeLock.isHeld()) { + mWakeLock.release(); + } + } + + private void log(String msg) { + Log.d(TAG, msg); + } +} diff --git a/core/java/android/bluetooth/IBluetoothDevice.aidl b/core/java/android/bluetooth/IBluetoothDevice.aidl new file mode 100644 index 0000000..e7cc8ed --- /dev/null +++ b/core/java/android/bluetooth/IBluetoothDevice.aidl @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2008, The Android Open Source Project + * + * 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 android.bluetooth; + +import android.bluetooth.IBluetoothDeviceCallback; + +/** + * System private API for talking with the Bluetooth service. + * + * {@hide} + */ +interface IBluetoothDevice +{ + boolean isEnabled(); + boolean enable(in IBluetoothDeviceCallback callback); // async + boolean disable(); + + String getAddress(); + String getName(); + boolean setName(in String name); + String getMajorClass(); + String getMinorClass(); + String getVersion(); + String getRevision(); + String getManufacturer(); + String getCompany(); + + int getMode(); + boolean setMode(int mode); + + int getDiscoverableTimeout(); + boolean setDiscoverableTimeout(int timeout); + + boolean startDiscovery(boolean resolveNames); + boolean cancelDiscovery(); + boolean isDiscovering(); + boolean startPeriodicDiscovery(); + boolean stopPeriodicDiscovery(); + boolean isPeriodicDiscovery(); + String[] listRemoteDevices(); + + String[] listAclConnections(); + boolean isAclConnected(in String address); + boolean disconnectRemoteDeviceAcl(in String address); + + boolean createBonding(in String address, in IBluetoothDeviceCallback callback); + boolean cancelBondingProcess(in String address); + String[] listBondings(); + boolean hasBonding(in String address); + boolean removeBonding(in String address); + + String getRemoteName(in String address); + String getRemoteAlias(in String address); + boolean setRemoteAlias(in String address, in String alias); + boolean clearRemoteAlias(in String address); + String getRemoteVersion(in String address); + String getRemoteRevision(in String address); + int getRemoteClass(in String address); + String getRemoteManufacturer(in String address); + String getRemoteCompany(in String address); + String getRemoteMajorClass(in String address); + String getRemoteMinorClass(in String address); + String[] getRemoteServiceClasses(in String address); + boolean getRemoteServiceChannel(in String address, int uuid16, in IBluetoothDeviceCallback callback); + byte[] getRemoteFeatures(in String adddress); + String lastSeen(in String address); + String lastUsed(in String address); + + boolean setPin(in String address, in byte[] pin); + boolean cancelPin(in String address); +} diff --git a/core/java/android/bluetooth/IBluetoothDeviceCallback.aidl b/core/java/android/bluetooth/IBluetoothDeviceCallback.aidl new file mode 100644 index 0000000..86f44dd --- /dev/null +++ b/core/java/android/bluetooth/IBluetoothDeviceCallback.aidl @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2008, The Android Open Source Project + * + * 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 android.bluetooth; + +/** + * {@hide} + */ +oneway interface IBluetoothDeviceCallback +{ + void onCreateBondingResult(in String address, int result); + void onGetRemoteServiceChannelResult(in String address, int channel); + + void onEnableResult(int result); +} diff --git a/core/java/android/bluetooth/IBluetoothHeadset.aidl b/core/java/android/bluetooth/IBluetoothHeadset.aidl new file mode 100644 index 0000000..7b6030b --- /dev/null +++ b/core/java/android/bluetooth/IBluetoothHeadset.aidl @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * 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 android.bluetooth; + +import android.bluetooth.IBluetoothHeadsetCallback; + +/** + * System private API for Bluetooth Headset service + * + * {@hide} + */ +interface IBluetoothHeadset { + int getState(); + + String getHeadsetAddress(); + + // Request that the given headset be connected + // Assumes the given headset is already bonded + // Will disconnect any currently connected headset + // returns false if cannot start a connection (for example, there is + // already a pending connect). callback will always be called iff this + // returns true + boolean connectHeadset(in String address, in IBluetoothHeadsetCallback callback); + + boolean isConnected(in String address); + + void disconnectHeadset(); +} diff --git a/core/java/android/bluetooth/IBluetoothHeadsetCallback.aidl b/core/java/android/bluetooth/IBluetoothHeadsetCallback.aidl new file mode 100644 index 0000000..03e884b --- /dev/null +++ b/core/java/android/bluetooth/IBluetoothHeadsetCallback.aidl @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2008, The Android Open Source Project + * + * 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 android.bluetooth; + +/** + * {@hide} + */ +oneway interface IBluetoothHeadsetCallback +{ + void onConnectHeadsetResult(in String address, int resultCode); +} diff --git a/core/java/android/bluetooth/RfcommSocket.java b/core/java/android/bluetooth/RfcommSocket.java new file mode 100644 index 0000000..a33263f --- /dev/null +++ b/core/java/android/bluetooth/RfcommSocket.java @@ -0,0 +1,674 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * 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 android.bluetooth; + +import java.io.IOException; +import java.io.FileOutputStream; +import java.io.FileInputStream; +import java.io.OutputStream; +import java.io.InputStream; +import java.io.FileDescriptor; + +/** + * The Android Bluetooth API is not finalized, and *will* change. Use at your + * own risk. + * + * This class implements an API to the Bluetooth RFCOMM layer. An RFCOMM socket + * is similar to a normal socket in that it takes an address and a port number. + * The difference is of course that the address is a Bluetooth-device address, + * and the port number is an RFCOMM channel. The API allows for the + * establishment of listening sockets via methods + * {@link #bind(String, int) bind}, {@link #listen(int) listen}, and + * {@link #accept(RfcommSocket, int) accept}, as well as for the making of + * outgoing connections with {@link #connect(String, int) connect}, + * {@link #connectAsync(String, int) connectAsync}, and + * {@link #waitForAsyncConnect(int) waitForAsyncConnect}. + * + * After constructing a socket, you need to {@link #create() create} it and then + * {@link #destroy() destroy} it when you are done using it. Both + * {@link #create() create} and {@link #accept(RfcommSocket, int) accept} return + * a {@link java.io.FileDescriptor FileDescriptor} for the actual data. + * Alternatively, you may call {@link #getInputStream() getInputStream} and + * {@link #getOutputStream() getOutputStream} to retrieve the respective streams + * without going through the FileDescriptor. + * + * @hide + */ +public class RfcommSocket { + + /** + * Used by the native implementation of the class. + */ + private int mNativeData; + + /** + * Used by the native implementation of the class. + */ + private int mPort; + + /** + * Used by the native implementation of the class. + */ + private String mAddress; + + /** + * We save the return value of {@link #create() create} and + * {@link #accept(RfcommSocket,int) accept} in this variable, and use it to + * retrieve the I/O streams. + */ + private FileDescriptor mFd; + + /** + * After a call to {@link #waitForAsyncConnect(int) waitForAsyncConnect}, + * if the return value is zero, then, the the remaining time left to wait is + * written into this variable (by the native implementation). It is possible + * that {@link #waitForAsyncConnect(int) waitForAsyncConnect} returns before + * the user-specified timeout expires, which is why we save the remaining + * time in this member variable for the user to retrieve by calling method + * {@link #getRemainingAsyncConnectWaitingTimeMs() getRemainingAsyncConnectWaitingTimeMs}. + */ + private int mTimeoutRemainingMs; + + /** + * Set to true when an asynchronous (nonblocking) connect is in progress. + * {@see #connectAsync(String,int)}. + */ + private boolean mIsConnecting; + + /** + * Set to true after a successful call to {@link #bind(String,int) bind} and + * used for error checking in {@link #listen(int) listen}. Reset to false + * on {@link #destroy() destroy}. + */ + private boolean mIsBound = false; + + /** + * Set to true after a successful call to {@link #listen(int) listen} and + * used for error checking in {@link #accept(RfcommSocket,int) accept}. + * Reset to false on {@link #destroy() destroy}. + */ + private boolean mIsListening = false; + + /** + * Used to store the remaining time after an accept with a non-negative + * timeout returns unsuccessfully. It is possible that a blocking + * {@link #accept(int) accept} may wait for less than the time specified by + * the user, which is why we store the remainder in this member variable for + * it to be retrieved with method + * {@link #getRemainingAcceptWaitingTimeMs() getRemainingAcceptWaitingTimeMs}. + */ + private int mAcceptTimeoutRemainingMs; + + /** + * Maintained by {@link #getInputStream() getInputStream}. + */ + protected FileInputStream mInputStream; + + /** + * Maintained by {@link #getOutputStream() getOutputStream}. + */ + protected FileOutputStream mOutputStream; + + private native void initializeNativeDataNative(); + + /** + * Constructor. + */ + public RfcommSocket() { + initializeNativeDataNative(); + } + + private native void cleanupNativeDataNative(); + + /** + * Called by the GC to clean up the native data that we set up when we + * construct the object. + */ + protected void finalize() throws Throwable { + try { + cleanupNativeDataNative(); + } finally { + super.finalize(); + } + } + + private native static void classInitNative(); + + static { + classInitNative(); + } + + /** + * Creates a socket. You need to call this method before performing any + * other operation on a socket. + * + * @return FileDescriptor for the data stream. + * @throws IOException + * @see #destroy() + */ + public FileDescriptor create() throws IOException { + if (mFd == null) { + mFd = createNative(); + } + if (mFd == null) { + throw new IOException("socket not created"); + } + return mFd; + } + + private native FileDescriptor createNative(); + + /** + * Destroys a socket created by {@link #create() create}. Call this + * function when you no longer use the socket in order to release the + * underlying OS resources. + * + * @see #create() + */ + public void destroy() { + synchronized (this) { + destroyNative(); + mFd = null; + mIsBound = false; + mIsListening = false; + } + } + + private native void destroyNative(); + + /** + * Returns the {@link java.io.FileDescriptor FileDescriptor} of the socket. + * + * @return the FileDescriptor + * @throws IOException + * when the socket has not been {@link #create() created}. + */ + public FileDescriptor getFileDescriptor() throws IOException { + if (mFd == null) { + throw new IOException("socket not created"); + } + return mFd; + } + + /** + * Retrieves the input stream from the socket. Alternatively, you can do + * that from the FileDescriptor returned by {@link #create() create} or + * {@link #accept(RfcommSocket, int) accept}. + * + * @return InputStream + * @throws IOException + * if you have not called {@link #create() create} on the + * socket. + */ + public InputStream getInputStream() throws IOException { + if (mFd == null) { + throw new IOException("socket not created"); + } + + synchronized (this) { + if (mInputStream == null) { + mInputStream = new FileInputStream(mFd); + } + + return mInputStream; + } + } + + /** + * Retrieves the output stream from the socket. Alternatively, you can do + * that from the FileDescriptor returned by {@link #create() create} or + * {@link #accept(RfcommSocket, int) accept}. + * + * @return OutputStream + * @throws IOException + * if you have not called {@link #create() create} on the + * socket. + */ + public OutputStream getOutputStream() throws IOException { + if (mFd == null) { + throw new IOException("socket not created"); + } + + synchronized (this) { + if (mOutputStream == null) { + mOutputStream = new FileOutputStream(mFd); + } + + return mOutputStream; + } + } + + /** + * Starts a blocking connect to a remote RFCOMM socket. It takes the address + * of a device and the RFCOMM channel (port) to which to connect. + * + * @param address + * is the Bluetooth address of the remote device. + * @param port + * is the RFCOMM channel + * @return true on success, false on failure + * @throws IOException + * if {@link #create() create} has not been called. + * @see #connectAsync(String, int) + */ + public boolean connect(String address, int port) throws IOException { + synchronized (this) { + if (mFd == null) { + throw new IOException("socket not created"); + } + return connectNative(address, port); + } + } + + private native boolean connectNative(String address, int port); + + /** + * Starts an asynchronous (nonblocking) connect to a remote RFCOMM socket. + * It takes the address of the device to connect to, as well as the RFCOMM + * channel (port). On successful return (return value is true), you need to + * call method {@link #waitForAsyncConnect(int) waitForAsyncConnect} to + * block for up to a specified number of milliseconds while waiting for the + * asyncronous connect to complete. + * + * @param address + * of remote device + * @param port + * the RFCOMM channel + * @return true when the asynchronous connect has successfully started, + * false if there was an error. + * @throws IOException + * is you have not called {@link #create() create} + * @see #waitForAsyncConnect(int) + * @see #getRemainingAsyncConnectWaitingTimeMs() + * @see #connect(String, int) + */ + public boolean connectAsync(String address, int port) throws IOException { + synchronized (this) { + if (mFd == null) { + throw new IOException("socket not created"); + } + mIsConnecting = connectAsyncNative(address, port); + return mIsConnecting; + } + } + + private native boolean connectAsyncNative(String address, int port); + + /** + * Interrupts an asynchronous connect in progress. This method does nothing + * when there is no asynchronous connect in progress. + * + * @throws IOException + * if you have not called {@link #create() create}. + * @see #connectAsync(String, int) + */ + public void interruptAsyncConnect() throws IOException { + synchronized (this) { + if (mFd == null) { + throw new IOException("socket not created"); + } + if (mIsConnecting) { + mIsConnecting = !interruptAsyncConnectNative(); + } + } + } + + private native boolean interruptAsyncConnectNative(); + + /** + * Tells you whether there is an asynchronous connect in progress. This + * method returns an undefined value when there is a synchronous connect in + * progress. + * + * @return true if there is an asyc connect in progress, false otherwise + * @see #connectAsync(String, int) + */ + public boolean isConnecting() { + return mIsConnecting; + } + + /** + * Blocks for a specified amount of milliseconds while waiting for an + * asynchronous connect to complete. Returns an integer value to indicate + * one of the following: the connect succeeded, the connect is still in + * progress, or the connect failed. It is possible for this method to block + * for less than the time specified by the user, and still return zero + * (i.e., async connect is still in progress.) For this reason, if the + * return value is zero, you need to call method + * {@link #getRemainingAsyncConnectWaitingTimeMs() getRemainingAsyncConnectWaitingTimeMs} + * to retrieve the remaining time. + * + * @param timeoutMs + * the time to block while waiting for the async connect to + * complete. + * @return a positive value if the connect succeeds; zero, if the connect is + * still in progress, and a negative value if the connect failed. + * + * @throws IOException + * @see #getRemainingAsyncConnectWaitingTimeMs() + * @see #connectAsync(String, int) + */ + public int waitForAsyncConnect(int timeoutMs) throws IOException { + synchronized (this) { + if (mFd == null) { + throw new IOException("socket not created"); + } + int ret = waitForAsyncConnectNative(timeoutMs); + if (ret != 0) { + mIsConnecting = false; + } + return ret; + } + } + + private native int waitForAsyncConnectNative(int timeoutMs); + + /** + * Returns the number of milliseconds left to wait after the last call to + * {@link #waitForAsyncConnect(int) waitForAsyncConnect}. + * + * It is possible that waitForAsyncConnect() waits for less than the time + * specified by the user, and still returns zero (i.e., async connect is + * still in progress.) For this reason, if the return value is zero, you + * need to call this method to retrieve the remaining time before you call + * waitForAsyncConnect again. + * + * @return the remaining timeout in milliseconds. + * @see #waitForAsyncConnect(int) + * @see #connectAsync(String, int) + */ + public int getRemainingAsyncConnectWaitingTimeMs() { + return mTimeoutRemainingMs; + } + + /** + * Shuts down both directions on a socket. + * + * @return true on success, false on failure; if the return value is false, + * the socket might be left in a patially shut-down state (i.e. one + * direction is shut down, but the other is still open.) In this + * case, you should {@link #destroy() destroy} and then + * {@link #create() create} the socket again. + * @throws IOException + * is you have not caled {@link #create() create}. + * @see #shutdownInput() + * @see #shutdownOutput() + */ + public boolean shutdown() throws IOException { + synchronized (this) { + if (mFd == null) { + throw new IOException("socket not created"); + } + if (shutdownNative(true)) { + return shutdownNative(false); + } + + return false; + } + } + + /** + * Shuts down the input stream of the socket, but leaves the output stream + * in its current state. + * + * @return true on success, false on failure + * @throws IOException + * is you have not called {@link #create() create} + * @see #shutdown() + * @see #shutdownOutput() + */ + public boolean shutdownInput() throws IOException { + synchronized (this) { + if (mFd == null) { + throw new IOException("socket not created"); + } + return shutdownNative(true); + } + } + + /** + * Shut down the output stream of the socket, but leaves the input stream in + * its current state. + * + * @return true on success, false on failure + * @throws IOException + * is you have not called {@link #create() create} + * @see #shutdown() + * @see #shutdownInput() + */ + public boolean shutdownOutput() throws IOException { + synchronized (this) { + if (mFd == null) { + throw new IOException("socket not created"); + } + return shutdownNative(false); + } + } + + private native boolean shutdownNative(boolean shutdownInput); + + /** + * Tells you whether a socket is connected to another socket. This could be + * for input or output or both. + * + * @return true if connected, false otherwise. + * @see #isInputConnected() + * @see #isOutputConnected() + */ + public boolean isConnected() { + return isConnectedNative() > 0; + } + + /** + * Determines whether input is connected (i.e., whether you can receive data + * on this socket.) + * + * @return true if input is connected, false otherwise. + * @see #isConnected() + * @see #isOutputConnected() + */ + public boolean isInputConnected() { + return (isConnectedNative() & 1) != 0; + } + + /** + * Determines whether output is connected (i.e., whether you can send data + * on this socket.) + * + * @return true if output is connected, false otherwise. + * @see #isConnected() + * @see #isInputConnected() + */ + public boolean isOutputConnected() { + return (isConnectedNative() & 2) != 0; + } + + private native int isConnectedNative(); + + /** + * Binds a listening socket to the local device, or a non-listening socket + * to a remote device. The port is automatically selected as the first + * available port in the range 12 to 30. + * + * NOTE: Currently we ignore the device parameter and always bind the socket + * to the local device, assuming that it is a listening socket. + * + * TODO: Use bind(0) in native code to have the kernel select an unused + * port. + * + * @param device + * Bluetooth address of device to bind to (currently ignored). + * @return true on success, false on failure + * @throws IOException + * if you have not called {@link #create() create} + * @see #listen(int) + * @see #accept(RfcommSocket,int) + */ + public boolean bind(String device) throws IOException { + if (mFd == null) { + throw new IOException("socket not created"); + } + for (int port = 12; port <= 30; port++) { + if (bindNative(device, port)) { + mIsBound = true; + return true; + } + } + mIsBound = false; + return false; + } + + /** + * Binds a listening socket to the local device, or a non-listening socket + * to a remote device. + * + * NOTE: Currently we ignore the device parameter and always bind the socket + * to the local device, assuming that it is a listening socket. + * + * @param device + * Bluetooth address of device to bind to (currently ignored). + * @param port + * RFCOMM channel to bind socket to. + * @return true on success, false on failure + * @throws IOException + * if you have not called {@link #create() create} + * @see #listen(int) + * @see #accept(RfcommSocket,int) + */ + public boolean bind(String device, int port) throws IOException { + if (mFd == null) { + throw new IOException("socket not created"); + } + mIsBound = bindNative(device, port); + return mIsBound; + } + + private native boolean bindNative(String device, int port); + + /** + * Starts listening for incoming connections on this socket, after it has + * been bound to an address and RFCOMM channel with + * {@link #bind(String,int) bind}. + * + * @param backlog + * the number of pending incoming connections to queue for + * {@link #accept(RfcommSocket, int) accept}. + * @return true on success, false on failure + * @throws IOException + * if you have not called {@link #create() create} or if the + * socket has not been bound to a device and RFCOMM channel. + */ + public boolean listen(int backlog) throws IOException { + if (mFd == null) { + throw new IOException("socket not created"); + } + if (!mIsBound) { + throw new IOException("socket not bound"); + } + mIsListening = listenNative(backlog); + return mIsListening; + } + + private native boolean listenNative(int backlog); + + /** + * Accepts incoming-connection requests for a listening socket bound to an + * RFCOMM channel. The user may provide a time to wait for an incoming + * connection. + * + * Note that this method may return null (i.e., no incoming connection) + * before the user-specified timeout expires. For this reason, on a null + * return value, you need to call + * {@link #getRemainingAcceptWaitingTimeMs() getRemainingAcceptWaitingTimeMs} + * in order to see how much time is left to wait, before you call this + * method again. + * + * @param newSock + * is set to the new socket that is created as a result of a + * successful accept. + * @param timeoutMs + * time (in milliseconds) to block while waiting to an + * incoming-connection request. A negative value is an infinite + * wait. + * @return FileDescriptor of newSock on success, null on failure. Failure + * occurs if the timeout expires without a successful connect. + * @throws IOException + * if the socket has not been {@link #create() create}ed, is + * not bound, or is not a listening socket. + * @see #bind(String, int) + * @see #listen(int) + * @see #getRemainingAcceptWaitingTimeMs() + */ + public FileDescriptor accept(RfcommSocket newSock, int timeoutMs) + throws IOException { + synchronized (newSock) { + if (mFd == null) { + throw new IOException("socket not created"); + } + if (mIsListening == false) { + throw new IOException("not listening on socket"); + } + newSock.mFd = acceptNative(newSock, timeoutMs); + return newSock.mFd; + } + } + + /** + * Returns the number of milliseconds left to wait after the last call to + * {@link #accept(RfcommSocket, int) accept}. + * + * Since accept() may return null (i.e., no incoming connection) before the + * user-specified timeout expires, you need to call this method in order to + * see how much time is left to wait, and wait for that amount of time + * before you call accept again. + * + * @return the remaining time, in milliseconds. + */ + public int getRemainingAcceptWaitingTimeMs() { + return mAcceptTimeoutRemainingMs; + } + + private native FileDescriptor acceptNative(RfcommSocket newSock, + int timeoutMs); + + /** + * Get the port (rfcomm channel) associated with this socket. + * + * This is only valid if the port has been set via a successful call to + * {@link #bind(String, int)}, {@link #connect(String, int)} + * or {@link #connectAsync(String, int)}. This can be checked + * with {@link #isListening()} and {@link #isConnected()}. + * @return Port (rfcomm channel) + */ + public int getPort() throws IOException { + if (mFd == null) { + throw new IOException("socket not created"); + } + if (!mIsListening && !isConnected()) { + throw new IOException("not listening or connected on socket"); + } + return mPort; + } + + /** + * Return true if this socket is listening ({@link #listen(int)} + * has been called successfully). + */ + public boolean isListening() { + return mIsListening; + } +} diff --git a/core/java/android/bluetooth/ScoSocket.java b/core/java/android/bluetooth/ScoSocket.java new file mode 100644 index 0000000..75b3329 --- /dev/null +++ b/core/java/android/bluetooth/ScoSocket.java @@ -0,0 +1,201 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * 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 android.bluetooth; + +import android.content.Context; +import android.os.Handler; +import android.os.Message; +import android.os.PowerManager; +import android.os.PowerManager.WakeLock; +import android.util.Log; + +import java.io.IOException; +import java.lang.Thread; + + +/** + * The Android Bluetooth API is not finalized, and *will* change. Use at your + * own risk. + * + * Simple SCO Socket. + * Currently in Android, there is no support for sending data over a SCO + * socket - this is managed by the hardware link to the Bluetooth Chip. This + * class is instead intended for management of the SCO socket lifetime, + * and is tailored for use with the headset / handsfree profiles. + * @hide + */ +public class ScoSocket { + private static final String TAG = "ScoSocket"; + private static final boolean DBG = true; + private static final boolean VDBG = false; // even more logging + + public static final int STATE_READY = 1; // Ready for use. No threads or sockets + public static final int STATE_ACCEPT = 2; // accept() thread running + public static final int STATE_CONNECTING = 3; // connect() thread running + public static final int STATE_CONNECTED = 4; // connected, waiting for close() + public static final int STATE_CLOSED = 5; // was connected, now closed. + + private int mState; + private int mNativeData; + private Handler mHandler; + private int mAcceptedCode; + private int mConnectedCode; + private int mClosedCode; + + private WakeLock mWakeLock; // held while STATE_CONNECTING or STATE_CONNECTED + + static { + classInitNative(); + } + private native static void classInitNative(); + + public ScoSocket(PowerManager pm, Handler handler, int acceptedCode, int connectedCode, + int closedCode) { + initNative(); + mState = STATE_READY; + mHandler = handler; + mAcceptedCode = acceptedCode; + mConnectedCode = connectedCode; + mClosedCode = closedCode; + mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ScoSocket"); + mWakeLock.setReferenceCounted(false); + if (VDBG) log(this + " SCO OBJECT CTOR"); + } + private native void initNative(); + + protected void finalize() throws Throwable { + try { + if (VDBG) log(this + " SCO OBJECT DTOR"); + destroyNative(); + releaseWakeLock(); + } finally { + super.finalize(); + } + } + private native void destroyNative(); + + /** Connect this SCO socket to the given BT address. + * Does not block. + */ + public synchronized boolean connect(String address) { + if (VDBG) log("connect() " + this); + if (mState != STATE_READY) { + if (DBG) log("connect(): Bad state"); + return false; + } + acquireWakeLock(); + if (connectNative(address)) { + mState = STATE_CONNECTING; + return true; + } else { + mState = STATE_CLOSED; + releaseWakeLock(); + return false; + } + } + private native boolean connectNative(String address); + + /** Accept incoming SCO connections. + * Does not block. + */ + public synchronized boolean accept() { + if (VDBG) log("accept() " + this); + if (mState != STATE_READY) { + if (DBG) log("Bad state"); + return false; + } + if (acceptNative()) { + mState = STATE_ACCEPT; + return true; + } else { + mState = STATE_CLOSED; + return false; + } + } + private native boolean acceptNative(); + + public synchronized void close() { + if (DBG) log(this + " SCO OBJECT close() mState = " + mState); + mState = STATE_CLOSED; + closeNative(); + releaseWakeLock(); + } + private native void closeNative(); + + public synchronized int getState() { + return mState; + } + + private synchronized void onConnected(int result) { + if (VDBG) log(this + " onConnected() mState = " + mState + " " + this); + if (mState != STATE_CONNECTING) { + if (DBG) log("Strange state, closing " + mState + " " + this); + return; + } + if (result >= 0) { + mState = STATE_CONNECTED; + } else { + mState = STATE_CLOSED; + } + mHandler.obtainMessage(mConnectedCode, mState, -1, this).sendToTarget(); + if (result < 0) { + releaseWakeLock(); + } + } + + private synchronized void onAccepted(int result) { + if (VDBG) log("onAccepted() " + this); + if (mState != STATE_ACCEPT) { + if (DBG) log("Strange state" + this); + return; + } + if (result >= 0) { + acquireWakeLock(); + mState = STATE_CONNECTED; + } else { + mState = STATE_CLOSED; + } + mHandler.obtainMessage(mAcceptedCode, mState, -1, this).sendToTarget(); + } + + private synchronized void onClosed() { + if (DBG) log("onClosed() " + this); + if (mState != STATE_CLOSED) { + mState = STATE_CLOSED; + mHandler.obtainMessage(mClosedCode, mState, -1, this).sendToTarget(); + releaseWakeLock(); + } + } + + private void acquireWakeLock() { + if (!mWakeLock.isHeld()) { + mWakeLock.acquire(); + if (VDBG) log("mWakeLock.acquire()" + this); + } + } + + private void releaseWakeLock() { + if (mWakeLock.isHeld()) { + if (VDBG) log("mWakeLock.release()" + this); + mWakeLock.release(); + } + } + + private void log(String msg) { + Log.d(TAG, msg); + } +} diff --git a/core/java/android/bluetooth/package.html b/core/java/android/bluetooth/package.html new file mode 100644 index 0000000..ccd8fec --- /dev/null +++ b/core/java/android/bluetooth/package.html @@ -0,0 +1,14 @@ +<HTML> +<BODY> +Provides classes that manage Bluetooth functionality on the device. +<p> +The Bluetooth APIs allow applications can connect and disconnect headsets, or scan +for other kinds of Bluetooth devices and pair them. Further control includes the +ability to write and modify the local Service Discovery Protocol (SDP) database, +query the SDP database of other Bluetooth devices, establish RFCOMM +channels/sockets on Android, and connect to specified sockets on other devices. +</p> +<p>Remember, not all Android devices are guaranteed to have Bluetooth functionality.</p> +{@hide} +</BODY> +</HTML> |