Send Bluetooth Messages Between Android Phones API 31+ In Java

In this comprehensive guide, we will delve into the intricacies of sending text messages between two Android phones using Bluetooth Classic in Java, specifically targeting API level 31 and above (Android 12/13). This task, while seemingly straightforward, involves navigating permission changes, establishing Bluetooth connections, and handling data transfer, all within the Android environment. This article will equip you with the knowledge and practical steps to implement this functionality in your Android applications.

Developing Bluetooth communication between Android devices, especially with newer API levels, presents several challenges. The primary hurdle lies in the permission changes introduced in Android 12 (API level 31). These changes necessitate a more granular approach to requesting Bluetooth permissions, differentiating between connecting to paired devices and discovering new devices. Furthermore, ensuring seamless data transfer and robust error handling are crucial for a reliable Bluetooth messaging system. This article aims to demystify these challenges and provide clear, actionable solutions.

Before we embark on the implementation, let's ensure you have the necessary tools and understanding:

• Android Studio: The official IDE for Android development is essential for writing, building, and debugging your application.
• Java Development Kit (JDK): Ensure you have a compatible JDK installed, as Java is the primary language for this project.
• Two Android Phones (API 31+): You'll need two physical devices running Android 12 or later to test the Bluetooth communication.
• Basic Android Development Knowledge: Familiarity with activities, permissions, UI elements, and background threads is beneficial.
• Bluetooth Fundamentals: A basic understanding of Bluetooth Classic, Service Discovery Protocol (SDP), and UUIDs is helpful.

Now, let's break down the implementation process into manageable steps:

1. Setting Up the Project and Permissions

First, create a new Android Studio project with an empty activity. The most critical step here is to declare the necessary Bluetooth permissions in your AndroidManifest.xml file. With API 31 and above, you need to request specific permissions for different Bluetooth functionalities.

• Declare Bluetooth Permissions: To start, you'll need the android.permission.BLUETOOTH_CONNECT permission to connect to paired devices. For discovering new devices, the android.permission.BLUETOOTH_SCAN permission is necessary, along with android.permission.ACCESS_FINE_LOCATION as Bluetooth scanning can be used to infer location. Additionally, if you want your app to be discoverable by other Bluetooth devices, include the android.permission.BLUETOOTH_ADVERTISE permission. These permissions are crucial for establishing and maintaining Bluetooth communication in your application.
• Request Permissions at Runtime: Declaring permissions in the manifest is not enough; you must also request them at runtime. Use the ActivityCompat.requestPermissions() method to prompt the user for permission. Remember to handle the permission request results in the onRequestPermissionsResult() callback method. This step ensures that your app complies with Android's permission model, enhancing user privacy and security.

Code Snippet (AndroidManifest.xml)

<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" android:usesPermissionFlags="neverForLocation" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:usesPermissionFlags="neverForLocation" />
<uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />

Code Snippet (Requesting Permissions in Activity)

private static final int BLUETOOTH_PERMISSIONS_REQUEST_CODE = 100;
private final String[] bluetoothPermissions = {
        Manifest.permission.BLUETOOTH_CONNECT,
        Manifest.permission.BLUETOOTH_SCAN,
        Manifest.permission.ACCESS_FINE_LOCATION,
        Manifest.permission.BLUETOOTH_ADVERTISE
};

private void requestBluetoothPermissions() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED ||
            ContextCompat.checkSelfPermission(this, Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED ||
            ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED ||
            ContextCompat.checkSelfPermission(this, Manifest.permission.BLUETOOTH_ADVERTISE) != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, bluetoothPermissions, BLUETOOTH_PERMISSIONS_REQUEST_CODE);
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == BLUETOOTH_PERMISSIONS_REQUEST_CODE) {
        if (grantResults.length > 0) {
            boolean allGranted = true;
            for (int grantResult : grantResults) {
                if (grantResult != PackageManager.PERMISSION_GRANTED) {
                    allGranted = false;
                    break;
                }
            }
            if (allGranted) {
                // Permissions granted, proceed with Bluetooth operations
            } else {
                // Permissions denied, handle accordingly
                Toast.makeText(this, "Bluetooth permissions are required.", Toast.LENGTH_SHORT).show();
            }
        }
    }
}

2. Setting Up Bluetooth Adapter and Discoverability

Next, you need to obtain the BluetoothAdapter, which represents the device's Bluetooth radio. If the adapter is null, the device doesn't support Bluetooth. Enabling Bluetooth and making the device discoverable are crucial steps for establishing connections.

