xref: /external/sl4a/Common/src/com/googlecode/android_scripting/facade/bluetooth/BluetoothSocketConnFacade.java

/*
 * Copyright 2017 The Android Open Source Project
 *
 * Licensed 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.
 */

package com.googlecode.android_scripting.facade.bluetooth;

import android.app.Service;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.os.Bundle;

import com.googlecode.android_scripting.Log;
import com.googlecode.android_scripting.facade.EventFacade;
import com.googlecode.android_scripting.facade.FacadeManager;
import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
import com.googlecode.android_scripting.rpc.Rpc;
import com.googlecode.android_scripting.rpc.RpcDefault;
import com.googlecode.android_scripting.rpc.RpcOptional;
import com.googlecode.android_scripting.rpc.RpcParameter;

import org.apache.commons.codec.binary.Base64Codec;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * Bluetooth functions.
 *
 */

public class BluetoothSocketConnFacade extends RpcReceiver {
    private final Service mService;
    private final BluetoothAdapter mBluetoothAdapter;
    private Map<String, BluetoothConnection> mConnections =
            new HashMap<String, BluetoothConnection>();
    private final EventFacade mEventFacade;
    private ConnectThread mConnectThread;
    private AcceptThread mAcceptThread;
    private byte mTxPktIndex = 0;

    private final Bundle mGoodNews;
    private final Bundle mBadNews;

    private static final String DEFAULT_PSM = "161";  //=0x00A1

    // UUID for SL4A.
    protected static final String DEFAULT_UUID = "457807c0-4897-11df-9879-0800200c9a66";
    protected static final String SDP_NAME = "SL4A";

    protected static final String DEFAULT_LE_DATA_LENGTH = "23";

    public BluetoothSocketConnFacade(FacadeManager manager) {
        super(manager);
        mEventFacade = manager.getReceiver(EventFacade.class);
        mService = manager.getService();
        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

        mGoodNews = new Bundle();
        mGoodNews.putBoolean("Status", true);
        mBadNews = new Bundle();
        mBadNews.putBoolean("Status", false);
    }

    private BluetoothConnection getConnection(String connID) throws IOException {
        if (connID == null) {
            throw new IOException("Connection ID is null");
        }
        Log.d("BluetoothConnection:getConnection: connID=" + connID);
        BluetoothConnection conn = null;
        if (connID.trim().length() > 0) {
            conn = mConnections.get(connID);
        } else if (mConnections.size() == 1) {
            conn = (BluetoothConnection) mConnections.values().toArray()[0];
        } else {
            Log.e("More than one available connections. Num=" + mConnections.size());
            throw new IOException("More than 1 available connections. Num=" + mConnections.size());
        }
        if (conn == null) {
            throw new IOException("Bluetooth connection not established. connID=" + connID);
        }
        return conn;
    }

    private String addConnection(BluetoothConnection conn) {
        String uuid = UUID.randomUUID().toString();
        mConnections.put(uuid, conn);
        conn.setUUID(uuid);
        return uuid;
    }

    /**
     * Create L2CAP socket to Bluetooth device
     *
     * @param address the bluetooth address to open the socket on
     * @param channel the channel to open the socket on
     * @throws Exception
     */
    @Rpc(description = "Create L2CAP socket to Bluetooth deice")
    public void bluetoothSocketConnCreateL2capSocket(@RpcParameter(name = "address") String address,
            @RpcParameter(name = "channel") Integer channel) throws Exception {
        BluetoothDevice mDevice;
        mDevice = mBluetoothAdapter.getRemoteDevice(address);
        Class bluetoothDeviceClass = Class.forName("android.bluetooth.BluetoothDevice");
        Method createL2capSocketMethod =
                bluetoothDeviceClass.getMethod("createL2capSocket", int.class);
        createL2capSocketMethod.invoke(mDevice, channel);
    }

