void ProcessThrottler::updateAssertion()
{
// If the process is currently runnable but will be suspended then first give it a chance to complete what it was doing
// and clean up - move it to the background and send it a message to notify. Schedule a timeout so it can't stay running
// in the background for too long.
if (m_assertion && m_assertion->state() != AssertionState::Suspended && !m_foregroundCounter.value() && !m_backgroundCounter.value()) {
++m_suspendMessageCount;
RELEASE_LOG("%p - ProcessThrottler::updateAssertion() sending PrepareToSuspend IPC", this);
m_process.sendPrepareToSuspend();
m_suspendTimer.startOneShot(processSuspensionTimeout);
m_assertion->setState(AssertionState::Background);
m_process.didSetAssertionState(AssertionState::Background);
return;
}
bool shouldBeRunnable = m_foregroundCounter.value() || m_backgroundCounter.value();
// If we're currently waiting for the Web process to do suspension cleanup, but no longer need to be suspended, tell the Web process to cancel the cleanup.
if (m_suspendTimer.isActive() && shouldBeRunnable)
m_process.sendCancelPrepareToSuspend();
if (m_assertion && m_assertion->state() == AssertionState::Suspended && shouldBeRunnable)
m_process.sendProcessDidResume();
updateAssertionNow();
}
void ProcessThrottler::updateAssertionNow()
{
m_suspendTimer.stop();
if (m_assertion) {
if (m_assertion->state() != assertionState())
RELEASE_LOG("%p - ProcessThrottler::updateAssertionNow() updating process assertion state to %u (foregroundActivities: %lu, backgroundActivities: %lu)", this, assertionState(), m_foregroundCounter.value(), m_backgroundCounter.value());
m_assertion->setState(assertionState());
m_process.didSetAssertionState(assertionState());
}
}
bool MySQLp::Query(const string &query)
//执行SQL语句 成功返回真 并将结果存放在 resluts_中 如果没有结果 resluts_.size() == 0
{
MYSQL_RES *results;
MYSQL_ROW record;
int num_fields;
results_.clear();
if(mysql_query(&mysql_, query.c_str()))
{
u_int err = mysql_errno(&mysql_);
RELEASE_LOG("数据库操作失败，错误代码 " << err << ": " << mysql_error(&mysql_));
//INDEX_EVENT("数据库操作失败，错误代码 " << err);
return false;
}
if(mysql_field_count(&mysql_))
{
results = mysql_store_result(&mysql_);
num_fields = mysql_num_fields(results);
while((record = mysql_fetch_row(results)))
{
vector<string> rslt_line;
for(int i = 0; i < num_fields; i++ )
{
rslt_line.push_back(string(record[i]));
}
results_.push_back(rslt_line);
rslt_line.clear();
}
mysql_free_result(results);
}
return true;
}
static inline UTransliterator *utrans_find(CFStringRef transform, UTransDirection dir, UErrorCode *error) {
UEnumeration *uenum = NULL;
UTransliterator *trans = NULL;
do {
uenum = utrans_openIDs(error);
if (U_FAILURE(*error)) {
DEBUG_LOG("%s", u_errorName(*error));
break;
}
int32_t count = uenum_count(uenum, error);
if (U_FAILURE(*error)) {
DEBUG_LOG("%s", u_errorName(*error));
break;
}
int32_t trans_idx = 0;
while (trans_idx < count && trans == NULL) {
int32_t idLen = 0;
const UChar *uid = uenum_unext(uenum, &idLen, error);
if (U_FAILURE(*error)) {
DEBUG_LOG("%s", u_errorName(*error));
break;
}
// this seems rather unlikely since we should have already broken
// by the trans_idx exceeding the count
if (uid == NULL) {
break;
}
CFStringRef name = CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault, uid, idLen, kCFAllocatorNull);
// It would have been nice if these stirng constants were actually defined somewhere in icu, but sadly they are runtime metadata...
if ((CFEqual(name, CFSTR("Any-Remove")) && CFEqual(transform, kCFStringTransformStripCombiningMarks)) ||
(CFEqual(name, CFSTR("Any-Latin")) && CFEqual(transform, kCFStringTransformToLatin)) ||
(CFEqual(name, CFSTR("Latin-Katakana")) && CFEqual(transform, kCFStringTransformLatinKatakana)) ||
(CFEqual(name, CFSTR("Latin-Hiragana")) && CFEqual(transform, kCFStringTransformLatinHiragana)) ||
(CFEqual(name, CFSTR("Hiragana-Katakana")) && CFEqual(transform, kCFStringTransformHiraganaKatakana)) ||
(CFEqual(name, CFSTR("Latin-Hangul")) && CFEqual(transform, kCFStringTransformLatinHangul)) ||
(CFEqual(name, CFSTR("Latin-Arabic")) && CFEqual(transform, kCFStringTransformLatinArabic)) ||
(CFEqual(name, CFSTR("Latin-Hebrew")) && CFEqual(transform, kCFStringTransformLatinHebrew)) ||
(CFEqual(name, CFSTR("Latin-Thai")) && CFEqual(transform, kCFStringTransformLatinThai)) ||
(CFEqual(name, CFSTR("Latin-Cyrillic")) && CFEqual(transform, kCFStringTransformLatinCyrillic)) ||
(CFEqual(name, CFSTR("Latin-Greek")) && CFEqual(transform, kCFStringTransformLatinGreek)) ||
(CFEqual(name, CFSTR("Any-Hex/XML")) && CFEqual(transform, kCFStringTransformToXMLHex)) ||
(CFEqual(name, CFSTR("Any-Name")) && CFEqual(transform, kCFStringTransformToUnicodeName)) ||
(CFEqual(name, CFSTR("Accents-Any")) && CFEqual(transform, kCFStringTransformStripDiacritics))) {
trans = utrans_openU(uid, idLen, dir, NULL, 0, NULL, error);
}
CFRelease(name);
trans_idx++;
}
} while (0);
if (uenum != NULL) {
uenum_reset(uenum, error);
uenum_close(uenum);
}
if (trans == NULL && (CFEqual(transform, kCFStringTransformStripCombiningMarks) ||
CFEqual(transform, kCFStringTransformToLatin) ||
CFEqual(transform, kCFStringTransformLatinKatakana) ||
CFEqual(transform, kCFStringTransformLatinHiragana) ||
CFEqual(transform, kCFStringTransformHiraganaKatakana) ||
CFEqual(transform, kCFStringTransformLatinHangul) ||
CFEqual(transform, kCFStringTransformLatinArabic) ||
CFEqual(transform, kCFStringTransformLatinHebrew) ||
CFEqual(transform, kCFStringTransformLatinCyrillic) ||
CFEqual(transform, kCFStringTransformLatinGreek) ||
CFEqual(transform, kCFStringTransformToXMLHex) ||
CFEqual(transform, kCFStringTransformToUnicodeName) ||
CFEqual(transform, kCFStringTransformStripDiacritics))) {
static dispatch_once_t once = 0L;
dispatch_once(&once, ^{
RELEASE_LOG("Unable to find transliterators in icu data: likely this is from not including the Transliterators section in building your icu.dat file");
});
}
static ALCboolean opensles_reset_playback(ALCdevice *pDevice)
{
if (pDevice == NULL) {
LOGE("Received a NULL ALCdevice! Returning ALC_FALSE from opensles_reset_playback");
return ALC_FALSE;
}
LOGV("opensles_reset_playback pDevice=%p", pDevice);
opesles_data_t *devState;
unsigned bits = BytesFromDevFmt(pDevice->FmtType) * 8;
unsigned channels = ChannelsFromDevFmt(pDevice->FmtChans);
unsigned samples = pDevice->UpdateSize;
unsigned size = samples * channels * bits / 8;
SLuint32 sampling_rate = pDevice->Frequency * 1000;
SLresult result;
LOGV("bits=%u, channels=%u, samples=%u, size=%u, freq=%u", bits, channels, samples, size, pDevice->Frequency);
if (pDevice->Frequency <= 22050) {
bufferSize = defaultBufferSize / 2;
}
devState = (opesles_data_t *) pDevice->ExtraData;
// create buffer queue audio player
// configure audio source
SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
// SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, 2, SL_SAMPLINGRATE_44_1,
SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, 2, sampling_rate,
SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16,
SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT, SL_BYTEORDER_LITTLEENDIAN};
SLDataSource audioSrc = {&loc_bufq, &format_pcm};
// configure audio sink
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
SLDataSink audioSnk = {&loc_outmix, NULL};
// create audio player
LOGV("create audio player");
const SLInterfaceID ids[1] = {*pSL_IID_ANDROIDSIMPLEBUFFERQUEUE};
const SLboolean req[1] = {SL_BOOLEAN_TRUE};
result = (*engineEngine)->CreateAudioPlayer(engineEngine, &devState->bqPlayerObject, &audioSrc, &audioSnk,
1, ids, req);
if ((result != SL_RESULT_SUCCESS) || (devState->bqPlayerObject == NULL)) {
RELEASE_LOG("create audio player is null or errored: %lx", result);
return ALC_FALSE;
}
// realize the player
result = (*devState->bqPlayerObject)->Realize(devState->bqPlayerObject, SL_BOOLEAN_FALSE);
assert(SL_RESULT_SUCCESS == result);
// get the play interface
result = (*devState->bqPlayerObject)->GetInterface(devState->bqPlayerObject, *pSL_IID_PLAY, &devState->bqPlayerPlay);
assert(SL_RESULT_SUCCESS == result);
// get the buffer queue interface
result = (*devState->bqPlayerObject)->GetInterface(devState->bqPlayerObject, *pSL_IID_BUFFERQUEUE,
&devState->bqPlayerBufferQueue);
if ((result != SL_RESULT_SUCCESS) || (devState->bqPlayerBufferQueue == NULL)) {
RELEASE_LOG("get the buffer queue interface is null or errored: %lx", result);
return ALC_FALSE;
}
// register callback on the buffer queue
result = (*devState->bqPlayerBufferQueue)->RegisterCallback(devState->bqPlayerBufferQueue, opensles_callback, (void *) pDevice);
assert(SL_RESULT_SUCCESS == result);
// playback_lock = createThreadLock();
start_playback(pDevice);
// set the player's state to playing
result = (*devState->bqPlayerPlay)->SetPlayState(devState->bqPlayerPlay, SL_PLAYSTATE_PLAYING);
assert(SL_RESULT_SUCCESS == result);
// enqueue the first buffer to kick off the callbacks
result = (*devState->bqPlayerBufferQueue)->Enqueue(devState->bqPlayerBufferQueue, "\0", 1);
assert(SL_RESULT_SUCCESS == result);
SetDefaultWFXChannelOrder(pDevice);
devlist_add(pDevice);
return ALC_TRUE;
}