DeviceManagerServiceImpl.java - bluecove

‹r2600

r2997

Source path: svn/ trunk/ bluecove-emu/ src/ main/ java/ com/ intel/ bluetooth/ emu/ DeviceManagerServiceImpl.java

/**
 *  BlueCove - Java library for Bluetooth
 *  Copyright (C) 2008-2009 Michael Lifshits
 *  Copyright (C) 2008-2009 Vlad Skarzhevskyy
 *
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you under the Apache License, Version 2.0 (the
 *  "License"); you may not use this file except in compliance
 *  with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing,
 *  software distributed under the License is distributed on an
 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 *  specific language governing permissions and limitations
 *  under the License.
 *
 *  @author vlads
 *  @version $Id$
 */
package com.intel.bluetooth.emu;

import java.io.IOException;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import javax.bluetooth.BluetoothConnectionException;
import javax.bluetooth.BluetoothStateException;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.ServiceRegistrationException;

import com.intel.bluetooth.DebugLog;
import com.intel.bluetooth.RemoteDeviceHelper;

public class DeviceManagerServiceImpl implements DeviceManagerService {

	public static final int MAJOR_COMPUTER = 0x0100;

	static final EmulatorConfiguration configuration;

	private static Map<Long, Device> devices = new Hashtable<Long, Device>();

	static {
		configuration = new EmulatorConfiguration();
		configuration.loadConfigFile();
	}

	public DeviceManagerServiceImpl() {
	}

	public void shutdown() {
		synchronized (devices) {
			for (Iterator<Device> iterator = devices.values().iterator(); iterator.hasNext();) {
				Device device = iterator.next();
				device.release();
			}
			devices.clear();
		}
	}

	public DeviceDescriptor createNewDevice(String deviceID, String deviceAddress) throws BluetoothStateException {
		synchronized (devices) {
			long address = getNextAvailableBTAddress(deviceID, deviceAddress);

			String name = configuration.getProperty(address, EmulatorConfiguration.deviceName);
			if (name == null) {
				name = configuration.getDeviceNamePrefix() + RemoteDeviceHelper.getBluetoothAddress(address);
			}
			int deviceClass = MAJOR_COMPUTER;
			String cod = configuration.getProperty(address, EmulatorConfiguration.deviceClass);
			if (cod != null) {
				deviceClass = EmulatorConfiguration.valueToInt(cod);
			}
			DeviceDescriptor descriptor = new DeviceDescriptor(address, name, deviceClass);

			if (!configuration.isDeviceDiscoverable()) {
				descriptor.setDiscoverableMode(DiscoveryAgent.NOT_DISCOVERABLE);
			}

			devices.put(new Long(address), new Device(descriptor));
			return descriptor;
		}
	}

	public EmulatorConfiguration getEmulatorConfiguration(long localAddress) {
		return configuration.clone(localAddress);
	}

	public void releaseDevice(long address) {
		Device device;
		synchronized (devices) {
			device = (Device) devices.remove(new Long(address));
		}
		if (device != null) {
			device.release();
		}
	}

	public DeviceCommand pollCommand(long address) {
		Device device = getDevice(address);
		if (device == null) {
			throw new RuntimeException("No such device " + RemoteDeviceHelper.getBluetoothAddress(address));
		}
		return device.pollCommand();
	}

	static Device getDevice(long address) {
		Device d = ((Device) devices.get(new Long(address)));
		if ((d != null) && (!d.isAlive())) {
			synchronized (devices) {
				devices.remove(new Long(address));
			}
			d.died();
			return null;
		}
		return d;
	}

	private Device getActiveDevice(long address) {
		Device d = getDevice(address);
		if ((d != null) && (!d.getDescriptor().isPoweredOn())) {
			return null;
		} else {
			return d;
		}
	}

	public DeviceDescriptor getDeviceDescriptor(long address) {
		Device device = getDevice(address);
		if (device == null) {
			throw new RuntimeException("No such device " + RemoteDeviceHelper.getBluetoothAddress(address));
		}
		return device.getDescriptor();
	}

	private DeviceSDP getDeviceSDP(long address) {
		Device device = getActiveDevice(address);
		if (device == null) {
			return null;
		}
		return device.getDeviceSDP(false);
	}

	public static List<MonitorDevice> getMonitorDevices() {
		Vector<MonitorDevice> monitorDevices = new Vector<MonitorDevice>();
		synchronized (devices) {
			for (Iterator<Device> iterator = devices.values().iterator(); iterator.hasNext();) {
				Device device = iterator.next();
				if (!device.isAlive()) {
					iterator.remove();
					device.died();
					continue;
				}
				isDiscoverable(device.getDescriptor());
				monitorDevices.add(new MonitorDevice(device));
			}
		}
		return monitorDevices;
	}

