The free PHP hosting comparison chart below was compiled from phpinfo() files on test accounts of the free webspace hosts, and are subject to change as the free website hosts update their PHP software configurations.
|
Chart #2: General details
|
This application is the result of a P2P challenge performed by 5 different groups in the scope of a lecture on Peer-to-Peer Systems and Applications during summer term 2006 at the University of Zurich.
The goal of this challenge was to build a P2P application, that transports an MPEG Transport Stream (TS) from a streaming server to several clients via the UDP protocol (cf. Figure 1). The application was used to broadcast the FIFA World Cup 2006 as live stream to the students participating in the challenge.
The application had to meet the following requirements:
More information about the challenge task can be found at http://www.csg.uzh.ch/teaching/ss06/p2p/challenge (in german).
The application has been implemented in Java. It requires Java version 1.4.2 (JDK) or higher for compilation*. It depends on the FreePastry 1.4.4 library which is included in the application source package and needs to be put on the class path. The application may easily be compiled using Eclipse or any other development environment.
* Package csg.p2p.challenge.group3 requires Java 1.5
Refer to the README file. Further documentation about the different solutions can be found in the doc folder of the source distribution.
Refer to the LICENSE file.
See AUTHORS for the full list of authors for the different P2P challenge groups.
Here we see some important info about VoIP, needed to understand it.
To setup a VoIP communication we need:
Base architecture
Voice )) ADC - Compression Algo - Assembling RTP in TCP/IP ----
----> |
<---- | Voice (( DAC - Decompress. Algo - Disass. RTP from TCP/IP ----
This is made by hardware, typically by card integrated ADC.
Today every sound card allows you convert with 16 bit a band of 22050 Hz (for sampling it you need a freq of 44100 Hz for Nyquist Principle) obtaining a throughput of 2 bytes * 44100 (samples per second) = 88200 Bytes/s, 176.4 kBytes/s for stereo stream.
For VoIP we needn't such a throughput (176kBytes/s) to send voice packet: next we'll see other coding used for it.
Now that we have digital data we may convert it to a standard format that could be quickly transmitted.
PCM, Pulse Code Modulation, Standard ITU-T G.711
ADPCM, Adaptive differential PCM, Standard ITU-T G.726
It converts only the difference between the actual and the previous voice packet requiring 32 kbps (see Standard ITU-T G.726).
LD-CELP, Standard ITU-T G.728
CS-ACELP, Standard ITU-T G.729 and G.729a
MP-MLQ, Standard ITU-T G.723.1, 6.3kbps, Truespeech
ACELP, Standard ITU-T G.723.1, 5.3kbps, Truespeech
LPC-10, able to reach 2.5 kbps!!
This last protocols are the most important cause can guarantee a very low minimal band using source coding; also G.723.1 codecs have a very high MOS (Mean Opinion Score, used to measure voice fidelity) but attention to elaboration performance required by them, up to 26 MIPS!
Now we have the raw data and we want to encapsulate it into TCP/IP stack. We follow the structure:
VoIP data packets
RTP
UDP
IP
I,II layers
VoIP data packets live in RTP (Real-Time Transport Protocol) packets which are inside UDP-IP packets.
Firstly, VoIP doesn't use TCP because it is too heavy for real time applications, so instead a UDP (datagram) is used.
Secondly, UDP has no control over the order in which packets arrive at the destination or how long it takes them to get there (datagram concept). Both of these are very important to overall voice quality (how well you can understand what the other person is saying) and conversation quality (how easy it is to carry out a conversation). RTP solves the problem enabling the receiver to put the packets back into the correct order and not wait too long for packets that have either lost their way or are taking too long to arrive (we don't need every single voice packet, but we need a continuous flow of many of them and ordered).
Real Time Transport Protocol
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|V=2|P|X| CC |M| PT | sequence number |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| timestamp |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| synchronization source (SSRC) identifier |
+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
| contributing source (CSRC) identifiers |
| .... |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Where:
For a complete description of RTP protocol and all its applications see relative RFCs 1889 and 1890.
There are also other protocols used in VoIP, like RSVP, that can manage Quality of Service (QoS).
RSVP is a signaling protocol that requests a certain amount of bandwidth and latency in every network hop that supports it.
For detailed info about RSVP see the RFC 2205
We said many times that VoIP applications require a real-time data streaming cause we expect an interactive data voice exchange.
Unfortunately, TCP/IP cannot guarantee this kind of purpose, it just make a "best effort" to do it. So we need to introduce tricks and policies that could manage the packet flow in EVERY router we cross.
So here are:
For an exhaustive information about QoS see Differentiated Services at IETF.
H323 protocol is used, for example, by Microsoft Netmeeting to make VoIP calls.
This protocol allow a variety of elements talking each other:
h323 allows not only VoIP but also video and data communications.
Concerning VoIP, h323 can carry audio codecs G.711, G.722, G.723, G.728 and G.729 while for video it supports h261 and h263.
More info about h323 is available at Openh323 Standards, at this h323 web site and at its standard description: ITU H-series Recommendations.
You can find it implemented in various application software like Microsoft Netmeeting, Net2Phone, DialPad, ... and also in freeware products you can find at Openh323 Web Site.
To create a little VoIP system you need the following hardware:
All that has to be present twice to simulate a standard communication. The tool above are the minimal requirement for a VoIP connection: next we'll see that we should (and in Internet we must) use more hardware to do the same in a real situation. Sound card has be full duplex unless we couldn't hear anything while speaking! As additional you can use hardware cards (see next) able to manage data stream in a compressed format (see Par 4.3).
We can use special cards with hardware accelerating capability. Two of them (and also the only ones directly managed by the Linux kernel at this moment) are the
Quicknet PhoneJack is a sound card that can use standard algorithms to compress audio stream like G723.1 (section 4.3) down to 4.1 Kbps rate.
It can be connected directly to a phone (POTS port) or a couple mic-speaker.
It has a ISA or PCI connector bus.
Quicknet LineJack works like PhoneJack with some addition features (see next).
VoiceTronix V4PCI is a PCI card pretty like Quicknet LineJack but with 4 phone ports
VoiceTronix VPB4 is a ISA card equivalent to V4PCI.
VoiceTronix VPB8L is a logging card with 8 ports.
For more info see Quicknet web site and VoiceTronix web site
Quicknet LineJack and VoiceTronix cards can be connected to a PSTN line allowing VoIP gateway feature.
Then you'll need a software to manage it (see after).
We can choose what O.S. to use:
Under Win9x we have Microsoft Netmeeting, Internet Phone, DialPad or others or Internet Switchboard (from Quicknet web site) for Quicknet cards.
Warning!!: Latest Quicknet cards using Swithboard (older version too) NEED to be connected to Internet to get working for managing Microtelco account (not free of charge), so if you plan to remain isolated from Internet you need to install OpenH323 software.
For VoiceTronix cards you can find software at VoiceTronix web site
Under Linux we have free software GnomeMeeting, a clone of Microsoft Netmeeting, while in console mode we use (also free software) applications from OpenH323 web site: simph323 or ohphone that can also work with Quicknet accelerating hardware.
Attention: all Openh323 source code has to be compiled in a user directory (if not it is necessary to change some environment variable). You are warned that compiling time could be very high and you could need a lot of RAM to make it in a decent time.
To manage gateway feature (join TCP/IP VoIP to PSTN lines) you need some kind of software like this:
You can download as gatekeeper the Free product Openh323 Gatekeeper (GK) from here.
Version 2.0 of it supports "proxy function" to enabe talking from/to a private network.
In addition I report some useful software h323 compliant:
Same function can be obtained using "Proxy" function of Gatekeeper Gnugk (see before).
Here we see how to configure special hardware card in Linux and Windows environment.
As we saw, Quicknet Phonejack is a sound card with VoIP accelerating capability. It supports:
Quicknet PhoneJack is a ISA (or PCI) card to install into your Pc box. It can work without an IRQ.
Under Windows you have to install:
all downloadable from Quicknet web site
After Switchboard has been installed, you need to register to Quicknet to obtain full capability of your card.
When you pick up the phone Internet Switchboard wakes up and waits for your calling number (directly entered from your phone), you can:
Internet Swichboard is h323 compatible, so if you can use, for example, Microsoft Netmeeting at the other end to talk.
Warning!! Internet Switchboard NEED to be connected to Internet when used with newer Quicknet cards
In place of Internet Switchboard you can use openh323 application openphone (using GUI) or ohphone (command line).
Under Linux you have to install:
With Internet Switchboard (and with other application) you can:
This card is very similar to the previous, it supports also gateway feature.
We only notice that we have to download PSTNGx application (for Linux and Windows) or we use Internet Switchboard to gateway feature.
Follow README file for more help.
I personally haven't tested VoiceTronix products so please contact VoiceTronix web site for support.
In this chapter we try to setup VoIP system, simple at first, then more and more complex.
A (Sound card) - - - B (Sound card)
192.168.1.1 - - - 192.168.1.2
192.168.1.1 calls 192.168.1.2 and viceversa.
A and B should have
In this kind of view A can make a H323 call to B (if B has server side application active) using B IP address. Then B can answer to it if it wants. After accepting call, VoIP data packets start to flow.
Under Microsoft Windows a NetBIOS name can be used instead of an IP address.
A - - - B
192.168.1.1 - - - 192.168.1.2
John - - - Alice
John calls Alice.
This is possible cause John call request to Alice is converted to IP calling by the NetBIOS protocol.
The above 2 examples are very easy to implement but aren't scalable.
In a more big view such as Internet it is impossible to use direct calling cause, usually, the callers don't know the destination IP address. Furthermore NetBIOS naming feature cannot work cause it uses broadcast messages, which typically don't pass ISP routers .
You can also use DNS to solve name in IP address: for example you can call ''box.domain.com''.
The NetBIOS name calling idea can be implemented also in a Internet environment, using a WINS server: NetBIOS clients can be configured to use a WINS server to resolve names.
PCs using the same WINS server will be able to make direct calling between them.
A (WINS Server is S) - - - - I - - - - B (WINS Server is S)
N
T
E - - - - - S (WINS Server)
C (WINS Server is S) - - - - R
N
E - - - - D (WINS Server is S)
T
Internet communication
A, B, C and D are in different subnets, but they can call each other in a NetBIOS name calling fashion. The needed is that all are using S as WINS Server.
Note: WINS server hasn't very high performance cause it use NetBIOS feature and should only be used for joining few subnets.
ILS is a kind of server which allows you to solve your name during an H323 calling: when you start VoIP application you first register to ILS server using a name, then everyone will be able to see you using that name (if he uses same Server ILS!).
A problem of few IPs is commonly solved using the so called masquering (also NAT, network address translation): there is only 1 IP public address (that Internet can directly "see"), the others machines are "masqueraded" using all this IP.
A - - -
B - - - Router with NAT - - - Internet
C - - -
This doesn't work
In the example A,B and C can navigate, pinging, using mail and news services with Internet people, but they CANNOT make a VoIP call. This because H323 protocol send IP address at application level, so the answer will never arrive to source (that is using a private IP address).
Solutions:
A - - - Router with NAT
B - - - + - - - Internet
C - - - ip_masq_h323 module
This works
A - - -
B - - - PhonePatch - - - Internet
C - - -
This works
Sintax is:
"ohphone -l|--listen [options]"
"ohphone [options]... address"
Also, when you start ohphone, you can give command to the interpreter directly (like decrease AEC, Automatic Echo Cancellation).
Gnomemeeting is an application using GUI interface to make call using VoIP. It is very simple to use and allows you to use ILS server, chat and other things.
You can also experiment gatekeeper feature
Example
(Terminal H323) A - - -
\
(Terminal H323) B - - - D (Gatekeeper)
/
(Terminal H323) C - - -
Gatekeeper configuration
We have to notice that the Gatekeeper is able only to solve name in IP address, it couldn't join hosts that aren't reachable each other (at IP level), in other words it couldn't act as a NAT router.
You can find gatekeeper code here: openh323 library is also required.
Program has only to be launch with -d (as daemon) or -x (execute) parameter.
In addition you can use a config file (.ini) you find here.
As we said, gateway is an entity that can join VoIP to PSTN lines allowing us to made call from Internet to a classic telephone. So, in addition, we need a card that could manage PSTN lines: Quicknet LineJack does it.
From OpenH323 web site we download:
If executable doesn't work you need to download source code and openh323 library, then install all in a home user directory.
After that you only need to launch PSTNGw to start your H323 gateway.
First Matrix refers to:
| Netmeeting | SwitchBoard | Simph323 | OhPhone | LinPhone | Speak-Freely | HW PhoneJACK | HW LineJACK | |
| Netmeeting | V | V | V | V | X | X | V | V |
| SwitchBoard | V | V | V | V | X | X | V | V |
| Simph323 | V | V | V | V | X | X | X | X |
| OhPhone | V | V | V | V | X | X | V | V |
| LinPhone | X | X | X | X | V | X | X | X |
| SpeakFreely | X | X | X | X | X | V | X | X |
| HW PhoneJACK | V | V | X | V | X | X | - | - |
| HW LineJACK | V | V | X | V | X | X | - | - |
Second Matrix refers to Gateway softwares that manage LineJACK card.
___________________________________________________________
| |HW LineJACK GW| SwitchBoard | PSTNGW |
|______________|______________|______________|______________|
|HW LineJACK GW| _ | V | V |
|______________|______________|______________|______________|
| SwitchBoard | V | _ | _ |
|______________|______________|______________|______________|
| PSTNGW | V | _ | _ |
|______________|______________|______________|______________|
Notation:
public class BluetoothBrowser
implements DiscoveryListener {
private LocalDevice localDevice;
private DiscoveryAgent agent;
/** Creates a new instance of BluetoothBrowser */
public BluetoothBrowser()
throws BluetoothStateException {
localDevice = LocalDevice.getLocalDevice();
agent = localDevice.getDiscoveryAgent();
}
/** Start inquiry */
public void inquiry()
throws BluetoothStateException {
agent.startInquiry(DiscoveryAgent.GIAC, this);
}
...implementations for DiscoveryListener...
/*
* PresenceJFrame.java
*
* Created on 8. heinäkuuta 2007, 11:04
*/
package com.didiksoft.presence;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
*
* @author didiksoft
*/
public class PresenceJFrame extends javax.swing.JFrame {
private Controller controller;
/** Creates new form PresenceJFrame */
public PresenceJFrame() {
initComponents();
this.controller = Controller.getInstance();
}
/** Add text to the text area */
public void addText(String text) {
logTextArea.setText(logTextArea.getText() + text + "\r\n");
logTextArea.repaint();
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// =editor-fold defaultstate="collapsed" desc=" Generated Code "=//GEN-BEGIN:initComponents
private void initComponents() {
jScrollPane1 = new javax.swing.JScrollPane();
logTextArea = new javax.swing.JTextArea();
jButton1 = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("Bluetooth example");
logTextArea.setColumns(20);
logTextArea.setRows(5);
jScrollPane1.setViewportView(logTextArea);
jButton1.setText("Search nearby devices");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
searchDevices(evt);
}
});
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 291, Short.MAX_VALUE)
.addComponent(jButton1))
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(jButton1)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 186, Short.MAX_VALUE)
.addContainerGap())
);
pack();
}// =/editor-fold=//GEN-END:initComponents
private void searchDevices(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_searchDevices
controller.searchDevices();
}//GEN-LAST:event_searchDevices
/**
* @param args the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new PresenceJFrame().setVisible(true);
}
});
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton jButton1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea logTextArea;
// End of variables declaration//GEN-END:variables
}
/*
* __NAME__.java
*
* Copyright (C) 2007 didiksoft
* http://java-vb.blogspot.com
*
*/
package com.didiksoft.presence;
import javax.swing.UIManager;
/**
*
* @author Didik Rawandi (uchiha_didik@yahoo.com)
*/
public class Application {
private static Controller controller;
/** Creates a new instance of __NAME__ */
private Application() {
}
public static void main(String[] args) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
try {
UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
//UIManager.setLookAndFeel( new com.jgoodies.looks.plastic.PlasticXPLookAndFeel() );
} catch(Exception ex) {
ex.printStackTrace();
}
controller = Controller.getInstance();
controller.start();
}
});
}
}
/*
* Controller.java
*
* Copyright (C) 2007 didiksoft
* http://java-vb.blogspot.com
*
*/
package com.didiksoft.presence;
import com.didiksoft.bluetooth.BluetoothBrowser;
import com.didiksoft.logging.Log;
/**
*
* @author Didik Rawandi (uchiha_didik@yahoo.com)
*/
public class Controller {
private static Controller instance;
private static PresenceJFrame mainFrame;
/** Creates a new instance of Controller */
private Controller() {
}
public static Controller getInstance() {
if(instance==null) {
instance = new Controller();
mainFrame = new PresenceJFrame();
}
return instance;
}
public void start() {
mainFrame.setVisible(true);
}
public void searchDevices() {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
Log.add("Start discovery");
Thread.yield();
try {
BluetoothBrowser browser = new BluetoothBrowser();
//browser.inquiry();
Thread.yield();
Thread.sleep(15000);
} catch(Exception ex) {
Log.error("Error in main: " + ex);
}
Log.add("Discovery end");
Thread.yield();
}
});
}
public void addLogText(String text) {
mainFrame.addText(text);
}
}
/*
* BluetoothBrowser.java
*
* Copyright (C) 2007 didiksoft
* http://java-vb.blogspot.com
*
*/
package com.didiksoft.bluetooth;
import com.didiksoft.logging.Log;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.bluetooth.BluetoothStateException;
import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
/**
*
* @author Didik Rawandi (uchiha_didik@yahoo.com)
*/
public class BluetoothBrowser implements DiscoveryListener {
private LocalDevice localDevice;
private DiscoveryAgent agent;
/** Creates a new instance of BluetoothBrowser */
public BluetoothBrowser() throws BluetoothStateException {
System.out.print(LocalDevice.isPowerOn());
localDevice = LocalDevice.getLocalDevice();
agent = localDevice.getDiscoveryAgent();
}
public void inquiry() throws BluetoothStateException {
agent.startInquiry(DiscoveryAgent.GIAC, this);
}
public void deviceDiscovered(RemoteDevice device, DeviceClass devClass) {
try {
Log.add("Device discovered: " + device.getFriendlyName(false));
} catch (IOException ex) {
Logger.getLogger("global").log(Level.SEVERE, null, ex);
}
}
public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
Log.add("Service discovered");
}
public void serviceSearchCompleted(int transID, int responseCode) {
Log.add("Service search completed");
}
public void inquiryCompleted(int discType) {
Log.add("Inquiry completed");
}
}
/*
* Log.java
*
* Copyright (C) 2007 didiksoft
* http://java-vb.blogspot.com
*
*/
package com.didiksoft.logging;
import com.didiksoft.presence.Controller;
/**
*
* @author Didik Rawandi (uchiha_didik@yahoo.com)
*/
public class Log {
/** Creates a new instance of Log */
private Log() {
}
public static void add(String message) {
System.out.println("LOG: " + message);
Controller controller = Controller.getInstance();
controller.addLogText(message);
}
public static void error(String message) {
System.err.println("ERROR: " + message);
}
}
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
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.
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.
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
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.
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
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.
