JSR-82 : Java Bluetooth http://www.jsr82.com Articles, Tutorials and Discussion Forums about Java Bluetooth Programming and JSR-82 Bluetooth API Wed, 31 Oct 2007 03:35:35 +0000 http://wordpress.org/?v=2.9 en hourly 1 jsr82http://feedburner.google.com JSR-82 Sample : SPP Server and Client http://www.jsr82.com/jsr-82-sample-spp-server-and-client/ http://www.jsr82.com/jsr-82-sample-spp-server-and-client/#comments Wed, 31 Oct 2007 02:57:30 +0000 Bruse http://www.jsr82.com/jsr-82-sample-spp-server-and-client/ This article will teach you how to develop bluetooth server and client application and communicate each other using it. We will learn how to develop an SPP Server and an SPP client using JSR 82 API.


SPP Server

Any Java Bluetooth service initialization consists of the following steps

  • Constructing the connection URL.

    • The connection URL consists of the protocol identifier, the UUID of the the service, and other optional attributes. Since we are creating an SPP service, the protocol identifier will be "btspp". The UUID for the SPP service is defined to be 1101. This step is realized by the following code

    PLAIN TEXT
    1. //Create a UUID for SPP
    2. UUID uuid = new UUID("1101", true);
    3. //Create the servicve url
    4. String connectionString = "btspp://localhost:" + uuid +";name=Sample SPP Server";

  • Registering service and Waiting for Client connection.

    • The next step is to register for the service and to wait for client connection. This step is achieved by the following codes

    PLAIN TEXT
    1. //open server url
    2. StreamConnectionNotifier streamConnNotifier = (StreamConnectionNotifier)Connector.open( connectionString );
    3. //Wait for client connection
    4. StreamConnection connection=streamConnNotifier.acceptAndOpen ();

    The acceptAndOpen method waits until a client is connected.

  • Communicate with the client

    • Once a client is connected, use the returned 'Connection' object to open the input and output streams with the client. Now we have a stream connection with a remote bluetooth device, that can be used to develop your application.

SPP Client

Writing a client in JSR 82 is very easy. It consists of the following steps

  • Finding the connection URL to the service.

    • If you already knew the direct url to the server, this step can be skipped. This consist of searching for a service, and getting its connection URL. More details about this can be learned from the article about bluetooth service search

  • Connect to server

    • Once we know the connection url, simply connect with the server using the "Connector.open" and open the input/output streams from the created 'Connection' object. The rest is up to your logic to build your applpication based on this connection

    The complete code for a simple SPP Server that accepts an SPP connection and reads a single line and writes a single line back is given below. The source code for an SPP client that connects with the server and sends a single line is also given. For this sample to work, you need a JSR-82 Implmentation (Java Bluetooth Stack) like ElectricBlue in the class path

SPP Server Source Code

PLAIN TEXT
  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.InputStreamReader;
  5. import java.io.OutputStream;
  6. import java.io.OutputStreamWriter;
  7. import java.io.PrintWriter;
  8.  
  9. import javax.bluetooth.*;
  10. import javax.microedition.io.*;
  11.  
  12. /**
  13. * Class that implements an SPP Server which accepts single line of
  14. * message from an SPP client and sends a single line of response to the client.
  15. */
  16. public class SampleSPPServer {
  17.    
  18.     //start server
  19.     private void startServer() throws IOException{
  20.  
  21.         //Create a UUID for SPP
  22.         UUID uuid = new UUID("1101", true);
  23.         //Create the servicve url
  24.         String connectionString = "btspp://localhost:" + uuid +";name=Sample SPP Server";
  25.        
  26.         //open server url
  27.         StreamConnectionNotifier streamConnNotifier = (StreamConnectionNotifier)Connector.open( connectionString );
  28.        
  29.         //Wait for client connection
  30.         System.out.println("\nServer Started. Waiting for clients to connect...");
  31.         StreamConnection connection=streamConnNotifier.acceptAndOpen();
  32.  
  33.         RemoteDevice dev = RemoteDevice.getRemoteDevice(connection);
  34.         System.out.println("Remote device address: "+dev.getBluetoothAddress());
  35.         System.out.println("Remote device name: "+dev.getFriendlyName(true));
  36.        
  37.         //read string from spp client
  38.         InputStream inStream=connection.openInputStream();
  39.         BufferedReader bReader=new BufferedReader(new InputStreamReader(inStream));
  40.         String lineRead=bReader.readLine();
  41.         System.out.println(lineRead);
  42.        
  43.         //send response to spp client
  44.         OutputStream outStream=connection.openOutputStream();
  45.         PrintWriter pWriter=new PrintWriter(new OutputStreamWriter(outStream));
  46.         pWriter.write("Response String from SPP Server\r\n");
  47.         pWriter.flush();
  48.  
  49.         pWriter.close();
  50.         streamConnNotifier.close();
  51.  
  52.     }
  53.  
  54.  
  55.     public static void main(String[] args) throws IOException {
  56.        
  57.         //display local device address and name
  58.         LocalDevice localDevice = LocalDevice.getLocalDevice();
  59.         System.out.println("Address: "+localDevice.getBluetoothAddress());
  60.         System.out.println("Name: "+localDevice.getFriendlyName());
  61.        
  62.         SampleSPPServer sampleSPPServer=new SampleSPPServer();
  63.         sampleSPPServer.startServer();
  64.        
  65.     }
  66. }

SPP Client Source Code

