// ----------------------------------------------------------------------------- // RDRMRightsClient::CheckRights // Checks if appropriate rights exist for a certain content ID. // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::CheckRights( const TInt aIntent, const TDesC8& aContentID, TUint32& aRejection ) { TInt error = KErrNone; TInt size = 0; TPckg<TInt> package( size ); TPckg<TUint32> package2( aRejection ); DRMLOG( _L( "RDRMRightsClient::CheckRights" ) ); error = SendReceive( DRMEngine::ECheckRights, TIpcArgs( aIntent, &aContentID, &package, &package2 ) ); DRMLOG2( _L( "RDRMRightsClient::CheckRights: %d" ), error ); return error; }
// ----------------------------------------------------------------------------- // CHWRMPowerImpl::DoNotifyBatteryFullChargingTime // // ----------------------------------------------------------------------------- // TInt CHWRMPowerImpl::DoNotifyBatteryFullChargingTime(TRequestStatus& aStatus) { COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoNotifyBatteryFullChargingTime()" )); if (!iBatteryChargingTimeAO) { COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoNotifyBatteryFullChargingTime - return( - return 0x%x" ), KErrBadHandle ); return KErrBadHandle; } TInt err; CHWRMPower::TBatteryChargingStatus chargingStatus; err = DoGetBatteryChargingStatus(chargingStatus); if((err != KErrNone) || (chargingStatus <= CHWRMPower::EChargingStatusError) || (chargingStatus == CHWRMPower::EChargingStatusNotConnected) || (chargingStatus == CHWRMPower::EChargingStatusNotCharging)) { err = KErrNotReady; } else { iClient.ExecuteAsyncOperation(EHWRMStartBatteryFullChargingTimeReporting, TIpcArgs(), aStatus); //Issue request to retrieve battery full charge time measurements if( !iBatteryChargingTimeAO->IsActive()) { iBatteryChargingTimeAO->GetAsyncBatch( EHWRMGetBatteryFullChargingTimeMeasurements ); } err = KErrNone; } COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoNotifyBatteryFullChargingTime - return( - return 0x%x" ), err ); return err; }
//------------------------------------------------------------------------------------------------------ // testing // ESSProtocolStop //------------------------------------------------------------------------------------------------------ TInt CPARAM_MESS_NAMEStep::do_execute(Int2Type<ESSClearExclusiveMode>) { TInt result; //-- 1. Create and start a connection. result = CreateConnection(); if(result != KErrNone) return result; result = SendReceive(ESSClearExclusiveMode,TIpcArgs(0,0,0,iSSRes)); if(result != KErrNone) return result; //-- stop and close connection StopCloseConnection(); return KErrNone; }
TInt DoSetTags8(const TDesC8& aDir, const TDesC8& aName) { //TPtrC8 name(aName); //_LIT8(KDotTxt, ".txt"); //_LIT8(KDotLog, ".log"); //if (name.Right(KDotTxt().Length()) == KDotTxt) name.Set(name.Left(name.Length()-KDotTxt().Length())); //else if (name.Right(KDotLog().Length()) == KDotLog) name.Set(name.Left(name.Length()-KDotLog().Length())); TPckg<TUint32> enabledPkg(iEnabled); TInt result = SendReceive(ESetTag8, TIpcArgs(&aDir, &aName, &enabledPkg)); if (result >= 0) { iSequence = result; return KErrNone; } else { return result; } }
//------------------------------------------------------------------------------------------------------ // testing // ESSProtocolStop //------------------------------------------------------------------------------------------------------ TInt CPARAM_MESS_NAMEStep::do_execute(Int2Type<ESSProtocolStop>) { TInt result; //-- 1. Create and start a connection. result = CreateConnection(); if(result != KErrNone) return result; result = SendReceive(ESSProtocolStop,TIpcArgs(KAfInet,KSockDatagram,KProtocolInetUdp,iSSRes)); if(result != KErrNone) return result; //-- stop and close connection StopCloseConnection(); return KErrNone; }
// ----------------------------------------------------------------------------- // RRoapStorageClient::VerifyOcspResponsesL // ----------------------------------------------------------------------------- // EXPORT_C TBool Roap::RRoapStorageClient::VerifyOcspResponsesL( const RPointerArray<HBufC8>& aOcspResponses, const TDesC8& aRiCaCert, const RPointerArray<HBufC8>& aCertSerialNums ) { TBool ret( EFalse ); HBufC8* ocspData( ArrayToBufferLC( aOcspResponses ) ); HBufC8* serialNumsData( ArrayToBufferLC( aCertSerialNums ) ); TPtrC8 riCaCertParam( aRiCaCert ); TPckg<TBool> retParam( ret ); User::LeaveIfError( SendReceive( Roap::EVerifyOcspResponses, TIpcArgs( ocspData, &riCaCertParam, serialNumsData, &retParam ) ) ); CleanupStack::PopAndDestroy( serialNumsData ); CleanupStack::PopAndDestroy( ocspData ); return ret; }
EXPORT_C TInt RVpnServ::GetPolicyDetails(const TVpnPolicyId& aPolicyId, TVpnPolicyDetails& aPolicyDetails) /** * Returns detailed information about the specified policy. * * @param aPolicyId The ID of the policy to return information * about * @param aPolicyDetails [out] Detailed policy information * * @return KErrNone, if the request was processed successfully; * KVpnErrPolicyNotFound, if the specified policy was not found; * \<SystemError\> A system-wide error code if the request * failed for some unexpected reason. */ { TPckg<TVpnPolicyId> pckgPolicyId(aPolicyId); TPckg<TVpnPolicyDetails> pckgPolicyDetails(aPolicyDetails); return SendReceive(EVpnGetPolicyDetails, TIpcArgs(&pckgPolicyId, &pckgPolicyDetails)); }
EXPORT_C TInt RVpnServ::DeletePolicy(const TVpnPolicyId& aPolicyId) /** * Deletes the specified policy from the VPN policy store * maintained by the VPN Manager. * * NOTE. The policy is deleted even if its active. * * @param aPolicyId The ID of the policy to delete * * @return KErrNone, if the request was processed successfully; * KVpnErrPolicyNotFound, if the policy was not found; * \<SystemError\> A system-wide error code if the request * failed for some unexpected reason. */ { TPckg<TVpnPolicyId> pckgPolicyId(aPolicyId); return SendReceive(EVpnDeletePolicy, TIpcArgs(&pckgPolicyId)); }
// ----------------------------------------------------------------------------- // RDRMRightsClient::AddRecord // Add a new entry to the rights database. // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::AddRecord( const TDesC8& aCEK, // Content encryption key // The rights object which is to be added const CDRMPermission& aRightsObject, const TDesC8& aCID, // Content-ID TDRMUniqueID& aID ) // Unique ID, out-parameter { DRMLOG( _L( "RDRMRightsClient::AddRecord" ) ); TInt error = KErrArgument; // Check the parameters. if ( aCEK.Length() ) { HBufC8* rightsData = NULL; TRAP( error, rightsData = aRightsObject.ExportL() ); TInt size = aRightsObject.Size(); if ( rightsData && size > 0 ) { // For C/S communications. TPtr8 rightsObject( NULL, 0 ); TPtr8 uid( reinterpret_cast< TUint8* >( &aID ), 0, sizeof( TDRMUniqueID ) ); rightsObject.Set( const_cast< TUint8* >( rightsData->Ptr() ), size, size ); // Send the message. error = SendReceive( DRMEngine::EAddRecord, TIpcArgs( &aCID, &rightsObject, &aCEK, &uid ) ); delete rightsData; rightsData = NULL; } } DRMLOG2( _L( "RDRMRightsClient::AddRecord: %d" ), error ); return error; }
// ----------------------------------------------------------------------------- // RDRMRightsClient::DeleteDbEntry // Delete a single rights object identified by given parameters. // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::DeleteDbEntry( const TDesC8& aContentID, const TDRMUniqueID& aUniqueID ) { DRMLOG( _L( "RDRMRightsClient::DeleteDbEntry with CID & UID" ) ); if ( aContentID.Length() ) { // Something to do. // Put aUniqueID inside a descriptor. // Works even if its typedef is changed. TPtrC8 uid( reinterpret_cast< TUint8* >( const_cast< TDRMUniqueID* >( &aUniqueID ) ), sizeof( TDRMUniqueID ) ); return SendReceive( DRMEngine::EDeleteRO, TIpcArgs( &uid, NULL, NULL, &aContentID ) ); } return KErrArgument; }
// --------------------------------------------------------------------------- // Grant access // --------------------------------------------------------------------------- // EXPORT_C TInt RAlfClientBase::GrantAccessToPrivateFile( const RFile& aFile, TInt aObjectIdentfier, TInt aCommandId ) { if (!iEnv || !iEnv->TokenClient()) { return KErrNotReady; } TInt64 token = 0; TPckg<TInt64> tokenBuf(token); TInt err = iEnv->TokenClient()->GenerateToken(aFile, TUid::Uid(KAlfAppServerInterfaceUid3), tokenBuf); if (!err) { err = SendReceive(EAlfDoSubSessionCmd, TIpcArgs(aCommandId,&tokenBuf,&tokenBuf,aObjectIdentfier)); } return err; }
// ----------------------------------------------------------------------------- // RDRMHelper::SetAutomated // // Register one content uri to the helper server // ----------------------------------------------------------------------------- // TInt RDRMHelper::SetAutomated( const TDesC8& aUri, TBool aActive, TInt aAutomatedType, TInt aIntent ) const { TInt mode = aActive ? CDRMHelperServer::EActive : CDRMHelperServer::EPassive; // Create descriptor to enable copying data between // client and server. Note: This can be local since // this is a synchronous call. // Note : Using TPtr8 since this is binary information TPtrC8 descriptor( aUri ); // This call waits for the server to complete the request before // proceeding. return SendReceive( ERegister, TIpcArgs( aIntent, mode, aAutomatedType, &descriptor ) ); }
// ----------------------------------------------------------------------------- // RRoapStorageClient::SelectTrustedRootL() // ----------------------------------------------------------------------------- // EXPORT_C TInt Roap::RRoapStorageClient::SelectTrustedRootL( const RPointerArray<HBufC8>& aTrustedRoots, TDes8& aSelectedRoot ) const { TInt ret = KErrNone; if ( aTrustedRoots.Count() ) { HBufC8* rootsBuf = NULL; rootsBuf = ArrayToBufferLC( aTrustedRoots ); ret = SendReceive( Roap::ESelectRoot, TIpcArgs( rootsBuf, &aSelectedRoot ) ); CleanupStack::PopAndDestroy( rootsBuf ); return ret; } return KErrArgument; }
// ============================================================================ // RCwrtRegistryClientSession::DeRegisterWidgetL() // Deregister the widget // // ============================================================================ EXPORT_C bool RWACRegistryClientSession::DeRegisterWidgetL( const QString& appId, bool update ) { CBufFlat* buf = CBufFlat::NewL( 5120 ); CleanupStack::PushL( buf ); RBufWriteStream stream( *buf ); CleanupClosePushL( stream ); SerializeStringL( stream, appId ); SerializeBoolL( stream, update ); CleanupStack::PopAndDestroy( &stream ); TPtr8 p( buf->Ptr(0) ); bool ret = SendReceive( EOpCodeRegisterWidget, TIpcArgs( &p ) ); CleanupStack::PopAndDestroy( buf ); return ret; }
void CMtfTestActionSendEMsvDeleteAttachment::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionSendEMsvDeleteAttachment); // input params TMsvId entryId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(0) ); HBufC* fileName = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(1) ); TInt pass = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(2) ); RProxyServerSession RPSS; // Will auto start the server if not started. TInt error = RPSS.Connect(); CleanupClosePushL(RPSS); if (error!=KErrNone) { TestCase().ERR_PRINTF1(_L("CMtfTestActionSendEMsvDeleteAttachment :: Unable to start proxy server. !")); TestCase().SetTestStepResult(EFail); } else { TInt32 serverCaps; RPSS.GetServerCapabilities(serverCaps); TestCase().INFO_PRINTF2(_L("Proxy Server has capabilities: %x"), serverCaps); error = 0; TPtr pFileName = fileName->Des(); error=RPSS.SendReceive(EMsvDeleteAttachment , TIpcArgs(entryId, &pFileName)); IPCCommandReportPassOrFailForCapsPermissions( TestCase(), KMsvServerName, error , pass ); } CleanupStack::Check(&RPSS); CleanupStack::PopAndDestroy(); // RPSS TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionSendEMsvDeleteAttachment); TestCase().ActionCompletedL(*this); }
/** Function : ExecuteActionL Description : Entry point for the this test action in the test framework @internalTechnology @param : none @return : void @pre none @post none */ void CMtfTestActionSendEMsvStopService::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionSendEMsvStopService); // for this test action we need a pending operation on the MTM // we will create a spurious imap4 disconnect operation TMsvId serviceId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(0)); CImap4ClientMtm* paramMtm = ObtainParameterReferenceL<CImap4ClientMtm>(TestCase(),ActionParameters().Parameter(1)); TInt pass = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(2) ); CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection; CleanupStack::PushL( selection ); selection->AppendL( serviceId ); TBuf8<1> param; CMsvOperation* operation = paramMtm->InvokeAsyncFunctionL(KIMAP4MTMDisconnect,*selection,param,iStatus); CleanupStack::PushL( operation ); RProxyServerSession RPSS; TInt error = RPSS.Connect(); if (error!=KErrNone) { TestCase().ERR_PRINTF1(_L("CMtfTestActionSendEMsvStopService :: Unable to start proxy server. !")); TestCase().SetTestStepResult(EFail); } else { TInt32 serverCaps; RPSS.GetServerCapabilities(serverCaps); TestCase().INFO_PRINTF2(_L("Proxy Server has capabilities: %x"), serverCaps); error = 0; error=RPSS.SendReceive(EMsvStopService , TIpcArgs( serviceId ) ); IPCCommandReportPassOrFailForCapsPermissions( TestCase(), KMsvServerName, error , pass ); } CleanupStack::PopAndDestroy( 2, selection ); TestCase().INFO_PRINTF2(_L(" (<: Test Action %S completed :>) "), &KTestActionSendEMsvStopService ); TestCase().ActionCompletedL(*this); }
EXPORT_C void RMemSpySession::GetThreadInfoItemsL( RArray<CMemSpyApiThreadInfoItem*> &aInfoItems, TThreadId aId, TMemSpyThreadInfoItemType aType ) { TPckgBuf<TThreadId> id( aId ); TPckgBuf<TMemSpyThreadInfoItemType> type( aType ); TPckgBuf<TInt> count; TInt error = SendReceive( EMemSpyClientServerOpGetThreadInfoItemsCount, TIpcArgs( &id, &type, &count ) ); TInt itemCount = count(); if( error == KErrNone ) { if( itemCount == 0 ) { aInfoItems.Reset(); } else { HBufC8* buffer = HBufC8::NewLC( itemCount * sizeof(TMemSpyThreadInfoItemData) ); TPtr8 bufferPtr(buffer->Des()); TPckgBuf<TInt> requestedCount( itemCount ); TIpcArgs args( &requestedCount, &id, &type, &bufferPtr ); TInt error = SendReceive( EMemSpyClientServerOpGetThreadInfoItems, args ); // TODO check error aInfoItems.Reset(); for(TInt i=0, offset = 0; i < itemCount; i++, offset+=sizeof(TMemSpyThreadInfoItemData)) { TPckgBuf<TMemSpyThreadInfoItemData> data; data.Copy(bufferPtr.Ptr()+offset, sizeof(TMemSpyThreadInfoItemData)); aInfoItems.AppendL(CMemSpyApiThreadInfoItem::NewLC(data())); } CleanupStack::Pop(aInfoItems.Count()); CleanupStack::PopAndDestroy(buffer); } } User::LeaveIfError(error); }
/* Exec_SendReceive(): This Fn is called by the Child Thread 1. Create a session with the server 2. Test an SendReceive call 3. Informs the main thread about the status of the call using a. iSessionCreated, if the a connection is established b. iResult_Server, holds the return value for connection c. iResult_SR, the return value of SendReceive call */ TInt CERollbackDbTransaction1Step::Exec_SendReceive() { iResult_Server = CreateSession(SR_ServerName,Version(),2); if (iResult_Server!=KErrNone) { iResult_Server=StartServer(); if (iResult_Server!=KErrNone) return(iResult_Server); iResult_Server = CreateSession(SR_ServerName,TVersion(),2); } if(iResult_Server == 0) { iSessionCreated = ETrue; if(SR_MESSAGE_ID >= 0) iResult_SR = SendReceive(SR_MESSAGE_ID,TIpcArgs(0,0,0,0)); } return iResult_Server; }
//------------------------------------------------------------------------------------------------------ // testing // ESSProtocolInfoByName //------------------------------------------------------------------------------------------------------ TInt CPARAM_MESS_NAMEStep::do_execute(Int2Type<ESSProtocolInfoByName>) { TInt result; //-- 1. Create and start a connection. result = CreateConnection(); if(result != KErrNone) return result; const TDesC& protName = _L("tcp"); TProtocolDesc protoInfo; TPckg<TProtocolDesc> protDesc(protoInfo); result = SendReceive(ESSProtocolInfoByName,TIpcArgs(&protDesc,&protName,0,iSSRes)); if(result != KErrNone) return result; //-- stop and close connection StopCloseConnection(); return KErrNone; }
// --------------------------------------------------------------------------- // Give MIME types supported by this Module // --------------------------------------------------------------------------- // RPointerArray<TDataType> RCatalogsPCConnectivityClient:: SupportedMimeTypesL() { RPointerArray<TDataType> supportedMIMEs; TBool isThereMore = ETrue; TPckgBuf<TBool> pckgIsThereMore; TDataType* tempMIME = 0; TPckgBuf<TDataType> pckgMIME; while( isThereMore ) { User::LeaveIfError( SendReceive( ECatalogsPCConnectivitySupportedMimeTypes, TIpcArgs( &pckgMIME, &pckgIsThereMore ) ) ); isThereMore = pckgIsThereMore(); tempMIME = new( ELeave ) TDataType( pckgMIME() ); User::LeaveIfError( supportedMIMEs.Append( tempMIME ) ); } return supportedMIMEs; }
//------------------------------------------------------------ // RCntParserServer::TotalNumberOfContacts() //------------------------------------------------------------ EXPORT_C TInt RCntParserServer::TotalNumberOfContacts() { LOGGER_ENTERFN( "RCntParserServer::TotalNumberOfContacts()" ); TInt res = KErrNone; if( iConnected == ECntParserConnected ) { TPckgBuf<TInt> pckg; res = SendReceive(ECntParserServerTotalNumOfContacts,TIpcArgs(&pckg)); if( res == KErrNone) { res = pckg(); } } else { res = KErrNotReady; } LOGGER_WRITE_1( "RCntParserServer::TotalNumberOfContacts() : return %d", res ); return res; }
EXPORT_C TInt RVpnServ::UpdatePolicyData(const TVpnPolicyId& aPolicyId, const TDesC8& aPolicyData) /** * Updates the data of the specified VPN policy. If a policy with the * specified ID cannot be found, the method returns the * KVpnErrPolicyNotFound error code. If the policy ID or data argument * is empty, the method returns the KErrArgument error code. * * @param aPolicyId The ID of the policy to update * @param aPolicyData The policy data * * @return KErrNone, if the update was successful; * \<VpnError\> A VPN error code if the update fails for some * identified reason; * \<SystemError\> A system-wide error code if an out-of-resource * error occurred while processing the request. */ { TPckg<TVpnPolicyId> pckgPolicyId(aPolicyId); return SendReceive(EVpnUpdatePolicyData, TIpcArgs(&pckgPolicyId, &aPolicyData)); }
//------------------------------------------------------------------------------------------------------ // testing // ESSProtocolInfo //------------------------------------------------------------------------------------------------------ TInt CPARAM_MESS_NAMEStep::do_execute(Int2Type<ESSProtocolInfo>) { TInt result; //-- 1. Create and start a connection. result = CreateConnection(); if(result != KErrNone) return result; TUint index=1; TProtocolDesc protoInfo; TPckg<TProtocolDesc> protDesc(protoInfo); result = SendReceive(ESSProtocolInfo,TIpcArgs(&protDesc,index,0,iSSRes)); if(result != KErrNone) return result; //-- stop and close connection StopCloseConnection(); return KErrNone; }
//------------------------------------------------------------ // RCntParserServer::Disconnect() //------------------------------------------------------------ EXPORT_C TInt RCntParserServer::Disconnect() { LOGGER_ENTERFN( "RCntParserServer::Disconnect()" ); TInt res = KErrNone; if(iConnected==ECntParserConnected) { res = SendReceive( ECntParserServerDisconnect, TIpcArgs(NULL) ); if( res == KErrNone ) { iConnected = ECntParserNotConnected; RSessionBase::Close(); } } else { res = KErrCouldNotDisconnect; } LOGGER_WRITE_1( "RCntParserServer::CreateIrMCL2PhoneBook() : return %d", res ); return res; }
//------------------------------------------------------------------------------------------------------ // testing // ESSNumProtocols //------------------------------------------------------------------------------------------------------ TInt CPARAM_MESS_NAMEStep::do_execute(Int2Type<ESSNumProtocols>) { TInt result; //-- 1. Create and start a connection. result = CreateConnection(); if(result != KErrNone) return result; TUint count; TPtr8 n((TUint8 *)&count,sizeof(count)); result = SendReceive(ESSNumProtocols,TIpcArgs(&n,0,0,iSSRes)); if(result != KErrNone) return result; //-- stop and close connection StopCloseConnection(); return KErrNone; }
void CheckWentInStoreL(CMtfTestCase& aTestCase, const TDesC& aTestName, RProxyServerSession& RPSS , TMsvId id, TMsvEntryForward& entry , TMsvOp& operationId ) { HBufC8* iBuffer = HBufC8::NewLC(KMsvSessionBufferLength); TPtr8 ptr=iBuffer->Des(); TMsvEntryForward entryStore=entry; entryStore.SetId(id); entryStore.iDetails.Set( KNewAddress1 ); TMsvId aService(0); TPckg<TMsvId> service(aService); operationId++; TInt error = RPSS.SendReceive(EMsvGetEntry,TIpcArgs(entryStore.Id(),&ptr,&service)); if (error!=KErrNone) { aTestCase.ERR_PRINTF2(_L("%S :: PROBLEM :: Unable to read the message back.") , &aTestName ); User::LeaveIfError(error); } TMsvPackedEntry packedEntry(iBuffer); packedEntry.UnpackEntry(entryStore); if ( entryStore.iDetails == KNewAddress1 ) { aTestCase.ERR_PRINTF2(_L("%S :: PROBLEM :: Message was not modified in the store.") , &aTestName ); User::LeaveIfError(error); } else { //RDebug::Printf( " CheckWentInStoreL :: WORKS!!!!!!!!!!!!!!!!!!!!!!!!\n" ); //????? } CleanupStack::Check(iBuffer); CleanupStack::PopAndDestroy(); }
/* Exec_SendReceive(): This Fn is called by the Child Thread 1. Create a session with the server 2. Test an SendReceive call 3. Informs the main thread about the status of the call using a. iSessionCreated, if the a connection is established b. iResult_Server, holds the return value for connection c. iResult_SR, the return value of SendReceive call */ TInt CESipItcTerminateDialogRefresh1Step::Exec_SendReceive() { iResult_Server = CreateSession(SR_ServerName,Version(),2); if (iResult_Server!=KErrNone) { iResult_Server=StartServer(); if (iResult_Server!=KErrNone) return(iResult_Server); iResult_Server = CreateSession(SR_ServerName,TVersion(),2); } if(iResult_Server == 0) { iSessionCreated = ETrue; if(SR_MESSAGE_ID >= 0) iResult_SR = SendReceive(SR_MESSAGE_ID,TIpcArgs(0,0,0,0)); } return iResult_Server; }
/* Exec_SendReceive(): This Fn is called by the Child Thread 1. Create a session with the server 2. Test an SendReceive call 3. Informs the main thread about the status of the call using a. iSessionCreated, if the a connection is established b. iResult_Server, holds the return value for connection c. iResult_SR, the return value of SendReceive call */ TInt CECntGetSortPluginUidFromServer1Step::Exec_SendReceive() { iResult_Server = CreateSession(SR_ServerName,Version(),2); if (iResult_Server!=KErrNone) { iResult_Server=StartServer(); if (iResult_Server!=KErrNone) return(iResult_Server); iResult_Server = CreateSession(SR_ServerName,TVersion(),2); } if(iResult_Server == 0) { iSessionCreated = ETrue; if(SR_MESSAGE_ID >= 0) iResult_SR = SendReceive(SR_MESSAGE_ID,TIpcArgs(0,0,0,0)); } return iResult_Server; }
/* Exec_SendReceive(): This Fn is called by the Child Thread 1. Create a session with the server 2. Test an SendReceive call 3. Informs the main thread about the status of the call using a. iSessionCreated, if the a connection is established b. iResult_Server, holds the return value for connection c. iResult_SR, the return value of SendReceive call */ TInt CECntViewSortOrderExternalizedSize1Step::Exec_SendReceive() { iResult_Server = CreateSession(SR_ServerName,Version(),2); if (iResult_Server!=KErrNone) { iResult_Server=StartServer(); if (iResult_Server!=KErrNone) return(iResult_Server); iResult_Server = CreateSession(SR_ServerName,TVersion(),2); } if(iResult_Server == 0) { iSessionCreated = ETrue; if(SR_MESSAGE_ID >= 0) iResult_SR = SendReceive(SR_MESSAGE_ID,TIpcArgs(0,0,0,0)); } return iResult_Server; }
// --------------------------------------------------------------------------- // RContentManager::Cancel // --------------------------------------------------------------------------- EXPORT_C void RContentManager::Cancel() { LOG(_L("[Cm Server]\t RContentManager::Cancel\n")); // iCanceled is set ETrue if user is closing the application // We don't want to cancel asynchronous process TRACE(Print(_L("[Cm Server]\t RContentManager::Cancel value is %d\n"), iCanceled)); if ( !iCanceled ) { SendReceive( ECmCancel, TIpcArgs() ); } if ( iAo ) { iAo->Deque(); delete iAo; iAo = NULL; } LOG(_L("[Cm Server]\t RContentManager::Cancel end\n")); }