/*
* This method is used to inject a custom BPS event into the BPS event handler using
* the channel and domain that we saved during the initialisation process.
*/
void NfcWorker::interruptBpsWaitLoop(unsigned int code) {
int rc = 0;
if (!_timeToDie) {
qDebug() << "XXXX Trying to interrupt...";
_interruptMutex.lock();
bps_event_t *interruptEvent;
rc = 0;
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_event_create() - entering";
rc = bps_event_create(&interruptEvent, _bpsInterruptDomain, code, 0, 0);
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_event_create() - exited";
if (rc) {
qDebug() << "XXXX Unable to create a BPS custom event";
} else {
qDebug() << "XXXX Created a BPS custom event";
}
rc = 0;
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_channel_push_event() - entering";
rc = bps_channel_push_event(_bpsChannel, interruptEvent);
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_channel_push_event() - exited";
if (rc) {
qDebug() << "XXXX Unable to push custom event onto BPS channel";
} else {
qDebug() << "XXXX Pushed custom event onto BPS channel";
}
_interruptMutex.unlock();
} else {
qDebug() << "XXXX No need to interrupt NfcWorker since already closing down";
}
}
void BBMBPS::StartContactEvents()
{
if (!contactEventsEnabled) {
bps_event_t *event = NULL;
bps_event_create(&event, m_BBMInternalDomain, INTERNAL_EVENT_CONTACT_EVENTS, NULL, NULL);
bps_channel_push_event(m_eventChannel, event);
}
}
void BBMBPS::Register(const std::string& uuid)
{
bps_event_t *event = NULL;
bps_event_payload_t payload;
char *stringBuf = new char[uuid.size()];
payload.data1 = reinterpret_cast<uintptr_t>(stringBuf);
bps_event_create(&event, m_BBMInternalDomain, INTERNAL_EVENT_REGISTER, &payload, NULL);
bps_channel_push_event(m_eventChannel, event);
}
static int bpsIOHandler(int fd, int io_events, void *data)
{
qEventDispatcherDebug << Q_FUNC_INFO;
// decode callback payload
bpsIOHandlerData *ioData = static_cast<bpsIOHandlerData*>(data);
// check if first file is ready
bool firstReady = (ioData->count == 0);
// update ready state of file
if (io_events & BPS_IO_INPUT) {
qEventDispatcherDebug << fd << "ready for Read";
FD_SET(fd, ioData->readfds);
ioData->count++;
}
if (io_events & BPS_IO_OUTPUT) {
qEventDispatcherDebug << fd << "ready for Write";
FD_SET(fd, ioData->writefds);
ioData->count++;
}
if (io_events & BPS_IO_EXCEPT) {
qEventDispatcherDebug << fd << "ready for Exception";
FD_SET(fd, ioData->exceptfds);
ioData->count++;
}
// force bps_get_event() to return immediately by posting an event to ourselves;
// but this only needs to happen once if multiple files become ready at the same time
if (firstReady) {
qEventDispatcherDebug << "Sending bpsIOReadyDomain event";
// create unblock event
bps_event_t *event;
int result = bps_event_create(&event, bpsUnblockDomain, 0, NULL, NULL);
if (Q_UNLIKELY(result != BPS_SUCCESS)) {
qWarning("QEventDispatcherBlackberry: bps_event_create failed");
return BPS_FAILURE;
}
// post unblock event to our thread; in this callback the bps channel is
// guaranteed to be the same that was active when bps_add_fd was called
result = bps_push_event(event);
if (Q_UNLIKELY(result != BPS_SUCCESS)) {
qWarning("QEventDispatcherBlackberry: bps_push_event failed");
bps_event_destroy(event);
return BPS_FAILURE;
}
}
return BPS_SUCCESS;
}
void QEventDispatcherBlackberry::wakeUp()
{
Q_D(QEventDispatcherBlackberry);
if (d->wakeUps.testAndSetAcquire(0, 1)) {
bps_event_t *event;
if (Q_LIKELY(bps_event_create(&event, bpsUnblockDomain, 0, 0, 0) == BPS_SUCCESS)) {
if (Q_LIKELY(bps_channel_push_event(d->bps_channel, event) == BPS_SUCCESS))
return;
else
bps_event_destroy(event);
}
qWarning("QEventDispatcherBlackberry: wakeUp failed");
}
}
static int bpsIOHandler(int fd, int io_events, void *data)
{
// decode callback payload
bpsIOHandlerData *ioData = static_cast<bpsIOHandlerData*>(data);
// check if first file is ready
bool firstReady = (ioData->count == 0);
// update ready state of file
if (io_events & BPS_IO_INPUT) {
FD_SET(fd, ioData->readfds);
ioData->count++;
}
if (io_events & BPS_IO_OUTPUT) {
FD_SET(fd, ioData->writefds);
ioData->count++;
}
if (io_events & BPS_IO_EXCEPT) {
FD_SET(fd, ioData->exceptfds);
ioData->count++;
}
// force bps_get_event() to return immediately by posting an event to ourselves;
// but this only needs to happen once if multiple files become ready at the same time
if (firstReady) {
// create IO ready event
bps_event_t *event;
int result = bps_event_create(&event, bpsIOReadyDomain, 0, NULL, NULL);
if (result != BPS_SUCCESS) {
qWarning("QEventDispatcherBlackberryPrivate::QEventDispatcherBlackberry: bps_event_create() failed");
return BPS_FAILURE;
}
// post IO ready event to our thread
result = bps_push_event(event);
if (result != BPS_SUCCESS) {
qWarning("QEventDispatcherBlackberryPrivate::QEventDispatcherBlackberry: bps_push_event() failed");
bps_event_destroy(event);
return BPS_FAILURE;
}
}
return BPS_SUCCESS;
}
static void
status_callback(camera_handle_t handle,
camera_devstatus_t status,
uint16_t extra,
void* arg)
{
fprintf(stderr, "status notification: %d, %d\n", status, extra);
// when all photo-taking callbacks have completed, the capture-complete event is emitted
if (status == CAMERA_STATUS_CAPTURECOMPLETE) {
// picture-taking is done, so wake up the main thread again via bps.
// note that we are using the void* arg here as the bps channel to deliver
// the event on. this is just to demonstrate data passing between
// camera_take_photo() and the various callback functions.
bps_event_t* photo_done_event;
bps_event_create(&photo_done_event, photo_done_domain, 0, NULL, NULL);
bps_channel_push_event((int)arg, photo_done_event);
}
}
/**
* The main entry point.
*/
int
main(int argc, char *argv[])
{
pthread_t accel_thread;
bool exit_application = false;
int rc;
/*
* Before we can listen for events from the BlackBerry Tablet OS platform
* services, we need to initialize the BPS infrastructure
*/
bps_initialize();
/*
* Initialize the screen so that the window group Id is properly set,
* to allow the dialogs to be displayed.
*/
if (setup_screen() != EXIT_SUCCESS) {
fprintf(stderr, "Unable to initialize screen.");
exit(-1);
}
/*
* Once the BPS infrastructure has been initialized we can register for
* events from the various BlackBerry Tablet OS platform services. The
* Navigator service manages and delivers application life cycle and
* visibility events.
*
* We register a custom event domain so that we can communicate with the
* the accelerometer thread. We will need to tell it to quit once we get
* the NAVIGATOR_EXIT.
*
* We request Navigator events so that we can track when the system is
* terminating the application (NAVIGATOR_EXIT event).
*
*/
local_event_domain = bps_register_domain();
if (local_event_domain == -1) {
fprintf(stderr, "Error registering custom event domain: %s", strerror(errno));
exit(-1);
}
if (BPS_SUCCESS != navigator_request_events(0)) {
fprintf(stderr, "Error requesting navigator events: %s", strerror(errno));
exit(-1);
}
if (BPS_SUCCESS != dialog_request_events(0)) {
fprintf(stderr, "Error requesting dialog events: %s", strerror(errno));
exit(-1);
}
if (BPS_SUCCESS != geolocation_request_events(0)) {
fprintf(stderr, "Error requesting geolocation events: %s", strerror(errno));
exit(-1);
}
geolocation_set_period(1);
/*
* Create and display the dialogs that will show the data.
*/
create_top_dialog();
show_top_dialog_message("Geolocation getting first fix");
/*
* Before initializing the accelerometer service we must ensure the device
* supports it.
*/
if (!sensor_is_supported(SENSOR_TYPE_ACCELEROMETER)) {
/**
* If the device does not support accelerometer then notify the user,
* clean up and exit
*/
snprintf(msg, MSG_SIZE, "Accelerometer not supported by device!");
show_top_dialog_message(msg);
/*
* Destroy the dialog, if it exists and cleanup screen resources.
*/
destroy_top_dialog();
cleanup_screen();
bps_shutdown();
return EXIT_FAILURE;
}
/*
* Create the accelerometer event thread.
*/
rc = pthread_create(&accel_thread, NULL, accel_main, NULL);
if (rc != 0) {
fprintf(stderr, "Error in pthread_create: %s", strerror(errno));
exit(-1);
}
while (!exit_application) {
/*
* Using a negative timeout (-1) in the call to bps_get_event(...)
* ensures that we don't busy wait by blocking until an event is
* available.
*/
bps_event_t *event = NULL;
bps_get_event(&event, -1);
if (event) {
if (bps_event_get_domain(event) == geolocation_get_domain()) {
handle_geolocation_response(event);
}
else if (bps_event_get_domain(event) == navigator_get_domain()) {
exit_application = handle_navigator_event(event);
}
}
}
geolocation_stop_events(0);
/*
* Avoid a possible race condition where accel_chid has not yet
* been assigned a valid channel ID.
*/
pthread_mutex_lock(&chidMutex);
while (accel_chid == -1) {
pthread_cond_wait(&chidCond, &chidMutex);
}
pthread_mutex_unlock(&chidMutex);
bps_event_t *stop_request_event = NULL;
if (BPS_SUCCESS != bps_event_create(&stop_request_event, local_event_domain, STOP_REQUEST, NULL, NULL)) {
fprintf(stderr, "Unable to create event: %s", strerror(errno));
exit(-1);
}
if (BPS_SUCCESS != bps_channel_push_event(accel_chid, stop_request_event)) {
fprintf(stderr, "Unable to push event: %s", strerror(errno));
}
pthread_join(accel_thread, NULL);
/*
* Destroy the dialog, if it exists.
*/
destroy_top_dialog();
bps_shutdown();
cleanup_screen();
return 0;
}
void BBMBPS::SendEndEvent()
{
bps_event_t *event = NULL;
bps_event_create(&event, m_BBMInternalDomain, INTERNAL_EVENT_STOP, NULL, NULL);
bps_channel_push_event(m_eventChannel, event);
}
