void CDisplayDeviceIncompatibility::MarshallArgumentsL(TIpcArgs& aArguments)
	{
	*iStream << iAppInfo;
		
	iIpcInputPtr.Set(iStream->Ptr());
	aArguments.Set(0, &iIpcInputPtr);
	aArguments.Set(1, &iResultPackage);
	}
Пример #2
0
// ---------------------------------------------------------------------------
// RPeninputServerImpl::UpdateAppInfo
// Update current application information
// ---------------------------------------------------------------------------
//   
void RPeninputServerImpl::UpdateAppInfo(const TDesC& aInfo, TPeninputAppInfo aType)
    {
    TPckgC<TPeninputAppInfo> typeMsg(aType);
    TIpcArgs arg;    
    arg.Set(KMsgSlot0,&typeMsg);    
    arg.Set(KMsgSlot1,&aInfo);
    SendReceive(EPeninputRequestUpdateAppInfo,arg);    
    }
Пример #3
0
// -----------------------------------------------------------------------------
// RSWInstLauncher::Install
// Launches the software install procedure.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RSWInstLauncher::Install( const TDesC& aFileName )
    {
    __ASSERT_ALWAYS( iConnected, PanicClient( ESWInstPanicBadHandle ) );
    
    TIpcArgs args;
    args.Set( KFileNameIpcSlot, &aFileName );
    return SendReceive( ERequestInstall, args );
    }
Пример #4
0
// -----------------------------------------------------------------------------
// RVoIPAudioSession::OpenRingTonePlayer
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RVoIPAudioSession::OpenRingTonePlayer(const TDesC8& aDesData)
    {
    TPtrC8 ptr(aDesData);
    TIpcArgs args;
    args.Set(0, &ptr);
    TInt err = SendClientRequest(EVoIPOpenRingTonePlayerFromDes, args);
    return err;
    }
QString CSmfCredMgrClientSymbian::storeRSAKeysL(const QString KeyLabel,
		const QString keydata, const QDateTime Validity)
	{
	RDebug::Printf("Sending store RSA key message to server");

	TPtrC labelPtr(qt_QString2TPtrC(KeyLabel));
	TPtr dataPtr((qt_QString2HBufC(keydata)->Des()));

	QDateTime CurrentTime = QDateTime::currentDateTime();
	TTimeIntervalSeconds duration(CurrentTime.secsTo(Validity));

	TTime startDate;
	startDate.UniversalTime();

	TTime endDate(startDate);
	endDate += duration;

	CSmfRsaKeyParameters* storeRSAKeysparams = CSmfRsaKeyParameters::NewL(
			labelPtr, startDate, endDate, (dataPtr.Collapse()));
	CleanupStack::PushL(storeRSAKeysparams);

	CBufFlat* buf = CBufFlat::NewL(KMinBufSize);
	CleanupStack::PushL(buf);
	RBufWriteStream stream(*buf);
	CleanupClosePushL(stream);

	storeRSAKeysparams->ExternalizeL(stream);
	stream.CommitL();

	TPtr8 bufPtr = buf->Ptr(0);

	TIpcArgs args;
	args.Set(0, &bufPtr);

	CleanupStack::PopAndDestroy(&stream);

	HBufC8* retBuf = HBufC8::NewLC(KSHA1HashLengthBytes);
	TPtr8 retBufPtr(retBuf->Des());
	args.Set(1, &retBufPtr);

	iSession.RequestService(ESmfStoreRSAKey, args);

	RDebug::Printf("SMF: Message completed");

	TBuf<KSHA1HashLengthBytes> key;
	key.Copy(retBufPtr);

	QString RetString(qt_TDesC2QString(key));

	CleanupStack::Pop(retBuf);
	CleanupStack::PopAndDestroy(buf);
	CleanupStack::PopAndDestroy(storeRSAKeysparams);

	RDebug::Printf("-In storeAuthDataL()");
	
	return (RetString);

	}
Пример #6
0
// -----------------------------------------------------------------------------
// RSWInstLauncher::Install
// Launches the software install procedure.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void RSWInstLauncher::Install( TRequestStatus& aReqStatus, 
                                        const TDesC& aFileName )
    {
    __ASSERT_ALWAYS( iConnected, PanicClient( ESWInstPanicBadHandle ) );
    
    TIpcArgs args;
    args.Set( KFileNameIpcSlot, &aFileName );
    SendReceive( ERequestInstall, args, aReqStatus );
    }
void CDisplayApplicationsInUse::MarshallArgumentsL(TIpcArgs& aArguments)
	{
	*iStream << iAppInfo;
	StreamOutArrayL(iAppNames,*iStream);
		
	iIpcInputPtr.Set(iStream->Ptr());
	aArguments.Set(0, &iIpcInputPtr);
	aArguments.Set(1, &iResultPackage);
	}
