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