C++ TIpcArgs::Set方法代码示例

/*!
 * The leaving function that queries the SQL database
 * 
 * \a id database id of the contact
 * \return the list of matched contact names
 */
void CntSymbianSrvConnection::readContactsToBufferL(const TDesC& sqlQuery, QueryType aQueryType)
{
    // Initialize connection if it is not initialized yet.
    if (!m_isInitialized) {
        ConnectSrvL();
        OpenDatabaseL();
        m_isInitialized = true;
    }

    TIpcArgs args;
    args.Set(0, &GetReceivingBufferL());
    args.Set(1, &sqlQuery);
    TInt newBuffSize = SendReceive(aQueryType, args);
    User::LeaveIfError(newBuffSize);
    if (newBuffSize > 0) {
        args.Set(0, &GetReceivingBufferL(newBuffSize));
        args.Set(1, &sqlQuery);
        User::LeaveIfError(SendReceive(aQueryType, args));
    }
}

// -----------------------------------------------------------------------------
// RSWInstLauncher::SilentInstall
// Launches the silent software install procedure.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RSWInstLauncher::SilentInstall( RFile& aFile,
                                              const TDesC8& aOptions )
    {
    __ASSERT_ALWAYS( iConnected, PanicClient( ESWInstPanicBadHandle ) );
    
    TIpcArgs args;
    aFile.TransferToServer( args, KFileHandleIpcSlot, KFileSrvSessionIpcSlot );
    args.Set( KOptionsIpcSlot, &aOptions );    

    return SendReceive( ERequestSilentInstallHandle, args );
    }

// ---------------------------------------------------------------------------
// RPeninputServerImpl::SetForeground
// Set current session to be foreground application session
// ---------------------------------------------------------------------------
//
TBool RPeninputServerImpl::SetForeground(TBool aMustConnectFlag)
    {
 //   if(iIsForegroundSession)
 //       return ETrue;
    
    TInt curAppId;
    TRAP_IGNORE( curAppId = GetAppUidByWndGroupIdL(CCoeEnv::Static()->WsSession(),
                        CCoeEnv::Static()->RootWin().Identifier()).iUid);
    TIpcArgs arg;        
    TPckgC<TInt> idData(curAppId);
    arg.Set(KMsgSlot0,&idData); 

    TPckgC<TBool> flagMsg(aMustConnectFlag);    
    arg.Set(KMsgSlot1,&flagMsg); 
    
    TPckg<TInt> retMsg(iIsForegroundSession);
    arg.Set(KMsgSlot2,&retMsg);
    
    SendReceive(EPeninputRequestSetForeground,arg);
    return iIsForegroundSession;
    }

// ---------------------------------------------------------------------------
// RPeninputServerImpl::ServerEventDfataNum
// Get the number of server event
// ---------------------------------------------------------------------------
//
TInt RPeninputServerImpl::ServerEventDataNum()
    {  
    TInt num = -1;
    TPckg<TInt> msg(num);
    TIpcArgs arg;
    arg.Set(KMsgSlot0,&msg);
    TInt err = SendReceive(EPeninputRequestGetServerEventDataNumber,arg);
    if(err != KErrNone)
        num = err;//set the error code
    return num;
    
    }

// -----------------------------------------------------------------------------
// RMce::SendAppUid
// -----------------------------------------------------------------------------
//
TInt RMce::SendClientUid ( const TUid& aUid ) const
	{
    MCECLI_DEBUG("RMce::SendClientUid, Entry");
	TMceIds ids;
	ids.iAppUID = aUid.iUid;
	
    TPckgBuf<TInt> clientUidPckg( aUid.iUid );
    TPckgBuf<TMceIds> idsPckg( ids );
    TIpcArgs itcMsgArgs;
    
    itcMsgArgs.Set(EMceItcArgIds, &idsPckg);
    itcMsgArgs.Set(EMceItcArgAppUid, &clientUidPckg);

    TInt status = SendReceive ( EMceItcSetAppUid, itcMsgArgs);

    MCECLI_DEBUG_DVALUE("RMce::SendClientUid, Exit. status", status );

	return status;
    
	
	}

