bool CWsPackageProcessEx::onDeletePackage(IEspContext &context, IEspDeletePackageRequest &req, IEspDeletePackageResponse &resp)
{
int returnCode = 0;
StringBuffer returnMsg;
IArrayOf<IConstPackageMapEntry>& packageMaps = req.getPackageMaps();
ForEachItemIn(p, packageMaps)
{
IConstPackageMapEntry& item=packageMaps.item(p);
if (!item.getId() || !*item.getId())
{
returnMsg.appendf("PackageMap[%d]: Package map Id not specified; ", p);
continue;
}
if (!item.getTarget() || !*item.getTarget())
{
returnMsg.appendf("PackageMap[%d]: Target not specified;", p);
continue;
}
StringBuffer target, processName, packageMap;
packageMap.set(item.getId());
target.set(item.getTarget());
if (!item.getProcess() || !*item.getProcess())
processName.set("*");
else
processName.set(item.getProcess());
deletePackage(packageMap.str(), target.str(), processName.str(), req.getGlobalScope(), returnMsg, returnCode);
}
static void takeAction (Action *action, EnumAction actionCode) {
unsigned int newTime, oldTime;
unsigned long longNewTime, longOldTime;
int newIdxTimeframe, tempTime;
CtnrFile *newFile;
CtnrBlock *newBlock, *soundInsertBlock;
int newIdxAction;
EnumAction newActionCode;
EnumBorderCrossing direction;
signed long l;
int destination, aux, i, ret;
int status;
BOOL reposition = FALSE;
BOOL isTooFar = FALSE;
ListItem *list, *tempList;
char filename[PATH_LENGTH];
char *cursor, *cursor2;
CtnrFile *replayFile;
replayFile = NULL;
list = NULL;
oldTime = compressTime(Snd_A1800_GetCurrentTime(),context.package->timePrecision);
newFile = 0;
newTime = -1;
newBlock = 0;
if (actionCode == -1)
actionCode = getActionCode(action);
if (action) {
aux = action->aux;
destination = action->destination;
}
switch (actionCode) {
case JUMP_LIST:
stop();
list = &context.package->lists[destination];
context.idxActiveList = destination;
switch (getListRotation(aux)) {
case 0:
cursor = getCurrentList(list);
strcpy(filename,cursor);
break;
case 1:
strcpy(filename,getNextList(list,TRUE));
break;
case -1:
strcpy(filename,getPreviousList(list));
break;
}
if (!filename[0]) {
// empty list
insertSound(&pkgSystem.files[EMPTY_LIST_FILE_IDX],NULL,FALSE);
// empty list of packages; redirect to current point in list of lists
list = &context.package->lists[0];
context.idxActiveList = 0;
cursor = getCurrentList(list);
strcpy(filename,cursor);
}
if (list->listType == LIST_OF_PACKAGES) {
// load package
switch (filename[0]) {
case SYS_PKG_CHAR:
context.queuedPackageType = PKG_SYS;
destination = replaceStack(filename+1,&pkgSystem);
break;
case APP_PKG_CHAR:
context.queuedPackageType = PKG_APP;
destination = replaceStack(filename+1,&pkgSystem);
break;
default:
context.queuedPackageType = PKG_MSG;
destination = replaceStack(filename,&pkgSystem);
break;
}
context.queuedPackageNameIndex = destination;
} else { // list->listType != LIST_OF_PACKAGES
// play sound of subject
newFile = getListFile(filename);
newTime = 0;
reposition = TRUE;
}
break;
case JUMP_PACKAGE:
if (aux == PKG_VARIABLE) {
strcpy(filename,getCurrentList(&pkgSystem.lists[destination]));
switch (filename[0]) {
case SYS_PKG_CHAR:
aux = PKG_SYS;
destination = replaceStack(filename+1,&pkgSystem);
break;
case APP_PKG_CHAR:
aux = PKG_APP;
destination = replaceStack(filename+1,&pkgSystem);
break;
default:
aux = PKG_MSG;
destination = replaceStack(filename,&pkgSystem);
break;
}
}
context.queuedPackageType = aux;
context.queuedPackageNameIndex = destination;
break; // sets up main loop to handle this, rather than building up a stack overflow
case COPY:
stop();
tempList = &context.package->lists[destination];
getListFilename(filename,destination,FALSE);
cursor = getCurrentList(tempList);
if (PRE_COPY_FILE_IDX)
insertSound(&pkgSystem.files[PRE_COPY_FILE_IDX],NULL,TRUE);
ret = d2dCopy((const char *)filename,(const char *)cursor);
if (ret == 0 && POST_COPY_FILE_IDX)
insertSound(&pkgSystem.files[POST_COPY_FILE_IDX],NULL,TRUE);
// newBlock = &context.package->blocks[aux];
// newTime = newBlock->startTime;
// reposition = TRUE;
break;
case DELETE:
stop();
tempList = &context.package->lists[destination];
getListFilename(filename,destination,TRUE);
cursor = getCurrentList(tempList);
ret = findDeleteStringFromFile(LIST_PATH,filename,cursor,TRUE);
tempList->currentFilePosition = -1; // forces next list action to reload
if (ret != -1)
ret = deletePackage(cursor);
else
logException(29,cursor,0);
list = &context.package->lists[aux];
context.idxActiveList = aux;
newFile = getListFile(getCurrentList(list));
newTime = 0;
reposition = TRUE;
// newBlock = &context.package->blocks[aux];
// newTime = newBlock->startTime;
// reposition = TRUE;
break;
case TRIM:
stop();
tempList = &context.package->lists[destination];
cursor = getCurrentList(tempList);
strcpy(filename,USER_PATH);
strcat(filename,cursor); //todo: address application packages
strcat(filename,AUDIO_FILE_EXT);
edit(filename);
context.queuedPackageType = PKG_MSG;
destination = replaceStack(cursor,context.package);
context.queuedPackageNameIndex = destination;
break;
case SPEED_UP:
adjustSpeed(SPEED_INCREMENT,TRUE);
break;
case SPEED_DOWN:
adjustSpeed(-SPEED_INCREMENT,TRUE);
break;
case SPEED_NORMAL:
adjustSpeed(NORMAL_SPEED,FALSE);
break;
case VOLUME_UP:
adjustVolume(VOLUME_INCREMENT,TRUE,FALSE);
break;
case VOLUME_DOWN:
adjustVolume(-VOLUME_INCREMENT,TRUE,FALSE);
break;
case VOLUME_NORMAL:
adjustVolume(NORMAL_VOLUME,FALSE,FALSE);
break;
case LED_RED_ON:
setLED(LED_RED,TRUE);
break;
case LED_RED_OFF:
setLED(LED_RED,FALSE);
break;
case LED_GREEN_ON:
setLED(LED_GREEN,TRUE);
break;
case LED_GREEN_OFF:
setLED(LED_GREEN,FALSE);
break;
case LED_ALL_ON:
setLED(LED_ALL,TRUE);
break;
case LED_ALL_OFF:
setLED(LED_ALL,TRUE);
break;
case USB_DEVICE_ON:
setUSBDevice(TRUE);
newBlock = &context.package->blocks[destination];
newTime = newBlock->startTime;
reposition = TRUE;
break;
case USB_HOST_ON:
/* stop();
setUSBDevice(TRUE);
newBlock = &context.package->blocks[destination];
newTime = newBlock->startTime;
reposition = TRUE;
*/ break;
case STOP:
stop();
enterOrExitAllBlocks(context.idxTimeframe,EXITING);
break;
case PLAY_PAUSE:
status = SACM_Status();
switch (status) {
case 0:
// if (context.package->pkg_type != PKG_SYS)
markStartPlay(Snd_A1800_GetCurrentTime(),context.package->strHeapStack+context.package->idxName);
if (context.idxActiveList == -1) {
enterOrExitAllBlocks(context.idxTimeframe,ENTERING);
i = getStartingBlockIdxFromTimeline(context.idxTimeframe);
if (i != -1)
processStartBlock(i);
play(context.file,getCurrentTimeframeStart());
} else
play(context.file,0);
break;
case C_SACM_RECORD:
case C_SACM_PLAY:
context.isPaused = TRUE;
pause();
break;
case C_SACM_PAUSE:
context.isPaused = FALSE;
resume();
break;
default:
if (context.isPaused) {
context.isPaused = FALSE;
resume();
} else {
context.isPaused = TRUE;
pause();
}
break;
}
break;
case PAUSE:
pause();
context.isPaused = TRUE;
break;
case RECORD_TITLE: // deprecated
case RECORD_MSG:
stop();
/* // Not currently allowing sound inserts before record commands since aux is used for recording from another headphone jack
// Although the SPINS part of the headphone jack thing isn't currently working.
if (action && hasSoundInsert(action)) {
soundInsertBlock = &pkgSystem.blocks[getSoundInsertIdxFromAux(aux)];
insertSound(getFileFromBlock(soundInsertBlock),soundInsertBlock,TRUE);
wait(500);
}
*/
if(vCur_1 < V_MIN_RECORD_VOLTAGE) {
refuse_lowvoltage(0);
break;
}
cursor = getCurrentList(&pkgSystem.lists[context.package->idxMasterList]);
do {
strcpy(filename,USER_PATH);
getPkgNumber(filename+strlen(USER_PATH),TRUE);
strcat(filename,(const char *)CATEGORY_DELIM_STR);
strcat(filename,cursor); // adds current listname to new recording name
cursor2 = filename + strlen(filename);
strcat(filename,AUDIO_FILE_EXT);
ret = fileExists((LPSTR)filename); // this causes approx 1 sec delay!
} while (ret);
*cursor2 = 0; // remove extension
strcpy(filename,filename+strlen(USER_PATH)); //remove path
ret = createRecording(filename,aux,cursor);
if (ret != -1) {
destination = replaceStack(filename,context.package);
context.queuedPackageNameIndex = destination;
context.queuedPackageType = PKG_MSG;
} else
logException(28,"recording failed",RESET); //todo: add voice error msg?
break;
case CALL_BLOCK:
// TODO: handle error (return of -1) if stack is full
stackPush(context.package,context.file,oldTime - getRewind(aux)); // times are compressed
// this is designed to fall through
case JUMP_BLOCK:
newBlock = &context.package->blocks[destination];
newTime = newBlock->startTime;
reposition = TRUE;
break;
case RETURN:
if (stackPop(&context.package,&newFile,&newTime)) // times are compressed
reposition = TRUE;
break;
case FWD:
newActionCode = getStartEndCodeFromTimeframe(context.idxTimeframe,FORWARD_JUMPING, &newTime, &newIdxAction);
switch (newActionCode) {
case NOP:
case PAUSE:
break;
case STOP:
//rewind to give context before stopping
newTime -= compressTime(BLOCK_END_LEADER,context.package->timePrecision);
break;
case JUMP_BLOCK:
//follow this link
newBlock = &context.package->blocks[context.package->actions[newIdxAction].destination];
newTime = newBlock->startTime;
break;
case RETURN:
stackPop(&context.package,&newFile,&newTime); //todo: double verify there was something on stack (shouldn't have gotten RETURN if not)
break;
default:
//no action needed
break;
}
reposition = TRUE;
break;
case BACK:
// test whether within the start leader to determine whether to go to last start or to previous start before that
if ((oldTime - getCurrentTimeframeStart()) > compressTime(BLOCK_START_LEADER, context.package->timePrecision)) {
// just move to start time of same timeframe
newTime = getCurrentTimeframeStart(); // must make sure we call the Start event
} else {
newActionCode = getStartEndCodeFromTimeframe(context.idxTimeframe,BACKWARD_JUMPING, &newTime, &newIdxAction);
switch (newActionCode) {
case NOP:
case PAUSE:
case STOP:
break;
case JUMP_BLOCK:
//follow this link
newBlock = &context.package->blocks[context.package->actions[newIdxAction].destination];
newTime = newBlock->startTime;
break;
case RETURN:
stackPop(&context.package,&newFile,&newTime); //todo: double verify there was something on stack (shouldn't have gotten RETURN if not)
break;
default:
//no action needed
break;
}
}
reposition = TRUE;
break;
case JUMP_TIME:
// skip forward/back from relative position
// observe block boundary when they exist, but leap beyond them
// todo:do not leap over newFile boundaries
// if system package action, reset context to user package for this action
if (context.returnPackage)
context.package = context.returnPackage;
if (context.package != &pkgSystem) {
longOldTime = Snd_A1800_GetCurrentTime();
l = (signed long)extractSignedTime(destination,context.package->timePrecision); // hoping this brings back an originally negative number
longNewTime = longOldTime + l;
if (l >= 0)
direction = FORWARD_JUMPING;
else {
direction = BACKWARD_JUMPING;
if (abs(l) > longOldTime)
longNewTime = 0;
}
newTime = compressTime(longNewTime,context.package->timePrecision);
// check for interfering block events
newIdxTimeframe = context.idxTimeframe;
do {
newActionCode = getStartEndCodeFromTimeframe(newIdxTimeframe,direction, &tempTime, &newIdxAction);
if (direction == FORWARD_JUMPING)
isTooFar = blockTimeline[++newIdxTimeframe].time > newTime;
else
isTooFar = blockTimeline[--newIdxTimeframe].time < newTime;
} while (!isTooFar && newActionCode == NOP);
switch (newActionCode) {
case JUMP_BLOCK:
newBlock = &context.package->blocks[context.package->actions[newIdxAction].destination];
newTime = newBlock->startTime;
newFile = getFileFromBlock(newBlock);
break;
case RETURN:
stackPop(&context.package,&newFile,&newTime); //todo: double verify there was something on stack (shouldn't have gotten RETURN if not)
break;
default:
//no action needed
break;
}
playActionSound(JUMP_TIME);
reposition = TRUE;
} // context is not system file
break;
case SLEEP:
// call sleep function
setOperationalMode((int)P_SLEEP);
break;
case HALT:
// call sleep function
setOperationalMode((int)P_HALT);
break;
case NOP:
// no operation
break;
default:
//nothing should default here
logException(1,0,USB_MODE);
break;
}
if (reposition) {
//todo: am i catching every possible change in file?
if (newBlock && !newFile)
newFile = getFileFromBlock(newBlock);
if (newFile && newFile != context.file) {
enterOrExitAllBlocks(context.idxTimeframe,EXITING);
context.file = newFile;
if (!list)
buildBlockTimelines(newFile);
context.idxTimeframe = -1; // to signal it hasn't been set yet
context.timeNextTimeframe = -1; // resets this -- necessary for lists that dont go to processTimelineJump
}
if (!list) {
context.idxActiveList = -1;
newIdxTimeframe = getIdxTimeline(newTime);
if (newIdxTimeframe != context.idxTimeframe)
processTimelineJump(context.idxTimeframe, newIdxTimeframe); // this resets context.idxTimeframe and context.timeNextTimeframe
}
}
// now that context.idxTimeframe has been set for repositions, we can insert sounds
if (action && hasSoundInsert(action)) {
if (reposition)
stop(); // stop currently playing audio first or insertSound() will return to it
if (actionCode == JUMP_TIME) {
if (context.returnPackage)
context.package = &pkgSystem;
soundInsertBlock = &context.package->blocks[getSoundInsertIdxFromAux(aux)];
insertSound(getFileFromBlock(soundInsertBlock),soundInsertBlock,TRUE);
}
else {
soundInsertBlock = &context.package->blocks[getSoundInsertIdxFromAux(aux)];
insertSound(getFileFromBlock(soundInsertBlock),soundInsertBlock,FALSE);
}
}
// process start block action if landing on the start of a new block
if (reposition && newBlock && newTime == newBlock->startTime)
processStartBlock(newBlock - context.package->blocks);
if (list) {
soundInsertBlock = getStartInsert(list->actionStartEnd, list->idxFirstAction);
if (soundInsertBlock)
insertSound(getFileFromBlock(soundInsertBlock),soundInsertBlock,FALSE);
}
if (actionCode == JUMP_TIME && context.returnPackage) { // returning to user package after possibly inserting a system sound above
context.package = context.returnPackage;
context.returnPackage = NULL;
}
if (actionCode == SPEED_UP || actionCode == SPEED_DOWN) {
context.isPaused = FALSE;
resume();
}
if (reposition)
play(context.file,newTime); //todo: chg to seek if same file
//todo: maybe for JUMP_BLOCK (not CALL_BLOCK) , allow offsets within a block (stored in first 13 bits of aux)
}
int clearDeleteQueue(void) {
char strQueuePath[PATH_LENGTH];
char strMsgProfilePath[PATH_LENGTH],strMsgListPath[PATH_LENGTH];
struct f_info fileInfo;
int handle,ret;
int found,i,lineCount,linesCounted;
char buffer[READ_LENGTH+1],*packageName, *cursor;
ProfileData *pd;
// For each string in DELETE_QUEUE_FILENAME, look for references in all message list files. If none found, delete.
// When finished, delete DELETE_QUEUE_FILENAME.
// Look at all message files, not just the ones in current profile or even only the ones that are active lists,
// because a category that lists the message could later be activated.
strcpy(strQueuePath,SYSTEM_PATH);
strcat(strQueuePath,(char *)DELETE_QUEUE_FILENAME);
pd = getProfiles();
linesCounted = 0;
handle=tbOpen((LPSTR)strQueuePath,O_RDONLY);
if (handle < 0) {
logString(strQueuePath,ASAP,LOG_DETAIL);
return -1; //no queue
}
do {
getLine(-1,0); // reset from prior use
lineCount = 0;
while ((packageName = getLine(handle,buffer)) && ++lineCount <= linesCounted) {}
// This lineCount and linesCounted skips previously processed lines in this loop.
// This is necessary because findDeleteStringFromFile() also calls getLine and resets everything. (TODO:not optimal)
if (!*packageName)
break; // blank line at end of file
getLine(handle,0); //reset file cursor to beginning of file
linesCounted++;
found = 0;
if (DEBUG_MODE) {
logString((char *)"DELETE QUEUE: Looking for references to ",BUFFER,LOG_DETAIL);
logString(packageName,ASAP,LOG_DETAIL);
}
for (i=0;i<pd->intTotalMessageLists;i++) {
strcpy(strMsgProfilePath,LISTS_PATH);
strcat(strMsgProfilePath,pd->ptrProfileMessageLists[i]);
strcat(strMsgProfilePath,"/*");
ret = _findfirst((LPSTR)strMsgProfilePath, &fileInfo,D_FILE);
strcpy(strMsgListPath,strMsgProfilePath);
while (ret >=0) {
if (!strstr(fileInfo.f_name,LIST_MASTER)) { // don't search _activeLists.txt
cursor = strrchr(strMsgListPath, '/') + 1;
*cursor = 0; //remove *.* or previous filename
strcat(strMsgListPath,fileInfo.f_name);
logString(strMsgListPath,BUFFER,LOG_DETAIL);
if (-1 != findDeleteStringFromFile(NULL,strMsgListPath,packageName,FALSE)) {
found = 1;
if (DEBUG_MODE)
logString((char *)"Found another reference - will not delete package.",BUFFER,LOG_NORMAL);
break;
}
}
ret = _findnext(&fileInfo);
}
if (found)
break;
}
if (!found)
deletePackage(packageName);
} while (packageName);
close(handle);
unlink((LPSTR)strQueuePath);
}
int main( int argc, char *argv[] )
{
QString serverPath = "";
QString packagePath = "";
OPERATION listOperation = DEFAULT;
int c;
while ( ( c = getopt( argc, argv, "c:r:a:p:d:u" ) ) != -1 )
{
switch(c)
{
case 'c':
listOperation = CREATE_LIST;
serverPath = optarg;
break;
case 'd':
listOperation = DELETE_LIST;
break;
case 'a':
listOperation = ADD_PACKAGE;
packagePath = optarg;
break;
case 'r':
listOperation = DELETE_PACKAGE;
packagePath = optarg;
break;
case 'p':
listOperation = AUTO_CREATE;
serverPath = optarg;
break;
case 'u':
listOperation = AUTO_UPDATE;
serverPath = optarg;
break;
default:
printf( "operation not recognized\n" );
return 0;
}
}
if( argc < 2 || ( argc != 3 && listOperation != DELETE_LIST ) )
{
printf( "usage:\n" );
printf( "-p server_url : create list automatically by recursively parsing mapmanager directory\n" );
printf( "-u server_url : update list automatically by recursively parsing mapmanager directory\n" );
printf( "-c server_url : create list\n" );
printf( "-d server_url : delete list\n" );
printf( "-a package_path_and_name : add package to list\n" );
printf( "-r package_path_and_name : delete package from list\n" );
return 0;
}
if( !serverPath.endsWith( "/" ) )
serverPath.append( "/" );
if( packagePath.startsWith( "." ) )
packagePath.remove( 0, 1 );
if( packagePath.startsWith( "/" ) )
packagePath.remove( 0, 1 );
QString packageName = packagePath;
packageName.remove( 0, packageName.lastIndexOf( '/' ) + 1 );
packageName.truncate( packageName.lastIndexOf( '.' ) );
QDomDocument list;
QFile listFile( "packageList.xml" );
if( listOperation == CREATE_LIST )
return createList( &list, &listFile, serverPath );
if( listOperation == AUTO_CREATE )
{
if( !createList( &list, &listFile, serverPath ) )
return 0;
QStringList localPackages = parseForPackages( QDir() );
foreach( QString packagePath, localPackages )
processPackage( &list, packagePath );
}
else
{
if ( !listFile.exists() )
{
printf( "create list file first using -c or -p\n" );
return 0;
}
if( listOperation == DELETE_LIST )
{
if ( !listFile.remove() )
{
printf( "error deleting list file\n" );
return 0;
}
printf( "deleted list\n" );
return 1;
}
if ( !listFile.open( QIODevice::ReadOnly ) )
{
printf( "failed to open list file\n" );
return 0;
}
if ( !list.setContent( &listFile ) )
{
printf("error parsing list file\n");
listFile.close();
return 0;
}
listFile.close();
}
if( listOperation == DELETE_PACKAGE )
{
if ( !deletePackage( &list, packagePath ) )
return 0;
}
if( listOperation == ADD_PACKAGE )
{
if ( !processPackage( &list, packagePath ) )
return 0;
}
if( listOperation == AUTO_UPDATE )
{
QStringList localPackages = parseForPackages( QDir() );
foreach( QString packagePath, localPackages )
processPackage( &list, packagePath );
}
if (!listFile.open(QIODevice::ReadWrite | QIODevice::Truncate)) return 1;
listFile.write(list.toString().toUtf8());
listFile.close();
return 1;
}