void CSmfCredMgrClientSymbian::deleteRSAKey(QString KeyLabel)
	{
	TPtr bufPtr((qt_QString2HBufC(KeyLabel))->Des());

	TIpcArgs args;
	args.Set(0, &bufPtr);

	iSession.RequestService(ESmfDeleteKeys, args);
	}
Пример #9
0
void CDisplayLanguage::MarshallArgumentsL(TIpcArgs& aArguments)
	{
	*iStream << iAppInfo;
	StreamOutArrayL(iLanguages, *iStream);;
		
	iIpcInputPtr.Set(iStream->Ptr());
	aArguments.Set(0, &iIpcInputPtr);
	aArguments.Set(1,  &iResultPackage);
	}
void CDisplayDependencyBreak::MarshallArgumentsL(TIpcArgs& aArguments)
	{
	*iStream << iAppInfo;
	StreamOutArrayL(iComponents, *iStream);
	
	iIpcInputPtr.Set(iStream->Ptr());
	aArguments.Set(0, &iIpcInputPtr);
	aArguments.Set(1, &iResultPackage);
	}
Пример #11
0
void RPackagerTestClient::PrepareArgumentsL(TIpcArgs& anArgs) const
/** Sets a TIpcArgs object with the packager's buffer details necessary
for inter-process data exchange.

@param anArgs The TIpcArgs object to be set. */
	{
	anArgs.Set(EIPCPackagerTransmitBuffer, &iPackager->GetTransmittingBuffer());
	anArgs.Set(EIPCPackagerReceiveBuffer, &iPackager->GetReceivingBufferL());		
	}	
Пример #12
0
// ---------------------------------------------------------------------------
// RPeninputServerImpl::UiLayoutPos
// get ui layout position
// ---------------------------------------------------------------------------
//
void RPeninputServerImpl::GetUiLayoutPosAndSize()
    {
    TPckg<TPoint> msgPos(iPosition);
    TPckg<TSize> msgSize(iSize);
    
    TIpcArgs arg;
    arg.Set(KMsgSlot0,&msgPos);
    arg.Set(KMsgSlot1,&msgSize);
    SendReceive(EPeninputRequestUiGetUiPos,arg);
    }
Пример #13
0
void CDisplayText::MarshallArgumentsL(TIpcArgs& aArguments)
	{
	*iStream << iAppInfo;
	*iStream << TPckgC<TFileTextOption>(iOption);
	*iStream << iText;
	
	iIpcInputPtr.Set(iStream->Ptr());
	aArguments.Set(0, &iIpcInputPtr);
	aArguments.Set(1, &iResultPackage);
	}
Пример #14
0
EXPORT_C void RMemSpySession::SwitchOutputToFileL(const TDesC& aRootFolder)
	{
	TIpcArgs args;
	if (aRootFolder.Length())
		{
		args.Set(0, &aRootFolder);
		}
	
	User::LeaveIfError(SendReceive(EMemSpyClientServerOpSwitchOutputSinkFile, args));
	}
Пример #15
0
// -----------------------------------------------------------------------------
// 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 );
    }
Пример #16
0
// -----------------------------------------------------------------------------
// RSWInstLauncher::Uninstall
// Launches the software uninstall procedure.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RSWInstLauncher::Uninstall( const TUid& aUid,
                                          const TDesC8& aMIME )
    {
    __ASSERT_ALWAYS( iConnected, PanicClient( ESWInstPanicBadHandle ) );
       
    TIpcArgs args;
    args.Set( KUidIpcSlot, aUid.iUid );
    args.Set( KMimeIpcSlot, &aMIME );

    return SendReceive( ERequestUninstall, args );
    }
Пример #17
0
// ---------------------------------------------------------------------------
// RPeninputServerImpl::GetServerEventData
// Retrieve server event data
// ---------------------------------------------------------------------------
//
TInt RPeninputServerImpl::GetServerEventData(TDes& aBuf)
    {
    if(iServerExit)  // ???
      return -1;
    
    TIpcArgs arg;
    aBuf.Zero();    
    arg.Set(KMsgSlot0,aBuf.MaxLength());
    arg.Set(KMsgSlot1,&aBuf);
    return SendReceive(EPeninputRequestGetServerEventData,arg);
    }
Пример #18
0
// ---------------------------------------------------------------------------
// RPeninputServerImpl::SetDisplayMode
// To disable specified layouts at a time.
// ---------------------------------------------------------------------------
//
TInt RPeninputServerImpl::DisabledLayout()
    {
    TInt layouts = 0;
    TIpcArgs arg;        
    
    TPckg<TInt> msg(layouts);
    arg.Set(KMsgSlot0,&msg); 
    
    SendReceive( EPeninputRequestGetDisableLayout, arg );
    return layouts;
    }    
