btbrowsermidlet.java

提供蓝牙所有服务

package org.klings.j2me.BTBrowser;

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

import javax.bluetooth.BluetoothStateException;
import javax.bluetooth.DataElement;
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.ConnectionNotFoundException;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.List;
import javax.microedition.lcdui.Ticker;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
import org.klings.wireless.j2me.*;
import org.klings.wireless.BluetoothNumbers.*;

public class BTBrowserMIDlet extends MIDlet implements CommandListener,
		DiscoveryListener {

	/* Reference to the Display object to do anything useful with UI */
	private Display display = null;
	/* Reference to LocalDevice to do anything concerning Bluetooth */
	private LocalDevice local = null;
	/* Reference to a DiscoveryAgent to do inquiry or service searches */
	private DiscoveryAgent agent = null;
	/* Globally available Vectors for devices and services found */
	private Vector deviceVector = null;
	private Vector serviceVector = null;
	/* Global Ticker used for most screens in this application 滚动条 */
	private Ticker tic = null;
	/*
	 * Global UI list accessible to deviceDiscovered(...) so we can show devices
	 * and services as they are discovered, giving the user a feeling of
	 * progress in the program
	 */
	private List deviceList = null;
	private List serviceList = null;
	private String clientExecutableURL = null;
	private String documentationURL = null;

	private BluetoothServiceRecordCanvas rCanvas = null;

	/*
	 * Global list of interesting service attributes used when populating and
	 * showing service records
	 */
	int[] attrs = { BTServiceAttributeId.SDP_SERVICENAME,
			BTServiceAttributeId.SDP_SERVICEDESCRIPTION,
			BTServiceAttributeId.SDP_PROVIDERNAME,
			BTServiceAttributeId.SDP_SERVICEINFOTIMETOLIVE,
			BTServiceAttributeId.SDP_SERVICEAVAILABILITY,
			BTServiceAttributeId.SDP_BLUETOOTHPROFILEDESCRIPTORLIST,
			BTServiceAttributeId.SDP_DOCUMENTATIONURL,
			BTServiceAttributeId.SDP_CLIENTEEXECUTABLEURL,
			BTServiceAttributeId.SDP_ICONURL, };
	/* Globally available commands used for most menus */
	Command exitCommand = new Command("Exit", Command.EXIT, 2);
	Command searchCommand = new Command("New Search", Command.SCREEN, 1);
	Command backCommand = new Command("Back", Command.BACK, 1);
	Command cancelCommand = new Command("Cancel", Command.CANCEL, 1);
	Command openURL = new Command("Open URL", Command.CANCEL, 2);
	/* Integer to keep track of which menu is active */
	int currentMenu = 0;
	/* Boolean stating if an inquriy is in progress or not */
	boolean inquiring = false;
	/*
	 * Integer to keep track of service searches. Needed to cancel an ongoing
	 * service search
	 */
	int serviceSearch = 0;

	public BTBrowserMIDlet() {
		// TODO Auto-generated constructor stub
	}

	protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
		// TODO Auto-generated method stub
		notifyDestroyed();
	}

	protected void pauseApp() {
		// TODO Auto-generated method stub
		display = null;
		local = null;
		// attrs = null;
		tic = null;
	}

	protected void startApp() throws MIDletStateChangeException {
		// TODO Auto-generated method stub
		display = Display.getDisplay(this);
		Alert a = null;
		try {
			//获得本地蓝牙装置
			local = LocalDevice.getLocalDevice();
		} catch (BluetoothStateException bse) {
			a = new Alert("Bluetooth error",
					"Either Bluetooth must be turned on, or your "
							+ "device does not support JABWT", null,
					AlertType.ERROR);
			a.setTimeout(Alert.FOREVER);
			a.addCommand(exitCommand);
			a.setCommandListener(this);
		}
		tic = new Ticker("By Klings, www.klings.org/nowires");
		mainMenu(a);
	}

	/*
	 * mainMenu() will present the user a list of cached and preknown devices,
	 * and provide a menu to initiate device discovery (inquiry) in order to
	 * find nearby Bluetooth devices
	 */
	private void mainMenu(Alert a) {
		// TODO Auto-generated method stub
		List knownDevices = new List("Cached/known devices", List.IMPLICIT);
		if (deviceVector == null)
			deviceVector = new Vector();
		if (agent == null)
			//获得本地蓝牙代理
			agent = local.getDiscoveryAgent();

		/* Retrieve PREKNOWN devices and add them to our Vector */
		RemoteDevice[] devices = agent.retrieveDevices(DiscoveryAgent.PREKNOWN);
		String name = null;

		if (devices != null) {
			/*
			 * Synchronize on vector to obtain object lock before loop. Else,
			 * object lock will be obtained every iteration.
			 */
			synchronized (deviceVector) {
				for (int i = devices.length - 1; i >= 0; i--) {
					deviceVector.addElement(devices[i]);
					try {
						name = devices[i].getFriendlyName(false);
					} catch (IOException ioe) {
						name = devices[i].getBluetoothAddress();
					}
					if (name.equals(""))
						name = devices[i].getBluetoothAddress();
					knownDevices.insert(0, name, null);
				}
			} // End synchronized
		}

		/* Retrieve cached devices and add them to our Vector */
		devices = null;
		devices = agent.retrieveDevices(DiscoveryAgent.CACHED);
		if (devices != null) {
			synchronized (deviceVector) {
				for (int i = devices.length - 1; i >= 0; i--) {
					deviceVector.addElement(devices[i]);
					try {
						name = devices[i].getFriendlyName(false);
					} catch (IOException ioe) {
						name = devices[i].getBluetoothAddress();
					}
					if (name.equals(""))
						name = devices[i].getBluetoothAddress();
					knownDevices.insert(0, name, null);
				}
			}
		}

		/* Indicate to user if the Vector is empty */
		if (deviceVector.isEmpty()) {
			knownDevices.append("Empty", null);
		}
		knownDevices.setTicker(tic);
		knownDevices.addCommand(exitCommand);
		knownDevices.addCommand(searchCommand);
		knownDevices.setCommandListener(this);
		/* If we have an Alert, show it... */
		if (a == null)
			display.setCurrent(knownDevices);
		else
			display.setCurrent(a, knownDevices);
		currentMenu = 1;
	}

	/*
	 * deviceScreen() will show the user a list of devices found during device
	 * discovery (inquiry)
	 */
	private void deviceScreen(Alert a) {
		/*
		 * if currentmenu < 3 we are in screen with known/cached devices or
		 * screen with discovered devices and have issued a device search
		 * deviceList is then reinitialized by startInquiry(), hence we must add
		 * these commands again
		 */
		if (currentMenu < 3) {
			deviceList.setTicker(tic);
			if (inquiring) {
				deviceList.setTitle("Please wait...");
				deviceList.addCommand(cancelCommand);
			} else {
				deviceList.setTitle("Devices:");
				deviceList.removeCommand(cancelCommand);
				deviceList.addCommand(exitCommand);
				deviceList.addCommand(searchCommand);
				deviceList.addCommand(backCommand);
			}
			deviceList.setCommandListener(this);
		}
		/* Display Alert if any... */
		if (a == null)
			display.setCurrent(deviceList);
		else
			display.setCurrent(a, deviceList);
		currentMenu = 2;
	}

	/*
	 * startInquiry() will reinitialize the list of devices, and initiate a
	 * device discovery (inquiry) repopulating the list of devices
	 */
	private void startInquiry() {
		Alert a = new Alert("Inquiry status", null, null, AlertType.INFO);
		if (agent == null)
			// 获得本地蓝牙代理agent
			agent = local.getDiscoveryAgent();
		/* Get rid of old search results in vector and deviceList */
		deviceVector.removeAllElements();
		deviceList = null;
		deviceList = new List("Devices", List.IMPLICIT);
		/* Start the actual inquiry */
		try {
			

			//设备发现以调用startInquiry()函数开始。
			//在请求进行时，蓝牙发现代理会在适当的时候调用回调方法DeviceDiscovered()和inquiryCompleted()。
		//是否发现远程代理inquiring
			inquiring = agent.startInquiry(DiscoveryAgent.GIAC, this);
			
		} catch (BluetoothStateException bse) {
			a.setType(AlertType.ERROR);
			a.setString("Bluetooth error while starting inquiry");
			mainMenu(a);
			return;
		}
		if (inquiring) {
			a.setString("Inquiry started");
			deviceScreen(a);
		} else {
			a.setType(AlertType.ERROR);
			a.setString("Error starting inquiry");
			// With no Inquiry we have no need for this any more.
			deviceList = null;
			mainMenu(a);
		}
	}

	/*
	 * getFriendlyNames() will contact all devices in the deviceVector and
	 * retrieve their friendly names, if available
	 */
	private void getFriendlyNames() {
		String name = null;
		for (int i = deviceVector.size() - 1; i >= 0; i--) {
			try {
				name = ((RemoteDevice) deviceVector.elementAt(i))
						.getFriendlyName(false);
			} catch (IOException ioe) {
				/*
				 * An IOException may occur if the remote device can not be
				 * contacted or the remote device could not provide its name. In
				 * that case we leave the Bluetooth address in the list, and
				 * move on to the next device found.
				 */
				continue;
			}
			if (!name.equals("")) {
				deviceList.set(i, name, null);
			}
		}
	}

	/*
	 * startServiceSearch() will initiate a service search on the supplied
	 * remote device.
	 */
	private void startServiceSearch(RemoteDevice rDevice) {
		Alert a = null;
		// Prepare serviceVector
		if (serviceVector == null)
			serviceVector = new Vector();
		else
			serviceVector.removeAllElements();
		serviceList = null;
		serviceList = new List("", List.IMPLICIT);
		try {
			serviceList.setTitle(rDevice.getFriendlyName(false));
		} catch (IOException ioe) {
			serviceList.setTitle(rDevice.getBluetoothAddress());
		}
		/*
		 * Search for services containing the PublicBrowseRoot UUID (0x1002)
		 * Should give us all public browseable services
		 */
		UUID[] uuids = new UUID[1];
		uuids[0] = new UUID(0x1002);
		/*
		 * Start the actual service search, using the attrs array initialized
		 * earlier, the UUID array and the remote device we want to do a service
		 * search on
		 */
		try {
			/*服务发现API
			 * 你可以使用发现代理的服务发现方法来开始或取消服务发现：

			　　. selectService()启动服务发现搜索。（根据API手册应为尝试定位一个服务）

			　　. searchServices()启动服务发现搜索。

			　　. cancelServiceSearch()取消在正在进行中的任何的服务发现搜索操作。蓝牙发现代理在服务发现阶段的不同时候会分别调用DiscoveryListener的服务发现回调方法：

			　　. servicesDiscovered() 表示是否服务已被发现。

			　　. serviceSearchCompleted()表示服务发现是否已经完成。

			　　图7阐明了服务发现的状态改变结束于DiscoveryListener的回调方法的返回。
						 */
			//服务发现开始于对searchServices()的调用。当服务搜索进行时，
			//蓝牙发现代理会在适当的时候回调servicesDiscovered()和 serviceSearchCompleted()方法。 网管网bitsCN.com 
			//　服务发现开始于对searchServices()的调用。当服务搜索进行时，蓝牙发现代理会在适当的时候回调servicesDiscovered()和 serviceSearchCompleted()方法。 网管网bitsCN.com 
			//	　　除了DiscoveryAgent和DiscoveryListener了，你在服务发现过程中还要使用到的类有UUID，ServiceRecord以及DataElement等。