PLAIN TEXT
  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.InputStreamReader;
  5. import java.io.OutputStream;
  6. import java.io.OutputStreamWriter;
  7. import java.io.PrintWriter;
  8. import java.util.Vector;
  9.  
  10. import javax.bluetooth.DeviceClass;
  11. import javax.bluetooth.DiscoveryAgent;
  12. import javax.bluetooth.DiscoveryListener;
  13. import javax.bluetooth.LocalDevice;
  14. import javax.bluetooth.RemoteDevice;
  15. import javax.bluetooth.ServiceRecord;
  16. import javax.bluetooth.UUID;
  17. import javax.microedition.io.Connector;
  18. import javax.microedition.io.StreamConnection;
  19.  
  20. /**
  21. * A simple SPP client that connects with an SPP server
  22. */
  23. public class SampleSPPClient implements DiscoveryListener{
  24.    
  25.     //object used for waiting
  26.     private static Object lock=new Object();
  27.    
  28.     //vector containing the devices discovered
  29.     private static Vector vecDevices=new Vector();
  30.    
  31.     private static String connectionURL=null;
  32.  
  33.     public static void main(String[] args) throws IOException {
  34.        
  35.         SampleSPPClient client=new SampleSPPClient();
  36.        
  37.         //display local device address and name
  38.         LocalDevice localDevice = LocalDevice.getLocalDevice();
  39.         System.out.println("Address: "+localDevice.getBluetoothAddress());
  40.         System.out.println("Name: "+localDevice.getFriendlyName());
  41.        
  42.         //find devices
  43.         DiscoveryAgent agent = localDevice.getDiscoveryAgent();
  44.       
  45.         System.out.println("Starting device inquiry...");
  46.         agent.startInquiry(DiscoveryAgent.GIAC, client);
  47.        
  48.         try {
  49.             synchronized(lock){
  50.                 lock.wait();
  51.             }
  52.         }
  53.         catch (InterruptedException e) {
  54.             e.printStackTrace();
  55.         }
  56.        
  57.        
  58.         System.out.println("Device Inquiry Completed. ");
  59.        
  60.         //print all devices in vecDevices
  61.         int deviceCount=vecDevices.size();
  62.        
  63.         if(deviceCount <= 0){
  64.             System.out.println("No Devices Found .");
  65.             System.exit(0);
  66.         }
  67.         else{
  68.             //print bluetooth device addresses and names in the format [ No. address (name) ]
  69.             System.out.println("Bluetooth Devices: ");
  70.             for (int i = 0; i <deviceCount; i++) {
  71.                 RemoteDevice remoteDevice=(RemoteDevice)vecDevices.elementAt(i);
  72.                 System.out.println((i+1)+". "+remoteDevice.getBluetoothAddress()+" ("+remoteDevice.getFriendlyName(true)+")");
  73.             }
  74.         }
  75.        
  76.         System.out.print("Choose Device index: ");
  77.         BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
  78.        
  79.         String chosenIndex=bReader.readLine();
  80.         int index=Integer.parseInt(chosenIndex.trim());
  81.        
  82.         //check for spp service
  83.         RemoteDevice remoteDevice=(RemoteDevice)vecDevices.elementAt(index-1);
  84.         UUID[] uuidSet = new UUID[1];
  85.         uuidSet[0]=new UUID("1101",false);
  86.        
  87.         System.out.println("\nSearching for service...");
  88.         agent.searchServices(null,uuidSet,remoteDevice,client);
  89.        
  90.         try {
  91.             synchronized(lock){
  92.                 lock.wait();
  93.             }
  94.         }
  95.         catch (InterruptedException e) {
  96.             e.printStackTrace();
  97.         }
  98.        
  99.         if(connectionURL==null){
  100.             System.out.println("Device does not support Simple SPP Service.");
  101.             System.exit(0);
  102.         }
  103.        
  104.         //connect to the server and send a line of text
  105.         StreamConnection streamConnection=(StreamConnection)Connector.open(connectionURL);
  106.        
  107.         //send string
  108.         OutputStream outStream=streamConnection.openOutputStream();
  109.         PrintWriter pWriter=new PrintWriter(new OutputStreamWriter(outStream));
  110.         pWriter.write("Test String from SPP Client\r\n");
  111.         pWriter.flush();
  112.        
  113.        
  114.         //read response
  115.         InputStream inStream=streamConnection.openInputStream();
  116.         BufferedReader bReader2=new BufferedReader(new InputStreamReader(inStream));
  117.         String lineRead=bReader2.readLine();
  118.         System.out.println(lineRead);
  119.        
  120.                
  121.     }//main
  122.    
  123.     //methods of DiscoveryListener
  124.     public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
  125.         //add the device to the vector
  126.         if(!vecDevices.contains(btDevice)){
  127.             vecDevices.addElement(btDevice);
  128.         }
  129.     }
  130.  
  131.     //implement this method since services are not being discovered
  132.     public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
  133.         if(servRecord!=null && servRecord.length>0){
  134.             connectionURL=servRecord[0].getConnectionURL(0,false);
  135.         }
  136.         synchronized(lock){
  137.             lock.notify();
  138.         }
  139.     }
  140.  
  141.     //implement this method since services are not being discovered
  142.     public void serviceSearchCompleted(int transID, int respCode) {
  143.         synchronized(lock){
  144.             lock.notify();
  145.         }
  146.     }
  147.  
  148.    
  149.     public void inquiryCompleted(int discType) {
  150.         synchronized(lock){
  151.             lock.notify();
  152.         }
  153.        
  154.     }//end method
  155.    
  156.    
  157.    
  158. }

]]> http://www.jsr82.com/jsr-82-sample-spp-server-and-client/feed/ 59 JSR-82 Sample : Bluetooth Service Search http://www.jsr82.com/jsr-82-sample-bluetooth-service-search/ http://www.jsr82.com/jsr-82-sample-bluetooth-service-search/#comments Mon, 14 May 2007 02:16:25 +0000 Bruse http://www.jsr82.com/jsr-82-sample-bluetooth-service-search/ In the last article we found how to search for other bluetooth devices. Here we look in to how search for a service on a particular bluetooth device.