• Get the Bluetooth Adapter: The BluetoothAdapter is the gateway to all Bluetooth operations. Obtain an instance using BluetoothAdapter.getDefaultAdapter(). If this method returns null, the device does not support Bluetooth. This check is fundamental to prevent your application from crashing on unsupported devices and to provide a graceful fallback or an informative message to the user.
• Enable Bluetooth: Check if Bluetooth is enabled using bluetoothAdapter.isEnabled(). If not, prompt the user to enable it using an Intent with the BluetoothAdapter.ACTION_REQUEST_ENABLE action. This ensures that Bluetooth is active before your application attempts any Bluetooth-related operations, such as scanning for devices or establishing connections.
• Make Device Discoverable (Optional): To allow other devices to discover your device, use an Intent with the BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE action. This step is crucial for scenarios where one device needs to initiate a connection with another. You can specify a duration for discoverability, after which the device will revert to a non-discoverable state, enhancing security and privacy.

Code Snippet

private BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
private static final int REQUEST_ENABLE_BT = 200;
private static final int REQUEST_DISCOVERABLE_BT = 201;

private void setupBluetooth() {
    if (bluetoothAdapter == null) {
        // Device doesn't support Bluetooth
        Toast.makeText(this, "Bluetooth is not supported on this device.", Toast.LENGTH_SHORT).show();
        finish();
        return;
    }

    if (!bluetoothAdapter.isEnabled()) {
        Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
    }

    // Make the device discoverable for 300 seconds (5 minutes)
    Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
    discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
    startActivityForResult(discoverableIntent, REQUEST_DISCOVERABLE_BT);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == REQUEST_ENABLE_BT) {
        if (resultCode == Activity.RESULT_OK) {
            // Bluetooth is now enabled
        } else {
            // User did not enable Bluetooth or an error occurred
            Toast.makeText(this, "Bluetooth is required for this app.", Toast.LENGTH_SHORT).show();
            finish();
        }
    } else if (requestCode == REQUEST_DISCOVERABLE_BT) {
        if (resultCode == 300) { // 300 corresponds to the duration we requested
            // Device is now discoverable
        } else {
            // User declined discoverability or an error occurred
        }
    }
}

3. Scanning for Devices

To establish a connection, one device needs to scan for other Bluetooth devices. The BluetoothLeScanner class is used for scanning in modern Android versions. This process involves registering a ScanCallback to receive scan results. Remember to unregister the callback when scanning is no longer needed to conserve resources. Scanning for Bluetooth devices is a crucial step in establishing connections between devices.

• Start Scanning: Use the BluetoothLeScanner.startScan() method to begin scanning for Bluetooth devices. This method requires a ScanCallback object, which will receive the results of the scan. You can also provide ScanFilter and ScanSettings to refine the scanning process, such as filtering by device name or UUID and optimizing scan mode for power consumption or latency.
• Handle Scan Results: The ScanCallback provides the onScanResult() method, which is called each time a new device is discovered. This method provides a ScanResult object containing information about the discovered device, such as its BluetoothDevice object, signal strength (RSSI), and other relevant data. This is where you can implement logic to display discovered devices to the user or automatically connect to a specific device based on certain criteria.
• Stop Scanning: To conserve battery and system resources, it's essential to stop scanning when it's no longer needed. Use the BluetoothLeScanner.stopScan() method and unregister the ScanCallback. Failing to stop scanning can lead to significant battery drain and impact the performance of other Bluetooth applications. Implement a mechanism to automatically stop scanning after a certain period or when a connection is established.

Code Snippet

private BluetoothLeScanner bluetoothLeScanner = bluetoothAdapter.getBluetoothLeScanner();
private ScanCallback scanCallback;

private void startScanning() {
    scanCallback = new ScanCallback() {
        @Override
        public void onScanResult(int callbackType, ScanResult result) {
            super.onScanResult(callbackType, result);
            BluetoothDevice device = result.getDevice();
            // Handle discovered device (e.g., add to a list)
            Log.d("Bluetooth", "Discovered device: " + device.getName() + " - " + device.getAddress());
        }

        @Override
        public void onScanFailed(int errorCode) {
            super.onScanFailed(errorCode);
            // Handle scan failure
            Log.e("Bluetooth", "Scan failed with error: " + errorCode);
        }
    };

    bluetoothLeScanner.startScan(null, new ScanSettings.Builder().setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY).build(), scanCallback);
}

private void stopScanning() {
    if (bluetoothLeScanner != null && scanCallback != null) {
        bluetoothLeScanner.stopScan(scanCallback);
        scanCallback = null;
    }
}

4. Connecting to a Device

