/*
* This method processed an NFC Event when we're intending to Write a Uri Tag
*/
void NfcWorker::handleNfcWriteUriTagEvent(bps_event_t *event) {
uint16_t code = bps_event_get_code(event);
qDebug() << "XXXX NfcWorker::handleWriteUriTagEvent - processing event code " << code;
nfc_event_t *nfcEvent;
nfc_target_t* target;
nfc_ndef_record_t* myNdefRecord;
nfc_ndef_message_t* myNdefMessage;
if (NFC_TAG_READWRITE_EVENT == code) {
qDebug() << "XXXX NfcWorker::handleWriteUriTagEvent - Target Read Write Event";
CHECK(nfc_get_nfc_event(event, &nfcEvent));
CHECK(nfc_get_target(nfcEvent, &target));
qDebug() << "XXXX NfcWorker::handleWriteUriTagEvent - Preparing to write URI: " << _ndefUri;
myNdefRecord = makeUriRecord(Settings::NfcRtdUriPrefixNone, _ndefUri);
CHECK(nfc_create_ndef_message(&myNdefMessage));
CHECK(nfc_add_ndef_record(myNdefMessage, myNdefRecord));
CHECK(nfc_write_ndef_message_to_tag(target, myNdefMessage, false));
CHECK(nfc_delete_ndef_message(myNdefMessage, true));
CHECK(nfc_destroy_target(target));
emit message(QString("Tag Type Written URI: %1").arg(_ndefUri));
} else {
qDebug() << "XXXX NfcWorker::handleWriteUriTagEvent - NFC BPS event that we didn't register for: " << code;
}
}
void NfcWorker::handleNfcWriteCustomTagEvent(bps_event_t *event) {
uint16_t code = bps_event_get_code(event);
qDebug() << "XXXX NfcWorker::handleNfcWriteCustomTagEvent - processing event code " << code;
nfc_event_t *nfcEvent;
nfc_target_t* target;
nfc_ndef_record_t* myNdefRecord;
nfc_ndef_message_t* myNdefMessage;
if (NFC_TAG_READWRITE_EVENT == code) {
qDebug() << "XXXX NfcWorker::handleNfcWriteCustomTagEvent - Target Read Write Event";
CHECK(nfc_get_nfc_event(event, &nfcEvent));
CHECK(nfc_get_target(nfcEvent, &target));
qDebug() << "XXXX NfcWorker::handleWriteCustomTagEvent - Preparing to write Custom: DOMAIN=" << _ndefDomain << ", TYPE=" << _ndefType;
myNdefRecord = makeCustomRecord(_ndefDomain, _ndefType, _ndefPayload);
CHECK(nfc_create_ndef_message(&myNdefMessage));
CHECK(nfc_add_ndef_record(myNdefMessage, myNdefRecord));
CHECK(nfc_write_ndef_message_to_tag(target, myNdefMessage, false));
CHECK(nfc_delete_ndef_message(myNdefMessage, true));
CHECK(nfc_destroy_target(target));
emit message(QString("Custom Tag Written"));
} else {
qDebug() << "XXXX NfcWorker::handleNfcWriteCustomTagEvent - NFC BPS event that we didn't register for< " << code;
}
qDebug() << "XXXX Write Custom Tag written";
emit message(QString("Custom tag written OK"));
}
/*
* This method processed an NFC Event when we're intending to Write an Sp Tag
*/
void NfcWorker::handleNfcWriteSpTagEvent(bps_event_t *event) {
uint16_t code = bps_event_get_code(event);
qDebug() << "XXXX NfcWorker::handleNfcWriteSpTagEvent - processing event code " << code;
nfc_event_t *nfcEvent;
nfc_target_t* target;
nfc_ndef_record_t* spNdefRecord;
nfc_ndef_message_t* myNdefMessage;
if (NFC_TAG_READWRITE_EVENT == code) {
qDebug() << "XXXX NfcWorker::handleNfcWriteSpTagEvent - Target Read Write Event";
CHECK(nfc_get_nfc_event(event, &nfcEvent));
CHECK(nfc_get_target(nfcEvent, &target));
qDebug() << "XXXX NfcWorker::handleWriteSpTagEvent - Preparing to write Sp: URI=" << _ndefSpUri << ", Text=" << _ndefSpText;
spNdefRecord = makeSpRecord();
CHECK(nfc_create_ndef_message(&myNdefMessage));
CHECK(nfc_set_sp_uri(spNdefRecord, _ndefSpUri.toUtf8().constData()));
CHECK( nfc_add_sp_title(spNdefRecord, Settings::LANG_EN, _ndefSpText.toUtf8().constData()));
CHECK(nfc_add_ndef_record(myNdefMessage, spNdefRecord));
CHECK(nfc_write_ndef_message_to_tag(target, myNdefMessage, false));
CHECK(nfc_delete_ndef_message(myNdefMessage, true));
CHECK(nfc_destroy_target(target));
emit message(QString("Tag Type Sp Written: %1 %2").arg(_ndefSpUri).arg(_ndefSpText));
} else {
qDebug() << "XXXX NfcWorker::handleNfcWriteSpTagEvent - NFC BPS event that we didn't register for: " << code;
}
qDebug() << "XXXX Write Sp Tag written";
emit message(QString("Smart Poster tag written OK"));
}
void NfcWorker::prepareToStopEmulation() {
if (_failedToInitialize) {
return;
}
qDebug() << "XXXX NfcWorker::prepareToStopEmulation entered ...";
qDebug() << "XXXX setting inTagEmulationState=false";
StateManager* state_mgr = StateManager::getInstance();
state_mgr->setTagEmulationState(false);
if (state_mgr->inReadState()) {
_taskToPerform = READ_NDEF_TAG;
}
emit message(QString("Preparing to stop Tag emulation"));
if (_emulateNdefMessage) {
CHECK(nfc_delete_ndef_message(_emulateNdefMessage, true));
_emulateNdefMessage = 0;
}
CHECK(nfc_stop_ndef_tag_emulation());
emit message(QString("Tag emulation stopped"));
qDebug() << "XXXX NfcWorker::prepareToStopEmulation exited ...";
}
NfcWorker::~NfcWorker() {
qDebug() << "XXXX NfcWorker destructor";
_timeToDie = true;
_instance = 0;
if (_emulateNdefMessage) {
CHECK(nfc_delete_ndef_message(_emulateNdefMessage, true));
}
}
void NfcWorker::handleSendVcardEvent(bps_event_t *event) {
uint16_t code = bps_event_get_code(event);
qDebug() << "XXXX NfcWorker::handleSendVcardEvent - processing event code " << code;
nfc_event_t *nfcEvent;
nfc_target_t* target;
nfc_ndef_record_t* myNdefRecord;
nfc_ndef_message_t* myNdefMessage;
if (NFC_SNEP_CONNECTION_EVENT == code) {
QString mimeType = QString("text/x-vCard");
QString vCard = QString("BEGIN:VCARD\n").append("VERSION:3.0\n").append("N:").append(_last_name).append(";").append(_first_name).append("\n").append(
"FN:").append(_first_name).append(" ").append(_last_name).append("\n").append("ADR;TYPE=WORK:").append(_address).append("\n").append(
"TEL;TYPE=CELL:").append(_mobile).append("\n").append("EMAIL;TYPE=INTERNET:").append(_email).append("\n").append("END:VCARD");
CHECK(nfc_get_nfc_event(event, &nfcEvent));
CHECK(nfc_get_target(nfcEvent, &target));
qDebug() << "XXXX NfcWorker::handleSendVcardEvent - Preparing to send vCard: FIRST NAME=" << _first_name << ", LAST NAME=" << _last_name << ", ADDRESS="
<< _address << ", EMAIL=" << _email << ", MOBILE=" << _mobile;
qDebug() << "XXXX make a media record";
myNdefRecord = makeMediaRecord(mimeType, vCard);
qDebug() << "XXXX Create NDEF message";
CHECK(nfc_create_ndef_message(&myNdefMessage));
qDebug() << "XXXX Add ndef media record";
CHECK(nfc_add_ndef_record(myNdefMessage, myNdefRecord));
qDebug() << "XXXX Write NDEF message";
CHECK(nfc_push_ndef_message(target, myNdefMessage));
qDebug() << "XXXX Delete NDEF Message";
CHECK(nfc_delete_ndef_message(myNdefMessage, true));
qDebug() << "XXXX Destroy NFC Target";
CHECK(nfc_destroy_target(target));
emit message(QString("vCard sent OK"));
} else {
qDebug() << "XXXX NfcWorker::handleSendVcardEvent - NFC BPS event that we didn't register for: " << code;
}
qDebug() << "XXXX SendVcard done";
}
void NfcWorker::handleNfcWriteUriTagEvent(bps_event_t *event) {
uint16_t code = bps_event_get_code(event);
qDebug()
<< "XXXX NfcWorker::handleWriteUriTagEvent - processing event code "
<< code;
nfc_event_t *nfcEvent;
nfc_target_t* target;
nfc_ndef_message_t* myNdefMessage;
if (NFC_TAG_READWRITE_EVENT == code) {
qDebug()
<< "XXXX NfcWorker::handleWriteUriTagEvent - Target Read Write Event";
CHECK(nfc_get_nfc_event(event, &nfcEvent));
CHECK(nfc_get_target(nfcEvent, &target));
qDebug()
<< "XXXX NfcWorker::handleWriteUriTagEvent - Preparing to write URI: ";
//--------- Try using C APIs----------------------------
QString uri("www.google.ca");
nfc_ndef_record_t* record = 0;
int len = uri.length();
uchar_t payload[len + 1];
memcpy(&payload[0], uri.toUtf8().constData(), len);
CHECK(nfc_create_ndef_record(NDEF_TNF_WELL_KNOWN, "U", payload, len + 1, 0, &record));
CHECK(nfc_create_ndef_message(&myNdefMessage));
CHECK(nfc_add_ndef_record(myNdefMessage,record));
qDebug() << "Before Writing";
bool status;
status = true;
CHECK(nfc_tag_is_writable(target,&status));
CHECK(nfc_write_ndef_message_to_tag(target,myNdefMessage, true));
qDebug() << "After Writing";
CHECK(nfc_delete_ndef_message(myNdefMessage, true));
CHECK(nfc_destroy_target(target));
} else {
qDebug()
<< "XXXX NfcWorker::handleWriteUriTagEvent - NFC BPS event that we didn't register for: "
<< code;
}
}
//! [0]
//! [2]
void NfcSender::handleSnepPush(nfc_target_t *target)
{
nfc_ndef_message_t *ndef_message;
nfc_create_ndef_message(&ndef_message);
nfc_ndef_record_t *record;
const char* record_type = "text/plain";
const uchar_t *payload = (const uchar_t *)m_payload.toUtf8().constData();
//TODO: Kind of sketchy.
const int payload_length = m_payload.toUtf8().length();
nfc_create_ndef_record(NDEF_TNF_MEDIA, record_type, payload, payload_length, 0, &record);
nfc_add_ndef_record(ndef_message, record);
nfc_push_ndef_message(target, ndef_message);
nfc_delete_ndef_message(ndef_message, true);
}
void NfcWorker::prepareToEmulateTag(const QVariant &the_uri, const QVariant &the_text) {
if (_failedToInitialize) {
return;
}
QString uri = the_uri.toString();
QString text = the_text.toString();
qDebug() << "XXXX NfcWorker::prepareToEmulateTag entered ...";
qDebug() << "XXXX setting inTagEmulationState=true";
StateManager* state_mgr = StateManager::getInstance();
state_mgr->setTagEmulationState(true);
emit clearMessages();
emit message(QString("Preparing to emulate NDEF tag"));
_taskToPerform = EMULATE_TAG;
nfc_ndef_record_t* spNdefRecord;
_ndefSpUri = uri;
_ndefSpText = text;
spNdefRecord = makeSpRecord();
if (_emulateNdefMessage) {
CHECK(nfc_delete_ndef_message(_emulateNdefMessage, true));
_emulateNdefMessage = 0;
}
CHECK(nfc_create_ndef_message(&_emulateNdefMessage));
CHECK(nfc_set_sp_uri(spNdefRecord, _ndefSpUri.toUtf8().constData()));
CHECK(nfc_add_sp_title(spNdefRecord, Settings::LANG_EN, _ndefSpText.toUtf8().constData()));
CHECK(nfc_add_ndef_record(_emulateNdefMessage, spNdefRecord));
CHECK(nfc_start_ndef_tag_emulation(_emulateNdefMessage));
emit message(QString("Emulating Sp Tag:"));
emit message(QString("%1").arg(_ndefSpUri));
emit message(QString("%1").arg(_ndefSpText));
}
/*
* navigator events are generated when we're launched by the Invoke Framework (IF)
* due to a tag we're interested in (as declared in the bar-descriptor.xml file)
* is presented to the device. There are other situations that generate navigator
* events but in this specific case, we look to acquire the tag data which
* the IF has and process it.
*
*/
void NfcWorker::handleNavigatorNdefEvent(bps_event_t *event) {
uint16_t code = bps_event_get_code(event);
if (NAVIGATOR_INVOKE_TARGET == code) {
emit message("Navigator invoke target received");
const navigator_invoke_invocation_t *invocation = navigator_invoke_event_get_invocation(event);
if (!invocation) {
qDebug() << "XXXX No invocation for invoke NDEF event";
}
const char *invokeAction = navigator_invoke_invocation_get_action(invocation);
if (!invokeAction) {
qDebug() << "XXXX No action for invoke NDEF event";
}
const QString actionToPerform(invokeAction);
if (actionToPerform == "bb.action.OPEN") {
emit message("Navigator bb.action.OPEN received");
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_type() - entering";
const char *mimeType = navigator_invoke_invocation_get_type(invocation);
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_type() - exited";
if (!mimeType) {
qDebug() << "XXXX No Mime Type with invoke request";
}
const QString mimeTypeRequested(mimeType);
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_data_length() - entering";
int invokeDataLength = navigator_invoke_invocation_get_data_length(invocation);
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_data_length() - exited";
if (invokeDataLength == -1) {
qDebug() << "XXXX Invalid invoke data length";
}
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_data() - entering";
const void *invokeData = navigator_invoke_invocation_get_data(invocation);
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_data() - exited";
if (!invokeData) {
qDebug() << "XXXX Invalid invoke data";
}
nfc_ndef_message_t *ndefMessage;
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_create_ndef_message_from_bytes() - entering";
CHECK( nfc_create_ndef_message_from_bytes(reinterpret_cast<const uchar_t *>(invokeData), invokeDataLength, &ndefMessage));
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_create_ndef_message_from_bytes() - exited";
// cause event log to be displayed now
StateManager* state_mgr = StateManager::getInstance();
qDebug() << "XXXX NfcWorker::readTag() isEventLogShowing()=" << state_mgr->isEventLogShowing();
emit clearMessages();
if (!state_mgr->isEventLogShowing()) {
qDebug() << "XXXXX NfcWorker emiting read_selected";
emit read_selected();
}
parseNdefMessage(ndefMessage);
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_delete_ndef_message() - entering";
CHECK(nfc_delete_ndef_message(ndefMessage, true));
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_delete_ndef_message() - exited";
}
} else if (NAVIGATOR_INVOKE_QUERY_RESULT == code) {
emit message("Navigator invoke query received");
// just log and ignore query requests for the moment
const char *id = navigator_event_get_id(event);
const char *err = navigator_event_get_err(event);
qDebug() << QString("XXXX Invoke Query Result, Id: '%1' Error: '%2'").arg(id).arg(err);
} else {
qDebug() << "XXXX Received Navigation event we don't handle: " << getNavigatorEventName(code);
}
}