void RIpcApparcFuzzTest::RunFuzzTestL()
	{
	iTestFuzz.INFO_PRINTF1(_L("Testing appserv APIs GetExecutableNameGivenDataTypeL and AppForDataTypeL  "));	
	TInt ret;
	TVersion version(1,1,1);
	ret = CreateSession(_L("!AppListServer"),version,4);
	iTestFuzz.TEST(ret ==KErrNone);
	HBufC* buf = HBufC::NewLC(268);
	TPtr ptr = buf->Des();
	TIpcArgs args;
	args.Set(0, &ptr);	
	ret = SendReceive(14, args); // Send bad args to CApaAppListServSession::AppForDataTypeL using enum value of EAppListServAppForDataType
	iTestFuzz.TEST(ret ==KErrArgument);
	iTestFuzz.INFO_PRINTF1(_L("Testing CApaAppListServSession::AppForDataTypeL() is completed "));	
	args.Set(2, &ptr);	
	ret = SendReceive(21, args);// Send bad args to CApaAppListServSession::GetExecutableNameGivenDataTypeL using enum value EAppListServGetExecutableNameGivenDocument
	iTestFuzz.TEST(ret ==KErrArgument);
	iTestFuzz.INFO_PRINTF1(_L("Tesing CApaAppListServSession::GetExecutableNameGivenDataTypeL() is completed "));	
	iTestFuzz.INFO_PRINTF2(_L("Test successfully returns KErrArgument %d"),ret);	
	CleanupStack::PopAndDestroy(buf);	
	}

TInt RTestApaLsSession::TestExeRecognizerL(const CApaCommandLine& aCommandLine)
	{
	TThreadId dummyThreadId;
	TPckg<TThreadId> threadId(dummyThreadId);
	const TInt opcode=EAppListServStartAppWithoutReturningThreadId;
	TIpcArgs ipcArgs;
	aCommandLine.GetIpcArgsLC(ipcArgs);
	ipcArgs.Set(CApaCommandLine::EIpcFirstFreeSlot, &threadId);
	User::LeaveIfError(SendReceive(opcode, ipcArgs));
	CleanupStack::PopAndDestroy(); // the TIpcArgs
	return KErrNone;
	}

void RPeninputServerImpl::SetResourceChange(TBool aFlag)
    {
    iResourceChange = aFlag; 
    
    
    TBool bChange = aFlag;
    TIpcArgs arg;        
    
    TPckg<TBool> msg(bChange);
    arg.Set(KMsgSlot0,&msg);    
    SendReceive(EPeninputRequestDimResChangeLayout,arg);       
    }

// -----------------------------------------------------------------------------
// RUpnpMediaServerClient::SetUploadDirectoryL
// -----------------------------------------------------------------------------
//
EXPORT_C void RUpnpMediaServerClient::SetUploadDirectoryL( const TDesC& aPath,
    TRequestStatus& aStatus )
    {
    CUpnpMediaServerSettings* settings = CUpnpMediaServerSettings::NewL();
    CleanupStack::PushL( settings );
    User::LeaveIfError( settings->Set(UpnpMediaServerSettings::EUploadDirectory, aPath) );
    CleanupStack::PopAndDestroy( settings );

    TIpcArgs args;
    args.Set(0, &aPath);
    SendReceive( EMediaServerSetUploadDirectory, args, aStatus );
    }

// -----------------------------------------------------------------------------
// RSWInstLauncher::Install
// Launches the software install procedure.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void RSWInstLauncher::Install( TRequestStatus& aReqStatus, 
                                        RFile& aFile,
                                        const TDesC8& aParams )
    {
    __ASSERT_ALWAYS( iConnected, PanicClient( ESWInstPanicBadHandle ) );
    
    TIpcArgs args;
    aFile.TransferToServer( args, KFileHandleIpcSlot, KFileSrvSessionIpcSlot );    
    args.Set( KParamsIpcSlot, &aParams );   

    SendReceive( ERequestInstallParamsHandle, args, aReqStatus );
    }

// ---------------------------------------------------------------------------
// RPeninputServerImpl::IsForeground
// Test whether this session is the forground application session
// ---------------------------------------------------------------------------
//
TBool RPeninputServerImpl::IsForeground()
    {
    TBool bIsForeground;
    TIpcArgs arg;        
    
    TPckg<TBool> msg(bIsForeground);
    arg.Set(KMsgSlot0,&msg);    
    SendReceive(EPeninputRequestIsForeground,arg);
    //__ASSERT_DEBUG(bIsForeground == iIsForegroundSession,User::Leave(-1));    
    return bIsForeground;
    
    }