	public DeviceDescriptor[] getDiscoveredDevices(long address) {
		Vector<DeviceDescriptor> discoveredDevice = new Vector<DeviceDescriptor>();
		synchronized (devices) {
			for (Iterator<Device> iterator = devices.values().iterator(); iterator.hasNext();) {
				Device device = iterator.next();
				if (!device.isAlive()) {
					iterator.remove();
					device.died();
					continue;
				}
				if (device.getDescriptor().getAddress() == address) {
					continue;
				}
				if (isDiscoverable(device.getDescriptor())) {
					discoveredDevice.addElement(device.getDescriptor());
				}
			}
		}
		return (DeviceDescriptor[]) discoveredDevice.toArray(new DeviceDescriptor[discoveredDevice.size()]);
	}

	private static boolean isDiscoverable(DeviceDescriptor device) {
		if (!device.isPoweredOn()) {
			return false;
		}
		int discoverableMode = device.getDiscoverableMode();
		switch (discoverableMode) {
		case DiscoveryAgent.NOT_DISCOVERABLE:
			return false;
		case DiscoveryAgent.GIAC:
			return true;
		case DiscoveryAgent.LIAC:
			if (device.getLimitedDiscoverableStart() + configuration.getDurationLIAC() * 1000 * 60 < System
					.currentTimeMillis()) {
				DebugLog.debug(RemoteDeviceHelper.getBluetoothAddress(device.getAddress())
						+ " LIAC -> NOT_DISCOVERABLE");
				device.setDiscoverableMode(DiscoveryAgent.NOT_DISCOVERABLE);
				return false;
			} else {
				return true;
			}
		default:
			// No idea what are other modes are.
			return true;
		}
	}


	public boolean isLocalDevicePowerOn(long localAddress) {
		return getDeviceDescriptor(localAddress).isPoweredOn();
	}

	public void setLocalDevicePower(long localAddress, boolean on) {
		Device device = getDevice(localAddress);
		if (device == null) {
			throw new RuntimeException("No such device " + RemoteDeviceHelper.getBluetoothAddress(localAddress));
		}
		device.setDevicePower(on);
	}

	public int getLocalDeviceDiscoverable(long localAddress) {
		DeviceDescriptor dd = getDeviceDescriptor(localAddress);
		if (!dd.isPoweredOn()) {
			return DiscoveryAgent.NOT_DISCOVERABLE;
		}
		// Update mode if it was LIAC
		isDiscoverable(dd);
		return dd.getDiscoverableMode();
	}

	public boolean setLocalDeviceDiscoverable(long localAddress, int mode) throws BluetoothStateException {
		DeviceDescriptor dd = getDeviceDescriptor(localAddress);
		if (!dd.isPoweredOn()) {
			throw new BluetoothStateException("Device power is off");
		}
		DebugLog.debug(RemoteDeviceHelper.getBluetoothAddress(localAddress) + " setDiscoverableMode", EmulatorUtils
				.discoverableModeString(mode));
		dd.setDiscoverableMode(mode);
		return true;
	}

	public void setLocalDeviceServiceClasses(long localAddress, int classOfDevice) {
		DebugLog.debug(RemoteDeviceHelper.getBluetoothAddress(localAddress) + " setServiceClasses ", classOfDevice);
		getDeviceDescriptor(localAddress).setDeviceClass(classOfDevice);
	}

	public String getRemoteDeviceFriendlyName(long address) throws IOException {
		DeviceDescriptor dd = getDeviceDescriptor(address);
		if (!dd.isPoweredOn()) {
			throw new IOException("Remote device power is off");
		}
		return dd.getName();
	}

	private long getNextAvailableBTAddress(String deviceID, String deviceAddress) throws BluetoothStateException {
		if (deviceID != null) {
			long id = configuration.getFirstDeviceAddress() + Long.parseLong(deviceID);
			if (getDevice(id) != null) {
				throw new BluetoothStateException("Device already reserved "
						+ RemoteDeviceHelper.getBluetoothAddress(id));
			}
			return id;
		} else if (deviceAddress != null) {
			long address = RemoteDeviceHelper.getAddress(deviceAddress);
			if (getDevice(address) != null) {
				throw new BluetoothStateException("Device already reserved "
						+ RemoteDeviceHelper.getBluetoothAddress(address));
			}
			return address;
		} else {
			return EmulatorUtils.getNextAvailable(devices.keySet(), configuration.getFirstDeviceAddress(), 1);
		}

	}

