void BPSEventListener::event(bps_event_t *event) { if (event != NULL) { if (bps_event_get_domain(event) == virtualkeyboard_get_domain()) { uint16_t code = bps_event_get_code(event); if (code == VIRTUALKEYBOARD_EVENT_VISIBLE) { int pixelsHeight = 0; virtualkeyboard_get_height(&pixelsHeight); if (pixelsHeight > _mPixelsHeightToConsiderKeyboardVisible) { _isKeyboardVisible = true; emit keyboardVisibilityUpdated(); } } else if (code == VIRTUALKEYBOARD_EVENT_HIDDEN && _isKeyboardVisible) { _isKeyboardVisible = false; emit keyboardVisibilityUpdated(); } else if (code == VIRTUALKEYBOARD_EVENT_INFO) { int pixelsHeight = 0; virtualkeyboard_get_height(&pixelsHeight); _isKeyboardVisible = pixelsHeight > _mPixelsHeightToConsiderKeyboardVisible; emit keyboardVisibilityUpdated(); } } else if (bps_event_get_domain(event) == netstatus_get_domain()) { if (NETSTATUS_INFO == bps_event_get_code(event)) { netstatus_info_t *info = netstatus_event_get_info(event); if (info) { bool networkReachable = netstatus_info_get_availability(info); ms_message("[BB10] Network status event: network reachable: %i", networkReachable); LinphoneManager *manager = LinphoneManager::getInstance(); linphone_core_set_network_reachable(manager->getLc(), networkReachable); } } } } }
//! 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 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; } } }
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 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); } } }
void Keyboard_NDK::event(bps_event_t *event) { Json::FastWriter writer; Json::Value root; root["threadCount"] = "10"; int domain = bps_event_get_domain(event); if (domain == virtualkeyboard_get_domain()) { int code = bps_event_get_code(event); int a; std::string str; std::string eventString; std::ostringstream strs; switch(code) { case VIRTUALKEYBOARD_EVENT_VISIBLE: eventString = "native.keyboardshow"; eventString.append(" "); virtualkeyboard_get_height(&a) ; strs << a; str = strs.str(); eventString.append("{\"keyboardHeight\":\""+str+"\"}"); m_pParent->NotifyEvent(eventString); break; case VIRTUALKEYBOARD_EVENT_HIDDEN: m_pParent->NotifyEvent("native.keyboardhide"); break; } } }
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; }
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 bool s_eventFilter(void *message) { bps_event_t * const event = static_cast<bps_event_t *>(message); if (event && (bps_event_get_domain(event) == mmrenderer_get_domain() || bps_event_get_domain(event) == screen_get_domain() )) { const int id = mmrenderer_event_get_userdata(event); BbMediaPlayerControl * const control = s_idToPlayerMap.value(id); if (control) control->bpsEventHandler(event); } if (s_previousEventFilter) return s_previousEventFilter(message); else return false; }
void BbMediaPlayerControl::bpsEventHandler(bps_event_t *event) { if (m_videoControl) m_videoControl->bpsEventHandler(event); if (bps_event_get_domain(event) != mmrenderer_get_domain()) return; if (bps_event_get_code(event) == MMRENDERER_STATE_CHANGE) { const mmrenderer_state_t newState = mmrenderer_event_get_state(event); if (newState == MMR_STOPPED) { // Only react to stop events that happen when the end of the stream is reached and // playback is stopped because of this. // Ignore other stop event sources, souch as calling mmr_stop() ourselves and // mmr_input_attach(). if (m_stopEventsToIgnore > 0) { --m_stopEventsToIgnore; } else { setMediaStatus(QMediaPlayer::EndOfMedia); stopInternal(IgnoreMmRenderer); } return; } } if (bps_event_get_code(event) == MMRENDERER_STATUS_UPDATE) { // Prevent spurious position change events from overriding our own position, for example // when setting the position to 0 in stop(). if (m_state != QMediaPlayer::PlayingState || m_mediaStatus == QMediaPlayer::LoadingMedia || m_mediaStatus == QMediaPlayer::NoMedia || m_mediaStatus == QMediaPlayer::InvalidMedia) return; const qint64 newPosition = QString::fromAscii(mmrenderer_event_get_position(event)).toLongLong(); if (newPosition != 0 && newPosition != m_position) { m_position = newPosition; emit positionChanged(m_position); } const QString bufferStatus = QString::fromAscii(mmrenderer_event_get_bufferlevel(event)); const int slashPos = bufferStatus.indexOf('/'); if (slashPos != -1) { const int fill = bufferStatus.left(slashPos).toInt(); const int capacity = bufferStatus.mid(slashPos + 1).toInt(); if (capacity != 0) { m_bufferStatus = fill / static_cast<float>(capacity) * 100.0f; emit bufferStatusChanged(m_bufferStatus); } } } }
bool QQnxVirtualKeyboardBps::handleEvent(bps_event_t *event) { const int eventDomain = bps_event_get_domain(event); if (eventDomain == locale_get_domain()) return handleLocaleEvent(event); if (eventDomain == virtualkeyboard_get_domain()) return handleVirtualKeyboardEvent(event); return false; }
void* eventLoop(void* data) { FREContext ctx = (FREContext) data; float x, y, z; bps_event_t *event = NULL; char buffer[256]; // Initialize BPS bps_initialize(); // Start the gyroscope if (sensor_request_events(SENSOR_TYPE_GYROSCOPE) != BPS_SUCCESS) { shutdown = true; } // Receive events through the event channel while (!shutdown) { event = NULL; if (bps_get_event(&event, 50) != BPS_SUCCESS) return NULL; if (event) { if (bps_event_get_domain(event) == sensor_get_domain()) { if (bps_event_get_code(event) == SENSOR_GYROSCOPE_READING) { if (sensor_event_get_xyz(event, &x, &y, &z) == BPS_SUCCESS) { sprintf(buffer, "%f&%f&%f", x, y, z); fprintf(stdout, "Sensor event: %f&%f&%f\n", x, y, z); fflush(stdout); if(ctx != NULL) { FREDispatchStatusEventAsync(ctx, (uint8_t*)"CHANGE", (uint8_t*)buffer); } } } } } } if (sensor_stop_events(SENSOR_TYPE_GYROSCOPE) != BPS_SUCCESS) { fprintf(stdout, "Unable to stop sensor\n"); fflush(stdout); } // Stop BPS bps_shutdown(); return NULL; }
bool QBBEngine::nativeEventFilter(const QByteArray &eventType, void *message, long *result) { Q_UNUSED(eventType); Q_UNUSED(result); bps_event_t * const event = static_cast<bps_event_t *>(message); Q_ASSERT(event); if (bps_event_get_domain(event) == netstatus_get_domain()) { qBearerDebug() << Q_FUNC_INFO << "got update request."; doRequestUpdate(); } return false; }
void LocatoinData::timerEvent(QTimerEvent *timerevent) { bps_event_t *event = NULL; bps_get_event(&event, -1); if (event) { if (bps_event_get_domain(event) == geolocation_get_domain()) { Q_EMIT sourceUpdated(d->geoLocationEvent(event)); } else { qDebug() << Q_FUNC_INFO << "Not a Geo Info Event"; geolocation_stop_events(0); this->startGeoTracking(); } } else { qDebug() << Q_FUNC_INFO << "Event not ready"; } }
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); } } }
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; }
bool myEventFilter(void *message) { // here we should have all requested bps events (no Qt events here) bps_event_t *event = (bps_event_t*)message; if (event) { int domain = bps_event_get_domain(event); if (domain == virtualkeyboard_get_domain()) { unsigned int ec = bps_event_get_code(event); if (!bKBhidden && ec == VIRTUALKEYBOARD_EVENT_INFO){ int nNewKBHeight = virtualkeyboard_event_get_height(event); virtualkeyboard_get_height(&nNewKBHeight); if ( nNewKBHeight != nKBHeight){ nKBHeight = nNewKBHeight; QRect r = QApplication::desktop()->screenGeometry(0); if (r.width() > 800){ // Landscape console->setGeometry(0, 0, r.width()-73, r.height()-nKBHeight); }else{ // Portrait - keyboard is taller console->setGeometry(0, 53, r.width(), r.height()-nKBHeight-53); } } } QRect r = QApplication::desktop()->screenGeometry(0); if (ec == VIRTUALKEYBOARD_EVENT_VISIBLE){ bKBhidden = false; nKBHeight = nMaxKBHeight; virtualkeyboard_change_options(VIRTUALKEYBOARD_LAYOUT_DEFAULT, VIRTUALKEYBOARD_ENTER_DEFAULT); }else if (ec == VIRTUALKEYBOARD_EVENT_HIDDEN){ bKBhidden = true; nKBHeight = 0; } if (r.width() > 800) console->setGeometry(0, 0, r.width()-73, r.height()-nKBHeight); // Landscape else console->setGeometry(0, 103, r.width(), r.height()-nKBHeight-103); // Portrait //font = QFont(QString("Courier New"), 6); font.setPixelSize(mainWindow->nFontSize); font.setStyle(QFont::StyleNormal); font.setWeight(QFont::Normal); console->setTerminalFont(font); } } mainEventFilter(message); // Call replaced event filter so we deliever everything to Qt that runs in background return false; }
bool PaymentService::handle_event(bps_event_t *p_event) { if (bps_event_get_domain(p_event) != paymentservice_get_domain()) { return false; }; Dictionary dict; int res = paymentservice_event_get_response_code(p_event); if (res == SUCCESS_RESPONSE) { dict["result"] = "ok"; res = bps_event_get_code(p_event); if (res == PURCHASE_RESPONSE) { dict["type"] = "purchase"; const char *pid = paymentservice_event_get_digital_good_id(p_event, 0); dict["product_id"] = String(pid ? pid : ""); }; } else { const char *desc = paymentservice_event_get_error_text(p_event); if (strcmp(desc, "alreadyPurchased") == 0) { dict["result"] = "ok"; } else { dict["result"] = "error"; dict["error_description"] = paymentservice_event_get_error_text(p_event); dict["error_code"] = paymentservice_event_get_error_id(p_event); printf("error code is %i\n", paymentservice_event_get_error_id(p_event)); printf("error description is %s\n", paymentservice_event_get_error_text(p_event)); }; dict["product_id"] = ""; }; res = bps_event_get_code(p_event); if (res == PURCHASE_RESPONSE) { dict["type"] = "purchase"; }; printf("********** adding event with result %ls\n", String(dict["result"]).c_str()); pending_events.push_back(dict); return true; };
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; } } }
void BbVideoWindowControl::bpsEventHandler(bps_event_t *event) { if (event && bps_event_get_domain(event) == screen_get_domain()) { const screen_event_t screen_event = screen_event_get_event(event); int eventType; if (screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &eventType) != 0) { perror("BbVideoWindowControl: Failed to query screen event type"); return; } if (eventType != SCREEN_EVENT_CREATE) return; screen_window_t window = 0; if (screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void**)&window) != 0) { perror("BbVideoWindowControl: Failed to query window property"); return; } const int maxIdStrLength = 128; char idString[maxIdStrLength]; if (screen_get_window_property_cv(window, SCREEN_PROPERTY_ID_STRING, maxIdStrLength, idString) != 0) { perror("BbVideoWindowControl: Failed to query window ID string"); return; } if (m_windowName == idString) { m_window = window; updateVideoPosition(); const int visibleFlag = 1; if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_VISIBLE, &visibleFlag) != 0) { perror("BbVideoWindowControl: Failed to make window visible"); return; } } } }
bool WindowGrabber::nativeEventFilter(const QByteArray&, void *message, long*) { bps_event_t * const event = static_cast<bps_event_t *>(message); if (event && bps_event_get_domain(event) == screen_get_domain()) { const screen_event_t screen_event = screen_event_get_event(event); int eventType; if (screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &eventType) != 0) { qWarning() << "WindowGrabber: Failed to query screen event type"; return false; } if (eventType != SCREEN_EVENT_CREATE) return false; screen_window_t window = 0; if (screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void**)&window) != 0) { qWarning() << "WindowGrabber: Failed to query window property"; return false; } const int maxIdStrLength = 128; char idString[maxIdStrLength]; if (screen_get_window_property_cv(window, SCREEN_PROPERTY_ID_STRING, maxIdStrLength, idString) != 0) { qWarning() << "WindowGrabber: Failed to query window ID string"; return false; } if (m_windowId == idString) { m_window = window; start(); } } return false; }
/** * 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; }
/** * Thread that handles accelerometer events and * sends relevant information to a dialog. * * @param p Unused. */ static void * accel_main (void *p) { bool run = true; bps_event_t *event; float force_x, force_y, force_z; bps_initialize(); /* * Each thread that calls bps_initialize() will have its * own unique channel ID. Protect it inside a mutex and * condition variable to avoid race condition where main * thread tries to use it before we assign it. */ pthread_mutex_lock(&chidMutex); accel_chid = bps_channel_get_active(); pthread_cond_signal(&chidCond); pthread_mutex_unlock(&chidMutex); /* * Create and display a dialog that will show the data. */ create_bottom_dialog(); show_bottom_dialog_message("\n\nThis is the Accelerometer Dialog"); if (BPS_SUCCESS != sensor_request_events(SENSOR_TYPE_ACCELEROMETER)) { fprintf(stderr, "Error requesting sensor's accelerometer events: %s", strerror(errno)); bps_shutdown(); return NULL; } sensor_set_rate(SENSOR_TYPE_ACCELEROMETER, ACCELEROMETER_RATE); sensor_set_skip_duplicates(SENSOR_TYPE_ACCELEROMETER, true); while (run) { /* * Block, at the very least we'll get the "STOP" event */ bps_get_event(&event, -1); if (bps_event_get_domain(event) == local_event_domain) { if (bps_event_get_code(event) == STOP_REQUEST) { run = false; } } if (bps_event_get_domain(event) == sensor_get_domain()) { if (SENSOR_ACCELEROMETER_READING == bps_event_get_code(event)) { sensor_event_get_xyz(event, &force_x, &force_y, &force_z); display_accelerometer_reading(force_x, force_y, force_z); } } } sensor_stop_events(0); destroy_bottom_dialog(); bps_shutdown(); fprintf(stderr, "Exiting accelerometer thread\n"); return NULL; }
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; }