The following code sample shows you how to use the DiscoveryAgent to search for an OBEX Push bluetooth service. It first searches for all available Bluetooth Devices, and prompts to select a device on which to search the OBEX Push Service.

For this sample to work, you need a JSR-82 Implmentation (Java Bluetooth Stack) like ElectricBlue or aveLink in the class path.

PLAIN TEXT
  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.util.Vector;
  5.  
  6. import javax.bluetooth.DeviceClass;
  7. import javax.bluetooth.DiscoveryAgent;
  8. import javax.bluetooth.DiscoveryListener;
  9. import javax.bluetooth.LocalDevice;
  10. import javax.bluetooth.RemoteDevice;
  11. import javax.bluetooth.ServiceRecord;
  12. import javax.bluetooth.UUID;
  13.  
  14. /**
  15. *
  16. * Class that discovers all bluetooth devices in the neighbourhood,
  17. *
  18. * Connects to the chosen device and checks for the presence of OBEX push service in it.
  19. * and displays their name and bluetooth address.
  20. *
  21. *
  22. */
  23. public class BluetoothServiceDiscovery implements DiscoveryListener{
  24.    
  25.     //object used for waiting
  26.     private static Object lock=new Object();
  27.        
  28.     //vector containing the devices discovered
  29.     private static Vector vecDevices=new Vector();
  30.    
  31.     private static String connectionURL=null;
  32.  
  33.    
  34.     /**
  35.      * Entry point.
  36.      */
  37.     public static void main(String[] args) throws IOException {
  38.        
  39.         BluetoothServiceDiscovery bluetoothServiceDiscovery=new BluetoothServiceDiscovery();
  40.        
  41.         //display local device address and name
  42.         LocalDevice localDevice = LocalDevice.getLocalDevice();
  43.         System.out.println("Address: "+localDevice.getBluetoothAddress());
  44.         System.out.println("Name: "+localDevice.getFriendlyName());
  45.        
  46.         //find devices
  47.         DiscoveryAgent agent = localDevice.getDiscoveryAgent();
  48.       
  49.         System.out.println("Starting device inquiry...");
  50.         agent.startInquiry(DiscoveryAgent.GIAC, bluetoothServiceDiscovery);
  51.        
  52.         try {
  53.             synchronized(lock){
  54.                 lock.wait();
  55.             }
  56.         }
  57.         catch (InterruptedException e) {
  58.             e.printStackTrace();
  59.         }
  60.        
  61.        
  62.         System.out.println("Device Inquiry Completed. ");
  63.        
  64.         //print all devices in vecDevices
  65.         int deviceCount=vecDevices.size();
  66.        
  67.         if(deviceCount <= 0){
  68.             System.out.println("No Devices Found .");
  69.         }
  70.         else{
  71.             //print bluetooth device addresses and names in the format [ No. address (name) ]
  72.             System.out.println("Bluetooth Devices: ");
  73.             for (int i = 0; i <deviceCount; i++) {
  74.                 RemoteDevice remoteDevice=(RemoteDevice)vecDevices.elementAt(i);
  75.                 System.out.println((i+1)+". "+remoteDevice.getBluetoothAddress()+" ("+remoteDevice.getFriendlyName(true)+")");
  76.             }
  77.         }
  78.        
  79.         System.out.print("Choose the device to search for Obex Push service : ");
  80.         BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
  81.        
  82.         String chosenIndex=bReader.readLine();
  83.         int index=Integer.parseInt(chosenIndex.trim());
  84.        
  85.         //check for obex service
  86.         RemoteDevice remoteDevice=(RemoteDevice)vecDevices.elementAt(index-1);
  87.         UUID[] uuidSet = new UUID[1];
  88.         uuidSet[0]=new UUID("1105",true);
  89.        
  90.         System.out.println("\nSearching for service...");
  91.         agent.searchServices(null,uuidSet,remoteDevice,bluetoothServiceDiscovery);
  92.        
  93.         try {
  94.             synchronized(lock){
  95.                 lock.wait();
  96.             }
  97.         }
  98.         catch (InterruptedException e) {
  99.             e.printStackTrace();
  100.         }
  101.        
  102.         if(connectionURL==null){
  103.             System.out.println("Device does not support Object Push.");
  104.         }
  105.         else{
  106.             System.out.println("Device supports Object Push.");
  107.         }
  108.     }
  109.    
  110.    
  111.     /**
  112.      * Called when a bluetooth device is discovered.
  113.      * Used for device search.
  114.      */
  115.     public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
  116.         //add the device to the vector
  117.         if(!vecDevices.contains(btDevice)){
  118.             vecDevices.addElement(btDevice);
  119.         }
  120.     }
  121.  
  122.    
  123.     /**
  124.      * Called when a bluetooth service is discovered.
  125.      * Used for service search.
  126.      */
  127.     public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
  128.         if(servRecord!=null && servRecord.length>0){
  129.             connectionURL=servRecord[0].getConnectionURL(0,false);
  130.         }
  131.         synchronized(lock){
  132.             lock.notify();
  133.         }
  134.     }
  135.  
  136.    
  137.     /**
  138.      * Called when the service search is over.
  139.      */
  140.     public void serviceSearchCompleted(int transID, int respCode) {
  141.         synchronized(lock){
  142.             lock.notify();
  143.         }
  144.     }
  145.  
  146.  
  147.     /**
  148.      * Called when the device search is over.
  149.      */
  150.     public void inquiryCompleted(int discType) {
  151.         synchronized(lock){
  152.             lock.notify();
  153.         }
  154.        
  155.     }//end method
  156.    
  157.    
  158. }//end class

]]> http://www.jsr82.com/jsr-82-sample-bluetooth-service-search/feed/ 17 JSR-82 Sample : Device Discovery http://www.jsr82.com/jsr-82-sample-device-discovery/ http://www.jsr82.com/jsr-82-sample-device-discovery/#comments Thu, 26 Apr 2007 19:51:40 +0000 Bruse http://www.jsr82.com/jsr-82-sample-device-discovery/ This article provides Java sample codes to search for Bluetooth devices using a JSR-82 API. If you are new to JSR-82, we recommend you to read the JSR-82 Basics tutorial to get a basic idea Java and Bluetooth.