    /**
     * Begin Connect Thread using UUID
     *
     * @param address the mac address of the device to connect to
     * @param uuid the UUID that is used by the server device
     * @throws Exception
     */
    @Rpc(description = "Begins a thread initiate an L2CAP socket connection over Bluetooth. ")
    public void bluetoothSocketConnBeginConnectThreadUuid(
            @RpcParameter(name = "address",
            description = "The mac address of the device to connect to.") String address,
            @RpcParameter(name = "uuid",
            description = "The UUID passed here must match the UUID used by the server device.")
            @RpcDefault(DEFAULT_UUID) String uuid)
            throws IOException {
        BluetoothDevice mDevice;
        mDevice = mBluetoothAdapter.getRemoteDevice(address);
        ConnectThread connectThread = new ConnectThread(mDevice, uuid);
        connectThread.start();
        mConnectThread = connectThread;
    }

    /**
     * Begin Connect Thread using PSM value
     *
     * @param address the mac address of the device to connect to
     * @param isBle the transport is LE
     * @param psmValue the assigned PSM value to use for this socket connection
     * @throws Exception
     */
    @Rpc(description = "Begins a thread initiate an L2CAP CoC connection over Bluetooth. ")
    public void bluetoothSocketConnBeginConnectThreadPsm(
            @RpcParameter(name = "address",
            description = "The mac address of the device to connect to.") String address,
            @RpcParameter(name = "isBle", description = "Is transport BLE?") @RpcDefault("false")
            Boolean isBle,
            @RpcParameter(name = "psmValue") @RpcDefault(DEFAULT_PSM) Integer psmValue,
            @RpcParameter(name = "securedConn") @RpcDefault("false") Boolean securedConn)
            throws IOException {
        BluetoothDevice mDevice;
        mDevice = mBluetoothAdapter.getRemoteDevice(address);
        Log.d("bluetoothSocketConnBeginConnectThreadPsm: Coc connecting to " + address + ", isBle="
                + isBle + ", psmValue=" + psmValue + ", securedConn=" + securedConn);
        ConnectThread connectThread = new ConnectThread(mDevice, psmValue, isBle, securedConn);
        connectThread.start();
        mConnectThread = connectThread;
    }

    /**
     * Get last connection ID
     *
     * @return String the last connection ID
     * @throws Exception
     */
    @Rpc(description = "Returns the connection ID of the last connection.")
    public String bluetoothGetLastConnId()
            throws IOException {
        if (mAcceptThread != null) {
            String connUuid = mAcceptThread.getConnUuid();
            Log.d("bluetoothGetLastConnId from Accept Thread: connUuid=" + connUuid);
            return connUuid;
        }
        if (mConnectThread != null) {
            String connUuid = mConnectThread.getConnUuid();
            Log.d("bluetoothGetLastConnId from Connect Thread: connUuid=" + connUuid);
            return connUuid;
        }
        Log.e("bluetoothGetLastConnId: No active threads");
        return null;
    }

    /**
     * Kill the connect thread
     */
    @Rpc(description = "Kill thread")
    public void bluetoothSocketConnKillConnThread() {
        try {
            mConnectThread.cancel();
            mConnectThread.join(5000);
        } catch (InterruptedException e) {
            Log.e("Interrupted Exception: " + e.toString());
        }
    }

    /**
     * Closes an active Client socket
     *
     * @throws Exception
     */
    @Rpc(description = "Close an active Client socket")
    public void bluetoothSocketConnEndConnectThread() throws IOException {
        mConnectThread.cancel();
    }

    /**
     * Closes an active Server socket
     *
     * @throws Exception
     */
    @Rpc(description = "Close an active Server socket")
    public void bluetoothSocketConnEndAcceptThread() throws IOException {
        mAcceptThread.cancel();
    }

    /**
     * Returns active Bluetooth mConnections
     *
     * @return map of active connections and its remote addresses
     */
    @Rpc(description = "Returns active Bluetooth mConnections.")
    public Map<String, String> bluetoothSocketConnActiveConnections() {
        Map<String, String> out = new HashMap<String, String>();
        for (Map.Entry<String, BluetoothConnection> entry : mConnections.entrySet()) {
            if (entry.getValue().isConnected()) {
                out.put(entry.getKey(), entry.getValue().getRemoteBluetoothAddress());
            }
        }
        return out;
    }

    /**
     * Returns the name of the connected device
     *
     * @return string name of connected device
     * @throws Exception
     */
    @Rpc(description = "Returns the name of the connected device.")
    public String bluetoothSocketConnGetConnectedDeviceName(
            @RpcParameter(name = "connID", description = "Connection id") @RpcOptional
            @RpcDefault("") String connID)
            throws IOException {
        BluetoothConnection conn = getConnection(connID);
        return conn.getConnectedDeviceName();
    }

