Question

I’m trying to get the basics of using Bluetooth through a simple application. I’d also like a laptop application so I can debug Bluetooth comms simply. The code below is my attempt with the laptop being the client (using BlueCove 2.1.0) and the tablet being the server (Android 2.2).

From what I understand, this should work as written, and the laptop is picking up both the tablet and its offered service. However, the line "StreamConnection conn = (StreamConnection) Connector.open(url, Connector.READ_WRITE);" returns null every time.

Any idea’s what’s going wrong? Here is the output from the code:

BlueCove version 2.1.0 on winsock
Address: 68A3C44A5265
Name: WS1497
Starting device inquiry…
Device discovered: 2013E061D922
Device discovered: 00242BFE7375
INQUIRY_COMPLETED
Device Inquiry Completed.
Service Inquiry Started.
From: Galaxy Tab
Service search completed – code: 1
From: WS1190
Service search completed – code: 4
Bluetooth Devices:
1. 2013E061D922 (Galaxy Tab)
2. 00242BFE7375 (WS1190)
btspp://2013E061D922:20;authenticate=false;encrypt=false;master=false —-=null
Exception in thread “main” java.lang.NullPointerException
at MainClass.main(MainClass.java:104)
BlueCove stack shutdown completed

And here is the code I’m using:

Laptop Code:

import java.io.DataInputStream;
import java.io.IOException;
import java.util.Vector;

import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;
import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;

public class MainClass implements DiscoveryListener {

// object used for waiting
private static Object lock = new Object();

// vector containing the devices discovered
private static Vector<RemoteDevice> vecDevices = new Vector<RemoteDevice>();
private static Vector<String> vecServices = new Vector<String>();

// main method of the application
public static void main(String[] args) throws IOException {

    // create an instance of this class
    MainClass bluetoothDeviceDiscovery = new MainClass();

    // display local device address and name
    LocalDevice localDevice = LocalDevice.getLocalDevice();

    System.out.println("Address: " + localDevice.getBluetoothAddress());
    System.out.println("Name: " + localDevice.getFriendlyName());

    // find devices
    DiscoveryAgent agent = localDevice.getDiscoveryAgent();

    System.out.println("Starting device inquiry...");
    agent.startInquiry(DiscoveryAgent.GIAC, bluetoothDeviceDiscovery);

    try {
        synchronized (lock) {
            lock.wait();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("Device Inquiry Completed. ");
    System.out.println("Service Inquiry Started. ");

    UUID uuids[] = new UUID[1];
    uuids[0] = new UUID("fa87c0d0afac11de8a390800200c9a66", false);

    for (RemoteDevice rd : vecDevices) {
        System.out.println("From: " + rd.getFriendlyName(false));
        agent.searchServices(null, uuids, rd, bluetoothDeviceDiscovery);
        try {
            synchronized (lock) {
                lock.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // print all devices in vecDevices
    int deviceCount = vecDevices.size();

    if (deviceCount <= 0) {
        System.out.println("No Devices Found .");
    } else {
        // print bluetooth device addresses and names in the format [ No.
        // address (name) ]
        System.out.println("Bluetooth Devices: ");
        for (int i = 0; i < deviceCount; i++) {
            RemoteDevice remoteDevice = (RemoteDevice) vecDevices
                    .elementAt(i);
            System.out.println((i + 1) + ". "
                    + remoteDevice.getBluetoothAddress() + " ("
                    + remoteDevice.getFriendlyName(false) + ")");
        }
    }

    // System.out.println("SR: " + sr.toString());
    for (String url : vecServices) {
        try {
            String url = sr
                    .getConnectionURL(
                            ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);
            StreamConnection conn = (StreamConnection) Connector.open(url, Connector.READ_WRITE);
            System.out.println(url + " ----=" + conn);
            DataInputStream din = new DataInputStream(
                    conn.openDataInputStream());
            synchronized (lock) {
                try {
                    lock.wait(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            while (din.available() != 0) {
                System.out.print(din.readChar());
            }
            System.out.println();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}// end main

// methods of DiscoveryListener

/**
 * This call back method will be called for each discovered bluetooth
 * devices.
 */
public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
    System.out.println("Device discovered: "
            + btDevice.getBluetoothAddress());
    // add the device to the vector
    if (!vecDevices.contains(btDevice)) {
        vecDevices.addElement(btDevice);
    }
}

// no need to implement this method since services are not being discovered
public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
    for (ServiceRecord sr : servRecord) {
        vecServices.add(sr.getConnectionURL(ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false));
    }
}

// no need to implement this method since services are not being discovered
public void serviceSearchCompleted(int transID, int respCode) {
    System.out.println("Service search completed - code: " + respCode);
    synchronized (lock) {
        lock.notify();
    }
}

/**
 * This callback method will be called when the device discovery is
 * completed.
 */
public void inquiryCompleted(int discType) {
    switch (discType) {
    case DiscoveryListener.INQUIRY_COMPLETED:
        System.out.println("INQUIRY_COMPLETED");
        break;

    case DiscoveryListener.INQUIRY_TERMINATED:
        System.out.println("INQUIRY_TERMINATED");
        break;

    case DiscoveryListener.INQUIRY_ERROR:
        System.out.println("INQUIRY_ERROR");
        break;

    default:
        System.out.println("Unknown Response Code");
        break;
    }
    synchronized (lock) {
        lock.notify();
    }
}// end method
}// end class

Android:

package com.mira.Bluetooth;

import java.io.IOException;

import java.util.UUID;

import android.app.Activity;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;

import android.os.Bundle;

import android.util.Log;

public class BluetoothAndroidActivity extends Activity implements Runnable {
    BluetoothServerSocket bss;
    Thread t;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        BluetoothAdapter bta = BluetoothAdapter.getDefaultAdapter();

        for (BluetoothDevice btd : bta.getBondedDevices()) {
            Log.i("Bluetooth Device Found",
                  btd.toString() + "; " + btd.getName());
        }

        try {
            bss =
bta.listenUsingRfcommWithServiceRecord("BluetoothChat", UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66"));
            t = new Thread(this);
            t.start();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        boolean bContinue = true;
        while (bContinue) {
            try {
                Thread.sleep(100);
            } catch (Exception e) {

            }

            try {
                System.out.println("Listening for connection");
                BluetoothSocket bs = bss.accept();
                System.out.println("Connection received");
                bs.getOutputStream().write("Hello BlueTooth World".getBytes());
                bs.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                bContinue = false;
            }
        }
    }

    /*
 * (non-Javadoc)
 *
 * @see android.app.Activity#onDestroy()
 */

    @Override
    protected void onStop() {
        try {
            System.out.println("Killing ServerSocket");
            bss.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        super.onStop();
    }
}

Answer 1

Bit of an update after a long time – turns out, bluetooth requires UUID’s to take the form “0000xxxx00001000800000805f9b34fb”, which does beg the question of why not just use 16 bit identifiers rather than 128 bit UUIDs, but never mind.

I don’t know if BlueCove works with this on my laptop, but my recent experiments on my laptop with Linux and ‘Bluez’ suggest any UUID of that form works. Android maybe should include that in their documents as a note of some sort.