|
1 /* |
|
2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 // System include files |
|
19 #include <s32strm.h> |
|
20 #include <s32mem.h> |
|
21 #include <hscontentcontroller.h> |
|
22 #include <hscontentinfoarray.h> |
|
23 #include <hscontentinfo.h> |
|
24 |
|
25 // User include files |
|
26 #include "hsccproviderclient.h" |
|
27 #include "ccresource.h" |
|
28 #include "ccsrvapi.h" |
|
29 #include "hsccapi.h" |
|
30 |
|
31 // Local constants |
|
32 |
|
33 // ======== MEMBER FUNCTIONS ======== |
|
34 |
|
35 // ----------------------------------------------------------------------------- |
|
36 // CHsCcProviderClient::NewL() |
|
37 // Two-phased constructor. |
|
38 // ----------------------------------------------------------------------------- |
|
39 EXPORT_C CHsCcProviderClient* CHsCcProviderClient::NewL( |
|
40 MHsContentController& aController ) |
|
41 { |
|
42 CHsCcProviderClient* self = new ( ELeave ) CHsCcProviderClient( aController ); |
|
43 CleanupStack::PushL( self ); |
|
44 self->ConstructL(); |
|
45 CleanupStack::Pop( self ); |
|
46 return( self ) ; |
|
47 } |
|
48 |
|
49 // ----------------------------------------------------------------------- |
|
50 // CHsCcProviderClient::ConstructL() |
|
51 // ----------------------------------------------------------------------- |
|
52 // |
|
53 void CHsCcProviderClient::ConstructL() |
|
54 { |
|
55 User::LeaveIfError( iSession.Connect() ); |
|
56 |
|
57 TPckgBuf<TUint32> provider( ECcHomescreen ); |
|
58 TPckgBuf<TUint32> address; |
|
59 User::LeaveIfError( iSession.RegisterProvider( |
|
60 provider, |
|
61 address ) ); |
|
62 iAddress = address(); |
|
63 |
|
64 WaitForApiReqL(); |
|
65 |
|
66 } |
|
67 |
|
68 // ----------------------------------------------------------------------- |
|
69 // CHsCcProviderClient::CHsCcProviderClient() |
|
70 // ----------------------------------------------------------------------- |
|
71 // |
|
72 CHsCcProviderClient::CHsCcProviderClient( |
|
73 MHsContentController& aController ) |
|
74 :CActive( EPriorityStandard ) |
|
75 ,iController( aController ) |
|
76 ,iAddress( 0 ) |
|
77 ,iApiHeader( NULL ) |
|
78 ,iApiHeaderPtr( NULL, 0 ) |
|
79 ,iApiData( NULL ) |
|
80 ,iApiDataPtr( NULL, 0 ) |
|
81 { |
|
82 CActiveScheduler::Add( this ); |
|
83 } |
|
84 |
|
85 // ----------------------------------------------------------------------- |
|
86 // CHsCcProviderClient::~CHsCcProviderClient() |
|
87 // ----------------------------------------------------------------------- |
|
88 // |
|
89 CHsCcProviderClient::~CHsCcProviderClient() |
|
90 { |
|
91 Cancel(); |
|
92 iSession.Close(); |
|
93 delete iApiHeader; |
|
94 delete iApiData; |
|
95 iObservers.Close(); |
|
96 } |
|
97 |
|
98 // ----------------------------------------------------------------------------- |
|
99 // CHsCcClient::RunL() |
|
100 // ----------------------------------------------------------------------------- |
|
101 // |
|
102 void CHsCcProviderClient::RunL() |
|
103 { |
|
104 |
|
105 TInt err( iStatus.Int() ); |
|
106 HBufC8* header( NULL ); |
|
107 TPtr8 headerPtr( NULL, 0 ); |
|
108 TUint32 sender( 0 ); |
|
109 TUint32 receiver( 0 ); |
|
110 if ( !err ) |
|
111 { |
|
112 // Read API request header |
|
113 header = iApiHeader->AllocL(); |
|
114 CleanupStack::PushL( header ); |
|
115 headerPtr.Set( header->Des() ); |
|
116 // Read sender |
|
117 sender = iPckgSender(); |
|
118 // Read receiver |
|
119 receiver = iPckgReceiver(); |
|
120 } |
|
121 |
|
122 // Receive next API request |
|
123 WaitForApiReqL(); |
|
124 |
|
125 if ( !err ) |
|
126 { |
|
127 // Get received message header |
|
128 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
129 CleanupStack::PushL( message ); |
|
130 RDesReadStream stream( headerPtr ); |
|
131 CleanupClosePushL( stream ); |
|
132 message->InternalizeHeaderL( stream ); |
|
133 CleanupStack::PopAndDestroy( &stream ); |
|
134 if ( message->DataSize() ) |
|
135 { |
|
136 // Get message data |
|
137 HBufC8* dataBuf = HBufC8::NewL( message->DataSize() ); |
|
138 CleanupStack::PushL( dataBuf ); |
|
139 TPtr8 dataPtr( NULL, 0 ); |
|
140 dataPtr.Set( dataBuf->Des() ); |
|
141 TPckgBuf<TUint32> trId( message->TrId() ); |
|
142 iSession.GetMsgData( trId, dataPtr ); |
|
143 message->SetData( dataPtr ); |
|
144 CleanupStack::PopAndDestroy( dataBuf ); |
|
145 } |
|
146 |
|
147 switch ( message->MsgId() ) |
|
148 { |
|
149 case ECcRegisterObserverNtf: |
|
150 HandleRegisterObserverNtfL( sender, receiver, *message ); |
|
151 break; |
|
152 case ECcUnregisterObserverNtf: |
|
153 HandleUnregisterObserverNtfL( sender, receiver, *message ); |
|
154 break; |
|
155 case EHsCcWidgetListReq: |
|
156 HandleWidgetListReqL( sender, receiver, *message ); |
|
157 break; |
|
158 case EHsCcAddWidgetReq: |
|
159 HandleAddWidgetReqL( sender, receiver, *message ); |
|
160 break; |
|
161 case EHsCcRemoveWidgetReq: |
|
162 HandleRemoveWidgetReqL( sender, receiver, *message ); |
|
163 break; |
|
164 case EHsCcViewListReq: |
|
165 HandleViewListReqL( sender, receiver, *message ); |
|
166 break; |
|
167 case EHsCcAddViewReq: |
|
168 HandleAddViewReqL( sender, receiver, *message ); |
|
169 break; |
|
170 case EHsCcRemoveViewReq: |
|
171 HandleRemoveViewReqL( sender, receiver, *message ); |
|
172 break; |
|
173 case EHsCcActivateViewReq: |
|
174 HandleActivateViewReqL( sender, receiver, *message ); |
|
175 break; |
|
176 case EHsCcAppListReq: |
|
177 HandleAppListReqL( sender, receiver, *message ); |
|
178 break; |
|
179 case EHsCcActivateAppReq: |
|
180 HandleActivateAppReqL( sender, receiver, *message ); |
|
181 break; |
|
182 case EHsCcActiveAppReq: |
|
183 HandleActiveAppReqL( sender, receiver, *message ); |
|
184 break; |
|
185 case EHsCcActiveViewReq: |
|
186 HandleActiveViewReqL( sender, receiver, *message ); |
|
187 break; |
|
188 default: |
|
189 HandleNotSupportedReqL( sender, receiver, *message ); |
|
190 break; |
|
191 } |
|
192 CleanupStack::PopAndDestroy( message ); |
|
193 } |
|
194 if ( header ) |
|
195 { |
|
196 CleanupStack::PopAndDestroy( header ); |
|
197 } |
|
198 } |
|
199 |
|
200 // ----------------------------------------------------------------------------- |
|
201 // CHsCcProviderClient::DoCancel() |
|
202 // ----------------------------------------------------------------------------- |
|
203 // |
|
204 void CHsCcProviderClient::DoCancel() |
|
205 { |
|
206 if ( IsActive() ) |
|
207 { |
|
208 TPckgBuf<TInt> function( ECcWaitForApiReq ); |
|
209 iSession.CancelReq( function ); |
|
210 } |
|
211 } |
|
212 |
|
213 // ----------------------------------------------------------------------------- |
|
214 // CHsCcProviderClient::NotifyWidgetListChanged() |
|
215 // ----------------------------------------------------------------------------- |
|
216 // |
|
217 void CHsCcProviderClient::NotifyWidgetListChanged() |
|
218 { |
|
219 if ( iObservers.Count() ) |
|
220 { |
|
221 TRAP_IGNORE( SendNtfL( EHsCcWidgetListChangedNtf ) ); |
|
222 } |
|
223 } |
|
224 |
|
225 // ----------------------------------------------------------------------------- |
|
226 // CHsCcProviderClient::NotifyViewListChanged() |
|
227 // ----------------------------------------------------------------------------- |
|
228 // |
|
229 void CHsCcProviderClient::NotifyViewListChanged() |
|
230 { |
|
231 if ( iObservers.Count() ) |
|
232 { |
|
233 TRAP_IGNORE( SendNtfL( EHsCcViewListChangedNtf ) ); |
|
234 } |
|
235 } |
|
236 |
|
237 // ----------------------------------------------------------------------------- |
|
238 // CHsCcProviderClient::NotifyAppListChanged() |
|
239 // ----------------------------------------------------------------------------- |
|
240 // |
|
241 void CHsCcProviderClient::NotifyAppListChanged() |
|
242 { |
|
243 if ( iObservers.Count() ) |
|
244 { |
|
245 TRAP_IGNORE( SendNtfL( EHsCcAppListChangedNtf ) ); |
|
246 } |
|
247 } |
|
248 |
|
249 // ----------------------------------------------------------------------------- |
|
250 // CHsCcProviderClient::WaitForApiReqL() |
|
251 // ----------------------------------------------------------------------------- |
|
252 // |
|
253 void CHsCcProviderClient::WaitForApiReqL() |
|
254 { |
|
255 |
|
256 if ( iApiHeader ) |
|
257 { |
|
258 delete iApiHeader; |
|
259 iApiHeader = NULL; |
|
260 } |
|
261 iApiHeader = HBufC8::NewL( KCcHeaderSize ); |
|
262 iApiHeaderPtr.Set( iApiHeader->Des() ); |
|
263 |
|
264 TPckgBuf<TUint32> provider( ECcHomescreen ); |
|
265 iPckgSender = 0; |
|
266 iPckgReceiver = 0; |
|
267 |
|
268 iSession.WaitForApiReq( provider, iPckgSender, iPckgReceiver, iApiHeaderPtr, iStatus ); |
|
269 SetActive(); |
|
270 |
|
271 } |
|
272 |
|
273 // ----------------------------------------------------------------------------- |
|
274 // CHsCcProviderClient::HandleRegisterObserverNtfL() |
|
275 // ----------------------------------------------------------------------------- |
|
276 // |
|
277 void CHsCcProviderClient::HandleRegisterObserverNtfL( |
|
278 TUint32 aSender, |
|
279 TUint32 /* aReceiver */, |
|
280 CCcSrvMsg& /* aMessage */ ) |
|
281 { |
|
282 iObservers.AppendL( aSender ); |
|
283 } |
|
284 |
|
285 // ----------------------------------------------------------------------------- |
|
286 // CHsCcProviderClient::HandleUnregisterObserverNtfL() |
|
287 // ----------------------------------------------------------------------------- |
|
288 // |
|
289 void CHsCcProviderClient::HandleUnregisterObserverNtfL( |
|
290 TUint32 aSender, |
|
291 TUint32 /* aReceiver */, |
|
292 CCcSrvMsg& /* aMessage */ ) |
|
293 { |
|
294 for ( TInt i = 0; i < iObservers.Count(); i++ ) |
|
295 { |
|
296 if ( iObservers[ i ] == aSender ) |
|
297 { |
|
298 iObservers.Remove( i ); |
|
299 break; |
|
300 } |
|
301 } |
|
302 } |
|
303 |
|
304 // ----------------------------------------------------------------------------- |
|
305 // CHsCcProviderClient::HandleWidgetListReqL() |
|
306 // ----------------------------------------------------------------------------- |
|
307 // |
|
308 void CHsCcProviderClient::HandleWidgetListReqL( |
|
309 TUint32 aSender, |
|
310 TUint32 aReceiver, |
|
311 CCcSrvMsg& aMessage ) |
|
312 { |
|
313 |
|
314 TInt err( KErrNone ); |
|
315 // Get widget list |
|
316 CHsContentInfoArray* widgets = CHsContentInfoArray::NewL(); |
|
317 CleanupStack::PushL( widgets ); |
|
318 |
|
319 if ( aMessage.DataSize() ) |
|
320 { |
|
321 // Internalize message data |
|
322 RDesReadStream dataStream( aMessage.Data() ); |
|
323 CleanupClosePushL( dataStream ); |
|
324 CHsContentInfo* info = CHsContentInfo::NewL( dataStream ); |
|
325 CleanupStack::PopAndDestroy( &dataStream ); |
|
326 CleanupStack::PushL( info ); |
|
327 |
|
328 // Get list of widgets included in the defined |
|
329 // application configuration or view |
|
330 err = iController.WidgetListL( *info, *widgets ); |
|
331 |
|
332 CleanupStack::PopAndDestroy( info ); |
|
333 } |
|
334 else |
|
335 { |
|
336 // Get list of available widgets |
|
337 err = iController.WidgetListL( *widgets ); |
|
338 } |
|
339 |
|
340 // Create and send WidgetListResp |
|
341 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
342 CleanupStack::PushL( message ); |
|
343 message->SetMsgId( EHsCcWidgetListResp ); |
|
344 message->SetTrId( aMessage.TrId() ); |
|
345 message->SetStatus( err ); |
|
346 |
|
347 if ( !err ) |
|
348 { |
|
349 // Externalize widget list |
|
350 HBufC8* dataBuf = widgets->MarshalL(); |
|
351 CleanupStack::PushL( dataBuf ); |
|
352 TPtr8 dataPtr( NULL, 0 ); |
|
353 dataPtr.Set( dataBuf->Des() ); |
|
354 message->SetData( dataPtr ); |
|
355 CleanupStack::PopAndDestroy( dataBuf ); |
|
356 } |
|
357 |
|
358 SendRespL( aReceiver, aSender, *message ); |
|
359 |
|
360 CleanupStack::PopAndDestroy( message ); |
|
361 CleanupStack::PopAndDestroy( widgets ); |
|
362 |
|
363 } |
|
364 |
|
365 // ----------------------------------------------------------------------------- |
|
366 // CHsCcProviderClient::HandleAddWidgetReqL() |
|
367 // ----------------------------------------------------------------------------- |
|
368 // |
|
369 void CHsCcProviderClient::HandleAddWidgetReqL( |
|
370 TUint32 aSender, |
|
371 TUint32 aReceiver, |
|
372 CCcSrvMsg& aMessage ) |
|
373 { |
|
374 TInt err( KErrNone ); |
|
375 if ( aMessage.DataSize() ) |
|
376 { |
|
377 // Internalize message data |
|
378 RDesReadStream dataStream( aMessage.Data() ); |
|
379 CleanupClosePushL( dataStream ); |
|
380 CHsContentInfo* info = CHsContentInfo::NewL( dataStream ); |
|
381 CleanupStack::PopAndDestroy( &dataStream ); |
|
382 CleanupStack::PushL( info ); |
|
383 |
|
384 // Add widget |
|
385 err = iController.AddWidgetL( *info ); |
|
386 |
|
387 CleanupStack::PopAndDestroy( info ); |
|
388 } |
|
389 else |
|
390 { |
|
391 // Mandatory message data missing |
|
392 err = KErrArgument; |
|
393 } |
|
394 |
|
395 // Create and send AddWidgetResp |
|
396 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
397 CleanupStack::PushL( message ); |
|
398 message->SetMsgId( EHsCcAddWidgetResp ); |
|
399 message->SetTrId( aMessage.TrId() ); |
|
400 message->SetStatus( err ); |
|
401 message->SetData( KNullDesC8() ); |
|
402 |
|
403 SendRespL( aReceiver, aSender, *message ); |
|
404 |
|
405 CleanupStack::PopAndDestroy( message ); |
|
406 } |
|
407 |
|
408 // ----------------------------------------------------------------------------- |
|
409 // CHsCcProviderClient::HandleRemoveWidgetReqL() |
|
410 // ----------------------------------------------------------------------------- |
|
411 // |
|
412 void CHsCcProviderClient::HandleRemoveWidgetReqL( |
|
413 TUint32 aSender, |
|
414 TUint32 aReceiver, |
|
415 CCcSrvMsg& aMessage ) |
|
416 { |
|
417 TInt err( KErrNone ); |
|
418 if ( aMessage.DataSize() ) |
|
419 { |
|
420 // Internalize message data |
|
421 RDesReadStream dataStream( aMessage.Data() ); |
|
422 CleanupClosePushL( dataStream ); |
|
423 CHsContentInfo* info = CHsContentInfo::NewL( dataStream ); |
|
424 CleanupStack::PopAndDestroy( &dataStream ); |
|
425 CleanupStack::PushL( info ); |
|
426 |
|
427 // Remove widget |
|
428 err = iController.RemoveWidgetL( *info ); |
|
429 |
|
430 CleanupStack::PopAndDestroy( info ); |
|
431 } |
|
432 else |
|
433 { |
|
434 // Mandatory message data missing |
|
435 err = KErrArgument; |
|
436 } |
|
437 |
|
438 // Create and send RemoveWidgetResp |
|
439 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
440 CleanupStack::PushL( message ); |
|
441 message->SetMsgId( EHsCcRemoveWidgetResp ); |
|
442 message->SetTrId( aMessage.TrId() ); |
|
443 message->SetStatus( err ); |
|
444 message->SetData( KNullDesC8() ); |
|
445 |
|
446 SendRespL( aReceiver, aSender, *message ); |
|
447 |
|
448 CleanupStack::PopAndDestroy( message ); |
|
449 } |
|
450 |
|
451 // ----------------------------------------------------------------------------- |
|
452 // CHsCcProviderClient::HandleViewListReqL() |
|
453 // ----------------------------------------------------------------------------- |
|
454 // |
|
455 void CHsCcProviderClient::HandleViewListReqL( |
|
456 TUint32 aSender, |
|
457 TUint32 aReceiver, |
|
458 CCcSrvMsg& aMessage ) |
|
459 { |
|
460 TInt err( KErrNone ); |
|
461 // Get view list |
|
462 CHsContentInfoArray* views = CHsContentInfoArray::NewL(); |
|
463 CleanupStack::PushL( views ); |
|
464 |
|
465 if ( aMessage.DataSize() ) |
|
466 { |
|
467 // Internalize message data |
|
468 RDesReadStream dataStream( aMessage.Data() ); |
|
469 CleanupClosePushL( dataStream ); |
|
470 CHsContentInfo* info = CHsContentInfo::NewL( dataStream ); |
|
471 CleanupStack::PopAndDestroy( &dataStream ); |
|
472 CleanupStack::PushL( info ); |
|
473 |
|
474 // Get list of views included in the defined |
|
475 // application configuration |
|
476 err = iController.ViewListL( *info, *views ); |
|
477 |
|
478 CleanupStack::PopAndDestroy( info ); |
|
479 } |
|
480 else |
|
481 { |
|
482 // Get list of available views |
|
483 err = iController.ViewListL( *views ); |
|
484 } |
|
485 |
|
486 |
|
487 // Create and send ViewListResp |
|
488 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
489 CleanupStack::PushL( message ); |
|
490 message->SetMsgId( EHsCcViewListResp ); |
|
491 message->SetTrId( aMessage.TrId() ); |
|
492 message->SetStatus( err ); |
|
493 |
|
494 if ( !err ) |
|
495 { |
|
496 // Externalize view list |
|
497 HBufC8* dataBuf = views->MarshalL(); |
|
498 CleanupStack::PushL( dataBuf ); |
|
499 TPtr8 dataPtr( NULL, 0 ); |
|
500 dataPtr.Set( dataBuf->Des() ); |
|
501 message->SetData( dataPtr ); |
|
502 CleanupStack::PopAndDestroy( dataBuf ); |
|
503 } |
|
504 |
|
505 SendRespL( aReceiver, aSender, *message ); |
|
506 |
|
507 CleanupStack::PopAndDestroy( message ); |
|
508 CleanupStack::PopAndDestroy( views ); |
|
509 |
|
510 } |
|
511 |
|
512 // ----------------------------------------------------------------------------- |
|
513 // CHsCcProviderClient::HandleAddViewReqL() |
|
514 // ----------------------------------------------------------------------------- |
|
515 // |
|
516 void CHsCcProviderClient::HandleAddViewReqL( |
|
517 TUint32 aSender, |
|
518 TUint32 aReceiver, |
|
519 CCcSrvMsg& aMessage ) |
|
520 { |
|
521 TInt err( KErrNone ); |
|
522 if ( aMessage.DataSize() ) |
|
523 { |
|
524 // Internalize message data |
|
525 RDesReadStream dataStream( aMessage.Data() ); |
|
526 CleanupClosePushL( dataStream ); |
|
527 CHsContentInfo* info = CHsContentInfo::NewL( dataStream ); |
|
528 CleanupStack::PopAndDestroy( &dataStream ); |
|
529 CleanupStack::PushL( info ); |
|
530 |
|
531 // Add view |
|
532 err = iController.AddViewL( *info ); |
|
533 |
|
534 CleanupStack::PopAndDestroy( info ); |
|
535 } |
|
536 else |
|
537 { |
|
538 // Mandatory message data missing |
|
539 err = KErrArgument; |
|
540 } |
|
541 |
|
542 // Create and send AddViewResp |
|
543 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
544 CleanupStack::PushL( message ); |
|
545 message->SetMsgId( EHsCcAddViewResp ); |
|
546 message->SetTrId( aMessage.TrId() ); |
|
547 message->SetStatus( err ); |
|
548 message->SetData( KNullDesC8() ); |
|
549 |
|
550 SendRespL( aReceiver, aSender, *message ); |
|
551 |
|
552 CleanupStack::PopAndDestroy( message ); |
|
553 } |
|
554 |
|
555 // ----------------------------------------------------------------------------- |
|
556 // CHsCcProviderClient::HandleRemoveViewReqL() |
|
557 // ----------------------------------------------------------------------------- |
|
558 // |
|
559 void CHsCcProviderClient::HandleRemoveViewReqL( |
|
560 TUint32 aSender, |
|
561 TUint32 aReceiver, |
|
562 CCcSrvMsg& aMessage ) |
|
563 { |
|
564 TInt err( KErrNone ); |
|
565 if ( aMessage.DataSize() ) |
|
566 { |
|
567 // Internalize message data |
|
568 RDesReadStream dataStream( aMessage.Data() ); |
|
569 CleanupClosePushL( dataStream ); |
|
570 CHsContentInfo* info = CHsContentInfo::NewL( dataStream ); |
|
571 CleanupStack::PopAndDestroy( &dataStream ); |
|
572 CleanupStack::PushL( info ); |
|
573 |
|
574 // Remove view |
|
575 err = iController.RemoveViewL( *info ); |
|
576 |
|
577 CleanupStack::PopAndDestroy( info ); |
|
578 } |
|
579 else |
|
580 { |
|
581 // Mandatory message data missing |
|
582 err = KErrArgument; |
|
583 } |
|
584 |
|
585 // Create and send RemoveViewResp |
|
586 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
587 CleanupStack::PushL( message ); |
|
588 message->SetMsgId( EHsCcRemoveViewResp ); |
|
589 message->SetTrId( aMessage.TrId() ); |
|
590 message->SetStatus( err ); |
|
591 message->SetData( KNullDesC8() ); |
|
592 |
|
593 SendRespL( aReceiver, aSender, *message ); |
|
594 |
|
595 CleanupStack::PopAndDestroy( message ); |
|
596 } |
|
597 |
|
598 // ----------------------------------------------------------------------------- |
|
599 // CHsCcProviderClient::HandleActivateViewReqL() |
|
600 // ----------------------------------------------------------------------------- |
|
601 // |
|
602 void CHsCcProviderClient::HandleActivateViewReqL( |
|
603 TUint32 aSender, |
|
604 TUint32 aReceiver, |
|
605 CCcSrvMsg& aMessage ) |
|
606 { |
|
607 TInt err( KErrNone ); |
|
608 if ( aMessage.DataSize() ) |
|
609 { |
|
610 // Internalize message data |
|
611 RDesReadStream dataStream( aMessage.Data() ); |
|
612 CleanupClosePushL( dataStream ); |
|
613 CHsContentInfo* info = CHsContentInfo::NewL( dataStream ); |
|
614 CleanupStack::PopAndDestroy( &dataStream ); |
|
615 CleanupStack::PushL( info ); |
|
616 |
|
617 // Activate view |
|
618 err = iController.ActivateViewL( *info ); |
|
619 |
|
620 CleanupStack::PopAndDestroy( info ); |
|
621 } |
|
622 else |
|
623 { |
|
624 // Mandatory message data missing |
|
625 err = KErrArgument; |
|
626 } |
|
627 |
|
628 // Create and send ActivateViewResp |
|
629 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
630 CleanupStack::PushL( message ); |
|
631 message->SetMsgId( EHsCcActivateViewResp ); |
|
632 message->SetTrId( aMessage.TrId() ); |
|
633 message->SetStatus( err ); |
|
634 message->SetData( KNullDesC8() ); |
|
635 |
|
636 SendRespL( aReceiver, aSender, *message ); |
|
637 |
|
638 CleanupStack::PopAndDestroy( message ); |
|
639 } |
|
640 |
|
641 // ----------------------------------------------------------------------------- |
|
642 // CHsCcProviderClient::HandleActiveViewReqL() |
|
643 // ----------------------------------------------------------------------------- |
|
644 // |
|
645 void CHsCcProviderClient::HandleActiveViewReqL( |
|
646 TUint32 aSender, |
|
647 TUint32 aReceiver, |
|
648 CCcSrvMsg& aMessage ) |
|
649 { |
|
650 // Get active view |
|
651 CHsContentInfo* view = CHsContentInfo::NewL(); |
|
652 CleanupStack::PushL( view ); |
|
653 TInt err = iController.ActiveViewL( *view ); |
|
654 |
|
655 // Create and send ActiveViewResp |
|
656 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
657 CleanupStack::PushL( message ); |
|
658 message->SetMsgId( EHsCcActiveViewResp ); |
|
659 message->SetTrId( aMessage.TrId() ); |
|
660 message->SetStatus( err ); |
|
661 |
|
662 if ( !err ) |
|
663 { |
|
664 // Externalize view list |
|
665 HBufC8* dataBuf = view->MarshalL(); |
|
666 CleanupStack::PushL( dataBuf ); |
|
667 TPtr8 dataPtr( NULL, 0 ); |
|
668 dataPtr.Set( dataBuf->Des() ); |
|
669 message->SetData( dataPtr ); |
|
670 CleanupStack::PopAndDestroy( dataBuf ); |
|
671 } |
|
672 |
|
673 SendRespL( aReceiver, aSender, *message ); |
|
674 |
|
675 CleanupStack::PopAndDestroy( message ); |
|
676 CleanupStack::PopAndDestroy( view ); |
|
677 |
|
678 } |
|
679 |
|
680 // ----------------------------------------------------------------------------- |
|
681 // CHsCcProviderClient::HandleAppListReqL() |
|
682 // ----------------------------------------------------------------------------- |
|
683 // |
|
684 void CHsCcProviderClient::HandleAppListReqL( |
|
685 TUint32 aSender, |
|
686 TUint32 aReceiver, |
|
687 CCcSrvMsg& aMessage ) |
|
688 { |
|
689 // Get app list |
|
690 CHsContentInfoArray* apps = CHsContentInfoArray::NewL(); |
|
691 CleanupStack::PushL( apps ); |
|
692 TInt err = iController.AppListL( *apps ); |
|
693 |
|
694 // Create and send AppListResp |
|
695 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
696 CleanupStack::PushL( message ); |
|
697 message->SetMsgId( EHsCcAppListResp ); |
|
698 message->SetTrId( aMessage.TrId() ); |
|
699 message->SetStatus( err ); |
|
700 if ( !err ) |
|
701 { |
|
702 // Externalize app list |
|
703 HBufC8* dataBuf = apps->MarshalL(); |
|
704 CleanupStack::PushL( dataBuf ); |
|
705 TPtr8 dataPtr( NULL, 0 ); |
|
706 dataPtr.Set( dataBuf->Des() ); |
|
707 message->SetData( dataPtr ); |
|
708 CleanupStack::PopAndDestroy( dataBuf ); |
|
709 } |
|
710 |
|
711 SendRespL( aReceiver, aSender, *message ); |
|
712 |
|
713 CleanupStack::PopAndDestroy( message ); |
|
714 CleanupStack::PopAndDestroy( apps ); |
|
715 |
|
716 } |
|
717 |
|
718 // ----------------------------------------------------------------------------- |
|
719 // CHsCcProviderClient::HandleActivateAppReqL() |
|
720 // ----------------------------------------------------------------------------- |
|
721 // |
|
722 void CHsCcProviderClient::HandleActivateAppReqL( |
|
723 TUint32 aSender, |
|
724 TUint32 aReceiver, |
|
725 CCcSrvMsg& aMessage ) |
|
726 { |
|
727 TInt err( KErrNone ); |
|
728 if ( aMessage.DataSize() ) |
|
729 { |
|
730 // Internalize message data |
|
731 RDesReadStream dataStream( aMessage.Data() ); |
|
732 CleanupClosePushL( dataStream ); |
|
733 CHsContentInfo* info = CHsContentInfo::NewL( dataStream ); |
|
734 CleanupStack::PopAndDestroy( &dataStream ); |
|
735 CleanupStack::PushL( info ); |
|
736 |
|
737 // Activate view |
|
738 err = iController.ActivateAppL( *info ); |
|
739 |
|
740 CleanupStack::PopAndDestroy( info ); |
|
741 } |
|
742 else |
|
743 { |
|
744 // Mandatory message data missing |
|
745 err = KErrArgument; |
|
746 } |
|
747 |
|
748 // Create and send ActivateAppResp |
|
749 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
750 CleanupStack::PushL( message ); |
|
751 message->SetMsgId( EHsCcActivateAppResp ); |
|
752 message->SetTrId( aMessage.TrId() ); |
|
753 message->SetStatus( err ); |
|
754 message->SetData( KNullDesC8() ); |
|
755 |
|
756 SendRespL( aReceiver, aSender, *message ); |
|
757 |
|
758 CleanupStack::PopAndDestroy( message ); |
|
759 } |
|
760 |
|
761 // ----------------------------------------------------------------------------- |
|
762 // CHsCcProviderClient::HandleActiveAppReqL() |
|
763 // ----------------------------------------------------------------------------- |
|
764 // |
|
765 void CHsCcProviderClient::HandleActiveAppReqL( |
|
766 TUint32 aSender, |
|
767 TUint32 aReceiver, |
|
768 CCcSrvMsg& aMessage ) |
|
769 { |
|
770 // Get active application info |
|
771 CHsContentInfo* app = CHsContentInfo::NewL(); |
|
772 CleanupStack::PushL( app ); |
|
773 TInt err = iController.ActiveAppL( *app ); |
|
774 |
|
775 // Create and send ActiveViewResp |
|
776 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
777 CleanupStack::PushL( message ); |
|
778 message->SetMsgId( EHsCcActiveAppResp ); |
|
779 message->SetTrId( aMessage.TrId() ); |
|
780 message->SetStatus( err ); |
|
781 |
|
782 if ( !err ) |
|
783 { |
|
784 // Externalize application info |
|
785 HBufC8* dataBuf = app->MarshalL(); |
|
786 CleanupStack::PushL( dataBuf ); |
|
787 TPtr8 dataPtr( NULL, 0 ); |
|
788 dataPtr.Set( dataBuf->Des() ); |
|
789 message->SetData( dataPtr ); |
|
790 CleanupStack::PopAndDestroy( dataBuf ); |
|
791 } |
|
792 |
|
793 SendRespL( aReceiver, aSender, *message ); |
|
794 |
|
795 CleanupStack::PopAndDestroy( message ); |
|
796 CleanupStack::PopAndDestroy( app ); |
|
797 } |
|
798 |
|
799 // ----------------------------------------------------------------------------- |
|
800 // CHsCcProviderClient::HandleNotSupportedReqL() |
|
801 // ----------------------------------------------------------------------------- |
|
802 // |
|
803 void CHsCcProviderClient::HandleNotSupportedReqL( |
|
804 TUint32 aSender, |
|
805 TUint32 aReceiver, |
|
806 CCcSrvMsg& aMessage ) |
|
807 { |
|
808 // Create and send NotSupportedResp |
|
809 CCcSrvMsg* message = CCcSrvMsg::NewL(); |
|
810 CleanupStack::PushL( message ); |
|
811 message->SetMsgId( EHsCcNotSupportedResp ); |
|
812 message->SetTrId( aMessage.TrId() ); |
|
813 message->SetStatus( KErrNone ); |
|
814 message->SetData( KNullDesC8() ); |
|
815 |
|
816 SendRespL( aReceiver, aSender, *message ); |
|
817 |
|
818 CleanupStack::PopAndDestroy( message ); |
|
819 |
|
820 } |
|
821 |
|
822 // ----------------------------------------------------------------------------- |
|
823 // CHsCcProviderClient::SendNtfL() |
|
824 // ----------------------------------------------------------------------------- |
|
825 // |
|
826 void CHsCcProviderClient::SendNtfL( |
|
827 TUint32 aNtf ) |
|
828 { |
|
829 // Notify registered observers |
|
830 CCcSrvMsg* ntf = CCcSrvMsg::NewL(); |
|
831 CleanupStack::PushL( ntf ); |
|
832 ntf->SetMsgId( aNtf ); |
|
833 HBufC8* ntfBuf = ntf->MarshalL(); |
|
834 CleanupStack::PushL( ntfBuf ); |
|
835 TPtr8 ntfPtr( NULL, 0 ); |
|
836 ntfPtr.Set( ntfBuf->Des() ); |
|
837 |
|
838 TPckgBuf<TUint32> provider( ECcHomescreen ); |
|
839 TPckgBuf<TUint32> sender( iAddress ); |
|
840 TPckgBuf<TUint32> receiver( 0 ); |
|
841 iSession.Send( ECcApiNtf, provider, sender, receiver, ntfPtr ); |
|
842 |
|
843 CleanupStack::PopAndDestroy( ntfBuf ); |
|
844 CleanupStack::PopAndDestroy( ntf ); |
|
845 } |
|
846 |
|
847 // ----------------------------------------------------------------------------- |
|
848 // CHsCcProviderClient::SendRespL() |
|
849 // ----------------------------------------------------------------------------- |
|
850 // |
|
851 void CHsCcProviderClient::SendRespL( |
|
852 TUint32 aSender, |
|
853 TUint32 aReceiver, |
|
854 CCcSrvMsg& aMessage ) |
|
855 { |
|
856 HBufC8* msgBuf = aMessage.MarshalL(); |
|
857 CleanupStack::PushL( msgBuf ); |
|
858 TPtr8 msgPtr( NULL, 0 ); |
|
859 msgPtr.Set( msgBuf->Des() ); |
|
860 |
|
861 TPckgBuf<TUint32> provider( ECcHomescreen ); |
|
862 TPckgBuf<TUint32> sender( aSender ); |
|
863 TPckgBuf<TUint32> receiver( aReceiver ); |
|
864 iSession.Send( ECcApiResp, provider, sender, receiver, msgPtr ); |
|
865 |
|
866 CleanupStack::PopAndDestroy( msgBuf ); |
|
867 } |
|
868 |
|
869 // End of file |