|
1 // Copyright (c) 2003-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 // Implements all classes involved in queuing deletes, writes and sends. |
|
15 // |
|
16 // |
|
17 |
|
18 /** |
|
19 @file |
|
20 */ |
|
21 |
|
22 #include "smspqueue.h" |
|
23 #include "smspcomm.h" |
|
24 #include "Gsmumsg.h" |
|
25 #include "smspdel.h" |
|
26 #include "smspsend.h" |
|
27 #include "smspenum.h" |
|
28 #include "SmsuTimer.h" |
|
29 |
|
30 // |
|
31 // |
|
32 // CQueuedSmsMessage |
|
33 // |
|
34 // |
|
35 |
|
36 |
|
37 /** |
|
38 * Constructor |
|
39 * |
|
40 * @param aSmsMessage the queued SMS message. |
|
41 * @param aObserver the observer to notify when the queued operation has completed. |
|
42 * @param aOptions options applicable to the queued operation. |
|
43 * |
|
44 */ |
|
45 CQueuedSmsMessage::CQueuedSmsMessage(CSmsMessage* aSmsMessage,MSmsMessageObserver& aObserver,TUint aOptions) |
|
46 :iSmsMessage(aSmsMessage) |
|
47 ,iObserver(aObserver) |
|
48 ,iOptions(aOptions) |
|
49 { |
|
50 } // CQueuedSmsMessage::CQueuedSmsMessage |
|
51 |
|
52 |
|
53 /** |
|
54 * Deletes the queued CSmsMessage object. |
|
55 * |
|
56 */ |
|
57 CQueuedSmsMessage::~CQueuedSmsMessage() |
|
58 { |
|
59 delete iSmsMessage; |
|
60 } // CQueuedSmsMessage::~CQueuedSmsMessage |
|
61 |
|
62 // |
|
63 // |
|
64 // CSmspMessageQueue |
|
65 // |
|
66 // |
|
67 |
|
68 CSmspMessageQueue::~CSmspMessageQueue() |
|
69 { |
|
70 __ASSERT_DEBUG(iMessageQueue.IsEmpty(), SmspPanic(KSmspQueueNotEmpty)); |
|
71 while (!iMessageQueue.IsEmpty()) |
|
72 { |
|
73 CQueuedSmsMessage* queuedMessage = iMessageQueue.First(); |
|
74 iMessageQueue.Remove(*queuedMessage); |
|
75 delete queuedMessage; |
|
76 } |
|
77 } // CSmspMessageQueue::~CSmspMessageQueue |
|
78 |
|
79 |
|
80 void CSmspMessageQueue::DoRunL() |
|
81 { |
|
82 LOGSMSPROT1("CSmspMessageQueue::DoRunL()"); |
|
83 |
|
84 CompleteFirst(iStatus.Int()); |
|
85 Start(); |
|
86 } // CSmspMessageQueue::DoRunL |
|
87 |
|
88 |
|
89 void CSmspMessageQueue::Queue(CSmsMessage* aMessage, MSmsMessageObserver& aObserver, TUint aOptions) |
|
90 { |
|
91 // TODO __ASSERT_DEBUG no item is in the queue for this observer |
|
92 |
|
93 TRAPD(err, DoQueueL(aMessage, aObserver, aOptions)); |
|
94 |
|
95 LOGSMSPROT4("*** CSmspMessageQueue::Queue [err=%d aObserver=0x%08x IsActive=%d]", err, &aObserver, IsActive()); |
|
96 |
|
97 if (err != KErrNone) |
|
98 { |
|
99 CompleteObserver(aObserver, err); |
|
100 } |
|
101 else if (!IsActive()) |
|
102 { |
|
103 Start(); |
|
104 } |
|
105 } // CSmspMessageQueue::Queue |
|
106 |
|
107 |
|
108 void CSmspMessageQueue::DoQueueL(CSmsMessage* aMessage, MSmsMessageObserver& aObserver, TUint aOptions) |
|
109 { |
|
110 LOGSMSPROT1("CSmspMessageQueue::DoQueueL()"); |
|
111 |
|
112 CleanupStack::PushL(aMessage); |
|
113 |
|
114 CQueuedSmsMessage* queuedsmsmessage= new (ELeave) CQueuedSmsMessage(aMessage, aObserver, aOptions); |
|
115 |
|
116 CleanupStack::Pop(aMessage); |
|
117 CleanupStack::PushL(queuedsmsmessage); |
|
118 |
|
119 iMessageQueue.AddLast(*queuedsmsmessage); |
|
120 |
|
121 CleanupStack::Pop(queuedsmsmessage); |
|
122 } // CSmspMessageQueue::DoQueueL |
|
123 |
|
124 |
|
125 CSmspMessageQueue::CSmspMessageQueue(MSmsComm& aSmsComm, TInt aPriority) |
|
126 : CSmspProtocolQueue(aSmsComm, aPriority) |
|
127 { |
|
128 iMessageQueue.SetOffset(_FOFF(CQueuedSmsMessage,iLink)); |
|
129 } // CSmspMessageQueue::CSmspMessageQueue |
|
130 |
|
131 |
|
132 /** |
|
133 * Completes all items in the queue with KErrCancel |
|
134 */ |
|
135 void CSmspMessageQueue::DoCancel() |
|
136 { |
|
137 LOGSMSPROT1("*** CSmspMessageQueue::DoCancel"); |
|
138 |
|
139 TSglQueIter<CQueuedSmsMessage> iter(iMessageQueue); |
|
140 CQueuedSmsMessage* queuedsmsmessage = iter; |
|
141 |
|
142 if ( queuedsmsmessage!=NULL ) |
|
143 { |
|
144 CompleteRequest(queuedsmsmessage, KErrCancel); |
|
145 } |
|
146 } // CSmspMessageQueue::DoCancel |
|
147 |
|
148 |
|
149 void CSmspMessageQueue::CompleteFirst(TInt aStatus) |
|
150 { |
|
151 LOGSMSPROT1("CSmspMessageQueue::CompleteFirst()"); |
|
152 |
|
153 CompleteRequest(iMessageQueue.First(), aStatus); |
|
154 } // CSmspMessageQueue::CompleteFirst |
|
155 |
|
156 |
|
157 void CSmspMessageQueue::CompleteRequest(CQueuedSmsMessage* aQueuedMessage, TInt aStatus) |
|
158 { |
|
159 LOGSMSPROT4("*** CSmspMessageQueue::CompleteRequest [aStatus=%d aObserver=0x%X IsFirst=%d]", aStatus, &aQueuedMessage->iObserver, iMessageQueue.IsFirst(aQueuedMessage)); |
|
160 |
|
161 // From defect HOE-563KLY, need to cancel request if active and remove from queue |
|
162 // before observer has chance to manipulate queue |
|
163 CancelRequestIfObserved(aQueuedMessage->iObserver); |
|
164 iMessageQueue.Remove(*aQueuedMessage); |
|
165 CompleteObserver(aQueuedMessage->iObserver, aStatus, aQueuedMessage->iSmsMessage); |
|
166 delete aQueuedMessage; |
|
167 } // CSmspMessageQueue::CompleteRequest |
|
168 |
|
169 |
|
170 void CSmspMessageQueue::CancelObserver(MSmsMessageObserver& aObserver) |
|
171 { |
|
172 LOGSMSPROT2("*** CSmspMessageQueue::CancelObserver [aObserver=0x%X]", &aObserver); |
|
173 |
|
174 TSglQueIter<CQueuedSmsMessage> iter(iMessageQueue); |
|
175 CQueuedSmsMessage* queuedsmsmessage = iter; |
|
176 |
|
177 for (; queuedsmsmessage!=NULL; queuedsmsmessage = iter++) |
|
178 { |
|
179 if (&queuedsmsmessage->iObserver==&aObserver) |
|
180 { |
|
181 if (iMessageQueue.IsFirst(queuedsmsmessage) && IsActive()) |
|
182 { |
|
183 Cancel(); |
|
184 } |
|
185 else |
|
186 { |
|
187 CompleteRequest(queuedsmsmessage, KErrCancel); |
|
188 } |
|
189 iter=iMessageQueue; |
|
190 } |
|
191 } |
|
192 |
|
193 if (!iMessageQueue.IsEmpty()) |
|
194 Start(); |
|
195 } // CSmspMessageQueue::CancelObserver |
|
196 |
|
197 |
|
198 // |
|
199 // |
|
200 // CSmspProtocolQueue |
|
201 // |
|
202 // |
|
203 |
|
204 CSmspProtocolQueue::CSmspProtocolQueue(MSmsComm& aSmsComm, TInt aPriority) |
|
205 : CSmsuActiveBase(aPriority), iSmsComm(aSmsComm) |
|
206 { |
|
207 } // CSmspProtocolQueue::CSmspProtocolQueue |
|
208 |
|
209 |
|
210 // |
|
211 // |
|
212 // CQueuedPDUDelete |
|
213 // |
|
214 // |
|
215 |
|
216 /** |
|
217 * 2 phase constructor |
|
218 * |
|
219 * @param aSlotArray an array of message slots to delete from the phone. |
|
220 * @param aObserver the observer to notify on completion. |
|
221 * |
|
222 */ |
|
223 CQueuedPDUDelete* CQueuedPDUDelete::NewL(const CArrayFix<TGsmSmsSlotEntry>& aSlotArray,MSmsMessageObserver* aObserver) |
|
224 { |
|
225 LOGSMSPROT1("CQueuedPDUDelete::NewL()"); |
|
226 |
|
227 CQueuedPDUDelete* queuedpdudelete=new(ELeave) CQueuedPDUDelete(aObserver); |
|
228 CleanupStack::PushL(queuedpdudelete); |
|
229 queuedpdudelete->ConstructL(aSlotArray); |
|
230 CleanupStack::Pop(); |
|
231 return queuedpdudelete; |
|
232 } // CQueuedPDUDelete::NewL |
|
233 |
|
234 |
|
235 CQueuedPDUDelete::~CQueuedPDUDelete() |
|
236 { |
|
237 } // CQueuedPDUDelete::~CQueuedPDUDelete |
|
238 |
|
239 |
|
240 CQueuedPDUDelete::CQueuedPDUDelete(MSmsMessageObserver* aObserver) |
|
241 :iLocationArray(8) |
|
242 ,iObserver(aObserver) |
|
243 { |
|
244 } // CQueuedPDUDelete::CQueuedPDUDelete |
|
245 |
|
246 |
|
247 /** |
|
248 * 2nd phase of construction, copies the elements of the slot array to |
|
249 * the internal array. |
|
250 * |
|
251 */ |
|
252 void CQueuedPDUDelete::ConstructL(const CArrayFix<TGsmSmsSlotEntry>& aSlotArray) |
|
253 { |
|
254 LOGSMSPROT1("CQueuedPDUDelete::ConstructL()"); |
|
255 |
|
256 TInt count=aSlotArray.Count(); |
|
257 for (TInt i=0; i<count; i++) |
|
258 iLocationArray.AppendL(aSlotArray[i]); |
|
259 } // CQueuedPDUDelete::ConstructL |
|
260 |
|
261 |
|
262 // |
|
263 // |
|
264 // CSmspDeleteQueue |
|
265 // |
|
266 // |
|
267 |
|
268 /** |
|
269 * This method superceeds DoRunL(), implemented below. |
|
270 * |
|
271 * When the protocol stack is being closed down, the |
|
272 * method iSmsComm.CloseNowWrap() deletes the stack and |
|
273 * this active object. Calling CloseNowWrap() must be the |
|
274 * last action performed by when the stack is being shut |
|
275 * down, otherwise the action will be performed on a NULL |
|
276 * object. |
|
277 * |
|
278 * @internalComponent |
|
279 * @capability None |
|
280 */ |
|
281 void CSmspDeleteQueue::RunL() |
|
282 { |
|
283 LOGSMSPROT1("CSmspDeleteQueue::RunL()"); |
|
284 |
|
285 CompleteFirst(iStatus.Int()); |
|
286 |
|
287 if (iDeleteQueue.IsEmpty() && iSmsComm.ClosingDown()) |
|
288 { |
|
289 iSmsComm.CloseNowWrap(); //causes CSmsProtocol to delete this |
|
290 //Don't do anything else in CSmspDeleteQueue because it is deleted now, |
|
291 //otherwise there will be an access violation!! |
|
292 } |
|
293 else |
|
294 { |
|
295 Start(); |
|
296 } |
|
297 } // CSmspDeleteQueue::RunL |
|
298 |
|
299 |
|
300 void CSmspDeleteQueue::DoRunL() |
|
301 { |
|
302 // Ignore in code coverage - the delete queue implements its own RunL. |
|
303 BULLSEYE_OFF |
|
304 LOGSMSPROT1("CSmspDeleteQueue::DoRunL()"); |
|
305 |
|
306 // This CSmspDeleteQueue::DoRunL() function would be called by |
|
307 // CSmsuActiveBase::RunL(). However, CSmspDeleteQueue::RunL() now |
|
308 // overwrites CSmsuActiveBase::RunL(), to make sure the delete queue is |
|
309 // not used after the CloseNowWrap() call. Therefore, this is now a |
|
310 // do-nothing method. |
|
311 BULLSEYE_RESTORE |
|
312 } |
|
313 |
|
314 void CSmspDeleteQueue::Queue(const CArrayFix<TGsmSmsSlotEntry>& aSlotArray, MSmsMessageObserver* aObserver) |
|
315 { |
|
316 // TODO __ASSERT_DEBUG no item is in the queue for this observer |
|
317 |
|
318 TRAPD(err, DoQueueL(aSlotArray, aObserver)); |
|
319 |
|
320 LOGSMSPROT4("*** CSmspDeleteQueue::Queue [err=%d aObserver=0x%X IsActive=%d]", err, aObserver, IsActive()); |
|
321 |
|
322 if (err != KErrNone) |
|
323 { |
|
324 if (aObserver != NULL) |
|
325 { |
|
326 CompleteObserver(*aObserver, err); |
|
327 } |
|
328 } |
|
329 else if (!IsActive()) |
|
330 Start(); |
|
331 } // CSmspDeleteQueue::Queue |
|
332 |
|
333 |
|
334 void CSmspDeleteQueue::DoQueueL(const CArrayFix<TGsmSmsSlotEntry>& aSlotArray, MSmsMessageObserver* aObserver) |
|
335 { |
|
336 LOGSMSPROT1("CSmspDeleteQueue::DoQueueL()"); |
|
337 |
|
338 CQueuedPDUDelete* queuedDelete= CQueuedPDUDelete::NewL(aSlotArray, aObserver); |
|
339 iDeleteQueue.AddLast(*queuedDelete); |
|
340 } // CSmspDeleteQueue::DoQueueL |
|
341 |
|
342 |
|
343 CSmspDeleteQueue::CSmspDeleteQueue(MSmsComm& aSmsComm, TInt aPriority) |
|
344 : CSmspProtocolQueue(aSmsComm, aPriority) |
|
345 { |
|
346 LOGSMSPROT1("CSmspDeleteQueue::CSmspDeleteQueue()"); |
|
347 |
|
348 iDeleteQueue.SetOffset(_FOFF(CQueuedPDUDelete,iLink)); |
|
349 } // CSmspDeleteQueue::CSmspDeleteQueue |
|
350 |
|
351 |
|
352 /** |
|
353 * Completes all items in the queue with KErrCancel |
|
354 */ |
|
355 void CSmspDeleteQueue::DoCancel() |
|
356 { |
|
357 LOGSMSPROT1("*** CSmspDeleteQueue::DoCancel"); |
|
358 |
|
359 iSmsPDUDelete->Cancel(); |
|
360 |
|
361 while (!iDeleteQueue.IsEmpty()) |
|
362 { |
|
363 CQueuedPDUDelete* queuedDelete = iDeleteQueue.First(); |
|
364 CompleteRequest(queuedDelete, KErrCancel); |
|
365 } |
|
366 } // CSmspDeleteQueue::DoCancel |
|
367 |
|
368 |
|
369 void CSmspDeleteQueue::CompleteFirst(TInt aStatus) |
|
370 { |
|
371 LOGSMSPROT1("CSmspDeleteQueue::CompleteFirst()"); |
|
372 |
|
373 CompleteRequest(iDeleteQueue.First(), aStatus); |
|
374 } // CSmspDeleteQueue::CompleteFirst |
|
375 |
|
376 |
|
377 void CSmspDeleteQueue::CompleteRequest(CQueuedPDUDelete* aQueuedDelete, TInt aStatus) |
|
378 { |
|
379 LOGSMSPROT4("*** CSmspDeleteQueue::CompleteRequest [aStatus=%d aObserver=0x%X IsFirst=%d]", aStatus, aQueuedDelete->iObserver, iDeleteQueue.IsFirst(aQueuedDelete)); |
|
380 |
|
381 if (aQueuedDelete->iObserver != NULL) |
|
382 CompleteObserver(*aQueuedDelete->iObserver, aStatus); |
|
383 |
|
384 iDeleteQueue.Remove(*aQueuedDelete); |
|
385 delete aQueuedDelete; |
|
386 } // CSmspDeleteQueue::CompleteRequest |
|
387 |
|
388 |
|
389 void CSmspDeleteQueue::CancelObserver(MSmsMessageObserver& aObserver) |
|
390 { |
|
391 LOGSMSPROT2("*** CSmspDeleteQueue::CancelObserver [aObserver=0x%X]", &aObserver); |
|
392 |
|
393 TSglQueIter<CQueuedPDUDelete> iter(iDeleteQueue); |
|
394 CQueuedPDUDelete* queuedDelete = iter; |
|
395 |
|
396 for (; queuedDelete!=NULL; queuedDelete = iter++) |
|
397 { |
|
398 if (queuedDelete->iObserver == &aObserver) |
|
399 { |
|
400 if (iDeleteQueue.IsFirst(queuedDelete) && IsActive()) |
|
401 { |
|
402 Cancel(); |
|
403 } |
|
404 else |
|
405 { |
|
406 CompleteRequest(queuedDelete, KErrCancel); |
|
407 } |
|
408 iter=iDeleteQueue; // <---- Here is fix for crash |
|
409 } |
|
410 } |
|
411 } // CSmspDeleteQueue::CancelObserver |
|
412 |
|
413 |
|
414 CSmspDeleteQueue* CSmspDeleteQueue::NewL(MSmsComm& aSmsComm, const TSmsSettings& aSmsSettings, RMobileSmsMessaging& aSmsMessaging, TInt aPriority) |
|
415 { |
|
416 LOGSMSPROT1("CSmspDeleteQueue::NewL()"); |
|
417 |
|
418 CSmspDeleteQueue* self = new (ELeave) CSmspDeleteQueue(aSmsComm, aPriority); |
|
419 CleanupStack::PushL(self); |
|
420 self->ConstructL(aSmsSettings, aSmsMessaging); |
|
421 CleanupStack::Pop(self); |
|
422 return self; |
|
423 } // CSmspDeleteQueue::NewL |
|
424 |
|
425 |
|
426 void CSmspDeleteQueue::Start() |
|
427 { |
|
428 LOGSMSPROT3("*** CSmspDeleteQueue::Start [IsActive=%d IsEmpty=%d]", IsActive(), iDeleteQueue.IsEmpty()); |
|
429 |
|
430 if (!IsActive() && !iDeleteQueue.IsEmpty()) |
|
431 { |
|
432 CQueuedPDUDelete& queuedDelete = *iDeleteQueue.First(); |
|
433 iSmsPDUDelete->Start(queuedDelete.iLocationArray, iStatus); |
|
434 SetActive(); |
|
435 } |
|
436 } // CSmspDeleteQueue::Start |
|
437 |
|
438 |
|
439 CSmspDeleteQueue::~CSmspDeleteQueue() |
|
440 { |
|
441 Cancel(); |
|
442 delete iSmsPDUDelete; |
|
443 |
|
444 __ASSERT_DEBUG(iDeleteQueue.IsEmpty(), SmspPanic(KSmspQueueNotEmpty)); |
|
445 while (!iDeleteQueue.IsEmpty()) |
|
446 { |
|
447 CQueuedPDUDelete* queuedDelete = iDeleteQueue.First(); |
|
448 iDeleteQueue.Remove(*queuedDelete); |
|
449 delete queuedDelete; |
|
450 } |
|
451 } // CSmspDeleteQueue::~CSmspDeleteQueue |
|
452 |
|
453 |
|
454 void CSmspDeleteQueue::ConstructL(const TSmsSettings& aSmsSettings, RMobileSmsMessaging& aSmsMessaging) |
|
455 { |
|
456 LOGSMSPROT1("CSmspDeleteQueue::ConstructL()"); |
|
457 |
|
458 iSmsPDUDelete = CSmsPDUDelete::NewL(aSmsSettings, aSmsMessaging); |
|
459 } // CSmspDeleteQueue::ConstructL |
|
460 |
|
461 |
|
462 void CSmspDeleteQueue::CompleteObserver(MSmsMessageObserver& aObserver, TInt aError, const CSmsMessage*) |
|
463 { |
|
464 LOGSMSPROT4("*** CSmspDeleteQueue::CompleteObserver [aObserver=0x%X aError=%d IsActive=%d]", &aObserver, aError, IsActive()); |
|
465 |
|
466 if (iSmsComm.ObserverIsPresent(aObserver)) |
|
467 { |
|
468 aObserver.MessageDeleteCompleted(aError); |
|
469 } |
|
470 } // CSmspDeleteQueue::CompleteObserver |
|
471 |
|
472 // |
|
473 // |
|
474 // CSmspSendQueue |
|
475 // |
|
476 // |
|
477 |
|
478 CSmspSendQueue* CSmspSendQueue::NewL(MSmsComm& aSmsComm, CSmsSegmentationStore& aSegmentationStore, const TSmsSettings& aSmsSettings, const RMobileSmsMessaging::TMobileSmsCapsV1& aMobileSmsCaps, RMobileSmsMessaging& aSmsMessaging, TInt aPriority, CSmspSetBearer& aSmspSetBearer) |
|
479 { |
|
480 LOGSMSPROT1("CSmspSendQueue::NewL()"); |
|
481 |
|
482 CSmspSendQueue* self = new (ELeave) CSmspSendQueue(aSmsComm, aPriority); |
|
483 CleanupStack::PushL(self); |
|
484 self->ConstructL(aSegmentationStore, aSmsSettings, aMobileSmsCaps, aSmsMessaging, aSmspSetBearer); |
|
485 CleanupStack::Pop(self); |
|
486 return self; |
|
487 } // CSmspSendQueue::NewL |
|
488 |
|
489 |
|
490 void CSmspSendQueue::Start() |
|
491 { |
|
492 LOGSMSPROT3("*** CSmspSendQueue::Start [IsActive=%d IsEmpty=%d]", IsActive(), iMessageQueue.IsEmpty()); |
|
493 |
|
494 if (!IsActive() && !iMessageQueue.IsEmpty()) |
|
495 { |
|
496 CQueuedSmsMessage& queuedMessage = *iMessageQueue.First(); |
|
497 iSmsMessageSend->Start(*queuedMessage.iSmsMessage, queuedMessage.iOptions, queuedMessage.iObserver.GetLocalAddress(), iStatus); |
|
498 SetActive(); |
|
499 } |
|
500 } // CSmspSendQueue::Start |
|
501 |
|
502 |
|
503 CSmspSendQueue::CSmspSendQueue(MSmsComm& aSmsComm, TInt aPriority) |
|
504 : CSmspMessageQueue(aSmsComm, aPriority) |
|
505 { |
|
506 } // CSmspSendQueue::CSmspSendQueue |
|
507 |
|
508 |
|
509 CSmspSendQueue::~CSmspSendQueue() |
|
510 { |
|
511 Cancel(); |
|
512 delete iSmsMessageSend; |
|
513 } // CSmspSendQueue::~CSmspSendQueue |
|
514 |
|
515 |
|
516 void CSmspSendQueue::ConstructL(CSmsSegmentationStore& aSegmentationStore, const TSmsSettings& aSmsSettings, const RMobileSmsMessaging::TMobileSmsCapsV1& aMobileSmsCaps, RMobileSmsMessaging& aSmsMessaging, CSmspSetBearer& aSmspSetBearer) |
|
517 { |
|
518 LOGSMSPROT1("CSmspSendQueue::ConstructL()"); |
|
519 |
|
520 iSmsMessageSend = CSmsMessageSend::NewL(aSegmentationStore, aSmsSettings, aMobileSmsCaps, aSmsMessaging, Priority(), aSmspSetBearer); |
|
521 } // CSmspSendQueue::ConstructL |
|
522 |
|
523 |
|
524 void CSmspSendQueue::CancelRequestIfObserved(MSmsMessageObserver& aObserver) |
|
525 { |
|
526 LOGSMSPROT1("CSmspSendQueue::CancelRequestIfObserved()"); |
|
527 |
|
528 if (IsActive() && &iMessageQueue.First()->iObserver == &aObserver) |
|
529 { |
|
530 iSmsMessageSend->Cancel(); |
|
531 } |
|
532 } // CSmspSendQueue::CancelRequestIfObserved |
|
533 |
|
534 |
|
535 void CSmspSendQueue::CompleteObserver(MSmsMessageObserver& aObserver, TInt aError, const CSmsMessage*) |
|
536 { |
|
537 LOGSMSPROT4("*** CSmspSendQueue::CompleteObserver [aObserver=0x%X aError=%d IsActive=%d]", &aObserver, aError, IsActive()); |
|
538 |
|
539 if (iSmsComm.ObserverIsPresent(aObserver)) |
|
540 { |
|
541 aObserver.MessageSendCompleted(aError); |
|
542 } |
|
543 } // CSmspSendQueue::CompleteObserver |
|
544 |
|
545 |
|
546 void CSmspSendQueue::Complete(TInt aStatus) |
|
547 { |
|
548 LOGSMSPROT1("CSmspSendQueue::Complete()"); |
|
549 |
|
550 iSmsComm.MessageSendCompleted(aStatus); |
|
551 } // CSmspSendQueue::Complete |
|
552 |
|
553 |
|
554 // |
|
555 // |
|
556 // CSmspWriteQueue |
|
557 // |
|
558 // |
|
559 |
|
560 CSmspWriteQueue* CSmspWriteQueue::NewL(MSmsComm& aSmsComm, const TSmsSettings& aSmsSettings, RMobilePhone& aGsmPhone, CSmsSegmentationStore& aSegmentationStore, TInt aPriority) |
|
561 { |
|
562 LOGSMSPROT1("CSmspWriteQueue::NewL()"); |
|
563 |
|
564 CSmspWriteQueue* self = new (ELeave) CSmspWriteQueue(aSmsComm, aPriority); |
|
565 CleanupStack::PushL(self); |
|
566 self->ConstructL(aSmsSettings, aGsmPhone, aSegmentationStore); |
|
567 CleanupStack::Pop(self); |
|
568 return self; |
|
569 } // CSmspWriteQueue::NewL |
|
570 |
|
571 |
|
572 void CSmspWriteQueue::Start() |
|
573 { |
|
574 LOGSMSPROT3("*** CSmspWriteQueue::Start [IsActive=%d IsEmpty=%d]", IsActive(), iMessageQueue.IsEmpty()); |
|
575 |
|
576 if (!IsActive() && !iMessageQueue.IsEmpty()) |
|
577 { |
|
578 CQueuedSmsMessage& queuedMessage = *iMessageQueue.First(); |
|
579 iSmsMessageWrite->Start(queuedMessage.iSmsMessage, iStatus); |
|
580 SetActive(); |
|
581 } |
|
582 } // CSmspWriteQueue::Start |
|
583 |
|
584 |
|
585 CSmspWriteQueue::CSmspWriteQueue(MSmsComm& aSmsComm, TInt aPriority) |
|
586 : CSmspMessageQueue(aSmsComm, aPriority) |
|
587 { |
|
588 } // CSmspWriteQueue::CSmspWriteQueue |
|
589 |
|
590 |
|
591 CSmspWriteQueue::~CSmspWriteQueue() |
|
592 { |
|
593 Cancel(); |
|
594 delete iSmsMessageWrite; |
|
595 } // CSmspWriteQueue::~CSmspWriteQueue |
|
596 |
|
597 |
|
598 void CSmspWriteQueue::ConstructL(const TSmsSettings& aSmsSettings, RMobilePhone& aGsmPhone, CSmsSegmentationStore& aSegmentationStore) |
|
599 { |
|
600 LOGSMSPROT1("CSmspWriteQueue::ConstructL()"); |
|
601 |
|
602 iSmsMessageWrite = CSmsMessageWrite::NewL(iSmsComm, aSmsSettings, aGsmPhone, aSegmentationStore); |
|
603 } // CSmspWriteQueue::ConstructL |
|
604 |
|
605 |
|
606 void CSmspWriteQueue::CancelRequestIfObserved(MSmsMessageObserver& aObserver) |
|
607 { |
|
608 LOGSMSPROT1("CSmspWriteQueue::CancelRequestIfObserved()"); |
|
609 |
|
610 if (IsActive() && &iMessageQueue.First()->iObserver == &aObserver) |
|
611 { |
|
612 iSmsMessageWrite->Cancel(); |
|
613 } |
|
614 } // CSmspWriteQueue::CancelRequestIfObserved |
|
615 |
|
616 |
|
617 void CSmspWriteQueue::CompleteObserver(MSmsMessageObserver& aObserver, TInt aError, const CSmsMessage* aSmsMessage) |
|
618 { |
|
619 LOGSMSPROT4("*** CSmspWriteQueue::CompleteObserver [aObserver=0x%X aError=%d IsActive=%d]", &aObserver, aError, IsActive()); |
|
620 if (iSmsComm.ObserverIsPresent(aObserver)) |
|
621 { |
|
622 aObserver.MessageWriteCompleted(aError, aSmsMessage); |
|
623 } |
|
624 } // CSmspWriteQueue::CompleteObserver |
|
625 |
|
626 |
|
627 void CSmspWriteQueue::Complete(TInt) |
|
628 { |
|
629 LOGSMSPROT1("CSmspWriteQueue::Complete()"); |
|
630 |
|
631 //Do Nothing :o) |
|
632 } // CSmspWriteQueue::Complete |
|
633 |