    /**
     * Begins a thread to accept an L2CAP connection over Bluetooth with UUID
     *
     * @param uuid the UUID to identify this L2CAP connection
     * @param timeout the time to wait for new connection
     * @throws Exception
     */
    @Rpc(description = "Begins a thread to accept an L2CAP connection over Bluetooth. ")
    public void bluetoothSocketConnBeginAcceptThreadUuid(
            @RpcParameter(name = "uuid") @RpcDefault(DEFAULT_UUID) String uuid,
            @RpcParameter(name = "timeout",
            description = "How long to wait for a new connection, 0 is wait for ever")
            @RpcDefault("0") Integer timeout)
            throws IOException {
        Log.d("bluetoothSocketConnBeginAcceptThreadUuid: uuid=" + uuid);
        AcceptThread acceptThread = new AcceptThread(uuid, timeout.intValue());
        acceptThread.start();
        mAcceptThread = acceptThread;
    }

    /**
     * Begins a thread to accept an L2CAP connection over Bluetooth with PSM value
     *
     * @param psmValue the PSM value to identify this L2CAP connection
     * @param timeout the time to wait for new connection
     * @param isBle whether this connection uses LE transport
     * @throws Exception
     */
    @Rpc(description = "Begins a thread to accept an Coc connection over Bluetooth. ")
    public void bluetoothSocketConnBeginAcceptThreadPsm(
            @RpcParameter(name = "timeout",
                      description = "How long to wait for a new connection, 0 is wait for ever")
            @RpcDefault("0") Integer timeout,
            @RpcParameter(name = "isBle",
                      description = "Is transport BLE?")
            @RpcDefault("false") Boolean isBle,
            @RpcParameter(name = "securedConn",
                      description = "Using secured connection?")
            @RpcDefault("false") Boolean securedConn,
            @RpcParameter(name = "psmValue") @RpcDefault(DEFAULT_PSM) Integer psmValue)
            throws IOException {
        Log.d("bluetoothSocketConnBeginAcceptThreadPsm: PSM value=" + psmValue);
        AcceptThread acceptThread = new AcceptThread(psmValue.intValue(), timeout.intValue(),
                                                     isBle, securedConn);
        acceptThread.start();
        mAcceptThread = acceptThread;
    }

    /**
     * Get the current BluetoothServerSocket PSM value
     * @return Integer the assigned PSM value
     * @throws Exception
     */
    @Rpc(description = "Returns the PSM value")
    public Integer bluetoothSocketConnGetPsm() throws IOException  {
        Integer psm = new Integer(mAcceptThread.getPsm());
        Log.d("bluetoothSocketConnGetPsm: PSM value=" + psm);
        return psm;
    }

    /**
     * Set the current BluetoothSocket LE Data Length value to the maximum supported by this BT
     * controller. This command suggests to the BT controller to set its maximum transmission packet
     * size.
     * @throws Exception
     */
    @Rpc(description = "Request Maximum Tx Data Length")
    public void bluetoothSocketRequestMaximumTxDataLength()
            throws IOException  {
        Log.d("bluetoothSocketRequestMaximumTxDataLength");

        if (mConnectThread == null) {
            String connUuid = mConnectThread.getConnUuid();
            throw new IOException("bluetoothSocketRequestMaximumTxDataLength: no active connect"
                                  + " thread");
        }

        BluetoothSocket socket = mConnectThread.getSocket();
        if (socket == null) {
            throw new IOException("bluetoothSocketRequestMaximumTxDataLength: no active connect"
                                  + " socket");
        }
        socket.requestMaximumTxDataLength();
    }

    /**
     * Sends ASCII characters over the currently open Bluetooth connection
     *
     * @param ascii the string to write
     * @param connID the connection ID
     * @throws Exception
     */
    @Rpc(description = "Sends ASCII characters over the currently open Bluetooth connection.")
    public void bluetoothSocketConnWrite(@RpcParameter(name = "ascii") String ascii,
            @RpcParameter(name = "connID", description = "Connection id")
            @RpcDefault("") String connID)
            throws IOException {
        BluetoothConnection conn = getConnection(connID);
        try {
            conn.write(ascii);
        } catch (IOException e) {
            mConnections.remove(conn.getUUID());
            throw e;
        }
    }