Once a device is discovered, you can initiate a connection. This involves creating a BluetoothSocket and connecting to the remote device using its UUID. The UUID is a unique identifier for your Bluetooth service. Connecting to a Bluetooth device involves several steps, each crucial for establishing a reliable communication channel.

• Create a BluetoothSocket: Use the BluetoothDevice.createRfcommSocketToServiceRecord(UUID) method to create a BluetoothSocket. The UUID is a unique identifier for your Bluetooth service and must be the same on both devices. Using a consistent UUID ensures that devices can correctly identify and connect to your specific service.
• Connect the Socket: Call the BluetoothSocket.connect() method to establish a connection. This is a blocking call, so it's essential to perform this operation in a background thread to avoid freezing the UI. The connect() method attempts to establish a connection with the remote device and will throw an IOException if the connection fails. Handle this exception gracefully, providing feedback to the user and attempting reconnection if necessary.
• Manage the Connection: After a successful connection, you'll need to manage the connection for data transfer. This typically involves creating input and output streams from the socket to send and receive data. Ensure that you close the socket when the connection is no longer needed to release resources and prevent connection leaks.

Code Snippet

private BluetoothSocket bluetoothSocket;
private static final UUID MY_UUID = UUID.fromString("your-unique-uuid-string"); // Replace with your UUID

private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;

    public ConnectThread(BluetoothDevice device) {
        BluetoothSocket tmp = null;
        mmDevice = device;

        try {
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
        } catch (IOException e) {
            Log.e("Bluetooth", "Socket creation failed", e);
        }
        mmSocket = tmp;
    }

    public void run() {
        // Cancel discovery because it otherwise slows down the connection.
        bluetoothAdapter.cancelDiscovery();

        try {
            mmSocket.connect();
        } catch (IOException connectException) {
            // Unable to connect; close the socket and return.
            try {
                mmSocket.close();
            } catch (IOException closeException) {
                Log.e("Bluetooth", "Could not close socket", closeException);
            }
            return;
        }

        // Do work to manage the connection (in a separate thread)
        manageConnectedSocket(mmSocket);
    }

    // Closes the client socket and causes the thread to finish.
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) {
            Log.e("Bluetooth", "Could not close socket", e);
        }
    }
}

5. Sending and Receiving Messages

With a connection established, you can now send and receive messages. This involves creating input and output streams from the BluetoothSocket. Use these streams to write and read data.

• Create Input and Output Streams: Obtain the input and output streams from the BluetoothSocket using socket.getInputStream() and socket.getOutputStream(). These streams are used for sending and receiving data between the connected devices. Ensure that you handle potential IOExceptions that may occur during stream creation.
• Send Data: To send data, write to the output stream using the OutputStream.write() method. You'll typically convert your message into a byte array before sending it. Consider using a specific encoding (e.g., UTF-8) to ensure proper character representation. Implement a mechanism to flush the output stream to ensure that all data is sent immediately.
• Receive Data: To receive data, read from the input stream using the InputStream.read() method. This method blocks until data is available or an exception occurs. Read data in chunks and buffer it until a complete message is received. Implement a protocol for message framing (e.g., using a delimiter or message length prefix) to correctly identify message boundaries.
• Handle Data in Background Threads: Both sending and receiving data are blocking operations, so it's crucial to perform these tasks in background threads to prevent UI freezes. Use AsyncTask, ExecutorService, or other threading mechanisms to handle data transfer asynchronously.

Code Snippet

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;

        try {
            tmpIn = socket.getInputStream();
            tmpOut = socket.getOutputStream();
        } catch (IOException e) {
            Log.e("Bluetooth", "Error getting streams", e);
        }

        mmInStream = tmpIn;
        mmOutStream = tmpOut;
    }

    public void run() {
        byte[] buffer = new byte[1024];
        int bytes;

        // Keep listening to the InputStream until an exception occurs.
        while (true) {
            try {
                // Read from the InputStream.
                bytes = mmInStream.read(buffer);
                // Send the obtained bytes to the UI activity.
                String message = new String(buffer, 0, bytes);
                Log.d("Bluetooth", "Received: " + message);
                // Post the message to UI thread
            } catch (IOException e) {
                Log.e("Bluetooth", "Input stream disconnected", e);
                break;
            }
        }
    }

    // Call this from the main activity to send data to the remote device.
    public void write(String message) {
        byte[] bytes = message.getBytes();
        try {
            mmOutStream.write(bytes);
            mmOutStream.flush();
        } catch (IOException e) {
            Log.e("Bluetooth", "Error occurred when sending data", e);
        }
    }

    // Call this method from the main activity to shut down the connection.
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) {
            Log.e("Bluetooth", "Could not close socket", e);
        }
    }
}

