import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
/**
 * if bluetooth connection is available, <code>sendBluetoothMessage()</code> run <code>sendReciveMessageThread()</code>.
 * Else, checks if Bluetooth is activated and chooses if close connection or wait again
 */
void sendBluetoothMessage() {
    if (connectionIsAvaible) {
        if (outStream != null) {
            if (sendReciveMessageThread.isInterrupted()) {
                messageThreadExecutor.execute(sendReciveMessageThread);
                System.out.println("thread creato e avviato");
                sendBluetoothMessage();
            } else {
                sendReciveMessageThread.interrupt();
                messageThreadExecutor.execute(sendReciveMessageThread);
            }
        }
    } else {
        try {
            if (LocalDevice.getLocalDevice() != null && !LocalDevice.getLocalDevice().getFriendlyName().equals("null"))
                System.out.println("connessione non stabilita " + LocalDevice.getLocalDevice().getFriendlyName());
            else {
                closeConnection();
            }
        } catch (BluetoothStateException | NullPointerException e) {
            e.printStackTrace();
            closeConnection();
        }
    }
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
private Optional<String> getLocalAddress() {
	try {
		final LocalDevice localDevice = LocalDevice.getLocalDevice();

		// Insert colons into the address because android needs them
		final StringBuilder addressBuilder = new StringBuilder();
		final String originalAddress = localDevice.getBluetoothAddress();
		for (int i = 0; i < originalAddress.length(); i++) {
			addressBuilder.append(originalAddress.charAt(i));
			if (i > 0 && i < originalAddress.length() - 1 && i % 2 != 0) addressBuilder.append(':');
		}

		return Optional.of(addressBuilder.toString());
	} catch (BluetoothStateException e) {
		logger.error("Failed to access local bluetooth device to fetch its address. Ensure the "
				+ "system's bluetooth service is started with \"sudo systemctl start bluetooth\" "
				+ "and the bluetooth stack is on in the system settings", e);
		return Optional.empty();
	}
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
public CoronataException correspondingTo(BluetoothStateException cause) {
	String errorMsg = cause.getMessage().toLowerCase();

	if (errorMsg.contains("librar") && errorMsg.contains("not available")) {
		return problemLoadingLibraries(cause);

	} else if (errorMsg.contains("device is not available") ||
			errorMsg.contains("stack not detected")) {
		return bluetoothAdapterIsOff(cause);

	} else if (errorMsg.contains("device is not ready")) {
		return deviceIsNotReady(cause);

	} else {
		return unexpectedError(cause);
	}
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
public BluetoothPairingInformation initDevicePairingBluetooth()
		throws BluetoothStateException, InterruptedException {
	// This is the first time we are going to touch the Bluetooth API so we
	// should attach our logger to the com.intel.bluetooth logging
	appendBluetoothLogging();

	// Make bluetooth device discoverbale!
	LocalDevice local = LocalDevice.getLocalDevice();
	try {
		local.setDiscoverable(DiscoveryAgent.GIAC);
	} catch (BluetoothStateException e) {
		logger.debug(
				"PanboxClient : initDevicePairingBluetooth : First try to set discoverable failed. Will try again in 1sec.");
		Thread.sleep(1000);
		local.setDiscoverable(DiscoveryAgent.GIAC);
	}

	// setting LocalDevice is only need for Linux, since on Windows we
	// bluecove only supports one device!
	BluetoothPairingInformation info = new BluetoothPairingInformation(local);
	extendPairingInformation(info);
	return info;
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
@Override
public void actionPerformed(ActionEvent e) {
	try {
		BluetoothPairingInformation pInfo = client
				.initDevicePairingBluetooth();
		if (pInfo != null) {
			new PairNewDeviceDialog(clientGuiFrame, client, pInfo);
		} else {
			logger.info("AddDeviceBluetoothActionListener : Bluetooth device pairing aborted!");
		}
	} catch (BluetoothStateException | InterruptedException ex) {
		if (ex.getMessage().contains("Device is not available") || ex.getMessage().contains("BluetoothStack not detected")) {
			JOptionPane
					.showMessageDialog(
							clientGuiFrame,
							bundle.getString("AddDeviceBluetoothActionListener.noDevice.Message"),
							bundle.getString("error"),
							JOptionPane.ERROR_MESSAGE);
		}
		logger.error(
				"AddDeviceBluetoothActionListener : Bluetooth device exited with exception: ",
				ex);
	}
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
/**
 * Creates a new instance.
 * 
 */
MonitoringThreadImpl() throws BluetoothException
{
    super("Bluetooth Monitoring"); //$NON-NLS-1$
    try
    {
        this.localDevice = LocalDevice.getLocalDevice();
    }
    catch (BluetoothStateException e)
    {
        throw new BluetoothException(e.getMessage());
    }

    this.localAddress = localDevice.getBluetoothAddress();
    this.localName = localDevice.getFriendlyName();
    this.discoveryAgent = localDevice.getDiscoveryAgent();

    logger.debug("LocalAdress: " + localAddress + ", Name: " + localName); //$NON-NLS-1$ //$NON-NLS-2$
    
    this.monitoringListeners = new ArrayList();
    this.discoveryInProgress = false;
    this.pass = 0;
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
/**
 * 
 * This method is used to re-establish a connection to a device when we have the address.  
 *
 * @param address The address to the device
 */
public void startServiceSearch(String address){
    // Connects to a remote device with the given address     
    RemoteDeviceInstance remoteDevice = new RemoteDeviceInstance(address);
    try{
        localDevice = LocalDevice.getLocalDevice();   
        agent = localDevice.getDiscoveryAgent();
        uuids[0] = new UUID(uuidString, false);
        servicesFound = new Vector();
        devicesFound = new Vector();
        agent.searchServices(attributes,uuids,remoteDevice,this);
    }catch(BluetoothStateException bse) {
        log.logException("BluetoothServiceDiscovery.startServiceSearch()",bse, false);
        // throw bse;
    }
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
public int searchService(int[] attrSet, UUID[] uuidSet, RemoteDevice btDev,
        DiscoveryListener discListener) throws BluetoothStateException,
        IllegalArgumentException {

    if (DEBUG) {
        System.out.println("- serviceSearcher: initializing");
    }
    initialize(attrSet, uuidSet, btDev);

    if (discListener == null) {
        throw new NullPointerException("DiscoveryListener is null");
    }
    this.discListener = discListener;

    return start();
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
private BluetoothServer() {
	clients = new ConcurrentHashMap<Integer, BluetoothClient>();
	try {
		device = LocalDevice.getLocalDevice();
		if (device != null) {
			if (!LocalDevice.isPowerOn()) {
				System.out.println("Device power is off. Turn it on!");
				System.exit(1);
			}
		} else {
			System.out.println("No device");
			System.exit(1);
		}
	} catch (BluetoothStateException e) {
		System.out.println(e.getMessage());
		System.exit(1);

	}
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
static void loadNativeLibraries(BluetoothStack stack) throws BluetoothStateException {
	// Check is libraries already loaded
	try {
		if ((UtilsJavaSE.canCallNotLoadedNativeMethod) && (stack.isNativeCodeLoaded())) {
			return;
		}
	} catch (Error e) {
		// We caught UnsatisfiedLinkError
	}
	LibraryInformation[] libs = stack.requireNativeLibraries();
	if ((libs == null) || (libs.length == 0)) {
		// No native libs for this stack
		return;
	}
	for (int i = 0; i < libs.length; i++) {
		Class c = libs[i].stackClass;
		if (c == null) {
			c = stack.getClass();
		}
		if (!NativeLibLoader.isAvailable(libs[i].libraryName, c)) {
			throw new BluetoothStateException("BlueCove library " + libs[i].libraryName + " not available");
		}
	}
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
/**
 * Applications should not used this function.
 *
 * @return current BluetoothStack implementation
 * @throws BluetoothStateException
 *             when BluetoothStack not detected. If one connected the hardware later, BlueCove would be able to
 *             recover and start correctly
 * @exception Error
 *                if called from outside of BlueCove internal code.
 */
public synchronized BluetoothStack getBluetoothStack() throws BluetoothStateException {
	Utils.isLegalAPICall(fqcnSet);
	BluetoothStackHolder sh = currentStackHolder(false);
	if ((sh != null) && (sh.bluetoothStack != null)) {
		return sh.bluetoothStack;
	} else if ((sh == null) && (threadStack != null)) {
		throw new BluetoothStateException("No BluetoothStack or Adapter for current thread");
	}

	BluetoothStack stack;
	if (accessControlContext == null) {
		stack = detectStack();
	} else {
		stack = detectStackPrivileged();
	}
	return stack;
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
/**
 * Start DeviceInquiry and wait for startException or deviceInquiryStartedCallback
 */
static boolean startInquiry(BluetoothStack stack, DeviceInquiryRunnable inquiryRunnable, int accessCode,
		DiscoveryListener listener) throws BluetoothStateException {
	DeviceInquiryThread t = (new DeviceInquiryThread(stack, inquiryRunnable, accessCode, listener));
	// In case the BTStack hangs, exit JVM anyway
	UtilsJavaSE.threadSetDaemon(t);
	synchronized (t.inquiryStartedEvent) {
		t.start();
		while (!t.started && !t.terminated) {
			try {
				t.inquiryStartedEvent.wait();
			} catch (InterruptedException e) {
				return false;
			}
			if (t.startException != null) {
				throw t.startException;
			}
		}
	}
	DebugLog.debug("startInquiry return", t.started);
	return t.started;
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
public void run() {
	int respCode = DiscoveryListener.SERVICE_SEARCH_ERROR;
	try {
		BlueCoveImpl.setThreadBluetoothStack(stack);
		respCode = serachRunnable.runSearchServices(this, attrSet, uuidSet, device, listener);
	} catch (BluetoothStateException e) {
		startException = e;
		return;
	} finally {
		finished = true;
		unregisterThread();
		synchronized (serviceSearchStartedEvent) {
			serviceSearchStartedEvent.notifyAll();
		}
		DebugLog.debug("runSearchServices ends", getTransID());
		if (started) {
			Utils.j2meUsagePatternDellay();
			listener.serviceSearchCompleted(getTransID(), respCode);
		}
	}
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
@Override
public void deviceDiscovered(RemoteDevice device, DeviceClass deviceClass) {
	UUID[] uuids = new UUID[] {new UUID(uuid, false)};
	// Try to discover the services associated with the UUID
	try {
		discoveryAgent.searchServices(null, uuids, device, this);
		searches.incrementAndGet();
	} catch (BluetoothStateException e) {
		if (LOG.isLoggable(WARNING)) LOG.log(WARNING, e.toString(), e);
	}
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
private void makeDeviceDiscoverable() {
	// Try to make the device discoverable (requires root on Linux)
	try {
		localDevice.setDiscoverable(GIAC);
	} catch (BluetoothStateException e) {
		if (LOG.isLoggable(WARNING)) LOG.log(WARNING, e.toString(), e);
	}
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
private void discoverDevices() throws BluetoothStateException {
    foundDevices = new ArrayList<>();
    agent.startInquiry(DiscoveryAgent.GIAC, getDiscoveryListener());
    try {
        synchronized (LOCK) {
            LOCK.wait();
        }
    } catch (InterruptedException e) {
        LOGGER.error("Error when discoverDevices().", e);
        fireBluetooothEvent(new ErrorEvent(e, this));
    }
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
private void discoverServices(RFCommBluetoothDevice device) throws BluetoothStateException {
    this.tempDevice = device;
    agent.searchServices(null, uuidSet, this.tempDevice.getRemoteDevice(), getDiscoveryListener());
    try {
        synchronized (LOCK) {
            LOCK.wait();
        }
    } catch (InterruptedException e) {
        LOGGER.error("Error when discoverServices().", e);
        fireBluetooothEvent(new ErrorEvent(e, this));
    }
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
private CoronataException
		problemLoadingLibraries(BluetoothStateException cause) {
	return new CoronataException(cause,
			"Unable to load required libraries for BlueCove.\n" +
			"\tCheck if the requirements described here were met:" +
			" http://www.bluecove.org/bluecove-gpl/index.html\n" +
			"\tTry installing one of these packages:" +
			" libbluetooth-dev (Ubuntu)," +
			" bluez-libs-devel (Fedora), bluez-devel (openSUSE)\n" +
			"");
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
@Override
State run() {
	try {
		BlueCoveLibraryFacade blueCoveLib = new BlueCoveLibraryFacade();
		leObserver.searchStarted(false);
		return states.startInquiry(blueCoveLib);

	} catch (BluetoothStateException e) {
		return states.bluetoothException(e);
	}
}
 

import javax.bluetooth.BluetoothStateException; //导入依赖的package包/类
BluetoothExceptionState(StateFactory states,
		CoronataLifecycleEventsObserver leObserver,
		BluetoothStateException exception) {
	this.states = states;
	this.leObserver = leObserver;
	this.exception = exception;
}