/*
 * Copyright 2018 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.android.cts.verifier.bluetooth;

import android.app.Service;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattServer;
import android.bluetooth.BluetoothGattServerCallback;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.bluetooth.le.AdvertiseCallback;
import android.bluetooth.le.AdvertiseData;
import android.bluetooth.le.AdvertiseSettings;
import android.bluetooth.le.BluetoothLeAdvertiser;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.ParcelUuid;
import android.util.Log;
import android.widget.Toast;

import com.android.cts.verifier.R;

import java.io.IOException;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import java.util.Timer;
import java.util.UUID;

public class BleCocServerService extends Service {

    public static final boolean DEBUG = true;
    public static final String TAG = "BleCocServerService";

    public static final int COMMAND_ADD_SERVICE = 0;
    public static final int COMMAND_WRITE_CHARACTERISTIC = 1;
    public static final int COMMAND_WRITE_DESCRIPTOR = 2;

    public static final int TEST_DATA_EXCHANGE_BUFSIZE = 8 * 1024;

    public static final String BLE_BLUETOOTH_MISMATCH_SECURE =
            "com.android.cts.verifier.bluetooth.BLE_BLUETOOTH_MISMATCH_SECURE";
    public static final String BLE_BLUETOOTH_MISMATCH_INSECURE =
            "com.android.cts.verifier.bluetooth.BLE_BLUETOOTH_MISMATCH_INSECURE";
    public static final String BLE_BLUETOOTH_DISABLED =
            "com.android.cts.verifier.bluetooth.BLE_BLUETOOTH_DISABLED";

    public static final String BLE_ACTION_COC_SERVER_INSECURE =
            "com.android.cts.verifier.bluetooth.BLE_ACTION_COC_SERVER_INSECURE";
    public static final String BLE_ACTION_COC_SERVER_SECURE =
            "com.android.cts.verifier.bluetooth.BLE_ACTION_COC_SERVER_SECURE";

    public static final String BLE_ACTION_SERVER_SECURE =
            "com.android.cts.verifier.bluetooth.BLE_ACTION_SERVER_SECURE";
    public static final String BLE_ACTION_SERVER_NON_SECURE =
            "com.android.cts.verifier.bluetooth.BLE_ACTION_SERVER_NON_SECURE";

    public static final String BLE_LE_CONNECTED =
            "com.android.cts.verifier.bluetooth.BLE_LE_CONNECTED";
    public static final String BLE_COC_LISTENER_CREATED =
            "com.android.cts.verifier.bluetooth.BLE_COC_LISTENER_CREATED";
    public static final String BLE_PSM_READ =
            "com.android.cts.verifier.bluetooth.BLE_PSM_READ";
    public static final String BLE_COC_CONNECTED =
            "com.android.cts.verifier.bluetooth.BLE_COC_CONNECTED";
    public static final String BLE_CONNECTION_TYPE_CHECKED =
            "com.android.cts.verifier.bluetooth.BLE_CONNECTION_TYPE_CHECKED";
    public static final String BLE_DATA_8BYTES_READ =
            "com.android.cts.verifier.bluetooth.BLE_DATA_8BYTES_READ";
    public static final String BLE_DATA_LARGEBUF_READ =
            "com.android.cts.verifier.bluetooth.BLE_DATA_LARGEBUF_READ";
    public static final String BLE_DATA_8BYTES_SENT =
            "com.android.cts.verifier.bluetooth.BLE_DATA_8BYTES_SENT";
    public static final String BLE_LE_DISCONNECTED =
            "com.android.cts.verifier.bluetooth.BLE_LE_DISCONNECTED";
    public static final String BLE_COC_SERVER_ACTION_SEND_DATA_8BYTES =
            "com.android.cts.verifier.bluetooth.BLE_COC_SERVER_ACTION_SEND_DATA_8BYTES";
    public static final String BLE_COC_SERVER_ACTION_EXCHANGE_DATA =
            "com.android.cts.verifier.bluetooth.BLE_COC_SERVER_ACTION_EXCHANGE_DATA";
    public static final String BLE_COC_SERVER_ACTION_DISCONNECT =
            "com.android.cts.verifier.bluetooth.BLE_COC_SERVER_ACTION_DISCONNECT";

    public static final String BLE_SERVER_DISCONNECTED =
            "com.android.cts.verifier.bluetooth.BLE_SERVER_DISCONNECTED";
    public static final String BLE_OPEN_FAIL =
            "com.android.cts.verifier.bluetooth.BLE_OPEN_FAIL";
    public static final String BLE_ADVERTISE_UNSUPPORTED =
            "com.android.cts.verifier.bluetooth.BLE_ADVERTISE_UNSUPPORTED";
    public static final String BLE_ADD_SERVICE_FAIL =
            "com.android.cts.verifier.bluetooth.BLE_ADD_SERVICE_FAIL";

    private static final UUID SERVICE_UUID =
            UUID.fromString("00009999-0000-1000-8000-00805f9b34fb");
    private static final UUID CHARACTERISTIC_UUID =
            UUID.fromString("00009998-0000-1000-8000-00805f9b34fb");
    private static final UUID CHARACTERISTIC_RESULT_UUID =
            UUID.fromString("00009974-0000-1000-8000-00805f9b34fb");
    private static final UUID UPDATE_CHARACTERISTIC_UUID =
            UUID.fromString("00009997-0000-1000-8000-00805f9b34fb");
    private static final UUID DESCRIPTOR_UUID =
            UUID.fromString("00009996-0000-1000-8000-00805f9b34fb");
    public static final UUID ADV_COC_SERVICE_UUID=
            UUID.fromString("00003334-0000-1000-8000-00805f9b34fb");

    private static final UUID SERVICE_UUID_ADDITIONAL =
            UUID.fromString("00009995-0000-1000-8000-00805f9b34fb");
    private static final UUID SERVICE_UUID_INCLUDED =
            UUID.fromString("00009994-0000-1000-8000-00805f9b34fb");

    // Variable for registration permission of Descriptor
    private static final UUID DESCRIPTOR_NO_READ_UUID =
            UUID.fromString("00009973-0000-1000-8000-00805f9b34fb");
    private static final UUID DESCRIPTOR_NO_WRITE_UUID =
            UUID.fromString("00009972-0000-1000-8000-00805f9b34fb");
    private static final UUID DESCRIPTOR_NEED_ENCRYPTED_READ_UUID =
            UUID.fromString("00009969-0000-1000-8000-00805f9b34fb");
    private static final UUID DESCRIPTOR_NEED_ENCRYPTED_WRITE_UUID =
            UUID.fromString("00009968-0000-1000-8000-00805f9b34fb");

    private static final int CONN_INTERVAL = 150;   // connection interval 150ms

    private static final int EXECUTION_DELAY = 1500;

    // Delay of notification when secure test failed to start.
    private static final long NOTIFICATION_DELAY_OF_SECURE_TEST_FAILURE = 5 * 1000;

    public static final String WRITE_VALUE = "SERVER_TEST";
    private static final String NOTIFY_VALUE = "NOTIFY_TEST";
    private static final String INDICATE_VALUE = "INDICATE_TEST";
    public static final String READ_NO_PERMISSION = "READ_NO_CHAR";
    public static final String WRITE_NO_PERMISSION = "WRITE_NO_CHAR";
    public static final String DESCRIPTOR_READ_NO_PERMISSION = "READ_NO_DESC";
    public static final String DESCRIPTOR_WRITE_NO_PERMISSION = "WRITE_NO_DESC";

    private BluetoothManager mBluetoothManager;
    private BluetoothGattServer mGattServer;
    private BluetoothGattService mService;
    private BluetoothDevice mDevice;
    private Handler mHandler;
    private BluetoothLeAdvertiser mAdvertiser;
    private boolean mSecure;
    private int mMtuSize = -1;

    private BluetoothServerSocket mServerSocket;
    private int mPsm = -1;
    private BluetoothGattCharacteristic mLePsmCharacteristic;
    BluetoothChatService mChatService;

    private int mNextReadExpectedLen = -1;
    private String mNextReadCompletionIntent;
    private int mTotalReadLen = 0;
    private byte mNextReadByte;
    private int mNextWriteExpectedLen = -1;
    private String mNextWriteCompletionIntent = null;

    // Handler for communicating task with peer.
    private TestTaskQueue mTaskQueue;

    // current test category
    private String mCurrentAction;

    // Task to notify failure of starting secure test.
    //   Secure test calls BluetoothDevice#createBond() when devices were not paired.
    //   createBond() causes onConnectionStateChange() twice, and it works as strange sequence.
    //   At the first onConnectionStateChange(), target device is not paired (bond state is
    //   BluetoothDevice.BOND_NONE).
    //   At the second onConnectionStateChange(), target devices is paired (bond state is
    //   BluetoothDevice.BOND_BONDED).
    //   CTS Verifier will perform lazy check of bond state. Verifier checks bond state
    //   after NOTIFICATION_DELAY_OF_SECURE_TEST_FAILURE from the first onConnectionStateChange().
    private Runnable mNotificationTaskOfSecureTestStartFailure;

    @Override
    public void onCreate() {
        super.onCreate();

        mTaskQueue = new TestTaskQueue(getClass().getName() + "_taskHandlerThread");

        mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
        mAdvertiser = mBluetoothManager.getAdapter().getBluetoothLeAdvertiser();
        mGattServer = mBluetoothManager.openGattServer(this, mCallbacks);

        mService = createService();

        mDevice = null;

        mHandler = new Handler();
        if (!mBluetoothManager.getAdapter().isEnabled()) {
            notifyBluetoothDisabled();
        } else if (mGattServer == null) {
            notifyOpenFail();
        } else if (mAdvertiser == null) {
            notifyAdvertiseUnsupported();
        } else {
            // start adding services
            mSecure = false;
            if (!mGattServer.addService(mService)) {
                notifyAddServiceFail();
            }
        }
    }

    private void notifyBluetoothDisabled() {
        Intent intent = new Intent(BLE_BLUETOOTH_DISABLED);
        sendBroadcast(intent);
    }

    private void notifyMismatchSecure() {
        Intent intent = new Intent(BLE_BLUETOOTH_MISMATCH_SECURE);
        sendBroadcast(intent);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        String action = intent.getAction();
        if (action != null) {
            if (DEBUG) {
                Log.d(TAG, "onStartCommand: action=" + action);
            }
            mTaskQueue.addTask(new Runnable() {
                @Override
                public void run() {
                    onTestFinish(intent.getAction());
                }
            }, EXECUTION_DELAY);
        }
        return START_NOT_STICKY;
    }

    private void startServerTest(boolean secure) {
        mSecure = secure;

        if (mBluetoothManager.getAdapter().isEnabled() && (mChatService == null)) {
            createChatService();
        }

        if (mBluetoothManager.getAdapter().isEnabled() && (mAdvertiser != null)) {
            startAdvertise();
        }
    }

    private void sendMessage(byte[] buf) {
        mChatService.write(buf);
    }

    private void sendData8bytes() {
        if (DEBUG) Log.d(TAG, "sendData8bytes");

        final byte[] buf = new byte[]{1,2,3,4,5,6,7,8};
        mNextWriteExpectedLen = 8;
        mNextWriteCompletionIntent = BLE_DATA_8BYTES_SENT;
        sendMessage(buf);
    }

    private void sendDataLargeBuf() {
        final int len = BleCocServerService.TEST_DATA_EXCHANGE_BUFSIZE;
        if (DEBUG) Log.d(TAG, "sendDataLargeBuf of size=" + len);

        byte[] buf = new byte[len];
        for (int i = 0; i < len; i++) {
            buf[i] = (byte)(i + 1);
        }
        mNextWriteExpectedLen = len;
        mNextWriteCompletionIntent = null;
        sendMessage(buf);
    }

    private void onTestFinish(String action) {
        mCurrentAction = action;
        if (mCurrentAction != null) {
            switch (mCurrentAction) {
                case BLE_ACTION_COC_SERVER_INSECURE:
                    startServerTest(false);
                    break;
                case BLE_ACTION_COC_SERVER_SECURE:
                    startServerTest(true);
                    break;
                case BLE_COC_SERVER_ACTION_SEND_DATA_8BYTES:
                    sendData8bytes();
                    break;
                case BLE_COC_SERVER_ACTION_EXCHANGE_DATA:
                    sendDataLargeBuf();
                    readDataLargeBuf();
                    break;
                case BLE_COC_SERVER_ACTION_DISCONNECT:
                    if (mChatService != null) {
                        mChatService.stop();
                    }
                    break;
                default:
                    Log.e(TAG, "Error: Unhandled or invalid action=" + mCurrentAction);
            }
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();

        if (mChatService != null) {
            mChatService.stop();
        }

        cancelNotificationTaskOfSecureTestStartFailure();
        stopAdvertise();

        mTaskQueue.quit();

        if (mGattServer == null) {
           return;
        }
        if (mDevice != null) {
            mGattServer.cancelConnection(mDevice);
        }
        mGattServer.clearServices();
        mGattServer.close();
    }

    private void notifyOpenFail() {
        if (DEBUG) {
            Log.d(TAG, "notifyOpenFail");
        }
        Intent intent = new Intent(BLE_OPEN_FAIL);
        sendBroadcast(intent);
    }

    private void notifyAddServiceFail() {
        if (DEBUG) {
            Log.d(TAG, "notifyAddServiceFail");
        }
        Intent intent = new Intent(BLE_ADD_SERVICE_FAIL);
        sendBroadcast(intent);
    }

    private void notifyAdvertiseUnsupported() {
        if (DEBUG) {
            Log.d(TAG, "notifyAdvertiseUnsupported");
        }
        Intent intent = new Intent(BLE_ADVERTISE_UNSUPPORTED);
        sendBroadcast(intent);
    }

    private void notifyConnected() {
        if (DEBUG) {
            Log.d(TAG, "notifyConnected");
        }
        Intent intent = new Intent(BLE_LE_CONNECTED);
        sendBroadcast(intent);
    }

    private void notifyDisconnected() {
        if (DEBUG) {
            Log.d(TAG, "notifyDisconnected");
        }
        Intent intent = new Intent(BLE_SERVER_DISCONNECTED);
        sendBroadcast(intent);
    }

    private BluetoothGattService createService() {
        BluetoothGattService service =
                new BluetoothGattService(SERVICE_UUID, BluetoothGattService.SERVICE_TYPE_PRIMARY);
        BluetoothGattCharacteristic characteristic =
                new BluetoothGattCharacteristic(CHARACTERISTIC_UUID, 0x0A, 0x11);
        characteristic.setValue(WRITE_VALUE.getBytes());

        BluetoothGattDescriptor descriptor = new BluetoothGattDescriptor(DESCRIPTOR_UUID, 0x11);
        descriptor.setValue(WRITE_VALUE.getBytes());
        characteristic.addDescriptor(descriptor);

        BluetoothGattDescriptor descriptor_permission =
            new BluetoothGattDescriptor(DESCRIPTOR_NO_READ_UUID, 0x10);
        characteristic.addDescriptor(descriptor_permission);

        descriptor_permission = new BluetoothGattDescriptor(DESCRIPTOR_NO_WRITE_UUID, 0x01);
        characteristic.addDescriptor(descriptor_permission);

        service.addCharacteristic(characteristic);

        // Registered the characteristic of PSM Value
        mLePsmCharacteristic =
                new BluetoothGattCharacteristic(BleCocClientService.LE_PSM_CHARACTERISTIC_UUID,
                                                BluetoothGattCharacteristic.PROPERTY_READ,
                                                BluetoothGattCharacteristic.PERMISSION_READ);
        service.addCharacteristic(mLePsmCharacteristic);

        return service;
    }

    private void showMessage(final String msg) {
        mHandler.post(new Runnable() {
            public void run() {
                Toast.makeText(BleCocServerService.this, msg, Toast.LENGTH_SHORT).show();
            }
        });
    }

    private synchronized void cancelNotificationTaskOfSecureTestStartFailure() {
        if (mNotificationTaskOfSecureTestStartFailure != null) {
            mHandler.removeCallbacks(mNotificationTaskOfSecureTestStartFailure);
            mNotificationTaskOfSecureTestStartFailure = null;
        }
    }

    private final BluetoothGattServerCallback mCallbacks = new BluetoothGattServerCallback() {
        @Override
        public void onConnectionStateChange(BluetoothDevice device, int status, int newState) {
            if (DEBUG) {
                Log.d(TAG, "onConnectionStateChange: newState=" + newState);
            }

            if (status == BluetoothGatt.GATT_SUCCESS) {
                if (newState == BluetoothProfile.STATE_CONNECTED) {
                    mDevice = device;
                    boolean bonded = false;
                    Set<BluetoothDevice> pairedDevices =
                        mBluetoothManager.getAdapter().getBondedDevices();
                    if (pairedDevices.size() > 0) {
                        for (BluetoothDevice target : pairedDevices) {
                            if (target.getAddress().equals(device.getAddress())) {
                                bonded = true;
                                break;
                            }
                        }
                    }

                    if (mSecure && ((device.getBondState() == BluetoothDevice.BOND_NONE) ||
                                    !bonded)) {
                        // not pairing and execute Secure Test
                        Log.e(TAG, "BluetoothGattServerCallback.onConnectionStateChange: "
                              + "Not paired but execute secure test");
                        cancelNotificationTaskOfSecureTestStartFailure();
                    } else if (!mSecure && ((device.getBondState() != BluetoothDevice.BOND_NONE)
                                            || bonded)) {
                        // already pairing and execute Insecure Test
                        Log.e(TAG, "BluetoothGattServerCallback.onConnectionStateChange: "
                              + "Paired but execute insecure test");
                    } else {
                        cancelNotificationTaskOfSecureTestStartFailure();
                    }
                    notifyConnected();
                } else if (status == BluetoothProfile.STATE_DISCONNECTED) {
                    notifyDisconnected();
                    mDevice = null;
                }
            }
        }

        @Override
        public void onCharacteristicReadRequest(BluetoothDevice device, int requestId, int offset,
                BluetoothGattCharacteristic characteristic) {
            if (mGattServer == null) {
                if (DEBUG) {
                    Log.d(TAG, "GattServer is null, return");
                }
                return;
            }
            if (DEBUG) {
                Log.d(TAG, "onCharacteristicReadRequest()");
            }

            boolean finished = false;
            byte[] value = null;
            if (mMtuSize > 0) {
                byte[] buf = characteristic.getValue();
                if (buf != null) {
                    int len = Math.min((buf.length - offset), mMtuSize);
                    if (len > 0) {
                        value = Arrays.copyOfRange(buf, offset, (offset + len));
                    }
                    finished = ((offset + len) >= buf.length);
                    if (finished) {
                        Log.d(TAG, "sent whole data: " + (new String(characteristic.getValue())));
                    }
                }
            } else {
                value = characteristic.getValue();
                finished = true;
            }

            mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, value);

            UUID uid = characteristic.getUuid();
            if (uid.equals(BleCocClientService.LE_PSM_CHARACTERISTIC_UUID)) {
                Log.d(TAG, "onCharacteristicReadRequest: reading PSM");
            }
        }

    };

    private void leCheckConnectionType() {
        if (mChatService == null) {
            Log.e(TAG, "leCheckConnectionType: no LE Coc connection");
            return;
        }
        int type = mChatService.getSocketConnectionType();
        if (type != BluetoothSocket.TYPE_L2CAP) {
            Log.e(TAG, "leCheckConnectionType: invalid connection type=" + type);
            return;
        }
        showMessage("LE CoC Connection Type Checked");
        Intent intent = new Intent(BLE_CONNECTION_TYPE_CHECKED);
        sendBroadcast(intent);
    }

    private void readData8bytes() {
        mNextReadExpectedLen = 8;
        mTotalReadLen = 0;
        mNextReadCompletionIntent = BLE_DATA_8BYTES_READ;
        mNextReadByte = 1;
    }

    private void readDataLargeBuf() {
        mNextReadExpectedLen = BleCocServerService.TEST_DATA_EXCHANGE_BUFSIZE;
        mTotalReadLen = 0;
        mNextReadCompletionIntent = BLE_DATA_LARGEBUF_READ;
        mNextReadByte = 1;
    }

    private void processChatStateChange(int newState) {
        Intent intent;
        if (DEBUG) {
            Log.d(TAG, "processChatStateChange: newState=" + newState);
        }
        switch (newState) {
        case BluetoothChatService.STATE_LISTEN:
            intent = new Intent(BLE_COC_LISTENER_CREATED);
            sendBroadcast(intent);
            break;
        case BluetoothChatService.STATE_CONNECTED:
            intent = new Intent(BLE_COC_CONNECTED);
            sendBroadcast(intent);

            // Check the connection type
            leCheckConnectionType();

            // Prepare the next data read
            readData8bytes();
            break;
        }
    }

    private boolean checkReadBufContent(byte[] buf, int len) {
        // Check that the content is correct
        for (int i = 0; i < len; i++) {
            if (buf[i] != mNextReadByte) {
                Log.e(TAG, "handleMessageRead: Error: wrong byte content. buf["
                      + i + "]=" + buf[i] + " not equal to " + mNextReadByte);
                return false;
            }
            mNextReadByte++;
        }
        return true;
    }

    private void handleMessageRead(Message msg) {
        byte[] buf = (byte[])msg.obj;
        int len = msg.arg1;
        if (len <= 0) {
            return;
        }
        mTotalReadLen += len;
        if (DEBUG) {
            Log.d(TAG, "handleMessageRead: receive buffer of length=" + len + ", mTotalReadLen="
                  + mTotalReadLen + ", mNextReadExpectedLen=" + mNextReadExpectedLen);
        }

        if (mNextReadExpectedLen == mTotalReadLen) {
            if (!checkReadBufContent(buf, len)) {
                mNextReadExpectedLen = -1;
                return;
            }
            showMessage("Read " + len + " bytes");
            if (DEBUG) {
                Log.d(TAG, "handleMessageRead: broadcast intent " + mNextReadCompletionIntent);
            }
            Intent intent = new Intent(mNextReadCompletionIntent);
            sendBroadcast(intent);
            mNextReadExpectedLen = -1;
            mNextReadCompletionIntent = null;
            mTotalReadLen = 0;
        } else if (mNextReadExpectedLen > mTotalReadLen) {
            if (!checkReadBufContent(buf, len)) {
                mNextReadExpectedLen = -1;
                return;
            }
        } else if (mNextReadExpectedLen < mTotalReadLen) {
            Log.e(TAG, "handleMessageRead: Unexpected receive buffer of length=" + len
                  + ", expected len=" + mNextReadExpectedLen);
        }
    }

    private void handleMessageWrite(Message msg) {
        byte[] buffer = (byte[]) msg.obj;
        int len = buffer.length;
        showMessage("LE CoC Server wrote " + len + " bytes" + ", mNextWriteExpectedLen="
                    + mNextWriteExpectedLen);
        if (len == mNextWriteExpectedLen) {
            if (mNextWriteCompletionIntent != null) {
                Intent intent = new Intent(mNextWriteCompletionIntent);
                sendBroadcast(intent);
            }
        } else {
            Log.d(TAG, "handleMessageWrite: unrecognized length=" + len);
        }
        mNextWriteCompletionIntent = null;
        mNextWriteExpectedLen = -1;
    }

    private class ChatHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (DEBUG) {
                Log.d(TAG, "ChatHandler.handleMessage: msg=" + msg);
            }
            switch (msg.what) {
                case BluetoothChatService.MESSAGE_STATE_CHANGE:
                    processChatStateChange(msg.arg1);
                    break;
                case BluetoothChatService.MESSAGE_READ:
                    handleMessageRead(msg);
                    break;
                case BluetoothChatService.MESSAGE_WRITE:
                    handleMessageWrite(msg);
                    break;
            }
        }
    }

    /* Start the Chat Service to create the Bluetooth Server Socket for LE CoC */
    private void createChatService() {

        mChatService = new BluetoothChatService(this, new ChatHandler(), true);
        mChatService.start(mSecure);
        mPsm = mChatService.getPsm(mSecure);
        if (DEBUG) {
            Log.d(TAG, "createChatService: assigned PSM=" + mPsm);
        }
        if (mPsm > 0x00ff) {
            Log.e(TAG, "createChatService: Invalid PSM=" + mPsm);
        }
        // Notify that the PSM is read
        Intent intent = new Intent(BLE_PSM_READ);
        sendBroadcast(intent);

        // Set the PSM value in the PSM characteristics in the GATT Server.
        mLePsmCharacteristic.setValue(mPsm, BluetoothGattCharacteristic.FORMAT_UINT8, 0);
    }

    private void startAdvertise() {
        if (DEBUG) {
            Log.d(TAG, "startAdvertise");
        }
        AdvertiseData data = new AdvertiseData.Builder()
            .addServiceData(new ParcelUuid(ADV_COC_SERVICE_UUID), new byte[]{1,2,3})
            .addServiceUuid(new ParcelUuid(ADV_COC_SERVICE_UUID))
            .build();
        AdvertiseSettings setting = new AdvertiseSettings.Builder()
            .setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_LATENCY)
            .setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_MEDIUM)
            .setConnectable(true)
            .build();
        mAdvertiser.startAdvertising(setting, data, mAdvertiseCallback);
    }

    private void stopAdvertise() {
        if (DEBUG) {
            Log.d(TAG, "stopAdvertise");
        }
        if (mAdvertiser != null) {
            mAdvertiser.stopAdvertising(mAdvertiseCallback);
        }
    }

    private final AdvertiseCallback mAdvertiseCallback = new AdvertiseCallback(){
        @Override
        public void onStartFailure(int errorCode) {
            // Implementation for API Test.
            super.onStartFailure(errorCode);
            if (DEBUG) {
                Log.d(TAG, "onStartFailure");
            }

            if (errorCode == ADVERTISE_FAILED_FEATURE_UNSUPPORTED) {
                notifyAdvertiseUnsupported();
            } else {
                notifyOpenFail();
            }
        }

        @Override
        public void onStartSuccess(AdvertiseSettings settingsInEffect) {
            // Implementation for API Test.
            super.onStartSuccess(settingsInEffect);
            if (DEBUG) {
                Log.d(TAG, "onStartSuccess");
            }
        }
    };

    /*protected*/ static void dumpService(BluetoothGattService service, int level) {
        String indent = "";
        for (int i = 0; i < level; ++i) {
            indent += "  ";
        }

        Log.d(TAG, indent + "[service]");
        Log.d(TAG, indent + "UUID: " + service.getUuid());
        Log.d(TAG, indent + "  [characteristics]");
        for (BluetoothGattCharacteristic ch : service.getCharacteristics()) {
            Log.d(TAG, indent + "    UUID: " + ch.getUuid());
            Log.d(TAG, indent + "      properties: "
                  + String.format("0x%02X", ch.getProperties()));
            Log.d(TAG, indent + "      permissions: "
                  + String.format("0x%02X", ch.getPermissions()));
            Log.d(TAG, indent + "      [descriptors]");
            for (BluetoothGattDescriptor d : ch.getDescriptors()) {
                Log.d(TAG, indent + "        UUID: " + d.getUuid());
                Log.d(TAG, indent + "          permissions: "
                      + String.format("0x%02X", d.getPermissions()));
            }
        }

        if (service.getIncludedServices() != null) {
            Log.d(TAG, indent + "  [included services]");
            for (BluetoothGattService s : service.getIncludedServices()) {
                dumpService(s, level + 1);
            }
        }
    }
}