//! runs the device. Returns false if device wants to be deleted
bool CIrrDeviceBB10::run()
{
os::Timer::tick();
//TODO: translate native event
SEvent irrevent;
bps_event_t *event = NULL;
while ( !Close &&(bps_get_event(&event, 0) ==BPS_SUCCESS))
{
if ((event) && (bps_event_get_domain(event) == navigator_get_domain())
&& (NAVIGATOR_EXIT == bps_event_get_code(event)))
{
Close =true;
break;
}
if ((event) && (bps_event_get_domain(event) == navigator_get_domain())
&& (NAVIGATOR_WINDOW_INACTIVE == bps_event_get_code(event)))
{
WindowHasFocus =false;
break;
}
if ((event) && (bps_event_get_domain(event) == navigator_get_domain())
&& (NAVIGATOR_WINDOW_ACTIVE == bps_event_get_code(event)))
{
WindowHasFocus =true;
break;
}
if ((event) && (bps_event_get_domain(event) == navigator_get_domain())
&& (NAVIGATOR_WINDOW_STATE == bps_event_get_code(event)))
{
if(navigator_event_get_window_state(event) == NAVIGATOR_WINDOW_INVISIBLE)
WindowHasFocus =false;
else
WindowHasFocus =true;
break;
}
//TODO: transfer bps event to irr event
//postEventFromUser(irrevent);
break;
} // end while
return !Close;
}
static void handle_events() {
int screen_domain = screen_get_domain();
int navigator_domain = navigator_get_domain();
int sensor_domain = sensor_get_domain();
int rc;
//Request and process available BPS events
for(;;) {
bps_event_t *event = NULL;
rc = bps_get_event(&event, 0);
assert(rc == BPS_SUCCESS);
if (event) {
int domain = bps_event_get_domain(event);
if (domain == screen_domain) {
handleScreenEvent(event);
} else if (domain == navigator_domain) {
handleNavigatorEvent(event);
} else if (domain == sensor_domain) {
handleSensorEvent(event);
}
} else {
//No more events in the queue
break;
}
}
}
static void handleNavigatorEvent(bps_event_t *event) {
switch (bps_event_get_code(event)) {
case NAVIGATOR_ORIENTATION_CHECK:
//Signal navigator that we intend to resize
navigator_orientation_check_response(event, true);
break;
case NAVIGATOR_ORIENTATION:
if (EXIT_FAILURE == resize(event)) {
shutdown = true;
}
break;
case NAVIGATOR_EXIT:
shutdown = true;
break;
case NAVIGATOR_WINDOW_INACTIVE:
//Wait for NAVIGATOR_WINDOW_ACTIVE event
for (;;) {
if (BPS_SUCCESS != bps_get_event(&event, -1)) {
fprintf(stderr, "bps_get_event failed\n");
break;
}
if (event && (bps_event_get_domain(event) == navigator_get_domain())) {
int code = bps_event_get_code(event);
if (code == NAVIGATOR_EXIT) {
shutdown = true;
break;
} else if (code == NAVIGATOR_WINDOW_ACTIVE) {
break;
}
}
}
break;
}
}
void handleEvent() {
//Request and process BPS next available event
int rc, domain;
for (;;) {
bps_event_t *event = NULL;
rc = bps_get_event(&event, 0);
assert(rc == BPS_SUCCESS);
if (event) {
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handleScreenEvent(event);
} else if(domain == navigator_get_domain()) {
handleNavigatorEvent(event);
} else if (domain == dialog_get_domain()) {
handle_dialog_response(event);
}
} else {
break;
}
}
}
bool ScreenWindow::pollEvent(WinEvent *event)
{
bps_event_t *bpsEvent;
bps_get_event(&bpsEvent, 0);
if (bpsEvent) {
int domain = bps_event_get_domain(bpsEvent);
if (domain == navigator_get_domain()) {
if (bps_event_get_code(bpsEvent) == NAVIGATOR_EXIT) {
event->type = QUIT;
return true;
}
} else if (domain == screen_get_domain()) {
screen_event_t se = screen_event_get_event(bpsEvent);
int type;
screen_get_event_property_iv(se, SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_EVENT_CLOSE) {
event->type = QUIT;
return true;
} else if (type == SCREEN_EVENT_MTOUCH_TOUCH) {
event->type = MOUSEBUTTONDOWN;
return true;
}
}
}
return false;
}
static void handleEvents()
{
int domain;
// Get the first event in the queue.
bps_event_t *event = NULL;
if (BPS_SUCCESS != bps_get_event(&event, 0)) {
fprintf(stderr, "bps_get_event() failed\n");
return;
}
// Handle all events in the queue.
// If we don't do this in a loop, we'll only handle one event per frame.
// If many events are triggered quickly, e.g. by spinning the analog sticks,
// the queue will grow and the user will see the analog sticks lag.
while (event) {
if (event) {
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain()) {
handleNavigatorEvent(event);
} else if (domain == screen_get_domain()) {
handleScreenEvent(event);
}
}
if (BPS_SUCCESS != bps_get_event(&event, 0)) {
fprintf(stderr, "bps_get_event() failed\n");
return;
}
}
}
static void qnx_input_poll(void *data)
{
global_t *global = global_get_ptr();
qnx_input_t *qnx = (qnx_input_t*)data;
global->lifecycle_state &= ~(1ULL << RARCH_MENU_TOGGLE);
/* Request and process all available BPS events. */
while(true)
{
bps_event_t *event = NULL;
int rc = bps_get_event(&event, 0);
if(rc == BPS_SUCCESS)
{
int domain;
if (!event)
break;
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain())
qnx_handle_navigator_event(qnx, event);
else if (domain == screen_get_domain())
qnx_handle_screen_event(qnx, event);
}
}
}
bool BbGuiHelper::nativeEventFilter(const QByteArray &eventType, void *message, long *result)
{
Q_UNUSED(result);
Q_UNUSED(eventType);
bps_event_t * const event = static_cast<bps_event_t *>(message);
if (event && bps_event_get_domain(event) == navigator_get_domain()) {
const int code = bps_event_get_code(event);
if (code == NAVIGATOR_ORIENTATION) {
const int newOrientation = navigator_event_get_orientation_angle(event);
if (newOrientation != m_currentOrientation) {
m_currentOrientation = newOrientation;
emit orientationChanged();
}
} else if (code == NAVIGATOR_WINDOW_STATE) {
const bool appActive =
(navigator_event_get_window_state(event) == NAVIGATOR_WINDOW_FULLSCREEN);
if (m_applicationActive != appActive) {
m_applicationActive = appActive;
emit applicationActiveChanged();
}
}
}
return false;
}
bool QQnxBpsEventFilter::nativeEventFilter(const QByteArray &eventType, void *message, long *result)
{
Q_UNUSED(eventType);
Q_UNUSED(result);
bps_event_t *event = static_cast<bps_event_t *>(message);
const int eventDomain = bps_event_get_domain(event);
qBpsEventFilterDebug() << Q_FUNC_INFO << "event=" << event << "domain=" << eventDomain;
if (eventDomain == screen_get_domain()) {
if (!m_screenEventHandler) {
qWarning("QQNX: registered for screen events, but no handler provided.");
return false;
}
screen_event_t screenEvent = screen_event_get_event(event);
return m_screenEventHandler->handleEvent(screenEvent);
}
if (eventDomain == dialog_get_domain()) {
dialog_instance_t nativeDialog = dialog_event_get_dialog_instance(event);
QQnxFileDialogHelper *dialog = m_dialogMapper.value(nativeDialog, 0);
if (dialog)
return dialog->handleEvent(event);
}
if (eventDomain == navigator_get_domain())
return handleNavigatorEvent(event);
if (m_virtualKeyboard->handleEvent(event))
return true;
return false;
}
static void qnx_input_poll(void *data)
{
qnx_input_t *qnx = (qnx_input_t*)data;
/* Request and process all available BPS events. */
while(true)
{
bps_event_t *event = NULL;
int rc = bps_get_event(&event, 0);
if(rc == BPS_SUCCESS)
{
int domain;
if (!event)
break;
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain())
qnx_handle_navigator_event(qnx, event);
else if (domain == screen_get_domain())
qnx_handle_screen_event(qnx, event);
}
}
}
static void qnx_input_poll(void *data)
{
(void)data;
//Request and process all available BPS events
int rc, domain;
g_extern.lifecycle_state &= ~(1ULL << RARCH_MENU_TOGGLE);
while(true)
{
bps_event_t *event = NULL;
rc = bps_get_event(&event, 0);
if(rc == BPS_SUCCESS)
{
if (event)
{
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain())
handle_navigator_event(event);
else if (domain == screen_get_domain())
handle_screen_event(event);
}
else
break;
}
}
}
static void gfx_ctx_check_window(bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
(void)frame_count;
//Request and process all available BPS events
bps_event_t *event = NULL;
bps_get_event(&event, 0);
*quit = false;
unsigned new_width, new_height;
gfx_ctx_get_video_size(&new_width, &new_height);
if (new_width != *width || new_height != *height)
{
*width = new_width;
*height = new_height;
*resize = true;
}
if (event)
{
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain())
{
screen_event_t screen_event = screen_event_get_event(event);
int screen_val;
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &screen_val);
switch (screen_val) {
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_MOVE:
case SCREEN_EVENT_MTOUCH_RELEASE:
break;
}
}
else if ((domain == navigator_get_domain()) && (NAVIGATOR_EXIT == bps_event_get_code(event)))
g_extern.lifecycle_state |= (1ULL << RARCH_QUIT_KEY);
}
// Check if we are exiting.
if (g_extern.lifecycle_state & (1ULL << RARCH_QUIT_KEY))
*quit = true;
}
static void
handle_event()
{
int rc, domain;
bps_event_t *event = NULL;
rc = bps_get_event(&event, -1);
assert(rc == BPS_SUCCESS);
if (event) {
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain()) {
handle_navigator_event(event);
} else if (domain == screen_get_domain()) {
handle_screen_event(event);
}
}
}
void ActionScreenLock::execute(ExecutionState* state)
{
DataModelLogger* RUNLOG = state->getLogger();
state->getRuntimeResources()->bpsInitialize();
navigator_request_events(NAVIGATOR_DEVICE_LOCK_STATE);
bps_event_t* event = state->getRuntimeResources()->bpsGetEvent(navigator_get_domain(),
NAVIGATOR_DEVICE_LOCK_STATE);
navigator_stop_events(NAVIGATOR_DEVICE_LOCK_STATE);
if (event) {
RUNLOG->debug(SSTR("Retrieved lock state event"));
state->setUserProperty("LOCK_STATE",
SSTR(
TriggerScreenLock::lockStateToString(
navigator_event_get_device_lock_state(event))));
} else {
RUNLOG->error("Did not receive lock state information");
}
}
void BbGuiHelper::handleBpsEvent(bps_event_t *event)
{
if (event && bps_event_get_domain(event) == navigator_get_domain()) {
const int code = bps_event_get_code(event);
if (code == NAVIGATOR_ORIENTATION) {
const int newOrientation = navigator_event_get_orientation_angle(event);
if (newOrientation != m_currentOrientation) {
m_currentOrientation = newOrientation;
emit orientationChanged();
}
} else if (code == NAVIGATOR_WINDOW_STATE) {
const bool appActive =
(navigator_event_get_window_state(event) == NAVIGATOR_WINDOW_FULLSCREEN);
if (m_applicationActive != appActive) {
m_applicationActive = appActive;
emit applicationActiveChanged();
}
}
}
}
static void handle_events() {
//Request and process available BPS events
for(;;) {
bps_event_t *event = NULL;
if (BPS_SUCCESS != bps_get_event(&event, 0)) {
fprintf(stderr, "bps_get_event failed\n");
break;
}
if (event) {
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handleScreenEvent(event);
} else if (domain == navigator_get_domain()) {
handleNavigatorEvent(event);
}
} else {
break;
}
}
}
int main(int argc, char *argv[]) {
int exit_application = 0;
//Create a screen context that will be used to create an EGL surface to to receive libscreen events
screen_create_context(&screen_ctx, 0);
// Get display configuration (dimensions)
int count = 0;
screen_get_context_property_iv(screen_ctx, SCREEN_PROPERTY_DISPLAY_COUNT, &count);
screen_display_t *screen_disps = (screen_display_t *)calloc(count, sizeof(screen_display_t));
screen_get_context_property_pv(screen_ctx, SCREEN_PROPERTY_DISPLAYS, (void **)screen_disps);
screen_display_t screen_disp = screen_disps[0];
free(screen_disps);
int dims[2] = { 0, 0 };
screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, dims);
nScreenWidth = dims[0];
nScreenHeight = dims[1];
//Initialize BPS library
bps_initialize();
//Use utility code to initialize EGL for rendering with GL ES 2.0
if (EXIT_SUCCESS != bbutil_init_egl(screen_ctx)) {
fprintf(stderr, "bbutil_init_egl failed\n");
bbutil_terminate();
screen_destroy_context(screen_ctx);
return 0;
}
//Initialize application logic
if (EXIT_SUCCESS != initialize()) {
fprintf(stderr, "initialize failed\n");
bbutil_terminate();
screen_destroy_context(screen_ctx);
bps_shutdown();
return 0;
}
while (!exit_application) {
//Request and process all available BPS events
bps_event_t *event = NULL;
for(;;) {
if (BPS_SUCCESS != bps_get_event(&event, 0)) {
fprintf(stderr, "bps_get_event failed\n");
break;
}
if (event) {
int domain = bps_event_get_domain(event);
if ((domain == navigator_get_domain())
&& (NAVIGATOR_EXIT == bps_event_get_code(event))) {
exit_application = 1;
}
} else {
break;
}
}
render();
}
//Stop requesting events from libscreen
screen_stop_events(screen_ctx);
//Shut down BPS library for this process
bps_shutdown();
//Use utility code to terminate EGL setup
bbutil_terminate();
//Destroy libscreen context
screen_destroy_context(screen_ctx);
return 0;
}
int main(int argc, char **argv) {
int rc;
//Create a screen context that will be used to create an EGL surface to to receive libscreen events
screen_create_context(&screen_cxt, 0);
//Initialize BPS library
bps_initialize();
//Use utility code to initialize EGL for rendering with GL ES 1.1
if (EXIT_SUCCESS != bbutil_init_egl(screen_cxt)) {
fprintf(stderr, "Unable to initialize EGL\n");
screen_destroy_context(screen_cxt);
return 0;
}
//Initialize app data
if (EXIT_SUCCESS != init()) {
fprintf(stderr, "Unable to initialize app logic\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator orientation is to be locked
if (BPS_SUCCESS != navigator_rotation_lock(true)) {
fprintf(stderr, "navigator_rotation_lock failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator and screen events will be requested
if (BPS_SUCCESS != screen_request_events(screen_cxt)) {
fprintf(stderr, "screen_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
if (BPS_SUCCESS != navigator_request_events(0)) {
fprintf(stderr, "navigator_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
for (;;) {
//Request and process BPS next available event
bps_event_t *event = NULL;
rc = bps_get_event(&event, 0);
assert(rc == BPS_SUCCESS);
if ((event) && (bps_event_get_domain(event) == navigator_get_domain())
&& (NAVIGATOR_EXIT == bps_event_get_code(event))) {
break;
}
render();
}
//Stop requesting events from libscreen
screen_stop_events(screen_cxt);
//Shut down BPS library for this process
bps_shutdown();
//Destroy the font
bbutil_destroy_font(font);
//Use utility code to terminate EGL setup
bbutil_terminate();
//Destroy libscreen context
screen_destroy_context(screen_cxt);
return 0;
}
/**
* A sample application that demonstrates the BlackBerry Native APIs for
* managing locale. The sample queries for the current locale and then listens
* for locale update events.
*/
int
main(int argc, char *argv[])
{
/*
* Before we can listen for events from the BlackBerry Tablet OS platform
* services, we need to initialize the BPS infrastructure
*/
bps_initialize();
if (setup_screen() != EXIT_SUCCESS) {
printf("Unable to set up the screen. Exiting.");
return 0;
}
/*
* 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 that we can track when
* the system is terminating the application (NAVIGATOR_EXIT event) as well
* as Locale events so we can be notified when the locale is updated
*/
navigator_request_events(0);
locale_request_events(0);
dialog_request_events(0);
/*
* Create and display the dialog.
*/
create_dialog();
/*
* Retrieve and display the current Locale using the locale_get(...) API
*/
char* country = NULL;
char* language = NULL;
locale_get(&language, &country);
display_locale(language, country);
bps_free((char*)language);
bps_free((char*)country);
/*
* Process Locale and Navigator events until we receive a NAVIGATOR_EXIT event.
*/
int exit_application = 0;
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) == locale_get_domain()) {
/*
* If it is a LOCALE_INFO event then display the updated locale
* information
*/
if (LOCALE_INFO == bps_event_get_code(event)) {
/*
* The locale_event_get_language and locale_event_get_country
* calls return pointers to data within the event. When
* the event is destroyed below via the call to
* bps_event_destroy(event), the returned pointers would
* reference deallocated memory.
*
* To avoid potentially having pointers to dereferenced
* memory, we'll use local variables to store the pointers
* into the event data. This way, the pointers will go
* out of scope and thus cannot be used after the event
* is freed.
*/
const char* language = locale_event_get_language(event);
const char* country = locale_event_get_country(event);
display_locale(language, country);
}
}
/*
* 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 (bps_event_get_domain(event) == navigator_get_domain()) {
if (NAVIGATOR_EXIT == bps_event_get_code(event)) {
exit_application = 1;
}
}
}
}
/*
* Destroy the dialog, if it exists and cleanup screen resources.
*/
destroy_dialog();
cleanup_screen();
/*
* Clean up the BPS infrastructure and exit
*/
bps_shutdown();
return 0;
}
int main(int argc, char *argv[])
{
int rc;
int exit_application = 0;
bps_initialize();
// Create and set up the app window.
if (EXIT_FAILURE == setup_screen())
return EXIT_FAILURE;
bbads_set_log_verbosity(2);
// Display Banner on screen
load_ad(screen_window, WINDOW_GROUP_NAME);
screen_request_events(screen_context);
navigator_request_events(0);
/**
* Handle keyboard events and stop playback upon user request.
*/
for (;;) {
bps_event_t *event = 0;
if (BPS_SUCCESS != bps_get_event(&event, -1)) {
fprintf(stderr, "ERROR: Could not get BPS event!\n");
return EXIT_FAILURE;
}
if (event) {
if (navigator_get_domain() == bps_event_get_domain(event)) {
int code = bps_event_get_code(event);
if (NAVIGATOR_EXIT == code) {
if (BBADS_EOK != bbads_banner_destroy(ad_banner))
{
fprintf(stderr, "cannot destroy banner");
}
else
{
fprintf(stderr, "banner destroy");
}
exit_application = 1;
}
}
else if (bbads_get_domain() == bps_event_get_domain(event)) {
bbads_banner_t* event_banner;
bbads_event_get_banner(event, &event_banner);
bbads_banner_event_type_t event_type = (bbads_banner_event_type_t)bps_event_get_code(event);
banner_event_handler(event_banner, event_type);
}
else if (screen_get_domain() == bps_event_get_domain(event)) {
int screen_val;
char buf[1024];
int pos[2];
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &screen_val);
screen_get_event_property_cv(screen_event, SCREEN_PROPERTY_ID_STRING, sizeof(buf), buf);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_POSITION, pos);
switch (screen_val) {
case SCREEN_EVENT_CREATE:
fprintf(stderr, "create\n");
if (BBADS_EOK != bbads_banner_is_visible(ad_banner, &ad_is_visible))
{
fprintf(stderr, "cannot get banner visibility");
}
if (!ad_is_visible)
{
if (BBADS_EOK != bbads_banner_set_window_visible(ad_banner))
fprintf(stderr, "bbads_banner_set_window_visible has errors\n");
if (BBADS_EOK != bbads_banner_display(ad_banner, screen_context, event))
fprintf(stderr, "create cannot display banner\n");
}
break;
}
if (exit_application)
break;
}
}
}
screen_stop_events(screen_context);
bps_shutdown();
if (screen_destroy_window(screen_window) != 0)
return EXIT_FAILURE;
if (screen_destroy_context(screen_context) != 0)
return EXIT_FAILURE;
screen_context = 0;
screen_window = 0;
return EXIT_SUCCESS;
}
int main( int argc, char **argv ) {
const char *mmrname = NULL;
const char *ctxtname = "testplayer";
const char *audioout = NULL;
const char *inputtype = "track";
char cwd[PATH_MAX];
char inputurl[PATH_MAX];
int rc;
int final_return_code = EXIT_FAILURE;
int exit_application = 0;
mmr_connection_t *connection = NULL;
mmr_context_t *ctxt = NULL;
/*
* Before we can listen for events from the BlackBerry(R) 10 OS platform
* services, we need to initialize the BPS infrastructure
*/
bps_initialize();
if (setup_screen() != EXIT_SUCCESS) {
printf("Unable to set up the screen. Exiting.");
return 0;
}
/*
* Once the BPS infrastructure has been initialized we can register for
* events from the various BlackBerry(R) 10 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);
dialog_request_events(0);
/*
* Create and display the dialog.
*/
create_dialog();
getcwd(cwd, PATH_MAX);
rc = snprintf(inputurl, PATH_MAX, "file://%s%s", cwd, WAV_RELATIVE_PATH);
if (rc > PATH_MAX - 1)
{
show_dialog_message("File name and path too long");
goto fail;
}
mode_t mode = S_IRUSR | S_IXUSR;
int audio_oid; // output ID
strm_dict_t *aoparams = NULL; // output parameters
audioout = DEFAULT_AUDIO_OUT;
if ( ( connection = mmr_connect( mmrname ) ) == NULL ) {
snprintf(msg, MSG_SIZE, "mmr_connect: %s", strerror(errno));
show_dialog_message(msg);
} else if ( ( ctxt = mmr_context_create( connection, ctxtname, 0, mode ) ) == NULL ) {
snprintf(msg, MSG_SIZE, "%s: %s", ctxtname, strerror(errno));
show_dialog_message(msg);
} else if ( audioout && ( audio_oid = mmr_output_attach( ctxt, audioout, "audio" ) ) < 0 ) {
mmrerror( ctxt, audioout );
} else if ( aoparams && mmr_output_parameters( ctxt, audio_oid, aoparams ) ) {
mmrerror( ctxt, "output parameters (audio)" );
} else if ( mmr_input_attach( ctxt, inputurl, inputtype ) < 0 ) {
mmrerror( ctxt, inputurl );
} else if ( mmr_play( ctxt ) < 0 ) {
mmrerror( ctxt, "mmr_play" );
} else if (BPS_SUCCESS != bps_add_sigevent_handler( &mmr_sigevent, mmr_sigevent_handler, ctxt ) ) {
snprintf( msg, MSG_SIZE, "bps_add_sigevent_handler() failure %s", strerror( errno ) );
show_dialog_message( msg );
} else if ( drain_and_arm_mmr_events ( ctxt ) ) {
snprintf( msg, MSG_SIZE, "drain_and_arm_mmr_events() failure %s", strerror( errno ) );
show_dialog_message( msg );
} else {
show_dialog_message( "Playing Audio\n" );
final_return_code = EXIT_SUCCESS;
}
fail:
/*
* Process Navigator events until we receive a NAVIGATOR_EXIT event.
*/
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 it is a NAVIGATOR_EXIT event then set the exit_application
* flag so the application will stop processing events, clean up
* and exit
*/
if (bps_event_get_domain(event) == navigator_get_domain()) {
if (NAVIGATOR_EXIT == bps_event_get_code(event)) {
if (final_return_code == EXIT_SUCCESS) {
mmr_stop( ctxt ); // Not really necessary -- mmr_input_detach() would take care of this
mmr_input_detach( ctxt ); // Not really necessary -- mmr_context_destroy() would take care of this
mmr_context_destroy( ctxt ); // Not really necessary -- mmr_disconnect() would take care of this
mmr_disconnect( connection ); // Not really necessary -- exiting would take care of this
}
exit_application = 1;
}
} else if (bps_event_get_domain(event) == dialog_get_domain()) {
if (DIALOG_RESPONSE == bps_event_get_code(event)) {
handle_dialog_response_events(event);
}
}
}
}
/*
* Destroy the dialog, if it exists and cleanup screen resources.
*/
destroy_dialog();
cleanup_screen();
/*
* Clean up the BPS infrastructure and exit
*/
bps_shutdown();
return final_return_code;
}
void ConfigWindow::runEventLoop(TCOContext *emuContext)
{
screen_buffer_t buffer = draw(emuContext);
bool showingWindow = true;
bps_initialize();
screen_request_events(m_context);
bps_event_t *event; /* FIXME: How do we verify they ran bps_initialize? */
screen_event_t se;
int eventType;
int contactId;
bool touching = false;
bool releasedThisRound = false;
int startPos[2] = {0,0};
int endPos[2] = {0,0};
bool scaling = false;
while (showingWindow)
{
const int dirtyRects[4] = {0, 0, m_size[0], m_size[1]};
releasedThisRound = false;
bps_get_event(&event, 0);
while (showingWindow && event)
{
int domain = bps_event_get_domain(event);
if (domain == navigator_get_domain())
{
if (bps_event_get_code(event) == NAVIGATOR_SWIPE_DOWN)
showingWindow = false;
else if (bps_event_get_code(event) == NAVIGATOR_EXIT) {
showingWindow = false;
}
} else if (domain == screen_get_domain()) {
se = screen_event_get_event(event);
screen_get_event_property_iv(se, SCREEN_PROPERTY_TYPE, &eventType);
screen_get_event_property_iv(se, SCREEN_PROPERTY_TOUCH_ID, &contactId);
switch (eventType)
{
case SCREEN_EVENT_MTOUCH_TOUCH:
screen_get_event_property_iv(se, SCREEN_PROPERTY_TOUCH_ID, &contactId);
if (contactId == 0 && !touching && !releasedThisRound) {
touching = true;
screen_get_event_property_iv(se, SCREEN_PROPERTY_SOURCE_POSITION, startPos);
endPos[0] = startPos[0];
endPos[1] = startPos[1];
}
break;
case SCREEN_EVENT_MTOUCH_MOVE:
screen_get_event_property_iv(se, SCREEN_PROPERTY_TOUCH_ID, &contactId);
if (contactId == 0 && touching) {
screen_get_event_property_iv(se, SCREEN_PROPERTY_SOURCE_POSITION, endPos);
}
break;
case SCREEN_EVENT_MTOUCH_RELEASE:
screen_get_event_property_iv(se, SCREEN_PROPERTY_TOUCH_ID, &contactId);
if (contactId == 0 && touching) {
touching = false;
releasedThisRound = true;
screen_get_event_property_iv(se, SCREEN_PROPERTY_SOURCE_POSITION, endPos);
}
break;
case SCREEN_EVENT_PROPERTY:
break;
default:
#ifdef _DEBUG
fprintf(stderr, "Unknown screen event: %d\n", eventType);
#endif
break;
}
}
bps_get_event(&event, 0);
}
if (releasedThisRound) {
m_selected = 0;
} else if (touching) {
if (!m_selected)
m_selected = emuContext->controlAt(startPos);
if (m_selected && (endPos[0] != startPos[0] || endPos[1] != startPos[1])) {
m_selected->move(endPos[0] - startPos[0], endPos[1] - startPos[1], (unsigned*)m_size);
buffer = draw(emuContext);
startPos[0] = endPos[0];
startPos[1] = endPos[1];
}
}
if (buffer)
post(buffer);
}
}
void zaAppBase::dispatchevent(bps_event_t *event)
{
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain())
{
int screen_val;
int pair[2];
int id;
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE,
&screen_val);
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_SOURCE_POSITION, pair);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TOUCH_ID,
&id);
if (screen_val >= SCREEN_EVENT_MTOUCH_TOUCH
&& screen_val <= SCREEN_EVENT_MTOUCH_RELEASE
&& (id == 0 || m_multitouch))
{
e.m_id = id;
e.m_type = screen_val;
e.m_x = pair[0];
e.m_y = m_height - pair[1];
// e.m_obj
m_active->processEvent(&e);
}
else if (screen_val == SCREEN_EVENT_KEYBOARD)
{
int key_status;
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_KEY_FLAGS, &key_status);
if (key_status & KEY_DOWN)
{
int key_code;
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_KEY_SYM, &key_code);
e.m_type = screen_val;
e.m_keycode = key_code;
m_active->processEvent(&e);
}
}
else if (screen_val == SCREEN_EVENT_POINTER)
{
int buttons;
static int mouse_pressed = false;
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_BUTTONS,
&buttons);
e.m_event = 0;
e.m_x = pair[0];
e.m_y = m_height - pair[1];
e.m_id = id;
if (buttons == SCREEN_LEFT_MOUSE_BUTTON && mouse_pressed == false)
{
mouse_pressed = true;
e.m_type = 100; //down
}
else if (mouse_pressed && buttons == SCREEN_LEFT_MOUSE_BUTTON)
{
e.m_type = 101; //move
}
else if (mouse_pressed)
{
fprintf(stderr,"2222222 btn %d, x %d ,y %d \n", buttons,e.m_x ,e.m_y );
mouse_pressed = false;
e.m_type = 102; //up
}
if (e.m_type >= 100 && e.m_type <= 102)
m_active->processEvent(&e);
}
}
else if (domain == navigator_get_domain())
{
int cod = bps_event_get_code(event);
if (NAVIGATOR_WINDOW_INACTIVE == cod)
{
onInactive();
// ZaScreenFlash * l_flash = (ZaScreenFlash *)ZaResLib::getInstance()->getScreen("ZaScreenFlash");
// ZaScreenBase * l_src = (ZaScreenBase *)ZaResLib::getInstance()->getScreen("ZaScreenStart");
// string p= "";
// l_flash->changeScreen(l_src,l_src,l_src,p.c_str(),ZaScreenFlash::NONE);
}
}
}
int main(int argc, char *argv[])
{
int rc;
int exit_application = 0;
// Screen variables
screen_context_t screen_context = 0;
screen_window_t screen_window = 0;
int screen_size[2] = {0,0};
// Renderer variables
mmr_connection_t* mmr_connection = 0;
mmr_context_t* mmr_context = 0;
strm_dict_t* dict = NULL;
// I/O variables
int video_device_output_id = -1;
int audio_device_output_id = -1;
bps_initialize();
/*
* Create the window used for video output.
*/
if (screen_create_context(&screen_context, SCREEN_APPLICATION_CONTEXT) != 0) {
return EXIT_FAILURE;
}
if (screen_create_window(&screen_window, screen_context) != 0) {
screen_destroy_context(screen_context);
return EXIT_FAILURE;
}
if (screen_create_window_group(screen_window, window_group_name) != 0) {
return EXIT_FAILURE;
}
int format = SCREEN_FORMAT_RGBA8888;
if (screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_FORMAT, &format) != 0) {
return EXIT_FAILURE;
}
int usage = SCREEN_USAGE_NATIVE;
if (screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_USAGE, &usage) != 0) {
return EXIT_FAILURE;
}
if (screen_create_window_buffers(screen_window, 1) != 0) {
return EXIT_FAILURE;
}
/*
* Configure mm-renderer.
*/
mmr_connection = mmr_connect(NULL);
if (mmr_connection == NULL) {
return EXIT_FAILURE;
}
mmr_context = mmr_context_create(mmr_connection, video_context_name, 0, S_IRWXU|S_IRWXG|S_IRWXO);
if (mmr_context == NULL) {
return EXIT_FAILURE;
}
/*
* Configure video and audio output.
*/
video_device_output_id = mmr_output_attach(mmr_context, video_device_url, "video");
if (video_device_output_id == -1) {
return EXIT_FAILURE;
}
audio_device_output_id = mmr_output_attach(mmr_context, audio_device_url, "audio");
if (audio_device_output_id == -1) {
return EXIT_FAILURE;
}
// Get the render buffer
screen_buffer_t temp_buffer[1];
if (screen_get_window_property_pv( screen_window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)temp_buffer) != 0) {
return EXIT_FAILURE;
}
// Fill the buffer with a solid color (black)
int fill_attributes[3] = {SCREEN_BLIT_COLOR, 0x0, SCREEN_BLIT_END};
if (screen_fill(screen_context, temp_buffer[0], fill_attributes) != 0) {
return EXIT_FAILURE;
}
// Make the window visible
if (screen_get_window_property_iv(screen_window, SCREEN_PROPERTY_SIZE, screen_size) != 0) {
return EXIT_FAILURE;
}
int temp_rectangle[4] = {0, 0, screen_size[0], screen_size[1]};
if (screen_post_window(screen_window, temp_buffer[0], 1, temp_rectangle, 0) != 0) {
return EXIT_FAILURE;
}
// Prevent the backlight from going off
int idle_mode = SCREEN_IDLE_MODE_KEEP_AWAKE;
if (screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_IDLE_MODE, &idle_mode) != 0) {
return EXIT_FAILURE;
}
// Build up the path where our bundled resource is.
char cwd[PATH_MAX];
char media_file[PATH_MAX];
getcwd(cwd,PATH_MAX);
rc = snprintf(media_file, PATH_MAX, "file://%s/app/native/pb_sample.mp4", cwd);
if ((rc == -1) || (rc >= PATH_MAX)) {
return EXIT_FAILURE;
}
/*
* Start the playback.
*/
if (mmr_input_attach(mmr_context, media_file, "track") != 0) {
return EXIT_FAILURE;
}
if (mmr_play(mmr_context) != 0) {
return EXIT_FAILURE;
}
/* Do some work to make the aspect ratio correct.
*/
dict = calculate_rect(screen_size[0], screen_size[1]);
if (NULL == dict) {
return EXIT_FAILURE;
}
if (mmr_output_parameters(mmr_context, video_device_output_id, dict) != 0) {
return EXIT_FAILURE;
}
/* Note that we allocated memory for the dictionary, but the call to
* mmr_output_parameters() deallocates that memory even on failure.
*/
dict = NULL;
screen_request_events(screen_context);
navigator_request_events(0);
/*
* Handle keyboard events and stop playback upon user request.
*/
for (;;) {
bps_event_t *event = NULL;
if (bps_get_event(&event, -1) != BPS_SUCCESS) {
return EXIT_FAILURE;
}
if (event) {
if (bps_event_get_domain(event) == navigator_get_domain() &&
bps_event_get_code(event) == NAVIGATOR_EXIT) {
exit_application = 1;
}
if (exit_application) {
break;
}
}
}
screen_stop_events(screen_context);
if (mmr_stop(mmr_context) != 0) {
return EXIT_FAILURE;
}
if (mmr_output_detach(mmr_context, audio_device_output_id) != 0) {
return EXIT_FAILURE;
}
if (mmr_output_detach(mmr_context, video_device_output_id) != 0) {
return EXIT_FAILURE;
}
if (mmr_context_destroy(mmr_context) != 0) {
return EXIT_FAILURE;
}
mmr_context = 0;
video_device_output_id = -1;
audio_device_output_id = -1;
mmr_disconnect(mmr_connection);
mmr_connection = 0;
bps_shutdown();
if (screen_destroy_window(screen_window) != 0) {
return EXIT_FAILURE;
}
if (screen_destroy_context(screen_context) != 0) {
return EXIT_FAILURE;
}
screen_context = 0;
screen_window = 0;
return EXIT_SUCCESS;
}
void BlackberryMain::runMain() {
bool running = true;
while (running && !g_quitRequested) {
input_state.mouse_valid = false;
input_state.accelerometer_valid = false;
while (true) {
// Handle Blackberry events
bps_event_t *event = NULL;
bps_get_event(&event, 0);
if (event == NULL)
break; // Ran out of events
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handleInput(screen_event_get_event(event));
} else if (domain == navigator_get_domain()) {
switch(bps_event_get_code(event))
{
case NAVIGATOR_INVOKE_TARGET:
{
const navigator_invoke_invocation_t *invoke = navigator_invoke_event_get_invocation(event);
if(invoke) {
boot_filename = navigator_invoke_invocation_get_uri(invoke)+7; // Remove file://
}
}
break;
case NAVIGATOR_ORIENTATION:
sensor_remap_coordinates(navigator_event_get_orientation_angle(event));
break;
case NAVIGATOR_BACK:
case NAVIGATOR_SWIPE_DOWN:
NativeKey(KeyInput(DEVICE_ID_KEYBOARD, NKCODE_ESCAPE, KEY_DOWN));
break;
case NAVIGATOR_EXIT:
return;
}
} else if (domain == sensor_get_domain()) {
if (SENSOR_ACCELEROMETER_READING == bps_event_get_code(event)) {
sensor_event_get_xyz(event, &(input_state.acc.y), &(input_state.acc.x), &(input_state.acc.z));
AxisInput axis;
axis.deviceId = DEVICE_ID_ACCELEROMETER;
axis.flags = 0;
axis.axisId = JOYSTICK_AXIS_ACCELEROMETER_X;
axis.value = input_state.acc.x;
NativeAxis(axis);
axis.axisId = JOYSTICK_AXIS_ACCELEROMETER_Y;
axis.value = input_state.acc.y;
NativeAxis(axis);
axis.axisId = JOYSTICK_AXIS_ACCELEROMETER_Z;
axis.value = input_state.acc.z;
NativeAxis(axis);
}
}
}
UpdateInputState(&input_state);
NativeUpdate(input_state);
// Work in Progress
// Currently: Render to HDMI port (eg. 1080p) when in game. Render to device when in menu.
// Idea: Render to all displays. Controls go to internal, game goes to external(s).
if (GetUIState() == UISTATE_INGAME && !emulating) {
emulating = true;
switchDisplay(screen_emu);
if (g_Config.iShowFPSCounter == 4) {
int options = SCREEN_DEBUG_STATISTICS;
screen_set_window_property_iv(screen_win[0], SCREEN_PROPERTY_DEBUG, &options);
}
} else if (GetUIState() != UISTATE_INGAME && emulating) {
emulating = false;
switchDisplay(screen_ui);
}
NativeRender();
EndInputState(&input_state);
time_update();
// This handles VSync
if (emulating)
eglSwapBuffers(egl_disp[screen_emu], egl_surf[screen_emu]);
else
eglSwapBuffers(egl_disp[screen_ui], egl_surf[screen_ui]);
}
}
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 that demonstrates the BlackBerry(R) 10 Native SDK APIs
* for geolocation.
*/
int
main(int argc, char *argv[])
{
bool exit_application = false;
/*
* Before we can listen for events from the BlackBerry(R) 10 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(R) 10 OS platform services. The
* Navigator service manages and delivers application life cycle and
* visibility events.
*
* For this sample, we request Navigator events so that we can track when
* the system is terminating the application (NAVIGATOR_EXIT event).
*
* We request dialog events so we can be notified when the dialog service
* responds to our requests/queries.
*
* We request geolocation events so that we can be notified of our current
* geolocation.
*/
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);
}
/*
* Get geolocation events once a second, which is the most often that they
* are capable of being reported.
*/
geolocation_set_period(1);
/*
* Create and display the dialog that will show the geolocation data.
*/
create_dialog();
show_dialog_message("Geolocation getting first fix");
/*
* Process Geolocation, Dialog and Navigator events until we receive a
* NAVIGATOR_EXIT event.
*/
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 it is a geolocation event, determine the response code and
* handle the event accordingly.
*/
if (bps_event_get_domain(event) == geolocation_get_domain()) {
handle_geolocation_response(event);
}
/*
* If it is a dialog event, determine the response code and handle
* the event accordingly.
*/
else if (bps_event_get_domain(event) == dialog_get_domain()) {
/* We have no buttons so we don't need to do anything. */
;
}
/*
* If it is a NAVIGATOR_EXIT event then set the exit_application
* flag so the application will stop processing events, clean up and
* exit.
*/
else if (bps_event_get_domain(event) == navigator_get_domain()) {
exit_application = handle_navigator_event(event);
}
}
}
/*
* Stop geolocation events.
*/
geolocation_stop_events(0);
/*
* Destroy the dialog, if it exists.
*/
destroy_dialog();
/*
* Clean up the bps infrastructure and exit
*/
bps_shutdown();
cleanup_screen();
return 0;
}
/*
* This method encapsulated the main BPS event loop -- all the details needed to
* set it in place have been done in the initialize() method
*/
void NfcWorker::listen() {
qDebug() << "XXXX NfcWorker::listen() entered ...";
int rc, domain;
if (_failedToInitialize) {
qDebug() << "XXXX NfcWorker::listen() terminating due to initialisation failure";
emit message("Terminating due to initialisation failure");
StateManager* state_mgr = StateManager::getInstance();
state_mgr->setDefaultState();
return;
}
_timeToDie = false;
qDebug() << "XXXX NfcWorker::listen() entering event loop";
while (!_timeToDie) {
bps_event_t *event;
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_get_event() - entering";
rc = bps_get_event(&event, BPS_EVENT_TIMEOUT);
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_get_event() - exited";
if (!rc) {
if (event) {
domain = bps_event_get_domain(event);
if (nfc_get_domain() == domain) {
handleNfcEvent(event);
} else if (navigator_get_domain() == domain) {
handleNavigatorEvent(event);
} else if (_bpsInterruptDomain == domain) {
unsigned int code;
code = bps_event_get_code(event);
switch (code) {
case NfcWorker::TERMINATE:
_timeToDie = true;
_taskToPerform = NONE_SET;
emit message("Got a custom BPS event to terminate");
qDebug() << "XXXX Got a custom BPS event to terminate.";
break;
case NfcWorker::WAKEUP:
emit message("Got a custom BPS event to wake up");
qDebug() << "XXXX Got a custom BPS event to wake up.";
break;
default:
emit message("Unrecognised custom BPS event");
qDebug() << "XXXX Unrecognised custom BPS event.";
break;
}
} else {
emit message("BPS event didn't match a wanted domain");
qDebug() << "XXXX BPS event didn't match a wanted domain";
}
} else {
qDebug() << "XXXX No events from BPS on this wakeup";
}
} else {
qDebug() << "XXXX NfcWorker::listen() bps_get_event rc=" << rc;
emit message("Error getting BPS event");
qDebug() << "XXXX Error getting BPS event.";
}
}
if (_navigatorExitReceived) {
qDebug() << "XXXX Exiting listen() loop since got NAVIGATOR_EXIT event";
}
qDebug() << "XXXX - exited listen loop - changing state";
StateManager* state_mgr = StateManager::getInstance();
state_mgr->setDefaultState();
//
// NOTE: no need to call nfc_unregister_tag_readerwriter() since it gets
// called on our behalf automatically if needed.
//
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_stop_events() - entering";
rc = nfc_stop_events();
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_stop_events() - exited";
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_stop_events() - entering";
rc = navigator_stop_events(0);
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_stop_events() - exited";
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_shutdown() - entering";
bps_shutdown();
qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": bps_shutdown() - exited";
qDebug() << "XXXX NfcWorker::listen() BPS shutdown. Exiting listen()";
}
/**
* 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[]) {
int rc;
int exit_application = 0;
static screen_context_t screen_cxt;
//Create a screen context that will be used to create an EGL surface to to receive libscreen events
screen_create_context(&screen_cxt, 0);
//Initialize BPS library
bps_initialize();
//Use utility code to initialize EGL in landscape orientation
if (EXIT_SUCCESS != bbutil_init_egl(screen_cxt, GL_ES_1, LANDSCAPE)) {
fprintf(stderr, "bbutil_init_egl failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Initialize application logic
if (EXIT_SUCCESS != initialize()) {
fprintf(stderr, "initialize failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator and screen events will be requested
if (BPS_SUCCESS != screen_request_events(screen_cxt)) {
fprintf(stderr, "screen_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
if (BPS_SUCCESS != navigator_request_events(0)) {
fprintf(stderr, "navigator_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator orientation is not to be locked
if (BPS_SUCCESS != navigator_rotation_lock(false)) {
fprintf(stderr, "navigator_rotation_lock failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
while (!exit_application) {
//Request and process BPS next available event
bps_event_t *event = NULL;
rc = bps_get_event(&event, 0);
assert(rc == BPS_SUCCESS);
if (event) {
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handleScreenEvent(event);
} else if ((domain == navigator_get_domain())
&& (NAVIGATOR_EXIT == bps_event_get_code(event))) {
exit_application = 1;
}
}
render();
}
//Stop requesting events from libscreen
screen_stop_events(screen_cxt);
//Shut down BPS library for this process
bps_shutdown();
//Use utility code to terminate EGL setup
bbutil_terminate();
//Destroy libscreen context
screen_destroy_context(screen_cxt);
return 0;
}