JSR-82 provides the class DiscoveryAgent for performing Device Discovery and Service Discovery. The LocalDevice class provides a factory method 'getDiscoveryAgent' that returns a singleton instance of the DiscoveryAgent. This instance can then be used to discover other bluetooth devices and services.

The following code sample shows you how to use the DiscoveryAgent to discover other bluetooth devices. For this sample to work, you need a JSR-82 Implmentation (Java Bluetooth Stack) like ElectricBlue or aveLink in the classpath.



BluetoothDeviceDiscovery.java

PLAIN TEXT
  1. import java.io.IOException;
  2. import java.util.Vector;
  3.  
  4. import javax.bluetooth.DeviceClass;
  5. import javax.bluetooth.DiscoveryAgent;
  6. import javax.bluetooth.DiscoveryListener;
  7. import javax.bluetooth.LocalDevice;
  8. import javax.bluetooth.RemoteDevice;
  9. import javax.bluetooth.ServiceRecord;
  10.  
  11.  
  12. /**
  13. * Class that discovers all bluetooth devices in the neighbourhood
  14. * and displays their name and bluetooth address.
  15. */
  16. public class BluetoothDeviceDiscovery implements DiscoveryListener{
  17.    
  18.    
  19.     //object used for waiting
  20.     private static Object lock=new Object();
  21.    
  22.     //vector containing the devices discovered
  23.     private static Vector vecDevices=new Vector();
  24.    
  25.    
  26.     //main method of the application
  27.     public static void main(String[] args) throws IOException {
  28.        
  29.         //create an instance of this class
  30.         BluetoothDeviceDiscovery bluetoothDeviceDiscovery=new BluetoothDeviceDiscovery();
  31.        
  32.         //display local device address and name
  33.         LocalDevice localDevice = LocalDevice.getLocalDevice();
  34.         System.out.println("Address: "+localDevice.getBluetoothAddress());
  35.         System.out.println("Name: "+localDevice.getFriendlyName());
  36.        
  37.         //find devices
  38.         DiscoveryAgent agent = localDevice.getDiscoveryAgent();
  39.       
  40.         System.out.println("Starting device inquiry...");
  41.         agent.startInquiry(DiscoveryAgent.GIAC, bluetoothDeviceDiscovery);
  42.        
  43.         try {
  44.             synchronized(lock){
  45.                 lock.wait();
  46.             }
  47.         }
  48.         catch (InterruptedException e) {
  49.             e.printStackTrace();
  50.         }
  51.        
  52.        
  53.         System.out.println("Device Inquiry Completed. ");
  54.        
  55.         //print all devices in vecDevices
  56.         int deviceCount=vecDevices.size();
  57.        
  58.         if(deviceCount <= 0){
  59.             System.out.println("No Devices Found .");
  60.         }
  61.         else{
  62.             //print bluetooth device addresses and names in the format [ No. address (name) ]
  63.             System.out.println("Bluetooth Devices: ");
  64.             for (int i = 0; i <deviceCount; i++) {
  65.                 RemoteDevice remoteDevice=(RemoteDevice)vecDevices.elementAt(i);
  66.                 System.out.println((i+1)+". "+remoteDevice.getBluetoothAddress()+" ("+remoteDevice.getFriendlyName(true)+")");
  67.             }
  68.         }
  69.        
  70.        
  71.     }//end main
  72.  
  73.     //methods of DiscoveryListener
  74.    
  75.     /**
  76.      * This call back method will be called for each discovered bluetooth devices.
  77.      */
  78.     public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
  79.         System.out.println("Device discovered: "+btDevice.getBluetoothAddress());
  80.         //add the device to the vector
  81.         if(!vecDevices.contains(btDevice)){
  82.             vecDevices.addElement(btDevice);
  83.         }
  84.     }
  85.  
  86.     //no need to implement this method since services are not being discovered
  87.     public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
  88.     }
  89.  
  90.     //no need to implement this method since services are not being discovered
  91.     public void serviceSearchCompleted(int transID, int respCode) {
  92.     }
  93.  
  94.    
  95.     /**
  96.      * This callback method will be called when the device discovery is
  97.      * completed.
  98.      */
  99.     public void inquiryCompleted(int discType) {
  100.         synchronized(lock){
  101.             lock.notify();
  102.         }
  103.        
  104.         switch (discType) {
  105.             case DiscoveryListener.INQUIRY_COMPLETED :
  106.                 System.out.println("INQUIRY_COMPLETED");
  107.                 break;
  108.                
  109.             case DiscoveryListener.INQUIRY_TERMINATED :
  110.                 System.out.println("INQUIRY_TERMINATED");
  111.                 break;
  112.                
  113.             case DiscoveryListener.INQUIRY_ERROR :
  114.                 System.out.println("INQUIRY_ERROR");
  115.                 break;
  116.  
  117.             default :
  118.                 System.out.println("Unknown Response Code");
  119.                 break;
  120.         }
  121.     }//end method
  122. }//end class

]]> http://www.jsr82.com/jsr-82-sample-device-discovery/feed/ 21 JSR-82 Initialization : LocalDevice http://www.jsr82.com/jsr-82-initialization-localdevice/ http://www.jsr82.com/jsr-82-initialization-localdevice/#comments Sun, 08 Apr 2007 17:26:41 +0000 Mark http://www.jsr82.com/jsr-82-initialization-localdevice/ LocalDevice class can be considered as the basic entry point to the JSR-82 API. It is used to initialize the JSR-82 stack, and to control the local bluetooth settings. If you are new to JSR-82, check out the JSR-82 Basics tutorial before reading this. JSR 82 API can be broadly classified into the following sections.

  • a. LocalDevice Settings Manipulation
  • Device Discovery
  • Service Discovery
  • Service Registration
  • L2CAP
  • SPP
  • GOEP
  • BCC