    /**
     * Read up to bufferSize ASCII characters
     *
     * @param bufferSize the size of buffer to read
     * @param connID the connection ID
     * @return the string buffer containing the read ASCII characters
     * @throws Exception
     */
    @Rpc(description = "Read up to bufferSize ASCII characters.")
    public String bluetoothSocketConnRead(
            @RpcParameter(name = "bufferSize") @RpcDefault("4096") Integer bufferSize,
            @RpcParameter(name = "connID", description = "Connection id") @RpcOptional
            @RpcDefault("") String connID)
            throws IOException {
        BluetoothConnection conn = getConnection(connID);
        try {
            return conn.read(bufferSize);
        } catch (IOException e) {
            mConnections.remove(conn.getUUID());
            throw e;
        }
    }

    /**
     * Send bytes over the currently open Bluetooth connection
     *
     * @param base64 the based64-encoded string to write
     * @param connID the connection ID
     * @throws Exception
     */
    @Rpc(description = "Send bytes over the currently open Bluetooth connection.")
    public void bluetoothSocketConnWriteBinary(
            @RpcParameter(name = "base64",
            description = "A base64 encoded String of the bytes to be sent.") String base64,
            @RpcParameter(name = "connID",
            description = "Connection id") @RpcDefault("") @RpcOptional String connID)
            throws IOException {
        BluetoothConnection conn = getConnection(connID);
        try {
            conn.write(Base64Codec.decodeBase64(base64));
        } catch (IOException e) {
            mConnections.remove(conn.getUUID());
            throw e;
        }
    }

    /**
     * Read up to bufferSize bytes and return a chunked, base64 encoded string
     *
     * @param bufferSize the size of buffer to read
     * @param connID the connection ID
     * @return the string buffer containing the read base64-encoded characters
     * @throws Exception
     */
    @Rpc(description = "Read up to bufferSize bytes and return a chunked, base64 encoded string.")
    public String bluetoothSocketConnReadBinary(
            @RpcParameter(name = "bufferSize") @RpcDefault("4096") Integer bufferSize,
            @RpcParameter(name = "connID", description = "Connection id") @RpcDefault("")
            @RpcOptional String connID)
            throws IOException {

        BluetoothConnection conn = getConnection(connID);
        try {
            return Base64Codec.encodeBase64String(conn.readBinary(bufferSize));
        } catch (IOException e) {
            mConnections.remove(conn.getUUID());
            throw e;
        }
    }

    /**
     * Returns true if the next read is guaranteed not to block
     *
     * @param connID the connection ID
     * @return true if the the next read is guaranteed not to block
     * @throws Exception
     */
    @Rpc(description = "Returns True if the next read is guaranteed not to block.")
    public Boolean bluetoothSocketConnReadReady(
            @RpcParameter(name = "connID", description = "Connection id") @RpcDefault("")
            @RpcOptional String connID)
            throws IOException {
        BluetoothConnection conn = getConnection(connID);
        try {
            return conn.readReady();
        } catch (IOException e) {
            mConnections.remove(conn.getUUID());
            throw e;
        }
    }

    /**
     * Read the next line
    *
    * @param connID the connection ID
    * @return the string buffer containing the read line
    * @throws Exception
     */
    @Rpc(description = "Read the next line.")
    public String bluetoothSocketConnReadLine(
            @RpcParameter(name = "connID", description = "Connection id") @RpcOptional
            @RpcDefault("") String connID)
            throws IOException {
        BluetoothConnection conn = getConnection(connID);
        try {
            return conn.readLine();
        } catch (IOException e) {
            mConnections.remove(conn.getUUID());
            throw e;
        }
    }

    private static byte getNextOutputChar(byte in) {
        in++;
        if (in >= 'z') {
            in = 'a';
        }
        return in;
    }

    private static int getNextOutputChar(int in) {
        in++;
        if (in >= 'z') {
            in = 'a';
        }
        return in;
    }

