Quickview
--
+
- Android's bluetooth APIs allow your application to perform wireless data transactions with -other devices -
- The Basics -
- Bluetooth Permissions -
- Setting Up Bluetooth -
- Finding Devices - -
- Connecting Devices - +other devices + + +
- The Basics +
- Bluetooth Permissions +
- Setting Up Bluetooth +
- Finding Devices + +
- Connecting Devices +
- Managing a Connection -
- {@link android.bluetooth.BluetoothAdapter} -
- {@link android.bluetooth.BluetoothDevice} -
- {@link android.bluetooth.BluetoothSocket} -
- {@link android.bluetooth.BluetoothServerSocket} -
- Bluetooth Chat -
- Working with Profiles + + + +
- {@link android.bluetooth.BluetoothAdapter} +
- {@link android.bluetooth.BluetoothDevice} +
- {@link android.bluetooth.BluetoothSocket} +
- {@link android.bluetooth.BluetoothServerSocket} +
- Bluetooth Chat +
Quickview
+In this document
--
-
In this document
+-
+
Key classes
--
-
Related samples
--
-
Key classes
+-
+
Related samples
+-
+
The Android platform includes support for the Bluetooth network stack, which allows a device to wirelessly exchange data with other Bluetooth devices. The application framework provides access to the Bluetooth functionality through the Android Bluetooth APIs. These APIs let applications wirelessly connect to other Bluetooth devices, enabling point-to-point and multipoint -wireless features.
- +wireless features. +Using the Bluetooth APIs, an Android application can perform the following:
-
@@ -69,14 +73,14 @@ following:
- {@link android.bluetooth.BluetoothAdapter} +package. Here's a summary of the classes and interfaces you will need to create Bluetooth +connections: + +
- {@link android.bluetooth.BluetoothAdapter}
- Represents the local Bluetooth adapter (Bluetooth radio). The {@link android.bluetooth.BluetoothAdapter} is the entry-point for all Bluetooth interaction. Using this, @@ -84,51 +88,72 @@ you can discover other Bluetooth devices, query a list of bonded (paired) devices, instantiate a {@link android.bluetooth.BluetoothDevice} using a known MAC address, and create a {@link android.bluetooth.BluetoothServerSocket} to listen for communications -from other devices. - -
- {@link android.bluetooth.BluetoothDevice} +from other devices. + +
- {@link android.bluetooth.BluetoothDevice}
- Represents a remote Bluetooth device. Use this to request a connection with a remote device through a {@link android.bluetooth.BluetoothSocket} or query information about the -device such as its name, address, class, and bonding state. - -
- {@link android.bluetooth.BluetoothSocket} +device such as its name, address, class, and bonding state. + +
- {@link android.bluetooth.BluetoothSocket}
- Represents the interface for a Bluetooth socket (similar to a TCP {@link java.net.Socket}). This is the connection point that allows an application to exchange data with another Bluetooth device via InputStream -and OutputStream. - -
- {@link android.bluetooth.BluetoothServerSocket} +and OutputStream. + +
- {@link android.bluetooth.BluetoothServerSocket}
- Represents an open server socket that listens for incoming requests (similar to a TCP {@link java.net.ServerSocket}). In order to connect two Android devices, one device must open a server socket with this class. When a remote Bluetooth device makes a connection request to the this device, the {@link android.bluetooth.BluetoothServerSocket} will return a connected {@link android.bluetooth.BluetoothSocket} when the -connection is accepted. - -
- {@link android.bluetooth.BluetoothClass} +connection is accepted. + +
- {@link android.bluetooth.BluetoothClass}
- Describes the general characteristics and capabilities of a Bluetooth device. This is a read-only set of properties that define the device's major and minor device classes and its services. However, this does not reliably describe all Bluetooth profiles and services supported by the device, but is useful as a -hint to the device type. -
- {@link android.bluetooth.BluetoothProfile}
- An interface that +represents a Bluetooth profile. A Bluetooth profile is a wireless +interface specification for Bluetooth-based communication between devices. An +example is the Hands-Free profile. For more discussion of profiles, see Working with Profiles +
- {@link android.bluetooth.BluetoothHeadset}
- Provides support for +Bluetooth headsets to be used with mobile phones. This includes both Bluetooth +Headset and Hands-Free (v1.5) profiles. +
- {@link android.bluetooth.BluetoothA2dp}
- Defines how high quality +audio can be streamed from one device to another over a Bluetooth connection. +"A2DP" stands for Advanced Audio Distribution Profile. +
- {@link android.bluetooth.BluetoothProfile.ServiceListener} -
- An interface that notifies {@link android.bluetooth.BluetoothProfile} IPC +clients when they have been connected to or disconnected from the service (that +is, the internal service that runs a particular profile). + +
This document describes how to use the Android Bluetooth APIs to accomplish the four major tasks necessary to communicate using Bluetooth: setting up Bluetooth, finding devices that are either paired or available in the local -area, connecting devices, and transferring data between devices.
- +area, connecting devices, and transferring data between devices. +All of the Bluetooth APIs are available in the {@link android.bluetooth} -package. Here's a summary of the classes you will need to create Bluetooth -connections:
- --
-
-
+
Bluetooth Permissions
- +Bluetooth Permissions
+In order to use Bluetooth features in your application, you need to declare at least one of two Bluetooth permissions: {@link android.Manifest.permission#BLUETOOTH} and {@link -android.Manifest.permission#BLUETOOTH_ADMIN}.
- +android.Manifest.permission#BLUETOOTH_ADMIN}. +You must request the {@link android.Manifest.permission#BLUETOOTH} permission in order to perform any Bluetooth communication, such as requesting a -connection, accepting a connection, and transferring data.
- +connection, accepting a connection, and transferring data. +You must request the {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission in order to initiate device discovery or manipulate Bluetooth settings. Most applications need this permission solely for the @@ -136,40 +161,40 @@ ability to discover local Bluetooth devices. The other abilities granted by this permission should not be used, unless the application is a "power manager" that will modify Bluetooth settings upon user request. Note: If you use {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission, then must -also have the {@link android.Manifest.permission#BLUETOOTH} permission.
- +also have the {@link android.Manifest.permission#BLUETOOTH} permission. +Declare the Bluetooth permission(s) in your application manifest file. For -example:
- -+example: + ++<manifest ... > <uses-permission android:name="android.permission.BLUETOOTH" /> ... </manifest> -- +
See the <uses-permission> -reference for more information about declaring application permissions.
- - -Setting Up Bluetooth
- -
+href="{@docRoot}guide/topics/manifest/uses-permission-element.html"><uses-permission>
+reference for more information about declaring application permissions.
+
+
+Setting Up Bluetooth
+ +
Figure 1: The enabling Bluetooth dialog.
-Before your application can communicate over Bluetooth, you need to verify -that Bluetooth is supported on the device, and if so, ensure that it is enabled.
- +that Bluetooth is supported on the device, and if so, ensure that it is enabled. +If Bluetooth is not supported, then you should gracefully disable any Bluetooth features. If Bluetooth is supported, but disabled, then you can request that the user enable Bluetooth without leaving your application. This setup is -accomplished in two steps, using the {@link android.bluetooth.BluetoothAdapter}.
- - --
+accomplished in two steps, using the {@link android.bluetooth.BluetoothAdapter}.
+
+
+
- Get the {@link android.bluetooth.BluetoothAdapter}
The {@link android.bluetooth.BluetoothAdapter} is required for any and all Bluetooth activity. To get the {@link android.bluetooth.BluetoothAdapter}, call the static {@link @@ -178,15 +203,15 @@ android.bluetooth.BluetoothAdapter#getDefaultAdapter()} method. This returns a Bluetooth adapter (the Bluetooth radio). There's one Bluetooth adapter for the entire system, and your application can interact with it using this object. If {@link android.bluetooth.BluetoothAdapter#getDefaultAdapter()} returns null, -then the device does not support Bluetooth and your story ends here. For example:
-+then the device does not support Bluetooth and your story ends here. For example: +
BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); if (mBluetoothAdapter == null) { // Device does not support Bluetooth } --
-
+
+
+
- Enable Bluetooth
Next, you need to ensure that Bluetooth is enabled. Call {@link android.bluetooth.BluetoothAdapter#isEnabled()} to check whether Bluetooth is @@ -195,26 +220,26 @@ request that Bluetooth be enabled, call {@link android.app.Activity#startActivityForResult(Intent,int) startActivityForResult()} with the {@link android.bluetooth.BluetoothAdapter#ACTION_REQUEST_ENABLE} action Intent. This will issue a request to enable Bluetooth through the system settings (without -stopping your application). For example:
-+stopping your application). For example: +
+if (!mBluetoothAdapter.isEnabled()) { Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT); } -- +A dialog will appear requesting user permission to enable Bluetooth, as shown in Figure 1. If the user responds "Yes," the system will begin to enable Bluetooth -and focus will return to your application once the process completes (or fails).
+and focus will return to your application once the process completes (or fails).If enabling Bluetooth succeeds, your Activity will receive the {@link android.app.Activity#RESULT_OK} result code in the {@link android.app.Activity#onActivityResult(int,int,Intent) onActivityResult()} callback. If Bluetooth was not enabled due to an error (or the user responded "No") then the result code will be {@link -android.app.Activity#RESULT_CANCELED}.
-
-
Optionally, your application can also listen for the {@link android.bluetooth.BluetoothAdapter#ACTION_STATE_CHANGED} broadcast Intent, which the system will broadcast whenever the Bluetooth state has changed. This broadcast contains @@ -226,21 +251,21 @@ android.bluetooth.BluetoothAdapter#STATE_ON}, {@link android.bluetooth.BluetoothAdapter#STATE_TURNING_OFF}, and {@link android.bluetooth.BluetoothAdapter#STATE_OFF}. Listening for this broadcast can be useful to detect changes made to the Bluetooth state while your -app is running.
- +app is running. +Tip: Enabling discoverability will automatically enable Bluetooth. If you plan to consistently enable device discoverability before performing Bluetooth activity, you can skip step 2 above. Read about enabling discoverability, -below.
- - -Finding Devices
- +below. + + +Finding Devices
+Using the {@link android.bluetooth.BluetoothAdapter}, you can find remote Bluetooth devices either through device discovery or by querying the list of paired (bonded) -devices.
- +devices. +Device discovery is a scanning procedure that searches the local area for Bluetooth enabled devices and then requesting some information about each one (this is sometimes referred to as "discovering," "inquiring" or "scanning"). @@ -249,15 +274,15 @@ request only if it is currently enabled to be discoverable. If a device is discoverable, it will respond to the discovery request by sharing some information, such as the device name, class, and its unique MAC address. Using this information, the device performing discovery can then choose to initiate a -connection to the discovered device.
- +connection to the discovered device. +Once a connection is made with a remote device for the first time, a pairing request is automatically presented to the user. When a device is paired, the basic information about that device (such as the device name, class, and MAC address) is saved and can be read using the Bluetooth APIs. Using the known MAC address for a remote device, a connection can be initiated with it at -any time without performing discovery (assuming the device is within range).
- +any time without performing discovery (assuming the device is within range). +Remember there is a difference between being paired and being connected. To be paired means that two devices are aware of each other's existence, have a shared link-key that can be used for authentication, and are capable of @@ -265,28 +290,28 @@ establishing an encrypted connection with each other. To be connected means that the devices currently share an RFCOMM channel and are able to transmit data with each other. The current Android Bluetooth API's require devices to be paired before an RFCOMM connection can be established. (Pairing is automatically performed -when you initiate an encrypted connection with the Bluetooth APIs.)
- +when you initiate an encrypted connection with the Bluetooth APIs.) +The following sections describe how to find devices that have been paired, or -discover new devices using device discovery.
- +discover new devices using device discovery. +Note: Android-powered devices are not discoverable by default. A user can make the device discoverable for a limited time through the system settings, or an application can request that the user enable discoverability without leaving the -application. How to enable discoverability -is discussed below.
- - -Querying paired devices
- +application. How to enable discoverability +is discussed below. + + +Querying paired devices
+Before performing device discovery, its worth querying the set of paired devices to see if the desired device is already known. To do so, call {@link android.bluetooth.BluetoothAdapter#getBondedDevices()}. This will return a Set of {@link android.bluetooth.BluetoothDevice}s representing paired devices. For example, you can query all paired devices and then -show the name of each device to the user, using an ArrayAdapter:
-
+show the name of each device to the user, using an ArrayAdapter:
+
Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
// If there are paired devices
if (pairedDevices.size() > 0) {
@@ -296,24 +321,24 @@ if (pairedDevices.size() > 0) {
mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
}
}
-
-
+
+
All that's needed from the {@link android.bluetooth.BluetoothDevice} object in order to initiate a connection is the MAC address. In this example, it's saved as a part of an ArrayAdapter that's shown to the user. The MAC address can later be extracted in order to initiate the connection. You can learn more about creating -a connection in the section about Connecting Devices.
- - -Discovering devices
- +a connection in the section about Connecting Devices. + + +Discovering devices
+To start discovering devices, simply call {@link android.bluetooth.BluetoothAdapter#startDiscovery()}. The process is asynchronous and the method will immediately return with a boolean indicating whether discovery has successfully started. The discovery process usually involves an inquiry scan of about 12 seconds, followed by a page scan of -each found device to retrieve its Bluetooth name.
- +each found device to retrieve its Bluetooth name. +Your application must register a BroadcastReceiver for the {@link android.bluetooth.BluetoothDevice#ACTION_FOUND} Intent in order to receive information about each @@ -324,8 +349,8 @@ Intent carries the extra fields {@link android.bluetooth.BluetoothDevice#EXTRA_CLASS}, containing a {@link android.bluetooth.BluetoothDevice} and a {@link android.bluetooth.BluetoothClass}, respectively. For example, here's how you can -register to handle the broadcast when devices are discovered:
-
+register to handle the broadcast when devices are discovered:
+
// Create a BroadcastReceiver for ACTION_FOUND
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
@@ -342,15 +367,15 @@ private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
// Register the BroadcastReceiver
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter); // Don't forget to unregister during onDestroy
-
-
+
+
All that's needed from the {@link android.bluetooth.BluetoothDevice} object in order to initiate a connection is the MAC address. In this example, it's saved as a part of an ArrayAdapter that's shown to the user. The MAC address can later be extracted in order to initiate the connection. You can learn more about creating a connection -in the section about Connecting Devices.
- +in the section about Connecting Devices. +Caution: Performing device discovery is a heavy procedure for the Bluetooth adapter and will consume a lot of its resources. Once you have found a device to @@ -359,41 +384,44 @@ connect, be certain that you always stop discovery with attempting a connection. Also, if you already hold a connection with a device, then performing discovery can significantly reduce the bandwidth available for the connection, so you should -not perform discovery while connected.
- -Enabling discoverability
- +not perform discovery while connected. + +Enabling discoverability
+If you would like to make the local device discoverable to other devices, call {@link android.app.Activity#startActivityForResult(Intent,int)} with the -{@link android.bluetooth.BluetoothAdapter#ACTION_REQUEST_DISCOVERABLE} action Intent. -This will issue a request to enable discoverable mode through the system settings (without -stopping your application). By default, the device will become discoverable for -120 seconds. You can define a different duration by adding the -{@link android.bluetooth.BluetoothAdapter#EXTRA_DISCOVERABLE_DURATION} Intent extra -(maximum duration is 300 seconds). For example:
-
-Intent discoverableIntent = new
+{@link android.bluetooth.BluetoothAdapter#ACTION_REQUEST_DISCOVERABLE} action
+Intent. This will issue a request to enable discoverable mode through the system
+settings (without stopping your application). By default, the device will become
+discoverable for 120 seconds. You can define a different duration by adding the
+{@link android.bluetooth.BluetoothAdapter#EXTRA_DISCOVERABLE_DURATION} Intent
+extra. The maximum duration an app can set is 3600 seconds, and a value of 0
+means the device is always discoverable. Any value below 0 or above 3600 is
+automatically set to 120 secs). For example, this snippet sets the duration to
+300:
+
+Intent discoverableIntent = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivity(discoverableIntent);
-
-
-
-
+
+
+
+
Figure 2: The enabling discoverability dialog.
-
-
+
+
A dialog will be displayed, requesting user permission to make the device
discoverable, as shown in Figure 2. If the user responds "Yes," then the device
will become discoverable for the specified amount of time. Your Activity will
then receive a call to the {@link android.app.Activity#onActivityResult(int,int,Intent)
onActivityResult())} callback, with the result code equal to the duration that the device
is discoverable. If the user responded "No" or if an error occurred, the result code will
-be Activity.RESULT_CANCELLED.
-
+be Activity.RESULT_CANCELLED.
+
Note: If Bluetooth has not been enabled on the device,
-then enabling device discoverability will automatically enable Bluetooth.
-
+then enabling device discoverability will automatically enable Bluetooth.
+
The device will silently remain in discoverable mode for the allotted time.
If you would like to be notified when the discoverable mode has changed, you can
register a BroadcastReceiver for the {@link
@@ -407,18 +435,18 @@ new and old scan mode, respectively. Possible values for each are
android.bluetooth.BluetoothAdapter#SCAN_MODE_NONE},
which indicate that the device is either in discoverable mode, not in
discoverable mode but still able to receive connections, or not in discoverable
-mode and unable to receive connections, respectively.
-
+mode and unable to receive connections, respectively.
+
You do not need to enable device discoverability if you will be initiating
the connection to a remote device. Enabling discoverability is only necessary when
you want your application to host a server socket that will accept incoming
connections, because the remote devices must be able to discover the device
-before it can initiate the connection.
-
-
-
-Connecting Devices
-
+before it can initiate the connection.
+
+
+
+Connecting Devices
+
In order to create a connection between your application on two devices, you
must implement both the server-side and client-side mechanisms, because one
device must open a server socket and the other one must initiate the connection
@@ -428,36 +456,36 @@ client are considered connected to each other when they each have a connected
point, each device can obtain input and output streams and data transfer can
begin, which is discussed in the section about Managing a Connection. This section describes how
-to initiate the connection between two devices.
-
+to initiate the connection between two devices.
+
The server device and the client device each obtain the required {@link
android.bluetooth.BluetoothSocket} in different ways. The server will receive it
when an incoming connection is accepted. The client will receive it when it
-opens an RFCOMM channel to the server.
-
-
-
+opens an RFCOMM channel to the server.
+
+
+
Figure 3: The Bluetooth pairing dialog.
-
-
+
+
One implementation technique is to automatically prepare each device as a
server, so that each one has a server socket open and listening for connections.
Then either device can initiate a connection with the other and become the
client. Alternatively, one device can explicitly "host" the connection and open
a server socket on demand and the other device can simply initiate the
-connection.
-
+connection.
+
Note: If the two devices have not been previously paired,
then the Android framework will automatically show a pairing request notification or
dialog to the user during the connection procedure, as shown in Figure 3. So
when attempting to connect devices,
your application does not need to be concerned about whether or not the devices are
paired. Your RFCOMM connection attempt will block until the user has successfully paired,
-or will fail if the user rejects pairing, or if pairing fails or times out.
-
-
-Connecting as a server
-
+or will fail if the user rejects pairing, or if pairing fails or times out.
+
+
+Connecting as a server
+
When you want to connect two devices, one must act as a server by holding an
open {@link android.bluetooth.BluetoothServerSocket}. The purpose of the server
socket is to listen for incoming connection requests and when one is accepted,
@@ -465,26 +493,26 @@ provide a connected {@link android.bluetooth.BluetoothSocket}. When the {@link
android.bluetooth.BluetoothSocket} is acquired from the {@link
android.bluetooth.BluetoothServerSocket},
the {@link android.bluetooth.BluetoothServerSocket} can (and should) be
-discarded, unless you want to accept more connections.
-
-
-
-About UUID
-
+discarded, unless you want to accept more connections.
+
+
+
+About UUID
+
A Universally Unique Identifier (UUID) is a standardized 128-bit format for a string
ID used to uniquely identify information. The point of a UUID is that it's big
enough that you can select any random and it won't clash. In this case, it's
used to uniquely identify your application's Bluetooth service. To get a UUID to
use with your application, you can use one of the many random UUID generators on
the web, then initialize a {@link java.util.UUID} with {@link
-java.util.UUID#fromString(String)}.
-
-
-
+java.util.UUID#fromString(String)}.
+
+
+
Here's the basic procedure to set up a server socket and accept a
-connection:
-
-
+connection:
+
+
- Get a {@link android.bluetooth.BluetoothServerSocket} by calling the
{@link
android.bluetooth.BluetoothAdapter#listenUsingRfcommWithServiceRecord(String,
@@ -496,9 +524,9 @@ UUID is also included in the SDP entry and will be the basis for the connection
agreement with the client device. That is, when the client attempts to connect
with this device, it will carry a UUID that uniquely identifies the service with
which it wants to connect. These UUIDs must match in order for the connection to
-be accepted (in the next step).
-
-
+be accepted (in the next step).
+
+
- Start listening for connection requests by calling
{@link android.bluetooth.BluetoothServerSocket#accept()}.
This is a blocking call. It will return when either a connection has been
@@ -506,9 +534,9 @@ accepted or an exception has occurred. A connection is accepted only when a
remote device has sent a connection request with a UUID matching the one
registered with this listening server socket. When successful, {@link
android.bluetooth.BluetoothServerSocket#accept()} will
-return a connected {@link android.bluetooth.BluetoothSocket}.
-
-
+return a connected {@link android.bluetooth.BluetoothSocket}.
+
+
- Unless you want to accept additional connections, call
{@link android.bluetooth.BluetoothServerSocket#close()}.
This releases the server socket and all its resources, but does not close the
@@ -517,10 +545,10 @@ android.bluetooth.BluetoothServerSocket#accept()}. Unlike TCP/IP, RFCOMM only al
connected client per channel at a time, so in most cases it makes sense to call {@link
android.bluetooth.BluetoothServerSocket#close()} on the {@link
android.bluetooth.BluetoothServerSocket} immediately after accepting a connected
-socket.
-
-
-
+socket.
+
+
+
The {@link android.bluetooth.BluetoothServerSocket#accept()} call should not
be executed in the main Activity UI thread because it is a blocking call and
will prevent any other interaction with the application. It usually makes
@@ -533,16 +561,16 @@ android.bluetooth.BluetoothServerSocket} (or {@link
android.bluetooth.BluetoothSocket}) from another thread and the blocked call will
immediately return. Note that all methods on a {@link
android.bluetooth.BluetoothServerSocket} or {@link android.bluetooth.BluetoothSocket}
-are thread-safe.
-
-Example
-
+are thread-safe.
+
+Example
+
Here's a simplified thread for the server component that accepts incoming
-connections:
-
+connections:
+
private class AcceptThread extends Thread {
private final BluetoothServerSocket mmServerSocket;
-
+
public AcceptThread() {
// Use a temporary object that is later assigned to mmServerSocket,
// because mmServerSocket is final
@@ -553,7 +581,7 @@ private class AcceptThread extends Thread {
} catch (IOException e) { }
mmServerSocket = tmp;
}
-
+
public void run() {
BluetoothSocket socket = null;
// Keep listening until exception occurs or a socket is returned
@@ -572,7 +600,7 @@ private class AcceptThread extends Thread {
}
}
}
-
+
/** Will cancel the listening socket, and cause the thread to finish */
public void cancel() {
try {
@@ -580,37 +608,37 @@ private class AcceptThread extends Thread {
} catch (IOException e) { }
}
}
-
-
+
+
In this example, only one incoming connection is desired, so as soon as a
connection is accepted and the {@link android.bluetooth.BluetoothSocket} is
acquired, the application
sends the acquired {@link android.bluetooth.BluetoothSocket} to a separate
thread, closes the
-{@link android.bluetooth.BluetoothServerSocket} and breaks the loop.
-
+{@link android.bluetooth.BluetoothServerSocket} and breaks the loop.
+
Note that when {@link android.bluetooth.BluetoothServerSocket#accept()}
returns the {@link android.bluetooth.BluetoothSocket}, the socket is already
connected, so you should not call {@link
android.bluetooth.BluetoothSocket#connect()} (as you do from the
-client-side).
-
+client-side).
+
manageConnectedSocket() is a fictional method in the application
that will
initiate the thread for transferring data, which is discussed in the section
-about Managing a Connection.
-
+about Managing a Connection.
+
You should usually close your {@link android.bluetooth.BluetoothServerSocket}
as soon as you are done listening for incoming connections. In this example, {@link
android.bluetooth.BluetoothServerSocket#close()} is called as soon
as the {@link android.bluetooth.BluetoothSocket} is acquired. You may also want
to provide a public method in your thread that can close the private {@link
android.bluetooth.BluetoothSocket} in the event that you need to stop listening on the
-server socket.
-
-
-Connecting as a client
-
+server socket.
+
+
+Connecting as a client
+
In order to initiate a connection with a remote device (a device holding an
open
server socket), you must first obtain a {@link
@@ -619,11 +647,11 @@ android.bluetooth.BluetoothDevice} object that represents the remote device.
section about Finding Devices.) You must then use the
{@link android.bluetooth.BluetoothDevice} to acquire a {@link
-android.bluetooth.BluetoothSocket} and initiate the connection.
-
-Here's the basic procedure:
-
-
+android.bluetooth.BluetoothSocket} and initiate the connection.
+
+Here's the basic procedure:
+
+
- Using the {@link android.bluetooth.BluetoothDevice}, get a {@link
android.bluetooth.BluetoothSocket} by calling {@link
android.bluetooth.BluetoothDevice#createRfcommSocketToServiceRecord(UUID)}.
@@ -634,9 +662,9 @@ must match the UUID used by the server device when it opened its
android.bluetooth.BluetoothAdapter#listenUsingRfcommWithServiceRecord(String,
UUID)}). Using the same UUID is simply a matter of hard-coding the UUID string
into your application and then referencing it from both the server and client
-code.
-
-
+code.
+
+
- Initiate the connection by calling {@link
android.bluetooth.BluetoothSocket#connect()}.
Upon this call, the system will perform an SDP lookup on the remote device in
@@ -647,34 +675,34 @@ android.bluetooth.BluetoothSocket#connect()} will return. This method is a
blocking call. If, for
any reason, the connection fails or the {@link
android.bluetooth.BluetoothSocket#connect()} method times out (after about
-12 seconds), then it will throw an exception.
+12 seconds), then it will throw an exception.
Because {@link
android.bluetooth.BluetoothSocket#connect()} is a blocking call, this connection
procedure should always be performed in a thread separate from the main Activity
-thread.
+thread.
Note: You should always ensure that the device is not performing
device discovery when you call {@link
android.bluetooth.BluetoothSocket#connect()}. If discovery is in progress, then
the
-connection attempt will be significantly slowed and is more likely to fail.
-
-
-
-Example
-
+connection attempt will be significantly slowed and is more likely to fail.
+
+
+
+Example
+
Here is a basic example of a thread that initiates a Bluetooth
-connection:
-
+connection:
+
private class ConnectThread extends Thread {
private final BluetoothSocket mmSocket;
private final BluetoothDevice mmDevice;
-
+
public ConnectThread(BluetoothDevice device) {
// Use a temporary object that is later assigned to mmSocket,
// because mmSocket is final
BluetoothSocket tmp = null;
mmDevice = device;
-
+
// Get a BluetoothSocket to connect with the given BluetoothDevice
try {
// MY_UUID is the app's UUID string, also used by the server code
@@ -682,11 +710,11 @@ private class ConnectThread extends Thread {
} catch (IOException e) { }
mmSocket = tmp;
}
-
+
public void run() {
// Cancel discovery because it will slow down the connection
mBluetoothAdapter.cancelDiscovery();
-
+
try {
// Connect the device through the socket. This will block
// until it succeeds or throws an exception
@@ -698,11 +726,11 @@ private class ConnectThread extends Thread {
} catch (IOException closeException) { }
return;
}
-
+
// Do work to manage the connection (in a separate thread)
manageConnectedSocket(mmSocket);
}
-
+
/** Will cancel an in-progress connection, and close the socket */
public void cancel() {
try {
@@ -710,42 +738,42 @@ private class ConnectThread extends Thread {
} catch (IOException e) { }
}
}
-
-
+
+
Notice that {@link android.bluetooth.BluetoothAdapter#cancelDiscovery()} is called
before the connection is made. You should always do this before connecting and it is safe
to call without actually checking whether it is running or not (but if you do want to
-check, call {@link android.bluetooth.BluetoothAdapter#isDiscovering()}).
-
+check, call {@link android.bluetooth.BluetoothAdapter#isDiscovering()}).
+
manageConnectedSocket() is a fictional method in the application
that will initiate the thread for transferring data, which is discussed in the section
-about Managing a Connection.
-
+about Managing a Connection.
+
When you're done with your {@link android.bluetooth.BluetoothSocket}, always
call {@link android.bluetooth.BluetoothSocket#close()} to clean up.
Doing so will immediately close the connected socket and clean up all internal
-resources.
-
-
-Managing a Connection
-
+resources.
+
+
+Managing a Connection
+
When you have successfully connected two (or more) devices, each one will
have a connected {@link android.bluetooth.BluetoothSocket}. This is where the fun
begins because you can share data between devices. Using the {@link
android.bluetooth.BluetoothSocket}, the general procedure to transfer arbitrary data is
-simple:
-
+simple:
+
- Get the {@link java.io.InputStream} and {@link java.io.OutputStream} that
handle transmissions through the socket, via {@link
android.bluetooth.BluetoothSocket#getInputStream()} and
-{@link android.bluetooth.BluetoothSocket#getOutputStream}, respectively.
-
+{@link android.bluetooth.BluetoothSocket#getOutputStream}, respectively.
+
- Read and write data to the streams with {@link
-java.io.InputStream#read(byte[])} and {@link java.io.OutputStream#write(byte[])}.
-
-
-That's it.
-
+java.io.InputStream#read(byte[])} and {@link java.io.OutputStream#write(byte[])}.
+
+
+That's it.
+
There are, of course, implementation details to consider. First and foremost,
you should use a dedicated thread for all stream reading and writing. This is
important because both {@link java.io.InputStream#read(byte[])} and {@link
@@ -756,37 +784,37 @@ block, but can block for flow control if the remote device is not calling {@link
java.io.InputStream#read(byte[])} quickly enough and the intermediate buffers are full.
So, your main loop in the thread should be dedicated to reading from the {@link
java.io.InputStream}. A separate public method in the thread can be used to initiate
-writes to the {@link java.io.OutputStream}.
-
-Example
-
-Here's an example of how this might look:
-
+writes to the {@link java.io.OutputStream}.
+
+Example
+
+Here's an example of how this might look:
+
private class ConnectedThread extends Thread {
private final BluetoothSocket mmSocket;
private final InputStream mmInStream;
private final OutputStream mmOutStream;
-
+
public ConnectedThread(BluetoothSocket socket) {
mmSocket = socket;
InputStream tmpIn = null;
OutputStream tmpOut = null;
-
+
// Get the input and output streams, using temp objects because
// member streams are final
try {
tmpIn = socket.getInputStream();
tmpOut = socket.getOutputStream();
} catch (IOException e) { }
-
+
mmInStream = tmpIn;
mmOutStream = tmpOut;
}
-
+
public void run() {
byte[] buffer = new byte[1024]; // buffer store for the stream
int bytes; // bytes returned from read()
-
+
// Keep listening to the InputStream until an exception occurs
while (true) {
try {
@@ -800,14 +828,14 @@ private class ConnectedThread extends Thread {
}
}
}
-
+
/* Call this from the main Activity to send data to the remote device */
public void write(byte[] bytes) {
try {
mmOutStream.write(bytes);
} catch (IOException e) { }
}
-
+
/* Call this from the main Activity to shutdown the connection */
public void cancel() {
try {
@@ -815,27 +843,124 @@ private class ConnectedThread extends Thread {
} catch (IOException e) { }
}
}
-
-
+
+
The constructor acquires the necessary streams and once executed, the thread
will wait for data to come through the InputStream. When {@link
java.io.InputStream#read(byte[])} returns with
bytes from the stream, the data is sent to the main Activity using a member
Handler from the parent class. Then it goes back and waits for more bytes from
-the stream.
-
+the stream.
+
Sending outgoing data is as simple as calling the thread's
write() method from the main Activity and passing in the bytes to
be sent. This method then simply calls {@link
-java.io.OutputStream#write(byte[])} to send the data to the remote device.
-
+java.io.OutputStream#write(byte[])} to send the data to the remote device.
+
The thread's cancel() method is important so that the connection
can be
terminated at any time by closing the {@link android.bluetooth.BluetoothSocket}.
This should always be called when you're done using the Bluetooth
-connection.
+connection.
+
+
+For a demonstration of using the Bluetooth APIs, see the Bluetooth Chat sample app.
+
-
-For a complete demonstration using the Bluetooth APIs, see the Bluetooth Chat sample app.
-
+Working with Profiles
+
+Starting in Android 3.0, the Bluetooth API includes support for working with
+Bluetooth profiles. A Bluetooth profile is a wireless interface
+specification for Bluetooth-based communication between devices. An example
+is the Hands-Free profile. For a mobile phone to connect to a wireless headset,
+both devices must support the Hands-Free profile.
+
+You can implement the interface {@link android.bluetooth.BluetoothProfile} to write
+your own classes to support a particular Bluetooth profile. The Android
+Bluetooth API provides implementations for the following Bluetooth
+profiles:
+-
+
+
- Headset. The Headset profile provides support for +Bluetooth headsets to be used with mobile phones. Android provides the {@link +android.bluetooth.BluetoothHeadset} class, which is a proxy for controlling the +Bluetooth Headset Service via interprocess communication (IPC). This includes both Bluetooth Headset and Hands-Free (v1.5) profiles. The +{@link android.bluetooth.BluetoothHeadset} class includes support for AT commands. +For more discussion of this topic, see Vendor-specific AT commands + +
- A2DP. The Advanced Audio Distribution Profile (A2DP) +profile defines how high quality audio can be streamed from one device to +another over a Bluetooth connection. Android provides the {@link +android.bluetooth.BluetoothA2dp} class, which is a proxy for controlling +the Bluetooth A2DP Service via IPC. + +
Here are the basic steps for working with a profile:
+-
+
+
- Get the default adapter, as described in Setting Up Bluetooth. + +
- Use {@link +android.bluetooth.BluetoothAdapter#getProfileProxy(android.content.Context, +android.bluetooth.BluetoothProfile.ServiceListener, int) getProfileProxy()} to +establish a connection to the profile proxy object associated with the profile. +In the example below, the profile proxy object is an instance of {@link +android.bluetooth.BluetoothHeadset}. + +
- Set up a {@link android.bluetooth.BluetoothProfile.ServiceListener}. This +listener notifies {@link android.bluetooth.BluetoothProfile} IPC clients when +they have been connected to or disconnected from the service. + +
- In {@link +android.bluetooth.BluetoothProfile.ServiceListener#onServiceConnected(int, +android.bluetooth.BluetoothProfile) onServiceConnected()}, get a handle +to the profile proxy object. + +
- Once you have the profile proxy object, you can use it to monitor the +state of the connection and perform other operations that are relevant to that +profile. +
For example, this code snippet shows how to connect to a {@link android.bluetooth.BluetoothHeadset} proxy object so that you can control the +Headset profile:
+ +BluetoothHeadset mBluetoothHeadset;
+
+// Get the default adapter
+BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+
+// Establish connection to the proxy.
+mBluetoothAdapter.getProfileProxy(context, mProfileListener, BluetoothProfile.HEADSET);
+
+private BluetoothProfile.ServiceListener mProfileListener = new BluetoothProfile.ServiceListener() {
+ public void onServiceConnected(int profile, BluetoothProfile proxy) {
+ if (profile == BluetoothProfile.HEADSET) {
+ mBluetoothHeadset = (BluetoothHeadset) proxy;
+ }
+ }
+ public void onServiceDisconnected(int profile) {
+ if (profile == BluetoothProfile.HEADSET) {
+ mBluetoothHeadset = null;
+ }
+ }
+};
+
+// ... call functions on mBluetoothHeadset
+
+// Close proxy connection after use.
+mBluetoothAdapter.closeProfileProxy(mBluetoothHeadset);
+
+
+Vendor-specific AT commands
+ +Starting in Android 3.0, applications can register to receive system +broadcasts of pre-defined vendor-specific AT commands sent by headsets (such as +a Plantronics +XEVENT command). For example, an application could receive +broadcasts that indicate a connected device's battery level and could notify the +user or take other action as needed. Create a broadcast receiver for the {@link +android.bluetooth.BluetoothHeadset#ACTION_VENDOR_SPECIFIC_HEADSET_EVENT} intent +to handle vendor-specific AT commands for the headset.