16 // |
16 // |
17 |
17 |
18 #include <e32debug.h> |
18 #include <e32debug.h> |
19 #include <ssm/ssmadaptation.h> |
19 #include <ssm/ssmadaptation.h> |
20 #include "susemergencycallrfadaptation.h" |
20 #include "susemergencycallrfadaptation.h" |
21 |
21 #include "suspanic.h" |
22 |
22 |
23 /** |
23 |
24 * Function used to cleanup the CAdaptationMessage object which is pushed to cleanup stack incase of Leave |
24 //Count to reserve space for one Activate Rf call + one Deactive Rf message in Queue |
25 * CAdaptationMessage message will be freed back to reserved heap incase of it is created using reserved heap. |
25 const TInt KReserveCount = 2; |
|
26 /** |
|
27 * Function used to cleanup the CAdaptationMessage object which is pushed on to the cleanup stack incase of Leave. |
|
28 * CAdaptationMessage message will be reset to hold default values, if it is using the precreated message pointer. |
26 * or else message will be deleted. |
29 * or else message will be deleted. |
27 */ |
30 */ |
28 static void DoCleanUp(TAny* aAdaptationMessage) |
31 static void DoCleanUp(TAny* aAdaptationMessage) |
29 { |
32 { |
30 TStoreAdaptationMessage* storeMessage = static_cast <TStoreAdaptationMessage*>(aAdaptationMessage); |
33 CEmergencyAdaptationMessage* storeAdaptationMessage = static_cast <CEmergencyAdaptationMessage*>(aAdaptationMessage); |
31 if(storeMessage->iAdaptationMessage->iUsingReservedHeap) |
34 storeAdaptationMessage->Complete(KErrNone); |
32 { |
35 if(storeAdaptationMessage->IsMessageReserved()) |
33 storeMessage->iReservedHeap->Free(storeMessage->iAdaptationMessage); |
36 { |
|
37 storeAdaptationMessage->UnsetMessageStatus(EMsgInUse); |
34 } |
38 } |
35 else |
39 else |
36 { |
40 { |
37 delete storeMessage->iAdaptationMessage; |
41 delete storeAdaptationMessage; |
38 } |
42 } |
39 } |
43 } |
40 |
44 |
41 /** |
45 /** |
42 @publishedPartner |
46 @publishedPartner |
43 */ |
47 */ |
44 void CEmergencyCallRfAdaptation::SubmitOrQueueL(const RMessage2 &aMessage) |
48 void CEmergencyCallRfAdaptation::SubmitOrQueueL(const RMessage2 &aMessage) |
45 { |
49 { |
46 CAdaptationMessage *messageCopy = NULL; |
50 CEmergencyAdaptationMessage *storeAdaptationMessage = NULL; |
47 TRAPD(err , messageCopy = new(ELeave) CAdaptationMessage(aMessage)); |
51 TRAPD(err, storeAdaptationMessage = CEmergencyAdaptationMessage::NewL(aMessage)); |
48 //Use preallocated heap for creating CAdaptationMessage under OOM condition, if it is a priority client |
52 |
|
53 //Allow only priority client to perform emergency call. |
49 if (KErrNoMemory == err && aMessage.Session() == iPriorityClientSession) |
54 if (KErrNoMemory == err && aMessage.Session() == iPriorityClientSession) |
50 { |
55 { |
51 DEBUGPRINT1A("CAdaptationMessage will be created using Reserved Heap"); |
56 DEBUGPRINT1A("CEmergencyAdaptationMessage will be created using reserved pointers"); |
52 TAny* messagePtr = iReservedHeap->AllocL(sizeof(CAdaptationMessage)); |
57 if ( iReserveMsgCount == 0 ) |
53 messageCopy = new (messagePtr)CAdaptationMessage(aMessage); |
58 { |
54 messageCopy->iUsingReservedHeap = ETrue; |
59 DEBUGPRINT1A("There is no reserved message to perform emergency call"); |
|
60 User::Leave(err); |
|
61 } |
|
62 //Traverse through the reserved message array to look for free message. |
|
63 for ( TInt index = 0 ; index < KReserveCount ; ++index ) |
|
64 { |
|
65 //Use the reserve message, if it is not already used. |
|
66 if (!(iAdaptationReservedMessageArray[index]->IsMessageInuse())) |
|
67 { |
|
68 iAdaptationReservedMessageArray[index]->SetMessage(aMessage); |
|
69 iAdaptationReservedMessageArray[index]->SetMessageStatus(EMsgInUse); |
|
70 storeAdaptationMessage = iAdaptationReservedMessageArray[index]; |
|
71 --iReserveMsgCount; |
|
72 break; |
|
73 } |
|
74 } |
55 } |
75 } |
56 else |
76 else |
57 { |
77 { |
58 User::LeaveIfError(err); |
78 User::LeaveIfError(err); |
59 } |
79 } |
60 |
|
61 if(!IsActive()) |
80 if(!IsActive()) |
62 { |
81 { |
63 Submit(messageCopy); |
82 Submit(storeAdaptationMessage); |
64 } |
83 } |
65 else |
84 else |
66 { |
85 { |
67 //Store the CAdaptationMessage pointer and iReservedHeap in a struct inorder to cleanup |
86 //Push the CEmergencyAdaptationMessage pointer on to the cleanup stack and reset/delete the pointer |
68 //depending on the reserved heap/normal heap used. |
87 //depending on using precreated pointer/new pointer. |
69 TStoreAdaptationMessage storeMessage; |
88 CleanupStack::PushL(TCleanupItem(DoCleanUp, storeAdaptationMessage )); |
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()); |
89 DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests queueing request with function id: %d", aMessage.Function()); |
74 //Reserve heap only in non OOM condition |
90 //Reserve slot only in non OOM condition |
75 if(messageCopy->iUsingReservedHeap == EFalse) |
91 if(!(storeAdaptationMessage->IsMessageReserved())) |
76 { |
92 { |
77 //Always reserve 2 slots in queue for Emergency call requests. Slots will be reserved if count |
93 //Priority clients are allowed to queue only two(KReserveCount) emergengency call request in the OOM condition. |
78 //to request memory(RPointerArray.Reserve(count)) is greater than the existing reserved memory in |
94 //So always request to reserve only iPendingRequestsQueue.Count()+ iReserveMsgCount + 1 |
79 //RPonterArray. So there will be memory allocation only when |
95 //slots. |
80 //iPendingRequestsQueue.Count()+ reserveCount + 1(for the present message)) |
96 //Memory will be only reserved if (iPendingRequestsQueue.Count()+ iReserveMsgCount + 1) > |
81 // > already reserved memory. |
97 //already reserved memory |
82 const TInt reserveCount = 2; |
98 TRAP(err, iPendingEmergencyRequestsQueue.ReserveL(iPendingEmergencyRequestsQueue.Count() + iReserveMsgCount + 1 )); |
83 err = iPendingRequestsQueue.Reserve(iPendingRequestsQueue.Count() + reserveCount + 1 ); |
|
84 } |
99 } |
85 if(KErrNone == err || (KErrNoMemory == err && aMessage.Session() == iPriorityClientSession)) |
100 if(KErrNone == err || (KErrNoMemory == err && aMessage.Session() == iPriorityClientSession)) |
86 { |
101 { |
87 User::LeaveIfError(iPendingRequestsQueue.Queue(messageCopy)); |
102 iPendingEmergencyRequestsQueue.AppendL(storeAdaptationMessage); |
88 } |
103 } |
89 else |
104 else |
90 { |
105 { |
91 User::Leave(err); |
106 User::Leave(err); |
92 } |
107 } |
93 CleanupStack::Pop(&storeMessage); |
108 CleanupStack::Pop(storeAdaptationMessage); |
94 } |
109 } |
95 } |
110 } |
96 |
111 |
97 void CEmergencyCallRfAdaptation::Submit(CAdaptationMessage*& aMessage) |
112 void CEmergencyCallRfAdaptation::Submit(CEmergencyAdaptationMessage*& aMessage) |
98 { |
113 { |
|
114 __ASSERT_ALWAYS((iEmergencyCallRfAdaptation != NULL), User::Panic(KPanicSsmSus, EEmergencyCallRfAdaptationNullPtrError1)); |
99 DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests immediate submission of request with function id: %d", aMessage->Function()); |
115 DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests immediate submission of request with function id: %d", aMessage->Function()); |
100 iCurrentMessage = aMessage; |
116 iCurrentMessage = aMessage; |
101 switch(aMessage->Function()) |
117 switch(aMessage->Function()) |
102 { |
118 { |
103 case EActivateRfForEmergencyCall : |
119 case EActivateRfForEmergencyCall : |
104 { |
120 { |
105 iEmergencyCallRfAdaptation.ActivateRfForEmergencyCall(iStatus); |
121 iEmergencyCallRfAdaptation->ActivateRfForEmergencyCall(iStatus); |
106 break; |
122 break; |
107 } |
123 } |
108 case EDeactivateRfForEmergencyCall : |
124 case EDeactivateRfForEmergencyCall : |
109 { |
125 { |
110 iEmergencyCallRfAdaptation.DeactivateRfForEmergencyCall(iStatus); |
126 iEmergencyCallRfAdaptation->DeactivateRfForEmergencyCall(iStatus); |
111 break; |
127 break; |
112 } |
128 } |
113 default : |
129 default : |
114 { |
130 { |
115 break; |
131 break; |
124 will be owned by CEmergencyCallRfAdaptation. |
140 will be owned by CEmergencyCallRfAdaptation. |
125 |
141 |
126 @internalComponent |
142 @internalComponent |
127 */ |
143 */ |
128 |
144 |
129 CEmergencyCallRfAdaptation* CEmergencyCallRfAdaptation::NewL(MEmergencyCallRfAdaptation& aAdaptation) |
145 CEmergencyCallRfAdaptation* CEmergencyCallRfAdaptation::NewL(MEmergencyCallRfAdaptation* aAdaptation) |
130 { |
146 { |
131 CEmergencyCallRfAdaptation* self = new(ELeave) CEmergencyCallRfAdaptation(aAdaptation); |
147 CEmergencyCallRfAdaptation* self = new(ELeave) CEmergencyCallRfAdaptation(); |
132 return self; |
148 CleanupStack::PushL(self); |
133 } |
149 self->ConstructL(aAdaptation); |
|
150 CleanupStack::Pop(self); |
|
151 return self; |
|
152 } |
|
153 |
|
154 void CEmergencyCallRfAdaptation::ConstructL(MEmergencyCallRfAdaptation* aAdaptation) |
|
155 { |
|
156 ReserveMemoryL(); |
|
157 //Taking the ownership of emergencyCallRfAdaptationPlugin after all the leaving function have passed. |
|
158 //If some function leaves before taking ownership of emergencyCallRfAdaptationPlugin, it will be released twice, which causes system to panic. |
|
159 iEmergencyCallRfAdaptation = aAdaptation; |
|
160 } |
|
161 |
134 /** |
162 /** |
135 * Function to reserve memory to make emergency call during OOM condition |
163 * Function to reserve memory to make emergency call during OOM condition |
136 */ |
164 */ |
137 void CEmergencyCallRfAdaptation :: ReserveMemoryL() |
165 void CEmergencyCallRfAdaptation :: ReserveMemoryL() |
138 { |
166 { |
139 //Reserve space for one Activate Rf call + one Deactive Rf message in Queue. |
167 //Reserve space for one Activate Rf call + one Deactive Rf message in Queue. |
140 const TInt reserveCount = 2; |
168 iPendingEmergencyRequestsQueue.ReserveL(KReserveCount); |
141 // heap requested for one Active Rf call + one Deactive Rf |
169 |
142 const TInt reservedHeap = reserveCount * sizeof(CAdaptationMessage); |
170 //Pre-create an array to hold CEmergencyAdaptationMessage pointer, this is of size CEmergencyAdaptationMessage. |
143 //heap is reserved for storing CAdaptationMessage during OOM condition. |
171 RMessage2 message; |
144 iReservedHeap = UserHeap::ChunkHeap(NULL, reservedHeap, reservedHeap); |
172 for( TInt index = 0 ; index < KReserveCount ; ++index ) |
145 //Leave with KErrNoMemory if iReservedHeap is NULL |
173 { |
146 if(iReservedHeap == NULL) |
174 CEmergencyAdaptationMessage* adaptationMessage = NULL; |
147 { |
175 adaptationMessage = CEmergencyAdaptationMessage::NewL(message, EMsgReserved); |
148 User::Leave(KErrNoMemory); |
176 CleanupStack::PushL(adaptationMessage); |
149 } |
177 iAdaptationReservedMessageArray.AppendL(adaptationMessage); |
150 User::LeaveIfError(iPendingRequestsQueue.Reserve(reserveCount)); |
178 CleanupStack::Pop(adaptationMessage); |
151 } |
179 } |
152 |
180 } |
153 |
181 |
154 CEmergencyCallRfAdaptation::~CEmergencyCallRfAdaptation() |
182 CEmergencyCallRfAdaptation::~CEmergencyCallRfAdaptation() |
155 { |
183 { |
156 iPendingRequestsQueue.NotifyAndRemoveAll(iReservedHeap); |
184 NotifyAndRemoveAll(); |
157 Cancel(); |
185 Cancel(); |
158 iPendingRequestsQueue.Close(); |
186 iPendingEmergencyRequestsQueue.Close(); |
159 if(iReservedHeap != NULL) |
187 iAdaptationReservedMessageArray.ResetAndDestroy(); |
|
188 Release(); |
|
189 } |
|
190 |
|
191 void CEmergencyCallRfAdaptation::NotifyAndRemoveAll() |
|
192 { |
|
193 TInt count = iPendingEmergencyRequestsQueue.Count(); |
|
194 |
|
195 for(TInt index =0; index < count; ++index) |
|
196 { |
|
197 iPendingEmergencyRequestsQueue[index]->Complete(KErrServerTerminated); |
|
198 if (!(iPendingEmergencyRequestsQueue[index]->IsMessageReserved())) |
|
199 { |
|
200 delete iPendingEmergencyRequestsQueue[index]; |
|
201 } |
|
202 iPendingEmergencyRequestsQueue[index] = NULL; |
|
203 } |
|
204 iPendingEmergencyRequestsQueue.Reset(); |
|
205 } |
|
206 |
|
207 CEmergencyCallRfAdaptation::CEmergencyCallRfAdaptation() : CActive(EPriorityStandard) |
|
208 ,iReserveMsgCount(KReserveCount) |
|
209 { |
|
210 CActiveScheduler::Add(this); |
|
211 } |
|
212 |
|
213 void CEmergencyCallRfAdaptation::Release() |
|
214 { |
|
215 if(iEmergencyCallRfAdaptation != NULL) |
160 { |
216 { |
161 iReservedHeap->Reset(); |
217 iEmergencyCallRfAdaptation->Release(); |
162 iReservedHeap->Close(); |
|
163 } |
218 } |
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 } |
219 } |
177 |
220 |
178 void CEmergencyCallRfAdaptation::DoActivateRfForEmergencyCallL(const RMessage2& aMessage) |
221 void CEmergencyCallRfAdaptation::DoActivateRfForEmergencyCallL(const RMessage2& aMessage) |
179 { |
222 { |
180 SubmitOrQueueL(aMessage); |
223 SubmitOrQueueL(aMessage); |
185 SubmitOrQueueL(aMessage); |
228 SubmitOrQueueL(aMessage); |
186 } |
229 } |
187 |
230 |
188 void CEmergencyCallRfAdaptation::DoEmergencyCallRfAdaptationCancelL(const RMessage2& aMessage) |
231 void CEmergencyCallRfAdaptation::DoEmergencyCallRfAdaptationCancelL(const RMessage2& aMessage) |
189 { |
232 { |
190 |
233 __ASSERT_ALWAYS((iEmergencyCallRfAdaptation != NULL), User::Panic(KPanicSsmSus, EEmergencyCallRfAdaptationNullPtrError2)); |
|
234 |
191 if(iCurrentMessage != NULL) |
235 if(iCurrentMessage != NULL) |
192 { |
236 { |
193 if(aMessage.Session() == iCurrentMessage->Session()) |
237 if(aMessage.Session() == iCurrentMessage->Session()) |
194 { |
238 { |
195 DEBUGPRINT1A("CEmergencyCallRfAdaptationRequests cancelling current request as requested"); |
239 DEBUGPRINT1A("CEmergencyCallRfAdaptationRequests cancelling current request as requested"); |
196 iEmergencyCallRfAdaptation.Cancel(); |
240 iEmergencyCallRfAdaptation->Cancel(); |
197 } |
241 } |
198 iPendingRequestsQueue.RemoveFromQueueAndComplete(aMessage, iReservedHeap); |
242 CEmergencyAdaptationMessage *messageToBeDeleted; |
|
243 for(TInt index = 0; index < iPendingEmergencyRequestsQueue.Count(); ++index ) |
|
244 { |
|
245 if(aMessage.Session() == iPendingEmergencyRequestsQueue[index]->Session()) |
|
246 { |
|
247 messageToBeDeleted = iPendingEmergencyRequestsQueue[index]; |
|
248 DEBUGPRINT2A("RSsmAdaptationRequestQueue(aMessage,ReservedHeap)called to cancel the request with function id: %d", messageToBeDeleted->Function()); |
|
249 iPendingEmergencyRequestsQueue.Remove(index); |
|
250 messageToBeDeleted->Complete(KErrCancel); |
|
251 //Reset the AdaptationMessage if it is created using reserved pointer or delete the pointer |
|
252 if(messageToBeDeleted->IsMessageReserved()) |
|
253 { |
|
254 messageToBeDeleted->UnsetMessageStatus(EMsgInUse); |
|
255 ++iReserveMsgCount; |
|
256 } |
|
257 else |
|
258 { |
|
259 delete messageToBeDeleted; |
|
260 } |
|
261 --index; |
|
262 } |
|
263 } |
199 |
264 |
200 aMessage.Complete(KErrNone); |
265 aMessage.Complete(KErrNone); |
201 } |
266 } |
202 else |
267 else |
203 { |
268 { |
207 } |
272 } |
208 |
273 |
209 |
274 |
210 void CEmergencyCallRfAdaptation::RunL() |
275 void CEmergencyCallRfAdaptation::RunL() |
211 { |
276 { |
212 |
277 __ASSERT_DEBUG((iCurrentMessage != NULL), User::Panic(KPanicSsmSus, EEmergencyAdaptationMessageNullPtrError)); |
213 DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests processed the request with funtion id: %d", iCurrentMessage->Function()); |
278 DEBUGPRINT2A("CEmergencyCallRfAdaptationRequests processed the request with funtion id: %d", iCurrentMessage->Function()); |
214 iCurrentMessage->Complete(iStatus.Int()); |
279 iCurrentMessage->Complete(iStatus.Int()); |
215 if(iCurrentMessage->iUsingReservedHeap) |
280 DeleteAdaptationMessage(); |
216 { |
|
217 iReservedHeap->Free(iCurrentMessage); |
|
218 } |
|
219 else |
|
220 { |
|
221 delete iCurrentMessage; |
|
222 } |
|
223 iCurrentMessage = NULL; |
281 iCurrentMessage = NULL; |
224 |
282 |
225 if( (iPendingRequestsQueue.IsEmpty()) == EFalse ) |
283 if( (iPendingEmergencyRequestsQueue.Count()) > 0 ) |
226 { |
284 { |
227 CAdaptationMessage *messageCopy = NULL; |
285 CEmergencyAdaptationMessage *messageCopy = NULL; |
228 iPendingRequestsQueue.Dequeue(messageCopy); |
286 Dequeue(messageCopy); |
229 Submit(messageCopy); |
287 Submit(messageCopy); |
230 } |
288 } |
231 } |
289 } |
232 |
290 |
233 TInt CEmergencyCallRfAdaptation::RunError( TInt aError ) |
291 TInt CEmergencyCallRfAdaptation::RunError( TInt aError ) |
234 { |
292 { |
235 |
293 |
236 if(iCurrentMessage != NULL) |
294 if(iCurrentMessage != NULL) |
237 { |
295 { |
238 iCurrentMessage->Complete(aError); |
296 iCurrentMessage->Complete(aError); |
239 if(iCurrentMessage->iUsingReservedHeap) |
297 DeleteAdaptationMessage(); |
240 { |
|
241 iReservedHeap->Free(iCurrentMessage); |
|
242 } |
|
243 else |
|
244 { |
|
245 delete iCurrentMessage; |
|
246 } |
|
247 iCurrentMessage = NULL; |
298 iCurrentMessage = NULL; |
248 } |
299 } |
249 |
300 |
250 while( (iPendingRequestsQueue.IsEmpty()) == EFalse ) |
301 while( (iPendingEmergencyRequestsQueue.Count() > 0 )) |
251 { |
302 { |
252 iPendingRequestsQueue.Dequeue(iCurrentMessage); |
303 Dequeue(iCurrentMessage); |
253 iCurrentMessage->Complete(aError); |
304 iCurrentMessage->Complete(aError); |
254 if(iCurrentMessage->iUsingReservedHeap) |
305 DeleteAdaptationMessage(); |
255 { |
306 iCurrentMessage = NULL; |
256 iReservedHeap->Free(iCurrentMessage); |
307 } |
257 } |
|
258 else |
|
259 { |
|
260 delete iCurrentMessage; |
|
261 } |
|
262 iCurrentMessage = NULL; |
|
263 } |
|
264 |
308 |
265 return KErrNone; |
309 return KErrNone; |
266 |
310 |
267 } |
311 } |
268 |
312 |
269 void CEmergencyCallRfAdaptation::DoCancel() |
313 void CEmergencyCallRfAdaptation::DoCancel() |
270 { |
314 { |
271 if(iCurrentMessage != NULL) |
315 if(iCurrentMessage != NULL) |
272 { |
316 { |
273 iCurrentMessage->Complete(KErrCancel); |
317 iCurrentMessage->Complete(KErrCancel); |
274 if(iCurrentMessage->iUsingReservedHeap) |
318 DeleteAdaptationMessage(); |
275 { |
|
276 iReservedHeap->Free(iCurrentMessage); |
|
277 } |
|
278 else |
|
279 { |
|
280 delete iCurrentMessage; |
|
281 } |
|
282 iCurrentMessage = NULL; |
319 iCurrentMessage = NULL; |
283 } |
320 } |
284 |
321 |
285 while( (iPendingRequestsQueue.IsEmpty()) == EFalse ) |
322 while( (iPendingEmergencyRequestsQueue.Count() > 0 )) |
286 { |
323 { |
287 iPendingRequestsQueue.Dequeue(iCurrentMessage); |
324 Dequeue(iCurrentMessage); |
288 iCurrentMessage->Complete(KErrCancel); |
325 iCurrentMessage->Complete(KErrCancel); |
289 if(iCurrentMessage->iUsingReservedHeap) |
326 DeleteAdaptationMessage(); |
290 { |
327 iCurrentMessage = NULL; |
291 iReservedHeap->Free(iCurrentMessage); |
|
292 } |
|
293 else |
|
294 { |
|
295 delete iCurrentMessage; |
|
296 } |
|
297 iCurrentMessage = NULL; |
|
298 } |
328 } |
299 } |
329 } |
300 |
330 |
301 /** |
331 /** |
302 * Sets the Priority Client Session |
332 * Sets the Priority Client Session |
312 void CEmergencyCallRfAdaptation::RemovePriorityClientSession() |
342 void CEmergencyCallRfAdaptation::RemovePriorityClientSession() |
313 { |
343 { |
314 iPriorityClientSession = NULL; |
344 iPriorityClientSession = NULL; |
315 } |
345 } |
316 |
346 |
|
347 /** |
|
348 * Reset the AdaptationMessage if it is created using reserved pointer or delete the pointer |
|
349 */ |
|
350 void CEmergencyCallRfAdaptation::DeleteAdaptationMessage() |
|
351 { |
|
352 if(iCurrentMessage->IsMessageReserved()) |
|
353 { |
|
354 iCurrentMessage->UnsetMessageStatus(EMsgInUse); |
|
355 ++iReserveMsgCount; |
|
356 } |
|
357 else |
|
358 { |
|
359 delete iCurrentMessage; |
|
360 } |
|
361 } |
|
362 |
|
363 void CEmergencyCallRfAdaptation::Dequeue(CEmergencyAdaptationMessage *&aCurrentMessage) |
|
364 { |
|
365 aCurrentMessage = iPendingEmergencyRequestsQueue[0]; |
|
366 iPendingEmergencyRequestsQueue.Remove(0); |
|
367 } |
|
368 |
|
369 /** |
|
370 * Constructor. |
|
371 */ |
|
372 CEmergencyAdaptationMessage::CEmergencyAdaptationMessage(const TInt8 aMessageStatus): iAdaptationMessage(NULL), iMessageStatus(0) |
|
373 { |
|
374 iMessageStatus |= aMessageStatus ; |
|
375 } |
|
376 |
|
377 /** |
|
378 * Destructor. |
|
379 */ |
|
380 CEmergencyAdaptationMessage::~CEmergencyAdaptationMessage() |
|
381 { |
|
382 if (iAdaptationMessage != NULL) |
|
383 { |
|
384 delete iAdaptationMessage; |
|
385 } |
|
386 } |
|
387 |
|
388 CEmergencyAdaptationMessage* CEmergencyAdaptationMessage::NewL(const RMessage2& aMessage) |
|
389 { |
|
390 return CEmergencyAdaptationMessage::NewL(aMessage, EMsgStatusNULL); |
|
391 } |
|
392 |
|
393 CEmergencyAdaptationMessage* CEmergencyAdaptationMessage::NewL(const RMessage2& aMessage, const TInt8 aMessageStatus) |
|
394 { |
|
395 CEmergencyAdaptationMessage* self = new(ELeave) CEmergencyAdaptationMessage(aMessageStatus); |
|
396 //custom cleanup is not required here as it is a normal message till this point. |
|
397 CleanupStack::PushL(self); |
|
398 self->ConstructL(aMessage); |
|
399 CleanupStack::Pop(self); |
|
400 return self; |
|
401 } |
|
402 |
|
403 void CEmergencyAdaptationMessage::ConstructL(const RMessage2& aMessage) |
|
404 { |
|
405 iAdaptationMessage = new (ELeave)CAdaptationMessage(aMessage); |
|
406 } |
|
407 |
|
408 void CEmergencyAdaptationMessage::Complete(TInt aReason) |
|
409 { |
|
410 if (iAdaptationMessage != NULL) |
|
411 { |
|
412 iAdaptationMessage->Complete(aReason); |
|
413 } |
|
414 } |
|
415 |
|
416 /** |
|
417 * Function to check whether the messages is using reserved heap or not. |
|
418 */ |
|
419 inline TBool CEmergencyAdaptationMessage::IsMessageReserved() const |
|
420 { |
|
421 return (iMessageStatus & EMsgReserved)? ETrue:EFalse; |
|
422 } |
|
423 |
|
424 /** |
|
425 * Function to check whether the reserved messages is in use or not. |
|
426 */ |
|
427 inline TBool CEmergencyAdaptationMessage::IsMessageInuse() const |
|
428 { |
|
429 return (iMessageStatus & EMsgInUse)? ETrue:EFalse; |
|
430 } |
|
431 |
|
432 /** |
|
433 * Unset the message status . |
|
434 */ |
|
435 inline void CEmergencyAdaptationMessage::UnsetMessageStatus(const TInt8 aMessageStatus) |
|
436 { |
|
437 iMessageStatus &= ~aMessageStatus ; |
|
438 } |
|
439 |
|
440 /** |
|
441 * Set the message status . |
|
442 */ |
|
443 inline void CEmergencyAdaptationMessage::SetMessageStatus(const TInt8 aMessageStatus) |
|
444 { |
|
445 iMessageStatus |= aMessageStatus ; |
|
446 } |
|
447 |
|
448 /** |
|
449 * Sets the RMessage2 . |
|
450 */ |
|
451 void CEmergencyAdaptationMessage::SetMessage(const RMessage2& aMessage) |
|
452 { |
|
453 iAdaptationMessage->SetMessage(aMessage); |
|
454 } |
|
455 |
|
456 /** |
|
457 * Returns the Function . |
|
458 */ |
|
459 TInt CEmergencyAdaptationMessage::Function() const |
|
460 { |
|
461 return iAdaptationMessage->Function(); |
|
462 } |
|
463 |
|
464 /** |
|
465 * Returns the Session . |
|
466 */ |
|
467 CSession2 *CEmergencyAdaptationMessage::Session() const |
|
468 { |
|
469 return iAdaptationMessage->Session(); |
|
470 } |
|
471 |