Out of these sections ,the LocalDevice class provides the lowest level of access to the bluetooth stack. There is also another part that can more or less be counted among the lowest layers of JSR82 : the Bluetooth Control Center or the BCC. This part is implementation specific and has no standard APIs. Each vendor can expose their own required APIs which they think is appropriate for their JSR82 implementation. In this article we will look in to LocalDevice and how it can be used to manipulate the Local Bluetooth Device settings.


The class LocalDevice represents the local bluetooth device. The actual bluetooth device could be a built-in bluetooth chip in the case of latest bluetooth enabled laptops and mobiles or it could be a USB or UART interface attached to a PC. No matter whatever shape or form the device takes it can be manipulated using the methods of class LocalDevice.

Local Device Methods

public static LocalDevice getLocalDevice()

The LocalDevice class produces a singleton object. i.e. At any instance there's only one instance of the class in the VM. Hence applications cannot directly instantiate this class. To obtain an instance of this class application has to invoke the method getLocalDevice(). Multiple calls to this method will return the same object. This object can be used to invoke other methods of this class. In effect, this method is the entry point to a JSR-82 API, and initializes the underlying JSR-82 bluetooth stack.

public java.lang.String getBluetoothAddress()

This method returns the unique address of the local bluetooth device as a String.

Each bluetooth device has a 48-bit or 6-byte value which is termed as the device's bluetooth address. This is the unique value that differentiates one bluetooth device from the other. So if you and your friend each have a bluetooth enabled mobile, then the device addresses of these 2 mobiles will be different. The address will look somewhat like this. 00:55:34:A6:56:89

The ':' used to separate each byte, and is not part of the address. This is usually used to present the address in a readable form.

public java.lang.String getFriendlyName()

This method returns the friendly name of the local bluetooth device.

Though the bluetooth address can be used to identify a bluetooth device it's not always so easy to remember the 6 byte addresses. Unlike computers human users are not so good with numbers, especially big ones. So to make the task of recognizing a device easier to a human user, each device can be assigned a user friendly name. This is a String and can be set to any value.

public DeviceClass getDeviceClass()

This method returns the class of the local bluetooth device as an Object of DeviceClass. The class DeviceClass has methods to retrieve the major device class, minor device class and service classes of the device.

Each bluetooth device has a device class or (Class of Device, CoD as specified by the bluetooth spec). This field stores information about the type of device and which types of service are supported by the device. For example if the bluetooth deviec is a mobile then in the device class field the particular bit representing mobile should be set. Likewise for services like Imaging or Rendering the respective bits should be set in the CoD field.

Discoverability

Bluetooth devices usually have some way to discover all other neighbouring bluetooth devices within range. But in some cases the device user might wish to hide his device from other searching devices. This is just like logging in to an instance messenger and making ourselves invisible. The hidden device itself can see all other bluetooth devices (that are not hidden) and can perform bluetooth operations but the only difference is that, it will be invisible in the bluetooth network. Later on when the device user wishes to make it visible he can make the device discoverable so that it again becomes visible in the bluetooth network.

Related Methods:

public boolean setDiscoverable(int mode)

This method can be used to make the device visible/invisible. Infact this method sets the discoverable mode of the device. Valid modes are DiscoveryAgent.GIAC, DiscoveryAgent.LIAC, DiscoveryAgent.NOT_DISCOVERABLE.

public int getDiscoverable()

This method returns the current mode of the bluetooth device.

Device Properties

public static java.lang.String getProperty(java.lang.String property)

The local bluetooth device is associated with some properties which specifies the features the device supports and also some specific values related to the features. All these can be retreived by the application running above jsr82.

Device Search

public DiscoveryAgent getDiscoveryAgent()

It has been mentioned earlier that bluetooth devices can search for other bluetooth devices in it's neighbourhood. Once a device is found, it can be searched for specific services. All this is made possible by the class DiscoveryAgent. This class exports methods to search for both bluetooth devices and services. A localdevice can have only one instance of discovery agent and this is retreived using the above method.

Local Service Database

Each bluetooth device has a service database in which it can register services so as to allow other bluetooth devices to use them. The details of each registered service is kept as an object of class ServiceRecord. The process of creating and registering services will be discussed in a later article. For the time being we'll examine the ways in which local device's service records can be manipulated.

Each service record is associated with a Notifier object that registers it. In JSR82 there are notifiers for L2CAP, SPP and GOEP. To retrieve a service record corresponding to a service, the notifier that registered the record is necessary. Once the service record is fetched from the local service database it can be updated with the new values and the modified record can be added to the service database.

Related Methods:

a. public ServiceRecord getRecord(javax.microedition.io.Connection notifier)

This method gets the service record corresponding to a btspp, btl2cap, or btgoep notifier.

b. public void updateRecord(ServiceRecord srvRecord) throws ServiceRegistrationException