    /**
     * Send a data buffer with auto-generated data
     *
     * @param numBuffers the number of buffers to send
     * @param bufferSize the buffer size in bytes
     * @param connID the connection ID
     * @throws Exception
     */
    @Rpc(description = "Send a large buffer of bytes for throughput test")
    public void bluetoothConnectionThroughputSend(
            @RpcParameter(name = "numBuffers", description = "number of buffers")
            Integer numBuffers,
            @RpcParameter(name = "bufferSize", description = "buffer size") Integer bufferSize,
            @RpcParameter(name = "connID", description = "Connection id")
            @RpcDefault("") @RpcOptional String connID)
            throws IOException {

        Log.d("bluetoothConnectionThroughputSend: numBuffers=" + numBuffers + ", bufferSize="
                + bufferSize + ", connID=" + connID + ", mTxPktIndex=" + mTxPktIndex);

        // Generate a buffer of given size
        byte[] outBuf = new byte[bufferSize];
        byte outChar = 'a';
        // The first byte is the buffer index
        int i = 0;
        outBuf[i++] = mTxPktIndex;
        for (; i < bufferSize; i++) {
            outBuf[i] = outChar;
            outChar = getNextOutputChar(outChar);
        }

        BluetoothConnection conn = getConnection(connID);
        try {
            for (i = 0; i < numBuffers; i++) {
                Log.d("bluetoothConnectionThroughputSend: sending " + i + " buffer.");
                outBuf[0] = mTxPktIndex++;
                conn.write(outBuf);
            }
        } catch (IOException e) {
            mConnections.remove(conn.getUUID());
            throw e;
        }
    }

    /**
     * Read a number of data buffers and make sure the data is correct
     *
     * @param numBuffers the number of buffers to send
     * @param bufferSize the buffer size in bytes
     * @param connID the connection ID
     * @return the data rate read in terms of bytes per second
     * @throws Exception
     */
    @Rpc(description = "Returns the throughput in bytes-per-sec, or Returns 0 if unsuccessful")
    public Integer bluetoothConnectionThroughputRead(
            @RpcParameter(name = "numBuffers", description = "number of buffers")
            Integer numBuffers,
            @RpcParameter(name = "bufferSize", description = "buffer size") Integer bufferSize,
            @RpcParameter(name = "connID", description = "Connection id")
            @RpcDefault("") @RpcOptional String connID)
            throws IOException {

        Log.d("bluetoothConnectionThroughputRead: numBuffers=" + numBuffers + ", bufferSize="
                + bufferSize);

        BluetoothConnection conn = getConnection(connID);

        long startTesttime = System.currentTimeMillis();

        byte bufIndex = (byte) 0x00FF;

        try {

            ByteArrayOutputStream tmp_array = new ByteArrayOutputStream();
            for (int i = 0; i < numBuffers; i++) {
                // Read one buffer
                while (tmp_array.size() < bufferSize) {
                    byte[] tmp_read = conn.readBinary(bufferSize);
                    if (tmp_read.length == 0) {
                        break;
                    }
                    tmp_array.write(tmp_read);
                }
                byte[] readBuf = tmp_array.toByteArray();
                tmp_array.reset();

                // Make sure the contents are valid
                int nextInChar = 'a';
                int j = 0;
                // The first byte is the buffer index
                if (i == 0) {
                    bufIndex = readBuf[j];
                } else {
                    bufIndex++;
                    if (bufIndex != readBuf[j]) {
                        Log.e("bluetoothConnectionThroughputRead: Wrong Buffer index (First byte). "
                                + "Expected=" + bufIndex + ", read=" + readBuf[j]);
                        throw new IOException("bluetoothConnectionThroughputRead: Wrong Buffer("
                                              + (i + 1) + ") index (First byte). Expected="
                                              + bufIndex + ", read=" + readBuf[j]);
                    }
                }
                Log.d("bluetoothConnectionThroughputRead: First byte=" + bufIndex);
                j++;

                for (; j < bufferSize; j++) {
                    if (readBuf[j] != nextInChar) {
                        Log.e("Last Read Char Read wrong value. Read=" + String.valueOf(readBuf[j])
                                + ", Expected=" + String.valueOf(nextInChar));
                        throw new IOException("Read mismatched at buf=" + i + ", idx=" + j);
                    }
                    nextInChar = getNextOutputChar(nextInChar);
                }
                Log.d("bluetoothConnectionThroughputRead: Buffer Read index=" + i);
                if (bufferSize < readBuf.length) {
                    tmp_array.write(readBuf, bufferSize, readBuf.length - bufferSize);
                }
            }

            long endTesttime = System.currentTimeMillis();

            long diffTime = endTesttime - startTesttime;  // time delta in milliseconds
            Log.d("bluetoothConnectionThroughputRead: Completed! numBuffers=" + numBuffers
                    + ",delta time=" + diffTime + " millisec");
            long numBytes = numBuffers * bufferSize;
            long dataRatePerMsec;
            if (diffTime > 0) {
                dataRatePerMsec = (1000L * numBytes) / diffTime;
            } else {
                dataRatePerMsec = 9999;
            }
            Integer dataRate = new Integer((int) dataRatePerMsec);

            Log.d("bluetoothConnectionThroughputRead: Completed! numBytes=" + numBytes
                    + ", data rate=" + dataRate + " bytes per sec");

            return dataRate;
        } catch (IOException e) {
            mConnections.remove(conn.getUUID());
            throw e;
        }
    }

