How to find the active Bluetooth Devices and Services Using J2ME

Using the following code you can start bluetooth connection in your mobile. This
will register the service(UUID) while starting the bluetooth
connection. You can find the active bluetooth devices near to your mobile which
has registered same service(UUID) and you can connect with them.
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.io.*;
import javax.bluetooth.*;
import java.util.*;
/**
* @author test
*/
public class Blue extends MIDlet implements CommandListener,DiscoveryListener {
private List activeDevices;
private List activeServices;
private Command select,exit;
private Display display;
private LocalDevice local=null;
private DiscoveryAgent agent = null;
private Vector devicesFound = null;
private ServiceRecord[] servicesFound = null;
private String connectionURL = null;
public void startApp() {
display = Display.getDisplay(this);
activeDevices = new List("Active Devices", List.IMPLICIT);
activeServices = new List("Active Services", List.IMPLICIT);
select = new Command("Select", Command.OK, 0);
exit = new Command("Exit", Command.EXIT, 0);
activeDevices.addCommand(exit);
activeServices.addCommand(exit);
activeDevices.setCommandListener(this);
activeServices.setCommandListener(this);
try {
local = LocalDevice.getLocalDevice();
} catch (Exception e) {
}
doDeviceDiscovery();
display.setCurrent(activeDevices);
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
notifyDestroyed();
}
public void commandAction(Command cmd, Displayable disp) {
if (cmd == select && disp == activeDevices) {
int device = activeDevices.getSelectedIndex();
doServiceSearch((RemoteDevice) devicesFound.elementAt(device))
;

display.setCurrent(activeServices);
//doServiceSearch( (RemoteDevice)devicesFound.firstElement());
}
if (cmd == select && disp == activeServices) {
int service = activeServices.getSelectedIndex();
connectionURL = servicesFound[service].getConnectionURL(0, fal
se);
try {
StreamConnection sc = (StreamConnection) Connector.open(
connectionURL);
OutputStream outStream = connection.openOutputStream();
PrintWriter pWriter = new PrintWriter(new OutputStreamWr
iter(outStream));
pWriter.write("Response String from SPP Server\r\n");
pWriter.flush();
pWriter.close();
} catch (Exception e) {
Alert alert = new Alert("");
alert.setString(e.toString());
display.setCurrent(alert);
}
}
if (cmd == exit) {
destroyApp(false);
}
}
public void inquiryCompleted(int param) {
switch (param) {
case DiscoveryListener.INQUIRY_COMPLETED:
/* Inquiry completed normally, add appropriate code
* here
*/
if (devicesFound.size() > 0) {
activeDevices.addCommand(select);
activeDevices.setSelectCommand(select);
} else {
try {
activeDevices.append("No Devices Found", nul
l);
startServer();
} catch (Exception e) {
}
}
break;
case DiscoveryListener.INQUIRY_ERROR:
// Error during inquiry, add appropriate code here.
break;
case DiscoveryListener.INQUIRY_TERMINATED:
/* Inquiry terminated by agent.cancelInquiry()
* Add appropriate code here.
*/
break;
}
}
public void serviceSearchCompleted(int transID, int respCode) {
switch (respCode) {
case DiscoveryListener.SERVICE_SEARCH_COMPLETED:

break;
case DiscoveryListener.SERVICE_SEARCH_DEVICE_NOT_REACHABLE:
break;
case DiscoveryListener.SERVICE_SEARCH_ERROR:
break;
case DiscoveryListener.SERVICE_SEARCH_NO_RECORDS:
break;
case DiscoveryListener.SERVICE_SEARCH_TERMINATED:
break;
}
}
public void servicesDiscovered(int transID, ServiceRecord[] serviceRecord)
{
servicesFound = serviceRecord;
activeServices.append(servicesFound.toString(), null);
activeServices.addCommand(select);
activeServices.setSelectCommand(select);
}
public void deviceDiscovered(RemoteDevice remoteDevice, DeviceClass device
Class) {
String str = null;
try {
str = remoteDevice.getFriendlyName(true);
} catch (Exception e) {
}
activeDevices.append(str, null);
devicesFound.addElement(remoteDevice);
}
private void doDeviceDiscovery() {
try {
local = LocalDevice.getLocalDevice();
} catch (BluetoothStateException bse) {
// Error handling code here
}
agent = local.getDiscoveryAgent();
devicesFound = new Vector();
try {
if (!agent.startInquiry(DiscoveryAgent.GIAC, this)) {
// Inquiry not started, error handling code here
}
} catch (BluetoothStateException bse) {
// Error handling code here
}
}
private void doServiceSearch(RemoteDevice device) {
int[] attributes = {0x100, 0x101, 0x102};
UUID[] uuids = new UUID[1];
uuids[0] = new UUID("1101", false);
try {
agent.searchServices(attributes, uuids, device, this);
} catch (BluetoothStateException e) {
Alert alert1 = new Alert("Error");
alert1.setString(e.toString());
display.setCurrent(alert1);
}
}

public void startServer() throws IOException {

UUID uuid = new UUID("1101", false);
//Create the service url
String connectionString = "btspp://localhost:" + uuid + ";name=xyz";
//open server url
StreamConnectionNotifier streamConnNotifier = (StreamConnectionNotif
ier) Connector.open(connectionString);
//Wait for client connection
System.out.println("\nServer Started. Waiting for clients to connect
...");
StreamConnection connection = streamConnNotifier.acceptAndOpen();
RemoteDevice dev = RemoteDevice.getRemoteDevice(connection);
System.out.println("Remote device address: " + dev.getBluetoothAddre
ss());
System.out.println("Remote device name: " + dev.getFriendlyName(true
));
//read string from spp client
try {
DataInputStream in = (DataInputStream) connection.openDataInpu
tStream();
/*BufferedReader bReader=new BufferedReader(new InputStreamRea
der(inStream));
String lineRead=bReader.readLine();
System.out.println(lineRead);*/
/*//send response to spp client
OutputStream outStream=connection.openOutputStream();
PrintWriter pWriter=new PrintWriter(new OutputStreamWriter(out
Stream));
pWriter.write("Response String from SPP Server\r\n");
pWriter.flush();
pWriter.close();*/
streamConnNotifier.close();
}
}