S32 LLQueuedThread::updateQueue(U32 max_time_ms)
{
F64 max_time = (F64)max_time_ms * .001;
LLTimer timer;
S32 pending = 1;
// Frame Update
if (mThreaded)
{
pending = getPending();
if(pending > 0)
{
unpause();
}
}
else
{
while (pending > 0)
{
pending = processNextRequest();
if (max_time && timer.getElapsedTimeF64() > max_time)
break;
}
}
return pending;
}
int main_menu()
{
MENU_T menu;
int opt=0;
int selItem = 0;
int acceptKbdEvents=0;
//lk_getkey(); //Commented by Neeraja 08/06/2010 for 2 times pressed after entered password field.
lk_dispclr();
fprintf(fp,"Begun main_menu()");
fflush(fp);
menu.start = 0;
menu.maxEntries = 4;
strcpy(menu.title,"Main Menu");
strcpy(menu.menu[0],"Retail Sale");
strcpy(menu.menu[1],"Reprint");
strcpy(menu.menu[3],"Logout");
while(1) {
sprintf(menu.menu[2],"Update Pending (%d)",getPending());
lk_dispclr();
opt = scroll_menu(&menu,&selItem,acceptKbdEvents);
switch(opt) {
case ENTER:
switch (selItem+1) {
case 1:
retail_sale();
break; //retail.c
case 2:
reprint();
break;
case 3:
updatePendingBatch();
break;
case 4:
logout();
return SUCCESS;
break;
default:
break;
}
}
}
}
void PhoneMachine::receiveSolicited(const Parcel& data)
{
int serial = data.readInt32();
int result = data.readInt32();
RILRequest *request = getPending(serial);
if (!request) {
SLOGW("receiveSolicited: not requested serial=%d result=%d\n", serial, result);
return;
}
SLOGV("<<< Solicited message=%s [%d] serial=%d result=%d\n", rilMessageStr(request->message()),
request->message(), serial, result);
int token = request->token();
int message = request->message();
int ivalue = 0;
Parcel extra;
switch (message) {
case RIL_REQUEST_GET_SIM_STATUS:
ivalue = data.readInt32(); // Store the card state
break;
case RIL_REQUEST_GET_CURRENT_CALLS: {
// We retrieve audio information for the client.
// We also update the AudioFlinger audio state appropriately based
// on the current call state
ivalue = data.readInt32(); // How many calls there are
audio_mode_t audio_mode = AUDIO_MODE_NORMAL;
for (int i = 0 ; i < ivalue ; i++) {
RILCall call(data);
CallState call_state(call.state, call.index,
call.number, call.numberPresentation,
call.name, call.namePresentation);
call_state.writeToParcel(&extra);
if (call.state == RIL_CALL_INCOMING)
audio_mode = AUDIO_MODE_RINGTONE;
else if (call.state == RIL_CALL_ACTIVE || call.state == RIL_CALL_DIALING || call.state == RIL_CALL_ALERTING)
audio_mode = AUDIO_MODE_IN_CALL;
}
SLOGV(" %d calls, audio_mode=%d\n", ivalue, audio_mode);
updateAudioMode(audio_mode);
break;
}
case RIL_REQUEST_DIAL:
case RIL_REQUEST_HANGUP:
case RIL_REQUEST_ANSWER:
case RIL_REQUEST_UDUB:
case RIL_REQUEST_SET_MUTE:
break;
case RIL_REQUEST_GET_MUTE:
ivalue = data.readInt32();
break;
case RIL_REQUEST_SIGNAL_STRENGTH:
// In actuality, we should probably read all 12 signal strengths
ivalue = data.readInt32();
break;
#if defined(SHORT_PLATFORM_VERSION) && (SHORT_PLATFORM_VERSION == 23)
#else
case RIL_REQUEST_VOICE_REGISTRATION_STATE:
ivalue = data.readInt32(); // Starts with the number of strings
for (int i = 0 ; i < ivalue ; i++)
extra.writeString16(data.readString16());
break;
#endif
case RIL_REQUEST_OPERATOR: {
ivalue = data.readInt32();
assert(ivalue == 3);
extra.writeString16(data.readString16());
extra.writeString16(data.readString16());
extra.writeString16(data.readString16());
break;
}
case RIL_REQUEST_RADIO_POWER:
SLOGV(" RIL Radio Power\n");
// No response....
break;
default:
SLOGV("Unhandled RIL request %d\n", message);
break;
}
if (request->client() != NULL) {
SLOGV(" Passing solicited message to client token=%d message=%d result=%d ivalue=%d...\n",
token, message, result, ivalue);
request->client()->Response( token, message, result, ivalue, extra );
}
delete request;
}
S32 LLQueuedThread::processNextRequest()
{
QueuedRequest *req;
// Get next request from pool
lockData();
while(1)
{
req = NULL;
if (mRequestQueue.empty())
{
break;
}
req = *mRequestQueue.begin();
mRequestQueue.erase(mRequestQueue.begin());
if ((req->getFlags() & FLAG_ABORT) || (mStatus == QUITTING))
{
req->setStatus(STATUS_ABORTED);
// Unlock, because we can't call finishRequest() while keeping this lock:
// generateHandle() takes this lock too and is called while holding a lock
// (ie LLTextureFetchWorker::mWorkMutex) that finishRequest will lock too,
// causing a dead lock.
// Although a complete rewrite of LLQueuedThread is in order because it's
// far from robust the way it handles it's locking; the following rationale
// at least makes plausible that releasing the lock here SHOULD work if
// the original coder didn't completely f**k up: if before the QueuedRequest
// req was only accessed while keeping the lock, then it still should
// never happen that another thread is waiting for this lock in order to
// access the QueuedRequest: a few lines lower we delete it.
// In other words, if directly after releasing this lock another thread
// would access req, then that can only happen by finding it again in
// either mRequestQueue or mRequestHash. We already deleted it from the
// first, so this access would have to happen by finding it in mRequestHash.
// Such access happens in the following functions:
// 1) LLQueuedThread::shutdown -- but it does that anyway, as it doesn't use any locking.
// 2) LLQueuedThread::generateHandle -- might skip our handle while before it would block until we deleted it. Skipping it is actually better.
// 3) LLQueuedThread::waitForResult -- this now doesn't touch the req when it has the flag FLAG_LOCKED set.
// 4) LLQueuedThread::getRequest -- whereever this is used, FLAG_LOCKED is tested before using the req.
// 5) LLQueuedThread::getRequestStatus -- this is a read-only operation on the status, which should never be changed from finishRequest().
// 6) LLQueuedThread::abortRequest -- it doesn't seem to hurt to add flags (if this happens at all), while calling finishRequest().
// 7) LLQueuedThread::setFlags -- same.
// 8) LLQueuedThread::setPriority -- doesn't access req with status STATUS_ABORTED, STATUS_COMPLETE or STATUS_INPROGRESS.
// 9) LLQueuedThread::completeRequest -- now sets FLAG_AUTO_COMPLETE instead of deleting the req, if FLAG_LOCKED is set, so that deletion happens here when finishRequest returns.
req->setFlags(FLAG_LOCKED);
unlockData();
req->finishRequest(false);
lockData();
req->resetFlags(FLAG_LOCKED);
if ((req->getFlags() & FLAG_AUTO_COMPLETE))
{
req->resetFlags(FLAG_AUTO_COMPLETE);
mRequestHash.erase(req);
// check();
unlockData();
req->deleteRequest();
lockData();
}
continue;
}
llassert_always(req->getStatus() == STATUS_QUEUED);
break;
}
U32 start_priority = 0 ;
if (req)
{
req->setStatus(STATUS_INPROGRESS);
start_priority = req->getPriority();
}
unlockData();
// This is the only place we will call req->setStatus() after
// it has initially been seet to STATUS_QUEUED, so it is
// safe to access req.
if (req)
{
// process request
bool complete = req->processRequest();
if (complete)
{
lockData();
req->setStatus(STATUS_COMPLETE);
req->setFlags(FLAG_LOCKED);
unlockData();
req->finishRequest(true);
if ((req->getFlags() & FLAG_AUTO_COMPLETE))
{
lockData();
req->resetFlags(FLAG_AUTO_COMPLETE);
mRequestHash.erase(req);
// check();
req->resetFlags(FLAG_LOCKED);
unlockData();
req->deleteRequest();
}
else
{
req->resetFlags(FLAG_LOCKED);
}
}
else
{
lockData();
req->setStatus(STATUS_QUEUED);
mRequestQueue.insert(req);
unlockData();
if (mThreaded && start_priority < PRIORITY_NORMAL)
{
ms_sleep(1); // sleep the thread a little
}
}
}
S32 pending = getPending();
return pending;
}
