int BBMBPS::InitializeEvents()
{
m_eventChannel = bps_channel_get_active();
m_BBMInternalDomain = bps_register_domain();
return (m_BBMInternalDomain >= 0) ? 0 : 1;
}
/*
* This method initialises the interface to BPS
*/
void NfcWorker::initialize() {
qDebug() << "XXXX NfcWorker::initialize() starts...";
int rc = BPS_FAILURE;
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_initialize() - entering";
rc = bps_initialize();
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_initialize() - exited";
if (rc) {
_failedToInitialize = true;
qDebug() << "XXXX Error: BPS failed to initialise. rc=" << rc;
emit message(QString("BPS failed to initialise. rc=%1").arg(rc));
} else {
qDebug() << "XXXX BPS Initialised";
}
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_request_events() - entering";
rc = nfc_request_events();
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_request_events() - exited";
if (rc) {
_failedToInitialize = true;
qDebug() << "XXXX Error: Failed to request NFC BPS events. rc=" << rc;
emit message("Failed to request NFC BPS events");
bps_shutdown();
} else {
qDebug() << "XXXX Registered for NFC BPS events OK";
emit message("Registered for NFC BPS events OK");
_interruptMutex.lock();
_bpsInterruptDomain = bps_register_domain();
if (_bpsInterruptDomain == -1) {
qDebug() << "XXXX Failed to register an interrupt domain.";
emit message("Failed to register an interrupt domain");
}
_bpsChannel = bps_channel_get_active();
_interruptMutex.unlock();
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_request_events() - entering";
CHECK(navigator_request_events(0));
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_request_events() - exited";
}
qDebug() << "XXXX NfcWorker::initialize() ends...";
}
QEventDispatcherBlackberryPrivate::QEventDispatcherBlackberryPrivate()
: loop_level(0)
, ioData(new bpsIOHandlerData)
{
// prepare to use BPS
int result = bps_initialize();
if (Q_UNLIKELY(result != BPS_SUCCESS))
qFatal("QEventDispatcherBlackberry: bps_initialize failed");
bps_channel = bps_channel_get_active();
if (bps_channel_create(&holding_channel, 0) != BPS_SUCCESS) {
qWarning("QEventDispatcherBlackberry: bps_channel_create failed");
holding_channel = -1;
}
// get domain for IO ready and wake up events - ignoring race condition here for now
if (bpsUnblockDomain == -1) {
bpsUnblockDomain = bps_register_domain();
if (Q_UNLIKELY(bpsUnblockDomain == -1))
qWarning("QEventDispatcherBlackberry: bps_register_domain failed");
}
}
QEventDispatcherBlackberryPrivate::QEventDispatcherBlackberryPrivate()
: ioData(new bpsIOHandlerData)
{
// prepare to use BPS
int result = bps_initialize();
if (result != BPS_SUCCESS)
qFatal("QEventDispatcherBlackberryPrivate::QEventDispatcherBlackberry: bps_initialize() failed");
// get domain for IO ready events - ignoring race condition here for now
if (bpsIOReadyDomain == -1) {
bpsIOReadyDomain = bps_register_domain();
if (bpsIOReadyDomain == -1)
qWarning("QEventDispatcherBlackberryPrivate::QEventDispatcherBlackberry: bps_register_domain() failed");
}
// \TODO Reinstate this when bps is fixed. See comment in select() below.
// Register thread_pipe[0] with bps
/*
int io_events = BPS_IO_INPUT;
result = bps_add_fd(thread_pipe[0], io_events, &bpsIOHandler, ioData.data());
if (result != BPS_SUCCESS)
qWarning() << Q_FUNC_INFO << "bps_add_fd() failed";
*/
}
/**
* 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;
}
int
main(int argc, char **argv)
{
const int usage = SCREEN_USAGE_NATIVE;
screen_window_t screen_win;
screen_buffer_t screen_buf = NULL;
int rect[4] = { 0, 0, 0, 0 };
// create an application window which will just act as a background
screen_create_context(&screen_ctx, 0);
screen_create_window(&screen_win, screen_ctx);
screen_create_window_group(screen_win, vf_group);
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage);
screen_create_window_buffers(screen_win, 1);
screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)&screen_buf);
screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, rect+2);
// fill the window with black
int attribs[] = { SCREEN_BLIT_COLOR, 0x00000000, SCREEN_BLIT_END };
screen_fill(screen_ctx, screen_buf, attribs);
screen_post_window(screen_win, screen_buf, 1, rect, 0);
// position the window at an arbitrary z-order
int i = APP_ZORDER;
screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &i);
// Signal bps library that navigator and screen events will be requested
bps_initialize();
main_bps_chid = bps_channel_get_active();
screen_request_events(screen_ctx);
navigator_request_events(0);
// create a custom BPS event that we can use in to let our main thread know
// that photo-taking is finished
photo_done_domain = bps_register_domain();
// open camera and configure viewfinder
if (init_camera() == EOK) {
// our main loop just runs a state machine and handles input
while (!shutdown) {
run_state_machine();
// Handle user input
handle_event();
}
if (state == STATE_TAKINGPHOTO) {
// wait for picture-taking to finish? TBD
state = STATE_VIEWFINDER;
}
if (state == STATE_VIEWFINDER) {
// clean up camera
camera_stop_photo_viewfinder(handle);
camera_close(handle);
}
}
// Clean up
screen_stop_events(screen_ctx);
bps_shutdown();
screen_destroy_window(screen_win);
screen_destroy_context(screen_ctx);
return 0;
}