6. Error Handling and UI Updates

Robust error handling is crucial for a reliable application. Handle exceptions gracefully and provide informative feedback to the user. Update the UI from the main thread to reflect the connection status and received messages. Error handling and UI updates are essential components of a robust Bluetooth application.

• Handle Exceptions: Bluetooth communication is prone to various exceptions, such as IOException during socket operations, SecurityException due to permission issues, and BluetoothStateException if Bluetooth is disabled or unavailable. Implement try-catch blocks to catch these exceptions and handle them appropriately. Log the exceptions for debugging purposes and provide informative error messages to the user.
• Provide User Feedback: Keep the user informed about the connection status, any errors that occur, and the progress of data transfer. Use UI elements such as Toast messages, AlertDialogs, or status indicators to provide feedback. Avoid displaying technical details to the user; instead, provide user-friendly messages that guide them on how to resolve the issue.
• Update UI from Main Thread: Bluetooth operations often occur in background threads to prevent UI freezes. When you need to update the UI based on Bluetooth events (e.g., receiving a message, connection status change), ensure that you perform the UI updates from the main thread. Use methods like runOnUiThread() or Handler to post updates to the main thread safely.

Code Snippet

// Example of handling exceptions in ConnectThread

catch (IOException connectException) {
    // Unable to connect; close the socket and return.
    try {
        mmSocket.close();
    } catch (IOException closeException) {
        Log.e("Bluetooth", "Could not close socket", closeException);
    }
    // Update UI with connection failure message (using runOnUiThread)
    runOnUiThread(() -> Toast.makeText(MainActivity.this, "Connection failed.", Toast.LENGTH_SHORT).show());
    return;
}

7. Testing and Debugging

Thorough testing is essential to ensure your Bluetooth messaging application works reliably. Test on multiple devices and under various conditions. Use Android Studio's debugging tools to identify and fix issues.

• Test on Multiple Devices: Bluetooth behavior can vary across different Android devices due to hardware and software differences. Test your application on a range of devices with varying Android versions and Bluetooth chipsets to ensure compatibility and consistent performance. This helps identify device-specific issues and ensures a broader user base can use your application without problems.
• Simulate Real-World Conditions: Test your application in different environments and under various conditions to simulate real-world usage scenarios. This includes testing in areas with Bluetooth interference, varying distances between devices, and with different numbers of connected devices. Simulate scenarios where connections might be interrupted or lost to test the application's robustness and error handling.
• Use Debugging Tools: Android Studio provides powerful debugging tools that can help you identify and fix issues in your Bluetooth application. Use log messages extensively to track the flow of execution and identify potential problems. Utilize breakpoints to pause execution and inspect variables and the state of your application. The Android Debug Bridge (ADB) allows you to connect to devices and debug applications directly, providing valuable insights into the application's behavior.

Sending Bluetooth messages between Android phones requires careful handling of permissions, connection management, and data transfer. By following the steps outlined in this guide and adapting the code snippets to your specific needs, you can create a functional and reliable Bluetooth messaging application. Remember to prioritize error handling and thorough testing to ensure a seamless user experience. This article provides a comprehensive guide on sending Bluetooth messages between Android phones, covering permissions, device discovery, connection establishment, data transfer, and error handling. It equips developers with the necessary knowledge to implement Bluetooth communication in their Android applications effectively.

• Q: What are the key permission changes in Android 12 (API 31+) for Bluetooth?
  • A: Android 12 introduces more granular Bluetooth permissions. You need BLUETOOTH_CONNECT to connect to paired devices, BLUETOOTH_SCAN and ACCESS_FINE_LOCATION to discover devices, and BLUETOOTH_ADVERTISE to make your device discoverable.
• Q: How do I handle Bluetooth permission requests at runtime?
  • A: Use ActivityCompat.requestPermissions() to prompt the user for permissions. Handle the results in onRequestPermissionsResult(), checking if permissions were granted and responding accordingly.
• Q: Why is it important to perform Bluetooth operations in background threads?
  • A: Bluetooth operations like scanning, connecting, and data transfer can block the main thread, causing UI freezes. Use background threads (e.g., AsyncTask, ExecutorService) to avoid this.
• Q: What is a UUID and why is it important in Bluetooth communication?
  • A: A UUID (Universally Unique Identifier) is a 128-bit number used to identify a Bluetooth service uniquely. It's crucial for devices to find and connect to the correct service.
• Q: How can I ensure my Bluetooth application works reliably across different Android devices?
  • A: Test your application on multiple devices with varying Android versions and Bluetooth chipsets. Simulate real-world conditions like interference and varying distances to identify and address potential issues.