	public void updateServiceRecord(long address, long handle, ServicesDescriptor sdpData)
			throws ServiceRegistrationException {
		Device device = getActiveDevice(address);
		if (device == null) {
			throw new ServiceRegistrationException("No such device " + RemoteDeviceHelper.getBluetoothAddress(address));
		}
		DeviceSDP ds = device.getDeviceSDP(true);
		ds.updateServiceRecord(handle, sdpData);
	}

	public void removeServiceRecord(long address, long handle) throws IOException {
		DeviceSDP ds = getDeviceSDP(address);
		if (ds != null) {
			ds.removeServiceRecord(handle);
		}
	}

	public long[] searchServices(long address, String[] uuidSet) {
		if (getActiveDevice(address) == null) {
			return null;
		}
		DeviceSDP ds = getDeviceSDP(address);
		if (ds == null) {
			return new long[0];
		}
		return ds.searchServices(uuidSet);
	}

	public byte[] getServicesRecordBinary(long address, long handle) throws IOException {
		DeviceSDP ds = getDeviceSDP(address);
		if (ds == null) {
			throw new IOException("No such device " + RemoteDeviceHelper.getBluetoothAddress(address));
		}
		ServicesDescriptor sd = ds.getServicesDescriptor(handle);
		if (sd == null) {
			throw new IOException("No such service");
		}
		return sd.getSdpBinary();
	}

	public void rfOpenService(long localAddress, int channel) throws IOException {
		openService(localAddress, ServiceListener.rfPrefix(channel));
	}

	public long rfAccept(long localAddress, int channel, boolean authenticate, boolean encrypt) throws IOException {
		return accept(localAddress, ServiceListener.rfPrefix(channel), authenticate, encrypt, 0);
	}

	public long rfConnect(long localAddress, long remoteAddress, int channel, boolean authenticate, boolean encrypt,
			int timeout) throws IOException {
		return connect(localAddress, remoteAddress, ServiceListener.rfPrefix(channel), authenticate, encrypt, 0,
				timeout);
	}

	public void rfCloseService(long address, int pcm) {
		closeService(address, ServiceListener.rfPrefix(pcm));
	}

	public void l2OpenService(long localAddress, int pcm) throws IOException {
		openService(localAddress, ServiceListener.l2Prefix(pcm));
	}

	public long l2Accept(long localAddress, int channel, boolean authenticate, boolean encrypt, int receiveMTU)
			throws IOException {
		return accept(localAddress, ServiceListener.l2Prefix(channel), authenticate, encrypt, receiveMTU);
	}

	public long l2Connect(long localAddress, long remoteAddress, int channel, boolean authenticate, boolean encrypt,
			int receiveMTU, int timeout) throws IOException {
		return connect(localAddress, remoteAddress, ServiceListener.l2Prefix(channel), authenticate, encrypt,
				receiveMTU, timeout);
	}

	public void l2CloseService(long address, int channel) {
		closeService(address, ServiceListener.l2Prefix(channel));
	}

	private long accept(long localAddress, String channelID, boolean authenticate, boolean encrypt, int receiveMTU)
			throws IOException {
		Device device;
		if ((device = getActiveDevice(localAddress)) == null) {
			throw new IOException("No such device " + RemoteDeviceHelper.getBluetoothAddress(localAddress));
		}
		ServiceListener sl = device.createServiceListener(channelID);
		return sl.accept(device, authenticate, encrypt, receiveMTU);
	}

	private long connect(long localAddress, long remoteAddress, String portID, boolean authenticate, boolean encrypt,
			int receiveMTU, int timeout) throws IOException {
		Device remoteDevice = getActiveDevice(remoteAddress);
		if (remoteDevice == null) {
			throw new BluetoothConnectionException(BluetoothConnectionException.FAILED_NOINFO, "No such device "
					+ RemoteDeviceHelper.getBluetoothAddress(remoteAddress));
		}
		Device localDevice = getActiveDevice(localAddress);
		if (localDevice == null) {
			throw new BluetoothConnectionException(BluetoothConnectionException.FAILED_NOINFO, "No such device "
					+ RemoteDeviceHelper.getBluetoothAddress(localAddress));
		}
		if (localDevice.getConnectionBuffer(remoteAddress, portID) != null) {
			throw new BluetoothConnectionException(BluetoothConnectionException.FAILED_NOINFO,
					"Already connected to the same port " + portID + " on "
							+ RemoteDeviceHelper.getBluetoothAddress(remoteAddress));
		}
		ServiceListener sl = remoteDevice.connectService(portID, timeout);
		if (sl == null) {
			throw new BluetoothConnectionException(BluetoothConnectionException.UNKNOWN_PSM, "No such service "
					+ portID);
		}
		return sl.connect(localDevice, authenticate, encrypt, receiveMTU, timeout);
	}

