/* * This method processed an NFC Event when we're intending to read an NDEF Tag */ void NfcWorker::handleNfcReadNdefTagEvent(bps_event_t *event) { uint16_t code = bps_event_get_code(event); nfc_event_t *nfcEvent; qDebug() << "XXXX NfcWorker::handleNfcReadNdefTagEvent - processing event code " << code; if (NFC_TAG_READWRITE_EVENT == code) { qDebug() << "XXXX NfcWorker::handleNfcReadNdefTagEvent - NDEF read event"; CHECK(nfc_get_nfc_event(event, &nfcEvent)); qDebug() << "XXXX NfcWorker::handleNfcReadNdefTagEvent - got NFC event object"; nfc_target_t* target; CHECK(nfc_get_target(nfcEvent, &target)); qDebug() << "XXXX NfcWorker::handleNfcReadNdefTagEvent - got target"; int ndefMsgCount = 0; CHECK(nfc_get_ndef_message_count(target, &ndefMsgCount)); qDebug() << "XXXX NfcWorker::handleNfcReadNdefTagEvent - target message count=" << ndefMsgCount; for (int ndefMsgIndex = 0; ndefMsgIndex < ndefMsgCount; ++ndefMsgIndex) { // Now processing an an NDEF message // qDebug() << "XXXX Processing NDEF Message index: " << ndefMsgIndex; // nfc_ndef_message_t *ndefMessage; // CHECK(nfc_get_ndef_message(target, ndefMsgIndex, &ndefMessage)); //TODO // Parse the ndef message!! CHECK(nfc_destroy_target(target)); } } else { qDebug() << "XXXX NfcWorker::handleNfcReadNdefTagEvent - NFC BPS event that we didn't register for: " << code; } }
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; }
void NfcWorker::handleNfcWriteUriTagEvent(bps_event_t *event) { uint16_t code = bps_event_get_code(event); qDebug() << "XXXX NfcWorker::handleWriteUriTagEvent - processing event code " << code; nfc_event_t *nfcEvent; nfc_target_t* target; nfc_ndef_message_t* myNdefMessage; if (NFC_TAG_READWRITE_EVENT == code) { qDebug() << "XXXX NfcWorker::handleWriteUriTagEvent - Target Read Write Event"; CHECK(nfc_get_nfc_event(event, &nfcEvent)); CHECK(nfc_get_target(nfcEvent, &target)); qDebug() << "XXXX NfcWorker::handleWriteUriTagEvent - Preparing to write URI: "; //--------- Try using C APIs---------------------------- QString uri("www.google.ca"); nfc_ndef_record_t* record = 0; int len = uri.length(); uchar_t payload[len + 1]; memcpy(&payload[0], uri.toUtf8().constData(), len); CHECK(nfc_create_ndef_record(NDEF_TNF_WELL_KNOWN, "U", payload, len + 1, 0, &record)); CHECK(nfc_create_ndef_message(&myNdefMessage)); CHECK(nfc_add_ndef_record(myNdefMessage,record)); qDebug() << "Before Writing"; bool status; status = true; CHECK(nfc_tag_is_writable(target,&status)); CHECK(nfc_write_ndef_message_to_tag(target,myNdefMessage, true)); qDebug() << "After Writing"; CHECK(nfc_delete_ndef_message(myNdefMessage, true)); CHECK(nfc_destroy_target(target)); } else { qDebug() << "XXXX NfcWorker::handleWriteUriTagEvent - NFC BPS event that we didn't register for: " << code; } }
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; }
//! [1] void NfcSender::event(bps_event_t *event) { uint16_t code = bps_event_get_code(event); nfc_event_t *nfc_event = 0; if (nfc_get_nfc_event(event, &nfc_event) != BPS_SUCCESS) { qDebug() << "[ERRO] Get NFC event: BPS_FAILURE" << endl; } nfc_target_t *target = 0; nfc_get_target(nfc_event, &target); switch (code) { case NFC_SNEP_CONNECTION_EVENT: { qDebug() << "[INFO] Received NFC_NDEF_PUSH_EVENT" << endl; handleSnepPush(target); } break; case NFC_NDEF_PUSH_SUCCEED_EVENT: { qDebug() << "[INFO] Received NFC_NDEF_PUSH_SUCCEED_EVENT" << endl; } break; case NFC_NDEF_PUSH_FAILURE_MSG_OVER_SIZE_EVENT: { qDebug() << "[ERRO] Received NFC_NDEF_PUSH_FAILURE_MSG_OVER_SIZE_EVENT" << endl; } break; case NFC_NDEF_PUSH_FAILURE_REJECTED_EVENT: { qDebug() << "[ERRO] Received NFC_NDEF_PUSH_FAILURE_REJECTED_EVENT" << endl; } break; case NFC_NDEF_PUSH_FAILURE_IO_ERROR_EVENT: { qDebug() << "[ERRO] Received NFC_NDEF_PUSH_FAILURE_IO_ERROR_EVENT" << endl; } break; default: { qDebug() << "[WARN] Event not handled: " << code << endl; } break; } nfc_destroy_target(target); }
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(); } } } }
void NfcWorker::handleEmulateNfcEvent(bps_event_t *event) { uint16_t code = bps_event_get_code(event); qDebug() << "XXXX NfcWorker::handleEmulateNfcEvent - processing event code: " << code; if (NFC_VIRTUAL_TAG_SELECTION_EVENT == code) { qDebug() << "XXXX Nfc Virtual Tag Selection Event detected"; emit message("NFC Virtual Tag Selection Event detected"); } else if (NFC_VIRTUAL_TAG_LEFT_EVENT == code) { qDebug() << "XXXX Nfc Virtual Tag Left Event detected"; emit message("NFC Virtual Tag Left Event detected"); } else if (NFC_VIRTUAL_TAG_READ_EVENT == code) { qDebug() << "XXXX Nfc Virtual Tag Read Event detected"; emit message("NFC Virtual Tag Read Event detected"); } qDebug() << "XXXX Emulate done"; }
bool QNXNFCEventFilter::nativeEventFilter(const QByteArray &eventType, void *message, long *result) { Q_UNUSED(eventType); Q_UNUSED(result); bps_event_t *event = static_cast<bps_event_t *>(message); int code = bps_event_get_code(event); if (code == NAVIGATOR_INVOKE_TARGET) { // extract bps request from event const navigator_invoke_invocation_t *invoke = navigator_invoke_event_get_invocation(event); const char *uri = navigator_invoke_invocation_get_uri(invoke); const char *type = navigator_invoke_invocation_get_type(invoke); int dataLength = navigator_invoke_invocation_get_data_length(invoke); const char *raw_data = (const char*)navigator_invoke_invocation_get_data(invoke); QByteArray data(raw_data, dataLength); //message.fromByteArray(data); //const char* metadata = navigator_invoke_invocation_get_metadata(invoke); nfc_ndef_message_t *ndefMessage; nfc_create_ndef_message_from_bytes(reinterpret_cast<const uchar_t *>(data.data()), data.length(), &ndefMessage); QNdefMessage message = QNXNFCManager::instance()->decodeMessage(ndefMessage); unsigned int ndefRecordCount; nfc_get_ndef_record_count(ndefMessage, &ndefRecordCount); qQNXNFCDebug() << "Got Invoke event" << uri << "Type" << type; emit ndefEvent(message); } return false; }
static void handleSensorEvent(bps_event_t *event) { if (SENSOR_AZIMUTH_PITCH_ROLL_READING == bps_event_get_code(event)) { float azimuth, pitch, roll; float result_x = 0.0f, result_y = -1.0f; sensor_event_get_apr(event, &azimuth, &pitch, &roll); float radians = abs(roll) * M_PI / 180 ;//+ adjustment_angle; float horizontal = sin(radians) * 0.5f; float vertical = cos(radians) * 0.5f; if (pitch < 0) { vertical = -vertical; } if (roll >= 0) { horizontal = -horizontal; } //Account for axis change due to different starting orientations if (orientation_angle == 0) { result_x = horizontal; result_y = vertical; } else if (orientation_angle == 90) { result_x = -vertical; result_y = horizontal; } else if (orientation_angle == 180) { result_x = -horizontal; result_y = -vertical; } else if (orientation_angle == 270) { result_x = vertical; result_y = -horizontal; } set_gravity(result_x, result_y); } }
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; }
/* * navigator events are generated when we're launched by the Invoke Framework (IF) * due to a tag we're interested in (as declared in the bar-descriptor.xml file) * is presented to the device. There are other situations that generate navigator * events but in this specific case, we look to acquire the tag data which * the IF has and process it. * */ void NfcWorker::handleNavigatorNdefEvent(bps_event_t *event) { uint16_t code = bps_event_get_code(event); if (NAVIGATOR_INVOKE_TARGET == code) { emit message("Navigator invoke target received"); const navigator_invoke_invocation_t *invocation = navigator_invoke_event_get_invocation(event); if (!invocation) { qDebug() << "XXXX No invocation for invoke NDEF event"; } const char *invokeAction = navigator_invoke_invocation_get_action(invocation); if (!invokeAction) { qDebug() << "XXXX No action for invoke NDEF event"; } const QString actionToPerform(invokeAction); if (actionToPerform == "bb.action.OPEN") { emit message("Navigator bb.action.OPEN received"); qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_type() - entering"; const char *mimeType = navigator_invoke_invocation_get_type(invocation); qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_type() - exited"; if (!mimeType) { qDebug() << "XXXX No Mime Type with invoke request"; } const QString mimeTypeRequested(mimeType); qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_data_length() - entering"; int invokeDataLength = navigator_invoke_invocation_get_data_length(invocation); qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_data_length() - exited"; if (invokeDataLength == -1) { qDebug() << "XXXX Invalid invoke data length"; } qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_data() - entering"; const void *invokeData = navigator_invoke_invocation_get_data(invocation); qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": navigator_invoke_invocation_get_data() - exited"; if (!invokeData) { qDebug() << "XXXX Invalid invoke data"; } nfc_ndef_message_t *ndefMessage; qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_create_ndef_message_from_bytes() - entering"; CHECK( nfc_create_ndef_message_from_bytes(reinterpret_cast<const uchar_t *>(invokeData), invokeDataLength, &ndefMessage)); qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_create_ndef_message_from_bytes() - exited"; // cause event log to be displayed now StateManager* state_mgr = StateManager::getInstance(); qDebug() << "XXXX NfcWorker::readTag() isEventLogShowing()=" << state_mgr->isEventLogShowing(); emit clearMessages(); if (!state_mgr->isEventLogShowing()) { qDebug() << "XXXXX NfcWorker emiting read_selected"; emit read_selected(); } parseNdefMessage(ndefMessage); qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_delete_ndef_message() - entering"; CHECK(nfc_delete_ndef_message(ndefMessage, true)); qDebug() << "XXXX Time(ms) : " << getSysTimeMs() << ": nfc_delete_ndef_message() - exited"; } } else if (NAVIGATOR_INVOKE_QUERY_RESULT == code) { emit message("Navigator invoke query received"); // just log and ignore query requests for the moment const char *id = navigator_event_get_id(event); const char *err = navigator_event_get_err(event); qDebug() << QString("XXXX Invoke Query Result, Id: '%1' Error: '%2'").arg(id).arg(err); } else { qDebug() << "XXXX Received Navigation event we don't handle: " << getNavigatorEventName(code); } }
/* * 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()"; }
int main(int argc, char **argv) { FILE *file; int samples; char *sample_buffer; int rtn, final_return_code = -1, exit_application = 0; int bsize, bytes_read, total_written = 0; fd_set rfds, wfds; char input_file[PATH_MAX]; char cwd[PATH_MAX]; /* * 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."); 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. * * 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. * * We request Audio Device events because we want to make sure that * we properly handle changes in audio output. * * We request dialog events to properly initialize the dialog * subsystem in order to display status and error messages. */ 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 != audiodevice_request_events(0)) { fprintf(stderr, "Error requesting audio device events: %s", strerror(errno)); exit(-1); } /* * Create and display the dialog. */ create_dialog(); /* * Open and check the input file. */ getcwd(cwd, PATH_MAX); rtn = snprintf(input_file, PATH_MAX, "%s/%s", cwd, WAV_RELATIVE_PATH); if (rtn > PATH_MAX - 1) { err("File name and path too long"); goto fail1; } if ((file = fopen(input_file, "r")) == 0) { err("File open failed"); goto fail1; } if (check_hdr(file) == -1) { err("check_hdr failed"); goto fail2; } /* * Parse the headers in the wav file to figure out what kind of data we * are dealing with in the file. */ samples = find_tag(file, "fmt "); fread(&wav_header, sizeof(wav_header), 1, file); fseek(file,(samples - sizeof(wave_hdr)), SEEK_CUR); sample_rate = ENDIAN_LE32(wav_header.samples_per_sec); sample_channels = ENDIAN_LE16(wav_header.channels); sample_bits = ENDIAN_LE16(wav_header.bits_per_sample); snprintf(msg, MSG_SIZE, "SampleRate = %d, channels = %d, SampleBits = %d\n", sample_rate, sample_channels, sample_bits); show_dialog_message(msg); if (setup_snd(NULL)) { goto fail2; } bsize = setup.buf.block.frag_size; samples = find_tag(file, "data"); sample_buffer = malloc(bsize); if (!sample_buffer) { goto fail3; } FD_ZERO(&rfds); FD_ZERO(&wfds); bytes_read = 1; while (total_written < samples && bytes_read > 0 ) { bps_event_t *event = NULL; while (BPS_SUCCESS == bps_get_event(&event, 0) && event) { /* * If it is a NAVIGATOR_EXIT event then we are done so 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; goto success; } } if (bps_event_get_domain(event) == audiodevice_get_domain()) { /* * If it is a audio device event then it means a new audio device * has been enabled and a switch is required. We close the old, * open the new audio device using the path and get the card number so * that we can close and re-open the mixer with the new card * number. */ const char * audiodevice_path = audiodevice_event_get_path(event); if (NULL == audiodevice_path) { snprintf(msg, MSG_SIZE, "audiodevice_event_get_path failed: %s\n", snd_strerror(rtn)); show_dialog_message(msg); goto fail5; } if ((rtn = snd_mixer_close(mixer_handle)) < 0) { snprintf(msg, MSG_SIZE, "snd_mixer_close failed: %s\n", snd_strerror(rtn)); show_dialog_message(msg); goto fail4; } if ((rtn = snd_pcm_close(pcm_handle)) < 0) { snprintf(msg, MSG_SIZE, "snd_pcm_close failed: %s\n", snd_strerror(rtn)); show_dialog_message(msg); goto fail3; } if (setup_snd(audiodevice_path)) { /* * setup_snd() closes pcm and mixer handles in the case of error so we * skip clean up of the handles in the case of failure. */ goto fail3; } } } if (tcgetpgrp(0) == getpid()) FD_SET(STDIN_FILENO, &rfds); FD_SET(snd_mixer_file_descriptor(mixer_handle), &rfds); FD_SET(snd_pcm_file_descriptor(pcm_handle, SND_PCM_CHANNEL_PLAYBACK), &wfds); rtn = max(snd_mixer_file_descriptor(mixer_handle), snd_pcm_file_descriptor(pcm_handle, SND_PCM_CHANNEL_PLAYBACK)); if (select(rtn + 1, &rfds, &wfds, NULL, NULL) == -1) { err("select"); goto fail5; } if (FD_ISSET(snd_pcm_file_descriptor(pcm_handle, SND_PCM_CHANNEL_PLAYBACK), &wfds)) { snd_pcm_channel_status_t status; int written = 0; if ((bytes_read = fread(sample_buffer, 1, min(samples - total_written, bsize), file)) <= 0) continue; written = snd_pcm_plugin_write(pcm_handle, sample_buffer, bytes_read); if (written < bytes_read) { memset(&status, 0, sizeof(status)); status.channel = SND_PCM_CHANNEL_PLAYBACK; if (snd_pcm_plugin_status(pcm_handle, &status) < 0) { show_dialog_message("underrun: playback channel status error\n"); goto fail5; } if (status.status == SND_PCM_STATUS_READY || status.status == SND_PCM_STATUS_UNDERRUN) { if (snd_pcm_plugin_prepare(pcm_handle, SND_PCM_CHANNEL_PLAYBACK) < 0) { show_dialog_message("underrun: playback channel prepare error\n"); goto fail5; } } if (written < 0) written = 0; written += snd_pcm_plugin_write(pcm_handle, sample_buffer + written, bytes_read - written); } total_written += written; } } success: bytes_read = snd_pcm_plugin_flush(pcm_handle, SND_PCM_CHANNEL_PLAYBACK); final_return_code = 0; /* * there are return codes to these close calls, but we would do the same * thing regardless of error or success so we do not check the return codes. */ fail5: snd_mixer_close(mixer_handle); fail4: snd_pcm_close(pcm_handle); fail3: free(sample_buffer); sample_buffer = NULL; fail2: fclose(file); fail1: while (!exit_application) { /* * Something went wrong so there is probably an error message and * we don't want to exit right away because we want the user to see * the message in the dialog. * * 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 we are done so 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(); bps_shutdown(); return final_return_code; }
// Entry Point int main(int argc, char *argv[]) { static screen_context_t screen_cxt; // Receive events from window manager screen_create_context(&screen_cxt, 0); //Initialise Blackberry Platform Services bps_initialize(); net::Init(); init_GLES2(screen_cxt); #ifdef BLACKBERRY10 // Dev Alpha: 1280x768, 4.2", 356DPI, 0.6f scale int dpi; screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_DPI, &dpi); #else // Playbook: 1024x600, 7", 170DPI, 1.25f scale int screen_phys_size[2]; screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_PHYSICAL_SIZE, screen_phys_size); int screen_resolution[2]; screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution); double diagonal_pixels = sqrt(screen_resolution[0] * screen_resolution[0] + screen_resolution[1] * screen_resolution[1]); double diagonal_inches = 0.0393700787 * sqrt(screen_phys_size[0] * screen_phys_size[0] + screen_phys_size[1] * screen_phys_size[1]); int dpi = (int)(diagonal_pixels / diagonal_inches + 0.5); #endif float dpi_scale = 213.6f / dpi; dp_xres = (int)(pixel_xres * dpi_scale); dp_yres = (int)(pixel_yres * dpi_scale); NativeInit(argc, (const char **)argv, "data/", "/accounts/1000/shared", "BADCOFFEE"); NativeInitGraphics(); screen_request_events(screen_cxt); navigator_request_events(0); dialog_request_events(0); #ifdef BLACKBERRY10 vibration_request_events(0); #endif BlackberryAudio* audio = new BlackberryAudio(); InputState input_state; bool running = true; while (running) { input_state.mouse_valid = false; input_state.accelerometer_valid = false; SimulateGamepad(&input_state); 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()) { int screen_val, buttons, pointerId; int pair[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_iv(screen_event, SCREEN_PROPERTY_SOURCE_POSITION, pair); screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TOUCH_ID, &pointerId); input_state.mouse_valid = true; switch(screen_val) { // Touchscreen case SCREEN_EVENT_MTOUCH_TOUCH: case SCREEN_EVENT_MTOUCH_RELEASE: // Up, down input_state.pointer_down[pointerId] = (screen_val == SCREEN_EVENT_MTOUCH_TOUCH); case SCREEN_EVENT_MTOUCH_MOVE: input_state.pointer_x[pointerId] = pair[0] * dpi_scale; input_state.pointer_y[pointerId] = pair[1] * dpi_scale; break; // Mouse, Simulator case SCREEN_EVENT_POINTER: screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_BUTTONS, &buttons); if (buttons == SCREEN_LEFT_MOUSE_BUTTON) { // Down input_state.pointer_x[pointerId] = pair[0] * dpi_scale; input_state.pointer_y[pointerId] = pair[1] * dpi_scale; input_state.pointer_down[pointerId] = true; } else if (input_state.pointer_down[pointerId]) { // Up input_state.pointer_x[pointerId] = pair[0] * dpi_scale; input_state.pointer_y[pointerId] = pair[1] * dpi_scale; input_state.pointer_down[pointerId] = false; } break; // Keyboard case SCREEN_EVENT_KEYBOARD: int flags, value; screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_FLAGS, &flags); screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_SYM, &value); if (flags & (KEY_DOWN | KEY_SYM_VALID)) { for (int b = 0; b < 14; b++) { if (value == buttonMappings[b]) input_state.pad_buttons |= (1<<b); } } break; } } else if (domain == navigator_get_domain()) { switch(bps_event_get_code(event)) { case NAVIGATOR_BACK: case NAVIGATOR_SWIPE_DOWN: input_state.pad_buttons |= PAD_BUTTON_MENU; break; case NAVIGATOR_EXIT: running = false; break; } } } UpdateInputState(&input_state); NativeUpdate(input_state); EndInputState(&input_state); NativeRender(); // On Blackberry, this handles VSync for us eglSwapBuffers(egl_disp, egl_surf); } screen_stop_events(screen_cxt); bps_shutdown(); NativeShutdownGraphics(); delete audio; NativeShutdown(); kill_GLES2(); net::Shutdown(); screen_destroy_context(screen_cxt); exit(0); return 0; }
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; }
/** * 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; }
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); };
/* * @param doWhat: 0 for reading, 1 for Writing * 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(int doWhat) { 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"); return; } _timeToDie = false; qDebug() << "XXXX NfcWorker::listen() entering event loop"; while (!_timeToDie) { bps_event_t *event; qDebug() << ": bps_get_event() - entering"; rc = bps_get_event(&event, BPS_EVENT_TIMEOUT); qDebug() << ": bps_get_event() - exited"; if (!rc) { if (event) { domain = bps_event_get_domain(event); if (nfc_get_domain() == domain) { //Un-implemented portion handleNfcEvent(event,doWhat); } else if (_bpsInterruptDomain == domain) { unsigned int code; code = bps_event_get_code(event); switch (code) { case NfcWorker::TERMINATE: _timeToDie = true; 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."; } } // // NOTE: no need to call nfc_unregister_tag_readerwriter() since it gets // called on our behalf automatically if needed. // qDebug() << ": nfc_stop_events() - entering"; rc = nfc_stop_events(); qDebug() << ": nfc_stop_events() - exited"; qDebug() << ": bps_shutdown() - entering"; bps_shutdown(); qDebug() << ": bps_shutdown() - exited"; qDebug() << "XXXX NfcWorker::listen() BPS shutdown. Exiting listen()"; }
int main(int argc, char *argv[]) { int exit_application = 0; 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); initGestures(); //Initialize BPS library bps_initialize(); //Use utility code to initialize EGL for 2D rendering with GL ES 1.1 if (EXIT_SUCCESS != bbutil_init_egl(screen_cxt, GL_ES_1, AUTO)) { 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; } // set up our box2D tests fprintf(stderr, "Box2D Version %d.%d.%d\n", b2_version.major, b2_version.minor, b2_version.revision); testCount = 0; while (g_testEntries[testCount].createFcn != NULL) { ++testCount; } testIndex = b2Clamp(testIndex, 0, testCount-1); testSelection = testIndex; entry = g_testEntries + testIndex; test = entry->createFcn(); test->m_debugDraw.SetFont(font); test->m_debugDraw.SetScreenSize(width, height); struct timespec time_struct; clock_gettime(CLOCK_REALTIME, &time_struct); long update_time = time2millis(&time_struct); long current_time, last_time; #ifdef FPS int frames = 0; last_time = update_time; #endif for (;;) { //Request and process BPS next available event bps_event_t *event = NULL; rc = bps_get_event(&event, 1); 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; } } clock_gettime(CLOCK_REALTIME, &time_struct); current_time = time2millis(&time_struct); if ((current_time - update_time) > framePeriod) { update_time = current_time; render(); #ifdef FPS frames++; #endif } else { sleep(0); } #ifdef FPS if (current_time - last_time > 1000) { fprintf(stderr, "fps: %d\n", frames); frames = 0; last_time = current_time; } #endif if (exit_application) break; } // clean up gestures gesturesCleanup(); //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; }
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]); } }
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; }
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; }
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 ButtonMap::mapNextButtonPressed() { bps_event_t *event = NULL; int sym; //use in frontend run loop, get key pressed back, and map int z = 10; if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &z) != 0) { return -1; } screen_post_window(screen_win, screen_buf, 1, screen_resolution, 0); while(1) { if (BPS_SUCCESS != bps_get_event(&event, -1)) { fprintf(stderr, "bps_get_event failed\n"); break; } if (event) { int domain = bps_event_get_domain(event); int events = bps_event_get_code(event); if (events == NAVIGATOR_SWIPE_DOWN) { if(overlayDisplay) { *g_settings.input.overlay = '\1'; } else { *g_settings.input.overlay = '\1'; } overlayDisplay = !overlayDisplay; } 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); //TODO: Should we only let the buttons through that we are trying to map? if(screen_val == SCREEN_EVENT_MTOUCH_TOUCH) { //This is touch screen event sym = NO_BTN; break; } else if(screen_val == SCREEN_EVENT_KEYBOARD) { screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_SYM, &sym); sym &= 0xFF; break; } else if( (screen_val == SCREEN_EVENT_GAMEPAD) || (screen_val == SCREEN_EVENT_JOYSTICK) ) { screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_BUTTONS, &sym); break; } } } } z = -10; if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &z) != 0) { return -1; } screen_post_window(screen_win, screen_buf, 1, screen_resolution, 0); return (g_settings.input.binds[player][button].joykey = sym); }
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); } }
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; }
void StatusEventHandler::event(bps_event_t *event) { bool status = false; const char* language = ""; const char* country = ""; const char* locale = ""; const char* interface = ""; const char* type = "none"; double latitude = 0; double longitude= 0; if (bps_event_get_domain(event) == geolocation_get_domain()) { if(event == NULL || bps_event_get_code(event) != GEOLOCATION_INFO) { qDebug() << "NO INFORMATION PROVIDED"; return; } latitude = geolocation_event_get_latitude(event); longitude = geolocation_event_get_longitude(event); double accuracy = geolocation_event_get_accuracy(event); double altitude = geolocation_event_get_altitude(event); bool altitude_valid = geolocation_event_is_altitude_valid(event); double altitude_accuracy = geolocation_event_get_altitude_accuracy(event); bool altitude_accuracy_valid = geolocation_event_is_altitude_accuracy_valid(event); double heading = geolocation_event_get_heading(event); bool heading_valid = geolocation_event_is_heading_valid(event); double speed = geolocation_event_get_speed(event); bool speed_valid = geolocation_event_is_speed_valid(event); double num_satellites = geolocation_event_get_num_satellites_used(event); bool num_satellites_valid = geolocation_event_is_num_satellites_valid(event); emit geolocationUpdated(latitude,longitude); } 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) { status = netstatus_info_get_availability(info); interface = netstatus_info_get_default_interface(info); netstatus_interface_details_t *details; int success = netstatus_get_interface_details(interface, &details); if (success == BPS_SUCCESS) { switch (netstatus_interface_get_type(details)) { case NETSTATUS_INTERFACE_TYPE_UNKNOWN: type = "Unknown"; break; case NETSTATUS_INTERFACE_TYPE_WIRED: type = "Wired"; break; case NETSTATUS_INTERFACE_TYPE_WIFI: type = "Wi-Fi"; break; case NETSTATUS_INTERFACE_TYPE_BLUETOOTH_DUN: type = "Bluetooth"; break; case NETSTATUS_INTERFACE_TYPE_USB: type = "USB"; break; case NETSTATUS_INTERFACE_TYPE_VPN: type = "VPN"; break; case NETSTATUS_INTERFACE_TYPE_BB: type = "BB"; break; case NETSTATUS_INTERFACE_TYPE_CELLULAR: type = "Cellular"; break; case NETSTATUS_INTERFACE_TYPE_P2P: type = "P2P"; break; } } netstatus_free_interface_details(&details); emit networkStatusUpdated(status, type); } } } else if (bps_event_get_domain(event) == locale_get_domain()) { if (LOCALE_INFO == bps_event_get_code(event)) { language = locale_event_get_language(event); country = locale_event_get_country(event); locale = locale_event_get_locale(event); emit localeUpdated(language, country, locale); } } }
/** * 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; }
bool CCEGLView::handleEvents() { bps_event_t* event = NULL; mtouch_event_t mtouch_event; int touch_id = 0; int val = 0; int rc = 0; int domain = 0; char buf[4] = {0}; for (;;) { rc = bps_get_event(&event, 1); assert(rc == BPS_SUCCESS); // break if no more events if (event == NULL) break; domain = bps_event_get_domain(event); if (domain == navigator_get_domain()) { switch (bps_event_get_code(event)) { case NAVIGATOR_SWIPE_DOWN: CCDirector::sharedDirector()->getKeypadDispatcher()->dispatchKeypadMSG(kTypeMenuClicked); break; case NAVIGATOR_EXIT: // exit the application // release(); end(); break; case NAVIGATOR_WINDOW_INACTIVE: if (m_isWindowActive) { CCApplication::sharedApplication()->applicationDidEnterBackground(); m_isWindowActive = false; } break; case NAVIGATOR_WINDOW_ACTIVE: if (!m_isWindowActive) { CCApplication::sharedApplication()->applicationWillEnterForeground(); m_isWindowActive = true; } break; case NAVIGATOR_WINDOW_STATE: { switch(navigator_event_get_window_state(event)) { case NAVIGATOR_WINDOW_FULLSCREEN: if (!m_isWindowActive) { CCApplication::sharedApplication()->applicationWillEnterForeground(); m_isWindowActive = true; } break; case NAVIGATOR_WINDOW_THUMBNAIL: if (m_isWindowActive) { CCApplication::sharedApplication()->applicationDidEnterBackground(); m_isWindowActive = false; } break; } break; } default: break; } } else if (domain == screen_get_domain()) { m_screenEvent = screen_event_get_event(event); rc = screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_TYPE, &val); if (rc || val == SCREEN_EVENT_NONE) break; float x, y; switch (val) { case SCREEN_EVENT_CLOSE: fprintf(stderr, "SCREEN CLOSE EVENT!\n"); break; case SCREEN_EVENT_MTOUCH_RELEASE: screen_get_mtouch_event(m_screenEvent, &mtouch_event, 0); touch_id = mtouch_event.contact_id; x = mtouch_event.x; y = mtouch_event.y; handleTouchesEnd(1, &touch_id, &x, &y); break; case SCREEN_EVENT_MTOUCH_TOUCH: screen_get_mtouch_event(m_screenEvent, &mtouch_event, 0); touch_id = mtouch_event.contact_id; x = mtouch_event.x; y = mtouch_event.y; handleTouchesBegin(1, &touch_id, &x, &y); break; case SCREEN_EVENT_MTOUCH_MOVE: screen_get_mtouch_event(m_screenEvent, &mtouch_event, 0); touch_id = mtouch_event.contact_id; x = mtouch_event.x; y = mtouch_event.y; handleTouchesMove(1, &touch_id, &x, &y); break; case SCREEN_EVENT_POINTER: { int buttons = 0; int pair_[2] = {0}; float pair[2] = {0.0f}; static bool mouse_pressed = false; // this is a mouse move event, it is applicable to a device with a usb mouse or simulator screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_BUTTONS, &buttons); screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_SOURCE_POSITION, pair_); pair[0] = (float)pair_[0]; pair[1] = (float)pair_[1]; if (buttons & SCREEN_LEFT_MOUSE_BUTTON) { if (mouse_pressed) { handleTouchesMove(1, &touch_id, &pair[0], &pair[1]); } else { // Left mouse button is pressed mouse_pressed = true; handleTouchesBegin(1, &touch_id, &pair[0], &pair[1]); } } else { if (mouse_pressed) { mouse_pressed = false; handleTouchesEnd(1, &touch_id, &pair[0], &pair[1]); } } } break; case SCREEN_EVENT_KEYBOARD: screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_KEY_FLAGS, &val); if (val & KEY_DOWN) { screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_KEY_SYM, &val); if (val >= ' ' && val < '~') { buf[0] = val; buf[1]= '\0'; CCIMEDispatcher::sharedDispatcher()->dispatchInsertText(buf, 1); } else { val = val - 0xf000; buf[0] = val; buf[1]= '\0'; switch (val) { case 8: // backspace // CCKeypadDispatcher::sharedDispatcher()->dispatchKeypadMSG(kTypeBackClicked); CCIMEDispatcher::sharedDispatcher()->dispatchDeleteBackward(); break; default: CCIMEDispatcher::sharedDispatcher()->dispatchInsertText(buf, 1); break; } } } break; default: break; } } else if (domain == sensor_get_domain()) { if (bps_event_get_code(event) == SENSOR_ACCELEROMETER_READING) { struct timespec time_struct; long current_time; float x, y, z; clock_gettime(CLOCK_REALTIME, &time_struct); current_time = time2millis(&time_struct); sensor_event_get_xyz(event, &x, &y, &z); CCDirector::sharedDirector()->getAccelerometer()->update(current_time, -x, -y, z); } } } return true; }