www.pudn.com > bluecove-1.2.1-src.zip > LocalDevice.java, change:2007-01-07,size:13728b
/*
Copyright 2004 Intel Corporation
This file is part of Blue Cove.
Blue Cove is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
Blue Cove is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with Blue Cove; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package javax.bluetooth;
import java.io.IOException;
import javax.microedition.io.Connection;
import com.intel.bluetooth.BluetoothPeer;
import com.intel.bluetooth.BluetoothStreamConnectionNotifier;
public class LocalDevice {
private static LocalDevice localDevice;
private BluetoothPeer bluetoothPeer;
private DiscoveryAgent discoveryAgent;
private String address;
private long bluetoothAddress;
private LocalDevice() {
bluetoothPeer = new BluetoothPeer();
discoveryAgent = new DiscoveryAgent();
try {
int socket = bluetoothPeer.socket(false, false);
bluetoothAddress = bluetoothPeer.getsockaddress(socket);
address = Long.toHexString(bluetoothAddress);
bluetoothPeer.close(socket);
} catch (IOException e) {
address = "";
}
address = "000000000000".substring(address.length()) + address;
}
public BluetoothPeer getBluetoothPeer() {
return bluetoothPeer;
}
/*
* Retrieves the LocalDevice object for the local Bluetooth device. Multiple
* calls to this method will return the same object. This method will never
* return null. Returns: an object that represents the local Bluetooth
* device Throws: BluetoothStateException - if the Bluetooth system could
* not be initialized
*/
public static LocalDevice getLocalDevice() throws BluetoothStateException {
if (localDevice == null)
localDevice = new LocalDevice();
return localDevice;
}
/*
* Returns the discovery agent for this device. Multiple calls to this
* method will return the same object. This method will never return null.
* Returns: the discovery agent for the local device
*/
public DiscoveryAgent getDiscoveryAgent() {
return discoveryAgent;
}
/*
* Retrieves the name of the local device. The Bluetooth specification calls
* this name the "Bluetooth device name" or the "user-friendly name".
* Returns: the name of the local device; null if the name could not be
* retrieved
*/
public String getFriendlyName() {
return bluetoothPeer.getradioname(bluetoothAddress);
}
/*
* Retrieves the DeviceClass object that represents the service classes,
* major device class, and minor device class of the local device. This
* method will return null if the service classes, major device class, or
* minor device class could not be determined. Returns: the service classes,
* major device class, and minor device class of the local device, or null
* if the service classes, major device class or minor device class could
* not be determined
*/
public DeviceClass getDeviceClass() {
return null;
}
/*
* Sets the discoverable mode of the device. The mode may be any number in
* the range 0x9E8B00 to 0x9E8B3F as defined by the Bluetooth Assigned
* Numbers Document. When this specification was defined, only GIAC
* (DiscoveryAgent.GIAC) and LIAC (DiscoveryAgent.LIAC) were defined, but
* Bluetooth profiles may add additional access codes in the future. To
* determine what values may be used, check the Bluetooth Assigned Numbers
* document at http://www.bluetooth.org/assigned-numbers/baseband.htm. If
* DiscoveryAgent.GIAC or DiscoveryAgent.LIAC are provided, then this method
* will attempt to put the device into general or limited discoverable mode,
* respectively. To take a device out of discoverable mode, provide the
* DiscoveryAgent.NOT_DISCOVERABLE flag. The BCC decides if the request will
* be granted. In addition to the BCC, the Bluetooth system could effect the
* discoverability of a device. According to the Bluetooth Specification, a
* device should only be limited discoverable (DiscoveryAgent.LIAC) for 1
* minute. This is handled by the implementation of the API. After the
* minute is up, the device will revert back to the previous discoverable
* mode.
*
* Parameters: mode - the mode the device should be in; valid modes are
* DiscoveryAgent.GIAC, DiscoveryAgent.LIAC, DiscoveryAgent.NOT_DISCOVERABLE
* and any value in the range 0x9E8B00 to 0x9E8B3F Returns: true if the
* request succeeded, otherwise false if the request failed because the BCC
* denied the request; false if the Bluetooth system does not support the
* access mode specified in mode Throws: IllegalArgumentException - if the
* mode is not DiscoveryAgent.GIAC, DiscoveryAgent.LIAC,
* DiscoveryAgent.NOT_DISCOVERABLE, or in the range 0x9E8B00 to 0x9E8B3F
* BluetoothStateException - if the Bluetooth system is in a state that does
* not allow the discoverable mode to be changed See Also:
* DiscoveryAgent.GIAC, DiscoveryAgent.LIAC, DiscoveryAgent.NOT_DISCOVERABLE
*/
public boolean setDiscoverable(int mode) throws BluetoothStateException {
return false;
}
/*
* Retrieves Bluetooth system properties. The following properties must be
* supported, but additional values are allowed: Property Name Description
* bluetooth.api.version The version of the Java API for Bluetooth wireless
* technology that is supported. For this version it will be set to "1.0".
* bluetooth.master.switch Is master/slave switch allowed? Valid values are
* either "true" or "false". bluetooth.sd.attr.retrievable.max Maximum
* number of service attributes to be retrieved per service record. The
* string will be in Base 10 digits. bluetooth.connected.devices.max The
* maximum number of connected devices supported. This number may be greater
* than 7 if the implementation handles parked connections. The string will
* be in Base 10 digits. bluetooth.l2cap.receiveMTU.max The maximum
* ReceiveMTU size in bytes supported in L2CAP. The string will be in Base
* 10 digits, e.g. "32". bluetooth.sd.trans.max Maximum number of concurrent
* service discovery transactions. The string will be in Base 10 digits.
* bluetooth.connected.inquiry.scan Is Inquiry scanning allowed during
* connection? Valid values are either "true" or "false".
* bluetooth.connected.page.scan Is Page scanning allowed during connection?
* Valid values are either "true" or "false". bluetooth.connected.inquiry Is
* Inquiry allowed during a connection? Valid values are either "true" or
* "false". bluetooth.connected.page Is paging allowed during a connection?
* In other words, can a connection be established to one device if it is
* already connected to another device. Valid values are either "true" or
* "false".
*
* Parameters: property - the property to retrieve as defined in this class.
* Returns: the value of the property specified; null if the property is not
* defined
*/
public static String getProperty(String property) {
return null;
}
/*
* Retrieves the local device's discoverable mode. The return value will be
* DiscoveryAgent.GIAC, DiscoveryAgent.LIAC,
* DiscoveryAgent.NOT_DISCOVERABLE, or a value in the range 0x9E8B00 to
* 0x9E8B3F. Returns: the discoverable mode the device is presently in See
* Also: DiscoveryAgent.GIAC, DiscoveryAgent.LIAC,
* DiscoveryAgent.NOT_DISCOVERABLE
*/
public int getDiscoverable() {
return DiscoveryAgent.NOT_DISCOVERABLE;
}
/*
* Retrieves the Bluetooth address of the local device. The Bluetooth
* address will never be null. The Bluetooth address will be 12 characters
* long. Valid characters are 0-9 and A-F. Returns: the Bluetooth address of
* the local device
*/
public String getBluetoothAddress() {
return address;
}
/*
* Gets the service record corresponding to a btspp, btl2cap, or btgoep
* notifier. In the case of a run-before-connect service, the service record
* returned by getRecord() was created by the same call to Connector.open()
* that created the notifier. If a connect-anytime server application does
* not already have a service record in the SDDB, either because a service
* record for this service was never added to the SDDB or because the
* service record was added and then removed, then the ServiceRecord
* returned by getRecord() was created by the same call to Connector.open()
* that created the notifier.
*
* In the case of a connect-anytime service, there may be a service record
* in the SDDB corresponding to this service prior to application startup.
* In this case, the getRecord() method must return a ServiceRecord whose
* contents match those of the corresponding service record in the SDDB. If
* a connect-anytime server application made changes previously to its
* service record in the SDDB (for example, during a previous execution of
* the server), and that service record is still in the SDDB, then those
* changes must be reflected in the ServiceRecord returned by getRecord().
*
* Two invocations of this method with the same notifier argument return
* objects that describe the same service attributes, but the return values
* may be different object references.
*
* Parameters: notifier - a connection that waits for clients to connect to
* a Bluetooth service Returns: the ServiceRecord associated with notifier
* Throws: IllegalArgumentException - if notifier is closed, or if notifier
* does not implement one of the following interfaces:
* javax.microedition.io.StreamConnectionNotifier,
* javax.bluetooth.L2CapConnectionNotifier, or javax.obex.SessionNotifier.
* This exception is also thrown if notifier is not a Bluetooth notifier,
* e.g., a StreamConnectionNotifier created with a scheme other than btspp.
* NullPointerException - if notifier is null
*/
public ServiceRecord getRecord(Connection notifier) {
if (notifier == null)
throw new NullPointerException();
if (!(notifier instanceof BluetoothStreamConnectionNotifier))
throw new IllegalArgumentException();
return ((BluetoothStreamConnectionNotifier) notifier)
.getServiceRecord();
}
/*
* 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. The service record in the SDDB is
* modified to have the same service attributes with the same contents as
* srvRecord. If srvRecord was obtained from the SDDB of a remote device
* using the service search methods, updating is not possible and this
* method will throw an IllegalArgumentException.
*
* If the srvRecord parameter is a btspp service record, then before the
* SDDB is changed the following checks are performed. If any of these
* checks fail, then an IllegalArgumentException is thrown.
*
* ServiceClassIDList and ProtocolDescriptorList, the mandatory service
* attributes for a btspp service record, must be present in srvRecord.
* L2CAP and RFCOMM must be in the ProtocolDescriptorList. srvRecord must
* not have changed the RFCOMM server channel number from the channel number
* that is currently in the SDDB version of this service record. If the
* srvRecord parameter is a btl2cap service record, then before the SDDB is
* changed the following checks are performed. If any of these checks fail,
* then an IllegalArgumentException is thrown.
*
* ServiceClassIDList and ProtocolDescriptorList, the mandatory service
* attributes for a btl2cap service record, must be present in srvRecord.
* L2CAP must be in the ProtocolDescriptorList. srvRecord must not have
* changed the PSM value from the PSM value that is currently in the SDDB
* version of this service record. If the srvRecord parameter is a btgoep
* service record, then before the SDDB is changed the following checks are
* performed. If any of these checks fail, then an IllegalArgumentException
* is thrown.
*
* ServiceClassIDList and ProtocolDescriptorList, the mandatory service
* attributes for a btgoep service record, must be present in srvRecord.
* L2CAP, RFCOMM and OBEX must all be in the ProtocolDescriptorList.
* srvRecord must not have changed the RFCOMM server channel number from the
* channel number that is currently in the SDDB version of this service
* record. updateRecord() is not required to ensure that srvRecord is a
* completely valid service record. It is the responsibility of the
* application to ensure that srvRecord follows all of the applicable
* syntactic and semantic rules for service record correctness.
*
* If there is currently no SDDB version of the srvRecord service record,
* then this method will do nothing.
*
* Parameters: srvRecord - the new contents to use for the service record in
* the SDDB Throws: NullPointerException - if srvRecord is null
* IllegalArgumentException - if the structure of the srvRecord is missing
* any mandatory service attributes, or if an attempt has been made to
* change any of the values described as fixed. ServiceRegistrationException -
* if the local SDDB could not be updated successfully due to insufficient
* disk space, database locks, etc.
*/
/*
* public void updateRecord(ServiceRecord srvRecord) throws
* ServiceRegistrationException { }
*/
}