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;
}
void OSBB10::process_events() {
handle_accelerometer();
bps_event_t *event = NULL;
do {
int rc = bps_get_event(&event, 0);
assert(rc == BPS_SUCCESS);
if (!event) break;
#ifdef BB10_SCORELOOP_ENABLED
ScoreloopBB10* sc = Globals::get_singleton()->get_singleton_object("Scoreloop")->cast_to<ScoreloopBB10>();
if (sc->handle_event(event))
continue;
#endif
#ifdef PAYMENT_SERVICE_ENABLED
if (payment_service->handle_event(event))
continue;
#endif
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handle_screen_event(event);
} else if (domain == navigator_get_domain()) {
if (NAVIGATOR_EXIT == bps_event_get_code(event)) {
if (main_loop)
main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
bps_event_destroy(event);
exit(0);
return;
/*
} else if (bps_event_get_code(event) == NAVIGATOR_ORIENTATION_CHECK) {
int angle = navigator_event_get_orientation_angle(event);
navigator_orientation_check_response(event, false);
} else if (bps_event_get_code(event) == NAVIGATOR_ORIENTATION) {
_resize(event);
*/
} else if (bps_event_get_code(event) == NAVIGATOR_WINDOW_STATE) {
int state = navigator_event_get_window_state(event);
bool was_fullscreen = fullscreen;
minimized = state == NAVIGATOR_WINDOW_INVISIBLE;
fullscreen = state == NAVIGATOR_WINDOW_FULLSCREEN;
set_low_processor_usage_mode(!fullscreen);
if (fullscreen != was_fullscreen) {
if (fullscreen) {
audio_server->set_fx_global_volume_scale(fullscreen_mixer_volume);
audio_server->set_stream_global_volume_scale(fullscreen_stream_volume);
} else {
fullscreen_mixer_volume = audio_server->get_fx_global_volume_scale();
fullscreen_stream_volume = audio_server->get_stream_global_volume_scale();
audio_server->set_fx_global_volume_scale(0);
audio_server->set_stream_global_volume_scale(0);
};
};
};
} else if (domain == audiodevice_get_domain()) {
const char * audiodevice_path = audiodevice_event_get_path(event);
printf("************* got audiodevice event, path %s\n", audiodevice_path);
audio_driver->finish();
audio_driver->init(audiodevice_path);
audio_driver->start();
};
//bps_event_destroy(event);
} while (event);
};
/**
* A sample application demonstrates the BlackBerry Native APIs for accelerometer.
* The sample initializes and reads the accelerometer periodically until a
* NAVIGATOR_EXIT event is received.
* The application also listens for window state changes from the navigator so that
* it can stop reading the accelerometer when the application is no longer visible.
*/
int
main(int argc, char *argv[])
{
if (setup_screen() != EXIT_SUCCESS) {
printf("Unable to set up the screen. Exiting.");
return 0;
}
/*
* The accelerometer forces
*/
double force_x, force_y, force_z;
/*
* Before we can listen for events from the BlackBerry Tablet OS platform
* services, we need to initialize the BPS infrastructure
*/
bps_initialize();
/*
* 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.
* For this sample, we request Navigator events so we can track when
* the system is terminating the application (NAVIGATOR_EXIT event). This allows
* us to clean up application resources.
*/
navigator_request_events(0);
/*
* Before initializing the accelerometer service we must ensure the device
* supports it
*/
if (!accelerometer_is_supported()) {
/*
* If the device does not support accelerometer then notify the user,
* clean up and exit
*/
printf("Accelerometer not supported by device!");
bps_shutdown();
return EXIT_FAILURE;
}
/*
* Initialize the accelerometer by setting the rates at which the
* accelerometer values will be updated from hardware
*/
accelerometer_set_update_frequency(FREQ_40_HZ);
/*
* Process Navigator events and take accelerometer readings periodically
* until we receive a NAVIGATOR_EXIT event.
*/
int exit_application = 0;
int paused = 0;
while (!exit_application) {
/*
* By setting the bps_get_event timeout to ACCELEROMETER_MAX_POLL_INTERVAL,
* we assign the maximum time (in millis) that we will wait before
* unblocking so we can take an accelerometer reading.
*/
bps_event_t *event = NULL;
bps_get_event(&event, ACCELEROMETER_MAX_POLL_INTERVAL);
if (event) {
if (bps_event_get_domain(event) == navigator_get_domain()) {
/*
* If it is a NAVIGATOR_EXIT event then set the
* exit_application flag so the application will stop
* processing events, clean up and exit.
*
* If it is a NAVIGATOR_WINDOW_STATE event, and the window
* state is NAVIGATOR_WINDOW_INVISIBLE, set paused to true so
* that we stop collecting accelerometer data. Otherwise, if
* we're currently paused, then set paused back to false to
* resume collecting accelerometer data.
*/
unsigned int event_code = bps_event_get_code(event);
if (NAVIGATOR_EXIT == event_code) {
exit_application = 1;
} else if (NAVIGATOR_WINDOW_STATE == event_code) {
if (navigator_event_get_window_state(event) == NAVIGATOR_WINDOW_FULLSCREEN) {
/*
* The application is now full screen.
* Resume reading the accelerometer.
*/
paused = 0;
printf("Resuming accelerometer reads.\n");
} else if (!paused){
/*
* The application has become thumbnailed or invisible.
* If it is not already paused, then pause it.
* Otherwise, ignore the window state change.
*/
paused = 1;
printf("Resuming accelerometer reads.\n");
}
}
}
/*
* Remember to destroy any delivered events as we need to trigger
* the release of any event resources when we are done processing
* it.
*/
bps_event_destroy(event);
} else {
/*
* We've woken up. See if we are in the paused state. If not,
* take an accelerometer reading
*/
if (!paused) {
accelerometer_read_forces(&force_x, &force_y, &force_z);
display_accelerometer_reading(
ACCELEROMETER_CALCULATE_PITCH(force_x, force_y, force_z),
ACCELEROMETER_CALCULATE_ROLL(force_x, force_y, force_z));
}
}
}
/*
* Clean up screen resources
*/
screen_destroy_window(screen_win);
screen_destroy_context(screen_ctx);
/*
* Clean up the BPS infrastructure and exit
*/
bps_shutdown();
return 0;
}