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);
};
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;
}
