qint64 QBluetoothSocketPrivate::writeData(const char *data, qint64 maxSize)
{
if(!iSocket || data == 0 || maxSize <= 0 || txMTU <= 0) {
return -1;
}
if (!txArray.isEmpty())
{
txArray.append(QByteArray(data, maxSize));
}
else
{
txArray = QByteArray(data, maxSize);
}
// we try to send the data to the remote device
if(tryToSend())
{
// Warning : It doesn't mean the data have been sent
// to the remote device, it means that the data was
// at least stored in a local buffer.
return maxSize;
}
else
{
writeSize = 0;
return -1;
}
}
void BootStrapLoader::customEvent(QEvent *e) {
if(e->type()==QEvent::User) {
BslSendPacketEvent *ev=(BslSendPacketEvent *)e;
mOutQueue.append(ev->packet());
if(mOutPacket==NULL) tryToSend();
}
}
void QBluetoothSocketPrivate::HandleSendCompleteL(TInt aErr)
{
Q_Q(QBluetoothSocket);
transmitting = false;
if (aErr == KErrNone) {
txArray.remove(0, writeSize);
emit q->bytesWritten(writeSize);
if (state == QBluetoothSocket::ClosingState)
{
writeSize = 0;
q->close();
}
else
{
if(!tryToSend())
{
socketError = QBluetoothSocket::UnknownSocketError;
writeSize = 0;
emit q->error(socketError);
}
}
} else {
socketError = QBluetoothSocket::UnknownSocketError;
writeSize = 0;
emit q->error(socketError);
}
}
void BootStrapLoader::BSLPolling() {
mPollPacket->setSequence(BSLPacket::seqIdle);
mPollPacket->reply()->setSequence(BSLPacket::seqAckWait);
mOutPacket=mPollPacket;
mTimeout.start();
tryToSend();
}
void BootStrapLoader::on_SerialPort_ReadyRead() {
quint8 incoming; bslState newstate;
while(mSerialPort->read((char *)&incoming,1)>0) {
switch(mState) {
case afterConnect:
case beforeDisconnect:
if(mSerialPlugin) {
newstate=mSerialPlugin->incomingByte(incoming);
if(newstate!=mState) setState(newstate);
}
break;
case serial:
if(mOutPacket==NULL) {
qDebug("Data (%d) (%c) recevived but no packet active!!!",incoming,incoming);
} else {
if(mOutPacket->reply()->incomingByte(incoming)) {
if(mOutPacket->hasReply()) {
BSLCoreCommmand* coreCommand = dynamic_cast<BSLCoreCommmand*>(mOutPacket);
if(coreCommand && coreCommand->command()==BSLCoreCommmand::txBslVersion) {
mOutPacket=NULL;
setState(bsl);
stateChanged(mState);
}
}
}
}
break;
case bsl:
case working:
if(mOutPacket==NULL) {
qDebug("Data (%d) (%c) recevived but no packet active!!!",incoming,incoming);
} else {
if(mOutPacket->reply()->incomingByte(incoming)) {
mComplQueue.append(mOutPacket);
emit replyReceived(mOutPacket);
mOutPacket=NULL;
tryToSend();
}
}
break;
default:
qDebug("BootStrapLoader::on_SerialPort_ReadyRead state:%d byte:%02X",state(),incoming);
break;
}
}
}
void BootStrapLoader::doQueuePacket(BSLPacket *packet) {
mOutQueue.append(packet);
tryToSend();
}
// Bluetooth logic
static void packet_handler (void * connection, uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
bd_addr_t event_addr;
uint8_t rfcomm_channel_nr;
uint16_t mtu;
uint8_t event = packet[0];
// handle events, ignore data
if (packet_type != HCI_EVENT_PACKET) return;
switch (event) {
case BTSTACK_EVENT_STATE:
// bt stack activated, get started - set local name
if (packet[2] == HCI_STATE_WORKING) {
hci_send_cmd(&hci_write_local_name, "BTstack SPP Counter");
}
break;
case HCI_EVENT_COMMAND_COMPLETE:
if (COMMAND_COMPLETE_EVENT(packet, hci_read_bd_addr)){
bt_flip_addr(event_addr, &packet[6]);
printf("BD-ADDR: %s\n\r", bd_addr_to_str(event_addr));
break;
}
if (COMMAND_COMPLETE_EVENT(packet, hci_write_local_name)){
hci_discoverable_control(1);
break;
}
break;
case HCI_EVENT_LINK_KEY_REQUEST:
// deny link key request
printf("Link key request\n\r");
bt_flip_addr(event_addr, &packet[2]);
hci_send_cmd(&hci_link_key_request_negative_reply, &event_addr);
break;
case HCI_EVENT_PIN_CODE_REQUEST:
// inform about pin code request
printf("Pin code request - using '0000'\n\r");
bt_flip_addr(event_addr, &packet[2]);
hci_send_cmd(&hci_pin_code_request_reply, &event_addr, 4, "0000");
break;
case RFCOMM_EVENT_INCOMING_CONNECTION:
// data: event (8), len(8), address(48), channel (8), rfcomm_cid (16)
bt_flip_addr(event_addr, &packet[2]);
rfcomm_channel_nr = packet[8];
rfcomm_channel_id = READ_BT_16(packet, 9);
printf("RFCOMM channel %u requested for %s\n\r", rfcomm_channel_nr, bd_addr_to_str(event_addr));
rfcomm_accept_connection_internal(rfcomm_channel_id);
break;
case RFCOMM_EVENT_OPEN_CHANNEL_COMPLETE:
// data: event(8), len(8), status (8), address (48), server channel(8), rfcomm_cid(16), max frame size(16)
if (packet[2]) {
printf("RFCOMM channel open failed, status %u\n\r", packet[2]);
} else {
rfcomm_channel_id = READ_BT_16(packet, 12);
mtu = READ_BT_16(packet, 14);
printf("\n\rRFCOMM channel open succeeded. New RFCOMM Channel ID %u, max frame size %u\n\r", rfcomm_channel_id, mtu);
}
break;
case DAEMON_EVENT_HCI_PACKET_SENT:
case RFCOMM_EVENT_CREDITS:
tryToSend();
break;
case RFCOMM_EVENT_CHANNEL_CLOSED:
rfcomm_channel_id = 0;
break;
default:
break;
}
}
static void timer_handler(timer_source_t *ts){
real_counter++;
// re-register timer
run_loop_register_timer(ts, HEARTBEAT_PERIOD_MS);
tryToSend();
}