// -----------------------------------------------------------------------------
// RWimCertMgmt::CertRefLst()
// Returns certificate list on the WIM
// -----------------------------------------------------------------------------
//
void  RWimCertMgmt::CertRefLst( TCertificateAddressList aCertAddrLst, 
                                TWimCertInfo* aCertInfoArr, 
                                TUint8 aCount, 
                                TWimEntryType aCertEntryType,
                                TRequestStatus& aStatus )
    {
    _WIMTRACE ( _L( "RWimCertMgmt::CertRefLst()" ) );
    aStatus = KRequestPending;
    TInt16 size = ( TInt16 ) ( sizeof ( TCertificateAddress ) * aCount );
    iCertLst.Set( ( TUint8* ) aCertAddrLst, size, size );   

    size = ( TInt16 )( sizeof ( TWimCertInfo ) * aCount );
    iCertInfoLst.Set( ( TUint8* ) aCertInfoArr, size, size ); 
    
    TIpcArgs args;
    args.Set( 0, &iCertLst );
    args.Set( 1, &iCertInfoLst );
    args.Set( 2, aCertEntryType );
    
    SendReceiveData( EGetWIMCertLst, args, aStatus );
    }

// ---------------------------------------------------------------------------
// RPeninputServerImpl::GetImePluginIdListL
// Get IME plugin list for a language
// ---------------------------------------------------------------------------
//
void RPeninputServerImpl::GetImePluginIdListL(TInt aLanguage, 
                                                  TInt aPluginMode, 
                                                  RArray<TInt>& aImplmentationIds)
    {
    TInt size = sizeof(TInt) * (KMaxImeImplementations + 1);
	HBufC8* buf = HBufC8::NewLC(size);
	TPtr8 bufPtr = buf->Des();

    TIpcArgs args;
    args.Set(KMsgSlot0, aLanguage);
    args.Set(KMsgSlot1, aPluginMode);
    args.Set(KMsgSlot2, size);
    args.Set(KMsgSlot3, &bufPtr);    
    aImplmentationIds.Reset();
    TInt err = SendReceive(EPenInputRequestGetImePluginIdList,args);
    if( err == KErrNone )
        {
        ReadIntArrayFromBufL(*buf, aImplmentationIds);
        }
    
    CleanupStack::PopAndDestroy(buf);    
    }

// -----------------------------------------------------------------------------
// RWimCertMgmt::CertCount()
// Returns count of certificates
// -----------------------------------------------------------------------------
//
TUint8 RWimCertMgmt::CertCount( TWimEntryType aType )
    {
    _WIMTRACE ( _L( "RWimCertMgmt::CertCount()" ) );

    TPckgBuf<TUint8> pckg( 0 );
    
    TIpcArgs args;
    args.Set( 0, &pckg );
    args.Set( 1, aType );
    
    SendReceiveData( EGetCertCount, args );
    return pckg();
    }

// -----------------------------------------------------------------------------
// RWimCertMgmt::GetAuthObjsInfo()
// Get Authentication Object information
// -----------------------------------------------------------------------------
//
void RWimCertMgmt::RetrieveAuthObjsInfoL( const RArray<TInt>& aAuthIdList,
                      RArray<TJavaPINParams>& aAuthObjsInfoList,
                      TRequestStatus& aStatus,
                      const TWimServRqst aOpCode )             
    {
    _WIMTRACE ( _L( "RWimCertMgmt::RetrieveAuthObjsInfo" ) );
      
    TInt count = aAuthIdList.Count();
    TInt authIdLength = count * sizeof( TInt );
    TInt authobjLength = count * sizeof( TJavaPINParams ); 
    
    if ( iAuthIdLstPtr == NULL )
	    {
	    iAuthIdLstPtr = new( ELeave )TPtrC8( (TText8*)&aAuthIdList[0], authIdLength );
	    }
    else
        {
        iAuthIdLstPtr->Set( (TText8*)&aAuthIdList[0], authIdLength );
        } 
    
    if ( iAuthObjsInfoLstPtr == NULL )
        {
        iAuthObjsInfoLstPtr = new( ELeave )TPtr8( (TText8*)&aAuthObjsInfoList[0], authobjLength, authobjLength );	
        }
    else
        {
        iAuthObjsInfoLstPtr->Set( (TText8*)&aAuthObjsInfoList[0], authobjLength, authobjLength );	
        }
    
    aStatus = KRequestPending;
    TIpcArgs args;
    
    args.Set( 0, iAuthIdLstPtr );
    args.Set( 1, iAuthObjsInfoLstPtr );
    args.Set( 2, count );
    
    
    SendReceiveData( aOpCode, args, aStatus );
    }