hcidriver.java

蓝牙协议栈可是要钱的喔

            { 0x01, 0x06, 0x04, 03, (byte)((connectionHandle) & 0xff), (byte)((connectionHandle >> 8) & 0xff), 0x13 };
        byte[] resultData = send_HCI_Command_Packet(data);
        return resultData[3];
    }

    /**
     * The Reset command will reset the Host Controller and the
     * Link Manager. After the reset is completed, the current operational state will be lost, the Bluetooth device will enter
     * standby mode and the Host Controller will automatically revert
     * to the default values for the parameters for which default values are defined in the specification.
     * For details see Page 622 of the Bluetooth Core Specification Version 1.1
     * @return 0x00 if the command succeeded. 0x01-0xFF if the command failed. See Table 6.1 on page 766
     * for list of Error Codes.
     * @throws HCIException
     */
    public byte send_HCI_HC_Reset() throws HCIException {
        byte[] data = { 0x01, 0x03, 0x0C, 0x00 };
        byte[] resultData = send_HCI_Command_Packet(data);
        return resultData[6];
    }

    /**
     * Sends an HCIPacket. The Packet bytes are send over the Transport via the
     * underlying hardware to the Bluetooth Host Controller.
     * @param packet HCI Command or Data Packet.
     * @throws HCIException
     */
    protected abstract void sendPacket(byte[] packet) throws HCIException;

    /**
     * Resets the Bluetooth Host Controller.
     * @throws HCIException
     */
    protected abstract void reset() throws HCIException;

    protected void receiveData(byte[] incomingBytes, int incomingLength) {
        int incomingBytesIndex = 0;
        while (incomingBytesIndex < incomingLength) //process all available data
        {
            if (headerBufferIndex < headerBuffer.length) //header is still incomplete
            {
                int length = headerBuffer.length - headerBufferIndex;
                if (length > incomingLength - incomingBytesIndex) length = incomingLength - incomingBytesIndex;
                System.arraycopy(incomingBytes, incomingBytesIndex, headerBuffer, headerBufferIndex, length);
                incomingBytesIndex += length;
                headerBufferIndex += length;
                if (headerBufferIndex == headerBuffer.length) //header is complete
                {
                    parseHeader(); //creates Packet and copy header into packet.
                }
            }
            else //header is complete. copy data to packet.
            {
                int length = packetBuffer.length - packetBufferIndex;
                if (length > incomingLength - incomingBytesIndex) length = incomingLength - incomingBytesIndex;
                System.arraycopy(incomingBytes, incomingBytesIndex, packetBuffer, packetBufferIndex, length);
                incomingBytesIndex += length;
                packetBufferIndex += length;
                if (packetBufferIndex == packetBuffer.length) //packet is complete
                {
                    headerBufferIndex = 0; //this'll lead to a new packet creation
                    dispatchPacket(packetBuffer);
                }
            }
        }
    }

    private void parseHeader() {
        switch (headerBuffer[0]) {
            case PACKET_TYPE_ACL:
                packetBuffer = new byte[5 + (short)(((short)headerBuffer[4] & 0xff) << 8 | ((short)headerBuffer[3] & 0xff))];
                System.arraycopy(headerBuffer, 0, packetBuffer, 0, headerBuffer.length);
                packetBufferIndex = headerBuffer.length;
                break;
            case PACKET_TYPE_EVENT:
                packetBuffer = new byte[3 + (short)(((short)headerBuffer[2]) & 0xff)];
                System.arraycopy(headerBuffer, 0, packetBuffer, 0, headerBuffer.length);
                packetBufferIndex = headerBuffer.length;
                break;
            default:
                headerBufferIndex = 0; //reset packet parser
                System.err.println("HCI: Received Invalid Packet Header" + headerBuffer);
        }
        //Debug.println("HCI: Parsed Header ("+Debug.printByteArray(headerBuffer));
    }

    private void dispatchPacket(byte[] hciPacket) {
        Debug.println(0, "HCI: Received Packet: ", hciPacket);
        switch (hciPacket[0]) //Packet Type
        {
            case PACKET_TYPE_EVENT:
                switch (hciPacket[1]) //Event Type
                {
                    case HCI_EVENT_INQUIRY_COMPLETE:
                        receive_HCI_Event_Inquiry_Complete(hciPacket);
                        break;
                    case HCI_EVENT_INQUIRY_RESULT:
                        receive_HCI_Event_Inquiry_Result(hciPacket);
                        break;
                    case HCI_EVENT_COMMAND_COMPLETE:
                        receive_HCI_Event_Command_Complete(hciPacket);
                        break;
                    case HCI_EVENT_COMMAND_STATUS:
                        receive_HCI_Event_Command_Status(hciPacket);
                        break;
                    case HCI_EVENT_CONNECTION_COMPLETE:
                        receive_HCI_Event_Connection_Complete(hciPacket);
                        break;
                    case HCI_EVENT_DISCONNECTION_COMPLETE:
                        receive_HCI_Event_Disconnection_Complete(hciPacket);
                        break;
                    case HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE:
                        receive_HCI_Event_Remote_Name_Request_Complete(hciPacket);
                        break;
                    case HCI_EVENT_NUMBER_OF_COMPLETED_PACKETS:
                        break;
                    default:
                        System.err.println("HCI: Received Unknown Event Packet:" + Debug.printByteArray(hciPacket));
                }
                break;
            case PACKET_TYPE_ACL:
                //Debug.println("HCI: Received Data Packet:" + Debug.printByteArray(hciPacket));
                receive_HCI_Data_Packet(hciPacket);
                break;
            default:
                System.err.println("HCI: Received Packet of Unknown Type:" + Debug.printByteArray(hciPacket));
        }
    }

    private void receive_HCI_Event_Inquiry_Complete(byte[] eventPacket) {
        Debug.println(1, "HCI: Received Inquiry Complete Event.");
        Enumeration receivers = hciReceivers.elements();
        while (receivers.hasMoreElements()) {
            HCIReceiver receiver = (HCIReceiver)receivers.nextElement();
            receiver.receive_HCI_Event_Inquiry_Complete(eventPacket);
        }
    }

    private void receive_HCI_Event_Inquiry_Result(byte[] eventPacket) {
        Debug.println(1, "HCI: Received Inquiry Result Event.");
        Enumeration receivers = hciReceivers.elements();
        while (receivers.hasMoreElements()) {
            HCIReceiver receiver = (HCIReceiver)receivers.nextElement();
            receiver.receive_HCI_Event_Inquiry_Result(eventPacket);
        }
    }

    private void receive_HCI_Event_Connection_Complete(byte[] eventPacket) {
        if (eventPacket[3] == 0) //is connected
        {
            L2CAPLink conn = new L2CAPLink(this, eventPacket);
            Debug.println(1, "HCI: Received Connection Complete Event: " + conn.remoteAddress);
        }
        else Debug.println(1, "HCI: Received Connection Complete Event: Create Connection failed.");
    }

    private void receive_HCI_Event_Disconnection_Complete(byte[] eventPacket) {
        short connectionHandle = (short)(((short)eventPacket[5] & 0x0f) << 8 | ((short)eventPacket[4] & 0xff));
        L2CAPLink link = (L2CAPLink)connectionHandels.remove(new Short(connectionHandle));
        if (link != null) {
            Debug.println(1, "HCI: Received Disconnection Complete Event: " + link.remoteAddress);
            link.wasDisconnected();
        }
        else Debug.println(1, "HCI: Received Disconnection Complete Event.");
    }

    private void receive_HCI_Event_Remote_Name_Request_Complete(byte[] eventPacket) {
        Debug.println(1, "HCI: Remote Name Request Complete Event.");
        Enumeration receivers = hciReceivers.elements();
        while (receivers.hasMoreElements()) {
            HCIReceiver receiver = (HCIReceiver)receivers.nextElement();
            receiver.receive_HCI_Event_Remote_Name_Request_Complete(eventPacket);
        }
    }

    private synchronized void receive_HCI_Event_Command_Complete(byte[] packetData) {
        //TODO catch Reset Event and reset rest of stack
        short opCode = (short)((packetData[5] << 8) | (packetData[4] & 0xff));
        Debug.println(1, "HCI: Received Command Complete Event: " + opCode);
        while (commandResponse != null) {
            try { wait(100); }
            catch (InterruptedException e) { }
        }
        if (opCode == commandResponseOpCode) { commandResponse = packetData; }
    }

    private synchronized void receive_HCI_Event_Command_Status(byte[] packetData) {
        short opCode = (short)((packetData[6] << 8) | (packetData[5] & 0xff));
        Debug.println(1, "HCI: Received Command Status Event: " + opCode);
        while (commandResponse != null) {
            try { wait(100); }
            catch (InterruptedException e) { }
        }
        if (opCode == commandResponseOpCode) { commandResponse = packetData; }
    }

    private void receive_HCI_Data_Packet(byte[] data) {
        short handle = (short)(((short)data[2] & 0x0f) << 8 | ((short)data[1] & 0xff));
        L2CAPLink link = (L2CAPLink)connectionHandels.get(new Short(handle));
        if (link != null) {
            link.receiveData(data);
            Debug.println(1, "HCI: Received Data Packet from " + link.remoteAddress);
        }
        else System.err.println("HCI: Unable to deliver Data Packet. No open link with handle " + handle + ". : " +
                Debug.printByteArray(data));
    }
}