/**
* Check that we aren't stuck waiting, while loading or playing...
*/
bool SoundPlayer::healthCheck()
{
DEBUG("SoundPlayer::healthCheck(%s, %llu ms)", getStateName(), currentTime() - m_lastPlayingTime);
if (!m_filePath.empty() && // we are supposed to play something
( (m_state == eState_Connecting && m_lastPlayingTime + cConnectDelay < currentTime()) || // but we can't connect, or
(m_state == eState_PlayPending && m_lastPlayingTime + cLoadDelay < currentTime()) || // we can't load the file, or
(m_state == eState_Playing && m_lastPlayingTime + cPlayDelay < currentTime()))) // we can't play the file
{
if (m_fakeBackupRingtoneCount == 0)
{ // log failure, when it first happens
CRITICAL("SoundPlayer::healthCheck(%s): can't play '%s' as %s for %llu ms", getStateName(),
m_filePath.c_str(), m_streamClass.c_str(), currentTime() - m_lastPlayingTime);
m_retries++; // we failed to play. Remember this, so that we won't recycle this player.
}
if (m_audioStreamClass == kAudioStreamRingtone || m_audioStreamClass == kAudioStreamAlarm)
{ // back ringtone for ringtones & alarms
if (m_fakeBackupRingtoneCount == 0)
WARNING("SoundPlayer::healthCheck: using backup ringtone using alert notifications!");
// Don't use alarm & ringtone sinks, because they trigger a ringtone vibration, which we are faking here!
if ((m_fakeBackupRingtoneCount++ % 5) < 3)
SoundPlayerPool::instance()->playFeedback("sysmgr_notification", "palerts"); // let's hope audiod & pulse are ok!
}
else if (m_audioStreamClass == kAudioStreamNotification)
{
WARNING("SoundPlayer::healthCheck: using default notification instead!");
stop();
SoundPlayerPool::instance()->playFeedback("sysmgr_alert", "palerts"); // let's hope audiod & pulse are ok!
}
else if (m_audioStreamClass == kAudioStreamCalendar)
{
WARNING("SoundPlayer::healthCheck: using default notification instead!");
stop();
SoundPlayerPool::instance()->playFeedback("sysmgr_alert", "pcalendar"); // let's hope audiod & pulse are ok!
}
else if (m_audioStreamClass == kAudioStreamAlert)
{
WARNING("SoundPlayer::healthCheck: using default alert instead!");
stop();
SoundPlayerPool::instance()->playFeedback("sysmgr_alert", "palerts"); // let's hope audiod & pulse are ok!
}
}
else if (m_state == eState_Closing && m_lastPlayingTime + cCloseDelay < currentTime())
{
WARNING("SoundPlayer::healthCheck(%s): can't close for %llu ms. Declaring SoundPlayer object dead.", getStateName(), currentTime() - m_lastPlayingTime);
setState(eState_Dead);
}
else
{
m_fakeBackupRingtoneCount = 0;
}
return true; // return true to repeat
}
void log_state(state s, enum role_t r) {
if (log_level < TRACE) return;
int line_size = (num_nodes()) * 9 + 6;
char line[line_size];
draw_base_graph(line, line_size);
int meidx = graph_index(my_id(), r);
line[meidx] = getStateName(s.state)[2];
printf("GRAPH: %s STATE %s %s %ld %ld %ld dead %ld\n", line, getRole(r), getStateName(s.state), s.ticket, s.slot, s.value, s.deadline);
}
/**
* Takes a PCB pointer and prints out the contents of the PCB
* @param PCB_p pointer referencing the PCB to print
*/
void toString(PCB_p pcb_p) {
printf("contents: ");
printf("State: %s ", getStateName(pcb_p->state));
printf("PID: %d ", pcb_p->pid);
printf("PC: %d ", pcb_p->PC);
// prints the register files associated with this PCB
printf("Reg Files: ");
if (pcb_p->reg_file) {
int i;
for (i = 0; i < NUMREGS; i++) {
printf("REG%d: %d ", i, pcb_p->reg_file[i]);
}
printf(" ");
} else {
printf("\t\tNONE\n\n");
}
// if there exists a following pcb, print out the next address
if (pcb_p->next_pcb) {
PCB_p next = pcb_p->next_pcb;
printf("Next Struct Address: %d ", next->address_space);
} else {
// otherwise print nothing
printf("Next Struct Address: NULL ");
}
printf("Priority: %d ", pcb_p->Priority);
printf("Address Space: %d\n\n ", pcb_p->address_space);
}
/**
* Destructor: Stop anything we have going & disconnect proxy listener
*/
SoundPlayer::~SoundPlayer()
{
PRINTF_BLUE("SoundPlayer::~SoundPlayer(%s)", getStateName());
if (m_state == eState_PlayPending || m_state == eState_Playing)
stop();
if (m_player.get()) {
m_player->removeMediaPlayerChangeListener(m_mediaPlayerChangeListener);
m_player.reset((media::MediaPlayer*) 0);
}
// Important: Make sure to call this before the service handle destuction
if (m_mediaPlayerChangeListener.get())
m_mediaPlayerChangeListener.reset((media::MediaPlayerChangeListener*)0);
if (m_serviceHandle) {
LSError lserror;
LSErrorInit(&lserror);
if (!LSUnregisterPalmService(m_serviceHandle, &lserror)) {
LSErrorPrint (&lserror, stderr);
LSErrorFree (&lserror);
}
m_serviceHandle = 0;
}
}
/**
* Takes a PCB pointer and prints out the contents of the PCB
* @param PCB_p pointer referencing the PCB to print
*/
void toString(PCB_p pcb_p) {
printf("contents: ");
printf("State: %s ", getStateName(pcb_p->state));
printf("PID: %d ", pcb_p->pid);
printf("PC: %d ", pcb_p->PC);
printf("Priority: %d ", pcb_p->Priority);
printf("Address Space: %u\n\n", pcb_p->address_space);
}
void MapTile::setState( byte newState )
{
if (state_ == newState)
return;
if (state_ == DEADBEEF)
return;
char error[1024];
switch (newState) {
case NONE:
state_ = newState;
return;
case LOADING:
if (state_ == NONE) {
state_ = newState;
return;
}
sprintf_s(error, "Loading <= %s %d", getStateName(), this);
throw std::exception(error);
case NEW_DATA:
if (state_ == LOADING) {
state_ = newState;
return;
}
sprintf_s(error, "NewData <= %s %d", getStateName(), this);
throw std::exception(error);
case READY:
if (state_ == NEW_DATA) {
state_ = newState;
return;
}
sprintf_s(error, "Ready <= %s %d", getStateName(), this);
throw std::exception(error);
case CANCEL:
if (state_ == LOADING) {
state_ = newState;
return;
}
sprintf_s(error, "Cancel <= %s %d", getStateName(), this);
throw std::exception(error);
case DEADBEEF:
state_ = newState;
return;
}
}
/*
* Prints contents of the passed PCB to the passed file.
*/
void printToFile(FILE *outfile, PCB_p pcb_p) {
fprintf(outfile, "contents: ");
fprintf(outfile, "State: %s ", getStateName(pcb_p->state));
fprintf(outfile, "PID: %d ", pcb_p->pid);
fprintf(outfile, "PC: %u ", pcb_p->PC);
fprintf(outfile, "Priority: %d ", pcb_p->Priority);
fprintf(outfile, "Address Space: %u\n\n", pcb_p->address_space);
}
// getStateObjFx
CMenuFxObj CGameState::getStateObjFx()
{
if ( m_menuFx )
{
return m_menuFx->getObj( getStateName(m_state) );
}
return CMenuFxObj();
}
// setFxStateVisible
// show/hide state on flash
void CGameState::setFxStateVisible( EGameState state, bool b )
{
if ( m_menuFx )
{
CMenuFxObj menuObj = m_menuFx->getObj( getStateName(state) );
menuObj.setVisible( b );
menuObj.gotoFrame(0, true);
}
}
/**
* Errors occur asynchronously. If an error occurs, this will be called.
*/
void SoundPlayer::errorChanged()
{
if (!VERIFY(m_player))
return;
if (m_player->getError() != NO_ERROR)
{
CRITICAL("SoundPlayer::errorChanged(%s): %d", getStateName(), m_player->getError());
onError();
}
}
/**
* Errors occur asynchronously. If an error occurs, this will be called.
*/
void SoundPlayer::extendedErrorChanged()
{
if (!VERIFY(m_player))
return;
if (!m_player->getExtendedError().empty())
{
CRITICAL("SoundPlayer::extendedErrorChanged(%s): '%s'", getStateName(), m_player->getExtendedError().c_str());
onError();
}
}
/**
* The object we are playing was changed.
*/
void SoundPlayer::sourceChanged()
{
if (!VERIFY(m_player))
return;
PRINTF_BLUE("SoundPlayer::sourceChanged(%s): '%s'", getStateName(), m_player->getSource().c_str());
if (m_player->getSource().empty() && m_state == eState_Closing)
{
setState(eState_Connected);
checkForNextStep();
}
}
void raiseFatalFromInvalidState(const EventExecuter &eventExecuter, const InvalidStateError &ex)
{
auto state = chila::lib::misc::deref(boost::get_error_info<ErrorInfo::ModState>(ex));
eventExecuter.template execute<Event>
CHILA_CONNECTIONTOOLS_LIB_OTHER__EV_FATAL_ARGS
(
"Invalid state: '" + getStateName(state) + "'",
chila::lib::misc::deref(boost::get_error_info<boost::throw_function>(ex)),
chila::lib::misc::deref(boost::get_error_info<boost::throw_file>(ex)),
chila::lib::misc::deref(boost::get_error_info<boost::throw_line>(ex))
);
}
/**
* Playback is moving
*/
void SoundPlayer::currentTimeChanged()
{
if (VERIFY(m_player))
{
PRINTF_BOLD("SoundPlayer::currentTimeChanged(%s): %f sec", getStateName(), m_player->getCurrentTime());
if (m_state == eState_PlayPending || m_state == eState_Playing)
{
setState(eState_Playing);
m_lastPlayingTime = currentTime();
if (!m_repeat && m_duration > 0 && m_player->getCurrentTime() >= m_duration)
stop();
}
}
}
void CGameState::setFxAllStateVisible( EGameState ignoreState, bool b )
{
if ( m_menuFx )
{
for ( int i = 0; i < CGameState::StateCount; i++ )
{
if ( i == ignoreState )
continue;
CMenuFxObj menuObj = m_menuFx->getObj( getStateName( (EGameState)i) );
menuObj.setVisible( b );
menuObj.gotoFrame(0, b);
}
}
}
/**
* The end of the stream has been reached (i.e. we played the entire stream).
*/
void SoundPlayer::eosChanged()
{
if (VERIFY(m_player) && m_player->getEos()) {
PRINTF_BLUE("SoundPlayer::eosChanged(%s): EOS", getStateName());
if (m_state == eState_PlayPending || m_state == eState_Playing)
{
if (m_repeat)
{
m_player->seek(0);
m_player->play();
}
else
stop();
}
}
}
/**
* Client side cancel point. Also used internally.
*/
void SoundPlayer::stop()
{
PRINTF_BLUE("SoundPlayer::stop(%s)", getStateName());
if (m_state == eState_PlayPending || m_state == eState_Playing)
{
if (VERIFY(m_player))
{
m_player->pause();
m_player->unload();
}
setState(eState_Closing);
}
else
{ // not sure why we were not playing: don't take chance...
WARNING("SoundPlayer::stop(%s): unexpected stop request. Declaring SoundPlayer object dead.", getStateName());
setState(eState_Dead);
}
m_filePath.clear();
m_streamClass.clear();
m_lastPlayingTime = currentTime();
m_fakeBackupRingtoneCount = 0;
if (m_activityID)
{
gchar * request = g_strdup_printf("{\"id\":\"com.palm.sysmgr.soundplayer.%i\"}", m_activityID);
LSError lserror;
LSErrorInit(&lserror);
bool activityStartRequestSuccess = LSCall(getServiceHandle(), "palm://com.palm.power/com/palm/power/activityEnd", request, NULL, NULL, NULL, &lserror);
if (!activityStartRequestSuccess)
{
CRITICAL("SoundPlayer::stop: activity '%s' End failed", request);
LSErrorPrint (&lserror, stderr);
LSErrorFree (&lserror);
}
else
DEBUG("SoundPlayer::stop: ended activity '%s'...", request);
g_free(request);
m_activityID = 0;
}
}
/**
* Ajoute une action à la règle en cours d'édition (variable gloable lastRule)
* \param device capteur concerné
* \param state état du field du device
* \param field champ du capteur concerné
*/
void addAction(char *device, char *state, char *field) {
Action *action = malloc(sizeof(Action));
action->device = getDeviceIndex(device);
action->state = getState(state);
action->field = getFieldIndex(field);
action->next = NULL;
Action *lastAction = getLastAction(lastRule);
if(lastAction == NULL)
{
lastRule->actions = action;
}
else
{
lastAction->next = action;
}
if(DEBUG_MODE == 1)
{
printf("New action added : %s -> %s\n", device, getStateName(getState(state)));
}
}
/**
* Connect to mediaserver using lunaservice.
*/
LSPalmService* SoundPlayer::connectToBus()
{
PRINTF_BLUE("SoundPlayer::connectToBus(%s)", getStateName());
VERIFY(m_state == eState_Connecting);
setState(eState_Connecting);
if (m_serviceHandle)
return m_serviceHandle;
bool result = true;
LSError lserror;
LSErrorInit(&lserror);
result = LSRegisterPalmService(NULL, &m_serviceHandle, &lserror);
if (!result)
{
CRITICAL("SoundPlayer::connectToBus: Could not register SoundPlayer");
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
// Make next health check fail ASAP...
m_lastPlayingTime = 0;
return NULL;
}
result = LSGmainAttachPalmService (m_serviceHandle, HostBase::instance()->mainLoop(), &lserror);
if (!result)
{
CRITICAL("SoundPlayer::connectToBus: Could not attach SoundPlayer to main loop");
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
// Make next health check fail ASAP...
m_lastPlayingTime = 0;
return NULL;
}
return m_serviceHandle;
}
static void
setState( tr_handshake * handshake, handshake_state_t state )
{
dbgmsg( handshake, "setting to state [%s]", getStateName( state ) );
handshake->state = state;
}
ParseStatus gotXSTATE(TAPState tapState) {
printf("XSTATE(%s)\n", getStateName(tapState));
return PARSE_SUCCESS;
}
//====================UTILITY METHOD================
bool BTFsaManager::isValidStateTransition(BTState destState){
char buff[100];
switch(this->state)
{
case START:
if(destState == STANDBY || destState == ADVERTISING)
return true;
break;
case STANDBY:
if(destState != CONNECTION_MASTER || destState != CONNECTION_SLAVE )
return true;
break;
case SCANNING:
if(destState != CONNECTION_MASTER || destState != CONNECTION_SLAVE )
return true;
break;
case ADVERTISING:
if(destState != CONNECTION_MASTER)
return true;
break;
case INITIATING:
if(destState != CONNECTION_SLAVE )
return true;
break;
case CONNECTION_MASTER:
if(destState != CONNECTION_SLAVE)
return true;
break;
case CONNECTION_SLAVE:
if(destState != CONNECTION_MASTER)
return true;
break;
default: throw std::runtime_error("INVALID BT FSA STATE !!");
}
sprintf(buff, "Bluetooth FSA INVALID STATE TRANSITION FROM %s TO %s !!", getStateName(state), getStateName(destState));
std::string errorMessage(buff);
throw std::logic_error(errorMessage);
}
int getOptModelStateName(emb_optimizer optim, int name_idx, char x_name[], size_t maxlen, size_t *reqlen)
{
return getStateName(myModel, name_idx, x_name, maxlen, reqlen);
}
void Jtag::setTapState(tapState_t state, int pre)
{
bool tms;
while(current_state!=state){
switch(current_state){
case TEST_LOGIC_RESET:
switch(state){
case TEST_LOGIC_RESET:
tms=true;
break;
default:
tms=false;
current_state=RUN_TEST_IDLE;
};
break;
case RUN_TEST_IDLE:
switch(state){
case RUN_TEST_IDLE:
tms=false;
break;
default:
tms=true;
current_state=SELECT_DR_SCAN;
};
break;
case SELECT_DR_SCAN:
switch(state){
case CAPTURE_DR:
case SHIFT_DR:
case EXIT1_DR:
case PAUSE_DR:
case EXIT2_DR:
case UPDATE_DR:
tms=false;
current_state=CAPTURE_DR;
break;
default:
tms=true;
current_state=SELECT_IR_SCAN;
};
break;
case CAPTURE_DR:
switch(state){
case SHIFT_DR:
tms=false;
current_state=SHIFT_DR;
break;
default:
tms=true;
current_state=EXIT1_DR;
};
break;
case SHIFT_DR:
switch(state){
case SHIFT_DR:
tms=false;
break;
default:
tms=true;
current_state=EXIT1_DR;
};
break;
case EXIT1_DR:
switch(state){
case PAUSE_DR:
case EXIT2_DR:
case SHIFT_DR:
case EXIT1_DR:
tms=false;
current_state=PAUSE_DR;
break;
default:
tms=true;
current_state=UPDATE_DR;
};
break;
case PAUSE_DR:
switch(state){
case PAUSE_DR:
tms=false;
break;
default:
tms=true;
current_state=EXIT2_DR;
};
break;
case EXIT2_DR:
switch(state){
case SHIFT_DR:
case EXIT1_DR:
case PAUSE_DR:
tms=false;
current_state=SHIFT_DR;
break;
default:
tms=true;
current_state=UPDATE_DR;
};
break;
case UPDATE_DR:
switch(state){
case RUN_TEST_IDLE:
tms=false;
current_state=RUN_TEST_IDLE;
break;
default:
tms=true;
current_state=SELECT_DR_SCAN;
};
break;
case SELECT_IR_SCAN:
switch(state){
case CAPTURE_IR:
case SHIFT_IR:
case EXIT1_IR:
case PAUSE_IR:
case EXIT2_IR:
case UPDATE_IR:
tms=false;
current_state=CAPTURE_IR;
break;
default:
tms=true;
current_state=TEST_LOGIC_RESET;
};
break;
case CAPTURE_IR:
switch(state){
case SHIFT_IR:
tms=false;
current_state=SHIFT_IR;
break;
default:
tms=true;
current_state=EXIT1_IR;
};
break;
case SHIFT_IR:
switch(state){
case SHIFT_IR:
tms=false;
break;
default:
tms=true;
current_state=EXIT1_IR;
};
break;
case EXIT1_IR:
switch(state){
case PAUSE_IR:
case EXIT2_IR:
case SHIFT_IR:
case EXIT1_IR:
tms=false;
current_state=PAUSE_IR;
break;
default:
tms=true;
current_state=UPDATE_IR;
};
break;
case PAUSE_IR:
switch(state){
case PAUSE_IR:
tms=false;
break;
default:
tms=true;
current_state=EXIT2_IR;
};
break;
case EXIT2_IR:
switch(state){
case SHIFT_IR:
case EXIT1_IR:
case PAUSE_IR:
tms=false;
current_state=SHIFT_IR;
break;
default:
tms=true;
current_state=UPDATE_IR;
};
break;
case UPDATE_IR:
switch(state){
case RUN_TEST_IDLE:
tms=false;
current_state=RUN_TEST_IDLE;
break;
default:
tms=true;
current_state=SELECT_DR_SCAN;
};
break;
default:
tapTestLogicReset();
tms=true;
};
if(fp_dbg)
fprintf(fp_dbg,"TMS %d: %s\n", tms, getStateName(current_state));
io->set_tms(tms);
}
for(int i=0; i<pre; i++)
io->set_tms(false);
}
/**
* Client request entry point
*/
void SoundPlayer::play(const std::string& filePath, const std::string& streamClass, bool repeat, int duration)
{
WARNING("SoundPlayer::play(%s): %p: filePath: %s, streamClass: %s, repeat: %d, duration: %d",
getStateName(), this, filePath.c_str(), streamClass.c_str(), repeat, duration);
if (m_state == eState_Dead)
{
CRITICAL("SoundPlayer::play(%s): This player can not be reused!", getStateName());
return;
}
if (m_state != eState_Init)
stop();
// recycling? move state machine back
if (m_state == eState_Finished)
setState(eState_Connected);
m_filePath = filePath;
m_streamClass = streamClass;
m_audioStreamClass = kAudioStreamMedia;
if (!m_streamClass.empty())
{
if (m_streamClass == "ringtones")
m_audioStreamClass = kAudioStreamRingtone;
else if (m_streamClass == "alarm")
m_audioStreamClass = kAudioStreamAlarm;
else if (m_streamClass == "alerts")
m_audioStreamClass = kAudioStreamAlert;
else if (m_streamClass == "notifications")
m_audioStreamClass = kAudioStreamNotification;
else if (m_streamClass == "calendar")
m_audioStreamClass = kAudioStreamCalendar;
else if (m_streamClass == "media")
m_audioStreamClass = kAudioStreamMedia;
else if (m_streamClass == "voicedial")
m_audioStreamClass = kAudioStreamVoicedial;
else if (m_streamClass == "flash")
m_audioStreamClass = kAudioStreamFlash;
else if (m_streamClass == "navigation")
m_audioStreamClass = kAudioStreamNavigation;
else if (m_streamClass == "defaultapp")
m_audioStreamClass = kAudioStreamDefaultapp;
else if (m_streamClass == "feedback")
m_audioStreamClass = kAudioStreamFeedback;
else
{
WARNING("SoundPlayer::play: unrecognized media class '%s' for '%s'. Will use media class.", streamClass.c_str(), filePath.c_str());
m_audioStreamClass = kAudioStreamMedia;
}
}
m_repeat = repeat;
m_duration = float(duration) / 1000.f; // integer ms to float seconds
checkForNextStep();
}
char* getState(PCB_p pcb_p) {
return getStateName(pcb_p->state);
}
/**
* Ecrit un fichier de règles sur une sortie
* \param rules les règles à écrire
* \param output la sortie à utiliser
*/
void ftraceRules(Rule *rules, int output)
{
Rule *r;
int i=0, j;
char msg[1024];
printf("\n==========[[ Regles chargees ]]==========\n");
for(r = rules; r != NULL; r = r->next)
{
sprintf(msg, "\n\033[31mRule n°%d :\033[00m %s\n", ++i, r->name);
write(output, msg, strlen(msg));
// Liste les actions
Action *ac;
j=0;
sprintf(msg, "├── \033[32mActions\033[00m\n");
write(output, msg, strlen(msg));
for(ac = r->actions; ac != NULL; ac = ac->next)
{
if(ac->next == NULL)
{
sprintf(msg, "│\t└── \033[33mAction n°%d : \033[34mDo\033[00m %s\033[34m->\033[00m%s \033[34m=\033[00m %s\n", ++j, getDeviceName(ac->device), getFieldName(ac->field), getStateName(ac->state));
write(output, msg, strlen(msg));
}
else
{
sprintf(msg, "│\t├── \033[33mAction n°%d : \033[34mDo\033[00m %s\033[34m->\033[00m%s \033[34m=\033[00m %s\n", ++j, getDeviceName(ac->device), getFieldName(ac->field), getStateName(ac->state));
write(output, msg, strlen(msg));
}
}
// Liste les alertes
Alert *al;
j=0;
sprintf(msg, "├── \033[32mAlertes\033[00m\n");
write(output, msg, strlen(msg));
for(al = r->alerts; al != NULL; al = al->next)
{
if(al->next == NULL)
{
sprintf(msg, "│\t└── \033[33mAlert n°%d : \033[34mSend \"\033[00m%s\033[34m\" To\033[00m %s\n", ++j, al->message, getRecipientName(al->recipient));
write(output, msg, strlen(msg));
}
else
{
sprintf(msg, "│\t├── \033[33mAlert n°%d : \033[34mSend\033[00m \"%s\" \033[34mTo\033[00m %s\n", ++j, al->message, getRecipientName(al->recipient));
write(output, msg, strlen(msg));
}
}
// Liste les conditions
Condition *cd;
j=0;
sprintf(msg, "└── \033[32mConditions\033[00m\n");
write(output, msg, strlen(msg));
for(cd = r->conditions; cd != NULL; cd = cd->next)
{
if(cd->next == NULL)
{
sprintf(msg, "\t└── \033[33mCondition n°%d : \033[34mWhen\033[00m %s[%d]\033[34m->\033[00m%s %s %f\n", ++j, getDeviceName(cd->device), cd->device, getFieldName(cd->field), getConditionType(cd->type), cd->value);
write(output, msg, strlen(msg));
}
else
{
sprintf(msg, "\t├── \033[33mCondition n°%d : \033[34mWhen\033[00m %s[%d]\033[34m->\033[00m%s %s %f \033[34mAnd\033[00m\n", ++j, getDeviceName(cd->device), cd->device, getFieldName(cd->field), getConditionType(cd->type), cd->value);
write(output, msg, strlen(msg));
}
}
}
printf("\n=========================================\n");
}
static ReadState
canRead( struct tr_peerIo * io, void * arg, size_t * piece )
{
tr_handshake * handshake = arg;
struct evbuffer * inbuf = tr_peerIoGetReadBuffer( io );
ReadState ret;
tr_bool readyForMore = TRUE;
assert( tr_isPeerIo( io ) );
/* no piece data in handshake */
*piece = 0;
dbgmsg( handshake, "handling canRead; state is [%s]",
getStateName( handshake->state ) );
while( readyForMore )
{
switch( handshake->state )
{
case AWAITING_HANDSHAKE:
ret = readHandshake ( handshake, inbuf ); break;
case AWAITING_PEER_ID:
ret = readPeerId ( handshake, inbuf ); break;
case AWAITING_YA:
ret = readYa ( handshake, inbuf ); break;
case AWAITING_PAD_A:
ret = readPadA ( handshake, inbuf ); break;
case AWAITING_CRYPTO_PROVIDE:
ret = readCryptoProvide( handshake, inbuf ); break;
case AWAITING_PAD_C:
ret = readPadC ( handshake, inbuf ); break;
case AWAITING_IA:
ret = readIA ( handshake, inbuf ); break;
case AWAITING_PAYLOAD_STREAM:
ret = readPayloadStream( handshake, inbuf ); break;
case AWAITING_YB:
ret = readYb ( handshake, inbuf ); break;
case AWAITING_VC:
ret = readVC ( handshake, inbuf ); break;
case AWAITING_CRYPTO_SELECT:
ret = readCryptoSelect ( handshake, inbuf ); break;
case AWAITING_PAD_D:
ret = readPadD ( handshake, inbuf ); break;
default:
assert( 0 );
}
if( ret != READ_NOW )
readyForMore = FALSE;
else if( handshake->state == AWAITING_PAD_C )
readyForMore = evbuffer_get_length( inbuf ) >= handshake->pad_c_len;
else if( handshake->state == AWAITING_PAD_D )
readyForMore = evbuffer_get_length( inbuf ) >= handshake->pad_d_len;
else if( handshake->state == AWAITING_IA )
readyForMore = evbuffer_get_length( inbuf ) >= handshake->ia_len;
}
return ret;
}
/**
* This simply loads the media source URI and plays it.
*/
void SoundPlayer::connected() {
PRINTF_BLUE("SoundPlayer::connected(%s): loading '%s', as '%s'", getStateName(), m_filePath.c_str(), m_streamClass.c_str());
if (VERIFY(m_state == eState_Connecting))
setState(eState_Connected);
checkForNextStep();
}
void handleAjaxRequest(CGIRequest& request,Json::Value& root)
{
ISD_LOGGER_TRACE("cgi begin.");
//判断用户的合法性
string strUid = request.getTrimQueryVal("uid");
string strErrorMsg;
int iRet = argsIsIllegal(strUid,strErrorMsg);
if ( iRet != 0 )
{
root["ret"] = 10;
root["msg"] = strErrorMsg;
return;
}
string strWhere;
bool bFlag = false;
string strCid = request.getTrimQueryVal("cid",bFlag);
if (bFlag && !strCid.empty())
{
strWhere = "c_cid='" + _cMysqlUtil.EscapeString2(strCid) + "'";
}
else
{
string strTitle = request.getTrimQueryVal("title",bFlag);
if (bFlag && !strTitle.empty())
{
strWhere = "c_title like '%" + _cMysqlUtil.EscapeString2(strTitle) + "%'";
}
}
int iState = atoi(request.getTrimQueryVal("state",bFlag).c_str());
if (bFlag && iState != -1)
{
if (strWhere.empty())
{
strWhere = "c_state=" + intToString(iState);
}
else
{
strWhere += " and c_state=" + intToString(iState);
}
}
if (!strWhere.empty())
{
strWhere = "and " + strWhere;
}
int iStartPage = 0;
int iPage = atoi(request.getQueryVal("p").c_str()); //当前页
if ( iPage > 0 )
{
iStartPage = iPage - 1;
}
int iRecordNumberOfPage = atoi(request.getQueryVal("psz").c_str()); //每页结果数
if ( iRecordNumberOfPage <= 0 || iRecordNumberOfPage > 20)
{
iRecordNumberOfPage = 20;
}
char szSql[MAX_SQL_LENGTH] = {0};
snprintf(szSql,sizeof(szSql)-1,"select c_cid,c_title,c_date,c_mtime,c_state,c_longpic_num,c_normalpic_num from d_config_system.t_cover where c_uid='%s' %s order by c_mtime desc limit %d,%d;",_cMysqlUtil.EscapeString2(strUid).c_str(),strWhere.c_str(),iStartPage*iRecordNumberOfPage,iRecordNumberOfPage);
int iIndex = iStartPage*iRecordNumberOfPage;
MYSQL_EXEC_GET_BEGIN(_cMysqlUtil, szSql, iRet)
{
string strCid,strTitle,strDate,strMtime;
int iState = 0,iLongPicNum = 0,iNormalPicNum = 0;
unsigned int uiPos = 0;
GET_STR_COLUMN_VALUE_SCROLL(strCid, uiPos)
GET_STR_COLUMN_VALUE_SCROLL(strTitle, uiPos)
GET_STR_COLUMN_VALUE_SCROLL(strDate, uiPos)
GET_STR_COLUMN_VALUE_SCROLL(strMtime, uiPos)
GET_INT_COLUMN_VALUE_SCROLL(iState, uiPos)
GET_INT_COLUMN_VALUE_SCROLL(iLongPicNum, uiPos)
GET_INT_COLUMN_VALUE_SCROLL(iNormalPicNum, uiPos)
Json::Value json;
json["no"] = ++iIndex;
json["cid"] = strCid;
json["ti"] = strTitle;
json["d"] = strDate;
json["m"] = strMtime;
json["sn"] = getStateName(iState);
json["ln"] = iLongPicNum;
json["rn"] = iNormalPicNum;
root["node"].append(json);
}MYSQL_EXEC_GET_END()