Updates the service record in the local SDDB that corresponds to the ServiceRecord parameter. Updating is possible only if srvRecord was obtained using the getRecord() method.

These are the operations that can be performed using the LocalDevice.

]]> http://www.jsr82.com/jsr-82-initialization-localdevice/feed/ 6 Simulating JABWT applications using JSR-82 Simulators http://www.jsr82.com/simulating-jabwt-applications-using-jsr-82-simulators/ http://www.jsr82.com/simulating-jabwt-applications-using-jsr-82-simulators/#comments Fri, 30 Mar 2007 16:17:56 +0000 Bruse http://www.jsr82.com/simulating-jabwt-applications-using-jsr-82-simulators/ Any one who is developing JSR-82 based application hopes for an easy JSR-82 simulator over which they can test their applications.Testing on actual devices can be very time consuming, and may not be feasible in every circumstances. JSR-82 simulators mimic the real Bluetooth environment, providing a way for the Java Bluetooth developers to test their JSR-82 based application effortlessly, without the need of the actual Bluetooth device.

The major JSR-82 simulators available today are Java Wireless Toolkit from Sun, BlueSim from JSRSoft and Impronto from Rococo. Java Wireless Toolkit is a simulator for a wide range of J2ME based API’s, and hence is the biggest to download, and the toughest to configure. It allows only J2ME based simulations, and is not platform independent. BlueSim and Impronto are both platform independent and supports J2SE and J2ME.

In this article we review BlueSim and list its important features, which any good JSR-82 simulators should provide. The features that BlueSim JSR-82 Simulator provides to a Java Bluetooth developer are given below.

  • Simulated Environment. No Bluetooth Device needed.

Don’t have a Bluetooth device to test your JSR-82 based application? Don’t worry. Just use a JSR-82 Simulator. A proper JSR-82 simulator simulates the Bluetooth environment completely, enabling you to test your JSR-82 applications over it.

  • Simple Configuration.

There is nothing much to configure when using the BlueSim simulator. All you have to do is specify the Bluetooth device address, and device name. Even these have default values.A good simulator should be easily configurable.

  • 100% Pure Java

It is a desirable that the simulator be developed in pure java, so that it can be run on any platform.

  • J2ME/J2SE support

Another most desirable feature of a JSR-82 simulator is that it should support both J2ME and J2SE based development. The simulator should not limit the development environment to J2ME or J2SE alone. In the ideal case, you should be able to develop and test your J2SE or J2ME based JSR-82 application by just providing the JSR-82 simulator jar in the class path.

  • 100% JSR-82 Compliant

What use does it have, if the simulator is not in full compliance with the specification? A proper simulation should comply with the specification completely. I.e. it should provide both javax.bluetooth and javax.obex packages.

  • Multiple Instance Support

The JSR-82 simulator should support multiple instances that recognize each other. This means the JABWT developer should be able to test different instances of applications running concurrently and communicating with each other. I.e. you can test both a bluetooth client and a server as two separate instances.

  • Intranet Support

A very important and desirable feature found in BlueSim JSR-82 Simulator is that it allows you to run multiple instances even on different machines. All simulator instances running on the same internal network discovers each other automatically. Each simulator instance simulates a Bluetooth device, and each of these simulated Bluetooth devices can search and find each other, and their services.This in effect is simulating the wireless Bluetooth environment with your local wired intranet.

In short JSR-82 Simulators makes development and testing of JABWT applications effortless and much efficient. In addition to these excellent features provided by JSR-82 simulators, the fact that they cost very less, and some times even free makes them one of the must have tools of any JABWT application developer.

]]> http://www.jsr82.com/simulating-jabwt-applications-using-jsr-82-simulators/feed/ 2 JSR-82 Basics http://www.jsr82.com/jsr-82-basics/ http://www.jsr82.com/jsr-82-basics/#comments Thu, 29 Mar 2007 03:02:19 +0000 Mark http://www.jsr82.com/jsr-82-basics/ This is the first part of the tutorial covering the basics of JSR-82.

What is JSR-82?

JSR-82 is a standard defined by the Java Community Process for providing a standard to develop Bluetooth applications in Java. It is an open and non-proprietary standard for developing Bluetooth applications. The JSR-82 API hides the complexity of the Bluetooth protocol stack, by exposing a simple set of Java API's. The JSR-82 specific can be downloaded from here.

Pre-Requisites

To develop a Bluetooth application in Java using the JSR-82, you need to have the following

  1. JSR-82 Compliant Bluetooth Stack.

    2. You need a JSR-82 Implementation to successfully develop and test a Java Bluetooth application. You either need to have a simulated enviorment like the Sun Java Wireless Toolkit, or a real Java Bluetooth Stack like ElectricBlue or Avelink. The simulator allows you to test the Bluetooth application in a simulated environment, with no access to real bluetooth device.

  2. Local Bluetooth Device.

    3. If you are using a simulator, this is not needed. But to test your application in real world over a java bluetooth stack, you need to have a bluetooth enabled system. This can either be a Bluetooth USB Dongle plugged in to your system, or the internal built in bluetooth device. The java application that you writes, runs over this bluetooth device, and this bluetooth device is called as the 'LocalDevice' in JSR-82.

Capabilities of JSR-82

What all applications can you develop using the JS-82? The JSR-82 API provides you the options to do the following

  1. Manage the Local Bluetooth Device settings.
  2. Discover other bluetooth devices in the neighborhood.
  3. Search for bluetooth devices on the discovered bluetooth devices.
  4. Connect to any of those bluetooth service and communicate with it.
  5. Register a bluetooth service on the Local Bluetooth Device, so that other bluetooth devices can connect to it.
  6. Manage and control the communication connections.
  7. Provide the security to all of the above options.

