--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sysstatemgmt/systemstatemgr/sus/src/susemergencycallrfadaptation.cpp Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,316 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// susemergencycallrfadaptationref.cpp
+//
+//
+
+#include <e32debug.h>
+#include <ssm/ssmadaptation.h>
+#include "susemergencycallrfadaptation.h"
+
+
+/**
+ * Function used to cleanup the CAdaptationMessage object which is pushed to cleanup stack incase of Leave
+ * CAdaptationMessage message will be freed back to reserved heap incase of it is created using reserved heap.
+ * or else message will be deleted.
+ */
+static void DoCleanUp(TAny* aAdaptationMessage)
+ {
+ TStoreAdaptationMessage* storeMessage = static_cast <TStoreAdaptationMessage*>(aAdaptationMessage);
+ if(storeMessage->iAdaptationMessage->iUsingReservedHeap)
+ {
+ storeMessage->iReservedHeap->Free(storeMessage->iAdaptationMessage);
+ }
+ else
+ {
+ delete storeMessage->iAdaptationMessage;
+ }
+ }
+
+/**
+@publishedPartner
+*/
+void CEmergencyCallRfAdaptation::SubmitOrQueueL(const RMessage2 &aMessage)
+ {
+ CAdaptationMessage *messageCopy = NULL;
+ TRAPD(err , messageCopy = new(ELeave) CAdaptationMessage(aMessage));
+ //Use preallocated heap for creating CAdaptationMessage under OOM condition, if it is a priority client
+ if (KErrNoMemory == err && aMessage.Session() == iPriorityClientSession)
+ {
+ DEBUGPRINT1A("CAdaptationMessage will be created using Reserved Heap");
+ TAny* messagePtr = iReservedHeap->AllocL(sizeof(CAdaptationMessage));
+ messageCopy = new (messagePtr)CAdaptationMessage(aMessage);
+ messageCopy->iUsingReservedHeap = ETrue;
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ if(!IsActive())
+ {
+ Submit(messageCopy);
+ }
+ else
+ {
+ //Store the CAdaptationMessage pointer and iReservedHeap in a struct inorder to cleanup
+ //depending on the reserved heap/normal heap used.
+ TStoreAdaptationMessage storeMessage;
+ storeMessage.iAdaptationMessage = messageCopy;
+ storeMessage.iReservedHeap = iReservedHeap;
+ CleanupStack::PushL(TCleanupItem(DoCleanUp, &storeMessage ));
+ DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests queueing request with function id: %d", aMessage.Function());
+ //Reserve heap only in non OOM condition
+ if(messageCopy->iUsingReservedHeap == EFalse)
+ {
+ //Always reserve 2 slots in queue for Emergency call requests. Slots will be reserved if count
+ //to request memory(RPointerArray.Reserve(count)) is greater than the existing reserved memory in
+ //RPonterArray. So there will be memory allocation only when
+ //iPendingRequestsQueue.Count()+ reserveCount + 1(for the present message))
+ // > already reserved memory.
+ const TInt reserveCount = 2;
+ err = iPendingRequestsQueue.Reserve(iPendingRequestsQueue.Count() + reserveCount + 1 );
+ }
+ if(KErrNone == err || (KErrNoMemory == err && aMessage.Session() == iPriorityClientSession))
+ {
+ User::LeaveIfError(iPendingRequestsQueue.Queue(messageCopy));
+ }
+ else
+ {
+ User::Leave(err);
+ }
+ CleanupStack::Pop(&storeMessage);
+ }
+ }
+
+void CEmergencyCallRfAdaptation::Submit(CAdaptationMessage*& aMessage)
+ {
+ DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests immediate submission of request with function id: %d", aMessage->Function());
+ iCurrentMessage = aMessage;
+ switch(aMessage->Function())
+ {
+ case EActivateRfForEmergencyCall :
+ {
+ iEmergencyCallRfAdaptation.ActivateRfForEmergencyCall(iStatus);
+ break;
+ }
+ case EDeactivateRfForEmergencyCall :
+ {
+ iEmergencyCallRfAdaptation.DeactivateRfForEmergencyCall(iStatus);
+ break;
+ }
+ default :
+ {
+ break;
+ }
+ }
+ SetActive();
+ }
+/**
+CEmergencyCallRfAdaptation implements EmergencyCallRf Adaptation related functionality as part of
+CSsmAdaptationServer.CSsmAdaptationServer loads EmergencyCallRf Adaptation plugin and creates
+CEmergencyCallRfAdaptation using the NewL. From then the loaded EmergencyCallRf Adaptation plugin
+will be owned by CEmergencyCallRfAdaptation.
+
+@internalComponent
+*/
+
+CEmergencyCallRfAdaptation* CEmergencyCallRfAdaptation::NewL(MEmergencyCallRfAdaptation& aAdaptation)
+ {
+ CEmergencyCallRfAdaptation* self = new(ELeave) CEmergencyCallRfAdaptation(aAdaptation);
+ return self;
+ }
+/**
+ * Function to reserve memory to make emergency call during OOM condition
+ */
+void CEmergencyCallRfAdaptation :: ReserveMemoryL()
+ {
+ //Reserve space for one Activate Rf call + one Deactive Rf message in Queue.
+ const TInt reserveCount = 2;
+ // heap requested for one Active Rf call + one Deactive Rf
+ const TInt reservedHeap = reserveCount * sizeof(CAdaptationMessage);
+ //heap is reserved for storing CAdaptationMessage during OOM condition.
+ iReservedHeap = UserHeap::ChunkHeap(NULL, reservedHeap, reservedHeap);
+ //Leave with KErrNoMemory if iReservedHeap is NULL
+ if(iReservedHeap == NULL)
+ {
+ User::Leave(KErrNoMemory);
+ }
+ User::LeaveIfError(iPendingRequestsQueue.Reserve(reserveCount));
+ }
+
+
+CEmergencyCallRfAdaptation::~CEmergencyCallRfAdaptation()
+ {
+ iPendingRequestsQueue.NotifyAndRemoveAll(iReservedHeap);
+ Cancel();
+ iPendingRequestsQueue.Close();
+ if(iReservedHeap != NULL)
+ {
+ iReservedHeap->Reset();
+ iReservedHeap->Close();
+ }
+ Release();
+ }
+
+CEmergencyCallRfAdaptation::CEmergencyCallRfAdaptation(MEmergencyCallRfAdaptation& aAdaptation) : CActive(EPriorityStandard), iEmergencyCallRfAdaptation(aAdaptation)
+, iReservedHeap(NULL)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+void CEmergencyCallRfAdaptation::Release()
+ {
+ iEmergencyCallRfAdaptation.Release();
+ }
+
+void CEmergencyCallRfAdaptation::DoActivateRfForEmergencyCallL(const RMessage2& aMessage)
+ {
+ SubmitOrQueueL(aMessage);
+ }
+
+void CEmergencyCallRfAdaptation::DoDeactivateRfForEmergencyCallL(const RMessage2& aMessage)
+ {
+ SubmitOrQueueL(aMessage);
+ }
+
+void CEmergencyCallRfAdaptation::DoEmergencyCallRfAdaptationCancelL(const RMessage2& aMessage)
+ {
+
+ if(iCurrentMessage != NULL)
+ {
+ if(aMessage.Session() == iCurrentMessage->Session())
+ {
+ DEBUGPRINT1A("CEmergencyCallRfAdaptationRequests cancelling current request as requested");
+ iEmergencyCallRfAdaptation.Cancel();
+ }
+ iPendingRequestsQueue.RemoveFromQueueAndComplete(aMessage, iReservedHeap);
+
+ aMessage.Complete(KErrNone);
+ }
+ else
+ {
+ DEBUGPRINT1A("CEmergencyCallRfAdaptationRequests nothing to cancel, but cancel requested");
+ aMessage.Complete(KErrNone);
+ }
+ }
+
+
+void CEmergencyCallRfAdaptation::RunL()
+ {
+
+ DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests processed the request with funtion id: %d", iCurrentMessage->Function());
+ iCurrentMessage->Complete(iStatus.Int());
+ if(iCurrentMessage->iUsingReservedHeap)
+ {
+ iReservedHeap->Free(iCurrentMessage);
+ }
+ else
+ {
+ delete iCurrentMessage;
+ }
+ iCurrentMessage = NULL;
+
+ if( (iPendingRequestsQueue.IsEmpty()) == EFalse )
+ {
+ CAdaptationMessage *messageCopy = NULL;
+ iPendingRequestsQueue.Dequeue(messageCopy);
+ Submit(messageCopy);
+ }
+ }
+
+TInt CEmergencyCallRfAdaptation::RunError( TInt aError )
+ {
+
+ if(iCurrentMessage != NULL)
+ {
+ iCurrentMessage->Complete(aError);
+ if(iCurrentMessage->iUsingReservedHeap)
+ {
+ iReservedHeap->Free(iCurrentMessage);
+ }
+ else
+ {
+ delete iCurrentMessage;
+ }
+ iCurrentMessage = NULL;
+ }
+
+ while( (iPendingRequestsQueue.IsEmpty()) == EFalse )
+ {
+ iPendingRequestsQueue.Dequeue(iCurrentMessage);
+ iCurrentMessage->Complete(aError);
+ if(iCurrentMessage->iUsingReservedHeap)
+ {
+ iReservedHeap->Free(iCurrentMessage);
+ }
+ else
+ {
+ delete iCurrentMessage;
+ }
+ iCurrentMessage = NULL;
+ }
+
+ return KErrNone;
+
+ }
+
+void CEmergencyCallRfAdaptation::DoCancel()
+ {
+ if(iCurrentMessage != NULL)
+ {
+ iCurrentMessage->Complete(KErrCancel);
+ if(iCurrentMessage->iUsingReservedHeap)
+ {
+ iReservedHeap->Free(iCurrentMessage);
+ }
+ else
+ {
+ delete iCurrentMessage;
+ }
+ iCurrentMessage = NULL;
+ }
+
+ while( (iPendingRequestsQueue.IsEmpty()) == EFalse )
+ {
+ iPendingRequestsQueue.Dequeue(iCurrentMessage);
+ iCurrentMessage->Complete(KErrCancel);
+ if(iCurrentMessage->iUsingReservedHeap)
+ {
+ iReservedHeap->Free(iCurrentMessage);
+ }
+ else
+ {
+ delete iCurrentMessage;
+ }
+ iCurrentMessage = NULL;
+ }
+ }
+
+/**
+ * Sets the Priority Client Session
+ */
+void CEmergencyCallRfAdaptation::SetPriorityClientSession(CSsmAdaptationSession* aPriorityClientSession)
+ {
+ iPriorityClientSession = aPriorityClientSession;
+ }
+
+/**
+ * Unsets the Priority Client session
+ */
+void CEmergencyCallRfAdaptation::RemovePriorityClientSession()
+ {
+ iPriorityClientSession = NULL;
+ }
+