BluetoothStackMicrosoft.java - bluecove - Java library for Bluetooth

Source path: svn/ trunk/ bluecove/ src/ main/ java/ com/ intel/ bluetooth/ BluetoothStackMicrosoft.java

‹r2915

r3067

/**
 *  BlueCove - Java library for Bluetooth
 *  Copyright (C) 2006-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.
 *
 *  @version $Id$
 */
package com.intel.bluetooth;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import javax.bluetooth.BluetoothConnectionException;
import javax.bluetooth.BluetoothStateException;
import javax.bluetooth.DataElement;
import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.ServiceRegistrationException;
import javax.bluetooth.UUID;

class BluetoothStackMicrosoft implements BluetoothStack {

	private static final int BTH_MODE_POWER_OFF = 1;

	private static final int BTH_MODE_CONNECTABLE = 2;

	private static final int BTH_MODE_DISCOVERABLE = 3;

	private static BluetoothStackMicrosoft singleInstance = null;

	private boolean peerInitialized = false;

	private boolean windowsCE;

	private long localBluetoothAddress = 0;

	private DiscoveryListener currentDeviceDiscoveryListener;

	private Thread limitedDiscoverableTimer;

	// TODO what is the real number for Attributes retrievable ?
	private final static int ATTR_RETRIEVABLE_MAX = 256;

	private Hashtable deviceDiscoveryDevices;

	private static int connectThreadNumber;

	private static synchronized int nextConnectThreadNum() {
		return connectThreadNumber++;
	}

	BluetoothStackMicrosoft() {
	}

	// ---------------------- Library initialization