	public void connectionAccepted(long localAddress, long connectionId) throws IOException {
		Device device;
		if ((device = getActiveDevice(localAddress)) == null) {
			throw new IOException("No such device " + RemoteDeviceHelper.getBluetoothAddress(localAddress));
		}
		ConnectionBuffer c = device.getConnectionBuffer(connectionId);
		if (c == null) {
			throw new IOException("No such connection " + connectionId);
		}
		c.accepted();
	}

	private void openService(long address, String channelID) throws IOException {
		Device device = getActiveDevice(address);
		if (device == null) {
			throw new IOException("No such device " + RemoteDeviceHelper.getBluetoothAddress(address));
		}
		device.openService(channelID);
	}

	private void closeService(long address, String channelID) {
		Device device = getDevice(address);
		if (device == null) {
			return;
		}
		device.closeService(channelID);
	}


	private ConnectionBuffer getConnectionBuffer(long localAddress, long connectionId) throws IOException {
		Device localDevice = getActiveDevice(localAddress);
		if (localDevice == null) {
			throw new IOException("No such device " + RemoteDeviceHelper.getBluetoothAddress(localAddress));
		}
		ConnectionBuffer c = localDevice.getConnectionBuffer(connectionId);
		if (c == null) {
			throw new IOException("No such connection " + connectionId);
		}
		return c;
	}

	public long getRemoteAddress(long localAddress, long connectionId) throws IOException {
		return getConnectionBuffer(localAddress, connectionId).getRemoteAddress();
	}

	public void rfWrite(long localAddress, long connectionId, byte[] b) throws IOException {
		((ConnectionBufferRFCOMM) getConnectionBuffer(localAddress, connectionId)).rfWrite(b);
	}

	public void rfFlush(long localAddress, long connectionId) throws IOException {
		((ConnectionBufferRFCOMM) getConnectionBuffer(localAddress, connectionId)).rfFlush();
	}

	public int rfAvailable(long localAddress, long connectionId) throws IOException {
		return ((ConnectionBufferRFCOMM) getConnectionBuffer(localAddress, connectionId)).rfAvailable();
	}

	public byte[] rfRead(long localAddress, long connectionId, int len) throws IOException {
		return ((ConnectionBufferRFCOMM) getConnectionBuffer(localAddress, connectionId)).rfRead(len);
	}

	public void closeConnection(long localAddress, long connectionId) throws IOException {
		Device localDevice = getDevice(localAddress);
		if (localDevice == null) {
			throw new IOException("No such device " + RemoteDeviceHelper.getBluetoothAddress(localAddress));
		}
		localDevice.closeConnection(connectionId);
	}

	public int getSecurityOpt(long localAddress, long connectionId, int expected) throws IOException {
		return ((ConnectionBuffer) getConnectionBuffer(localAddress, connectionId)).getSecurityOpt(expected);
	}

	public boolean encrypt(long localAddress, long connectionId, long remoteAddress, boolean on) throws IOException {
		return ((ConnectionBuffer) getConnectionBuffer(localAddress, connectionId)).encrypt(remoteAddress, on);
	}

	public int l2RemoteDeviceReceiveMTU(long localAddress, long connectionId) throws IOException {
		return ((ConnectionBufferL2CAP) getConnectionBuffer(localAddress, connectionId)).getRemoteReceiveMTU();
	}

	public boolean l2Ready(long localAddress, long connectionId) throws IOException {
		return ((ConnectionBufferL2CAP) getConnectionBuffer(localAddress, connectionId)).ready();
	}

	public byte[] l2Receive(long localAddress, long connectionId, int len) throws IOException {
		return ((ConnectionBufferL2CAP) getConnectionBuffer(localAddress, connectionId)).receive(len);
	}

	public void l2Send(long localAddress, long connectionId, byte[] data) throws IOException {
		((ConnectionBufferL2CAP) getConnectionBuffer(localAddress, connectionId)).send(data);
	}
}

Show details Hide details

Change log

r2917 by skarzhevskyy on Mar 13, 2009 Diff

Updated javadocs and Copyright

Go to:

Project members, sign in to write a code review

Older revisions

r2600 by skarzhevskyy on Dec 16, 2008 Diff

Impl should be public

r2599 by skarzhevskyy on Dec 16, 2008 Diff

Emulator configuration properties

r2578 by skarzhevskyy on Dec 13, 2008 Diff

RFCOMM flush(); Block till client
reads all data.

All revisions of this file

File info

Size: 17171 bytes, 486 lines

View raw file

File properties

svn:mime-type: text/plain
svn:eol-style: native
svn:keywords: Date Author Id Revision