static void nativeReleaseSuspendBlocker(JNIEnv *env, jclass clazz, jstring nameStr) {
ScopedUtfChars name(env, nameStr);
release_wake_lock(name.c_str());
}
static void release_wakelock_callback()
{
release_wake_lock(WAKE_LOCK_NAME);
}
ssize_t AudioStreamInMotorola::read( void* buffer, ssize_t bytes)
{
LOGD("read(%p, %ld) called\n", buffer, bytes);
if (!mHardware) {
LOGE("read(): hardware is null, erroring out\n");
return -1;
}
size_t count = bytes;
uint8_t* p = static_cast<uint8_t*>(buffer);
status_t status = NO_ERROR;
if (mStandby) {
LOGD("read(): input in standby, open device\n");
{ // scope for the lock
Mutex::Autolock lock(mHardware->mLock);
LOGD("read(): acquire input wakelock");
acquire_wake_lock(PARTIAL_WAKE_LOCK, kInputWakelockStr);
// TODO: open truncate?
// open audio input device
status = ::open(CPCAP_DSP_CODEC, O_RDWR);
if (status < 0) {
LOGE("read(): cannot open %s errno: %d", CPCAP_DSP_CODEC, errno);
LOGD("read(): release input wakelock");
release_wake_lock(kInputWakelockStr);
goto error;
}
mFd = status;
mStandby = false;
// set sample rate
unsigned int rate = mSampleRate;
LOGD("read(): setting DSP speed to %d", rate);
status = ioctl(mFd, SNDCTL_DSP_SPEED, &rate);
if (status < 0) {
LOGE("read(): error setting DSP speed to %d: %d", rate, status);
goto error;
}
// set channels
int channels = AudioSystem::popCount(mChannels);
LOGD("read(): setting DSP channels to %d", channels);
#ifdef USE_STEREO_IOCTL_FOR_CHANNELS
status = ioctl(mFd, SNDCTL_DSP_STEREO, &channels);
#else
status = ioctl(mFd, SNDCTL_DSP_CHANNELS, &channels);
#endif
if (status < 0) {
LOGE("read(): error setting DSP channels to %d: %d", channels, status);
goto error;
}
}
// TODO: figure out what the f**k to do here
LOGE("read(): TODO: need to figure out how the f**k to do this part...");
// mHardware->set_mRecordState(1);
// make sure a1026 config is re-applied even is input device is not changed
mHardware->clearCurDevice();
mHardware->doRouting();
// uint32_t acdb_id = mHardware->getACDB(MOD_REC, mHardware->get_snd_dev());
// if (ioctl(mFd, AUDIO_START, &acdb_id)) {
// LOGE("Error starting record");
// goto Error;
// }
}
while (count) {
ssize_t bytesRead = ::read(mFd, buffer, count);
if (bytesRead >= 0) {
count -= bytesRead;
p += bytesRead;
} else {
if (errno != EAGAIN) {
status = bytesRead;
goto error;
}
mRetryCount++;
LOGD("read(): EAGAIN - retrying");
}
}
LOGD("read(): read %ld bytes", bytes);
return bytes;
error:
standby();
// Simulate audio input timing in case of error
usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate());
LOGE("read(): returning with error status %d", status);
return status;
}
bool AudioPolicyService::AudioCommandThread::threadLoop()
{
nsecs_t waitTime = INT64_MAX;
mLock.lock();
while (!exitPending())
{
while(!mAudioCommands.isEmpty()) {
nsecs_t curTime = systemTime();
// commands are sorted by increasing time stamp: execute them from index 0 and up
if (mAudioCommands[0]->mTime <= curTime) {
AudioCommand *command = mAudioCommands[0];
mAudioCommands.removeAt(0);
mLastCommand = *command;
switch (command->mCommand) {
case START_TONE: {
mLock.unlock();
ToneData *data = (ToneData *)command->mParam;
LOGV("AudioCommandThread() processing start tone %d on stream %d",
data->mType, data->mStream);
if (mpToneGenerator != NULL)
delete mpToneGenerator;
mpToneGenerator = new ToneGenerator(data->mStream, 1.0);
mpToneGenerator->startTone(data->mType);
delete data;
mLock.lock();
}break;
case STOP_TONE: {
mLock.unlock();
LOGV("AudioCommandThread() processing stop tone");
if (mpToneGenerator != NULL) {
mpToneGenerator->stopTone();
delete mpToneGenerator;
mpToneGenerator = NULL;
}
mLock.lock();
}break;
case SET_VOLUME: {
VolumeData *data = (VolumeData *)command->mParam;
LOGV("AudioCommandThread() processing set volume stream %d, volume %f, output %d", data->mStream, data->mVolume, data->mIO);
command->mStatus = AudioSystem::setStreamVolume(data->mStream, data->mVolume, data->mIO);
if (command->mWaitStatus) {
command->mCond.signal();
mWaitWorkCV.wait(mLock);
}
delete data;
}break;
case SET_PARAMETERS: {
ParametersData *data = (ParametersData *)command->mParam;
LOGV("AudioCommandThread() processing set parameters string %s, io %d", data->mKeyValuePairs.string(), data->mIO);
command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
if (command->mWaitStatus) {
command->mCond.signal();
mWaitWorkCV.wait(mLock);
}
delete data;
}break;
case SET_VOICE_VOLUME: {
VoiceVolumeData *data = (VoiceVolumeData *)command->mParam;
LOGV("AudioCommandThread() processing set voice volume volume %f", data->mVolume);
command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
if (command->mWaitStatus) {
command->mCond.signal();
mWaitWorkCV.wait(mLock);
}
delete data;
}break;
#ifdef HAVE_FM_RADIO
case SET_FM_VOLUME: {
FmVolumeData *data = (FmVolumeData *)command->mParam;
LOGV("AudioCommandThread() processing set fm volume volume %f", data->mVolume);
command->mStatus = AudioSystem::setFmVolume(data->mVolume);
if (command->mWaitStatus) {
command->mCond.signal();
mWaitWorkCV.wait(mLock);
}
delete data;
}break;
#endif
default:
LOGW("AudioCommandThread() unknown command %d", command->mCommand);
}
delete command;
waitTime = INT64_MAX;
} else {
waitTime = mAudioCommands[0]->mTime - curTime;
break;
}
}
// release delayed commands wake lock
if (mName != "" && mAudioCommands.isEmpty()) {
release_wake_lock(mName.string());
}
LOGV("AudioCommandThread() going to sleep");
mWaitWorkCV.waitRelative(mLock, waitTime);
LOGV("AudioCommandThread() waking up");
}
mLock.unlock();
return false;
}
status_t SpeechVMRecorder::Close()
{
pthread_mutex_lock(&mMutex);
ALOGD("+%s()", __FUNCTION__);
if (mEnable == false)
{
ALOGW("-%s(), mEnable == false, return!!", __FUNCTION__);
pthread_mutex_unlock(&mMutex);
return INVALID_OPERATION;
}
mStarting = false;
int ret = 0;
// VM log recycle mechanism
char property_value[PROPERTY_VALUE_MAX];
property_get(PROPERTY_KEY_VM_RECYCLE_ON, property_value, "1"); //"1": default on
const bool vm_recycle_on = (property_value[0] == '0') ? false : true;
if (vm_recycle_on == true)
{
// Get gVMFileList, gNumOfVMFiles, gTotalSizeOfVMFiles
memset(gVMFileList, 0, sizeof(gVMFileList));
gNumOfVMFiles = 0;
gTotalSizeOfVMFiles = 0;
ret = ftw(kFolderOfVMFile, GetVMFileList, FTW_D);
ASSERT(ret == 0);
// Sort file name
qsort(gVMFileList, gNumOfVMFiles, sizeof(vm_file_info_t), CompareVMFileName);
//for(int i = 0; i < gNumOfVMFiles; i++)
// ALOGD("%s(), %s, %u", __FUNCTION__, gVMFileList[i].path, gVMFileList[i].size);
// Remove VM files
uint32_t index_vm_file_list = 0;
while (gNumOfVMFiles > kMinKeepNumOfVMFiles && gTotalSizeOfVMFiles > kMaxSizeOfAllVMFiles)
{
ALOGD("%s(), gNumOfVMFiles = %lu, gTotalSizeOfVMFiles = %lu", __FUNCTION__, gNumOfVMFiles, gTotalSizeOfVMFiles);
ALOGD("%s(), remove(%s), size = %lu", __FUNCTION__, gVMFileList[index_vm_file_list].path, gVMFileList[index_vm_file_list].size);
ret = remove(gVMFileList[index_vm_file_list].path);
ASSERT(ret == 0);
gNumOfVMFiles--;
gTotalSizeOfVMFiles -= gVMFileList[index_vm_file_list].size;
index_vm_file_list++;
}
}
// release wake lock
ret = release_wake_lock(VM_RECORD_WAKELOCK_NAME);
ALOGD("%s(), release_wake_lock:%s return %d.", __FUNCTION__, VM_RECORD_WAKELOCK_NAME, ret);
// turn off record function
SpeechDriverFactory::GetInstance()->GetSpeechDriver()->VoiceMemoRecordOff();
mEnable = false;
pthread_mutex_unlock(&mMutex);
pthread_cond_signal(&mExitCond); // wake up thread to exit
ALOGD("-%s()", __FUNCTION__);
return NO_ERROR;
}
S32 user_main(S32 argc, PPS8 argv)
{
S32 i;
PS8 eeprom_file_name = (PS8)"./nvs_map.bin";
PS8 init_file_name = (PS8)"tiwlan.ini";
PS8 firmware_file_name = (PS8)"firmware.bin";
/* Parse command line parameters */
if( argc > 1 )
{
i=1;
if( argv[i][0] != '-' )
{
os_strcpy( g_drv_name, argv[i++] );
}
for( ;i < argc; i++ )
{
if( !os_strcmp(argv[i], (PS8)"-h" ) || !os_strcmp(argv[i], (PS8)"--help") )
return print_usage();
else if(!os_strcmp(argv[i], (PS8)"-f" ) )
{
firmware_file_name = argv[++i];
}
else if(!os_strcmp(argv[i], (PS8)"-e") && (i+1<argc))
{
eeprom_file_name = argv[++i];
}
else if(!os_strcmp(argv[i], (PS8)"-i") && (i+1<argc))
{
init_file_name = argv[++i];
}
else if(!os_strcmp(argv[i], (PS8)"-n" ) )
{
eeprom_file_name = NULL;
}
else
{
os_error_printf (CU_MSG_ERROR, (PS8)"Loader: unknow parameter '%s'\n", argv[i]);
#ifdef ANDROID
check_and_set_property("wlan.driver.status", "failed");
#endif
return -1;
}
}
}
if( !g_drv_name[0] )
{
os_strcpy(g_drv_name, (PS8)TIWLAN_DRV_NAME "0" );
}
#ifdef ANDROID
acquire_wake_lock(PARTIAL_WAKE_LOCK, PROGRAM_NAME);
#endif
if (init_driver (g_drv_name, eeprom_file_name, init_file_name, firmware_file_name) != 0)
{
#ifdef ANDROID
check_and_set_property("wlan.driver.status", "failed");
release_wake_lock(PROGRAM_NAME);
#endif
return -1;
}
#ifdef ANDROID
check_and_set_property("wlan.driver.status", "ok");
release_wake_lock(PROGRAM_NAME);
#endif
return 0;
}
static void ReleaseWakelock() {
release_wake_lock(WAKE_LOCK_NAME);
}
int main(int argc, char **argv)
{
int pid, fd, mode;
unsigned int delay = 0;
int status = 0;
char *file = 0;
char lockid[32];
if (argc < 2) {
printf("Usage: %s [-f logfile] [-a] [-d delay] <program>\n", argv[0]);
exit(1);
}
close(0); open("/dev/null", 0);
close(1);
mode = O_TRUNC;
while(**++argv == '-') {
while(*++*argv) {
switch(**argv) {
case 'f':
if(*++*argv)
file = *argv;
else
file = *++argv;
goto next_arg;
case 'd':
if(*++*argv)
delay = atoi(*argv);
else
delay = atoi(*++argv);
goto next_arg;
case 'a':
mode = O_APPEND;
break;
}
}
next_arg: ;
}
if (file) {
if(open(file, O_WRONLY|mode|O_CREAT, 0666) < 0) {
perror(file);
exit(1);
}
}
else {
if(open("/dev/null", O_WRONLY) < 0) {
perror("/dev/null");
exit(1);
}
}
switch(pid = fork()) {
case -1:
perror(argv[0]);
exit(1);
break;
case 0:
fflush(stdout);
close(2); dup(1); /* join stdout and stderr */
chdir("/");
umask(0);
setpgrp();
setsid();
for (fd = 3; fd < 256; fd++) {
close(fd);
}
if(delay) {
snprintf(lockid, 32, "daemonize%d", (int) getpid());
acquire_wake_lock(PARTIAL_WAKE_LOCK, lockid);
}
switch(pid = fork()) {
case -1:
break;
case 0:
if(delay) {
sleep(delay);
}
execv(argv[0], argv);
execvp(argv[0], argv);
perror(argv[0]);
break;
default:
if(delay) {
waitpid(pid, &status, 0);
release_wake_lock(lockid);
}
_exit(0);
}
_exit(1);
break;
default:
exit(0);
break;
}
}
void
releaseWakeLock() {
release_wake_lock(ANDROID_WAKE_LOCK_NAME);
}