These are the properties and capabilities of JSR-82 in a nutshell. How you can develop application using the capabilities of the JSR-82 will be explained in the next section of this article.

]]> http://www.jsr82.com/jsr-82-basics/feed/ 14 15 Most Popular Phones with JSR-82 Bluetooth API http://www.jsr82.com/15-most-popular-phones-with-jsr-82-bluetooth-api/ http://www.jsr82.com/15-most-popular-phones-with-jsr-82-bluetooth-api/#comments Mon, 26 Mar 2007 19:09:07 +0000 Stuart http://www.jsr82.com/15-most-popular-phones-with-jsr-82-bluetooth-api/ As a Bluetooth Java developer which phone will you choose from the list of hundreds of available phones? There are many hundreds of phones to choose from, that comes with the Bluetooth and Java enabled on it. But for a Bluetooth Java developer, the most important requirement is the support of JSR-82 API.

Here we list the most popular 15 mobile phones that support the JSR-82 API, with the complete list of all the JSR's that each phone supports.

Sony Ericsson K750 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-184 Java 3D (Mascot Capsule® v3)
JSR-75 PIM
JSR-82 Bluetooth
JSR-120 WMA
JSR-135 MMAPI
JSR-185 JTWI R1
KDWP debug interface
Nokia UI API
Details
Review
Nokia N70 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-120 Wireless Messaging API
JSR-135 Mobile Media API
JSR-172 Web Services API
JSR-184 Mobile 3D Graphics API
JSR-185 JTWI
JSR-75 FileConnection and PIM API
JSR-82 Bluetooth API
Nokia UI API
Details
Review
Nokia N80 Bluetooth V1.2
CLDC 1.1
MIDP 2.0
JSR-135 Mobile Media API
JSR-172 Web Services API
JSR-177 Security and Trust Services API
JSR-179 Location API
JSR-180 SIP API
JSR-184 Mobile 3D Graphics API
JSR-185 JTWI
JSR-205 Wireless Messaging API
JSR-75 FileConnection and PIM API
JSR-82 Bluetooth API
Nokia UI API
Details
Review
Sony Ericsson K800 Bluetooth V2.0 with A2DP
CLDC 1.1
MIDP 2.0
JSR-120/205 Wireless Messaging 1.0 and 2.0 API's
JSR-135 Mobile Media API
JSR-185 Java Technology for the Wireless Industry
JSR-82 Java API for Bluetooth
JSR-75 PDA Optional Packages for J2ME Platform
JSR-172 Web Services
JSR-234 Advanced Multimedia Supplements (camera capabilities)
JSR-184 Mobile 3D Graphics API for Java ME
Mascot Capsule Micro3D Version 3
Details
Review
Sony Ericsson W800 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-184 Java 3D (Mascot Capsule® v3)
JSR-75 PIM
JSR-82 Bluetooth
JSR-120 WMA
JSR-135 MMAPI
JSR-185 JTWI R1
KDWP debug interface
Nokia UI API
Details
Review
Nokia N73 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-135 Mobile Media API
JSR-172 Web Services API
JSR-177 Security and Trust Services API
JSR-179 Location API
JSR-180 SIP API
JSR-184 Mobile 3D Graphics API
JSR-185 JTWI
JSR-205 Wireless Messaging API
JSR-75 FileConnection and PIM API
JSR-82 Bluetooth API
Nokia UI API
Details
Review
Nokia N95 Bluetooth V2.0 + EDR with A2DP
CLDC 1.1
MIDP 2.0
JSR-135 Mobile Media API
JSR-172 Web Services API
JSR-177 Security and Trust Services API
JSR-179 Location API
JSR-180 SIP API
JSR-184 Mobile 3D Graphics API
JSR-185 JTWI
JSR-205 Wireless Messaging API
JSR-226 Scalable 2D Vector Graphics API
JSR-234 Advanced Multimedia Supplements
JSR-75 FileConnection and PIM API
JSR-82 Bluetooth API
Nokia UI API
Details
Review
Sony Ericsson W810 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-120/205 Wireless Messaging API
JSR-135 Mobile Media API
JSR-185 Java Technology for the Wireless Industry
JSR-82 Java API for Bluetooth™
JSR-75 PDA Optional Packages J2ME Platform
JSR-172 Web Services
Details
Review
Nokia N91 Bluetooth V1.2
CLDC 1.1
MIDP 2.0
JSR-135 Mobile Media API
JSR-172 Web Services API
JSR-177 Security and Trust Services API
JSR-179 Location API
JSR-180 SIP API
JSR-184 Mobile 3D Graphics API
JSR-185 JTWI
JSR-205 Wireless Messaging API
JSR-75 FileConnection and PIM API
JSR-82 Bluetooth API
Nokia UI API
Details
Review
Nokia 6280 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-75 FileConnection and PIM API
JSR-184 Mobile 3D Graphics API
JSR-82 Bluetooth API
JSR-185 JTWI
JSR-226 Scalable 2D Vector Graphics API
JSR-135 Mobile Media API
JSR-120 Wireless Messaging API
Nokia UI API
Details
Review
Nokia N90 Bluetooth V1.2
CLDC 1.1
MIDP 2.0
JSR-120 Wireless Messaging API
JSR-135 Mobile Media API
JSR-172 Web Services API
JSR-184 Mobile 3D Graphics API
JSR-185 JTWI
JSR-75 FileConnection and PIM API
JSR-82 Bluetooth API
Nokia UI API
Details
Review
Sony Ericsson W900 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-120/205 Wireless Messaging API
JSR-135 Mobile Media API
JSR-185 Java Technology for the Wireless Industry
JSR-82 Java API for Bluetooth™
JSR-75 PDA Optional Packages for J2ME Platform
JSR-172 Web Services
Mascot Capsule Micro3D Version 3
JSR-184Mobile 3D Graphics API with hardware acceleration
Details
Review
Nokia N93 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-135 Mobile Media API
JSR-172 Web Services API
JSR-177 Security and Trust Services API
JSR-179 Location API
JSR-180 SIP API
JSR-184 Mobile 3D Graphics API
JSR-185 JTWI
JSR-205 Wireless Messaging API
JSR-75 FileConnection and PIM API
JSR-82 Bluetooth API
Nokia UI API
Details
Review
Sony Ericsson W850 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-120/205 Wireless Messaging 1.0 and 2.0 API's
JSR-135 Mobile Media API
JSR-185 Java Technology for the Wireless Industry
JSR-82 Java API for Bluetooth
JSR-75 PDA Optional Packages for J2ME Platform
JSR-172 Web Services
JSR-234
Advanced Multimedia Supplements (camera capabilities)
Mascot Capsule Micro3D Version 3
JSR-184 Mobile 3D Graphics API for Java ME
Details
Review
Nokia 3250 Bluetooth V2.0
CLDC 1.1
MIDP 2.0
JSR-120 Wireless Messaging API
JSR-135 Mobile Media API
JSR-172 Web Services API
JSR-177 Security and Trust Services API
JSR-179 Location API
JSR-180 SIP API
JSR-184 Mobile 3D Graphics API
JSR-185 JTWI
JSR-205 Wireless Messaging API
JSR-75 FileConnection and PIM API
JSR-82 Bluetooth API
Nokia UI API
Details
Review

]]> http://www.jsr82.com/15-most-popular-phones-with-jsr-82-bluetooth-api/feed/ 5 Bluetooth Basics http://www.jsr82.com/bluetooth-basics/ http://www.jsr82.com/bluetooth-basics/#comments Sun, 25 Mar 2007 15:14:53 +0000 Stuart http://www.jsr82.com/bluetooth-basics/ What is Bluetooth?

