1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // susemergencycallrfadaptationref.cpp

    15 // 

    16 //

    17 

    18 #include <e32debug.h>

    19 #include <ssm/ssmadaptation.h>

    20 #include "susemergencycallrfadaptation.h"

    21 

    22 

    23 /**

    24  * Function used to cleanup the CAdaptationMessage object which is pushed to cleanup stack incase of Leave

    25  * CAdaptationMessage message will be freed back to reserved heap incase of it is created using reserved heap.

    26  * or else message will be deleted.

    27  */

    28 static void DoCleanUp(TAny* aAdaptationMessage)

    29     {

    30     TStoreAdaptationMessage* storeMessage = static_cast <TStoreAdaptationMessage*>(aAdaptationMessage);

    31     if(storeMessage->iAdaptationMessage->iUsingReservedHeap)

    32         {

    33         storeMessage->iReservedHeap->Free(storeMessage->iAdaptationMessage);

    34         }

    35     else

    36         {

    37         delete storeMessage->iAdaptationMessage;

    38         }

    39     }

    40 

    41 /**

    42 @publishedPartner

    43 */

    44 void CEmergencyCallRfAdaptation::SubmitOrQueueL(const RMessage2 &aMessage)

    45 	{

    46 	CAdaptationMessage *messageCopy = NULL;	

    47 	TRAPD(err , messageCopy = new(ELeave) CAdaptationMessage(aMessage));

    48 	//Use preallocated heap for creating CAdaptationMessage under OOM condition, if it is a priority client

    49     if (KErrNoMemory == err && aMessage.Session() == iPriorityClientSession)

    50         {

    51         DEBUGPRINT1A("CAdaptationMessage will be created using Reserved Heap");

    52         TAny* messagePtr = iReservedHeap->AllocL(sizeof(CAdaptationMessage));

    53         messageCopy = new (messagePtr)CAdaptationMessage(aMessage);

    54         messageCopy->iUsingReservedHeap = ETrue;

    55         }

    56     else

    57         {

    58         User::LeaveIfError(err);

    59         }

    60 	  

    61 	if(!IsActive())

    62 		{

    63 		Submit(messageCopy);

    64 		}

    65 	else 

    66 		{

    67 		//Store the CAdaptationMessage pointer and iReservedHeap in a struct inorder to cleanup 

    68 		//depending on the reserved heap/normal heap used.

    69 		TStoreAdaptationMessage storeMessage;

    70 		storeMessage.iAdaptationMessage = messageCopy;

    71 		storeMessage.iReservedHeap = iReservedHeap;

    72 		CleanupStack::PushL(TCleanupItem(DoCleanUp, &storeMessage ));

    73 		DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests queueing request with function id: %d", aMessage.Function());

    74 		//Reserve heap only in non OOM condition

    75 		if(messageCopy->iUsingReservedHeap == EFalse)

    76 		    {

    77 		    //Always reserve 2 slots in queue for Emergency call requests. Slots will be reserved if count

    78 		    //to request memory(RPointerArray.Reserve(count)) is greater than the existing reserved memory in

    79 		    //RPonterArray. So there will be memory allocation only when

    80 		    //iPendingRequestsQueue.Count()+ reserveCount + 1(for the present message))

    81 		    // > already reserved memory.

    82 		    const TInt reserveCount = 2;

    83 		    err = iPendingRequestsQueue.Reserve(iPendingRequestsQueue.Count() + reserveCount + 1 );

    84 		    }

    85 		if(KErrNone == err || (KErrNoMemory == err && aMessage.Session() == iPriorityClientSession))

    86 		    {	 

    87 		    User::LeaveIfError(iPendingRequestsQueue.Queue(messageCopy));

    88 		    }

    89 		else

    90 		    {

    91 		    User::Leave(err);

    92 		    }

    93 		CleanupStack::Pop(&storeMessage);

    94 		}	

    95 	}

    96 

    97 void CEmergencyCallRfAdaptation::Submit(CAdaptationMessage*& aMessage)

    98 	{

    99 	DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests immediate submission of request with function id: %d", aMessage->Function());

   100 	iCurrentMessage = aMessage;

   101 	switch(aMessage->Function())

   102 		{

   103 		case EActivateRfForEmergencyCall :

   104 			{

   105 			iEmergencyCallRfAdaptation.ActivateRfForEmergencyCall(iStatus);

   106 			break;	

   107 			}

   108 		case EDeactivateRfForEmergencyCall :

   109 			{

   110 			iEmergencyCallRfAdaptation.DeactivateRfForEmergencyCall(iStatus);

   111 			break;	

   112 			}

   113 		default :

   114 			{

   115 			break;

   116 			}

   117 		}

   118 	SetActive();

   119 	}

   120 /**

   121 CEmergencyCallRfAdaptation implements EmergencyCallRf Adaptation related functionality as part of 

   122 CSsmAdaptationServer.CSsmAdaptationServer loads EmergencyCallRf Adaptation plugin and creates

   123 CEmergencyCallRfAdaptation using the NewL. From then the loaded EmergencyCallRf Adaptation plugin

   124 will be owned by CEmergencyCallRfAdaptation.

   125 

   126 @internalComponent

   127 */

   128 

   129 CEmergencyCallRfAdaptation* CEmergencyCallRfAdaptation::NewL(MEmergencyCallRfAdaptation& aAdaptation)

   130 	{

   131 	CEmergencyCallRfAdaptation* self = new(ELeave) CEmergencyCallRfAdaptation(aAdaptation);

   132 	return self;	

   133 	}

   134 /**

   135  * Function to reserve memory to make emergency call during OOM condition

   136  */

   137 void CEmergencyCallRfAdaptation :: ReserveMemoryL()

   138     {

   139     //Reserve space for one Activate Rf call + one Deactive Rf message in Queue.

   140     const TInt reserveCount = 2;

   141     // heap requested for one Active Rf call + one Deactive Rf

   142     const TInt reservedHeap = reserveCount * sizeof(CAdaptationMessage);    

   143     //heap is reserved for storing CAdaptationMessage during OOM condition.

   144     iReservedHeap = UserHeap::ChunkHeap(NULL, reservedHeap, reservedHeap); 

   145     //Leave with KErrNoMemory if iReservedHeap is NULL    

   146     if(iReservedHeap == NULL)

   147         {

   148         User::Leave(KErrNoMemory);

   149         }

   150     User::LeaveIfError(iPendingRequestsQueue.Reserve(reserveCount));   

   151     }

   152 

   153 

   154 CEmergencyCallRfAdaptation::~CEmergencyCallRfAdaptation()

   155 	{

   156 	iPendingRequestsQueue.NotifyAndRemoveAll(iReservedHeap);

   157 	Cancel();

   158 	iPendingRequestsQueue.Close();

   159 	if(iReservedHeap != NULL)

   160 	    {

   161         iReservedHeap->Reset();

   162         iReservedHeap->Close();

   163 	    }

   164 	Release();

   165 	}

   166 

   167 CEmergencyCallRfAdaptation::CEmergencyCallRfAdaptation(MEmergencyCallRfAdaptation& aAdaptation) : CActive(EPriorityStandard), iEmergencyCallRfAdaptation(aAdaptation)

   168 , iReservedHeap(NULL)

   169 	{

   170 	CActiveScheduler::Add(this);

   171 	}

   172 

   173 void CEmergencyCallRfAdaptation::Release()

   174 	{

   175 	iEmergencyCallRfAdaptation.Release();

   176 	}

   177 

   178 void CEmergencyCallRfAdaptation::DoActivateRfForEmergencyCallL(const RMessage2& aMessage)

   179 	{

   180 	SubmitOrQueueL(aMessage);	

   181 	}

   182 

   183 void CEmergencyCallRfAdaptation::DoDeactivateRfForEmergencyCallL(const RMessage2& aMessage)

   184 	{

   185 	SubmitOrQueueL(aMessage);	

   186 	}

   187 

   188 void CEmergencyCallRfAdaptation::DoEmergencyCallRfAdaptationCancelL(const RMessage2& aMessage)

   189 	{

   190 

   191 	if(iCurrentMessage != NULL)	

   192 		{

   193 		if(aMessage.Session() == iCurrentMessage->Session())

   194 			{

   195 			DEBUGPRINT1A("CEmergencyCallRfAdaptationRequests cancelling current request as requested");

   196 			iEmergencyCallRfAdaptation.Cancel();

   197 			}

   198 		iPendingRequestsQueue.RemoveFromQueueAndComplete(aMessage, iReservedHeap);

   199 		

   200 		aMessage.Complete(KErrNone);

   201 		}

   202 	else

   203 		{

   204 		DEBUGPRINT1A("CEmergencyCallRfAdaptationRequests nothing to cancel, but cancel requested");

   205 		aMessage.Complete(KErrNone);				

   206 		}		

   207 	}

   208 

   209 

   210 void CEmergencyCallRfAdaptation::RunL()

   211 	{

   212 	

   213 	DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests processed the request with funtion id: %d", iCurrentMessage->Function());

   214 	iCurrentMessage->Complete(iStatus.Int());

   215 	if(iCurrentMessage->iUsingReservedHeap)

   216         {

   217         iReservedHeap->Free(iCurrentMessage);

   218         }

   219     else

   220         {

   221         delete iCurrentMessage;

   222         }

   223 	iCurrentMessage = NULL;  

   224 

   225 	if( (iPendingRequestsQueue.IsEmpty()) == EFalse )

   226 		{

   227 		CAdaptationMessage *messageCopy = NULL;

   228 		iPendingRequestsQueue.Dequeue(messageCopy);		

   229 		Submit(messageCopy);

   230 		} 

   231 	}

   232 

   233 TInt CEmergencyCallRfAdaptation::RunError( TInt aError )

   234 	{

   235 	

   236 	if(iCurrentMessage != NULL)	

   237 		{

   238 		iCurrentMessage->Complete(aError);

   239         if(iCurrentMessage->iUsingReservedHeap)

   240             {

   241             iReservedHeap->Free(iCurrentMessage);

   242             }

   243         else

   244             {

   245             delete iCurrentMessage;

   246             }

   247 		iCurrentMessage = NULL;

   248 		}

   249 	

   250 	while( (iPendingRequestsQueue.IsEmpty()) == EFalse )

   251 		{

   252 		iPendingRequestsQueue.Dequeue(iCurrentMessage);

   253 		iCurrentMessage->Complete(aError);

   254 		if(iCurrentMessage->iUsingReservedHeap)

   255             {

   256             iReservedHeap->Free(iCurrentMessage);

   257             }

   258         else

   259             {

   260             delete iCurrentMessage;

   261             }

   262 		iCurrentMessage = NULL;

   263 		}

   264 	

   265 	return KErrNone;

   266 		

   267 	}

   268 

   269 void CEmergencyCallRfAdaptation::DoCancel()

   270 	{

   271 	if(iCurrentMessage != NULL)	

   272 		{

   273 		iCurrentMessage->Complete(KErrCancel);

   274 		if(iCurrentMessage->iUsingReservedHeap)

   275             {

   276             iReservedHeap->Free(iCurrentMessage);

   277             }

   278         else

   279             {

   280             delete iCurrentMessage;

   281             }

   282 		iCurrentMessage = NULL;

   283 		}

   284 		

   285 	while( (iPendingRequestsQueue.IsEmpty()) == EFalse )

   286 		{

   287 		iPendingRequestsQueue.Dequeue(iCurrentMessage);

   288 		iCurrentMessage->Complete(KErrCancel);

   289 		if(iCurrentMessage->iUsingReservedHeap)

   290             {

   291             iReservedHeap->Free(iCurrentMessage);

   292             }

   293         else

   294             {

   295             delete iCurrentMessage;

   296             }

   297 		iCurrentMessage = NULL;

   298 		}

   299 	}

   300 

   301 /**

   302  * Sets the Priority Client Session

   303  */

   304 void CEmergencyCallRfAdaptation::SetPriorityClientSession(CSsmAdaptationSession* aPriorityClientSession)

   305     {

   306     iPriorityClientSession = aPriorityClientSession;

   307     }

   308 

   309 /**

   310  * Unsets the Priority Client session

   311  */

   312 void CEmergencyCallRfAdaptation::RemovePriorityClientSession()

   313     {

   314     iPriorityClientSession = NULL;

   315     }

   316