    /**
     * Stops Bluetooth connection
     *
     * @param connID the connection ID
     */
    @Rpc(description = "Stops Bluetooth connection.")
    public void bluetoothSocketConnStop(
            @RpcParameter(name = "connID", description = "Connection id") @RpcOptional
            @RpcDefault("") String connID) {
        BluetoothConnection conn;
        try {
            conn = getConnection(connID);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        if (conn == null) {
            Log.d("bluetoothSocketConnStop: conn is NULL. connID=%s" + connID);
            return;
        }
        Log.d("bluetoothSocketConnStop: connID=" + connID + ", UUID=" + conn.getUUID());

        conn.stop();
        mConnections.remove(conn.getUUID());

        if (mAcceptThread != null) {
            mAcceptThread.cancel();
        }
        if (mConnectThread != null) {
            mConnectThread.cancel();
        }
    }

    @Override
    public void shutdown() {
        for (Map.Entry<String, BluetoothConnection> entry : mConnections.entrySet()) {
            entry.getValue().stop();
        }
        mConnections.clear();
        if (mAcceptThread != null) {
            mAcceptThread.cancel();
        }
        if (mConnectThread != null) {
            mConnectThread.cancel();
        }
    }

    private class ConnectThread extends Thread {
        private final BluetoothSocket mSocket;
        private final Boolean mIsBle;
        String mConnUuid;

        ConnectThread(BluetoothDevice device, String uuid) {
            BluetoothSocket tmp = null;
            try {
                tmp = device.createRfcommSocketToServiceRecord(UUID.fromString(uuid));
            } catch (IOException createSocketException) {
                Log.e("Failed to create socket: " + createSocketException.toString());
            }
            mIsBle = false;
            mSocket = tmp;
        }

        ConnectThread(BluetoothDevice device,
                             @RpcParameter(name = "psmValue")
                             @RpcDefault(DEFAULT_PSM) Integer psmValue,
                             @RpcParameter(name = "isBle") @RpcDefault("false") boolean isBle,
                             @RpcParameter(name = "securedConn")
                             @RpcDefault("false") boolean securedConn) {
            BluetoothSocket tmp = null;
            Log.d("ConnectThread: psmValue=" + psmValue + ", isBle=" + isBle
                        + ", securedConn=" + securedConn);
            try {
                if (isBle) {
                    if (securedConn) {
                        tmp = device.createL2capChannel(psmValue);
                    } else {
                        tmp = device.createInsecureL2capChannel(psmValue);
                    }
                } else {
                    if (securedConn) {
                        tmp = device.createL2capSocket(psmValue);
                    } else {
                        tmp = device.createInsecureL2capSocket(psmValue);
                    }
                }
                // Secured version: tmp = device.createL2capSocket(0x1011);
                // tmp = device.createRfcommSocketToServiceRecord(UUID.fromString(uuid));
            } catch (IOException createSocketException) {
                Log.e("Failed to create socket: " + createSocketException.toString());
            }
            mIsBle = isBle;
            mSocket = tmp;
        }

        public void run() {
            mBluetoothAdapter.cancelDiscovery();
            try {
                BluetoothConnection conn;
                mSocket.connect();
                conn = new BluetoothConnection(mSocket);
                mConnUuid = addConnection(conn);
                Log.d("ConnectThread:run: isConnected=" + mSocket.isConnected() + ", address="
                        + mSocket.getRemoteDevice().getAddress() + ", uuid=" + mConnUuid);
                if (mSocket.isConnected()) {
                    mEventFacade.postEvent("BluetoothSocketConnectSuccess", mGoodNews);
                } else {
                    mEventFacade.postEvent("BluetoothSocketConnectError", mBadNews);
                }
            } catch (IOException connectException) {
                Log.e("ConnectThread::run(): Error: Connection Unsuccessful");
                cancel();
                mEventFacade.postEvent("BluetoothSocketConnectError", mBadNews);
                return;
            }
        }

        public void cancel() {
            if (mSocket != null) {
                try {
                    mSocket.close();
                } catch (IOException closeException) {
                    Log.e("Failed to close socket: " + closeException.toString());
                }
            }
        }

        public BluetoothSocket getSocket() {
            return mSocket;
        }

        public String getConnUuid() {
            Log.d("ConnectThread::getConnUuid(): mConnUuid=" + mConnUuid);
            return mConnUuid;
        }
    }

    private class AcceptThread extends Thread {
        private final BluetoothServerSocket mServerSocket;
        private final int mTimeout;
        private BluetoothSocket mSocket;
        String mConnUuid;

        AcceptThread(String uuid, int timeout) {
            BluetoothServerSocket tmp = null;
            mTimeout = timeout;
            try {
                tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(SDP_NAME,
                        UUID.fromString(uuid));
            } catch (IOException createSocketException) {
                Log.e("Failed to create socket: " + createSocketException.toString());
            }
            mServerSocket = tmp;
            Log.d("AcceptThread: uuid=" + uuid);
        }

        AcceptThread(int psmValue, int timeout, boolean isBle, boolean securedConn) {
            BluetoothServerSocket tmp = null;
            mTimeout = timeout;
            try {
                // Secured version: mBluetoothAdapter.listenUsingL2capOn(0x1011, false, false);
                if (isBle) {
                    /* Assigned a dynamic LE_PSM Value */
                    if (securedConn) {
                        tmp = mBluetoothAdapter.listenUsingL2capChannel();
                    } else {
                        tmp = mBluetoothAdapter.listenUsingInsecureL2capChannel();
                    }
                } else {
                    if (securedConn) {
                        tmp = mBluetoothAdapter.listenUsingL2capOn(psmValue);
                    } else {
                        tmp = mBluetoothAdapter.listenUsingInsecureL2capOn(psmValue);
                    }
                }
            } catch (IOException createSocketException) {
                Log.e("Failed to create Coc socket: " + createSocketException.toString());
            }
            mServerSocket = tmp;
            Log.d("AcceptThread: securedConn=" + securedConn + ", Old PSM value=" + psmValue
                        + ", new PSM=" + getPsm());
        }

        public void run() {
            try {
                mSocket = mServerSocket.accept(mTimeout);
                BluetoothConnection conn = new BluetoothConnection(mSocket, mServerSocket);
                mConnUuid = addConnection(conn);
                Log.d("AcceptThread:run: isConnected=" + mSocket.isConnected() + ", address="
                        + mSocket.getRemoteDevice().getAddress() + ", uuid=" + mConnUuid);
            } catch (IOException connectException) {
                Log.e("AcceptThread:run: Failed to connect socket: " + connectException.toString());
                if (mSocket != null) {
                    cancel();
                }
                return;
            }
        }

        public void cancel() {
            Log.d("AcceptThread:cancel: mmSocket=" + mSocket + ", mmServerSocket=" + mServerSocket);
            if (mSocket != null) {
                try {
                    mSocket.close();
                } catch (IOException closeException) {
                    Log.e("Failed to close socket: " + closeException.toString());
                }
            }
            if (mServerSocket != null) {
                try {
                    mServerSocket.close();
                } catch (IOException closeException) {
                    Log.e("Failed to close socket: " + closeException.toString());
                }
            }
        }

        public BluetoothSocket getSocket() {
            return mSocket;
        }

        public int getPsm() {
            return mServerSocket.getPsm();
        }

        public String getConnUuid() {
            Log.d("ConnectThread::getConnUuid(): mConnUuid=" + mConnUuid);
            return mConnUuid;
        }
    }
}