Bluetooth EarpieceBluetooth is a wireless communications specification named after the 10th century Danish King Harald Blatland, or “Bluetooth”. King Harald united the separate kingdoms of Denmark and Norway. The Bluetooth specification is intended to “unite” separate personal computing devices such as laptops, PDAs, palmtops, cell phones and peripherals, like printers for example. In short, Bluetooth is wireless technology intended for short-range radio links to replace cables. Its primary features are voice and data capabilities, robustness, low complexity, low power and low cost.

How Bluetooth Works

In the world of Bluetooth wireless technology, there are no wires and virtually no limits. Bluetooth operates on a 2.4GHz band that’s available everywhere, so no license or subscription is necessary. Using adaptive frequency hopping (AFH), the signal “hops” to various frequencies to help ensure your signal is secure. Additionally, Bluetooth products use 128-bit encryption and a PIN code upon the first connection, giving you a secure connection every time.

Unlike other wireless technology, such as infrared, the devices you want to synchronize don’t have to be facing each other to make the connection. As long as two Bluetooth enabled devices are within a specified range of one another, the connection will be made. This means you can talk on a wireless headset with your mobile phone stashed in the other room, access data from your PC on your mobile phone, or wirelessly stream music from your iPod to your home stereo. The possibilities are truly endless!

Operating range for Bluetooth enabled devices depends on the class. Class 1 devices have a range of 100 meters (300 feet) and Class 2 devices have a range of 10 meters (30 feet). Class 2 devices are most commonly found in mobile devices.

Bluetooth Devices

The popularity of Bluetooth is on the rise. The amount of Bluetooth enabled products entering the market is increasing exponentially every year. Some of the major bluetooth applications are as follows.

  • Keyboard/Mouse

Lets you create a wire-free work space . No more wires attached to your mouse or keyboard. The bluetooth profile used here is Human Interface Device Profile.

  • Phone Headsets


These are lightweight and portable headsets that lets you talk up to 30 feet away from your wireless phone. The bluetooth profile used by these devices is Hands Free profile.

  • Headphones

Bluetooth headphones lets you go completely wire free. The bluetooth profile used by these devices is Headset profile.

  • Printers/PDAs

Bluetooth printers lets you print documents without having to run cables or connect devices. There are printers that are specifically targeted for small memory devices which do not need the printer driver to be installed. The profile used by printers is Bluetooth Printing Profile.

Learn More about Bluetooth :

]]> http://www.jsr82.com/bluetooth-basics/feed/ 0 Java Bluetooth Forum http://www.jsr82.com/java-bluetooth-forum/ http://www.jsr82.com/java-bluetooth-forum/#comments Sat, 24 Mar 2007 17:53:44 +0000 Bruse http://www.jsr82.com/java-bluetooth-forum/ Java Bluetooth Forum is now up and running. Share and learn by participating in the discussions related to JSR-82 and Java Bluetooth Programming.

]]> http://www.jsr82.com/java-bluetooth-forum/feed/ 7 Welcoming all Java Bluetooth Developers http://www.jsr82.com/welcoming-all-java-bluetooth-developers/ http://www.jsr82.com/welcoming-all-java-bluetooth-developers/#comments Sat, 24 Mar 2007 16:11:17 +0000 Bruse http://www.jsr82.com/welcoming-all-java-bluetooth-developers/ Good news for every Java Bluetooth developers. Here is a place where you can learn and share new tips and techniques about JSR-82 and Java Bluetooth Programming. Learn from the new articles that talks about various aspects about Java Bluetooth Programming, and JSR-82.

Come and discuss about Java and Bluetooth at the Java Bluetooth Forum. Share and learn more about JSR-82.

]]> http://www.jsr82.com/welcoming-all-java-bluetooth-developers/feed/ 0