Пример #19
0
// ---------------------------------------------------------------------------
// RPeninputServerImpl::IsDimmed
// ---------------------------------------------------------------------------
//
TInt RPeninputServerImpl::SupportInputMode()
    {
    TInt supportMode = 0;
    TIpcArgs arg;        
    
    TPckg<TInt> msg(supportMode);
    arg.Set(KMsgSlot0,&msg);    
    SendReceive(EPeninputRequestSupportInputMode,arg);

    return supportMode;
    }    
Пример #20
0
// ---------------------------------------------------------------------------
// RPeninputServerImpl::IsVisible
// ---------------------------------------------------------------------------
//
TBool RPeninputServerImpl::IsVisible()
    {
    TBool bVisible;
    TIpcArgs arg;        
    
    TPckg<TBool> msg(bVisible);
    arg.Set(KMsgSlot0,&msg);    
    SendReceive(EPeninputRequestUiIsVisible,arg);

    return bVisible;
    }
Пример #21
0
// ---------------------------------------------------------------------------
// RPeninputServerImpl::IsVisible
// ---------------------------------------------------------------------------
//
TBool RPeninputServerImpl::IsDimmed()
    {
    TBool bDimmed;
    TIpcArgs arg;        
    
    TPckg<TBool> msg(bDimmed);
    arg.Set(KMsgSlot0,&msg);    
    SendReceive(EPeninputRequestIsLayoutDimmed,arg);

    return bDimmed;
    }
Пример #22
0
// -----------------------------------------------------------------------------
// RSWInstLauncher::Uninstall
// Launches the software uninstall procedure.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void RSWInstLauncher::Uninstall( TRequestStatus& aReqStatus, 
                                          const TUid& aUid,
                                          const TDesC8& aMIME ) 
    {
    __ASSERT_ALWAYS( iConnected, PanicClient( ESWInstPanicBadHandle ) );
  
    TIpcArgs args;
    args.Set( KUidIpcSlot, aUid.iUid );
    args.Set( KMimeIpcSlot, &aMIME );
    
    SendReceive( ERequestUninstall, args, aReqStatus );
    }
Пример #23
0
// -----------------------------------------------------------------------------
// RWimCertMgmt::GetKeyInfo()
//
// Gets Info for single key
// -----------------------------------------------------------------------------
//
TInt RWimCertMgmt::GetKeyInfo( const TInt32 aKeyReference,                                
                               TKeyInfo& aKeyInfo )
    {
    _WIMTRACE ( _L( "RWimCertMgmt::GetKeyInfo()" ) );
    TPckg<TKeyInfo> keyinfo ( aKeyInfo );
    
    TIpcArgs args;
    args.Set( 0, aKeyReference );
    args.Set( 1, &keyinfo );
    
    return SendReceiveData( EGetKeyDetails, args );
    }
Пример #24
0
// ---------------------------------------------------------------------------
// 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;
    
    }
Пример #25
0
// ---------------------------------------------------------------------------
// RPeninputServerImpl::SetDisplayMode
// Set the display mode
// ---------------------------------------------------------------------------
//
void RPeninputServerImpl::SetDisplayMode(TDisplayMode aDisplayMode,
                                                TDisplayMode aMaskDisplayMode)
    {
    TPckgC<TDisplayMode> msg(aDisplayMode);
    TPckgC<TDisplayMode> msg2(aMaskDisplayMode);
    
    TIpcArgs arg;    
    arg.Set(KMsgSlot0,&msg);
    arg.Set(KMsgSlot1,&msg2);
    
    SendReceive( EPeninputServerRequestSetDisplayMode, arg); 
    }
Пример #26
0
// ---------------------------------------------------------------------------
// RPeninputServerImpl::SetUiLayoutId
// Create a ui layout
// ---------------------------------------------------------------------------
//
TInt RPeninputServerImpl::SetUiLayoutId(TUid aId)
    {
    TInt uid = aId.iUid;    

    TPckgC<TInt> msg(uid);
    TIpcArgs arg;    
    arg.Set(KMsgSlot0,&msg);
    
    TPckg<TInt> type(iCurPenUiType);
    arg.Set(KMsgSlot2,&type);
    return SendReceive(EPeninputRequestSetUiLayoutId,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 );
    }
Пример #28
0
// ---------------------------------------------------------------------------
// 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;
    
    }
Пример #29
0
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;
	}
Пример #30
0
void RPeninputServerImpl::SetResourceChange(TBool aFlag)
    {
    iResourceChange = aFlag; 
    
    
    TBool bChange = aFlag;
    TIpcArgs arg;        
    
    TPckg<TBool> msg(bChange);
    arg.Set(KMsgSlot0,&msg);    
    SendReceive(EPeninputRequestDimResChangeLayout,arg);       
    }