void CommandBuilder::BuildCommand(const wxString &cmdName,
const wxString &cmdParamsArg)
{
// Stage 1: create a Command object of the right type
auto scriptOutput = ScriptCommandRelay::GetResponseTarget();
auto output
= std::make_unique<CommandOutputTargets>(std::make_unique<NullProgressTarget>(),
scriptOutput,
scriptOutput);
#ifdef OLD_BATCH_SYSTEM
OldStyleCommandType *factory = CommandDirectory::Get()->LookUp(cmdName);
if (factory == NULL)
{
// Fall back to hoping the Batch Command system can handle it
#endif
OldStyleCommandType *type = CommandDirectory::Get()->LookUp(wxT("BatchCommand"));
wxASSERT(type != NULL);
mCommand = type->Create(nullptr);
mCommand->SetParameter(wxT("CommandName"), cmdName);
mCommand->SetParameter(wxT("ParamString"), cmdParamsArg);
auto aCommand = std::make_shared<ApplyAndSendResponse>(mCommand, output);
Success(aCommand);
return;
#ifdef OLD_BATCH_SYSTEM
}
CommandSignature &signature = factory->GetSignature();
mCommand = factory->Create(nullptr);
//mCommand->SetOutput( std::move(output) );
// Stage 2: set the parameters
ShuttleCli shuttle;
shuttle.mParams = cmdParamsArg;
shuttle.mbStoreInClient = true;
ParamValueMap::const_iterator iter;
ParamValueMap params = signature.GetDefaults();
// Iterate through the parameters defined by the command
for (iter = params.begin(); iter != params.end(); ++iter)
{
wxString paramString;
// IF there is a match in the args actually used
if (shuttle.TransferString(iter->first, paramString, wxT("")))
{
// Then set that parameter.
if (!mCommand->SetParameter(iter->first, paramString))
{
Failure();
return;
}
}
}
// Check for unrecognised parameters
wxString cmdParams(cmdParamsArg);
while (!cmdParams.empty())
{
cmdParams.Trim(true);
cmdParams.Trim(false);
int splitAt = cmdParams.Find(wxT('='));
if (splitAt < 0 && !cmdParams.empty())
{
Failure(wxT("Parameter string is missing '='"));
return;
}
wxString paramName = cmdParams.Left(splitAt);
if (params.find(paramName) == params.end())
{
Failure(wxT("Unrecognized parameter: '") + paramName + wxT("'"));
return;
}
// Handling of quoted strings is quite limitted.
// You start and end with a " or a '.
// There is no escaping in the string.
cmdParams = cmdParams.Mid(splitAt+1);
if( cmdParams.empty() )
splitAt =-1;
else if( cmdParams[0] == '\"' ){
cmdParams = cmdParams.Mid(1);
splitAt = cmdParams.Find(wxT('\"'))+1;
}
else if( cmdParams[0] == '\'' ){
cmdParams = cmdParams.Mid(1);
splitAt = cmdParams.Find(wxT('\''))+1;
}
else
splitAt = cmdParams.Find(wxT(' '))+1;
if (splitAt < 1)
{
splitAt = cmdParams.length();
}
cmdParams = cmdParams.Mid(splitAt);
}
auto aCommand = std::make_shared<ApplyAndSendResponse>(mCommand, output);
Success(aCommand);
#endif
}
// ----------------------------------------------------------------------------------
// CASYStubCmdHandlerBase::ProcessCommandL()
// ----------------------------------------------------------------------------------
void CASYStubCmdHandlerBase::ProcessCommandL( const TProcessCmdId aCommand, const TASYCmdParams& aCmdParams )
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Enter" ) ) );
CASYMainServiceBase* mainServiceBase = ASYMainServiceBase();
COMPONENT_TRACE( ( _L( "AsyStub - CASYStubCmdHandlerBase::ProcessCommandL - mainServiceBase (0x%x)" ), &mainServiceBase ) );
CASYStubMainServiceBase* AsyStub = reinterpret_cast<CASYStubMainServiceBase*>( mainServiceBase );
COMPONENT_TRACE( ( _L( "AsyStub - CASYStubCmdHandlerBase::ProcessCommandL - AsyStub (0x%x)" ), &AsyStub ) );
TTFCapability aCapabilityS = AsyStub->GetAndRemoveCapability();
TASYCommandParamRecord cmdParams( aCmdParams() );//For debugging
COMPONENT_TRACE( ( _L( "AsyStub - CASYStubCmdHandlerBase::ProcessCommandL - command: (0x%x)" ), aCommand ) );
switch ( aCommand )
{
case ECmdGetValueBool:
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Get value Bool" ) ) );
TUint32 name;
aCmdParams().iNameRecord.GetName( name );
TAccValueTypeTBool aCmdResponse = { EFalse };
if( name == aCapabilityS.iCapability )
{
if( 0 != aCapabilityS.iTimeMs )
{
//Serve asynchronously
Start( aCapabilityS.iTimeMs, aCapabilityS.iValue, EAPVBool );
}
else
{
aCmdResponse.iValue = aCapabilityS.iValue;
ProcessResponseL( aCmdResponse );
}
}
else
{
TRACE_ASSERT_ALWAYS;
ProcessResponseL( aCmdResponse, KErrArgument );
}
}
break;
case ECmdSetValueBool:
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Set value Bool" ) ) );
TUint32 name;
aCmdParams().iNameRecord.GetName( name );
TAccValueTypeTBool aCmdResponse = { EFalse };
if( name == aCapabilityS.iCapability
&& aCmdParams().iCmdValue == aCapabilityS.iValue )
{
if( aCapabilityS.iTimeMs )
{
//Serve asynchronously
Start( aCapabilityS.iTimeMs, aCapabilityS.iValue, EAPVBool );
}
else
{
aCmdResponse.iValue = aCmdParams().iCmdValue;
ProcessResponseL( aCmdResponse );
}
}
else
{
TRACE_ASSERT_ALWAYS;
ProcessResponseL( aCmdResponse, KErrArgument );
}
}
break;
case ECmdProcessCommandInit:
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Process command init" ) ) );
TAccValueTypeTBool boolInitResponse;
TBool everyThing( ETrue );
// If everything is ok
if ( everyThing )
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - everything is ok" ) ) );
boolInitResponse.iValue = ETrue;
ProcessResponseL( boolInitResponse );
}
// If everything is not ok
else
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - everything is not ok" ) ) );
boolInitResponse.iValue = EFalse;
TInt errCode( KErrGeneral );
ProcessResponseL( boolInitResponse, errCode );
}
}
break;
// For user selection...
case ECmdAccessoryUpdated:
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Accessory updated" ) ) );
TAccValueTypeTBool boolInitResponse;
TBool everyThing( ETrue );
//get capabilities
CAccPolSubblockNameArray* nameArray = CAccPolSubblockNameArray::NewL();
CleanupStack::PushL( nameArray );
RAccessoryServer server;
server.Connect();
RAccessorySingleConnection connectionBase;
connectionBase.CreateSubSession( server);
connectionBase.GetSubblockNameArrayL( cmdParams.iGenericID, *nameArray );
RArray<TUint32>& array = *TAccPolSubblockNameArrayAccessor::Array( nameArray );
for ( TInt i( 0 ); i < array.Count(); i++ )
{
TUint32 name = array[ i ];
TAccPolNameRecord nameRecord;
nameRecord.SetNameL( name );
TAccValueTypeTInt value;
TRAPD( err, connectionBase.GetValueL( cmdParams.iGenericID, nameRecord, value ) );
if ( err != KErrNone )
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Capability 0x%x has no value!" ), name ) );
}
name = 0;
}
connectionBase.CloseSubSession();
server.Close();
CleanupStack::PopAndDestroy( nameArray );
// If everything is ok
if ( everyThing )
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - everything is ok" ) ) );
boolInitResponse.iValue = ETrue;
ProcessResponseL( boolInitResponse );
}
// If everything is not ok
else
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - everything is not ok" ) ) );
boolInitResponse.iValue = EFalse;
TInt errCode( KErrGeneral );
ProcessResponseL( boolInitResponse, errCode );
}
}
break;
case ECmdGetSupportedBTProfiles:
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Get BT profiles - Here is something wrong" ) ) );
TASYBTAccInfo btInfo;
btInfo.iReserved = 0;
TBTDevAddr btAddr( aCmdParams().iCmdValue );
switch( aCmdParams().iCmdValue )
{
case KBTAddrCarkit:
{
btInfo.iDeviceInfo = 0x191;
btInfo.iDeviceType = KDTCarKit;
btInfo.iProfiles = KAccInfoHFP;
btInfo.iSupportedFeatures.At(0) = 1;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
case KBTAddrHeadsetHSPAndHFP:
{
btInfo.iDeviceInfo = 0x192;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = KAccInfoHSP | KAccInfoHFP;
btInfo.iSupportedFeatures.At( 0 ) = 1;
btInfo.iSupportedFeatures.At( 1 ) = 2;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
case KBTAddrHeadsetHSP:
{
btInfo.iDeviceInfo = 0x193;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = KAccInfoHSP;
btInfo.iSupportedFeatures.At(0) = 1;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
case KBTAddrHeadsetHFP:
{
btInfo.iDeviceInfo = 0x194;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = KAccInfoHFP;
btInfo.iSupportedFeatures.At(1) = 1;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
case KBTAddrHeadsetAVRCP:
{
btInfo.iDeviceInfo = 0x195;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = KAccInfoHFP;
btInfo.iSupportedFeatures.At(1) = 1;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
case KBTAddrHeadseA2DP:
{
btInfo.iDeviceInfo = 0x196;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = KAccInfoHFP;
btInfo.iSupportedFeatures.At(1) = 1;
btInfo.iReserved |= KAccInfoDRM;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
case KBTAddrHeadsetEmptyPR:
{
btInfo.iDeviceInfo = 0x197;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = 0;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
case KBTAddrHeadsetNokiaSPId:
{
btInfo.iDeviceInfo = 0x181;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = KAccInfoHSP;
btInfo.iSupportedFeatures.At(0) = 1;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
case KBTAddrNoResponse:
{
// No response
}
break;
case KBTAddrErrCode:
{
btInfo.iDeviceInfo = 0x198;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = KAccInfoHSP;
btInfo.iSupportedFeatures.At( 0 ) = 1;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrGeneral );
}
break;
case KBTAllBitsOn: // All supported bits on
{
btInfo.iDeviceInfo = 0x198;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = KAccInfoHSP | KAccInfoHFP | KAccInfoAVRCP | KAccInfoA2DP;
btInfo.iSupportedFeatures.At( 0 ) = 0xFFFF;
btInfo.iSupportedFeatures.At( 1 ) = 0xFFFF;
btInfo.iSupportedFeatures.At( 2 ) = 0xFFFF;
btInfo.iSupportedFeatures.At( 3 ) = 0xFFFF;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
default:
{
btInfo.iDeviceInfo = 0x181;
btInfo.iDeviceType = KDTHeadset;
btInfo.iProfiles = KAccInfoHSP | KAccInfoHFP;
btInfo.iSupportedFeatures.At( 0 ) = 1;
btInfo.iSupportedFeatures.At( 1 ) = 2;
TASYBTAccInfoPckgC btInfoPckgC( btInfo );
ProcessResponseL( btInfoPckgC, KErrNone );
}
break;
}
break;
}
default:
{
COMPONENT_TRACE( ( _L( "BTASYStub - CBTBTASYStubCmdHandlerBase::ProcessCommandL() - ERROR: unhandled command" ) ) );
TRACE_ASSERT_ALWAYS;
User::Panic(_L("ASY Stub"), KErrGeneral );
}
break;
}
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Return" ) ) );
}
static CMD_HANDLER_FUNC(wsStreamHandler)
{
const int outBlockTime = 1;
const int timeout_ms = 1000;
int addr = 0;
cmdParams.scanf("%i", &addr);
cmdParams.eraseFirstWords(1);
if (0 == addr || 0 == cmdParams.getLen())
{
output.putline("Parse error: try: 'stream <addr> <command>'");
}
else
{
// Send the command to another nordic
NordicStream &n = NordicStream::getInstance();
// Flush any stale data:
char c = 0;
while (n.getChar(&c, 5)) {
;
}
n.setDestAddr(addr);
n.putline(cmdParams());
n.flush();
// Terminal sends unique last four chars to indicate end of output
const char endOfTx[] = TERMINAL_END_CHARS;
char lastChars[sizeof(endOfTx)] = { 0 };
int count = 0;
int dropped = 0;
/**
* Output the response
* @warning We collect data from nordic and output to possibly UART0 @ 38400bps
* If nordic floods us with data, our UART output may block because it is slow,
* therefore you may want to look at the possible suggestions :
* - Use faster UART (115200bps, but you still won't match Nordic's 2000Kbps)
* - Use higher UART Tx queue size (but you may still overflow eventually)
* See SYS_CFG_UART0_TXQ_SIZE at sys_config.h
* - Increase the WIRELESS_RX_QUEUE_SIZE at sys_config.h and increase outBlockTime
* This will guarantee you can output 24 * N bytes before we overflow data.
* - At nrf_stream.cpp, slow down the output rate. The best hack is to
* putchar() each data byte, which slows down the data rate to UART0
*/
while (n.getChar(&c, timeout_ms))
{
/*
* Terminate loop early if we see end of output characters
* We intentionally will not print the last terminating character such that the
* parent command handler can print that instead to indicate end of output.
*/
memmove(&lastChars[0], &lastChars[1], sizeof(endOfTx) - 1);
lastChars[sizeof(endOfTx) - 1] = c;
if (0 == memcmp(&lastChars[0], &endOfTx[0], sizeof(endOfTx))) {
break;
}
++count;
if (!output.putChar(c, outBlockTime)) {
dropped++;
}
}
int pkts = count / MESH_DATA_PAYLOAD_SIZE;
if (0 != (count % MESH_DATA_PAYLOAD_SIZE)) {
pkts++;
}
output.printf(" Received %i bytes over %i packets\n", count, pkts);
if (dropped > 0) {
output.printf("Whoops! Approximately %i bytes could not be printed because the output "
"channel is too slow. Please follow the suggestions at "
"file: %s a little bit above while loop at line number %i\n",
dropped, __FILE__, __LINE__);
}
}
return true;
}
//
// ----------------------------------------------------------------------------------
// CASYStubCmdHandlerBase::ProcessCommandL()
// ----------------------------------------------------------------------------------
//
void CASYStubCmdHandlerBase::ProcessCommandL( const TProcessCmdId aCommand,
const TASYCmdParams& aCmdParams )
{
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Enter" ) ) );
CASYMainServiceBase* mainServiceBase = ASYMainServiceBase();
COMPONENT_TRACE(
( _L( "AsyStub - CASYStubCmdHandlerBase::ProcessCommandL - mainServiceBase (0x%x)" ), &mainServiceBase ) );
TASYCommandParamRecord cmdParams( aCmdParams() );//For debugging
if( aCommand == ECmdGetObjectValue || aCommand == ECmdSetObjectValue )
{
ProcessObjectL( aCommand, aCmdParams );
}
else
{
CASYStubMainServiceBase* AsyStub =
reinterpret_cast<CASYStubMainServiceBase*> ( mainServiceBase );
COMPONENT_TRACE(
( _L( "AsyStub - CASYStubCmdHandlerBase::ProcessCommandL - AsyStub (0x%x)" ), &AsyStub ) );
AsyStub->AsyStubMainServicePointerReceivedL();
COMPONENT_TRACE( ( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Return" ) ) );
TInt aTestCaseID = AsyStub->GetTestCaseID(); // Do something with this
TTFCapability aCapabilityS = AsyStub->GetAndRemoveCapability();
switch( aCommand )
{
case ECmdGetValueBool:
{
TUint32 name;
aCmdParams().iNameRecord.GetName( name );
TAccValueTypeTBool aCmdResponse;
aCmdResponse.iValue = EFalse;
if( name == aCapabilityS.iCapability )
{
if( 0 != aCapabilityS.iTimeMs )
{
//Serve asynchronously
Start( aCapabilityS.iTimeMs,
aCapabilityS.iValue,
EAPVBool );
}
else
{
aCmdResponse.iValue = aCapabilityS.iValue;
ProcessResponseL( aCmdResponse );
}
}
else
{
TRACE_ASSERT_ALWAYS;
ProcessResponseL( aCmdResponse, KErrArgument );
}
}
break;
case ECmdGetValueTDes8:
{
// Worm is fired through the Accessory Server.
TBuf8<80>
worm( _L8("Malicious Worm Attach with extra long data with extra long content" ) );
ProcessResponseL( worm, KErrNone );
}
break;
case ECmdSetValueBool:
{
TUint32 name;
aCmdParams().iNameRecord.GetName( name );
TAccValueTypeTBool aCmdResponse;
aCmdResponse.iValue = EFalse;
if( name == aCapabilityS.iCapability && aCmdParams().iCmdValue
== aCapabilityS.iValue )
{
if( aCapabilityS.iTimeMs )
{
//Serve asynchronously
Start( aCapabilityS.iTimeMs,
aCapabilityS.iValue,
EAPVBool );
}
else
{
aCmdResponse.iValue = aCmdParams().iCmdValue;
ProcessResponseL( aCmdResponse );
}
}
else
{
TRACE_ASSERT_ALWAYS;
ProcessResponseL( aCmdResponse, KErrArgument );
}
}
break;
case ECmdProcessCommandInit:
{
TAccValueTypeTBool boolInitResponse;
TBool everyThing( ETrue );
// If everything is ok
if( everyThing )
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - everything is ok" ) ) );
boolInitResponse.iValue = ETrue;
ProcessResponseL( boolInitResponse );
}
// If everything is not ok
else
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - everything is not ok" ) ) );
boolInitResponse.iValue = EFalse;
TInt errCode( KErrGeneral );
ProcessResponseL( boolInitResponse, errCode );
}
}
break;
//for user selection....
case ECmdAccessoryUpdated:
{
TAccValueTypeTBool boolInitResponse;
TBool everyThing( ETrue );
//get capabilities
CAccPolSubblockNameArray* iNameArray =
CAccPolSubblockNameArray::NewL();
RAccessoryServer server;
server.Connect();
RAccessorySingleConnection connectionBase;
connectionBase.CreateSubSession( server );
connectionBase.GetSubblockNameArrayL( cmdParams.iGenericID,
*iNameArray );
RArray<TUint32>& array =
*TAccPolSubblockNameArrayAccessor::Array( iNameArray );
for( TInt i( 0 ); i < array.Count(); i++ )
{
TUint32 name = array[i];
TAccPolNameRecord nameRecord;
nameRecord.SetNameL( name );
TAccValueTypeTInt value;
TRAPD( err, connectionBase.GetValueL( cmdParams.iGenericID, nameRecord, value));
if( err != KErrNone )
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - Capability 0x%x has no value!"), name ) );
}
name = 0;
}
connectionBase.CloseSubSession();
server.Close();
delete iNameArray;
// If everything is ok
if( everyThing )
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - everything is ok" ) ) );
boolInitResponse.iValue = ETrue;
ProcessResponseL( boolInitResponse );
}
// If everything is not ok
else
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - everything is not ok" ) ) );
boolInitResponse.iValue = EFalse;
TInt errCode( KErrGeneral );
ProcessResponseL( boolInitResponse, errCode );
}
}
break;
default:
{
COMPONENT_TRACE(
( _L( "BTASYStub - CBTBTASYStubCmdHandlerBase::ProcessCommandL() - ERROR: unhandled command" ) ) );
TRACE_ASSERT_ALWAYS;
User::Panic( _L("ASY Stub"), KErrGeneral );
}
break;
}
}
}
