// ----------------------------------------------------------------------------------
// CASYStubCmdHandlerBase::DoTimeOutL()
// ----------------------------------------------------------------------------------
void CASYStubCmdHandlerBase::DoTimeOutL()
{
if( iTimer )
{
delete iTimer; // One timeout is all what is needed
iTimer = NULL;
}
switch ( iResponseType )
{
case ( EAPVBool ):
{
TAccValueTypeTBool response = { EFalse };
response.iValue = iResponse;
ProcessResponseL( response );
}
break;
default:
{
TRACE_ASSERT_ALWAYS;
}
break;
}
iResponse = 0;
iResponseType = EAPVNone;
}
// ----------------------------------------------------------------------------------
// 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" ) ) );
}
//
// ----------------------------------------------------------------------------------
// 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;
}
}
}
void CASYStubCmdHandlerBase::ProcessObjectL( const TProcessCmdId aCommand,
const TASYCmdParams& aCmdParams )
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL() - CAccPolObjectBase" ) ) );
RBufReadStream rStrm;
TUint32 name;
aCmdParams().iNameRecord.GetName( name );
if( name == KAccAudioStreamsFormat )
{
switch( aCommand )
{
case ECmdGetObjectValue:
{
CAccPolAudioStreamFormatCon* container1 =
CAccPolAudioStreamFormatCon::NewLC();
CAccPolAudioStreamFormatCon* container2 =
CAccPolAudioStreamFormatCon::NewLC();
RProperty prop;
CBufFlat* buf =
CBufFlat::NewL( KAccSrvObjectBaseStreamBufGranularity );
CleanupStack::PushL( buf );
buf->ResizeL( KAccSrvObjectBaseStreamBufMaxSize );
TPtr8 ptr( buf->Ptr( 0 ) );
TInt retval = prop.Get( KTFAccessoryTestProperty,
KTFAccessoryObjectMethod,
ptr );
( void )rStrm.Open( *buf );
rStrm.PushL();
container1->InternalizeL( rStrm );
rStrm.Close();
rStrm.Pop();
for( TInt i = 0; i < container1->Count(); i++ )
{
container2->AddL( *container1->AtL( i ) );
}
ProcessResponseL( *container2 );
CleanupStack::PopAndDestroy( buf );
CleanupStack::PopAndDestroy( container2 );
CleanupStack::PopAndDestroy( container1 );
}
break;
case ECmdSetObjectValue:
{
CAccPolAudioStreamFormatCon* container1 =
CAccPolAudioStreamFormatCon::NewLC();
CAccPolAudioStreamFormatCon* container2 =
CAccPolAudioStreamFormatCon::NewLC();
RProperty prop;
CBufFlat* buf =
CBufFlat::NewL( KAccSrvObjectBaseStreamBufGranularity );
CleanupStack::PushL( buf );
buf->ResizeL( KAccSrvObjectBaseStreamBufMaxSize );
TPtr8 ptr( buf->Ptr( 0 ) );
TInt retval = prop.Get( KTFAccessoryTestProperty,
KTFAccessoryObjectMethod,
ptr );
( void )rStrm.Open( *buf );
rStrm.PushL();
container1->InternalizeL( rStrm );
rStrm.Close();
rStrm.Pop();
// Read objects from proxy
ObjectConDataFromProxyL( *container2 );
//externalize container to bufFromServer
CBufFlat* bufFromServer =
CBufFlat::NewL( KAccSrvObjectBaseStreamBufGranularity );
CleanupStack::PushL( bufFromServer );
bufFromServer->ResizeL( KAccSrvObjectBaseStreamBufMaxSize );
RBufWriteStream wStrm;
( void )wStrm.Open( *bufFromServer );
wStrm.PushL();
container2->ExternalizeL( wStrm );
wStrm.CommitL();
wStrm.Close();
wStrm.Pop();
TPtr8 ptrbufFromServer( bufFromServer->Ptr( 0 ) );
//bufFromServer content must equal to buf content
TInt
err =
( 0
== memcompare( reinterpret_cast<TUint8*> ( &ptrbufFromServer ),
sizeof( bufFromServer ),
reinterpret_cast<TUint8*> ( &ptr ),
sizeof( bufFromServer ) ) ) ? KErrNone
: KErrGeneral;
ProcessResponseL( *container2, err ); // same container which was received from server
CleanupStack::PopAndDestroy( bufFromServer );
CleanupStack::PopAndDestroy( buf );
CleanupStack::PopAndDestroy( container2 );
CleanupStack::PopAndDestroy( container1 );
}
break;
default:
{
COMPONENT_TRACE(
( _L( "BTASYStub - CBTBTASYStubCmdHandlerBase::ProcessCommandL() - CAccPolObjectBase - ERROR: unhandled command" ) ) );
TRACE_ASSERT_ALWAYS;
User::Panic( _L("ASY Stub"), KErrGeneral );
}
break;
}
}
else if( name == KAccAudioUnits )
{
CAccPolAudioTopologyObjectCon* container1 =
CAccPolAudioTopologyObjectCon::NewLC();
CAccPolAudioTopologyObjectCon* container2 =
CAccPolAudioTopologyObjectCon::NewLC();
RProperty prop;
CBufFlat* buf = CBufFlat::NewL( KAccSrvObjectBaseStreamBufGranularity );
CleanupStack::PushL( buf );
buf->ResizeL( KAccSrvObjectBaseStreamBufMaxSize );
TPtr8 ptr( buf->Ptr( 0 ) );
TInt retval = prop.Get( KTFAccessoryTestProperty,
KTFAccessoryObjectMethod,
ptr );
( void )rStrm.Open( *buf );
rStrm.PushL();
container1->InternalizeL( rStrm );
rStrm.Close();
rStrm.Pop();
for( TInt i = 0; i < container1->Count(); i++ )
{
container2->AddL( *container1->AtL( i ) );
}
ProcessResponseL( *container2 );
CleanupStack::PopAndDestroy( buf );
CleanupStack::PopAndDestroy( container2 );
CleanupStack::PopAndDestroy( container1 );
}
else if( name == KAccAudioControl )
{
if( aCommand == ECmdSetObjectValue )
{
CAccPolAudioTopologyObjectCon* container1 =
CAccPolAudioTopologyObjectCon::NewLC();
// Get object from proxy
ObjectConDataFromProxyL( *container1 );
for( TInt i = 0; i < container1->Count(); i++ )
{
if( container1->AtL( i )->ObjectType()
== EAccPolAudioVolumeControlObject )
{
CAccPolVolumeControl* mVolume =
( CAccPolVolumeControl* )container1->AtL( i );
if( mVolume->UnitId() == 2 && mVolume->Channel()
== KAccRightFrontChannel )
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - SET - right channel volume level=%f" ), mVolume->VolumeDb() ) );
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - SET - right channel volume min level=%f" ), mVolume->MinVolumeDb() ) );
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - SET - right channel volume max level=%f" ), mVolume->MaxVolumeDb() ) );
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - SET - right channel volume res level=%f" ), mVolume->VolumeResDb() ) );
}
if( mVolume->UnitId() == 2 && mVolume->Channel()
== KAccLeftFrontChannel )
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - SET - left channel volume level=%f" ), mVolume->VolumeDb() ) );
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - SET - left channel volume min level=%f" ), mVolume->MinVolumeDb() ) );
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - SET - left channel volume max level=%f" ), mVolume->MaxVolumeDb() ) );
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - SET - left channel volume res level=%f" ), mVolume->VolumeResDb() ) );
}
}
else
{
CAccPolMuteControl* mMute =
( CAccPolMuteControl* )container1->AtL( i );
if( mMute->Channel() == KAccMasterChannel )
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - KAccSetAudioControl - mute=%d" ), mMute->Mute() ) );
}
}
}
ProcessResponseL( *container1 );
CleanupStack::PopAndDestroy( container1 );
}
else if( aCommand == ECmdGetObjectValue )
{
CAccPolAudioTopologyObjectCon* container1 =
CAccPolAudioTopologyObjectCon::NewLC();
CAccPolAudioTopologyObjectCon* container2 =
CAccPolAudioTopologyObjectCon::NewLC();
RProperty prop;
CBufFlat* buf =
CBufFlat::NewL( KAccSrvObjectBaseStreamBufGranularity );
CleanupStack::PushL( buf );
buf->ResizeL( KAccSrvObjectBaseStreamBufMaxSize );
TPtr8 ptr( buf->Ptr( 0 ) );
TInt retval = prop.Get( KTFAccessoryTestProperty,
KTFAccessoryObjectMethod,
ptr );
( void )rStrm.Open( *buf );
rStrm.PushL();
container2->InternalizeL( rStrm );
rStrm.Close();
rStrm.Pop();
// Read object --> after that assign new value
ObjectConDataFromProxyL( *container1 );
if( container1->AtL( 0 )->ObjectType()
== EAccPolAudioVolumeControlObject )
{
CAccPolVolumeControl* rightVolume =
( CAccPolVolumeControl* )container2->AtL( 0 );
CAccPolVolumeControl* leftVolume =
( CAccPolVolumeControl* )container2->AtL( 1 );
if( reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 0 ) )->Channel()
== KAccRightFrontChannel )
{
reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 0 ) )->SetVolumeDb( rightVolume->VolumeDb() );
reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 0 ) )->SetMinVolumeDb( rightVolume->MinVolumeDb() );
reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 0 ) )->SetMaxVolumeDb( rightVolume->MaxVolumeDb() );
reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 0 ) )->SetVolumeResDb( rightVolume->VolumeResDb() );
}
if( reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 1 ) )->Channel()
== KAccLeftFrontChannel )
{
reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 1 ) )->SetVolumeDb( rightVolume->VolumeDb() );
reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 1 ) )->SetMinVolumeDb( rightVolume->MinVolumeDb() );
reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 1 ) )->SetMaxVolumeDb( rightVolume->MaxVolumeDb() );
reinterpret_cast<CAccPolVolumeControl*> ( container1->AtL( 1 ) )->SetVolumeResDb( rightVolume->VolumeResDb() );
}
}
else
{
CAccPolMuteControl* psMute =
( CAccPolMuteControl* )container2->AtL( 0 );
if( reinterpret_cast<CAccPolMuteControl*> ( container1->AtL( 0 ) )->Channel()
== KAccMasterChannel )
{
reinterpret_cast<CAccPolMuteControl*> ( container1->AtL( 0 ) )->SetMute( psMute->Mute() );
}
}
ProcessResponseL( *container1 );
CleanupStack::PopAndDestroy( buf );
CleanupStack::PopAndDestroy( container2 );
CleanupStack::PopAndDestroy( container1 );
}
else
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - No control object to found!" ) ) );
}
}
else if( name == KAccVideoHdmiAttributes )
{
switch( aCommand )
{
case ECmdGetObjectValue:
{
// Create buffer
CBufFlat* buf = CBufFlat::NewL( KAccSrvObjectBaseStreamBufGranularity );
CleanupStack::PushL( buf );
buf->ResizeL( KAccSrvObjectBaseStreamBufMaxSize );
// Read container from P&S
TPtr8 bufPtr( buf->Ptr( 0 ) );
TInt err = RProperty::Get( KTFAccessoryTestProperty,
KTFAccessoryObjectMethod,
bufPtr );
if( err == KErrNone )
{
// Stream HDMI container from data read from P&S
CAccPolHdmiObjectCon* con = CAccPolHdmiObjectCon::NewLC();
RBufReadStream readStream( *buf );
readStream.PushL();
con->InternalizeL( readStream );
// Change all aatributes in speaker allocation to false
RAccPolHdmiSpeakerAllocationArray array;
CleanupClosePushL( array );
con->GetHdmiSpeakerAllocationObjectsL( array );
if( array.Count() )
{
CAccPolHdmiSpeakerAllocation* speakerAllocation = array[0];
CAccPolHdmiSpeakerAllocation::THdmiSpeakerAllocation bits =
CAccPolHdmiSpeakerAllocation::EHdmiSpeakerUnknown;
speakerAllocation->SetSpeakerAllocation( bits );
}
CleanupStack::PopAndDestroy( &array );
// Process response
ProcessResponseL( *con, err );
// Cleanup
CleanupStack::PopAndDestroy( &readStream );
CleanupStack::PopAndDestroy( con );
}
// Cleanup
CleanupStack::PopAndDestroy( buf );
break;
}
case ECmdSetObjectValue:
default:
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - Nothing to do!" ) ) );
break;
}
}
}
else if( name == KAccVideoFormat )
{
switch( aCommand )
{
case ECmdGetObjectValue:
{
// Create buffer
CBufFlat* buf = CBufFlat::NewL( KAccSrvObjectBaseStreamBufGranularity );
CleanupStack::PushL( buf );
buf->ResizeL( KAccSrvObjectBaseStreamBufMaxSize );
// Read container from P&S
TPtr8 bufPtr( buf->Ptr( 0 ) );
TInt err = RProperty::Get( KTFAccessoryTestProperty,
KTFAccessoryObjectMethod,
bufPtr );
if( err == KErrNone )
{
// Stream HDMI object container format from data read from P&S
CAccPolHdmiObjectCon* con = CAccPolHdmiObjectCon::NewLC();
RBufReadStream readStream( *buf );
readStream.PushL();
con->InternalizeL( readStream );
CleanupStack::PopAndDestroy( &readStream );
// Set video format to interlaced mode
RAccPolHdmiVideoFormatArray array;
CleanupClosePushL( array );
con->GetHdmiVideoFormatObjectsL( array );
if( array.Count() )
{
CAccPolHdmiVideoFormat* videoFormat = array[0];
videoFormat->SetInterlaced( ETrue );
}
CleanupStack::PopAndDestroy( &array );
// Process response
ProcessResponseL( *con, err );
// Cleanup
CleanupStack::PopAndDestroy( con );
}
// Cleanup
CleanupStack::PopAndDestroy( buf );
break;
}
case ECmdSetObjectValue:
default:
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - Nothing to do!" ) ) );
break;
}
}
}
else
{
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - Nothing to do!" ) ) );
}
/*CleanupStack::PopAndDestroy( buf );
CleanupStack::PopAndDestroy( container );
CleanupStack::PopAndDestroy( aObject );
*/
COMPONENT_TRACE(
( _L( "ASYStub - CASYStubCmdHandlerBase::ProcessCommandL - return void - CAccPolObjectBase" ) ) );
}
//
// ----------------------------------------------------------------------------------
// CASYStubCmdHandlerBase::ProcessCommandL()
// ----------------------------------------------------------------------------------
//
void CASYStubCmdHandlerBase::ProcessCommandL( const TProcessCmdId aCommand, const TASYCmdParams& aCmdParams )
{
CASYMainServiceBase* mainServiceBase = ASYMainServiceBase();
CASYStubMainServiceBase* AsyStub = reinterpret_cast<CASYStubMainServiceBase*>( mainServiceBase );
AsyStub->AsyStubMainServicePointerReceivedL();
TTFCapability aCapabilityS = AsyStub->GetAndRemoveCapability();
TASYCommandParamRecord cmdParams ( aCmdParams() );//For debugging
switch ( aCommand )
{
case ECmdGetValueBool:
{
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
{
ProcessResponseL(aCmdResponse, KErrArgument);
}
}
break;
case ECmdGetValueTDes8:
{
// Worm is fired through the Accessory Server.
TBuf8<22> worm(_L8("Malicious Worm Attach" ));
ProcessResponseL( worm, KErrNone );
}
break;
case ECmdSetValueBool:
{
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
{
ProcessResponseL(aCmdResponse, KErrArgument);
}
}
break;
case ECmdProcessCommandInit:
{
TAccValueTypeTBool boolInitResponse;
TBool everyThing( ETrue );
// If everything is ok
if ( everyThing )
{
boolInitResponse.iValue = ETrue;
ProcessResponseL( boolInitResponse );
}
// If everything is not ok
else
{
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)
{
}
name = 0;
}
connectionBase.CloseSubSession();
server.Close();
delete iNameArray;
// If everything is ok
if ( everyThing )
{
boolInitResponse.iValue = ETrue;
ProcessResponseL( boolInitResponse );
}
// If everything is not ok
else
{
boolInitResponse.iValue = EFalse;
TInt errCode( KErrGeneral );
ProcessResponseL( boolInitResponse, errCode );
}*/
}
break;
default:
{
User::Panic(_L("ASY Stub"), KErrGeneral );
}
break;
}
}