	public String getStackID() {
		return BlueCoveImpl.STACK_WINSOCK;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#isNativeCodeLoaded()
	 */
	public native boolean isNativeCodeLoaded();

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#requireNativeLibraries()
	 */
	public LibraryInformation[] requireNativeLibraries() {
		return LibraryInformation.library(BlueCoveImpl.NATIVE_LIB_MS);
	}

	public String toString() {
		return getStackID();
	}

	public native int getLibraryVersion();

	public native int detectBluetoothStack();

	public native void enableNativeDebug(Class nativeDebugCallback, boolean on);

	private static native int initializationStatus() throws IOException;

	private native void uninitialize();

	private native boolean isWindowsCE();

	public void initialize() throws BluetoothStateException {
		if (singleInstance != null) {
			throw new BluetoothStateException("Only one instance of " + getStackID() + " stack supported");
		}
		try {
			int status = initializationStatus();
			DebugLog.debug("initializationStatus", status);
			if (status == 1) {
				peerInitialized = true;
			}
			windowsCE = isWindowsCE();
			singleInstance = this;
		} catch (BluetoothStateException e) {
			throw e;
		} catch (IOException e) {
			DebugLog.fatal("initialization", e);
			throw new BluetoothStateException(e.getMessage());
		}
	}

	public void destroy() {
		if (singleInstance != this) {
			throw new RuntimeException("Destroy invalid instance");
		}
		if (peerInitialized) {
			peerInitialized = false;
			uninitialize();
		}
		cancelLimitedDiscoverableTimer();
		singleInstance = null;
	}

	private void initialized() throws BluetoothStateException {
		if (!peerInitialized) {
			throw new BluetoothStateException("Bluetooth system is unavailable");
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#getFeatureSet()
	 */
	public int getFeatureSet() {
		return FEATURE_SERVICE_ATTRIBUTES | (windowsCE ? 0 : FEATURE_SET_DEVICE_SERVICE_CLASSES);
	}

	// ---------------------- LocalDevice

	private native int getDeviceClass(long address);

	private native void setDiscoverable(boolean on) throws BluetoothStateException;

	private native int getBluetoothRadioMode();

	private native String getradioname(long address);

	private native int getDeviceVersion(long address);

	private native int getDeviceManufacturer(long address);

	public String getLocalDeviceBluetoothAddress() {
		try {
			long socket = socket(false, false);
			bind(socket);
			localBluetoothAddress = getsockaddress(socket);
			String address = RemoteDeviceHelper.getBluetoothAddress(localBluetoothAddress);
			storesockopt(socket);
			close(socket);
			return address;
		} catch (IOException e) {
			DebugLog.error("get local bluetoothAddress", e);
			return "000000000000";
		}
	}

	public String getLocalDeviceName() {
		if (localBluetoothAddress == 0) {
			getLocalDeviceBluetoothAddress();
		}
		return getradioname(localBluetoothAddress);
	}

	public String getRemoteDeviceFriendlyName(long address) throws IOException {
		return getpeername(address);
	}

	public DeviceClass getLocalDeviceClass() {
		return new DeviceClass(getDeviceClass(localBluetoothAddress));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#setLocalDeviceServiceClasses(int)
	 */
	public void setLocalDeviceServiceClasses(int classOfDevice) {
		// Done in rfServerUpdateServiceRecord
	}

	private void cancelLimitedDiscoverableTimer() {
		if (limitedDiscoverableTimer != null) {
			limitedDiscoverableTimer.interrupt();
			limitedDiscoverableTimer = null;
		}
	}

	public boolean setLocalDeviceDiscoverable(int mode) throws BluetoothStateException {
		switch (mode) {
		case DiscoveryAgent.NOT_DISCOVERABLE:
			cancelLimitedDiscoverableTimer();
			DebugLog.debug("setDiscoverable(false)");
			setDiscoverable(false);
			return (DiscoveryAgent.NOT_DISCOVERABLE == getLocalDeviceDiscoverable());
		case DiscoveryAgent.GIAC:
			cancelLimitedDiscoverableTimer();
			DebugLog.debug("setDiscoverable(true)");
			setDiscoverable(true);
			return (DiscoveryAgent.GIAC == getLocalDeviceDiscoverable());
		case DiscoveryAgent.LIAC:
			cancelLimitedDiscoverableTimer();
			DebugLog.debug("setDiscoverable(LIAC)");
			setDiscoverable(true);
			if (!(DiscoveryAgent.GIAC == getLocalDeviceDiscoverable())) {
				return false;
			}
			// Timer to turn it off
			limitedDiscoverableTimer = Utils.schedule(60 * 1000, new Runnable() {
				public void run() {
					try {
						setDiscoverable(false);
					} catch (BluetoothStateException e) {
						DebugLog.debug("error setDiscoverable", e);
					} finally {
						limitedDiscoverableTimer = null;
					}
				}
			});
			return true;
		}
		return false;
	}

	public boolean isLocalDevicePowerOn() {
		int mode = getBluetoothRadioMode();
		if (mode == BTH_MODE_POWER_OFF) {
			return false;
		}
		return ((mode == BTH_MODE_CONNECTABLE) || (mode == BTH_MODE_DISCOVERABLE));
	}

	public int getLocalDeviceDiscoverable() {
		int mode = getBluetoothRadioMode();
		if (mode == BTH_MODE_DISCOVERABLE) {
			if (limitedDiscoverableTimer != null) {
				DebugLog.debug("Discoverable = LIAC");
				return DiscoveryAgent.LIAC;
			} else {
				DebugLog.debug("Discoverable = GIAC");
				return DiscoveryAgent.GIAC;
			}
		} else {
			DebugLog.debug("Discoverable = NOT_DISCOVERABLE");
			return DiscoveryAgent.NOT_DISCOVERABLE;
		}
	}

	public String getLocalDeviceProperty(String property) {
		if (BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_DEVICES_MAX.equals(property)) {
			return "7";
		}
		if (BluetoothConsts.PROPERTY_BLUETOOTH_SD_TRANS_MAX.equals(property)) {
			return "7";
		}
		if (BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_INQUIRY_SCAN.equals(property)) {
			return BlueCoveImpl.TRUE;
		}
		if (BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_PAGE_SCAN.equals(property)) {
			return BlueCoveImpl.TRUE;
		}
		if (BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_INQUIRY.equals(property)) {
			return BlueCoveImpl.TRUE;
		}
		if (BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_PAGE.equals(property)) {
			return BlueCoveImpl.TRUE;
		}

		if (BluetoothConsts.PROPERTY_BLUETOOTH_SD_ATTR_RETRIEVABLE_MAX.equals(property)) {
			return String.valueOf(ATTR_RETRIEVABLE_MAX);
		}
		if (BluetoothConsts.PROPERTY_BLUETOOTH_MASTER_SWITCH.equals(property)) {
			return BlueCoveImpl.FALSE;
		}
		if (BluetoothConsts.PROPERTY_BLUETOOTH_L2CAP_RECEIVEMTU_MAX.equals(property)) {
			return "0";
		}

		if (BlueCoveLocalDeviceProperties.LOCAL_DEVICE_RADIO_VERSION.equals(property)) {
			return String.valueOf(getDeviceVersion(localBluetoothAddress));
		}
		if (BlueCoveLocalDeviceProperties.LOCAL_DEVICE_RADIO_MANUFACTURER.equals(property)) {
			return String.valueOf(getDeviceManufacturer(localBluetoothAddress));
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#isCurrentThreadInterruptedCallback()
	 */
	public boolean isCurrentThreadInterruptedCallback() {
		return UtilsJavaSE.isCurrentThreadInterrupted();
	}

	private native boolean retrieveDevicesImpl(int option, RetrieveDevicesCallback retrieveDevicesCallback);

	public RemoteDevice[] retrieveDevices(int option) {
		if (windowsCE) {
			return null;
		}
		final Vector devices = new Vector();
		RetrieveDevicesCallback retrieveDevicesCallback = new RetrieveDevicesCallback() {
			public void deviceFoundCallback(long deviceAddr, int deviceClass, String deviceName, boolean paired) {
				DebugLog.debug("device found", deviceAddr);
				RemoteDevice remoteDevice = RemoteDeviceHelper.createRemoteDevice(BluetoothStackMicrosoft.this,
						deviceAddr, deviceName, paired);
				devices.add(remoteDevice);
			}
		};
		if (retrieveDevicesImpl(option, retrieveDevicesCallback)) {
			return RemoteDeviceHelper.remoteDeviceListToArray(devices);
		} else {
			return null;
		}
	}

	private native boolean isRemoteDeviceTrustedImpl(long address);

	public Boolean isRemoteDeviceTrusted(long address) {
		if (windowsCE) {
			return null;
		}
		return new Boolean(isRemoteDeviceTrustedImpl(address));
	}

	private native boolean isRemoteDeviceAuthenticatedImpl(long address);

	public Boolean isRemoteDeviceAuthenticated(long address) {
		if (windowsCE) {
			return null;
		}
		return new Boolean(isRemoteDeviceAuthenticatedImpl(address));
	}

	private native boolean authenticateRemoteDeviceImpl(long address, String passkey) throws IOException;

	public boolean authenticateRemoteDevice(long address) throws IOException {
		return authenticateRemoteDeviceImpl(address, null);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#authenticateRemoteDevice(long, java.lang.String)
	 */
	public boolean authenticateRemoteDevice(long address, String passkey) throws IOException {
		return authenticateRemoteDeviceImpl(address, passkey);
	}

	private native void removeAuthenticationWithRemoteDeviceImpl(long address) throws IOException;

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#removeAuthenticationWithRemoteDevice (long)
	 */
	public void removeAuthenticationWithRemoteDevice(long address) throws IOException {
		removeAuthenticationWithRemoteDeviceImpl(address);
	}

	// ---------------------- Device Inquiry

	/*
     * perform synchronous inquiry
     */
    private native int runDeviceInquiryImpl(DeviceInquiryRunnable inquiryRunnable, DeviceInquiryThread inquiryThread, int accessCode, int duration,
            DiscoveryListener listener) throws BluetoothStateException;
    
	public boolean startInquiry(int accessCode, DiscoveryListener listener) throws BluetoothStateException {
		initialized();
		if (currentDeviceDiscoveryListener != null) {
			throw new BluetoothStateException("Another inquiry already running");
		}
		currentDeviceDiscoveryListener = listener;
		
		DeviceInquiryRunnable inquiryRunnable = new DeviceInquiryRunnable() {

            public int runDeviceInquiry(DeviceInquiryThread inquiryThread, int accessCode, DiscoveryListener listener) throws BluetoothStateException {
                try {
                    deviceDiscoveryDevices = new Hashtable();
                    int discType = runDeviceInquiryImpl(this, inquiryThread, accessCode, DeviceInquiryThread
                            .getConfigDeviceInquiryDuration(), listener);
                    if (discType == DiscoveryListener.INQUIRY_COMPLETED) {
                        for (Enumeration en = deviceDiscoveryDevices.keys(); en.hasMoreElements();) {
                            RemoteDevice remoteDevice = (RemoteDevice) en.nextElement();
                            DeviceClass deviceClass = (DeviceClass) deviceDiscoveryDevices.get(remoteDevice);
                            listener.deviceDiscovered(remoteDevice, deviceClass);
                            // If cancelInquiry has been called
                            if (currentDeviceDiscoveryListener == null) {
                                return DiscoveryListener.INQUIRY_TERMINATED;
                            }
                        }
                    }
                    return discType;
                } finally {
                    deviceDiscoveryDevices = null;
                    currentDeviceDiscoveryListener = null;
                }
            }

            /**
             * This is called when all device discoved by stack. To avoid problems with getpeername we will postpone the calls
             * to User deviceDiscovered function until runDeviceInquiry is finished.
             */
            public void deviceDiscoveredCallback(DiscoveryListener listener, long deviceAddr, int deviceClass, String deviceName, boolean paired) {
                RemoteDevice remoteDevice = RemoteDeviceHelper.createRemoteDevice(BluetoothStackMicrosoft.this, deviceAddr, deviceName, paired);
                if ((currentDeviceDiscoveryListener == null) || (deviceDiscoveryDevices == null)
                        || (currentDeviceDiscoveryListener != listener)) {
                    return;
                }
                DeviceClass cod = new DeviceClass(deviceClass);
                DebugLog.debug("deviceDiscoveredCallback address", remoteDevice.getBluetoothAddress());
                DebugLog.debug("deviceDiscoveredCallback deviceClass", cod);
                deviceDiscoveryDevices.put(remoteDevice, cod);
                
            }
		};
		return DeviceInquiryThread.startInquiry(this, inquiryRunnable, accessCode, listener);
	}

	/*
	 * cancel current inquiry (if any)
	 */
	private native boolean cancelInquiry();

	public boolean cancelInquiry(DiscoveryListener listener) {
		if (currentDeviceDiscoveryListener != listener) {
			return false;
		}
		// no further deviceDiscovered() events will occur for this inquiry
		currentDeviceDiscoveryListener = null;
		return cancelInquiry();
	}

	// ---------------------- Service search

	/*
	 * perform synchronous service discovery
	 */
	private native int[] runSearchServicesImpl(UUID[] uuidSet, long address) throws SearchServicesException;

	/*
	 * get service attributes
	 */
	public native byte[] getServiceAttributes(int[] attrIDs, long address, int handle) throws IOException;

	public int searchServices(int[] attrSet, UUID[] uuidSet, RemoteDevice device, DiscoveryListener listener)
			throws BluetoothStateException {
	    
	    SearchServicesRunnable searchRunnable = new SearchServicesRunnable() {

            public int runSearchServices(SearchServicesThread sst, int[] attrSet, UUID[] uuidSet, RemoteDevice device, DiscoveryListener listener)
                    throws BluetoothStateException {
                sst.searchServicesStartedCallback();
                int[] handles;
                try {
                    handles = runSearchServicesImpl(uuidSet, RemoteDeviceHelper.getAddress(device));
                } catch (SearchServicesDeviceNotReachableException e) {
                    return DiscoveryListener.SERVICE_SEARCH_DEVICE_NOT_REACHABLE;
                } catch (SearchServicesTerminatedException e) {
                    return DiscoveryListener.SERVICE_SEARCH_TERMINATED;
                } catch (SearchServicesException e) {
                    return DiscoveryListener.SERVICE_SEARCH_ERROR;
                }
                if (handles == null) {
                    return DiscoveryListener.SERVICE_SEARCH_ERROR;
                } else if (handles.length > 0) {
                    ServiceRecord[] records = new ServiceRecordImpl[handles.length];
                    int[] requiredAttrIDs = new int[] { BluetoothConsts.ServiceRecordHandle,
                            BluetoothConsts.ServiceClassIDList, BluetoothConsts.ServiceRecordState, BluetoothConsts.ServiceID,
                            BluetoothConsts.ProtocolDescriptorList };
                    boolean hasError = false;
                    for (int i = 0; i < handles.length; i++) {
                        records[i] = new ServiceRecordImpl(BluetoothStackMicrosoft.this, device, handles[i]);
                        try {
                            records[i].populateRecord(requiredAttrIDs);
                            if (attrSet != null) {
                                records[i].populateRecord(attrSet);
                            }
                        } catch (Exception e) {
                            DebugLog.debug("populateRecord error", e);
                            hasError = true;
                        }
                        if (sst.isTerminated()) {
                            return DiscoveryListener.SERVICE_SEARCH_TERMINATED;
                        }
                    }
                    listener.servicesDiscovered(sst.getTransID(), records);
                    if (hasError) {
                        return DiscoveryListener.SERVICE_SEARCH_ERROR;
                    } else {
                        return DiscoveryListener.SERVICE_SEARCH_COMPLETED;
                    }
                } else {
                    return DiscoveryListener.SERVICE_SEARCH_NO_RECORDS;
                }
            }
	        
	    };
		return SearchServicesThread.startSearchServices(this, searchRunnable, attrSet, uuidSet, device, listener);
	}

	public boolean cancelServiceSearch(int transID) {
		SearchServicesThread sst = SearchServicesThread.getServiceSearchThread(transID);
		if (sst != null) {
			return sst.setTerminated();
		} else {
			return false;
		}
	}

	public boolean populateServicesRecordAttributeValues(ServiceRecordImpl serviceRecord, int[] attrIDs)
			throws IOException {
		if (attrIDs.length > ATTR_RETRIEVABLE_MAX) {
			throw new IllegalArgumentException();
		}
		/*
		 * retrieve SDP blob
		 */
		byte[] blob = getServiceAttributes(attrIDs, RemoteDeviceHelper.getAddress(serviceRecord.getHostDevice()),
				(int) serviceRecord.getHandle());

		if (blob.length > 0) {
			try {
				boolean anyRetrived = false;
				DataElement element = (new SDPInputStream(new ByteArrayInputStream(blob))).readElement();
				for (Enumeration e = (Enumeration) element.getValue(); e.hasMoreElements();) {
					int attrID = (int) ((DataElement) e.nextElement()).getLong();
					serviceRecord.populateAttributeValue(attrID, (DataElement) e.nextElement());
					if (!anyRetrived) {
						for (int i = 0; i < attrIDs.length; i++) {
							if (attrIDs[i] == attrID) {
								anyRetrived = true;
								break;
							}
						}
					}
				}
				return anyRetrived;
			} catch (IOException e) {
				throw e;
			} catch (Throwable e) {
				throw new IOException();
			}
		} else {
			return false;
		}
	}

	/*
	 * socket operations
	 */
	private native long socket(boolean authenticate, boolean encrypt) throws IOException;

	private native long getsockaddress(long socket) throws IOException;

	private native void storesockopt(long socket);

	private native int getsockchannel(long socket) throws IOException;

	private native void connect(long socket, long address, int channel, int retryUnreachable) throws IOException;

	private native void bind(long socket) throws IOException;

	private native void listen(long socket) throws IOException;

	private native long accept(long socket) throws IOException;

	private native int recvAvailable(long socket) throws IOException;

	private native int recv(long socket) throws IOException;

	private native int recv(long socket, byte[] b, int off, int len) throws IOException;

	private native void send(long socket, int b) throws IOException;

	private native void send(long socket, byte[] b, int off, int len) throws IOException;

	private native void close(long socket) throws IOException;

	private native String getpeername(long address) throws IOException;

	private native long getpeeraddress(long socket) throws IOException;

	// ---------------------- Client RFCOMM connections

	private class ConnectThread extends Thread {

		final Object event;

		final long socket;

		final BluetoothConnectionParams params;

		final int retryUnreachable;

		volatile IOException error;

		volatile boolean success = false;

		volatile boolean connecting = true;

		ConnectThread(Object event, long socket, BluetoothConnectionParams params) {
			super("ConnectThread-" + nextConnectThreadNum());
			this.event = event;
			this.socket = socket;
			this.params = params;
			retryUnreachable = BlueCoveImpl.getConfigProperty(
					BlueCoveConfigProperties.PROPERTY_CONNECT_UNREACHABLE_RETRY, 2);

		}

		public void run() {
			try {
				connect(socket, params.address, params.channel, retryUnreachable);
				success = true;
			} catch (IOException e) {
				error = e;
			} finally {
				connecting = false;
				synchronized (event) {
					event.notifyAll();
				}
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2OpenClientConnection(com.intel.bluetooth .BluetoothConnectionParams,
	 * int, int)
	 */
	public long connectionRfOpenClientConnection(final BluetoothConnectionParams params) throws IOException {
		final long socket = socket(params.authenticate, params.encrypt);

		// Allow to interrupt connection thread
		final Object event = new Object();
		ConnectThread connectThread = new ConnectThread(event, socket, params);
		UtilsJavaSE.threadSetDaemon(connectThread);

		boolean timeoutHappend = false;

		synchronized (event) {
			connectThread.start();
			while (connectThread.connecting) {
				try {
					if (params.timeouts) {
						event.wait(params.timeout);
						timeoutHappend = connectThread.connecting;
						connectThread.interrupt();
						break;
					} else {
						event.wait();
					}
				} catch (InterruptedException e) {
					try {
						close(socket);
					} catch (Exception ignore) {
					}
					throw new InterruptedIOException();
				}
			}
		}
		if (!connectThread.success) {
			try {
				close(socket);
			} catch (Exception ignore) {
			}
		}
		if (connectThread.error != null) {
			throw connectThread.error;
		}

		if (!connectThread.success) {
			if (timeoutHappend) {
				throw new BluetoothConnectionException(BluetoothConnectionException.TIMEOUT);
			} else {
				throw new BluetoothConnectionException(BluetoothConnectionException.FAILED_NOINFO);
			}
		}
		return socket;
	}

	public void connectionRfCloseClientConnection(long handle) throws IOException {
		close(handle);
	}

	public long rfServerOpen(BluetoothConnectionNotifierParams params, ServiceRecordImpl serviceRecord)
			throws IOException {
		/*
		 * open socket
		 */
		long socket = socket(params.authenticate, params.encrypt);
		boolean success = false;
		try {

			synchronized (this) {
				bind(socket);
			}
			listen(socket);

			int channel = getsockchannel(socket);
			DebugLog.debug("service channel ", channel);

			long serviceRecordHandle = socket;
			serviceRecord.populateRFCOMMAttributes(serviceRecordHandle, channel, params.uuid, params.name, params.obex);

			/*
			 * register service
			 */
			serviceRecord.setHandle(registerService(serviceRecord.toByteArray(), serviceRecord.deviceServiceClasses));

			success = true;
		} finally {
			if (!success) {
				try {
					close(socket);
				} catch (IOException e) {
					DebugLog.debug("close on failure", e);
				}
			}
		}
		return socket;
	}

	public void rfServerClose(long handle, ServiceRecordImpl serviceRecord) throws IOException {
		try {
			/*
			 * close socket
			 */
			close(handle);
		} finally {
			/*
			 * unregister service
			 */
			unregisterService(serviceRecord.getHandle());
		}
	}

	/*
	 * register service
	 */
	private native long registerService(byte[] record, int classOfDevice) throws ServiceRegistrationException;

	/*
	 * unregister service
	 */
	private native void unregisterService(long handle) throws ServiceRegistrationException;

	public long rfServerAcceptAndOpenRfServerConnection(long handle) throws IOException {
		return accept(handle);
	}

	public void rfServerUpdateServiceRecord(long handle, ServiceRecordImpl serviceRecord, boolean acceptAndOpen)
			throws ServiceRegistrationException {
		unregisterService(serviceRecord.getHandle());
		byte[] blob;
		try {
			blob = serviceRecord.toByteArray();
		} catch (IOException e) {
			throw new ServiceRegistrationException(e.toString());
		}
		serviceRecord.setHandle(registerService(blob, serviceRecord.deviceServiceClasses));
		DebugLog.debug("new serviceRecord", serviceRecord);
	}

	public void connectionRfCloseServerConnection(long handle) throws IOException {
		connectionRfCloseClientConnection(handle);
	}

	public long getConnectionRfRemoteAddress(long handle) throws IOException {
		return getpeeraddress(handle);
	}

	public int connectionRfRead(long handle) throws IOException {
		return recv(handle);
	}

	public int connectionRfRead(long handle, byte[] b, int off, int len) throws IOException {
		return recv(handle, b, off, len);
	}

	public int connectionRfReadAvailable(long handle) throws IOException {
		return recvAvailable(handle);
	}

	public void connectionRfWrite(long handle, int b) throws IOException {
		send(handle, b);
	}

	public void connectionRfWrite(long handle, byte[] b, int off, int len) throws IOException {
		send(handle, b, off, len);
	}

	public void connectionRfFlush(long handle) throws IOException {
		// TODO are there any flush
	}

	public int rfGetSecurityOpt(long handle, int expected) throws IOException {
		return expected;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2Encrypt(long,long,boolean)
	 */
	public boolean rfEncrypt(long address, long handle, boolean on) throws IOException {
		return false;
	}

	// ---------------------- Client and Server L2CAP connections

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2OpenClientConnection(com.intel.bluetooth .BluetoothConnectionParams,
	 * int, int)
	 */
	public long l2OpenClientConnection(BluetoothConnectionParams params, int receiveMTU, int transmitMTU)
			throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2CloseClientConnection(long)
	 */
	public void l2CloseClientConnection(long handle) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @seecom.intel.bluetooth.BluetoothStack#l2ServerOpen(com.intel.bluetooth. BluetoothConnectionNotifierParams, int,
	 * int, com.intel.bluetooth.ServiceRecordImpl)
	 */
	public long l2ServerOpen(BluetoothConnectionNotifierParams params, int receiveMTU, int transmitMTU,
			ServiceRecordImpl serviceRecord) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2ServerUpdateServiceRecord(long, com.intel.bluetooth.ServiceRecordImpl,
	 * boolean)
	 */
	public void l2ServerUpdateServiceRecord(long handle, ServiceRecordImpl serviceRecord, boolean acceptAndOpen)
			throws ServiceRegistrationException {
		throw new ServiceRegistrationException("Not Supported on" + getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2ServerAcceptAndOpenServerConnection (long)
	 */
	public long l2ServerAcceptAndOpenServerConnection(long handle) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2CloseServerConnection(long)
	 */
	public void l2CloseServerConnection(long handle) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2ServerClose(long, com.intel.bluetooth.ServiceRecordImpl)
	 */
	public void l2ServerClose(long handle, ServiceRecordImpl serviceRecord) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2GetSecurityOpt(long, int)
	 */
	public int l2GetSecurityOpt(long handle, int expected) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2Ready(long)
	 */
	public boolean l2Ready(long handle) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2receive(long, byte[])
	 */
	public int l2Receive(long handle, byte[] inBuf) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2send(long, byte[])
	 */
	public void l2Send(long handle, byte[] data, int transmitMTU) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2GetReceiveMTU(long)
	 */
	public int l2GetReceiveMTU(long handle) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2GetTransmitMTU(long)
	 */
	public int l2GetTransmitMTU(long handle) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2RemoteAddress(long)
	 */
	public long l2RemoteAddress(long handle) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.intel.bluetooth.BluetoothStack#l2Encrypt(long,long,boolean)
	 */
	public boolean l2Encrypt(long address, long handle, boolean on) throws IOException {
		throw new NotSupportedIOException(getStackID());
	}
}

Show details Hide details

Change log

r2945 by skarzhevskyy on Mar 21, 2009 Diff

honor requested TransmitMTU

Go to:

Project members, sign in to write a code review

Older revisions

r2915 by skarzhevskyy on Mar 13, 2009 Diff

Updated javadocs and Copyright

r2730 by skarzhevskyy on Feb 11, 2009 Diff

work with local device properties

r2638 by skarzhevskyy on Dec 22, 2008 Diff

proper java code for InquiryRunnable
and SearchServicesRunnable

All revisions of this file

File info

Size: 30883 bytes, 991 lines

View raw file

File properties

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