|
1 /* |
|
2 * Copyright (c) 2004-2007 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: Local video configuration |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 // INCLUDE FILES |
|
21 #include "CVtEngLocalVideo.h" |
|
22 #include "CVtEngMediaHandler.h" |
|
23 #include "VtEngPanic.h" |
|
24 #include "MVtEngFrameObserver.h" |
|
25 #include "CVtEngStateManager.h" |
|
26 #include "CVtEngEventManager.h" |
|
27 #include "MVtEngMedia.h" |
|
28 #include "CVtEngSettings.h" |
|
29 #include "VtEngUtils.h" |
|
30 #include "VtEngEvents.h" |
|
31 #include <videotelephonydomainpskeys.h> |
|
32 #include <videotelephonyvariant.hrh> |
|
33 #include <capivideosource.h> |
|
34 #include <cvtlogger.h> |
|
35 #include <mvtprotocolhandler.h> |
|
36 |
|
37 #include "CVtEngCameraPreferences.h" |
|
38 |
|
39 // LOCAL CONSTANTS AND MACROS |
|
40 |
|
41 // Maximum count of providers stored (cameras, still, blank) |
|
42 const TInt KVtEngProviderCountMax = 4; |
|
43 |
|
44 // Max zoom step count. |
|
45 const TInt KVtMaxZoomStep = 10; |
|
46 |
|
47 // If prepare camera is called when provider is ready signal |
|
48 // immediately back with positive value. |
|
49 const TInt KVtEngAlreadySelected = 1; |
|
50 |
|
51 // If source is already active signal with this. |
|
52 const TInt KVtEngAlreadyActive = 2; |
|
53 |
|
54 // Number of providers buffered in image sharer |
|
55 const TInt KVtEngNumProvidersBuffered = 2; |
|
56 |
|
57 // ============================ MEMBER FUNCTIONS =============================== |
|
58 |
|
59 // ----------------------------------------------------------------------------- |
|
60 // CVtEngLocalVideo::CVtEngLocalVideo |
|
61 // C++ constructor can NOT contain any code, that |
|
62 // might leave. |
|
63 // ----------------------------------------------------------------------------- |
|
64 // |
|
65 CVtEngLocalVideo::CVtEngLocalVideo( |
|
66 CVtEngMediaHandler& aObserver ) |
|
67 |
|
68 /** priority is high to ensure that this AO gets scheduled as soon as |
|
69 * possible after signaling. If local video is requested a service, e.g. |
|
70 * source switch while its signaled but not yet scheduled, local video's |
|
71 * internal state may be compromised (signal AO => start selecting new source |
|
72 * => RunL [this would break ongoing source selection] |
|
73 */ |
|
74 : CActive( EPriorityHigh ), |
|
75 iRenderingMethod( EUnspecified ), |
|
76 iObserver( aObserver ), |
|
77 iCurrentCamera( MVtEngMedia::ESecondaryCamera ), |
|
78 iLayoutChangeHandler( *this ) |
|
79 { |
|
80 ResetIndices(); |
|
81 __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.c++") |
|
82 CActiveScheduler::Add( this ); |
|
83 } |
|
84 |
|
85 // ----------------------------------------------------------------------------- |
|
86 // CVtEngLocalVideo::ConstructL |
|
87 // Symbian 2nd phase constructor can leave. |
|
88 // ----------------------------------------------------------------------------- |
|
89 // |
|
90 void CVtEngLocalVideo::ConstructL() |
|
91 { |
|
92 __VTPRINTENTER( "LocVideo.ConstructL" ) |
|
93 |
|
94 iAsyncCallBack = new ( ELeave ) CAsyncCallBack( |
|
95 TCallBack( CallBackFunc, this ), EPriorityStandard ); |
|
96 |
|
97 TInt indexMobile( KErrNotFound ); |
|
98 iShareImage = CVtEngShareImage::NewL( *this ); |
|
99 iSourceController = CVSController::NewL( this ); |
|
100 iVideoProviders = |
|
101 new ( ELeave ) CArrayFixFlat<TProviderItem>( KVtEngProviderCountMax ); |
|
102 iSource = iSourceController->CreateDataSourceL( this ); |
|
103 PauseVideoSending(); |
|
104 TInt providers( iSourceController->ProvidersAvailable() ); |
|
105 iNumSupportedCameras = providers - 1; |
|
106 ResetIndices(); |
|
107 __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.providers=%d",providers) |
|
108 // Get the device specified default camera. |
|
109 TInt cameraId( iCurrentCamera ); |
|
110 TInt err( SetCameraTrackingL( cameraId ) ); |
|
111 if ( err == KErrNone && cameraId != EPSPreferredCameraUnknown ) |
|
112 { |
|
113 // Only if valid camera. |
|
114 iCurrentCamera = MapCameraInternally( cameraId ); |
|
115 err = KErrAlreadyExists; |
|
116 } |
|
117 |
|
118 while ( providers-- ) |
|
119 { |
|
120 CVSDataProvider* provider = NULL; |
|
121 TRAP_IGNORE( provider = |
|
122 iSourceController->CreateDataProviderL( providers, this, iSource ) ); |
|
123 if ( provider ) |
|
124 { |
|
125 CleanupStack::PushL( provider ); |
|
126 TProviderItem item; |
|
127 TVSDataProviderInfo info; |
|
128 provider->ProviderInfo( info ); |
|
129 TBool destroy( ETrue ); |
|
130 __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.Orient=%d", |
|
131 info.iOrientation ) |
|
132 switch ( info.iOrientation ) |
|
133 { |
|
134 case TCameraInfo::EOrientationInwards: |
|
135 SetFlag( EFlagCamera1Available ); |
|
136 item.iType = KVtEngProviderCam1; |
|
137 if ( err != KErrAlreadyExists ) |
|
138 { |
|
139 // Set only if value not obtained from PubSub |
|
140 iCurrentCamera = MVtEngMedia::EPrimaryCamera; |
|
141 } |
|
142 iProviderInfoIndexCam1 = providers; |
|
143 __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.ConL ID C1=%d", |
|
144 iProviderInfoIndexCam1 ) |
|
145 break; |
|
146 case TCameraInfo::EOrientationOutwards: |
|
147 // Configures outwards camera, it is treated as camera 1 |
|
148 // if there is only one camera in the device. |
|
149 ConfigureOutwardsCameraItem( item, providers ); |
|
150 break; |
|
151 case TCameraInfo::EOrientationMobile: |
|
152 __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.Mobile") |
|
153 item.iType = KVtEngProviderTempImage; |
|
154 indexMobile = providers; |
|
155 __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.Mobile ID=%d", |
|
156 indexMobile ) |
|
157 break; |
|
158 case TCameraInfo::EOrientationUnknown: |
|
159 { |
|
160 item.iType = KVtEngProviderImage; |
|
161 item.iProvider = provider; |
|
162 item.iProviderState = EPermanent; |
|
163 destroy = EFalse; // don't delete still provider |
|
164 CreateBlankProviderL( providers ); |
|
165 |
|
166 if ( CVtEngUtility::Settings(). |
|
167 IsDefaultStillImageDefined() ) |
|
168 { |
|
169 CreateDefaultStillImageProviderL( providers ); |
|
170 } |
|
171 |
|
172 iProviderInfoIndexStill = providers; |
|
173 __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT, |
|
174 "LocVideo.ConL ID Still=%d",iProviderInfoIndexStill ) |
|
175 } |
|
176 break; |
|
177 default: |
|
178 break; |
|
179 } |
|
180 iVideoProviders->AppendL( item ); |
|
181 CleanupStack::Pop(); |
|
182 if ( destroy ) |
|
183 { |
|
184 delete provider; |
|
185 provider = NULL; |
|
186 } |
|
187 } |
|
188 } |
|
189 iObserver.SetSelectedCameraId( iCurrentCamera ); |
|
190 // Check if mobile is there, and either 1 or 2 is not. |
|
191 |
|
192 if ( indexMobile != KErrNotFound ) |
|
193 { |
|
194 TProviderItem* item = NULL; |
|
195 const TInt err = GetProviderByType( KVtEngProviderTempImage, item ); |
|
196 __ASSERT_ALWAYS( err != KErrNotFound, |
|
197 Panic( EVtEngPanicInvalidInitializationState ) ); |
|
198 if ( iProviderInfoIndexCam1 == KErrNotFound ) |
|
199 { |
|
200 __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.ConL Switch 1" ) |
|
201 item->iType = KVtEngProviderCam1; |
|
202 iProviderInfoIndexCam1 = indexMobile; |
|
203 SetFlag( EFlagCamera1Available ); |
|
204 } |
|
205 else |
|
206 { |
|
207 __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.ConL Switch 2" ) |
|
208 DeleteProvider( KVtEngProviderCam2 ); |
|
209 item->iType = KVtEngProviderCam2; |
|
210 iProviderInfoIndexCam2 = indexMobile; |
|
211 SetFlag( EFlagCamera2Available ); |
|
212 } |
|
213 } |
|
214 __VTPRINTEXIT( "LocVideo.ConstructL" ) |
|
215 } |
|
216 |
|
217 // ----------------------------------------------------------------------------- |
|
218 // CVtEngLocalVideo::ConfigureOutwardsCameraItem |
|
219 // Creates providers item for outwards camera type. It is treated as |
|
220 // a) primary camera in single camera configurations |
|
221 // b) secondary camera in two camera configurations |
|
222 // ----------------------------------------------------------------------------- |
|
223 // |
|
224 void CVtEngLocalVideo::ConfigureOutwardsCameraItem( |
|
225 TProviderItem& aItem, |
|
226 const TInt aCurrentIndex ) |
|
227 { |
|
228 __VTPRINTENTER( "LocVideo.ConfigureOutwardsCameraItem" ) |
|
229 if ( iNumSupportedCameras == 1 ) |
|
230 { |
|
231 SetFlag( EFlagCamera1Available ); |
|
232 aItem.iType = KVtEngProviderCam1; |
|
233 iProviderInfoIndexCam1 = aCurrentIndex; |
|
234 iCurrentCamera = MVtEngMedia::EPrimaryCamera; |
|
235 __VTPRINT2( DEBUG_MEDIA, |
|
236 "LocVideo.ConL ID C1=%d", iProviderInfoIndexCam1 ) |
|
237 } |
|
238 else |
|
239 { |
|
240 SetFlag( EFlagCamera2Available ); |
|
241 aItem.iType = KVtEngProviderCam2; |
|
242 iProviderInfoIndexCam2 = aCurrentIndex; |
|
243 __VTPRINT2( DEBUG_MEDIA, |
|
244 "LocVideo.ConL ID C2=%d", iProviderInfoIndexCam2 ) |
|
245 } |
|
246 __VTPRINTEXITR( "LocVideo.ConfigureOutwardsCameraItem iCurrentCamera=%d", |
|
247 iCurrentCamera ) |
|
248 } |
|
249 |
|
250 // ----------------------------------------------------------------------------- |
|
251 // CVtEngLocalVideo::CallBackFunc |
|
252 // ----------------------------------------------------------------------------- |
|
253 // |
|
254 void CVtEngLocalVideo::CompleteOperation( const TInt aResult ) |
|
255 { |
|
256 __VTPRINTENTER( "LocVideo.CompleteOperation" ) |
|
257 SetResult( aResult ); |
|
258 iAsyncCallBack->CallBack(); |
|
259 __VTPRINTEXITR( "LocVideo.CompleteOperation %d", aResult ) |
|
260 } |
|
261 |
|
262 // ----------------------------------------------------------------------------- |
|
263 // CVtEngLocalVideo::VideoChannelOpenedL |
|
264 // ----------------------------------------------------------------------------- |
|
265 // |
|
266 void CVtEngLocalVideo::VideoChannelOpenedL() |
|
267 { |
|
268 __VTPRINTENTER( "LocVideo.VideoChannelOpenedL" ) |
|
269 if ( iDelayedSelect.IsDelayedSelectPending() ) |
|
270 { |
|
271 SelectSourceL( iDelayedSelect.DelayedSelectTarget() ); |
|
272 } |
|
273 __VTPRINTEXIT( "LocVideo.VideoChannelOpenedL" ) |
|
274 } |
|
275 |
|
276 // ----------------------------------------------------------------------------- |
|
277 // CVtEngLocalVideo::CallBackFunc |
|
278 // ----------------------------------------------------------------------------- |
|
279 // |
|
280 TInt CVtEngLocalVideo::CallBackFunc( TAny* aPtr ) |
|
281 { |
|
282 __VTPRINTENTER( "LocVideo.CallBackFunc" ) |
|
283 CVtEngLocalVideo* self = reinterpret_cast< CVtEngLocalVideo* >( aPtr ); |
|
284 TInt result( KErrNone ); |
|
285 TRAP( result, |
|
286 self->iObserver.HandleLocalVideoOperationCompleteL( |
|
287 self->Result() ) ); |
|
288 __VTPRINTEXITR( "LocVideo.CallBackFunc %d", result ) |
|
289 return result; |
|
290 } |
|
291 |
|
292 // ----------------------------------------------------------------------------- |
|
293 // CVtEngLocalVideo::Result |
|
294 // ----------------------------------------------------------------------------- |
|
295 // |
|
296 TInt CVtEngLocalVideo::Result() const |
|
297 { |
|
298 __VTPRINTENTER( "LocVideo.Result" ) |
|
299 __VTPRINTEXITR( "LocVideo.Result %d", iResult ) |
|
300 return iResult; |
|
301 } |
|
302 |
|
303 // ----------------------------------------------------------------------------- |
|
304 // CVtEngLocalVideo::SetResult |
|
305 // ----------------------------------------------------------------------------- |
|
306 // |
|
307 void CVtEngLocalVideo::SetResult( const TInt aResult ) |
|
308 { |
|
309 __VTPRINTENTER( "LocVideo.SetResult" ) |
|
310 iResult = aResult; |
|
311 __VTPRINTEXITR( "LocVideo.SetResult %d", iResult ) |
|
312 } |
|
313 |
|
314 // ----------------------------------------------------------------------------- |
|
315 // CVtEngLocalVideo::NewL |
|
316 // Two-phased constructor. |
|
317 // ----------------------------------------------------------------------------- |
|
318 // |
|
319 CVtEngLocalVideo* CVtEngLocalVideo::NewL( |
|
320 CVtEngMediaHandler& aObserver ) |
|
321 { |
|
322 __VTPRINTENTER( "LocVid.NewL" ) |
|
323 CVtEngLocalVideo* self = new( ELeave ) |
|
324 CVtEngLocalVideo( aObserver ); |
|
325 CleanupStack::PushL( self ); |
|
326 self->ConstructL( ); |
|
327 CleanupStack::Pop(); |
|
328 __VTPRINTEXIT( "LocVid.NewL" ) |
|
329 return self; |
|
330 } |
|
331 |
|
332 |
|
333 // ----------------------------------------------------------------------------- |
|
334 // CVtEngLocalVideo::~CVtEngLocalVideo |
|
335 // Destructor. Cannot leave. |
|
336 // ----------------------------------------------------------------------------- |
|
337 // |
|
338 CVtEngLocalVideo::~CVtEngLocalVideo() |
|
339 { |
|
340 __VTPRINTENTER( "LocVid.~" ) |
|
341 // Cancel the object |
|
342 if ( iActiveProvider ) |
|
343 { |
|
344 iActiveProvider->DetachFromCameraPreferences(); |
|
345 } |
|
346 if ( iAsyncCallBack ) |
|
347 { |
|
348 iAsyncCallBack->Cancel(); |
|
349 delete iAsyncCallBack; |
|
350 } |
|
351 Cancel(); |
|
352 if ( iVideoProviders ) |
|
353 { |
|
354 while ( iVideoProviders->Count() ) |
|
355 { |
|
356 TProviderItem& item = (*iVideoProviders)[0]; |
|
357 CVSDataProvider* provider = item.iProvider; |
|
358 delete provider; |
|
359 iVideoProviders->Delete( 0 ); |
|
360 } |
|
361 delete iVideoProviders; |
|
362 } |
|
363 |
|
364 delete iCameraListener; |
|
365 iCameraListener = NULL; |
|
366 |
|
367 delete iSource; |
|
368 delete iSourceController; |
|
369 DeleteAudioSource(); |
|
370 delete iShareImage; |
|
371 __VTPRINTEXIT( "LocVid.~" ) |
|
372 } |
|
373 |
|
374 // ----------------------------------------------------------------------------- |
|
375 // CVtEngLocalVideo::vsProviderError |
|
376 // Handles error in provider. |
|
377 // ----------------------------------------------------------------------------- |
|
378 // |
|
379 void CVtEngLocalVideo::vsProviderError( TInt aError ) |
|
380 { |
|
381 if( aError == KErrCancel ) |
|
382 { |
|
383 vsProviderReady(); |
|
384 return; |
|
385 } |
|
386 __VTPRINTENTER( "LocVid.vsProviderError" ) |
|
387 __VTPRINT2( DEBUG_MEDIA, "LocVideo.ProviderError=%d", aError ) |
|
388 iInitializingProvider = NULL; |
|
389 if ( aError != KErrNone ) |
|
390 { |
|
391 iShareImage->Error( aError ); |
|
392 if ( !iLayoutChangeHandler.ProviderError( aError ) ) |
|
393 { |
|
394 const TState previousState = iState; |
|
395 iState = ELocNone; |
|
396 __VTPRINT( DEBUG_MEDIA, " STATE TO NONE" ) |
|
397 |
|
398 // If the error indicates that camera is in use |
|
399 if ( aError == KErrInUse && previousState == ELocInitializing ) |
|
400 { |
|
401 // Store the error to be used later |
|
402 if( iSelectedProvider ) |
|
403 { |
|
404 __VTPRINT( DEBUG_MEDIA, |
|
405 "LocVideo.ProviderError in use") |
|
406 iSelectedProvider->iErrorCode = aError; |
|
407 if ( iSelectedProvider->iType == KVtEngProviderCam1 ) |
|
408 { |
|
409 ClearFlag( EFlagCamera1Available ); |
|
410 } |
|
411 else if ( iSelectedProvider->iType == KVtEngProviderCam2 ) |
|
412 { |
|
413 ClearFlag( EFlagCamera2Available ); |
|
414 } |
|
415 } |
|
416 } |
|
417 // Camera has been lost |
|
418 if ( aError == KVsErrCameraNoLongerReserved ) |
|
419 { |
|
420 if ( !IsActive() ) |
|
421 { |
|
422 SetActive(); |
|
423 TRequestStatus* status = &iStatus; |
|
424 User::RequestComplete( status, aError ); |
|
425 __VTPRINT( DEBUG_MEDIA, |
|
426 "LocVideo.ProviderError AO start" ) |
|
427 __VTPRINTEXITR( |
|
428 "LocVid.vsProviderError err=%d", aError ) |
|
429 |
|
430 __VTPRINT( DEBUG_MEDIA, |
|
431 "LocVideo.ProviderError iSelectedProvider NULL" ) |
|
432 if ( iSelectedProvider ) |
|
433 { |
|
434 __VTPRINT( DEBUG_MEDIA, |
|
435 "LocVideo.ProviderError iSelectedProvider NULL" ) |
|
436 iSelectedProvider->iInitialized = EFalse; |
|
437 iSelectedProvider->iProviderState = |
|
438 (CVtEngLocalVideo::TProviderState) aError; |
|
439 __VTPRINT( DEBUG_MEDIA, |
|
440 "LocVideo.ProviderError iSelectedProvider NULL" ) |
|
441 } |
|
442 return; |
|
443 } |
|
444 } |
|
445 if ( iSelectedProvider ) |
|
446 { |
|
447 // Try to select the last known to function camera |
|
448 if ( iSelectedProvider->iType == KVtEngProviderCam1 || |
|
449 iSelectedProvider->iType == KVtEngProviderCam2 ) |
|
450 { |
|
451 if ( !IsActive() ) |
|
452 { |
|
453 SetActive(); |
|
454 TRequestStatus* status = &iStatus; |
|
455 User::RequestComplete( status, aError ); |
|
456 __VTPRINT( DEBUG_MEDIA, |
|
457 "LocVideo.ProviderError AO start" ) |
|
458 __VTPRINTEXITR( |
|
459 "LocVid.vsProviderError err=%d", aError ) |
|
460 return; |
|
461 } |
|
462 } |
|
463 //Error code needed later |
|
464 iSelectedProvider->iInitialized = EFalse; |
|
465 iSelectedProvider->iProviderState = |
|
466 (CVtEngLocalVideo::TProviderState) aError; |
|
467 iSelectedProvider = NULL; |
|
468 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, |
|
469 " selected provider nulled" ) |
|
470 } |
|
471 else if ( iActiveProvider && |
|
472 !IsFlag( EFlagInitializeOnly ) && |
|
473 previousState == ELocSwichingProvider ) |
|
474 { |
|
475 iActiveProvider = iFadingProvider; |
|
476 iFadingProvider = NULL; |
|
477 } |
|
478 if ( IsFlag( EFlagSignalSourceSelection ) ) |
|
479 { |
|
480 ClearFlag( EFlagSignalSourceSelection ); |
|
481 TRAP_IGNORE( |
|
482 iObserver.HandleLocalVideoOperationCompleteL( aError ) ); |
|
483 } |
|
484 } |
|
485 } |
|
486 __VTPRINTEXIT( "LocVid.vsProviderError" ) |
|
487 } |
|
488 |
|
489 // ----------------------------------------------------------------------------- |
|
490 // CVtEngLocalVideo::vsProviderReady |
|
491 // Provider is ready to be taken into use. |
|
492 // ----------------------------------------------------------------------------- |
|
493 // |
|
494 void CVtEngLocalVideo::vsProviderReady() |
|
495 { |
|
496 __VTPRINTENTER( "LocVid.vsProviderReady" ) |
|
497 |
|
498 __VTPRINT3( DEBUG_MEDIA, "LocVideo.ProviderReady state=%d, initOnly=%d", |
|
499 iState, IsFlag( EFlagInitializeOnly ) ) |
|
500 const TState prevState( iState ); |
|
501 |
|
502 if ( iInitializingProvider ) |
|
503 { |
|
504 iInitializingProvider->iInitialized = ETrue; |
|
505 |
|
506 // Set camera flags in order to recover |
|
507 // error situation (error occured during init) |
|
508 if ( iInitializingProvider->iType == KVtEngProviderCam1 ) |
|
509 { |
|
510 __VTPRINT( DEBUG_MEDIA, " LocVid.vsProviderReady KVtEngProviderCam1" ) |
|
511 SetFlag( EFlagCamera1Available ); |
|
512 } |
|
513 else if ( iInitializingProvider->iType == KVtEngProviderCam2 ) |
|
514 { |
|
515 __VTPRINT( DEBUG_MEDIA, " LocVid.vsProviderReady KVtEngProviderCam2" ) |
|
516 SetFlag( EFlagCamera2Available ); |
|
517 } |
|
518 |
|
519 iInitializingProvider = NULL; |
|
520 } |
|
521 |
|
522 iState = ELocReady; |
|
523 __VTPRINT( DEBUG_MEDIA, " STATE TO READY" ) |
|
524 |
|
525 if ( iLayoutChangeHandler.ProviderReady() ) |
|
526 { |
|
527 __VTPRINTEXIT( "LocVid.vsProviderReady" ) |
|
528 return; |
|
529 } |
|
530 |
|
531 if ( prevState == ELocInitializing && !IsFlag( EFlagInitializeOnly ) ) |
|
532 { |
|
533 TProviderItem* switchTo = iActiveProvider; |
|
534 if ( iSelectedProvider ) |
|
535 { |
|
536 iSelectedProvider->iErrorCode = KErrNone; |
|
537 switchTo = iSelectedProvider; |
|
538 iSelectedProvider = NULL; |
|
539 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, " selected provider nulled" ) |
|
540 } |
|
541 __VTPRINT( DEBUG_MEDIA, "LocVideo.ProviderReady switching") |
|
542 SwitchProvider( switchTo ); |
|
543 __VTPRINTEXIT( "LocVid.vsProviderReady" ) |
|
544 return; |
|
545 } |
|
546 else |
|
547 { |
|
548 iSelectedProvider = NULL; |
|
549 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "Selected provider nulled, UDS" ) |
|
550 UpdateState(); |
|
551 __VTPRINT( DEBUG_MEDIA, |
|
552 "LocVideo.vsProviderReady KVtEngSourceCapsChanged") |
|
553 CVtEngEventManager::NotifyEvent( KVtEngSourceCapsChanged ); |
|
554 } |
|
555 |
|
556 if ( IsFlag( EFlagSignalSourceSelection ) ) |
|
557 { |
|
558 ClearFlag( EFlagSignalSourceSelection ); |
|
559 TRAP_IGNORE( iObserver.HandleLocalVideoOperationCompleteL( KErrNone ) ); |
|
560 } |
|
561 __VTPRINTEXIT( "LocVid.vsProviderReady" ) |
|
562 } |
|
563 |
|
564 // ----------------------------------------------------------------------------- |
|
565 // CVtEngLocalVideo::vsProviderSwitchDone |
|
566 // Provider switched. |
|
567 // ----------------------------------------------------------------------------- |
|
568 // |
|
569 void CVtEngLocalVideo::vsProviderSwitchDone( CVSDataProvider* aOldProvider ) |
|
570 { |
|
571 __VTPRINTENTER( "LocVid.vsProviderSwitchDone" ) |
|
572 iState = ELocReady; |
|
573 __VTPRINT( DEBUG_MEDIA, " STATE TO READY" ) |
|
574 |
|
575 iFadingProvider = NULL; |
|
576 |
|
577 if ( iActiveProvider && iActiveProvider->iProvider ) |
|
578 { |
|
579 iActiveProvider->iProvider->ProviderInfo( iProviderInfo ); |
|
580 TInt error( iActiveProvider->RestoreZoomFactor() ); |
|
581 if ( error ) |
|
582 { |
|
583 __VTPRINT2( DEBUG_MEDIA, |
|
584 "LocVid.vsProviderSwitchDone restoring stored zoom FAILED %d", |
|
585 error ) |
|
586 } |
|
587 } |
|
588 |
|
589 iShareImage->ProviderSwitchDone( aOldProvider ); |
|
590 |
|
591 if ( iActiveProvider && iActiveProvider->iType == KVtEngProviderCam1 ) |
|
592 { |
|
593 iCurrentCamera = MVtEngMedia::EPrimaryCamera; |
|
594 iObserver.SetSelectedCameraId( iCurrentCamera ); |
|
595 } |
|
596 else if ( iActiveProvider && iActiveProvider->iType == KVtEngProviderCam2 ) |
|
597 { |
|
598 iCurrentCamera = MVtEngMedia::ESecondaryCamera; |
|
599 iObserver.SetSelectedCameraId( iCurrentCamera ); |
|
600 } |
|
601 |
|
602 // Let layout change handler handle providerswitch |
|
603 if ( iLayoutChangeHandler.ProviderSwitchDone( aOldProvider ) ) |
|
604 { |
|
605 CVtEngEventManager::NotifyEvent( KVtEngLCHProviderSwitchDone ); |
|
606 __VTPRINTEXIT( "LocVid.vsProviderSwitchDone" ) |
|
607 return; |
|
608 } |
|
609 |
|
610 ClearFlag( EFlagFrozen ); |
|
611 |
|
612 // If initilization of the waiting provider fails fall back to the last one. |
|
613 TVtEngProviderType backupProviderType( KVtEngProviderNone ); |
|
614 |
|
615 // Delete non-permanent old provider |
|
616 const TInt indexI( ProviderIndexByInstance( aOldProvider ) ); |
|
617 |
|
618 // delete provider that became unavailable |
|
619 if ( indexI != KErrNotFound ) |
|
620 { |
|
621 __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, |
|
622 "LocVideo.providerSwitchDone indexInstance=%d", indexI ) |
|
623 TProviderItem& item( ( *iVideoProviders )[ indexI ] ); |
|
624 if ( item.iProviderState != EPermanent && |
|
625 item.iProviderState != ERefreshing ) |
|
626 { |
|
627 DeleteProvider( item ); |
|
628 TRAP_IGNORE( item.iProvider = CreateDataProviderL( item.iType ) ); |
|
629 } |
|
630 } |
|
631 |
|
632 // Uninitialize fading provider |
|
633 const TInt indexF = ProviderIndexByState( EFading ); |
|
634 if ( indexF != KErrNotFound ) |
|
635 { |
|
636 __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, |
|
637 "LocVideo.providerSwitchDone fading indexFading=%d", indexF ) |
|
638 TProviderItem& item = (*iVideoProviders)[indexF]; |
|
639 |
|
640 // Mark up type of the last provider. |
|
641 backupProviderType = item.iType; |
|
642 |
|
643 DeleteProvider( item ); |
|
644 __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, |
|
645 "LocVideo.providerSwitchDone fading=%d", item.iType ) |
|
646 TRAP_IGNORE( item.iProvider = CreateDataProviderL( item.iType ) ); |
|
647 } |
|
648 |
|
649 // Initialize waiting provider |
|
650 TInt err( KErrNone ); |
|
651 const TInt indexW( ProviderIndexByState( EWaiting ) ); |
|
652 if ( indexW != KErrNotFound ) |
|
653 { |
|
654 __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, |
|
655 "LocVideo.providerSwitchDone waiting=%d", indexW ) |
|
656 TProviderItem& item = (*iVideoProviders)[indexW]; |
|
657 item.iProviderState = EUndefined; |
|
658 TRAP( err, InitializeProviderL( item ) ); |
|
659 if ( err == KErrNone) |
|
660 { |
|
661 iSelectedProvider = &item; |
|
662 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, " selected provider set" ) |
|
663 backupProviderType = KVtEngProviderNone; |
|
664 } |
|
665 else |
|
666 { |
|
667 iState = ELocNone; |
|
668 __VTPRINT( DEBUG_MEDIA, " STATE TO NONE" ) |
|
669 __VTPRINT2( DEBUG_MEDIA, "failed initializing provider=%d", err ) |
|
670 // If initialization failed indicate that provider is not available |
|
671 if ( item.iType == KVtEngProviderCam1 ) |
|
672 { |
|
673 ClearFlag( EFlagCamera1Available ); |
|
674 } |
|
675 else if ( item.iType == KVtEngProviderCam2 ) |
|
676 { |
|
677 ClearFlag( EFlagCamera2Available ); |
|
678 } |
|
679 else if( item.iType == KVtEngProviderShareImage ) |
|
680 { |
|
681 iShareImage->Error( err ); |
|
682 } |
|
683 CVtEngEventManager::NotifyEvent( KVtEngMediaInitFailure ); |
|
684 } |
|
685 } |
|
686 |
|
687 // Reconstruct refreshing (new still image) provider. |
|
688 const TInt indexR( ProviderIndexByState( ERefreshing ) ); |
|
689 if ( indexR != KErrNotFound ) |
|
690 { |
|
691 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, |
|
692 "LocVideo.providerSwitchDone refreshing") |
|
693 TProviderItem& item = (*iVideoProviders)[indexR]; |
|
694 DeleteProvider( item ); |
|
695 |
|
696 // If still image disabled in settings. |
|
697 CVtEngSettings& settings = CVtEngUtility::Settings(); |
|
698 const CVtEngSettings::TVtEngVideoCallConfig& config = |
|
699 settings.Config(); |
|
700 const TBool stillImageValid( config.iVideo.iImageIsValid ); |
|
701 TRAP( err, |
|
702 { |
|
703 item.iProvider = CreateDataProviderL( item.iType ); |
|
704 if ( stillImageValid ) |
|
705 { |
|
706 InitializeProviderL( item ); |
|
707 } |
|
708 else |
|
709 { |
|
710 item.iProviderState = EPermanent; // change back to original |
|
711 } |
|
712 } ); |
|
713 if ( err == KErrNone && stillImageValid ) |
|
714 { |
|
715 iSelectedProvider = &item; |
|
716 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, " selected provider set" ) |
|
717 } |
|
718 else |
|
719 { |
|
720 iState = ELocNone; |
|
721 __VTPRINT2( DEBUG_MEDIA, " STATE TO NONE initerr=%d", err ) |
|
722 } |
|
723 } |
|
724 |
|
725 // If we have delayed select pending -> initiate new switch and return |
|
726 if ( iDelayedSelect.IsDelayedSelectPending() ) |
|
727 { |
|
728 ClearFlag( EFlagCheckRevertToPrevious ); |
|
729 TVtEngProviderType pending = iDelayedSelect.DelayedSelectTarget(); |
|
730 __VTPRINT2( DEBUG_MEDIA, " delayed select pending type = %d", pending ) |
|
731 if( iActiveProvider && iActiveProvider->iType == pending ) |
|
732 { |
|
733 // clear the iDelayedSelect to KVtEngProviderUndefined |
|
734 // and no need to select again,continue complete this vsProviderSwitchDone |
|
735 iDelayedSelect.DelayedSelectTarget(); |
|
736 } |
|
737 else |
|
738 { |
|
739 TRAP_IGNORE( SelectSourceL( pending ) ); |
|
740 __VTPRINTEXIT( "LocVid.vsProviderSwitchDone" ) |
|
741 return; |
|
742 } |
|
743 } |
|
744 |
|
745 if ( IsFlag( EFlagSignalSourceSelection ) && |
|
746 iState != ELocInitializing && // Set in InitializeProviderL if called |
|
747 err == KErrNone && // but not if init (or create provider in |
|
748 // there) failed. |
|
749 !IsFlag( EFlagCheckRevertToPrevious ) ) |
|
750 { |
|
751 // Signal only if we're in final state (i.e. not if blank provider |
|
752 // was switched and just started initializing a camera). |
|
753 ClearFlag( EFlagSignalSourceSelection ); |
|
754 TRAP_IGNORE( iObserver.HandleLocalVideoOperationCompleteL( KErrNone ) ); |
|
755 } |
|
756 else if ( IsFlag( EFlagCheckRevertToPrevious ) && |
|
757 ( iState == ELocReady || iState == ELocNone ) ) |
|
758 { |
|
759 ClearFlag( EFlagCheckRevertToPrevious ); |
|
760 MVtEngMedia::TCameraId currentCam( MVtEngMedia::EPrimaryCamera ); |
|
761 iObserver.GetCurrentCameraId( currentCam ); |
|
762 backupProviderType = |
|
763 ( currentCam==MVtEngMedia::EPrimaryCamera ) ? |
|
764 KVtEngProviderCam1 : KVtEngProviderCam2; |
|
765 } |
|
766 |
|
767 __VTPRINT2( DEBUG_MEDIA, " switch done iState=%d", iState ) |
|
768 |
|
769 //Inform camera preferences that valid provider is set |
|
770 // Check that valid provider exist |
|
771 // and set it as provider to camera |
|
772 // preferences |
|
773 if ( iActiveProvider ) |
|
774 { |
|
775 __VTPRINT2( DEBUG_MEDIA, "switch done prov.state=%d", |
|
776 iActiveProvider->iProviderState ) |
|
777 // Set provider to camera preferences |
|
778 // only if camera preferences exist |
|
779 if ( iCameraPref) |
|
780 { |
|
781 __VTPRINT2( DEBUG_MEDIA, |
|
782 "LocVideo.providerSwitchDone iCameraPref->SetProvider type=%d", |
|
783 iActiveProvider->iType ) |
|
784 iCameraPref->SetProvider( iActiveProvider->iProvider, |
|
785 *iActiveProvider ); |
|
786 |
|
787 TInt error( iActiveProvider->RestorePreferences() ); |
|
788 if ( error ) |
|
789 { |
|
790 __VTPRINT2( DEBUG_MEDIA, " restoring preferences FAILED %d", |
|
791 error ) |
|
792 } |
|
793 } |
|
794 else |
|
795 { |
|
796 __VTPRINT( DEBUG_MEDIA, |
|
797 "LocVideo.providerSwitchDone camera pref not created" ) |
|
798 } |
|
799 } |
|
800 |
|
801 if ( IsFlag( EFlagInitialized ) && iState != ELocInitializing ) |
|
802 { |
|
803 __VTPRINT( DEBUG_MEDIA, |
|
804 "LocVideo.providerSwitchDone KVtEngSourceCapsChanged" ) |
|
805 CVtEngEventManager::NotifyEvent( KVtEngSourceChanged ); |
|
806 } |
|
807 |
|
808 TRAP( err, StartViewFinderIfWasStartedL() ); // err is ignored |
|
809 |
|
810 if ( backupProviderType != KVtEngProviderNone ) |
|
811 { |
|
812 // Initialization of new provider failed, |
|
813 // try reverting back to last one. |
|
814 __VTPRINT2( DEBUG_MEDIA, |
|
815 "LocVideo.providerSwitchDone revert to %d", backupProviderType ) |
|
816 TRAP( err, SelectSourceL( backupProviderType ) ); |
|
817 if ( err != KErrNone ) |
|
818 { |
|
819 CVtEngEventManager::NotifyEvent( KVtEngMediaInitFailure ); |
|
820 } |
|
821 } |
|
822 |
|
823 __VTPRINTEXIT( "LocVid.vsProviderSwitchDone" ) |
|
824 } |
|
825 |
|
826 // ----------------------------------------------------------------------------- |
|
827 // CVtEngLocalVideo::vsViewFinderFrameReady |
|
828 // View finder image can be set. |
|
829 // ----------------------------------------------------------------------------- |
|
830 // |
|
831 void CVtEngLocalVideo::vsViewFinderFrameReady( CFbsBitmap& aFrame ) |
|
832 { |
|
833 __VTPRINTENTER( "LocVid.vsViewFinderFrameReady" ) |
|
834 if ( iActiveProvider && |
|
835 iActiveProvider->iType != KVtEngProviderNone ) |
|
836 { |
|
837 TRAP_IGNORE( iOptions.iObserver->vtHandleFrameL( |
|
838 MVtEngFrameObserver::ELocalVideoFrame, &aFrame ) ); |
|
839 } |
|
840 __VTPRINTEXIT( "LocVid.vsViewFinderFrameReady" ) |
|
841 } |
|
842 |
|
843 // ----------------------------------------------------------------------------- |
|
844 // CVtEngLocalVideo::vsProvidersChanged |
|
845 // Provider state has changed. |
|
846 // ----------------------------------------------------------------------------- |
|
847 // |
|
848 void CVtEngLocalVideo::vsProvidersChanged( TBool aAttached ) |
|
849 { |
|
850 __VTPRINTENTER( "LocVid.vsProvidersChanged" ) |
|
851 |
|
852 __VTPRINT2( DEBUG_MEDIA, " vsProvidersChanged attached=%d", aAttached ) |
|
853 __VTPRINT2( DEBUG_MEDIA, " vsProvidersChanged state=%d",iState ) |
|
854 if ( iAudioSource == NULL ) |
|
855 { |
|
856 // If this is called from ConstructL (indirectly) return immediately |
|
857 if ( aAttached || iCurrentCamera == MVtEngMedia::EPrimaryCamera ) |
|
858 { |
|
859 SetFlag( EFlagCamera1Available ); |
|
860 iObserver.SetSelectedCameraId( MVtEngMedia::EPrimaryCamera, ETrue ); |
|
861 } |
|
862 else |
|
863 { |
|
864 ClearFlag( EFlagCamera1Available ); |
|
865 iObserver.SetSelectedCameraId( |
|
866 MVtEngMedia::ESecondaryCamera, ETrue ); |
|
867 } |
|
868 __VTPRINTEXIT( "LocVid.vsProvidersChanged" ) |
|
869 return; |
|
870 } |
|
871 |
|
872 // If primary camera was not available and state is not "open" |
|
873 // UI should be requested for answer. Precondition is also that |
|
874 // primary camera is now available. |
|
875 TBool notifyAnswer( EFalse ); |
|
876 TInt activeMedia( 0 ); |
|
877 |
|
878 const MVtEngSessionInfo::TSessionState state( |
|
879 CVtEngUtility::StateManager()->SessionState() ); |
|
880 |
|
881 __VTPRINT2( DEBUG_MEDIA, " vsProvidersChanged, call state=%d", state ) |
|
882 if ( state == MVtEngSessionInfo::EReceiving ) |
|
883 { |
|
884 __VTPRINT2( DEBUG_MEDIA, " vsProvidersChanged attached=%d", aAttached ) |
|
885 if ( !IsFlag( EFlagCamera1Available ) && aAttached ) |
|
886 { |
|
887 notifyAnswer = ETrue; |
|
888 } |
|
889 } |
|
890 |
|
891 __VTPRINT2( DEBUG_MEDIA, |
|
892 " vsProvidersChanged answer=%d", notifyAnswer ) |
|
893 CVtEngLocalVideo::TVtEngProviderType providerToSelect( KVtEngProviderNone ); |
|
894 TRAPD( err, providerToSelect = UpdateAvailableProvidersL() ); |
|
895 if ( err == KErrNone ) |
|
896 { |
|
897 // Now get the state to check if video has been disabled |
|
898 GetMediaState( activeMedia ); |
|
899 __VTPRINT2( DEBUG_MEDIA, |
|
900 " vsProvidersChanged mediastate=%d", activeMedia ) |
|
901 __VTPRINT2( DEBUG_MEDIA, |
|
902 " vsProvidersChanged iState=%d", iState ) |
|
903 |
|
904 // values for checking if switch is allowed |
|
905 TBool activeIsStillOrBlank ( EFalse ); |
|
906 TBool activeIsBlankAndNewCam1( EFalse ); |
|
907 if ( iActiveProvider ) |
|
908 { |
|
909 __VTPRINT2( DEBUG_MEDIA, |
|
910 " vsProvidersChanged iActivePType=%d", iActiveProvider->iType ) |
|
911 if ( iActiveProvider->iType == KVtEngProviderImage || |
|
912 iActiveProvider->iType == KVtEngProviderNone ) |
|
913 { |
|
914 activeIsStillOrBlank = ETrue; |
|
915 if ( providerToSelect == KVtEngProviderCam1 && |
|
916 iActiveProvider->iType == KVtEngProviderNone ) |
|
917 { |
|
918 activeIsBlankAndNewCam1 = ETrue; |
|
919 } |
|
920 } |
|
921 } |
|
922 __VTPRINT2( DEBUG_MEDIA, |
|
923 " vsProvidersChanged blank active new cam1=%d", |
|
924 activeIsBlankAndNewCam1 ) |
|
925 |
|
926 __VTPRINT2( DEBUG_MEDIA, |
|
927 " vsProvidersChanged provider=%d", providerToSelect ) |
|
928 |
|
929 if ( providerToSelect == KVtEngProviderCam1 ) |
|
930 { |
|
931 iObserver.SetSelectedCameraId( MVtEngMedia::EPrimaryCamera ); |
|
932 } |
|
933 else if ( providerToSelect == KVtEngProviderCam2 ) |
|
934 { |
|
935 // delete provider that became unavailable |
|
936 iObserver.SetSelectedCameraId( MVtEngMedia::ESecondaryCamera ); |
|
937 } |
|
938 |
|
939 // Check if SelectSource should be called |
|
940 if ( !notifyAnswer && // for incoming calls automatic switch not allowed |
|
941 ( iState == ELocNone || iState == ELocReady ) && |
|
942 IsFlag( EFlagInitialized ) ) |
|
943 { |
|
944 __VTPRINT( DEBUG_MEDIA, " vsProvidersChanged ok to select" ) |
|
945 // Allow switch if video disabled (still/blank active) |
|
946 // and cam1 available. |
|
947 ClearFlag( EFlagInitializeOnly ); |
|
948 ClearFlag( EFlagCheckRevertToPrevious ); |
|
949 if ( activeIsStillOrBlank && |
|
950 providerToSelect == KVtEngProviderCam2 ) |
|
951 { |
|
952 SetFlag( EFlagInitializeOnly ); |
|
953 } |
|
954 else if ( activeIsBlankAndNewCam1 ) |
|
955 { |
|
956 iObserver.AutoEnableVideo(); |
|
957 } |
|
958 else if ( providerToSelect == KVtEngProviderNone ) |
|
959 { |
|
960 iObserver.AutoEnableVideo( EFalse ); |
|
961 } |
|
962 SetFlag( EFlagAutomaticSwitchCallback ); |
|
963 TRAP( err, SelectSourceL( providerToSelect ) ); |
|
964 ClearFlag( EFlagAutomaticSwitchCallback ); |
|
965 |
|
966 if ( err != KErrNone ) |
|
967 { |
|
968 __VTPRINT2( DEBUG_MEDIA, |
|
969 " vsProvidersChanged,select failed=%d", err ) |
|
970 if ( providerToSelect == KVtEngProviderCam1 && |
|
971 iNumSupportedCameras > 1 ) |
|
972 { |
|
973 __VTPRINT( DEBUG_MEDIA, "LocVideo.vsProvidersChanged 2 2" ) |
|
974 SetFlag( EFlagCamera2Available ); |
|
975 ClearFlag( EFlagCamera1Available ); |
|
976 TRAP( err, SelectSourceL( KVtEngProviderCam2 ) ); |
|
977 } |
|
978 else if ( providerToSelect == KVtEngProviderCam2 ) |
|
979 { |
|
980 __VTPRINT( DEBUG_MEDIA, |
|
981 "LocVideo.vsProvidersChanged 2 still") |
|
982 ClearFlag( EFlagCamera2Available ); |
|
983 TRAP( err, SelectSourceL( KVtEngProviderImage ) ); |
|
984 } |
|
985 } |
|
986 } |
|
987 else |
|
988 { |
|
989 __VTPRINT( DEBUG_MEDIA, " vsProvidersChanged Not Changed" ) |
|
990 if ( iState == ELocInitializing && |
|
991 iSelectedProvider && |
|
992 iSelectedProvider->iType != providerToSelect ) |
|
993 { |
|
994 SetFlag( EFlagCheckRevertToPrevious ); |
|
995 } |
|
996 } |
|
997 |
|
998 CVtEngStateManager* states = CVtEngUtility::StateManager(); |
|
999 states->Update(); |
|
1000 |
|
1001 if ( IsFlag( EFlagCamera1Available ) || |
|
1002 IsFlag( EFlagCamera2Available ) ) |
|
1003 { |
|
1004 if ( notifyAnswer ) |
|
1005 { |
|
1006 __VTPRINT( DEBUG_MEDIA, |
|
1007 "LocVideo.vsProvidersChanged KVtEngSessionAnswerPossible") |
|
1008 CVtEngEventManager::NotifyEvent( KVtEngSessionAnswerPossible ); |
|
1009 } |
|
1010 else if ( !notifyAnswer && |
|
1011 // Don't notify before selection is done. |
|
1012 ( iState == ELocReady || |
|
1013 iState == ELocNone ) ) |
|
1014 { |
|
1015 __VTPRINT( DEBUG_MEDIA, |
|
1016 "LocVideo.vsProvidersChanged KVtEngSourceCapsChanged" ) |
|
1017 CVtEngEventManager::NotifyEvent( KVtEngSourceCapsChanged ); |
|
1018 } |
|
1019 } |
|
1020 else if ( !IsFlag( EFlagCamera1Available ) && |
|
1021 !IsFlag( EFlagCamera2Available ) ) |
|
1022 { |
|
1023 __VTPRINT( DEBUG_MEDIA, "LocVideo.vsProvidersChanged NO CAMS" ) |
|
1024 CVtEngEventManager::NotifyEvent( KVtEngSourceCapsChanged ); |
|
1025 } |
|
1026 } |
|
1027 else |
|
1028 { |
|
1029 __VTPRINT( DEBUG_MEDIA, |
|
1030 "LocVideo.vsProvidersChanged KVtEngResourceMemAllocFailure" ) |
|
1031 CVtEngEventManager::NotifyEvent( KVtEngResourceMemAllocFailure ); |
|
1032 } |
|
1033 __VTPRINTEXITR( "LocVid.vsProvidersChanged err=%d", err ) |
|
1034 } |
|
1035 |
|
1036 // ----------------------------------------------------------------------------- |
|
1037 // CVtEngLocalVideo::SetViewFinderParameters |
|
1038 // Configures parameters for rendering via window server. |
|
1039 // ----------------------------------------------------------------------------- |
|
1040 // |
|
1041 void CVtEngLocalVideo::SetViewFinderParameters( |
|
1042 const TVtEngRenderingOptions& aParams ) |
|
1043 { |
|
1044 __VTPRINTENTER( "LocVid.SetViewFinderParameters" ) |
|
1045 |
|
1046 // Before setting the params, stop VF |
|
1047 if( ViewFinderStarted() ) |
|
1048 { |
|
1049 StopViewFinder(); |
|
1050 } |
|
1051 |
|
1052 iOptions.iSize = aParams.iSize; |
|
1053 __VTPRINT2( DEBUG_MEDIA, |
|
1054 " width = %d", iOptions.iSize.iWidth ); |
|
1055 __VTPRINT2( DEBUG_MEDIA, |
|
1056 " height = %d", iOptions.iSize.iHeight ); |
|
1057 |
|
1058 iOptions.iObserver = aParams.iObserver; |
|
1059 iRenderingMethod = EWindowServer; |
|
1060 __VTPRINTEXIT( "LocVid.SetViewFinderParameters" ) |
|
1061 } |
|
1062 |
|
1063 // ----------------------------------------------------------------------------- |
|
1064 // CVtEngLocalVideo::SetViewFinderParameters |
|
1065 // Configures parameters for rendering with direct screen access. |
|
1066 // ----------------------------------------------------------------------------- |
|
1067 // |
|
1068 void CVtEngLocalVideo::SetViewFinderParameters( |
|
1069 const TVtEngRenderingOptionsDSA& aDSA ) |
|
1070 { |
|
1071 __VTPRINTENTER( "LocVid.SetVFParamsDSA" ) |
|
1072 |
|
1073 // Before setting the params, stop VF |
|
1074 if( ViewFinderStarted() ) |
|
1075 { |
|
1076 StopViewFinder(); |
|
1077 } |
|
1078 |
|
1079 iRenderingMethod = EDSA; |
|
1080 iDsaOptions.iClipRect = aDSA.iClipRect; |
|
1081 iDsaOptions.iRect = aDSA.iRect; |
|
1082 iDsaOptions.iWindow = &aDSA.iWindow; |
|
1083 iDsaOptions.iWs = &aDSA.iWs; |
|
1084 iDsaOptions.iWsSD = &aDSA.iWsSD; |
|
1085 __VTPRINTEXIT( "LocVid.SetVFParamsDSA" ) |
|
1086 } |
|
1087 |
|
1088 // ----------------------------------------------------------------------------- |
|
1089 // CVtEngLocalVideo::SetViewFinderParameters |
|
1090 // Configures parameters for rendering with display posting. |
|
1091 // ----------------------------------------------------------------------------- |
|
1092 // |
|
1093 void CVtEngLocalVideo::SetViewFinderParameters( |
|
1094 const TVtEngRenderingOptionsDP& aDP ) |
|
1095 { |
|
1096 __VTPRINTENTER( "LocVid.SetVFParamsDP" ) |
|
1097 |
|
1098 // Before setting the params, stop VF |
|
1099 if( ViewFinderStarted() ) |
|
1100 { |
|
1101 StopViewFinder(); |
|
1102 } |
|
1103 |
|
1104 iRenderingMethod = EDP; |
|
1105 iDsaOptions.iClipRect = aDP.iClipRect; |
|
1106 iDsaOptions.iRect = aDP.iRect; |
|
1107 iDsaOptions.iWindow = &aDP.iWindow; |
|
1108 iDsaOptions.iWs = &aDP.iWs; |
|
1109 iDsaOptions.iWsSD = &aDP.iWsSD; |
|
1110 __VTPRINTEXIT( "LocVid.SetVFParamsDP" ) |
|
1111 } |
|
1112 |
|
1113 // ----------------------------------------------------------------------------- |
|
1114 // CVtEngLocalVideo::SetDefaultStillImageL |
|
1115 // Sets default still image. |
|
1116 // ----------------------------------------------------------------------------- |
|
1117 // |
|
1118 void CVtEngLocalVideo::SetDefaultStillImageL() |
|
1119 { |
|
1120 __VTPRINTENTER( "LocVid.SetDefaultStillImageL" ) |
|
1121 |
|
1122 TProviderItem* item = NULL; |
|
1123 GetProviderByType( KVtEngProviderDefaultStillImage, item ); |
|
1124 if ( item ) |
|
1125 { |
|
1126 CVSDataProvider* provider = item->iProvider; |
|
1127 |
|
1128 if ( provider && item->iType == KVtEngProviderDefaultStillImage ) |
|
1129 { |
|
1130 if ( item->iInitialized ) |
|
1131 { |
|
1132 StopViewFinder(); |
|
1133 |
|
1134 TInt providerIndex = |
|
1135 ProviderIndex( KVtEngProviderDefaultStillImage ); |
|
1136 |
|
1137 TProviderItem* defaultStillProviderItem = |
|
1138 &( *iVideoProviders )[providerIndex]; |
|
1139 SwitchProvider( defaultStillProviderItem ); |
|
1140 } |
|
1141 else |
|
1142 { |
|
1143 InitializeProviderL( *item ); |
|
1144 iSelectedProvider = item; |
|
1145 } |
|
1146 } |
|
1147 } |
|
1148 __VTPRINTEXIT( "LocVid.SetDefaultStillImageL" ) |
|
1149 } |
|
1150 |
|
1151 // ----------------------------------------------------------------------------- |
|
1152 // CVtEngLocalVideo::SetStillImageL |
|
1153 // Sets still image. |
|
1154 // ----------------------------------------------------------------------------- |
|
1155 // |
|
1156 void CVtEngLocalVideo::SetStillImageL( TBool aSetAsActive ) |
|
1157 { |
|
1158 __VTPRINTENTER( "LocVid.SetStillImageL" ) |
|
1159 |
|
1160 CVtEngSettings& settings = CVtEngUtility::Settings(); |
|
1161 const CVtEngSettings::TVtEngVideoCallConfig& config = |
|
1162 settings.Config(); |
|
1163 const TBool stillImageValid( config.iVideo.iImageIsValid ); |
|
1164 if ( iState == ELocInitializing && stillImageValid ) |
|
1165 { |
|
1166 __VTPRINT( DEBUG_MEDIA, " setStill failed" ) |
|
1167 User::Leave( KErrNotReady ); |
|
1168 } |
|
1169 |
|
1170 TInt count( iVideoProviders->Count() ); |
|
1171 TBool done( EFalse ); |
|
1172 while ( count-- ) |
|
1173 { |
|
1174 TProviderItem& item = ( *iVideoProviders )[count]; |
|
1175 CVSDataProvider* provider = item.iProvider; |
|
1176 |
|
1177 if ( item.iType == KVtEngProviderImage ) |
|
1178 { |
|
1179 if ( provider && item.iInitialized ) |
|
1180 { |
|
1181 // If still image provider is active change to temp provider |
|
1182 if ( iActiveProvider && |
|
1183 ( iActiveProvider->iType == KVtEngProviderImage ) ) |
|
1184 { |
|
1185 __VTPRINT( DEBUG_MEDIA, "Act.prov. must be deleted" ) |
|
1186 StopViewFinder(); |
|
1187 iActiveProvider->iProviderState = ERefreshing; |
|
1188 TInt providerIndex = ProviderIndex( KVtEngProviderNone ); |
|
1189 TProviderItem* blankProviderItem = |
|
1190 &( *iVideoProviders )[providerIndex]; |
|
1191 SwitchProvider( blankProviderItem ); |
|
1192 __VTPRINTEXIT( "LocVideo.SetStillImageL" ) |
|
1193 return; |
|
1194 } |
|
1195 |
|
1196 //Only way to change image is first delete the provider |
|
1197 delete provider; |
|
1198 item.iProvider = NULL; |
|
1199 |
|
1200 // Create it again. |
|
1201 // If there is a provider info for still. |
|
1202 if ( iProviderInfoIndexStill != KErrNotFound ) |
|
1203 { |
|
1204 item.iProvider = iSourceController->CreateDataProviderL( |
|
1205 iProviderInfoIndexStill, |
|
1206 this, iSource ); |
|
1207 item.iType = KVtEngProviderImage; |
|
1208 item.iInitialized = EFalse; |
|
1209 } |
|
1210 } |
|
1211 // Do initialization only if valid image (still not |
|
1212 // cleared in settings). |
|
1213 if ( stillImageValid ) |
|
1214 { |
|
1215 InitializeProviderL( item ); |
|
1216 if ( aSetAsActive ) |
|
1217 { |
|
1218 iSelectedProvider = &item; |
|
1219 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, |
|
1220 " selected provider set" ) |
|
1221 } |
|
1222 } |
|
1223 done = ETrue; |
|
1224 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, |
|
1225 "LocVideo.SetStillImageL ok" ) |
|
1226 } |
|
1227 } |
|
1228 if ( !done ) |
|
1229 { |
|
1230 __VTPRINT( DEBUG_MEDIA, "LocVideo.SetStillImageL fail") |
|
1231 User::Leave( KErrGeneral ); |
|
1232 } |
|
1233 __VTPRINTEXIT( "LocVid.SetStillImageL" ) |
|
1234 } |
|
1235 |
|
1236 // ----------------------------------------------------------------------------- |
|
1237 // CVtEngLocalVideo::InitializeL |
|
1238 // Initializes default blank provider. |
|
1239 // ----------------------------------------------------------------------------- |
|
1240 // |
|
1241 void CVtEngLocalVideo::InitializeL() |
|
1242 { |
|
1243 __VTPRINTENTER( "LocVid.InitializeL" ) |
|
1244 const TInt index( ProviderIndex( KVtEngProviderNone ) ); |
|
1245 TProviderItem* item = &(*iVideoProviders)[index]; |
|
1246 if ( iActiveProvider && |
|
1247 iActiveProvider->iType == KVtEngProviderImage ) |
|
1248 { |
|
1249 // Blank provider is set to active only |
|
1250 // if there is not valid still image. |
|
1251 SetFlag( EFlagInitializeOnly ); |
|
1252 iSelectedProvider = item; |
|
1253 } |
|
1254 else |
|
1255 { |
|
1256 iActiveProvider = item; |
|
1257 } |
|
1258 InitializeProviderL( *item ); |
|
1259 SetFlag( EFlagSignalSourceSelection ); |
|
1260 SetFlag( EFlagInitialized ); |
|
1261 __VTPRINTEXIT( "LocVid.InitializeL" ) |
|
1262 } |
|
1263 |
|
1264 // ----------------------------------------------------------------------------- |
|
1265 // CVtEngLocalVideo::SelectSourceL |
|
1266 // Selects source. |
|
1267 // ----------------------------------------------------------------------------- |
|
1268 // |
|
1269 TBool CVtEngLocalVideo::SelectSourceL( TVtEngProviderType aSource ) |
|
1270 { |
|
1271 __VTPRINTENTER( "LocVid.SelectSourceL" ) |
|
1272 |
|
1273 __VTPRINT2( DEBUG_MEDIA, " source=%d", aSource ) |
|
1274 |
|
1275 if ( iDelayedSelect.IsDelayedSelectPending() && |
|
1276 ( aSource != KVtEngProviderShareImage ) && |
|
1277 ( aSource == KVtEngProviderCam1 || |
|
1278 aSource == KVtEngProviderCam2 || |
|
1279 aSource == KVtEngProviderImage ) ) |
|
1280 { |
|
1281 aSource = iDelayedSelect.DelayedSelectTarget(); |
|
1282 } |
|
1283 |
|
1284 if( IsProviderWaiting( aSource ) ) |
|
1285 { |
|
1286 // If waiting for provide switch and a provider initialization |
|
1287 // don't allow selection. |
|
1288 __VTPRINT( DEBUG_MEDIA, "LocVideo.SelectSourceL already waiting" ) |
|
1289 User::Leave( KErrNotReady ); |
|
1290 } |
|
1291 |
|
1292 // To be selected source is already active |
|
1293 if ( IsActiveProvider( aSource ) ) |
|
1294 { |
|
1295 Cancel(); |
|
1296 TRequestStatus* status = &iStatus; |
|
1297 SetActive(); |
|
1298 User::RequestComplete( status, KVtEngAlreadyActive ); |
|
1299 SetFlag( EFlagSignalSourceSelection ); |
|
1300 __VTPRINT2( DEBUG_MEDIA, "LocVideo.SelectSourceL start AO=%d", |
|
1301 KVtEngAlreadyActive ) |
|
1302 if ( iActiveProvider ) |
|
1303 { |
|
1304 __VTPRINT2( DEBUG_MEDIA, "LocVideo. activeProv type=%d", |
|
1305 iActiveProvider->iType ) |
|
1306 } |
|
1307 // In case there were errors, NULL the selected provider |
|
1308 // to be able to initialize it when needed |
|
1309 if( iSelectedProvider ) |
|
1310 { |
|
1311 if( iSelectedProvider->iErrorCode ) |
|
1312 { |
|
1313 iSelectedProvider->iInitialized = EFalse; |
|
1314 iSelectedProvider->iProviderState = |
|
1315 (CVtEngLocalVideo::TProviderState) |
|
1316 iSelectedProvider->iErrorCode; |
|
1317 iSelectedProvider = NULL; |
|
1318 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, " selprovider nulled" ) |
|
1319 } |
|
1320 } |
|
1321 // Not actually switching but virtually doing it because |
|
1322 // async callback will be made. |
|
1323 __VTPRINTEXITR( "LocVid.SelectSourceL %d", ETrue ) |
|
1324 return ETrue; |
|
1325 } |
|
1326 __VTPRINT2( DEBUG_MEDIA, "LocVideo.Selectsource iState=%d", iState ) |
|
1327 if ( iState == ELocInitializing && |
|
1328 aSource == KVtEngProviderImage && |
|
1329 iActiveProvider && |
|
1330 iActiveProvider->iType != KVtEngProviderNone ) |
|
1331 { |
|
1332 __VTPRINT( DEBUG_MEDIA, |
|
1333 "LocVideo.SelectSource initialization pending" ) |
|
1334 User::Leave( KErrNotReady ); |
|
1335 } |
|
1336 // We have switch pending |
|
1337 else if ( iState == ELocSwichingProvider ) |
|
1338 { |
|
1339 __VTPRINT( DEBUG_MEDIA, |
|
1340 "LocVideo.SelectSource switching -> set delayed select" ) |
|
1341 iDelayedSelect.NotifyDelayedSelect( aSource ); |
|
1342 __VTPRINTEXITR( "LocVid.SelectSourceL %d", ETrue ) |
|
1343 return ETrue; |
|
1344 } |
|
1345 |
|
1346 TBool initialized( EFalse ); |
|
1347 TProviderItem item; |
|
1348 TInt providerIndex( GetProviderByType( aSource, item ) ); |
|
1349 |
|
1350 if ( providerIndex != KErrNotFound ) |
|
1351 { |
|
1352 // requested provider found, set initialization status |
|
1353 __VTPRINT2( DEBUG_MEDIA, "LocVideo.SelectSource index=%d", providerIndex ) |
|
1354 initialized = item.iInitialized; |
|
1355 } |
|
1356 else |
|
1357 { // requested provider not found |
|
1358 __VTPRINT( DEBUG_MEDIA, "LocVideo.SelectSource create provider" ) |
|
1359 // Try to create provider |
|
1360 TInt index = KErrNotFound; |
|
1361 switch ( aSource ) |
|
1362 { |
|
1363 case KVtEngProviderCam2: |
|
1364 index = iProviderInfoIndexCam2; |
|
1365 break; |
|
1366 case KVtEngProviderNone: |
|
1367 case KVtEngProviderImage: |
|
1368 case KVtEngProviderDefaultStillImage: |
|
1369 // Image sharing |
|
1370 case KVtEngProviderShareImage: |
|
1371 index = iProviderInfoIndexStill; |
|
1372 break; |
|
1373 case KVtEngProviderCam1: |
|
1374 index = iProviderInfoIndexCam1; |
|
1375 default: |
|
1376 break; |
|
1377 } |
|
1378 |
|
1379 __VTPRINT2( DEBUG_MEDIA, |
|
1380 "LocVideo.SelectSource create provider ID=%d", index ) |
|
1381 if ( index != KErrNotFound ) |
|
1382 { |
|
1383 TProviderItem newItem; |
|
1384 newItem.iProvider = |
|
1385 iSourceController->CreateDataProviderL( |
|
1386 index, this, iSource ); |
|
1387 newItem.iType = aSource; |
|
1388 CleanupStack::PushL( newItem.iProvider ); |
|
1389 iVideoProviders->AppendL( newItem ); |
|
1390 CleanupStack::Pop(); |
|
1391 providerIndex = iVideoProviders->Count() - 1; |
|
1392 __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, |
|
1393 "LocVideo.SelectSource create provider ok=%d", |
|
1394 newItem.iProvider != NULL ) |
|
1395 } |
|
1396 } |
|
1397 |
|
1398 TBool initOrSwitch = EFalse; |
|
1399 |
|
1400 // Initialize provider |
|
1401 if ( providerIndex != KErrNotFound && !initialized ) |
|
1402 { |
|
1403 if ( iActiveProvider->iProviderState != EPermanent ) |
|
1404 { |
|
1405 // Active provider must be destroyed and new one initialized |
|
1406 __VTPRINT( DEBUG_MEDIA, "LocVideo.SelectSource del Act.prov" ) |
|
1407 (*iVideoProviders)[providerIndex].iProviderState = EWaiting; |
|
1408 iActiveProvider->iProviderState = EFading; |
|
1409 StopViewFinder(); |
|
1410 providerIndex = ProviderIndex( KVtEngProviderNone ); |
|
1411 __VTPRINT2( DEBUG_MEDIA, "LocVideo.SelectSource index for none=%d", |
|
1412 providerIndex ) |
|
1413 } |
|
1414 else |
|
1415 { |
|
1416 __VTPRINT( DEBUG_MEDIA, "LocVideo.SelectSource do init" ) |
|
1417 UninitializeProviderL(); |
|
1418 TProviderItem& initItem = ( *iVideoProviders )[providerIndex]; |
|
1419 InitializeProviderL( initItem ); |
|
1420 // This item is stored, make it initialized only when callback |
|
1421 // received. |
|
1422 iSelectedProvider = &initItem; |
|
1423 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, " selected provider set" ) |
|
1424 initOrSwitch = InitializingOrSwitching(); |
|
1425 __VTPRINTEXITR( "LocVid.SelectSourceL %d", initOrSwitch ) |
|
1426 return initOrSwitch; |
|
1427 } |
|
1428 } |
|
1429 |
|
1430 // Switch provider |
|
1431 if ( providerIndex != KErrNotFound ) |
|
1432 { |
|
1433 if ( !IsFlag( EFlagInitializeOnly ) ) |
|
1434 { |
|
1435 __VTPRINT( DEBUG_MEDIA, "LocVideo.SelectSource ready for switch") |
|
1436 StopViewFinder(); |
|
1437 TProviderItem* switchItem = &(*iVideoProviders)[providerIndex]; |
|
1438 __VTPRINT2( DEBUG_MEDIA, |
|
1439 "LocVideo.SelectSource switchItem %d", switchItem->iType ) |
|
1440 SwitchProvider( switchItem ); |
|
1441 } |
|
1442 else if ( initialized && IsFlag( EFlagInitializeOnly ) ) |
|
1443 { |
|
1444 __VTPRINT2( DEBUG_MEDIA, |
|
1445 "LocVideo.SelectSource already initialized start AO %d", |
|
1446 KVtEngAlreadySelected ) |
|
1447 TProviderItem* switchItem = &( *iVideoProviders )[providerIndex]; |
|
1448 iActiveProvider = switchItem; |
|
1449 Cancel(); |
|
1450 TRequestStatus* status = &iStatus; |
|
1451 SetActive(); |
|
1452 User::RequestComplete( status, KVtEngAlreadySelected ); |
|
1453 } |
|
1454 else |
|
1455 { |
|
1456 __VTPRINT3( DEBUG_MEDIA, " initialized=%d,flags=%d", |
|
1457 initialized, iFlags ) |
|
1458 } |
|
1459 } |
|
1460 |
|
1461 // Error |
|
1462 if ( iActiveProvider == NULL ) |
|
1463 { |
|
1464 __VTPRINT( DEBUG_MEDIA, "LocVideo.SelectSource leave" ) |
|
1465 User::Leave( KErrNotFound ); |
|
1466 } |
|
1467 |
|
1468 initOrSwitch = InitializingOrSwitching(); |
|
1469 __VTPRINTEXITR( "LocVid.SelectSourceL %d", initOrSwitch ) |
|
1470 return initOrSwitch; |
|
1471 } |
|
1472 |
|
1473 // ---------------------------------------------------------------------------- |
|
1474 // CVtEngLocalVideo::InitializeProviderL |
|
1475 // Initializes a provider. |
|
1476 // ---------------------------------------------------------------------------- |
|
1477 // |
|
1478 void CVtEngLocalVideo::InitializeProviderL( |
|
1479 TProviderItem& aProviderItem ) |
|
1480 { |
|
1481 __VTPRINTENTER( "LocVid.InitializeProviderL" ) |
|
1482 |
|
1483 __VTPRINT2( DEBUG_MEDIA, "LocVideo.InitProv type=%d", aProviderItem.iType ) |
|
1484 |
|
1485 if ( iInitializingProvider ) |
|
1486 { |
|
1487 __VTPRINT( DEBUG_MEDIA, |
|
1488 "LocVideo.InitProv ERROR, already initializing" ) |
|
1489 User::Leave( KErrNotReady ); |
|
1490 } |
|
1491 |
|
1492 iInitializingProvider = &aProviderItem; |
|
1493 |
|
1494 CVtEngSettings& settings = CVtEngUtility::Settings(); |
|
1495 const CVtEngSettings::TVtEngVideoCallConfig& config = |
|
1496 settings.Config(); |
|
1497 TPckgBuf< TVSStillImageDataProviderParams > pckg; |
|
1498 |
|
1499 __VTPRINT2( DEBUG_MEDIA, "LocVideo.InitProv type=%d", aProviderItem.iType ) |
|
1500 CVSDataProvider* provider = aProviderItem.iProvider; |
|
1501 if ( provider == NULL ) |
|
1502 { |
|
1503 aProviderItem.iInitialized = EFalse; |
|
1504 aProviderItem.iProvider = CreateDataProviderL( aProviderItem.iType ); |
|
1505 provider = aProviderItem.iProvider; |
|
1506 } |
|
1507 else if ( aProviderItem.iInitialized ) |
|
1508 { |
|
1509 __VTPRINT2( DEBUG_MEDIA, "LocVideo.InitProv AO start %d", KErrNone ) |
|
1510 Cancel(); |
|
1511 TRequestStatus* status = &iStatus; |
|
1512 SetActive(); |
|
1513 User::RequestComplete( status, KErrNone ); |
|
1514 __VTPRINTEXIT( "LocVid.InitializeProviderL" ) |
|
1515 return; |
|
1516 } |
|
1517 User::LeaveIfNull( provider ); |
|
1518 switch ( aProviderItem.iType ) |
|
1519 { |
|
1520 case KVtEngProviderCam1: |
|
1521 case KVtEngProviderCam2: |
|
1522 provider->InitializeL( KNullDesC8 ); |
|
1523 iState = ELocInitializing; |
|
1524 __VTPRINT( DEBUG_MEDIA, " STATE TO INITIALIZING" ) |
|
1525 __VTPRINT2( DEBUG_MEDIA, "LocVideo.InitProv type=%d", |
|
1526 aProviderItem.iType ) |
|
1527 break; |
|
1528 case KVtEngProviderNone: |
|
1529 // Blank provider. |
|
1530 pckg().iInitialize = |
|
1531 TVSStillImageDataProviderParams::EInitializeAsBlankImage; |
|
1532 provider->InitializeL( pckg ); |
|
1533 iState = ELocInitializing; |
|
1534 __VTPRINT( DEBUG_MEDIA, " STATE TO INITIALIZING" ) |
|
1535 __VTPRINT2( DEBUG_MEDIA, "LocVideo.InitProv type=%d", |
|
1536 aProviderItem.iType ) |
|
1537 break; |
|
1538 case KVtEngProviderImage: |
|
1539 { |
|
1540 if ( config.iVideo.iImageIsValid ) |
|
1541 { |
|
1542 pckg().iInitialize = |
|
1543 TVSStillImageDataProviderParams::EInitializeFromGeneralSettings; |
|
1544 provider->InitializeL( pckg ); |
|
1545 iState = ELocInitializing; |
|
1546 __VTPRINT( DEBUG_MEDIA, " STATE TO INITIALIZING" ) |
|
1547 __VTPRINT( DEBUG_MEDIA, "LocVideo.InitProv Still image") |
|
1548 } |
|
1549 else |
|
1550 { |
|
1551 User::Leave( KErrPathNotFound ); |
|
1552 } |
|
1553 } |
|
1554 break; |
|
1555 case KVtEngProviderDefaultStillImage: |
|
1556 pckg().iInitialize = |
|
1557 TVSStillImageDataProviderParams::EInitializeAsDefaultStillImage; |
|
1558 |
|
1559 provider->InitializeL( pckg ); |
|
1560 iState = ELocInitializing; |
|
1561 __VTPRINT( DEBUG_MEDIA, " STATE TO INITIALIZING" ) |
|
1562 __VTPRINT2( DEBUG_MEDIA, "LocVideo.InitProv type=%d", |
|
1563 aProviderItem.iType ) |
|
1564 break; |
|
1565 default: |
|
1566 Panic( EVtEngPanicNoVideoProvider ); |
|
1567 break; |
|
1568 } |
|
1569 //aProviderItem.iInitialized = ETrue; |
|
1570 __VTPRINTEXIT( "LocVid.InitializeProviderL" ) |
|
1571 } |
|
1572 |
|
1573 // ---------------------------------------------------------------------------- |
|
1574 // CVtEngLocalVideo::InitializeShareProviderL |
|
1575 // Initializes a provider that is used for sharing. |
|
1576 // ---------------------------------------------------------------------------- |
|
1577 // |
|
1578 void CVtEngLocalVideo::InitializeShareProviderL( |
|
1579 TProviderItem& aProviderItem, const TDesC8& aParams ) |
|
1580 { |
|
1581 __VTPRINTENTER( "LocVid.InitializeShareProviderL" ) |
|
1582 aProviderItem.iProvider->InitializeL( aParams ); |
|
1583 aProviderItem.iInitialized = ETrue; |
|
1584 iState = ELocInitializing; |
|
1585 SetFlag( EFlagSignalSourceSelection | EFlagInitializeOnly ); |
|
1586 __VTPRINTEXIT( "LocVid.InitializeShareProviderL" ) |
|
1587 } |
|
1588 |
|
1589 // ----------------------------------------------------------------------------- |
|
1590 // CVtEngLocalVideo::ReCreateProviderL |
|
1591 // ----------------------------------------------------------------------------- |
|
1592 void CVtEngLocalVideo::ReCreateProviderL( |
|
1593 TProviderItem& aProviderItem, const TVtEngProviderType aType ) |
|
1594 { |
|
1595 __VTPRINTENTER( "LocVid.ReCreateProviderL" ) |
|
1596 |
|
1597 TInt index( KErrNotFound ); |
|
1598 |
|
1599 switch ( aType ) |
|
1600 { |
|
1601 case KVtEngProviderShareImage: |
|
1602 index = iProviderInfoIndexStill; |
|
1603 break; |
|
1604 |
|
1605 default: |
|
1606 User::Leave( KErrNotSupported ); |
|
1607 } |
|
1608 |
|
1609 // Delete old instance |
|
1610 DeleteProvider( aProviderItem ); |
|
1611 |
|
1612 // Create new instance |
|
1613 aProviderItem.iProvider = iSourceController->CreateDataProviderL( |
|
1614 index, this, iSource ); |
|
1615 aProviderItem.iType = aType; |
|
1616 |
|
1617 __VTPRINTEXIT( "LocVid.ReCreateProviderL" ) |
|
1618 } |
|
1619 |
|
1620 // ---------------------------------------------------------------------------- |
|
1621 // CVtEngLocalVideo::CameraIdToType |
|
1622 // Camera ID to type mapping. |
|
1623 // ---------------------------------------------------------------------------- |
|
1624 // |
|
1625 CVtEngLocalVideo::TVtEngProviderType CVtEngLocalVideo::CameraIdToType( |
|
1626 MVtEngMedia::TCameraId aId ) |
|
1627 { |
|
1628 TVtEngProviderType type( KVtEngProviderCam2 ); |
|
1629 switch ( aId ) |
|
1630 { |
|
1631 case MVtEngMedia::EPrimaryCamera: |
|
1632 type = KVtEngProviderCam1; |
|
1633 break; |
|
1634 case MVtEngMedia::ESecondaryCamera: |
|
1635 type = KVtEngProviderCam2; |
|
1636 break; |
|
1637 default: |
|
1638 type = KVtEngProviderNone; |
|
1639 break; |
|
1640 } |
|
1641 return type; |
|
1642 } |
|
1643 |
|
1644 // ---------------------------------------------------------------------------- |
|
1645 // CVtEngLocalVideo::RunL |
|
1646 // CActive heir, acts according to status. |
|
1647 // ---------------------------------------------------------------------------- |
|
1648 // |
|
1649 void CVtEngLocalVideo::RunL() |
|
1650 { |
|
1651 __VTPRINTENTER( "LocVid.RunL" ) |
|
1652 |
|
1653 const TInt status( iStatus.Int() ); |
|
1654 TVtEngProviderType providerType = KVtEngProviderNone; |
|
1655 __VTPRINT2( DEBUG_MEDIA, "LocVideo.RunL %d", status ) |
|
1656 switch ( status ) |
|
1657 { |
|
1658 case KVtEngAlreadySelected: |
|
1659 SetFlag( EFlagSignalSourceSelection ); |
|
1660 vsProviderReady(); |
|
1661 break; |
|
1662 case KVtEngAlreadyActive: |
|
1663 TRAP_IGNORE( |
|
1664 iObserver.HandleLocalVideoOperationCompleteL( KErrNone ) ); |
|
1665 break; |
|
1666 case KErrNone: |
|
1667 vsProviderSwitchDone( NULL ); |
|
1668 UpdateState(); |
|
1669 break; |
|
1670 // Camera has been lost during VT |
|
1671 case KVsErrCameraNoLongerReserved: |
|
1672 __VTPRINT2( DEBUG_MEDIA, "LocVideo.status =%d", |
|
1673 status ) |
|
1674 //delete provider here and null pointer |
|
1675 if ( iSelectedProvider ) |
|
1676 { |
|
1677 DeleteProvider( *iSelectedProvider ); |
|
1678 iSelectedProvider = NULL; |
|
1679 } |
|
1680 |
|
1681 // Check if still is in use |
|
1682 providerType = KVtEngProviderImage; |
|
1683 GetHighestSelectableProvider( providerType ); |
|
1684 |
|
1685 __VTPRINT2( DEBUG_MEDIA, "LocVideo.providerType=%d", |
|
1686 providerType ) |
|
1687 |
|
1688 iObserver.AutoEnableVideo( EFalse ); |
|
1689 SetFlag( EFlagAutomaticSwitchCallback ); |
|
1690 TRAPD( err, SelectSourceL( providerType ) ); |
|
1691 ClearFlag( EFlagAutomaticSwitchCallback ); |
|
1692 |
|
1693 if ( err != KErrNone ) |
|
1694 { |
|
1695 TRAP( err, iObserver.HandleLocalVideoOperationCompleteL( err) ); |
|
1696 } |
|
1697 break; |
|
1698 default: |
|
1699 // error |
|
1700 { |
|
1701 switch( iSelectedProvider->iType ) |
|
1702 { |
|
1703 case KVtEngProviderCam1: |
|
1704 ClearFlag( EFlagCamera1Available ); |
|
1705 break; |
|
1706 case KVtEngProviderCam2: |
|
1707 ClearFlag( EFlagCamera2Available ); |
|
1708 break; |
|
1709 default: |
|
1710 break; |
|
1711 } |
|
1712 DeleteProvider( *iSelectedProvider ); |
|
1713 iSelectedProvider = NULL; |
|
1714 MVtEngMedia::TCameraId currentCam( MVtEngMedia::EPrimaryCamera ); |
|
1715 iObserver.GetCurrentCameraId( currentCam ); |
|
1716 TVtEngProviderType providerType( CameraIdToType( currentCam ) ); |
|
1717 GetHighestSelectableProvider( providerType ); |
|
1718 TRAPD( err, SelectSourceL( providerType ) ); |
|
1719 if ( err != KErrNone ) |
|
1720 { |
|
1721 TRAP( err, iObserver.HandleLocalVideoOperationCompleteL( err) ); |
|
1722 } |
|
1723 } |
|
1724 } |
|
1725 __VTPRINTEXIT( "LocVid.RunL" ) |
|
1726 } |
|
1727 |
|
1728 // ----------------------------------------------------------------------------- |
|
1729 // CVtEngLocalVideo::IsActiveProvider |
|
1730 // Returns ETrue if given provider is already active. |
|
1731 // ----------------------------------------------------------------------------- |
|
1732 // |
|
1733 TBool CVtEngLocalVideo::IsActiveProvider( TVtEngProviderType aType ) const |
|
1734 { |
|
1735 __VTPRINTENTER( "LocVid.IsActiveProvider" ) |
|
1736 const TBool active( |
|
1737 ( iActiveProvider && iActiveProvider->iType == aType ) || |
|
1738 ( iSelectedProvider && iSelectedProvider->iType == aType ) ); |
|
1739 __VTPRINTEXITR( "LocVid.IsActiveProvider %d", active ) |
|
1740 return active; |
|
1741 } |
|
1742 |
|
1743 // ----------------------------------------------------------------------------- |
|
1744 // CVtEngLocalVideo::DoCancel |
|
1745 // Does nothing. |
|
1746 // ----------------------------------------------------------------------------- |
|
1747 // |
|
1748 void CVtEngLocalVideo::DoCancel() |
|
1749 { |
|
1750 __VTPRINTENTER( "LocVid.DoCancel" ) |
|
1751 __VTPRINTEXIT( "LocVid.DoCancel" ) |
|
1752 } |
|
1753 |
|
1754 // ----------------------------------------------------------------------------- |
|
1755 // CVtEngLocalVideo::ActiveProvider |
|
1756 // Returns active provider. |
|
1757 // ----------------------------------------------------------------------------- |
|
1758 // |
|
1759 CVtEngLocalVideo::TVtEngProviderType CVtEngLocalVideo::ActiveProvider() const |
|
1760 { |
|
1761 if ( iActiveProvider ) |
|
1762 { |
|
1763 return iActiveProvider->iType; |
|
1764 } |
|
1765 return KVtEngProviderNone; |
|
1766 } |
|
1767 |
|
1768 // ----------------------------------------------------------------------------- |
|
1769 // CVtEngLocalVideo::StartViewFinderIfWasStartedL |
|
1770 // View finder image can be set. |
|
1771 // ----------------------------------------------------------------------------- |
|
1772 // |
|
1773 void CVtEngLocalVideo::StartViewFinderIfWasStartedL() |
|
1774 { |
|
1775 __VTPRINTENTER( "LocVid.StartViewFinderIfWasStartedL" ) |
|
1776 if ( IsFlag( EFlagUIForeground ) && IsFlag( EFlagVFEnabled ) && |
|
1777 iState == ELocReady ) |
|
1778 { |
|
1779 StartViewFinderL(); |
|
1780 } |
|
1781 __VTPRINTEXIT( "LocVid.StartViewFinderIfWasStartedL" ) |
|
1782 } |
|
1783 |
|
1784 // ----------------------------------------------------------------------------- |
|
1785 // CVtEngLocalVideo::StartViewFinderL |
|
1786 // Starts view finder. |
|
1787 // ----------------------------------------------------------------------------- |
|
1788 // |
|
1789 void CVtEngLocalVideo::StartViewFinderL( TBool aClientRequest ) |
|
1790 { |
|
1791 __VTPRINTENTER( "LocVid.StartViewFinderL" ) |
|
1792 __ASSERT_ALWAYS( iVideoProviders->Count(), |
|
1793 Panic ( EVtEngPanicNoVideoProvider ) ); |
|
1794 |
|
1795 if ( aClientRequest ) |
|
1796 { |
|
1797 SetFlag( EFlagVFEnabled ); |
|
1798 } |
|
1799 if ( iRenderingMethod == EUnspecified || !iActiveProvider ) |
|
1800 { |
|
1801 __VTPRINT( DEBUG_MEDIA, "LocVideo.startVF error") |
|
1802 User::Leave( KErrNotReady ); |
|
1803 } |
|
1804 CVSDataProvider* provider = iActiveProvider->iProvider; |
|
1805 if ( !provider ) |
|
1806 { |
|
1807 __VTPRINT( DEBUG_MEDIA, "LocVideo.startVF error no provider") |
|
1808 User::Leave( KErrNotReady ); |
|
1809 } |
|
1810 else if ( provider->ViewFinderActive() ) |
|
1811 { |
|
1812 __VTPRINT( DEBUG_MEDIA, "LocVideo.startVF already started") |
|
1813 iViewFinderState = ( iRenderingMethod == EWindowServer ) ? |
|
1814 EVFReceivingBitmaps : EVFRenderingDsa; |
|
1815 __VTPRINTEXIT( "LocVid.StartViewFinderL" ) |
|
1816 return; |
|
1817 } |
|
1818 else if ( !IsFlag( EFlagInitialized ) ) |
|
1819 { |
|
1820 __VTPRINT( DEBUG_MEDIA, |
|
1821 "LocVideo.startVF not initialized") |
|
1822 __VTPRINTEXIT( "LocVid.StartViewFinderL" ) |
|
1823 return; |
|
1824 } |
|
1825 else if ( iState != ELocReady ) |
|
1826 { |
|
1827 __VTPRINT2( DEBUG_MEDIA | DEBUG_RETURN, |
|
1828 "LocVideo.startVF incorrect iState=%d", iState ) |
|
1829 } |
|
1830 else |
|
1831 { |
|
1832 // Lint requires this one |
|
1833 __VTPRINT( DEBUG_MEDIA, |
|
1834 "LocVideo.startVF unsupported clause" ) |
|
1835 } |
|
1836 |
|
1837 CheckOthersStopped( *provider ); |
|
1838 if ( iRenderingMethod == EWindowServer ) |
|
1839 { |
|
1840 TSize size( iOptions.iSize ); |
|
1841 provider->StartViewFinderBitmapsL( size ); |
|
1842 iViewFinderState = EVFReceivingBitmaps; |
|
1843 __VTPRINT( DEBUG_MEDIA | DEBUG_RETURN, " started" ) |
|
1844 } |
|
1845 else |
|
1846 { |
|
1847 provider->StartViewFinderDirectL( |
|
1848 *(iDsaOptions.iWs), |
|
1849 *(iDsaOptions.iWsSD), |
|
1850 *(iDsaOptions.iWindow), |
|
1851 iDsaOptions.iRect, |
|
1852 iDsaOptions.iClipRect ); |
|
1853 iViewFinderState = EVFRenderingDsa; |
|
1854 } |
|
1855 |
|
1856 if( iActiveProvider->iType == CVtEngLocalVideo::KVtEngProviderCam1 && |
|
1857 !provider->ViewFinderMirror() ) |
|
1858 { |
|
1859 provider->SetViewFinderMirrorL( ETrue ); |
|
1860 } |
|
1861 |
|
1862 __VTPRINTEXIT( "LocVid.StartViewFinderL" ) |
|
1863 } |
|
1864 |
|
1865 // ----------------------------------------------------------------------------- |
|
1866 // CVtEngLocalVideo::StopViewFinder |
|
1867 // Stops view finder. |
|
1868 // ----------------------------------------------------------------------------- |
|
1869 // |
|
1870 void CVtEngLocalVideo::StopViewFinder( TBool aClientRequest ) |
|
1871 { |
|
1872 __VTPRINTENTER( "LocVid.StopViewFinder" ) |
|
1873 if ( aClientRequest ) |
|
1874 { |
|
1875 __VTPRINT( DEBUG_MEDIA, "LocVideo.stopVF clearing EFlagVFEnabled" ) |
|
1876 ClearFlag( EFlagVFEnabled ); |
|
1877 } |
|
1878 if ( iActiveProvider && |
|
1879 iViewFinderState != EVFNone && |
|
1880 iActiveProvider->iProvider && |
|
1881 iActiveProvider->iProvider->ViewFinderActive() ) |
|
1882 { |
|
1883 TRAP_IGNORE( iOptions.iObserver->vtHandleFrameL( |
|
1884 MVtEngFrameObserver::ELocalVideoFrame, NULL ) ); |
|
1885 iActiveProvider->iProvider->StopViewFinder(); |
|
1886 __VTPRINT( DEBUG_MEDIA, "LocVideo.stopVF Stopped" ) |
|
1887 if ( IsFlag( EFlagAutomaticSwitchCallback ) || |
|
1888 IsFlag( EFlagUIBackground ) ) |
|
1889 { |
|
1890 // UI needs to be notified if stop done due to automatic |
|
1891 // source switch (from vsProvidersChanged). |
|
1892 ClearFlag( EFlagAutomaticSwitchCallback ); |
|
1893 CVtEngEventManager::NotifyEvent( KVtEngViewFinderStopped ); |
|
1894 __VTPRINT( DEBUG_MEDIA, "LocVideo.stopVF Notified" ) |
|
1895 } |
|
1896 } |
|
1897 iViewFinderState = EVFNone; |
|
1898 __VTPRINTEXIT( "LocVid.StopViewFinder" ) |
|
1899 } |
|
1900 |
|
1901 // ----------------------------------------------------------------------------- |
|
1902 // CVtEngLocalVideo::FreezeL |
|
1903 // Freezes provider. |
|
1904 // ----------------------------------------------------------------------------- |
|
1905 // |
|
1906 void CVtEngLocalVideo::FreezeL() |
|
1907 { |
|
1908 __VTPRINTENTER( "LocVid.FreezeL" ) |
|
1909 if( OkToFreeze() ) |
|
1910 { |
|
1911 iActiveProvider->iProvider->FreezeL(); |
|
1912 SetFlag( EFlagFrozen ); |
|
1913 } |
|
1914 __VTPRINTEXIT( "LocVid.FreezeL" ) |
|
1915 } |
|
1916 |
|
1917 // ----------------------------------------------------------------------------- |
|
1918 // CVtEngLocalVideo::UnfreezeL |
|
1919 // Unfreezes provider. |
|
1920 // ----------------------------------------------------------------------------- |
|
1921 // |
|
1922 void CVtEngLocalVideo::UnfreezeL() |
|
1923 { |
|
1924 __VTPRINTENTER( "LocVid.UnfreezeL" ) |
|
1925 if( OkToUnfreeze() ) |
|
1926 { |
|
1927 if ( !iLayoutChangeHandler.UnfreezeL() ) |
|
1928 { |
|
1929 iActiveProvider->iProvider->UnfreezeL(); |
|
1930 if ( iDelayedSelect.IsDelayedSelectPending() ) |
|
1931 { |
|
1932 TVtEngProviderType type( iDelayedSelect.DelayedSelectTarget() ); |
|
1933 __VTPRINT2( DEBUG_MEDIA, |
|
1934 "LocVideo.UnfreezeL delayed switch to %d", type ) |
|
1935 SelectSourceL( type ); |
|
1936 } |
|
1937 else |
|
1938 { |
|
1939 CompleteOperation( KErrNone ); |
|
1940 } |
|
1941 } |
|
1942 ClearFlag( EFlagFrozen ); |
|
1943 } |
|
1944 __VTPRINTEXIT( "LocVid.UnfreezeL" ) |
|
1945 } |
|
1946 |
|
1947 // ----------------------------------------------------------------------------- |
|
1948 // CVtEngLocalVideo::CheckOthersStopped |
|
1949 // Stops view finder of other providers than the one given as parameter. |
|
1950 // ----------------------------------------------------------------------------- |
|
1951 // |
|
1952 void CVtEngLocalVideo::CheckOthersStopped( const CVSDataProvider& aProvider ) |
|
1953 { |
|
1954 __VTPRINTENTER( "LocVid.CheckOthersStopped" ) |
|
1955 TInt count( iVideoProviders->Count() ); |
|
1956 while ( count-- ) |
|
1957 { |
|
1958 TProviderItem& item = ( *iVideoProviders )[count]; |
|
1959 if ( item.iProvider && |
|
1960 item.iProvider != &aProvider && |
|
1961 item.iProvider->ViewFinderActive() ) |
|
1962 { |
|
1963 item.iProvider->StopViewFinder(); |
|
1964 __VTPRINT( DEBUG_MEDIA | DEBUG_RETURN, "LocVideo.OtherStop" ) |
|
1965 } |
|
1966 } |
|
1967 __VTPRINTEXIT( "LocVid.CheckOthersStopped" ) |
|
1968 } |
|
1969 |
|
1970 // ----------------------------------------------------------------------------- |
|
1971 // CVtEngLocalVideo::Source |
|
1972 // Returns video source. |
|
1973 // ----------------------------------------------------------------------------- |
|
1974 // |
|
1975 MVTVideoSource* CVtEngLocalVideo::Source() const |
|
1976 { |
|
1977 return iSource; |
|
1978 } |
|
1979 |
|
1980 // ----------------------------------------------------------------------------- |
|
1981 // CVtEngLocalVideo::AudioSource |
|
1982 // Returns audio source. |
|
1983 // ----------------------------------------------------------------------------- |
|
1984 // |
|
1985 MVTAudioSource* CVtEngLocalVideo::AudioSource() const |
|
1986 { |
|
1987 return iAudioSource; |
|
1988 } |
|
1989 |
|
1990 // ----------------------------------------------------------------------------- |
|
1991 // CVtEngLocalVideo::GetMediaState |
|
1992 // Returns media state. |
|
1993 // ----------------------------------------------------------------------------- |
|
1994 // |
|
1995 TInt CVtEngLocalVideo::GetMediaState( TInt& aActiveMedia ) |
|
1996 { |
|
1997 aActiveMedia = 0; |
|
1998 if ( !IsFlag( EFlagAudioMuted ) ) |
|
1999 { |
|
2000 aActiveMedia |= MVtEngMedia::EMediaAudio; |
|
2001 // Check if the thing is muted |
|
2002 } |
|
2003 |
|
2004 if ( iActiveProvider ) |
|
2005 { |
|
2006 __VTPRINT2( DEBUG_MEDIA, "LocVideo.GetMediaState provider type=%d", |
|
2007 iActiveProvider->iType ) |
|
2008 switch ( iActiveProvider->iType ) |
|
2009 { |
|
2010 case KVtEngProviderCam1: |
|
2011 case KVtEngProviderCam2: |
|
2012 case KVtEngProviderImage: |
|
2013 case KVtEngProviderShareImage: |
|
2014 aActiveMedia |= MVtEngMedia::EMediaVideo; |
|
2015 break; |
|
2016 default: |
|
2017 break; |
|
2018 } |
|
2019 } |
|
2020 __VTPRINT2( DEBUG_MEDIA | DEBUG_RETURN, |
|
2021 "LocVideo.GetMediaState media state=%d", aActiveMedia ) |
|
2022 return KErrNone; |
|
2023 } |
|
2024 |
|
2025 // ----------------------------------------------------------------------------- |
|
2026 // CVtEngLocalVideo::GetMediaSource |
|
2027 // Returns media source. |
|
2028 // ----------------------------------------------------------------------------- |
|
2029 // |
|
2030 MVtEngMedia::TMediaSource CVtEngLocalVideo::GetMediaSource() |
|
2031 { |
|
2032 MVtEngMedia::TMediaSource source( MVtEngMedia::EMediaNone ); |
|
2033 if ( iActiveProvider ) |
|
2034 { |
|
2035 switch ( iActiveProvider->iType ) |
|
2036 { |
|
2037 case KVtEngProviderCam1: |
|
2038 case KVtEngProviderCam2: |
|
2039 source = MVtEngMedia::EMediaCamera; |
|
2040 break; |
|
2041 case KVtEngProviderShareImage: |
|
2042 source = MVtEngMedia::EMediaShare; |
|
2043 break; |
|
2044 case KVtEngProviderImage: |
|
2045 case KVtEngProviderDefaultStillImage: |
|
2046 source = MVtEngMedia::EMediaStillImage; |
|
2047 break; |
|
2048 default: |
|
2049 source = MVtEngMedia::EMediaNone; |
|
2050 break; |
|
2051 } |
|
2052 } |
|
2053 __VTPRINT2( DEBUG_MEDIA, "LocVideo.GetMediaSource src=%d", (TInt) source ) |
|
2054 return source; |
|
2055 } |
|
2056 |
|
2057 // ----------------------------------------------------------------------------- |
|
2058 // CVtEngLocalVideo::GetSourceCaps |
|
2059 // Returns capability of providers . |
|
2060 // ----------------------------------------------------------------------------- |
|
2061 // |
|
2062 TInt CVtEngLocalVideo::GetSourceCaps( TInt& aCaps ) |
|
2063 { |
|
2064 aCaps = 0; |
|
2065 TInt count( iVideoProviders->Count() ); |
|
2066 __VTPRINT2( DEBUG_MEDIA, "LocVideo.GetSourceCaps count=%d", count ) |
|
2067 while ( count-- ) |
|
2068 { |
|
2069 switch ( iVideoProviders->At(count).iType ) |
|
2070 { |
|
2071 case KVtEngProviderCam1: |
|
2072 __VTPRINT( DEBUG_MEDIA, |
|
2073 "LocVideo.GetSourceCaps cam1" ) |
|
2074 if ( IsFlag( EFlagCamera1Available ) ) |
|
2075 { |
|
2076 __VTPRINT( DEBUG_MEDIA, |
|
2077 "LocVideo.GetSourceCaps cam1 flagged" ) |
|
2078 aCaps |= MVtEngMedia::ESourceCapsPrimaryCamera; |
|
2079 } |
|
2080 break; |
|
2081 case KVtEngProviderCam2: |
|
2082 __VTPRINT( DEBUG_MEDIA, "LocVideo.GetSourceCaps cam2" ) |
|
2083 if ( IsFlag( EFlagCamera2Available ) ) |
|
2084 { |
|
2085 __VTPRINT( DEBUG_MEDIA, |
|
2086 "LocVideo.GetSourceCaps cam2 flagged" ) |
|
2087 aCaps |= MVtEngMedia::ESourceCapsSecondaryCamera; |
|
2088 } |
|
2089 break; |
|
2090 case KVtEngProviderImage: |
|
2091 { |
|
2092 __VTPRINT( DEBUG_MEDIA, |
|
2093 "LocVideo.GetSourceCaps image" ) |
|
2094 // Make sure that image is valid |
|
2095 CVtEngSettings& settings = CVtEngUtility::Settings(); |
|
2096 const CVtEngSettings::TVtEngVideoCallConfig& config = |
|
2097 settings.Config(); |
|
2098 if( config.iVideo.iImageIsValid ) |
|
2099 { |
|
2100 aCaps |= MVtEngMedia::ESourceCapsStillImage; |
|
2101 } |
|
2102 } |
|
2103 break; |
|
2104 default: |
|
2105 break; |
|
2106 } |
|
2107 } |
|
2108 __VTPRINT2( DEBUG_MEDIA, "LocVideo.GetSourceCaps caps=%d", aCaps ) |
|
2109 return KErrNone; |
|
2110 } |
|
2111 |
|
2112 // ----------------------------------------------------------------------------- |
|
2113 // CVtEngLocalVideo::InitializeOnly |
|
2114 // Sets boolean to indicate if the provider is to be initialized only. |
|
2115 // ----------------------------------------------------------------------------- |
|
2116 // |
|
2117 void CVtEngLocalVideo::InitializeOnly( TBool aInitOnly ) |
|
2118 { |
|
2119 InitializeOnlyEx( GetMediaSource() != MVtEngMedia::EMediaCamera && |
|
2120 aInitOnly ); |
|
2121 } |
|
2122 |
|
2123 // ----------------------------------------------------------------------------- |
|
2124 // CVtEngLocalVideo::InitializeOnlyEx |
|
2125 // Sets boolean to indicate if the provider is to be initialized only. Does |
|
2126 // not check current media source. |
|
2127 // ----------------------------------------------------------------------------- |
|
2128 // |
|
2129 void CVtEngLocalVideo::InitializeOnlyEx( TBool aInitOnly ) |
|
2130 { |
|
2131 SetFlag( EFlagSignalSourceSelection ); |
|
2132 ClearFlag( EFlagInitializeOnly ); |
|
2133 if ( aInitOnly ) |
|
2134 { |
|
2135 SetFlag( EFlagInitializeOnly ); |
|
2136 } |
|
2137 #ifdef VTDEBUG |
|
2138 if ( IsFlag( EFlagInitializeOnly ) ) |
|
2139 { |
|
2140 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, " initOnly SET" ) |
|
2141 } |
|
2142 else |
|
2143 { |
|
2144 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, " initOnly CLEARED" ) |
|
2145 } |
|
2146 #endif |
|
2147 } |
|
2148 |
|
2149 // ----------------------------------------------------------------------------- |
|
2150 // CVtEngLocalVideo::GetProviderByType |
|
2151 // Return provider of particular type. |
|
2152 // ----------------------------------------------------------------------------- |
|
2153 // |
|
2154 TInt CVtEngLocalVideo::GetProviderByType( |
|
2155 TVtEngProviderType aType, |
|
2156 TProviderItem& aItem ) |
|
2157 { |
|
2158 TInt ret( KErrNotFound ); |
|
2159 TInt count( iVideoProviders->Count() ); |
|
2160 while ( count-- ) |
|
2161 { |
|
2162 if ( ( *iVideoProviders )[count].iType == aType ) |
|
2163 { |
|
2164 aItem = ( *iVideoProviders )[count]; |
|
2165 ret = count; |
|
2166 count = 0; |
|
2167 } |
|
2168 } |
|
2169 __VTPRINT2( DEBUG_MEDIA, "LocVideo.GetProviderByType idx=%d", ret ) |
|
2170 return ret; |
|
2171 } |
|
2172 |
|
2173 // ----------------------------------------------------------------------------- |
|
2174 // CVtEngLocalVideo::GetProviderByType |
|
2175 // Return provider of particular type. |
|
2176 // ----------------------------------------------------------------------------- |
|
2177 // |
|
2178 TInt CVtEngLocalVideo::GetProviderByType( |
|
2179 TVtEngProviderType aType, |
|
2180 TProviderItem*& aItem ) |
|
2181 { |
|
2182 TInt ret( KErrNotFound ); |
|
2183 TInt count( iVideoProviders->Count() ); |
|
2184 while ( count-- ) |
|
2185 { |
|
2186 if ( ( *iVideoProviders )[count].iType == aType ) |
|
2187 { |
|
2188 aItem = &( *iVideoProviders )[count]; |
|
2189 ret = count; |
|
2190 count = 0; |
|
2191 } |
|
2192 } |
|
2193 __VTPRINT2( DEBUG_MEDIA, "LocVideo.GetProviderByType* idx=%d", ret ) |
|
2194 return ret; |
|
2195 } |
|
2196 |
|
2197 // ----------------------------------------------------------------------------- |
|
2198 // CVtEngLocalVideo::GetProviderByInstance |
|
2199 // Return provider with particular provider instance. |
|
2200 // ----------------------------------------------------------------------------- |
|
2201 // |
|
2202 TInt CVtEngLocalVideo::GetProviderByInstance( |
|
2203 const CVSDataProvider* aInstance, |
|
2204 TProviderItem*& aItem ) const |
|
2205 { |
|
2206 TInt indexI( ProviderIndexByInstance( aInstance ) ); |
|
2207 if ( indexI != KErrNotFound ) |
|
2208 { |
|
2209 aItem = &( *iVideoProviders )[ indexI ]; |
|
2210 } |
|
2211 else |
|
2212 { |
|
2213 aItem = NULL; |
|
2214 } |
|
2215 __VTPRINT2( DEBUG_MEDIA, "LocVideo.GetProviderByType* idx=%d", indexI ) |
|
2216 return indexI; |
|
2217 } |
|
2218 |
|
2219 // ----------------------------------------------------------------------------- |
|
2220 // CVtEngLocalVideo::ProviderIndex |
|
2221 // Returns provider index by type. |
|
2222 // ----------------------------------------------------------------------------- |
|
2223 // |
|
2224 TInt CVtEngLocalVideo::ProviderIndex( TVtEngProviderType aType ) const |
|
2225 { |
|
2226 for( TInt count = iVideoProviders->Count() - 1; count >= 0; count-- ) |
|
2227 { |
|
2228 if ( ( *iVideoProviders )[ count ].iType == aType ) |
|
2229 { |
|
2230 return count; |
|
2231 } |
|
2232 } |
|
2233 return KErrNotFound; |
|
2234 } |
|
2235 |
|
2236 // ----------------------------------------------------------------------------- |
|
2237 // CVtEngLocalVideo::ProviderIndexByState |
|
2238 // Gets a provider index by state. |
|
2239 // ----------------------------------------------------------------------------- |
|
2240 // |
|
2241 TInt CVtEngLocalVideo::ProviderIndexByState( TProviderState aState ) const |
|
2242 { |
|
2243 for( TInt count = iVideoProviders->Count() - 1; count >= 0; count-- ) |
|
2244 { |
|
2245 if ( ( *iVideoProviders )[ count ].iProviderState == aState ) |
|
2246 { |
|
2247 return count; |
|
2248 } |
|
2249 } |
|
2250 return KErrNotFound; |
|
2251 } |
|
2252 |
|
2253 // ----------------------------------------------------------------------------- |
|
2254 // CVtEngLocalVideo::ProviderIndexByInstance |
|
2255 // ----------------------------------------------------------------------------- |
|
2256 // |
|
2257 TInt CVtEngLocalVideo::ProviderIndexByInstance( |
|
2258 const CVSDataProvider* aInstance) const |
|
2259 { |
|
2260 for( TInt count = iVideoProviders->Count() - 1; count >= 0; count-- ) |
|
2261 { |
|
2262 if ( ( *iVideoProviders )[ count ].iProvider == aInstance ) |
|
2263 { |
|
2264 return count; |
|
2265 } |
|
2266 } |
|
2267 return KErrNotFound; |
|
2268 } |
|
2269 |
|
2270 // ----------------------------------------------------------------------------- |
|
2271 // CVtEngLocalVideo::CreateDataProviderL |
|
2272 // Creates VideoSource provider by type. |
|
2273 // ----------------------------------------------------------------------------- |
|
2274 // |
|
2275 CVSDataProvider* CVtEngLocalVideo::CreateDataProviderL( |
|
2276 TVtEngProviderType aType ) |
|
2277 { |
|
2278 __VTPRINTENTER( "LocVid.CreateDataProviderL" ) |
|
2279 __VTPRINT2( DEBUG_MEDIA, " provider type=%d", aType ) |
|
2280 TInt index = KErrNotFound; |
|
2281 switch ( aType ) |
|
2282 { |
|
2283 case KVtEngProviderNone: |
|
2284 case KVtEngProviderImage: |
|
2285 case KVtEngProviderShareImage: |
|
2286 case KVtEngProviderDefaultStillImage: |
|
2287 __VTPRINT( DEBUG_MEDIA, "LocVideo.CreateDataProviderL Still" ) |
|
2288 index = iProviderInfoIndexStill; |
|
2289 break; |
|
2290 case KVtEngProviderCam1: |
|
2291 __VTPRINT( DEBUG_MEDIA, "LocVideo.CreateDataProviderL Cam1" ) |
|
2292 index = iProviderInfoIndexCam1; |
|
2293 break; |
|
2294 case KVtEngProviderCam2: |
|
2295 __VTPRINT( DEBUG_MEDIA, "LocVideo.CreateDataProviderL Cam2" ) |
|
2296 index = iProviderInfoIndexCam2; |
|
2297 break; |
|
2298 default: |
|
2299 __VTPRINT( DEBUG_MEDIA, "LocVideo.CreateDataProviderL Mobile" ) |
|
2300 break; |
|
2301 } |
|
2302 |
|
2303 CVSDataProvider* provider = NULL; |
|
2304 if ( index != KErrNotFound ) |
|
2305 { |
|
2306 __VTPRINT( DEBUG_MEDIA, "LocVideo.CreateDataProviderL provider is" ) |
|
2307 provider = |
|
2308 iSourceController->CreateDataProviderL( |
|
2309 index, this, iSource ); |
|
2310 } |
|
2311 |
|
2312 __VTPRINT2( DEBUG_MEDIA, " provider created=%d", |
|
2313 ( TInt ) ( provider != NULL ) ) |
|
2314 __VTPRINTEXIT( "LocVid.CreateDataProviderL" ) |
|
2315 return provider; |
|
2316 } |
|
2317 |
|
2318 // ----------------------------------------------------------------------------- |
|
2319 // CVtEngLocalVideo::CreateBlankProvider |
|
2320 // Creates blank provider. |
|
2321 // ----------------------------------------------------------------------------- |
|
2322 // |
|
2323 void CVtEngLocalVideo::CreateBlankProviderL( const TInt aIndex ) |
|
2324 { |
|
2325 __VTPRINTENTER( "LocVid.CreateBlankProviderL" ) |
|
2326 __VTPRINT2( DEBUG_MEDIA, "LocVideo.CreateBlankProviderL idx=%d", aIndex ) |
|
2327 CVSDataProvider* provider = NULL; |
|
2328 TRAP_IGNORE( provider = iSourceController->CreateDataProviderL( |
|
2329 aIndex, this, iSource ) ); |
|
2330 CleanupStack::PushL( provider ); |
|
2331 TProviderItem item; |
|
2332 item.iProvider = provider; |
|
2333 item.iType = KVtEngProviderNone; |
|
2334 item.iInitialized = EFalse; |
|
2335 item.iProviderState = EPermanent; |
|
2336 iVideoProviders->AppendL( item ); |
|
2337 CleanupStack::Pop(); |
|
2338 __VTPRINTEXIT( "LocVid.CreateBlankProviderL" ) |
|
2339 } |
|
2340 |
|
2341 // ----------------------------------------------------------------------------- |
|
2342 // CVtEngLocalVideo::CreateDefaultStillImageProviderL |
|
2343 // Creates default still image provider. |
|
2344 // ----------------------------------------------------------------------------- |
|
2345 // |
|
2346 void CVtEngLocalVideo::CreateDefaultStillImageProviderL( const TInt aIndex ) |
|
2347 { |
|
2348 __VTPRINTENTER( "LocVid.CreateDefaultStillImageProviderL" ) |
|
2349 __VTPRINT2( DEBUG_MEDIA, "LocVideo.CreateDefaultStillImageProviderL idx=%d", aIndex ) |
|
2350 CVSDataProvider* provider = NULL; |
|
2351 TRAP_IGNORE( provider = iSourceController->CreateDataProviderL( |
|
2352 aIndex, this, iSource ) ); |
|
2353 CleanupStack::PushL( provider ); |
|
2354 TProviderItem item; |
|
2355 item.iProvider = provider; |
|
2356 item.iType = KVtEngProviderDefaultStillImage; |
|
2357 item.iInitialized = EFalse; |
|
2358 item.iProviderState = EPermanent; |
|
2359 iVideoProviders->AppendL( item ); |
|
2360 CleanupStack::Pop(); |
|
2361 __VTPRINTEXIT( "LocVid.CreateDefaultStillImageProviderL" ) |
|
2362 } |
|
2363 |
|
2364 |
|
2365 // ----------------------------------------------------------------------------- |
|
2366 // CVtEngLocalVideo::UpdateAvailableProvidersL |
|
2367 // Updates current providers and their information. |
|
2368 // ----------------------------------------------------------------------------- |
|
2369 // |
|
2370 CVtEngLocalVideo::TVtEngProviderType |
|
2371 CVtEngLocalVideo::UpdateAvailableProvidersL() |
|
2372 { |
|
2373 __VTPRINTENTER( "LocVid.UpdateAvailableProvidersL" ) |
|
2374 TVtEngProviderType type( KVtEngProviderNone ); |
|
2375 TInt count( iSourceController->ProvidersAvailable() ); |
|
2376 iNumSupportedCameras = count - 1; |
|
2377 TVSDataProviderInfo providerInfo; |
|
2378 TBool primaryAvailable( EFalse ); |
|
2379 TBool secondaryAvailable( EFalse ); |
|
2380 TBool mobileAvailable( EFalse ); |
|
2381 TInt indexMobile( KErrNotFound ); |
|
2382 ClearFlag( EFlagCamera1Available ); |
|
2383 ClearFlag( EFlagCamera2Available ); |
|
2384 ResetIndices(); |
|
2385 while ( count-- ) |
|
2386 { |
|
2387 iSourceController->ProviderInfoL( count, providerInfo ); |
|
2388 if ( providerInfo.iOrientation == TCameraInfo::EOrientationInwards || |
|
2389 // treat outwards camera as primary when only 1 cam in the system |
|
2390 ( providerInfo.iOrientation == TCameraInfo::EOrientationOutwards && |
|
2391 iNumSupportedCameras == 1 ) ) |
|
2392 { |
|
2393 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.UAP inw" ) |
|
2394 type = KVtEngProviderCam1; |
|
2395 primaryAvailable = ETrue; |
|
2396 SetFlag( EFlagCamera1Available ); |
|
2397 iProviderInfoIndexCam1 = count; |
|
2398 } |
|
2399 else if ( |
|
2400 providerInfo.iOrientation == TCameraInfo::EOrientationOutwards ) |
|
2401 { |
|
2402 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.UAP outw" ) |
|
2403 secondaryAvailable = ETrue; |
|
2404 SetFlag( EFlagCamera2Available ); |
|
2405 iProviderInfoIndexCam2 = count; |
|
2406 } |
|
2407 else if ( providerInfo.iOrientation == TCameraInfo::EOrientationMobile ) |
|
2408 { |
|
2409 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.UAP mobile" ) |
|
2410 mobileAvailable = ETrue; |
|
2411 indexMobile = count; |
|
2412 } |
|
2413 else if ( providerInfo.iOrientation == TCameraInfo::EOrientationUnknown ) |
|
2414 { |
|
2415 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.UAP still" ) |
|
2416 CVtEngSettings& settings = CVtEngUtility::Settings(); |
|
2417 const CVtEngSettings::TVtEngVideoCallConfig& config = |
|
2418 settings.Config(); |
|
2419 if ( config.iVideo.iImageIsValid ) |
|
2420 { |
|
2421 iProviderInfoIndexStill = count; |
|
2422 } |
|
2423 } |
|
2424 } |
|
2425 if ( !primaryAvailable && mobileAvailable ) |
|
2426 { |
|
2427 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.UAP 1 upd" ) |
|
2428 type = KVtEngProviderCam1; |
|
2429 iProviderInfoIndexCam1 = indexMobile; |
|
2430 primaryAvailable = ETrue; |
|
2431 SetFlag( EFlagCamera1Available ); |
|
2432 } |
|
2433 else if ( primaryAvailable && mobileAvailable ) |
|
2434 { |
|
2435 // No 1, 2 and mobile. |
|
2436 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.UAP 2 upd" ) |
|
2437 DeleteProvider( KVtEngProviderCam2 ); |
|
2438 secondaryAvailable = ETrue; |
|
2439 iProviderInfoIndexCam2 = indexMobile; |
|
2440 SetFlag( EFlagCamera2Available ); |
|
2441 } |
|
2442 else if ( !primaryAvailable && secondaryAvailable ) |
|
2443 { |
|
2444 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.UAP !1 & 2" ) |
|
2445 type = KVtEngProviderCam2; |
|
2446 } |
|
2447 else if ( type == KVtEngProviderNone ) |
|
2448 { |
|
2449 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.UAP none" ) |
|
2450 CVtEngSettings& settings = CVtEngUtility::Settings(); |
|
2451 const CVtEngSettings::TVtEngVideoCallConfig& config = |
|
2452 settings.Config(); |
|
2453 if ( config.iVideo.iImageIsValid ) |
|
2454 { |
|
2455 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.UAP valid image" ) |
|
2456 type = KVtEngProviderImage; |
|
2457 } |
|
2458 } |
|
2459 |
|
2460 __VTPRINTEXITR( "LocVid.UpdateAvailableProvidersL %d", type ) |
|
2461 return type; |
|
2462 } |
|
2463 |
|
2464 // ----------------------------------------------------------------------------- |
|
2465 // CVtEngLocalVideo::SwitchProvider |
|
2466 // Switches to active provider. |
|
2467 // ----------------------------------------------------------------------------- |
|
2468 // |
|
2469 void CVtEngLocalVideo::SwitchProvider( TProviderItem* aSwitchToItem ) |
|
2470 { |
|
2471 __VTPRINTENTER( "LocVid.SwitchProvider" ) |
|
2472 |
|
2473 iState = ELocSwichingProvider; |
|
2474 __VTPRINT( DEBUG_MEDIA, " STATE TO SWITCHING" ) |
|
2475 iFadingProvider = iActiveProvider; |
|
2476 iActiveProvider = aSwitchToItem; |
|
2477 TRAPD( err, iSource->SwitchDataProviderL( iActiveProvider->iProvider ) ); |
|
2478 if ( err != KErrNone ) |
|
2479 { |
|
2480 iState = ELocReady; // go to AO |
|
2481 __VTPRINT( DEBUG_MEDIA, " STATE TO READY" ) |
|
2482 } |
|
2483 switch ( iState ) |
|
2484 { |
|
2485 case ELocReady: // Switch done. Sync. |
|
2486 { |
|
2487 // Entered here if SwitchDataProviderL causes direct call to |
|
2488 // vsProviderSwitchDone. Since provider switch should be async |
|
2489 // from client point of view now start AO and signal in RunL. |
|
2490 Cancel(); |
|
2491 TRequestStatus* status = &iStatus; |
|
2492 SetActive(); |
|
2493 User::RequestComplete( status, err ); |
|
2494 __VTPRINT2( DEBUG_MEDIA, |
|
2495 "LocVideo.SwitchProvider AO start %d", err ) |
|
2496 } |
|
2497 // fall through |
|
2498 case ELocSwichingProvider: // Async. |
|
2499 case ELocNone: |
|
2500 SetFlag( EFlagSignalSourceSelection ); |
|
2501 break; |
|
2502 default: |
|
2503 break; |
|
2504 } |
|
2505 __VTPRINTEXIT( "LocVid.SwitchProvider" ) |
|
2506 } |
|
2507 |
|
2508 // ----------------------------------------------------------------------------- |
|
2509 // CVtEngLocalVideo::SwitchProvider |
|
2510 // Overloaded method that takes new active provider as a parameter. |
|
2511 // ----------------------------------------------------------------------------- |
|
2512 // |
|
2513 void CVtEngLocalVideo::SwitchProvider( TProviderItem& aProviderItem ) |
|
2514 { |
|
2515 __VTPRINTENTER( "LocVid.SwitchProvider by aProviderItem" ) |
|
2516 StopViewFinder( EFalse ); |
|
2517 SwitchProvider( &aProviderItem ); |
|
2518 __VTPRINTEXIT( "LocVid.SwitchProvider by aProviderItem" ) |
|
2519 } |
|
2520 |
|
2521 // ----------------------------------------------------------------------------- |
|
2522 // CVtEngLocalVideo::IsInitialized |
|
2523 // Checks if a provider with given id is initialized. |
|
2524 // ----------------------------------------------------------------------------- |
|
2525 // |
|
2526 TInt CVtEngLocalVideo::IsInitialized( |
|
2527 MVtEngMedia::TCameraId aId, |
|
2528 TBool& aInitialized ) |
|
2529 { |
|
2530 __VTPRINT2( DEBUG_MEDIA, "LocVideo.IsInitialized ID:%d", aId ) |
|
2531 TInt count( iVideoProviders->Count() ); |
|
2532 TVtEngProviderType type = CameraIdToType( aId ); |
|
2533 aInitialized = EFalse; |
|
2534 TInt err( KErrNotFound ); |
|
2535 while ( count-- ) |
|
2536 { |
|
2537 TProviderItem& item = ( *iVideoProviders )[count]; |
|
2538 if ( item.iType == type ) |
|
2539 { |
|
2540 __VTPRINT( DEBUG_MEDIA, "LocVideo.IsInitialized found" ) |
|
2541 aInitialized = item.iInitialized; |
|
2542 if ( ( !aInitialized && item.iProviderState < KErrNone ) || |
|
2543 item.iErrorCode < KErrNone ) |
|
2544 { |
|
2545 __VTPRINT( DEBUG_MEDIA, "LocVideo.IsInitialized problems" ) |
|
2546 err = item.iErrorCode; |
|
2547 } |
|
2548 else |
|
2549 { |
|
2550 err = KErrNone; |
|
2551 } |
|
2552 count = 0; // break |
|
2553 } |
|
2554 } |
|
2555 __VTPRINT3( DEBUG_MEDIA | DEBUG_RETURN, |
|
2556 "LocVideo.IsInitialized isInitialized=%d,err=%d", aInitialized, err ) |
|
2557 return err; |
|
2558 } |
|
2559 |
|
2560 // ----------------------------------------------------------------------------- |
|
2561 // CVtEngLocalVideo::UpdateState |
|
2562 // Updates view finder state. |
|
2563 // ----------------------------------------------------------------------------- |
|
2564 // |
|
2565 void CVtEngLocalVideo::UpdateState() |
|
2566 { |
|
2567 __VTPRINTENTER( "LocVid.UpdateState" ) |
|
2568 |
|
2569 if ( iActiveProvider ) |
|
2570 { |
|
2571 CVSDataProvider* provider = iActiveProvider->iProvider; |
|
2572 __VTPRINT2 ( DEBUG_MEDIA, "LocVideo.UpdateState, provider active", |
|
2573 provider->ViewFinderActive() ) |
|
2574 if ( provider && provider->ViewFinderActive()) |
|
2575 { |
|
2576 iViewFinderState = ( iRenderingMethod == EWindowServer ) ? |
|
2577 EVFReceivingBitmaps : EVFRenderingDsa; |
|
2578 } |
|
2579 } |
|
2580 ClearFlag( EFlagInitializeOnly ); |
|
2581 __VTPRINT2( DEBUG_MEDIA | DEBUG_RETURN, |
|
2582 "LocVideo.UpdateState iViewFinderState %d", iViewFinderState ) |
|
2583 __VTPRINTEXIT( "LocVid.UpdateState" ) |
|
2584 } |
|
2585 |
|
2586 // ----------------------------------------------------------------------------- |
|
2587 // CVtEngLocalVideo::InitializingOrSwitching |
|
2588 // Is either initializing or doing a provider switch. |
|
2589 // ----------------------------------------------------------------------------- |
|
2590 // |
|
2591 TBool CVtEngLocalVideo::InitializingOrSwitching() const |
|
2592 { |
|
2593 return ( iState == ELocInitializing || |
|
2594 iState == ELocSwichingProvider ); |
|
2595 } |
|
2596 |
|
2597 // ----------------------------------------------------------------------------- |
|
2598 // CVtEngLocalVideo::UninitializeProviderL |
|
2599 // Uninitializes initialized non-permanent provider. |
|
2600 // ----------------------------------------------------------------------------- |
|
2601 // |
|
2602 void CVtEngLocalVideo::UninitializeProviderL() |
|
2603 { |
|
2604 __VTPRINTENTER( "LocVid.UninitializeProviderL" ) |
|
2605 TInt count( iVideoProviders->Count() ); |
|
2606 while ( count-- ) |
|
2607 { |
|
2608 TProviderItem& item = ( *iVideoProviders )[count]; |
|
2609 if ( item.iProviderState == EUndefined && item.iInitialized ) |
|
2610 { |
|
2611 DeleteProvider( item ); |
|
2612 item.iProvider = CreateDataProviderL( item.iType ); |
|
2613 } |
|
2614 } |
|
2615 __VTPRINTEXIT( "LocVid.UninitializeProviderL" ) |
|
2616 } |
|
2617 |
|
2618 // ----------------------------------------------------------------------------- |
|
2619 // CVtEngLocalVideo::GetCameraInfo |
|
2620 // Gets camera info. |
|
2621 // ----------------------------------------------------------------------------- |
|
2622 // |
|
2623 TInt CVtEngLocalVideo::GetCameraInfo( MVtEngMedia::TCameraId aId, |
|
2624 MVtEngMedia::TCameraInfo& aInfo ) |
|
2625 { |
|
2626 TBool initialized( EFalse ); |
|
2627 TInt err( IsInitialized( aId, initialized ) ); |
|
2628 TVSDataProviderInfo info; |
|
2629 if ( initialized && err == KErrNone ) |
|
2630 { |
|
2631 TVtEngProviderType type = CameraIdToType( aId ); |
|
2632 TProviderItem item; |
|
2633 GetProviderByType( type, item ); |
|
2634 item.iProvider->ProviderInfo( info ); |
|
2635 aInfo.iMaxDigitalZoom = info.iMaxDigitalZoom; |
|
2636 aInfo.iMaxZoom = info.iMaxZoom; |
|
2637 aInfo.iMinZoom = info.iMinZoom; |
|
2638 aInfo.iMajorZoomStepCount = |
|
2639 CalculateMajorDigitalZoomStepCount( item.iProvider ); |
|
2640 } |
|
2641 return initialized ? err : KErrNotReady; |
|
2642 } |
|
2643 |
|
2644 // ----------------------------------------------------------------------------- |
|
2645 // CVtEngLocalVideo::GetDigitalZoomFactor |
|
2646 // Gets current zoom step. |
|
2647 // ----------------------------------------------------------------------------- |
|
2648 // |
|
2649 TInt CVtEngLocalVideo::GetDigitalZoomFactor( TInt& aCurrentStep ) |
|
2650 { |
|
2651 if ( !iActiveProvider || |
|
2652 !iActiveProvider->iProvider ) |
|
2653 { |
|
2654 return KErrNotReady; |
|
2655 } |
|
2656 aCurrentStep = iActiveProvider->iProvider->DigitalZoomFactor(); |
|
2657 __VTPRINT2( DEBUG_MEDIA, "LocVideo.GetZ %d", aCurrentStep ) |
|
2658 return KErrNone; |
|
2659 } |
|
2660 |
|
2661 // ----------------------------------------------------------------------------- |
|
2662 // CVtEngLocalVideo::GetMaxDigitalZoomStep |
|
2663 // Gets max. digital zoom step. |
|
2664 // ----------------------------------------------------------------------------- |
|
2665 // |
|
2666 TInt CVtEngLocalVideo::GetMaxDigitalZoomStep( TInt& aMaxZoomStep ) |
|
2667 { |
|
2668 if ( !iActiveProvider || |
|
2669 !iActiveProvider->iProvider ) |
|
2670 { |
|
2671 return KErrNotReady; |
|
2672 } |
|
2673 aMaxZoomStep = iProviderInfo.iMaxDigitalZoom; |
|
2674 __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, |
|
2675 "LocVideo.MaxZStep %d", aMaxZoomStep ) |
|
2676 return KErrNone; |
|
2677 } |
|
2678 |
|
2679 // ----------------------------------------------------------------------------- |
|
2680 // CVtEngLocalVideo::GetMajorDigitalZoomStepCount |
|
2681 // Gets number of major zoom level leaps. |
|
2682 // ----------------------------------------------------------------------------- |
|
2683 // |
|
2684 TInt CVtEngLocalVideo:: |
|
2685 GetMajorDigitalZoomStepCount( TInt& aCount, TBool /*aProviderSupplied*/ ) |
|
2686 { |
|
2687 /*__VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, |
|
2688 "LocVideo.GetMajZStepCount %d", aProviderSupplied )*/ |
|
2689 if ( !iActiveProvider || !iActiveProvider->iProvider ) |
|
2690 { |
|
2691 return KErrNotReady; |
|
2692 } |
|
2693 aCount = CalculateMajorDigitalZoomStepCount( iProviderInfo ); |
|
2694 __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, |
|
2695 "LocVideo.GetMajZStepCount %d", aCount ) |
|
2696 return KErrNone; |
|
2697 } |
|
2698 |
|
2699 // ----------------------------------------------------------------------------- |
|
2700 // CVtEngLocalVideo::GetMajorDigitalZoomStep |
|
2701 // Maps major step to zoom step. Note: aIndex is given in range |
|
2702 // [0 .. CalculateMajorDigitalZoomStepCount() - 1] |
|
2703 // ----------------------------------------------------------------------------- |
|
2704 // |
|
2705 void CVtEngLocalVideo::GetMajorDigitalZoomStep( const TInt aIndex, TInt& aStep ) |
|
2706 { |
|
2707 if ( !iActiveProvider || !iActiveProvider->iProvider ) |
|
2708 { |
|
2709 // No active provider. |
|
2710 __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "LocVideo.GetMajZStep NO active") |
|
2711 return; |
|
2712 } |
|
2713 if ( iProviderInfo.iMaxDigitalZoom > KVtMaxZoomStep ) |
|
2714 { |
|
2715 aStep = iProviderInfo.iMaxDigitalZoom * |
|
2716 Min( KVtMaxZoomStep, Max( 0, aIndex ) ) / KVtMaxZoomStep; |
|
2717 } |
|
2718 else |
|
2719 { |
|
2720 aStep = Min( iProviderInfo.iMaxDigitalZoom, Max( 0, aIndex ) ); |
|
2721 } |
|
2722 __VTPRINT3( DEBUG_MEDIA | DEBUG_DETAIL, |
|
2723 "LocVideo.GetMajZStep idx=%d,step=%d", aIndex, aStep ) |
|
2724 } |
|
2725 |
|
2726 // ----------------------------------------------------------------------------- |
|
2727 // CVtEngLocalVideo::GetFreezeSupported |
|
2728 // Gets freeze supported value from provider. |
|
2729 // ----------------------------------------------------------------------------- |
|
2730 // |
|
2731 TInt CVtEngLocalVideo::GetFreezeSupported( TBool& aFreezeSupported ) const |
|
2732 { |
|
2733 __VTPRINTENTER( "LocVideo.GetFreezeSupported" ) |
|
2734 if ( !iActiveProvider || |
|
2735 !iActiveProvider->iProvider ) |
|
2736 { |
|
2737 __VTPRINTEXIT( "LocVideo.GetFreezeSupported KErrNotReady") |
|
2738 return KErrNotReady; |
|
2739 } |
|
2740 aFreezeSupported = iProviderInfo.iFreezeSupported; |
|
2741 __VTPRINTEXITR( "LocVideo.GetFreezeSupported %d", aFreezeSupported ) |
|
2742 return KErrNone; |
|
2743 } |
|
2744 |
|
2745 // ----------------------------------------------------------------------------- |
|
2746 // CVtEngLocalVideo::OkToFreeze |
|
2747 // Returns ETrue if it is ok to freeze provider (i.e. freeze is supported AND |
|
2748 // provider is not currently frozen) |
|
2749 // ----------------------------------------------------------------------------- |
|
2750 // |
|
2751 TBool CVtEngLocalVideo::OkToFreeze() const |
|
2752 { |
|
2753 __VTPRINTENTER( "LocVideo.OkToFreeze" ) |
|
2754 TBool isOk( EFalse ); |
|
2755 if ( iActiveProvider && |
|
2756 iActiveProvider->iProvider ) |
|
2757 { |
|
2758 isOk = ( iProviderInfo.iFreezeSupported && !IsFlag( EFlagFrozen ) ); |
|
2759 } |
|
2760 __VTPRINTEXITR( "LocVideo.OkToFreeze %d", isOk ) |
|
2761 return isOk; |
|
2762 } |
|
2763 |
|
2764 // ----------------------------------------------------------------------------- |
|
2765 // CVtEngLocalVideo::OkToUnfreeze |
|
2766 // Returns ETrue if it is ok to unfreeze provider (i.e. freeze is supported AND |
|
2767 // provider is currently frozen) |
|
2768 // ----------------------------------------------------------------------------- |
|
2769 // |
|
2770 TBool CVtEngLocalVideo::OkToUnfreeze() const |
|
2771 { |
|
2772 __VTPRINTENTER( "LocVideo.OkToUnfreeze" ) |
|
2773 TBool isOk( EFalse ); |
|
2774 if ( iActiveProvider && |
|
2775 iActiveProvider->iProvider ) |
|
2776 { |
|
2777 isOk = ( iProviderInfo.iFreezeSupported && IsFlag( EFlagFrozen ) ); |
|
2778 } |
|
2779 __VTPRINTEXITR( "LocVideo.OkToUnfreeze %d", isOk ) |
|
2780 return isOk; |
|
2781 } |
|
2782 |
|
2783 // ----------------------------------------------------------------------------- |
|
2784 // CVtEngLocalVideo::Mute |
|
2785 // Sets the audio state as muted. |
|
2786 // ----------------------------------------------------------------------------- |
|
2787 void CVtEngLocalVideo::Mute() |
|
2788 { |
|
2789 SetFlag( EFlagAudioMuted ); |
|
2790 } |
|
2791 |
|
2792 // ----------------------------------------------------------------------------- |
|
2793 // CVtEngLocalVideo::UnMute |
|
2794 // Sets the audio state on again. |
|
2795 // ----------------------------------------------------------------------------- |
|
2796 void CVtEngLocalVideo::UnMute() |
|
2797 { |
|
2798 ClearFlag( EFlagAudioMuted ); |
|
2799 } |
|
2800 |
|
2801 // ----------------------------------------------------------------------------- |
|
2802 // CVtEngLocalVideo::SetUIForeground |
|
2803 // Sets UI foreground state. |
|
2804 // ----------------------------------------------------------------------------- |
|
2805 void CVtEngLocalVideo::SetUIForeground( TBool aForeground ) |
|
2806 { |
|
2807 __VTPRINTENTER( "LocVideo.SetUIForeground" ) |
|
2808 __VTPRINT2( DEBUG_GEN, " foreground=%d", aForeground ) |
|
2809 |
|
2810 //Error indicator |
|
2811 TInt err = KErrNone; |
|
2812 if ( aForeground ) |
|
2813 { |
|
2814 if ( iDelayedSelect.IsDelayedSelectPending() ) |
|
2815 { |
|
2816 TVtEngProviderType type( iDelayedSelect.DelayedSelectTarget() ); |
|
2817 __VTPRINT2( DEBUG_MEDIA, |
|
2818 "LocVideo.SetUIForeground delayed switch to %d", type ) |
|
2819 SelectSourceL( type ); |
|
2820 } |
|
2821 |
|
2822 SetFlag( EFlagUIForeground ); |
|
2823 ClearFlag( EFlagUIBackground ); |
|
2824 if ( IsFlag( EFlagVFEnabled ) ) |
|
2825 { |
|
2826 //Ignore error |
|
2827 TRAP (err, StartViewFinderL( EFalse )); |
|
2828 } |
|
2829 else |
|
2830 { |
|
2831 MVtEngMedia::TShareObjectState sharingState; |
|
2832 GetObjectSharingState( sharingState ); |
|
2833 if ( sharingState == MVtEngMedia::ESharingImage ) |
|
2834 { |
|
2835 //Ignore error |
|
2836 TRAP (err, StartViewFinderL( ETrue )); |
|
2837 } |
|
2838 } |
|
2839 } |
|
2840 else |
|
2841 { |
|
2842 ClearFlag( EFlagUIForeground ); |
|
2843 SetFlag( EFlagUIBackground ); |
|
2844 StopViewFinder( EFalse ); |
|
2845 ClearFlag( EFlagUIBackground ); |
|
2846 } |
|
2847 __VTPRINTEXIT( "LocVideo.SetUIForeground" ) |
|
2848 } |
|
2849 |
|
2850 // ----------------------------------------------------------------------------- |
|
2851 // CVtEngLocalVideo::GetObjectSharingState |
|
2852 // Get current media object sharing state. |
|
2853 // ----------------------------------------------------------------------------- |
|
2854 // |
|
2855 void CVtEngLocalVideo::GetObjectSharingState( |
|
2856 MVtEngMedia::TShareObjectState& aObjectSharingState ) const |
|
2857 { |
|
2858 __VTPRINTENTER( "LocVid.GetObjectSharingState" ) |
|
2859 if( iActiveProvider && iActiveProvider->iProvider ) |
|
2860 { |
|
2861 iShareImage->GetObjectSharingState( aObjectSharingState ); |
|
2862 } |
|
2863 else |
|
2864 { |
|
2865 aObjectSharingState = MVtEngMedia::ENotAbleToShare; |
|
2866 } |
|
2867 __VTPRINTEXITR( "LocVid.GetObjectSharingState %d", aObjectSharingState ) |
|
2868 } |
|
2869 |
|
2870 // ----------------------------------------------------------------------------- |
|
2871 // CVtEngLocalVideo::InitializeShareImageL |
|
2872 // Start Image sharing initialization. |
|
2873 // ----------------------------------------------------------------------------- |
|
2874 // |
|
2875 void CVtEngLocalVideo::InitializeShareImageL( |
|
2876 const MVtEngMedia::TShareObjectImageParameters& aParameters, |
|
2877 TBool& aFirstTime ) |
|
2878 { |
|
2879 __VTPRINTENTER( "LocVid.InitializeShareImageL" ) |
|
2880 |
|
2881 iShareImage->InitializeL( aParameters, |
|
2882 iActiveProvider->iType, aFirstTime ); |
|
2883 |
|
2884 __VTPRINTEXIT( "LocVid.InitializeShareImageL" ) |
|
2885 } |
|
2886 |
|
2887 // ----------------------------------------------------------------------------- |
|
2888 // CVtEngLocalVideo::StartShareImageL |
|
2889 // Stop sharing Image. |
|
2890 // ----------------------------------------------------------------------------- |
|
2891 // |
|
2892 void CVtEngLocalVideo::StartShareImageL() |
|
2893 { |
|
2894 __VTPRINTENTER( "LocVid.StartShareImageL" ) |
|
2895 const TBool delayed( iDelayedSelect.IsDelayedSelectPending() ); |
|
2896 const TVtEngProviderType type( iDelayedSelect.DelayedSelectTarget() ); |
|
2897 iShareImage->ShareL(); |
|
2898 if ( delayed ) |
|
2899 { |
|
2900 __VTPRINT2( DEBUG_MEDIA, |
|
2901 "LocVid.StartShareImageL IsDelayedSelectPending type = %d", |
|
2902 type ) |
|
2903 iShareImage->NotifyCameraChanged( type ); |
|
2904 } |
|
2905 __VTPRINTEXIT( "LocVid.StartShareImageL" ) |
|
2906 } |
|
2907 |
|
2908 // ----------------------------------------------------------------------------- |
|
2909 // CVtEngLocalVideo::StopShareImageL |
|
2910 // Stop sharing Image. |
|
2911 // ----------------------------------------------------------------------------- |
|
2912 // |
|
2913 void CVtEngLocalVideo::StopShareImageL() |
|
2914 { |
|
2915 __VTPRINTENTER( "LocVid.StopShareImageL" ) |
|
2916 iShareImage->StopL(); |
|
2917 __VTPRINTEXIT( "LocVid.StopShareImageL" ) |
|
2918 } |
|
2919 |
|
2920 // ----------------------------------------------------------------------------- |
|
2921 // CVtEngLocalVideo::ShareError |
|
2922 // Report error to image sharer. |
|
2923 // ----------------------------------------------------------------------------- |
|
2924 // |
|
2925 void CVtEngLocalVideo::ShareError( TInt aError ) |
|
2926 { |
|
2927 __VTPRINTENTER( "LocVid.ShareError" ) |
|
2928 iShareImage->Error( aError ); |
|
2929 __VTPRINTEXIT( "LocVid.ShareError" ) |
|
2930 } |
|
2931 |
|
2932 // ----------------------------------------------------------------------------- |
|
2933 // CVtEngLocalVideo::ShareStoredSource |
|
2934 // |
|
2935 // ----------------------------------------------------------------------------- |
|
2936 // |
|
2937 CVtEngLocalVideo::TVtEngProviderType CVtEngLocalVideo::ShareStoredSource() const |
|
2938 { |
|
2939 __VTPRINTENTER( "LocVid.ShareStoredSource" ) |
|
2940 const TVtEngProviderType stored( iShareImage->StoredSource() ); |
|
2941 __VTPRINTEXITR( "LocVid.ShareStoredSource = %d", stored ) |
|
2942 return stored; |
|
2943 } |
|
2944 |
|
2945 // ----------------------------------------------------------------------------- |
|
2946 // CVtEngLocalVideo::SettingsChanged |
|
2947 // Called when GS settings changed. |
|
2948 // ----------------------------------------------------------------------------- |
|
2949 // |
|
2950 void CVtEngLocalVideo::SettingsChanged() |
|
2951 { |
|
2952 __VTPRINTENTER( "LocVid.SettingsChanged" ) |
|
2953 iShareImage->SettingsChanged(); |
|
2954 __VTPRINTEXIT( "LocVid.SettingsChanged" ) |
|
2955 } |
|
2956 |
|
2957 // ----------------------------------------------------------------------------- |
|
2958 // CVtEngLocalVideo::SetIsPrepareCameraCalled |
|
2959 // ----------------------------------------------------------------------------- |
|
2960 // |
|
2961 void CVtEngLocalVideo::SetIsPrepareCameraCalled( TBool aCalled ) |
|
2962 { |
|
2963 __VTPRINTENTER( "LocVid.SetIsPrepareCameraCalled" ) |
|
2964 iPrepareCameraCalled = aCalled; |
|
2965 __VTPRINTEXITR( "LocVid.SetIsPrepareCameraCalled %d", iPrepareCameraCalled ) |
|
2966 } |
|
2967 |
|
2968 // ----------------------------------------------------------------------------- |
|
2969 // CVtEngLocalVideo::IsPrepareCameraCalled |
|
2970 // ----------------------------------------------------------------------------- |
|
2971 // |
|
2972 TBool CVtEngLocalVideo::IsPrepareCameraCalled() const |
|
2973 { |
|
2974 __VTPRINTENTER( "LocVid.IsPrepareCameraCalled" ) |
|
2975 __VTPRINTEXITR( "LocVid.IsPrepareCameraCalled %d", iPrepareCameraCalled ) |
|
2976 return iPrepareCameraCalled; |
|
2977 } |
|
2978 |
|
2979 // ----------------------------------------------------------------------------- |
|
2980 // CVtEngLocalVideo::HandleLayoutChangeL |
|
2981 // ----------------------------------------------------------------------------- |
|
2982 // |
|
2983 void CVtEngLocalVideo::HandleLayoutChangeL() |
|
2984 { |
|
2985 __VTPRINTENTER( "LocVid.HandleLayoutChangeL" ) |
|
2986 iLayoutChangeHandler.HandleLayoutChangeL(); |
|
2987 __VTPRINTEXIT( "LocVid.HandleLayoutChangeL" ) |
|
2988 } |
|
2989 |
|
2990 // ----------------------------------------------------------------------------- |
|
2991 // CVtEngLocalVideo::IsDelayedSelectPending |
|
2992 // ----------------------------------------------------------------------------- |
|
2993 // |
|
2994 TBool CVtEngLocalVideo::IsDelayedSelectPending() const |
|
2995 { |
|
2996 return iDelayedSelect.IsDelayedSelectPending(); |
|
2997 } |
|
2998 |
|
2999 // ----------------------------------------------------------------------------- |
|
3000 // CVtEngLocalVideo::DeleteProvider |
|
3001 // Deletes provider. |
|
3002 // ----------------------------------------------------------------------------- |
|
3003 // |
|
3004 void CVtEngLocalVideo::DeleteProvider( |
|
3005 TProviderItem& aItem ) |
|
3006 { |
|
3007 __VTPRINTENTER( "LocVid.DeleteProvider" ) |
|
3008 aItem.iProviderState = EUndefined; |
|
3009 if ( aItem.iProvider && |
|
3010 aItem.iInitialized && |
|
3011 aItem.iProvider->ViewFinderActive() ) |
|
3012 { |
|
3013 aItem.iProvider->StopViewFinder(); |
|
3014 } |
|
3015 delete aItem.iProvider; |
|
3016 aItem.iInitialized = EFalse; |
|
3017 aItem.iProvider = NULL; |
|
3018 __VTPRINTEXIT( "LocVid.DeleteProvider" ) |
|
3019 } |
|
3020 |
|
3021 // ----------------------------------------------------------------------------- |
|
3022 // CVtEngLocalVideo::DeleteProvider |
|
3023 // Deletes provider. |
|
3024 // ----------------------------------------------------------------------------- |
|
3025 // |
|
3026 void CVtEngLocalVideo::DeleteProvider( const TVtEngProviderType aType ) |
|
3027 { |
|
3028 TProviderItem dummy; |
|
3029 const TInt pos( GetProviderByType( aType, dummy ) ); |
|
3030 if ( pos >= 0 ) // valid index |
|
3031 { |
|
3032 TProviderItem& item = ( *iVideoProviders )[pos]; |
|
3033 DeleteProvider( item ); |
|
3034 } |
|
3035 } |
|
3036 |
|
3037 // ----------------------------------------------------------------------------- |
|
3038 // CVtEngLocalVideo::Reset |
|
3039 // Resets local video handler. |
|
3040 // ----------------------------------------------------------------------------- |
|
3041 // |
|
3042 void CVtEngLocalVideo::Reset() |
|
3043 { |
|
3044 __VTPRINTENTER( "LocVid.Reset" ) |
|
3045 |
|
3046 __VTPRINT( DEBUG_MEDIA, "LocVideo.Reset" ) |
|
3047 DeleteProvider( KVtEngProviderCam1 ); |
|
3048 DeleteProvider( KVtEngProviderCam2 ); |
|
3049 DeleteAudioSource(); |
|
3050 |
|
3051 ClearFlag( EFlagAudioMuted | |
|
3052 EFlagSignalSourceSelection | |
|
3053 EFlagInitialized | |
|
3054 EFlagVFEnabled | |
|
3055 EFlagFrozen ); |
|
3056 |
|
3057 __VTPRINT( DEBUG_MEDIA, "LocVideo.Reset clearing EFlagVFEnabled and other" ) |
|
3058 |
|
3059 StopViewFinder(); |
|
3060 __VTPRINTEXIT( "LocVid.Reset" ) |
|
3061 } |
|
3062 |
|
3063 // ----------------------------------------------------------------------------- |
|
3064 // CVtEngLocalVideo::SetDigitalZoomFactorL |
|
3065 // Sets video provider's digital zoom step. |
|
3066 // ----------------------------------------------------------------------------- |
|
3067 // |
|
3068 void CVtEngLocalVideo::SetDigitalZoomFactorL( TInt aDigitalZoomFactor ) |
|
3069 { |
|
3070 __VTPRINTENTER( "LocVid.SetDigitalZoomFactorL" ) |
|
3071 __VTPRINT2( DEBUG_MEDIA, "LocVideo.SetZoom %d", aDigitalZoomFactor ) |
|
3072 if ( !iActiveProvider || |
|
3073 !iActiveProvider->iProvider ) |
|
3074 { |
|
3075 User::Leave( KErrNotReady ); |
|
3076 } |
|
3077 CVSDataProvider* provider( iActiveProvider->iProvider ); |
|
3078 provider->SetDigitalZoomFactorL( aDigitalZoomFactor ); |
|
3079 iActiveProvider->iStoredZoomFactor = provider->DigitalZoomFactor(); |
|
3080 __VTPRINTEXIT( "LocVid.SetDigitalZoomFactorL" ) |
|
3081 } |
|
3082 |
|
3083 // ----------------------------------------------------------------------------- |
|
3084 // CVtEngLocalVideo::SetFlag |
|
3085 // ----------------------------------------------------------------------------- |
|
3086 // |
|
3087 void CVtEngLocalVideo::SetFlag( const TInt aFlag ) |
|
3088 { |
|
3089 iFlags |= aFlag; |
|
3090 } |
|
3091 |
|
3092 // ----------------------------------------------------------------------------- |
|
3093 // CVtEngLocalVideo::ClearFlag |
|
3094 // ----------------------------------------------------------------------------- |
|
3095 // |
|
3096 void CVtEngLocalVideo::ClearFlag( const TInt aFlag ) |
|
3097 { |
|
3098 iFlags &= ~aFlag; |
|
3099 } |
|
3100 |
|
3101 // ----------------------------------------------------------------------------- |
|
3102 // CVtEngLocalVideo::IsFlag |
|
3103 // ----------------------------------------------------------------------------- |
|
3104 // |
|
3105 TBool CVtEngLocalVideo::IsFlag( const TInt aFlag ) const |
|
3106 { |
|
3107 return ( ( iFlags & aFlag ) != 0 ); |
|
3108 } |
|
3109 |
|
3110 // ----------------------------------------------------------------------------- |
|
3111 // CVtEngLocalVideo::CalculateMajorDigitalZoomStepCount |
|
3112 // Utility function to calculate amount of major zoom steps. |
|
3113 // ----------------------------------------------------------------------------- |
|
3114 // |
|
3115 TInt CVtEngLocalVideo::CalculateMajorDigitalZoomStepCount( |
|
3116 CVSDataProvider* aProvider ) |
|
3117 { |
|
3118 TVSDataProviderInfo info; |
|
3119 aProvider->ProviderInfo( info ); |
|
3120 return CalculateMajorDigitalZoomStepCount( info ); |
|
3121 } |
|
3122 |
|
3123 // ----------------------------------------------------------------------------- |
|
3124 // CVtEngLocalVideo::CalculateMajorDigitalZoomStepCount |
|
3125 // Utility function to calculate amount of major zoom steps. |
|
3126 // ----------------------------------------------------------------------------- |
|
3127 // |
|
3128 TInt CVtEngLocalVideo::CalculateMajorDigitalZoomStepCount( |
|
3129 const TVSDataProviderInfo& aInfo ) const |
|
3130 { |
|
3131 TInt zStepCount( aInfo.iMaxDigitalZoom ? |
|
3132 aInfo.iMaxDigitalZoom + 1 : 0 ); |
|
3133 TInt maxZStepCount( KVtMaxZoomStep + 1 ); |
|
3134 return zStepCount > maxZStepCount ? maxZStepCount : zStepCount; |
|
3135 } |
|
3136 |
|
3137 // ----------------------------------------------------------------------------- |
|
3138 // CVtEngLocalVideo::TProviderItem::TProviderItem |
|
3139 // Constructor. |
|
3140 // ----------------------------------------------------------------------------- |
|
3141 // |
|
3142 CVtEngLocalVideo::TProviderItem::TProviderItem() : |
|
3143 iProvider( NULL ), |
|
3144 iType( KVtEngProviderUndefined ), |
|
3145 iInitialized( EFalse ), |
|
3146 iErrorCode( 0 ), |
|
3147 iProviderState( EUndefined ), |
|
3148 iStoredZoomFactor( 0 ), |
|
3149 iZFErr( KErrNone ), |
|
3150 iCamPrefs( NULL ), |
|
3151 iFirstTime( ETrue ) |
|
3152 { |
|
3153 __VTPRINTENTER( "LocVid.TProviderItem.ctor" ) |
|
3154 ResetStoredValues(); |
|
3155 __VTPRINTEXITR( "LocVid.TProviderItem.ctor $%x", TInt( this ) ) |
|
3156 } |
|
3157 |
|
3158 // ----------------------------------------------------------------------------- |
|
3159 // CVtEngLocalVideo::TProviderItem::~TProviderItem |
|
3160 // ----------------------------------------------------------------------------- |
|
3161 // |
|
3162 CVtEngLocalVideo::TProviderItem::~TProviderItem() |
|
3163 { |
|
3164 __VTPRINTENTER( "LocVid.TProviderItem.~" ) |
|
3165 DetachFromCameraPreferences(); |
|
3166 __VTPRINTEXITR( "LocVid.TProviderItem.~ $%x", TInt( this ) ) |
|
3167 } |
|
3168 |
|
3169 // ----------------------------------------------------------------------------- |
|
3170 // CVtEngLocalVideo::TProviderItem::ResetStoredValues |
|
3171 // Resets stored values. |
|
3172 // ----------------------------------------------------------------------------- |
|
3173 // |
|
3174 void CVtEngLocalVideo::TProviderItem::ResetStoredValues() |
|
3175 { |
|
3176 __VTPRINTENTER( "LocVid.ResetStoredValues" ) |
|
3177 DetachFromCameraPreferences(); |
|
3178 __VTPRINTEXIT( "LocVid.ResetStoredValues" ) |
|
3179 } |
|
3180 |
|
3181 // ----------------------------------------------------------------------------- |
|
3182 // CVtEngLocalVideo::TProviderItem::RestoreZoomFactor |
|
3183 // Tries to restore zoom factor. |
|
3184 // ----------------------------------------------------------------------------- |
|
3185 // |
|
3186 TInt CVtEngLocalVideo::TProviderItem::RestoreZoomFactor() |
|
3187 { |
|
3188 __VTPRINTENTER( "LocVid.RestoreZoomFactor" ) |
|
3189 TRAP( iZFErr, |
|
3190 { |
|
3191 if ( iProvider && !iZFErr ) |
|
3192 { |
|
3193 iProvider->SetDigitalZoomFactorL( iStoredZoomFactor ); |
|
3194 iStoredZoomFactor = iProvider->DigitalZoomFactor(); |
|
3195 __VTPRINT2( DEBUG_GEN, "LocVideo.RestoreZoomFactor ZF now = %d", |
|
3196 iStoredZoomFactor ) |
|
3197 } |
|
3198 } ); |
|
3199 __VTPRINTEXITR( "LocVid.RestoreZoomFactor %d", iZFErr ) |
|
3200 return iZFErr; |
|
3201 } |
|
3202 |
|
3203 // ----------------------------------------------------------------------------- |
|
3204 // CVtEngLocalVideo::TProviderItem::RestorePreferences |
|
3205 // Tries to restore preferences. |
|
3206 // ----------------------------------------------------------------------------- |
|
3207 // |
|
3208 TInt CVtEngLocalVideo::TProviderItem::RestorePreferences() |
|
3209 { |
|
3210 __VTPRINTENTER( "LocVid.RestorePreferences" ) |
|
3211 TRAPD( error, |
|
3212 { |
|
3213 if ( iCamPrefs && iProvider && !iFirstTime ) |
|
3214 { |
|
3215 if ( !iCtErr ) |
|
3216 { |
|
3217 iProvider->SetColorToneL( |
|
3218 CCamera::CCameraImageProcessing::TEffect( iColorTone ) ); |
|
3219 } |
|
3220 if ( !iWbErr ) |
|
3221 { |
|
3222 iProvider->SetWhiteBalanceL( |
|
3223 CCamera::TWhiteBalance( iWhiteBalance ) ); |
|
3224 } |
|
3225 if ( !iBrErr ) |
|
3226 { |
|
3227 iProvider->SetBrightnessL( iBrightness ); |
|
3228 } |
|
3229 if ( !iCrErr ) |
|
3230 { |
|
3231 iProvider->SetContrastL( iContrast ); |
|
3232 } |
|
3233 } |
|
3234 } ); |
|
3235 __VTPRINTEXITR( "LocVid.RestorePreferences %d", error ) |
|
3236 return error; |
|
3237 } |
|
3238 |
|
3239 // ----------------------------------------------------------------------------- |
|
3240 // CVtEngLocalVideo::TProviderItem::Attach |
|
3241 // ----------------------------------------------------------------------------- |
|
3242 // |
|
3243 void CVtEngLocalVideo::TProviderItem::Attach( MVtEngCameraPreferences& |
|
3244 aCamPrefs ) |
|
3245 { |
|
3246 __VTPRINTENTER( "LocVid.Attach" ) |
|
3247 iCamPrefs = &aCamPrefs; |
|
3248 if ( iFirstTime ) |
|
3249 { |
|
3250 iCtErr = iCamPrefs->GetColorTone( iColorTone ); |
|
3251 iWbErr = iCamPrefs->GetWhiteBalance( iWhiteBalance ); |
|
3252 iBrErr = iCamPrefs->GetBrightness( iBrightness ); |
|
3253 iCrErr = iCamPrefs->GetContrast( iContrast ); |
|
3254 iFirstTime = EFalse; |
|
3255 } |
|
3256 __VTPRINTEXITR( "LocVid.Attach $%x", TInt( iCamPrefs ) ) |
|
3257 } |
|
3258 |
|
3259 // ----------------------------------------------------------------------------- |
|
3260 // CVtEngLocalVideo::TProviderItem::ColorToneUpdated |
|
3261 // ----------------------------------------------------------------------------- |
|
3262 // |
|
3263 void CVtEngLocalVideo::TProviderItem::ColorToneUpdated( |
|
3264 MVtEngCameraPreferences::TColorTone aColorTone ) |
|
3265 { |
|
3266 __VTPRINTENTER( "LocVid.ColorToneUpdated" ) |
|
3267 iCtErr = KErrNone; |
|
3268 iColorTone = aColorTone; |
|
3269 __VTPRINTEXITR( "LocVid.ColorToneUpdated %d", aColorTone ) |
|
3270 } |
|
3271 |
|
3272 // ----------------------------------------------------------------------------- |
|
3273 // CVtEngLocalVideo::TProviderItem::WhiteBalanceUpdated |
|
3274 // ----------------------------------------------------------------------------- |
|
3275 // |
|
3276 void CVtEngLocalVideo::TProviderItem::WhiteBalanceUpdated( |
|
3277 MVtEngCameraPreferences::TWhiteBalance aWhiteBalance ) |
|
3278 { |
|
3279 __VTPRINTENTER( "LocVid.WhiteBalanceUpdated" ) |
|
3280 iWbErr = KErrNone; |
|
3281 iWhiteBalance = aWhiteBalance; |
|
3282 __VTPRINTEXITR( "LocVid.WhiteBalanceUpdated %d", aWhiteBalance ) |
|
3283 } |
|
3284 |
|
3285 // ----------------------------------------------------------------------------- |
|
3286 // CVtEngLocalVideo::TProviderItem::BrightnessUpdated |
|
3287 // ----------------------------------------------------------------------------- |
|
3288 // |
|
3289 void CVtEngLocalVideo::TProviderItem::BrightnessUpdated( TInt aBrightness ) |
|
3290 { |
|
3291 __VTPRINTENTER( "LocVid.BrightnessUpdated" ) |
|
3292 iBrErr = KErrNone; |
|
3293 iBrightness = aBrightness; |
|
3294 __VTPRINTEXITR( "LocVid.BrightnessUpdated %d", aBrightness ) |
|
3295 } |
|
3296 |
|
3297 // ----------------------------------------------------------------------------- |
|
3298 // CVtEngLocalVideo::TProviderItem::ContrastUpdated |
|
3299 // ----------------------------------------------------------------------------- |
|
3300 // |
|
3301 void CVtEngLocalVideo::TProviderItem::ContrastUpdated( TInt aContrast ) |
|
3302 { |
|
3303 __VTPRINTENTER( "LocVid.ContrastUpdated" ) |
|
3304 iCrErr = KErrNone; |
|
3305 iContrast = aContrast; |
|
3306 __VTPRINTEXITR( "LocVid.ContrastUpdated %d", aContrast ) |
|
3307 } |
|
3308 |
|
3309 // ----------------------------------------------------------------------------- |
|
3310 // CVtEngLocalVideo::TProviderItem::Detach |
|
3311 // ----------------------------------------------------------------------------- |
|
3312 // |
|
3313 void CVtEngLocalVideo::TProviderItem::Detach( MVtEngCameraPreferences& ) |
|
3314 { |
|
3315 __VTPRINTENTER( "LocVid.Detach" ) |
|
3316 iCamPrefs = NULL; |
|
3317 __VTPRINTEXIT( "LocVid.Detach" ) |
|
3318 } |
|
3319 |
|
3320 // ----------------------------------------------------------------------------- |
|
3321 // CVtEngLocalVideo::TProviderItem::DetachFromCameraPreferences |
|
3322 // ----------------------------------------------------------------------------- |
|
3323 // |
|
3324 void CVtEngLocalVideo::TProviderItem::DetachFromCameraPreferences() |
|
3325 { |
|
3326 __VTPRINTENTER( "LocVid.DetachFromCameraPreferences" ) |
|
3327 if ( iCamPrefs ) |
|
3328 { |
|
3329 static_cast< CVtEngCameraPreferences* >( iCamPrefs )->Detach( *this ); |
|
3330 iCamPrefs = NULL; |
|
3331 } |
|
3332 __VTPRINTEXIT( "LocVid.DetachFromCameraPreferences" ) |
|
3333 } |
|
3334 |
|
3335 // ----------------------------------------------------------------------------- |
|
3336 // CVtEngLocalVideo::CreateAudioSource |
|
3337 // Creates audio source. |
|
3338 // ----------------------------------------------------------------------------- |
|
3339 // |
|
3340 TInt CVtEngLocalVideo::CreateAudioSource() |
|
3341 { |
|
3342 __VTPRINTENTER( "LocVid.CreateAudioSource" ) |
|
3343 TInt err = KErrNone; |
|
3344 // Check if this really a target compilation |
|
3345 #if !defined( __WINS__ ) |
|
3346 iAudioSource = VTProtocolFactory::CreateAudioSource(); |
|
3347 if ( !iAudioSource ) |
|
3348 { |
|
3349 err = KErrNoMemory; |
|
3350 } |
|
3351 #endif // !(__WINS__) |
|
3352 __VTPRINTEXITR( "LocVid.CreateAudioSource %d", err ) |
|
3353 return err; |
|
3354 } |
|
3355 |
|
3356 // ----------------------------------------------------------------------------- |
|
3357 // CVtEngLocalVideo::DeleteAudioSource |
|
3358 // Deletes audio source. |
|
3359 // ----------------------------------------------------------------------------- |
|
3360 // |
|
3361 void CVtEngLocalVideo::DeleteAudioSource() |
|
3362 { |
|
3363 __VTPRINTENTER( "LocVid.DeleteAudioSource" ) |
|
3364 if( iAudioSource ) |
|
3365 { |
|
3366 VTProtocolFactory::DeletAudioSource(iAudioSource); |
|
3367 iAudioSource = NULL; |
|
3368 } |
|
3369 __VTPRINTEXIT( "LocVid.DeleteAudioSource" ) |
|
3370 } |
|
3371 |
|
3372 // ----------------------------------------------------------------------------- |
|
3373 // CVtEngLocalVideo::PauseVideoSending |
|
3374 // Pause video sending. |
|
3375 // ----------------------------------------------------------------------------- |
|
3376 // |
|
3377 void CVtEngLocalVideo::PauseVideoSending() |
|
3378 { |
|
3379 __VTPRINTENTER( "LocVid.PauseVideoSending" ) |
|
3380 if ( iSource ) |
|
3381 { |
|
3382 iSource->PauseSending(); |
|
3383 } |
|
3384 __VTPRINTEXIT( "LocVid.PauseVideoSending" ) |
|
3385 } |
|
3386 |
|
3387 // ----------------------------------------------------------------------------- |
|
3388 // CVtEngLocalVideo::ResumeVideoSending |
|
3389 // Resume video sending. |
|
3390 // ----------------------------------------------------------------------------- |
|
3391 // |
|
3392 void CVtEngLocalVideo::ResumeVideoSending() |
|
3393 { |
|
3394 __VTPRINTENTER( "LocVid.ResumeVideoSending" ) |
|
3395 if ( iSource ) |
|
3396 { |
|
3397 iSource->ResumeSending(); |
|
3398 } |
|
3399 __VTPRINTEXIT( "LocVid.ResumeVideoSending" ) |
|
3400 } |
|
3401 |
|
3402 // ----------------------------------------------------------------------------- |
|
3403 // CVtEngLocalVideo::ViewFinderStarted |
|
3404 // Is view finder started. |
|
3405 // ----------------------------------------------------------------------------- |
|
3406 // |
|
3407 TBool CVtEngLocalVideo::ViewFinderStarted() const |
|
3408 { |
|
3409 CVSDataProvider* provider = NULL; |
|
3410 if( iActiveProvider ) |
|
3411 { |
|
3412 provider = iActiveProvider->iProvider; |
|
3413 } |
|
3414 if ( !provider ) |
|
3415 { |
|
3416 return EFalse; |
|
3417 } |
|
3418 return provider->ViewFinderActive(); |
|
3419 } |
|
3420 |
|
3421 // ----------------------------------------------------------------------------- |
|
3422 // CVtEngLocalVideo::ViewFinderStarted |
|
3423 // Is view finder started. |
|
3424 // ----------------------------------------------------------------------------- |
|
3425 // |
|
3426 TBool CVtEngLocalVideo::IsFrozen() const |
|
3427 { |
|
3428 TBool result = IsFlag( EFlagFrozen ); |
|
3429 return result; |
|
3430 } |
|
3431 |
|
3432 // ----------------------------------------------------------------------------- |
|
3433 // CVtEngLocalVideo::ResetIndices |
|
3434 // Resets the provider info indices. |
|
3435 // ----------------------------------------------------------------------------- |
|
3436 // |
|
3437 void CVtEngLocalVideo::ResetIndices() |
|
3438 { |
|
3439 iProviderInfoIndexCam1 = KErrNotFound; |
|
3440 iProviderInfoIndexCam2 = KErrNotFound; |
|
3441 iProviderInfoIndexStill = KErrNotFound; |
|
3442 } |
|
3443 |
|
3444 // ----------------------------------------------------------------------------- |
|
3445 // CVtEngLocalVideo::SetCameraTracking |
|
3446 // Sets a listener for camera P & S data. |
|
3447 // ----------------------------------------------------------------------------- |
|
3448 // |
|
3449 TInt CVtEngLocalVideo::SetCameraTrackingL( TInt& aProviderIndex ) |
|
3450 { |
|
3451 __VTPRINTENTER( "LocVideo.SetCameraTracking" ) |
|
3452 iCameraListener = CVtEngPubSubsListener::NewL( KPSUidVTMediaConfiguration, |
|
3453 KPSPreferredCamera, this ); |
|
3454 |
|
3455 __VTPRINTEXIT( "LocVideo.SetCameraTracking" ) |
|
3456 return iCameraListener->Get( aProviderIndex ); |
|
3457 } |
|
3458 |
|
3459 // ----------------------------------------------------------------------------- |
|
3460 // CVtEngInitializer::HandleNotifyPSL |
|
3461 // Notification of changed port value. |
|
3462 // ----------------------------------------------------------------------------- |
|
3463 // |
|
3464 void CVtEngLocalVideo::HandleNotifyPSL( |
|
3465 const TUid /*aUid */, const TInt& /* aKey */, |
|
3466 const TRequestStatus& aStatus ) |
|
3467 { |
|
3468 __VTPRINTENTER( "LocVideo.handleNotifyPSL " ) |
|
3469 if ( aStatus.Int() == KErrNone ) |
|
3470 { |
|
3471 // Get the new camera value. |
|
3472 TInt cameraId( EPSPreferredCameraUnknown ); |
|
3473 iCameraListener->Get( cameraId ); |
|
3474 // No need to check error, since MapCameraInternally will return |
|
3475 // current camera, and no actions will be taken. |
|
3476 MVtEngMedia::TCameraId camId( MapCameraInternally( cameraId ) ); |
|
3477 |
|
3478 TVtEngProviderType providerType( KVtEngProviderUndefined ); |
|
3479 TInt result( KErrNone ); |
|
3480 switch( camId ) |
|
3481 { |
|
3482 case MVtEngMedia::EPrimaryCamera: |
|
3483 if( IsFlag( EFlagCamera1Available ) ) |
|
3484 { |
|
3485 providerType = KVtEngProviderCam1; |
|
3486 } |
|
3487 else |
|
3488 { |
|
3489 result = KErrNotFound; |
|
3490 } |
|
3491 break; |
|
3492 |
|
3493 case MVtEngMedia::ESecondaryCamera: |
|
3494 if( IsFlag( EFlagCamera2Available ) ) |
|
3495 { |
|
3496 providerType = KVtEngProviderCam2; |
|
3497 } |
|
3498 else |
|
3499 { |
|
3500 result = KErrNotFound; |
|
3501 } |
|
3502 break; |
|
3503 |
|
3504 default: |
|
3505 result = KErrNotSupported; |
|
3506 break; |
|
3507 } |
|
3508 |
|
3509 User::LeaveIfError( result ); |
|
3510 |
|
3511 // If we're sharing, then notify camera change to image sharer |
|
3512 if ( GetMediaSource() == MVtEngMedia::EMediaShare || |
|
3513 iShareImage->IsInitializingShare() ) |
|
3514 { |
|
3515 iShareImage->NotifyCameraChanged( providerType ); |
|
3516 } |
|
3517 // If current provider is camera |
|
3518 else if ( GetMediaSource() == MVtEngMedia::EMediaCamera ) |
|
3519 { |
|
3520 // If current camera is different than new |
|
3521 if ( iCurrentCamera != camId ) |
|
3522 { |
|
3523 // If VT is in the foreground and Provider is unfrozen |
|
3524 if ( IsFlag( EFlagUIForeground ) && !IsFrozen() && !iObserver.IsVideoChannelClosed() ) |
|
3525 { |
|
3526 // select camera.. |
|
3527 SelectSourceL( providerType ); |
|
3528 } |
|
3529 else |
|
3530 { |
|
3531 iObserver.SetSelectedCameraId( camId ); |
|
3532 // ..else notify delayed select |
|
3533 iLayoutChangeHandler.CancelHandleLayoutChange(); |
|
3534 iDelayedSelect.NotifyDelayedSelect( providerType ); |
|
3535 } |
|
3536 } |
|
3537 else |
|
3538 { |
|
3539 // else ignore |
|
3540 } |
|
3541 } |
|
3542 // Else store camera type and on next SelectSourceL() use this instead |
|
3543 else |
|
3544 { |
|
3545 iObserver.SetSelectedCameraId( camId ); |
|
3546 // If prepare camera has not been called, then just |
|
3547 // update preferred camera |
|
3548 if ( GetMediaSource()!= MVtEngMedia::EMediaNone && |
|
3549 ( IsPrepareCameraCalled() || iObserver.IsVideoChannelClosed() ) ) |
|
3550 { |
|
3551 iLayoutChangeHandler.CancelHandleLayoutChange(); |
|
3552 iDelayedSelect.NotifyDelayedSelect( providerType ); |
|
3553 } |
|
3554 else |
|
3555 { |
|
3556 iCurrentCamera = camId; |
|
3557 } |
|
3558 } |
|
3559 } |
|
3560 __VTPRINTEXIT( "LocVideo.HandleNotifyPSL" ) |
|
3561 } |
|
3562 |
|
3563 // ----------------------------------------------------------------------------- |
|
3564 // CVtEngLocalVideo::SetCurrentCameraId |
|
3565 // |
|
3566 // ----------------------------------------------------------------------------- |
|
3567 // |
|
3568 void CVtEngLocalVideo::SetCurrentCameraId( MVtEngMedia::TCameraId aCamId ) |
|
3569 { |
|
3570 __VTPRINTENTER( "LocVideo.SetCurrentCameraId" ) |
|
3571 iCurrentCamera = aCamId; |
|
3572 iObserver.SetSelectedCameraId( aCamId ); |
|
3573 __VTPRINTEXITR( "LocVideo.SetCurrentCameraId camId = %d", aCamId ) |
|
3574 } |
|
3575 |
|
3576 // ----------------------------------------------------------------------------- |
|
3577 // CVtEngLocalVideo::MapCameraInternally |
|
3578 // Maps camera id to internal data structures. |
|
3579 // ----------------------------------------------------------------------------- |
|
3580 // |
|
3581 MVtEngMedia::TCameraId CVtEngLocalVideo::MapCameraInternally( TInt aCameraId ) |
|
3582 { |
|
3583 __VTPRINT2( DEBUG_GEN, "LocVideo.MapCameraInternally cameraId=%d", |
|
3584 aCameraId ) |
|
3585 if ( aCameraId == EPSPreferredCameraInwards || |
|
3586 iNumSupportedCameras == 1 ) |
|
3587 { |
|
3588 return MVtEngMedia::EPrimaryCamera; |
|
3589 } |
|
3590 else if ( aCameraId == EPSPreferredCameraOutwards ) |
|
3591 { |
|
3592 return MVtEngMedia::ESecondaryCamera; |
|
3593 } |
|
3594 __VTPRINT2( DEBUG_GEN, "LocVideo.MapCameraInternally curCam=%d", iCurrentCamera ) |
|
3595 return iCurrentCamera; |
|
3596 } |
|
3597 |
|
3598 // ----------------------------------------------------------------------------- |
|
3599 // CVtEngLocalVideo::CameraAvailable |
|
3600 // Checks camera availabitility. |
|
3601 // ----------------------------------------------------------------------------- |
|
3602 // |
|
3603 void CVtEngLocalVideo:: |
|
3604 CameraAvailable( CVtEngLocalVideo::TVtEngProviderType &aType ) |
|
3605 { |
|
3606 __VTPRINT2( DEBUG_GEN, "LocVideo.CameraAvailable In.type=%d ", aType ) |
|
3607 if ( iCurrentCamera == MVtEngMedia::EPrimaryCamera ) |
|
3608 { |
|
3609 if ( IsFlag( EFlagCamera1Available ) ) |
|
3610 { |
|
3611 aType = KVtEngProviderCam1; |
|
3612 } |
|
3613 } |
|
3614 else if ( iCurrentCamera == MVtEngMedia::ESecondaryCamera ) |
|
3615 { |
|
3616 if ( IsFlag( EFlagCamera2Available ) ) |
|
3617 { |
|
3618 aType = KVtEngProviderCam2; |
|
3619 } |
|
3620 } |
|
3621 __VTPRINT2( DEBUG_GEN, "LocVideo.CameraAvailable Out.type=%d", aType ) |
|
3622 } |
|
3623 |
|
3624 // ----------------------------------------------------------------------------- |
|
3625 // CVtEngLocalVideo::IsProviderWaiting |
|
3626 // ----------------------------------------------------------------------------- |
|
3627 // |
|
3628 TBool CVtEngLocalVideo::IsProviderWaiting( TVtEngProviderType aType ) const |
|
3629 { |
|
3630 __VTPRINTENTER( "LocVid.IsProviderWaiting" ) |
|
3631 TBool isWaiting( EFalse ); |
|
3632 TInt indexWaiting( ProviderIndexByState( EWaiting ) ); |
|
3633 if ( indexWaiting != KErrNotFound ) |
|
3634 { |
|
3635 TProviderItem& item = ( *iVideoProviders )[ indexWaiting ]; |
|
3636 isWaiting = ( item.iType == aType ); |
|
3637 } |
|
3638 __VTPRINTEXITR( "LocVid.IsProviderWaiting %d", isWaiting ) |
|
3639 return isWaiting; |
|
3640 } |
|
3641 |
|
3642 // ----------------------------------------------------------------------------- |
|
3643 // CVtEngLocalVideo::GetHighestSelectableProvider |
|
3644 // ----------------------------------------------------------------------------- |
|
3645 // |
|
3646 TBool CVtEngLocalVideo::GetHighestSelectableProvider( |
|
3647 CVtEngLocalVideo::TVtEngProviderType& aPreferred ) const |
|
3648 { |
|
3649 __VTPRINTENTER( "LocVid.GetHighestSelectableProvider" ) |
|
3650 const TVtEngProviderType preferred = aPreferred; |
|
3651 switch ( preferred ) |
|
3652 { |
|
3653 case KVtEngProviderCam1: |
|
3654 if ( IsFlag( EFlagCamera1Available ) ) |
|
3655 { |
|
3656 // cam1 is selectable, jump out |
|
3657 break; |
|
3658 } |
|
3659 // othwerwise fall through to next in priority order |
|
3660 case KVtEngProviderCam2: |
|
3661 if ( IsFlag( EFlagCamera2Available ) && |
|
3662 // Do not allow change to another camera without user permission, |
|
3663 // i.e. test preferred was cam1 but it wasn't available. |
|
3664 preferred != KVtEngProviderCam1 ) |
|
3665 { |
|
3666 // cam2 is selectable |
|
3667 aPreferred = KVtEngProviderCam2; |
|
3668 break; |
|
3669 } |
|
3670 // othwerwise fall through to next in priority order |
|
3671 case KVtEngProviderImage: |
|
3672 if ( CVtEngUtility::Settings().Config().iVideo.iImageIsValid ) |
|
3673 { |
|
3674 aPreferred = KVtEngProviderImage; |
|
3675 break; |
|
3676 } |
|
3677 // othwerwise fall through to next in priority order |
|
3678 case KVtEngProviderNone: |
|
3679 default: |
|
3680 // always available |
|
3681 aPreferred = KVtEngProviderNone; |
|
3682 break; |
|
3683 } |
|
3684 __VTPRINTEXITR( "LocVid.GetHighestSelectableProvider %d", aPreferred ) |
|
3685 return ( preferred == aPreferred ); |
|
3686 } |
|
3687 |
|
3688 // Implementation of CVtEngLocalVideo::CVtEngShareImage |
|
3689 |
|
3690 // ----------------------------------------------------------------------------- |
|
3691 // CVtEngLocalVideo::CVtEngShareImage::NewL |
|
3692 // ----------------------------------------------------------------------------- |
|
3693 // |
|
3694 CVtEngLocalVideo::CVtEngShareImage* CVtEngLocalVideo::CVtEngShareImage::NewL( |
|
3695 CVtEngLocalVideo& aLocalVideo ) |
|
3696 { |
|
3697 CVtEngShareImage* self = new ( ELeave ) CVtEngShareImage( aLocalVideo ); |
|
3698 CleanupStack::PushL( self ); |
|
3699 self->ConstructL(); |
|
3700 CleanupStack::Pop(); // self |
|
3701 return self; |
|
3702 } |
|
3703 |
|
3704 // ----------------------------------------------------------------------------- |
|
3705 // CVtEngLocalVideo::CVtEngShareImage::~CVtEngShareImage |
|
3706 // ----------------------------------------------------------------------------- |
|
3707 // |
|
3708 CVtEngLocalVideo::CVtEngShareImage::~CVtEngShareImage() |
|
3709 { |
|
3710 DeleteProviders(); |
|
3711 iBuffered.ResetAndDestroy(); |
|
3712 } |
|
3713 |
|
3714 // ----------------------------------------------------------------------------- |
|
3715 // CVtEngLocalVideo::CVtEngShareImage::InitializeL |
|
3716 // ----------------------------------------------------------------------------- |
|
3717 // |
|
3718 void CVtEngLocalVideo::CVtEngShareImage::InitializeL( |
|
3719 const MVtEngMedia::TShareObjectImageParameters& aParameters, |
|
3720 TVtEngProviderType aCurrent, |
|
3721 TBool& aFirstTime ) |
|
3722 { |
|
3723 __VTPRINTENTER( "LocVid.ShareImage.InitializeL" ) |
|
3724 if ( IsInitializing() ) |
|
3725 { |
|
3726 // Already initializing. |
|
3727 User::Leave( KErrNotReady ); |
|
3728 } |
|
3729 |
|
3730 |
|
3731 CVtEngLocalVideo::TProviderItem* freeProviderItem = FetchProviderItem(); |
|
3732 if ( !freeProviderItem ) |
|
3733 { |
|
3734 User::Leave( KErrInUse ); |
|
3735 } |
|
3736 |
|
3737 iParameters = aParameters; |
|
3738 CreateProviderL( *freeProviderItem ); |
|
3739 InitializeProviderL( *freeProviderItem ); |
|
3740 |
|
3741 // Only set stored type when sharing is started, if resharing (i.e. sharing |
|
3742 // new image when already sharing other image), then don't change stored |
|
3743 // type. |
|
3744 if ( iStoredType == KVtEngProviderUndefined ) |
|
3745 { |
|
3746 iSettingsChanged = EFalse; |
|
3747 iOriginalStoredType = iStoredType = aCurrent; |
|
3748 aFirstTime = ETrue; |
|
3749 } |
|
3750 else |
|
3751 { |
|
3752 aFirstTime = EFalse; |
|
3753 } |
|
3754 iInitializingProvider = freeProviderItem; |
|
3755 SetState( EInitializing ); |
|
3756 __VTPRINTEXIT( "LocVid.ShareImage.InitializeL" ) |
|
3757 } |
|
3758 |
|
3759 // ----------------------------------------------------------------------------- |
|
3760 // CVtEngLocalVideo::CVtEngShareImage::ShareL |
|
3761 // ----------------------------------------------------------------------------- |
|
3762 // |
|
3763 void CVtEngLocalVideo::CVtEngShareImage::ShareL() |
|
3764 { |
|
3765 __VTPRINTENTER( "LocVid.ShareImage.ShareL" ) |
|
3766 if ( !IsInitializing() && iInitializingProvider ) |
|
3767 { |
|
3768 User::Leave( KErrNotReady ); |
|
3769 } |
|
3770 iActiveProvider = iInitializingProvider; |
|
3771 iInitializingProvider = NULL; |
|
3772 iLocalVideo->SwitchProvider( *iActiveProvider ); |
|
3773 SetState( ESharing ); |
|
3774 __VTPRINTEXIT( "LocVid.ShareImage.ShareL" ) |
|
3775 } |
|
3776 |
|
3777 // ----------------------------------------------------------------------------- |
|
3778 // CVtEngLocalVideo::CVtEngShareImage::StopL |
|
3779 // ----------------------------------------------------------------------------- |
|
3780 // |
|
3781 void CVtEngLocalVideo::CVtEngShareImage::StopL() |
|
3782 { |
|
3783 __VTPRINTENTER( "LocVid.ShareImage.StopL" ) |
|
3784 iLocalVideo->InitializeOnly( EFalse ); |
|
3785 |
|
3786 CVtEngLocalVideo::TVtEngProviderType target( StoredSource() ); |
|
3787 if ( iOriginalStoredType != target ) |
|
3788 { |
|
3789 TProviderItem* item = NULL; |
|
3790 if ( iLocalVideo->GetProviderByType( iOriginalStoredType, item ) |
|
3791 != KErrNotFound ) |
|
3792 { |
|
3793 if ( item->iProviderState != EPermanent ) |
|
3794 { |
|
3795 iLocalVideo->DeleteProvider( *item ); |
|
3796 } |
|
3797 } |
|
3798 } |
|
3799 |
|
3800 if ( iSettingsChanged ) |
|
3801 { |
|
3802 if ( target == KVtEngProviderDefaultStillImage ) |
|
3803 { |
|
3804 DeleteProvider( target ); |
|
3805 } |
|
3806 DeleteProvider( KVtEngProviderImage ); |
|
3807 } |
|
3808 |
|
3809 __VTPRINT2( DEBUG_MEDIA, "LocVid.ShareImage.StopL select %d", |
|
3810 target ) |
|
3811 iLocalVideo->SelectSourceL( target ); |
|
3812 |
|
3813 if ( iStoredType == KVtEngProviderCam1 || |
|
3814 iStoredType == KVtEngProviderCam2 ) |
|
3815 { |
|
3816 MVtEngMedia::TCameraId camId( |
|
3817 iStoredType == KVtEngProviderCam1 ? |
|
3818 MVtEngMedia::EPrimaryCamera : |
|
3819 MVtEngMedia::ESecondaryCamera ); |
|
3820 iLocalVideo->SetCurrentCameraId( camId ); |
|
3821 __VTPRINT2( DEBUG_MEDIA, "LocVid.ShareImage.StopL set camId %d", |
|
3822 camId ) |
|
3823 } |
|
3824 SetState( EStopped ); |
|
3825 __VTPRINTEXIT( "LocVid.ShareImage.StopL" ) |
|
3826 } |
|
3827 |
|
3828 // ----------------------------------------------------------------------------- |
|
3829 // CVtEngLocalVideo::CVtEngShareImage::Error |
|
3830 // ----------------------------------------------------------------------------- |
|
3831 // |
|
3832 void CVtEngLocalVideo::CVtEngShareImage::Error( TInt |
|
3833 #ifdef _DEBUG |
|
3834 aError |
|
3835 #endif // _DEBUG |
|
3836 ) |
|
3837 { |
|
3838 TState stateAfter( EStopped ); |
|
3839 __VTPRINTENTER( "LocVid.ShareImage.Error" ) |
|
3840 if ( IsInitializing() ) |
|
3841 { |
|
3842 iInitializingProvider = NULL; |
|
3843 stateAfter = iPreviousState; |
|
3844 } |
|
3845 else if ( iState == ESharing ) |
|
3846 { |
|
3847 if ( iLocalVideo->iObserver.GetPendingCommand() != KVtEngInitializeShareImage ) |
|
3848 { |
|
3849 CVtEngEventManager::NotifyEvent( KVtEngShareImageDecodingError ); |
|
3850 } |
|
3851 stateAfter = ESharing; |
|
3852 //iActiveProvider = NULL; |
|
3853 } |
|
3854 SetState( stateAfter ); |
|
3855 #ifdef _DEBUG |
|
3856 __VTPRINTEXITR( "LocVid.ShareImage.Error %d", aError ) |
|
3857 #endif // _DEBUG |
|
3858 } |
|
3859 |
|
3860 // ----------------------------------------------------------------------------- |
|
3861 // CVtEngLocalVideo::CVtEngShareImage::StoredSource |
|
3862 // |
|
3863 // Returns stored source for this share session. Stored source may have changed |
|
3864 // during share (e.g. when GS still image is being sent but during share |
|
3865 // GS still image is disabled => still image cannot be used anymore and thus |
|
3866 // None provider must be activated). All these conditions are checked by this |
|
3867 // method. |
|
3868 // ----------------------------------------------------------------------------- |
|
3869 // |
|
3870 CVtEngLocalVideo::TVtEngProviderType |
|
3871 CVtEngLocalVideo::CVtEngShareImage::StoredSource() const |
|
3872 { |
|
3873 __VTPRINTENTER( "LocVid.ShareImage.StoredSource" ) |
|
3874 CVtEngLocalVideo::TVtEngProviderType stored( iStoredType ); |
|
3875 |
|
3876 if ( iOriginalStoredType == KVtEngProviderNone || |
|
3877 iOriginalStoredType == KVtEngProviderImage || |
|
3878 iOriginalStoredType == KVtEngProviderDefaultStillImage ) |
|
3879 { |
|
3880 if ( CVtEngUtility::Settings().Config().iVideo.iImageIsValid ) |
|
3881 { |
|
3882 stored = KVtEngProviderImage; |
|
3883 } |
|
3884 else if ( CVtEngUtility::Settings().IsDefaultStillImageDefined() ) |
|
3885 { |
|
3886 stored = KVtEngProviderDefaultStillImage; |
|
3887 } |
|
3888 else |
|
3889 { |
|
3890 stored = KVtEngProviderNone; |
|
3891 } |
|
3892 } |
|
3893 __VTPRINTEXITR( "LocVid.ShareImage.StoredSource = %d", stored ) |
|
3894 return stored; |
|
3895 } |
|
3896 |
|
3897 // ----------------------------------------------------------------------------- |
|
3898 // CVtEngLocalVideo::CVtEngShareImage::CVtEngShareImage |
|
3899 // ----------------------------------------------------------------------------- |
|
3900 // |
|
3901 CVtEngLocalVideo::CVtEngShareImage::CVtEngShareImage( |
|
3902 CVtEngLocalVideo& aLocalVideo ) |
|
3903 : iLocalVideo( &aLocalVideo ), iState( EStopped ), |
|
3904 iStoredType( KVtEngProviderUndefined ), |
|
3905 iOriginalStoredType( KVtEngProviderUndefined ), |
|
3906 iBuffered( 2 ), iSettingsChanged( EFalse ) |
|
3907 { |
|
3908 } |
|
3909 |
|
3910 // ----------------------------------------------------------------------------- |
|
3911 // CVtEngLocalVideo::CVtEngShareImage::ConstructL |
|
3912 // ----------------------------------------------------------------------------- |
|
3913 // |
|
3914 void CVtEngLocalVideo::CVtEngShareImage::ConstructL() |
|
3915 { |
|
3916 __VTPRINTENTER( "LocVid.ShareImage.ConstructL" ) |
|
3917 for ( TInt i = 0; i < KVtEngNumProvidersBuffered; i++ ) |
|
3918 { |
|
3919 TProviderItem* item = new (ELeave) TProviderItem(); |
|
3920 CleanupStack::PushL( item ); |
|
3921 User::LeaveIfError( iBuffered.Append( item ) ); |
|
3922 CleanupStack::Pop(); // item |
|
3923 } |
|
3924 __VTPRINTEXIT( "LocVid.ShareImage.ConstructL" ) |
|
3925 } |
|
3926 |
|
3927 // ----------------------------------------------------------------------------- |
|
3928 // CVtEngLocalVideo::CVtEngShareImage::Parameters |
|
3929 // ----------------------------------------------------------------------------- |
|
3930 // |
|
3931 const MVtEngMedia::TShareObjectImageParameters& |
|
3932 CVtEngLocalVideo::CVtEngShareImage::Parameters() const |
|
3933 { |
|
3934 __VTPRINTENTER( "LocVid.ShareImage.Parameters" ) |
|
3935 __VTPRINTEXIT( "LocVid.ShareImage.Parameters" ) |
|
3936 return iParameters; |
|
3937 } |
|
3938 |
|
3939 // ----------------------------------------------------------------------------- |
|
3940 // CVtEngLocalVideo::CVtEngShareImage::IsInitializing |
|
3941 // ----------------------------------------------------------------------------- |
|
3942 // |
|
3943 TBool CVtEngLocalVideo::CVtEngShareImage::IsInitializing() const |
|
3944 { |
|
3945 TBool isInitializing( iState == EInitializing ); |
|
3946 __VTPRINTENTER( "LocVid.ShareImage.IsInitializing" ) |
|
3947 __VTPRINTEXITR( "LocVid.ShareImage.IsInitializing %d", isInitializing ) |
|
3948 return isInitializing; |
|
3949 } |
|
3950 |
|
3951 // ----------------------------------------------------------------------------- |
|
3952 // CVtEngLocalVideo::CVtEngShareImage::SetState |
|
3953 // ----------------------------------------------------------------------------- |
|
3954 // |
|
3955 void CVtEngLocalVideo::CVtEngShareImage::SetState( const TState aNewState ) |
|
3956 { |
|
3957 __VTPRINTENTER( "LocVid.ShareImage.SetState" ) |
|
3958 // Signal UI when entering or leaving initializing state |
|
3959 if ( aNewState == EInitializing ) |
|
3960 { |
|
3961 CVtEngEventManager::NotifyEvent( KVtEngShareImageInitializeBegin ); |
|
3962 } |
|
3963 else if ( iState == EInitializing ) |
|
3964 { |
|
3965 CVtEngEventManager::NotifyEvent( KVtEngShareImageInitializeEnd ); |
|
3966 } |
|
3967 // Reset stored type when stopping |
|
3968 if( aNewState == EStopped ) |
|
3969 { |
|
3970 iOriginalStoredType = iStoredType = KVtEngProviderUndefined; |
|
3971 iSettingsChanged = EFalse; |
|
3972 } |
|
3973 iPreviousState = iState; |
|
3974 iState = aNewState; |
|
3975 __VTPRINTEXITR( "LocVid.ShareImage.SetState iState = %d", iState ) |
|
3976 } |
|
3977 |
|
3978 // ----------------------------------------------------------------------------- |
|
3979 // CVtEngLocalVideo::CVtEngShareImage::GetProviderItemL |
|
3980 // ----------------------------------------------------------------------------- |
|
3981 // |
|
3982 CVtEngLocalVideo::TProviderItem* |
|
3983 CVtEngLocalVideo::CVtEngShareImage::FetchProviderItem() const |
|
3984 { |
|
3985 __VTPRINTENTER( "LocVid.ShareImage.FetchProviderItem" ) |
|
3986 for( TInt i = 0; i < iBuffered.Count(); i++ ) |
|
3987 { |
|
3988 if( ( iBuffered[ i ] != iActiveProvider ) && |
|
3989 ( iBuffered[ i ] != iInitializingProvider ) ) |
|
3990 { |
|
3991 __VTPRINTEXIT( "LocVid.ShareImage.FetchProviderItem" ) |
|
3992 return iBuffered[ i ]; |
|
3993 } |
|
3994 } |
|
3995 __VTPRINTEXIT( "LocVid.ShareImage.FetchProviderItem" ) |
|
3996 return NULL; |
|
3997 } |
|
3998 |
|
3999 // ----------------------------------------------------------------------------- |
|
4000 // CVtEngLocalVideo::CVtEngShareImage::CreateProviderL |
|
4001 // ----------------------------------------------------------------------------- |
|
4002 void CVtEngLocalVideo::CVtEngShareImage::CreateProviderL( |
|
4003 TProviderItem& aProviderItem ) |
|
4004 { |
|
4005 __VTPRINTENTER( "LocVid.ShareImage.CreateProviderL" ) |
|
4006 iLocalVideo->ReCreateProviderL( aProviderItem, KVtEngProviderShareImage ); |
|
4007 __VTPRINTEXIT( "LocVid.ShareImage.CreateProviderL" ) |
|
4008 } |
|
4009 |
|
4010 // ----------------------------------------------------------------------------- |
|
4011 // CVtEngLocalVideo::CVtEngShareImage::InitializeProviderL |
|
4012 // ----------------------------------------------------------------------------- |
|
4013 // |
|
4014 void CVtEngLocalVideo::CVtEngShareImage::InitializeProviderL( |
|
4015 TProviderItem& aProviderItem ) |
|
4016 { |
|
4017 __VTPRINTENTER( "LocVid.ShareImage.InitializeProviderL" ) |
|
4018 if( IsInitializing() ) |
|
4019 { |
|
4020 User::Leave( KErrNotReady ); |
|
4021 } |
|
4022 TPckgBuf< TVSStillImageDataProviderParams > pckg( Parameters() ); |
|
4023 #ifdef _DEBUG |
|
4024 RDebug::Print( _L( "LocVid.ShareImage.InitializeProviderL: %S" ), |
|
4025 &( pckg().iFileName ) ); |
|
4026 #endif // _DEBUG |
|
4027 iLocalVideo->InitializeShareProviderL( aProviderItem, pckg ); |
|
4028 __VTPRINTEXIT( "LocVid.ShareImage.InitializeProviderL" ) |
|
4029 } |
|
4030 |
|
4031 // ----------------------------------------------------------------------------- |
|
4032 // CVtEngLocalVideo::CVtEngShareImage::DeleteProvider |
|
4033 // ----------------------------------------------------------------------------- |
|
4034 // |
|
4035 void CVtEngLocalVideo::CVtEngShareImage::DeleteProvider( |
|
4036 TVtEngProviderType aProviderType ) |
|
4037 { |
|
4038 __VTPRINTENTER( "LocVid.ShareImage.DeleteProvider" ) |
|
4039 TProviderItem* pItem; |
|
4040 if ( iLocalVideo->GetProviderByType( aProviderType, pItem ) |
|
4041 != KErrNotFound ) |
|
4042 { |
|
4043 iLocalVideo->DeleteProvider( *pItem ); |
|
4044 } |
|
4045 __VTPRINTEXIT( "LocVid.ShareImage.DeleteProvider" ) |
|
4046 } |
|
4047 |
|
4048 // ----------------------------------------------------------------------------- |
|
4049 // CVtEngLocalVideo::CVtEngShareImage::GetObjectSharingState |
|
4050 // ----------------------------------------------------------------------------- |
|
4051 // |
|
4052 void CVtEngLocalVideo::CVtEngShareImage::GetObjectSharingState( |
|
4053 MVtEngMedia::TShareObjectState& aObjectSharingState ) const |
|
4054 { |
|
4055 __VTPRINTENTER( "LocVid.ShareImage.GetObjectSharingState" ) |
|
4056 switch ( iState ) |
|
4057 { |
|
4058 case EStopped: |
|
4059 aObjectSharingState = MVtEngMedia::ENotSharing; |
|
4060 break; |
|
4061 |
|
4062 case EInitializing: |
|
4063 aObjectSharingState = MVtEngMedia::EInitializingShareImage; |
|
4064 break; |
|
4065 |
|
4066 case ESharing: |
|
4067 aObjectSharingState = MVtEngMedia::ESharingImage; |
|
4068 break; |
|
4069 |
|
4070 default: |
|
4071 aObjectSharingState = MVtEngMedia::ENotAbleToShare; |
|
4072 break; |
|
4073 } |
|
4074 __VTPRINTEXIT( "LocVid.ShareImage.GetObjectSharingState" ) |
|
4075 } |
|
4076 |
|
4077 // ----------------------------------------------------------------------------- |
|
4078 // CVtEngLocalVideo::CVtEngShareImage::IsInitializingShare |
|
4079 // ----------------------------------------------------------------------------- |
|
4080 // |
|
4081 TBool CVtEngLocalVideo::CVtEngShareImage::IsInitializingShare() const |
|
4082 { |
|
4083 __VTPRINTENTER( "LocVid.ShareImage.IsInitializingShare" ) |
|
4084 const TBool result( iState == EInitializing ); |
|
4085 __VTPRINTEXITR( "LocVid.ShareImage.IsInitializingShare %d", result ) |
|
4086 return result; |
|
4087 } |
|
4088 |
|
4089 // ----------------------------------------------------------------------------- |
|
4090 // CVtEngLocalVideo::CVtEngShareImage::SettingsChanged |
|
4091 // ----------------------------------------------------------------------------- |
|
4092 // |
|
4093 void CVtEngLocalVideo::CVtEngShareImage::SettingsChanged() |
|
4094 { |
|
4095 __VTPRINTENTER( "LocVid.ShareImage.SettingsChanged" ) |
|
4096 iSettingsChanged = ETrue; |
|
4097 __VTPRINTEXIT( "LocVid.ShareImage.SettingsChanged" ) |
|
4098 } |
|
4099 |
|
4100 // ----------------------------------------------------------------------------- |
|
4101 // CVtEngLocalVideo::CVtEngShareImage::ProviderSwitchDone |
|
4102 // ----------------------------------------------------------------------------- |
|
4103 // |
|
4104 void CVtEngLocalVideo::CVtEngShareImage::ProviderSwitchDone( |
|
4105 CVSDataProvider* aOldProvider ) |
|
4106 { |
|
4107 __VTPRINTENTER( "LocVid.ShareImage.ProviderSwitchDone" ) |
|
4108 //if ( iState == EStopped ) |
|
4109 { |
|
4110 for ( TInt i = iBuffered.Count() - 1; i >= 0; i-- ) |
|
4111 { |
|
4112 if ( iBuffered[ i ]->iProvider == aOldProvider ) |
|
4113 { |
|
4114 iLocalVideo->DeleteProvider( *iBuffered[ i ] ); |
|
4115 break; |
|
4116 } |
|
4117 } |
|
4118 } |
|
4119 __VTPRINTEXIT( "LocVid.ShareImage.ProviderSwitchDone" ) |
|
4120 } |
|
4121 |
|
4122 // ----------------------------------------------------------------------------- |
|
4123 // CVtEngLocalVideo::CVtEngShareImage::NotifyCameraChanged |
|
4124 // ----------------------------------------------------------------------------- |
|
4125 // |
|
4126 void CVtEngLocalVideo::CVtEngShareImage::NotifyCameraChanged( |
|
4127 const TVtEngProviderType& aProviderType ) |
|
4128 { |
|
4129 __VTPRINTENTER( "LocVid.ShareImage.NotifyCameraChanged" ) |
|
4130 if ( ( iState == EInitializing ) || ( iState == ESharing ) ) |
|
4131 { |
|
4132 iStoredType = aProviderType; |
|
4133 } |
|
4134 __VTPRINTEXIT( "LocVid.ShareImage.NotifyCameraChanged" ) |
|
4135 } |
|
4136 |
|
4137 // ----------------------------------------------------------------------------- |
|
4138 // CVtEngLocalVideo::CVtEngShareImage::DeleteProviders |
|
4139 // ----------------------------------------------------------------------------- |
|
4140 // |
|
4141 void CVtEngLocalVideo::CVtEngShareImage::DeleteProviders() |
|
4142 { |
|
4143 __VTPRINTENTER( "LocVid.ShareImage.DeleteProviders" ) |
|
4144 for ( TInt i = 0; i < iBuffered.Count(); i++ ) |
|
4145 { |
|
4146 iLocalVideo->DeleteProvider( *iBuffered[ i ] ); |
|
4147 } |
|
4148 __VTPRINTEXIT( "LocVid.ShareImage.DeleteProviders" ) |
|
4149 } |
|
4150 |
|
4151 |
|
4152 // ----------------------------------------------------------------------------- |
|
4153 // CVtEngLocalVideo::CVtEngShareImage::CancelInitialize |
|
4154 // ----------------------------------------------------------------------------- |
|
4155 // |
|
4156 void CVtEngLocalVideo::CVtEngShareImage::CancelInitialize() |
|
4157 { |
|
4158 __VTPRINTENTER( "CVtEngLocalVideo.CVtEngShareImage.CancelInitialize"); |
|
4159 if( iInitializingProvider ) |
|
4160 { |
|
4161 if(iInitializingProvider->iProvider) |
|
4162 { |
|
4163 __VTPRINT( DEBUG_MEDIA,"iInitializingProvider->iProvider->CancelInitializing()"); |
|
4164 iInitializingProvider->iProvider->CancelInitializing(); |
|
4165 } |
|
4166 } |
|
4167 __VTPRINTEXIT( "CVtEngLocalVideo.CVtEngShareImage.CancelInitialize"); |
|
4168 } |
|
4169 // Implementation of CVtEngLocalVideo::TVtEngDelayedSelect |
|
4170 |
|
4171 // ----------------------------------------------------------------------------- |
|
4172 // CVtEngLocalVideo::TVtEngDelayedSelect::TVtEngDelayedSelect |
|
4173 // ----------------------------------------------------------------------------- |
|
4174 // |
|
4175 CVtEngLocalVideo::TVtEngDelayedSelect::TVtEngDelayedSelect() |
|
4176 : iDelayedProviderType( KVtEngProviderUndefined ) |
|
4177 { |
|
4178 } |
|
4179 |
|
4180 // ----------------------------------------------------------------------------- |
|
4181 // CVtEngLocalVideo::TVtEngDelayedSelect::NotifyDelayedSelect |
|
4182 // ----------------------------------------------------------------------------- |
|
4183 // |
|
4184 void CVtEngLocalVideo::TVtEngDelayedSelect::NotifyDelayedSelect( |
|
4185 const TVtEngProviderType& aProviderType ) |
|
4186 { |
|
4187 __VTPRINTENTER( "LocVid.DelSel.NotifyDelayedSelect" ) |
|
4188 iDelayedProviderType = aProviderType; |
|
4189 __VTPRINTEXIT( "LocVid.DelSel.NotifyDelayedSelect" ) |
|
4190 } |
|
4191 |
|
4192 // ----------------------------------------------------------------------------- |
|
4193 // CVtEngLocalVideo::TVtEngDelayedSelect::IsDelayedSelectPending |
|
4194 // ----------------------------------------------------------------------------- |
|
4195 // |
|
4196 TBool CVtEngLocalVideo::TVtEngDelayedSelect::IsDelayedSelectPending() const |
|
4197 { |
|
4198 __VTPRINTENTER( "LocVid.DelSel.IsDelayedSelectPending" ) |
|
4199 const TBool result( iDelayedProviderType != KVtEngProviderUndefined ); |
|
4200 __VTPRINTEXITR( "LocVid.DelSel.IsDelayedSelectPending %d", result ) |
|
4201 return result; |
|
4202 } |
|
4203 |
|
4204 // ----------------------------------------------------------------------------- |
|
4205 // CVtEngLocalVideo::TVtEngDelayedSelect::DelayedSelectTarget |
|
4206 // ----------------------------------------------------------------------------- |
|
4207 // |
|
4208 CVtEngLocalVideo::TVtEngProviderType |
|
4209 CVtEngLocalVideo::TVtEngDelayedSelect::DelayedSelectTarget() |
|
4210 { |
|
4211 __VTPRINTENTER( "LocVid.DelSel.DelayedSelectTarget" ) |
|
4212 TVtEngProviderType current( iDelayedProviderType ); |
|
4213 iDelayedProviderType = KVtEngProviderUndefined; |
|
4214 __VTPRINTEXITR( "LocVid.DelSel.DelayedSelectTarget %d", current ) |
|
4215 return current; |
|
4216 } |
|
4217 |
|
4218 // Implementation of CVtEngLocalVideo::TVtEngLayoutChangeHandler |
|
4219 |
|
4220 // ----------------------------------------------------------------------------- |
|
4221 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::TVtEngLayoutChangeHandler |
|
4222 // ----------------------------------------------------------------------------- |
|
4223 // |
|
4224 CVtEngLocalVideo::TVtEngLayoutChangeHandler::TVtEngLayoutChangeHandler( |
|
4225 CVtEngLocalVideo& aLocalVideo ) |
|
4226 : iLocalVideo( &aLocalVideo ), iState( EIdle ), |
|
4227 iStored( KVtEngProviderUndefined ) |
|
4228 { |
|
4229 __VTPRINTEXIT( "LocVid.LayoutCH.Ctor" ) |
|
4230 __VTPRINTEXIT( "LocVid.LayoutCH.Ctor" ) |
|
4231 } |
|
4232 |
|
4233 // ----------------------------------------------------------------------------- |
|
4234 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::UnfreezeL |
|
4235 // ----------------------------------------------------------------------------- |
|
4236 // |
|
4237 TBool CVtEngLocalVideo::TVtEngLayoutChangeHandler::UnfreezeL() |
|
4238 { |
|
4239 TBool result( EFalse ); |
|
4240 __VTPRINTENTER( "LocVid.LayoutCH.UnfreezeL" ) |
|
4241 if ( iState == ELayoutChangePending ) |
|
4242 { |
|
4243 result = ETrue; |
|
4244 DoHandleLayoutChangeL(); |
|
4245 } |
|
4246 __VTPRINTEXITR( "LocVid.LayoutCH.UnfreezeL %d", result ) |
|
4247 return result; |
|
4248 } |
|
4249 |
|
4250 // ----------------------------------------------------------------------------- |
|
4251 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::HandleLayoutChangeL |
|
4252 // ----------------------------------------------------------------------------- |
|
4253 // |
|
4254 void CVtEngLocalVideo::TVtEngLayoutChangeHandler::HandleLayoutChangeL() |
|
4255 { |
|
4256 __VTPRINTENTER( "LocVid.LayoutCH.HandleLayoutChangeL" ) |
|
4257 TInt error( KErrNone ); |
|
4258 if ( iState != EIdle ) |
|
4259 { |
|
4260 if ( iState == ELayoutChangePending ) |
|
4261 { |
|
4262 __VTPRINT( DEBUG_MEDIA, |
|
4263 "LocVid.LayoutCH.HandleLayoutChangeL PENDING" ) |
|
4264 } |
|
4265 else |
|
4266 { |
|
4267 __VTPRINT( DEBUG_MEDIA, |
|
4268 "LocVid.LayoutCH.HandleLayoutChangeL NOT ready" ) |
|
4269 error = KErrNotReady; |
|
4270 } |
|
4271 CompleteOperation( error ); |
|
4272 } |
|
4273 else |
|
4274 { |
|
4275 // Only do reinitialize if camera is active source |
|
4276 if ( iLocalVideo->GetMediaSource() == MVtEngMedia::EMediaCamera && |
|
4277 !iLocalVideo->IsDelayedSelectPending() ) |
|
4278 { |
|
4279 if ( !iLocalVideo->IsFrozen() ) |
|
4280 { |
|
4281 __VTPRINT( DEBUG_MEDIA, |
|
4282 "LocVid.LayoutCH.HandleLayoutChangeL camera active, reinitialize" ) |
|
4283 DoHandleLayoutChangeL(); |
|
4284 } |
|
4285 else |
|
4286 { |
|
4287 iState = ELayoutChangePending; |
|
4288 __VTPRINT( DEBUG_MEDIA, |
|
4289 "LocVid.LayoutCH.HandleLayoutChangeL flag set, frozen" ) |
|
4290 CompleteOperation( error ); |
|
4291 } |
|
4292 } |
|
4293 else |
|
4294 { |
|
4295 __VTPRINT( DEBUG_MEDIA, |
|
4296 "LocVid.LayoutCH.HandleLayoutChangeL no op, camera is not active" ) |
|
4297 CompleteL( error ); |
|
4298 } |
|
4299 } |
|
4300 __VTPRINTEXITR( "LocVid.LayoutCH.HandleLayoutChangeL %d", error ) |
|
4301 } |
|
4302 |
|
4303 // ----------------------------------------------------------------------------- |
|
4304 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::CancelHandleLayoutChange |
|
4305 // ----------------------------------------------------------------------------- |
|
4306 // |
|
4307 void CVtEngLocalVideo::TVtEngLayoutChangeHandler::CancelHandleLayoutChange() |
|
4308 { |
|
4309 __VTPRINTENTER( "LocVid.LayoutCH.CancelHandleLayoutChange" ) |
|
4310 if ( iState == ELayoutChangePending ) |
|
4311 { |
|
4312 iState = EIdle; |
|
4313 } |
|
4314 __VTPRINTEXITR( "LocVid.LayoutCH.CancelHandleLayoutChange iState = %d", |
|
4315 iState ) |
|
4316 } |
|
4317 |
|
4318 // ----------------------------------------------------------------------------- |
|
4319 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::DoHandleLayoutChangeL |
|
4320 // ----------------------------------------------------------------------------- |
|
4321 // |
|
4322 void CVtEngLocalVideo::TVtEngLayoutChangeHandler::DoHandleLayoutChangeL() |
|
4323 { |
|
4324 __VTPRINTENTER( "LocVid.LayoutCH.DoHandleLayoutChangeL" ) |
|
4325 iStored = iLocalVideo->ActiveProvider(); |
|
4326 iState = ESwitchingBlank; |
|
4327 TVtEngProviderType providerType( KVtEngProviderNone ); |
|
4328 // Use user defined image, if available |
|
4329 if ( CVtEngUtility::Settings().IsDefaultStillImageDefined() ) |
|
4330 { |
|
4331 providerType = KVtEngProviderDefaultStillImage; |
|
4332 } |
|
4333 iLocalVideo->SelectSourceL( providerType ); |
|
4334 __VTPRINTEXIT( "LocVid.LayoutCH.DoHandleLayoutChangeL" ) |
|
4335 } |
|
4336 |
|
4337 // ----------------------------------------------------------------------------- |
|
4338 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::Complete |
|
4339 // ----------------------------------------------------------------------------- |
|
4340 // |
|
4341 TInt CVtEngLocalVideo::TVtEngLayoutChangeHandler::Complete( const TInt aError ) |
|
4342 { |
|
4343 __VTPRINTENTER( "LocVid.LayoutCH.Complete" ) |
|
4344 TRAPD( error, CompleteL( aError ) ); |
|
4345 __VTPRINTEXITR( "LocVid.LayoutCH.Complete %d", error ) |
|
4346 return error; |
|
4347 } |
|
4348 |
|
4349 // ----------------------------------------------------------------------------- |
|
4350 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::CompleteL |
|
4351 // Resets internal state and completes asynchronous operation. |
|
4352 // ----------------------------------------------------------------------------- |
|
4353 // |
|
4354 void CVtEngLocalVideo::TVtEngLayoutChangeHandler::CompleteL( const TInt aError ) |
|
4355 { |
|
4356 __VTPRINTENTER( "LocVid.LayoutCH.CompleteL" ) |
|
4357 iStored = KVtEngProviderUndefined; |
|
4358 iState = EIdle; |
|
4359 CompleteOperation( aError ); |
|
4360 __VTPRINTEXIT( "LocVid.LayoutCH.CompleteL" ) |
|
4361 } |
|
4362 |
|
4363 // ----------------------------------------------------------------------------- |
|
4364 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::CompleteOperation |
|
4365 // Completes asynchronous operation. |
|
4366 // ----------------------------------------------------------------------------- |
|
4367 // |
|
4368 void CVtEngLocalVideo::TVtEngLayoutChangeHandler::CompleteOperation( |
|
4369 const TInt aError ) |
|
4370 { |
|
4371 __VTPRINTENTER( "LocVid.LayoutCH.CompleteOperation" ) |
|
4372 iLocalVideo->CompleteOperation( aError ); |
|
4373 __VTPRINTEXIT( "LocVid.LayoutCH.CompleteOperation" ) |
|
4374 } |
|
4375 |
|
4376 // ----------------------------------------------------------------------------- |
|
4377 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::ProviderError |
|
4378 // ----------------------------------------------------------------------------- |
|
4379 // |
|
4380 TBool CVtEngLocalVideo::TVtEngLayoutChangeHandler::ProviderError( TInt aError ) |
|
4381 { |
|
4382 TBool handled( EFalse ); |
|
4383 __VTPRINTENTER( "LocVid.LayoutCH.ProviderError" ) |
|
4384 if ( iState != EIdle && iState != ELayoutChangePending ) |
|
4385 { |
|
4386 handled = ETrue; |
|
4387 Complete( aError ); |
|
4388 } |
|
4389 __VTPRINTEXITR( "LocVid.LayoutCH.ProviderError %d", handled ) |
|
4390 return handled; |
|
4391 } |
|
4392 |
|
4393 // ----------------------------------------------------------------------------- |
|
4394 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::ProviderReady |
|
4395 // ----------------------------------------------------------------------------- |
|
4396 // |
|
4397 TBool CVtEngLocalVideo::TVtEngLayoutChangeHandler::ProviderReady() |
|
4398 { |
|
4399 TBool handled( EFalse ); |
|
4400 __VTPRINTENTER( "LocVid.LayoutCH.ProviderReady" ) |
|
4401 switch ( iState ) |
|
4402 { |
|
4403 case ESwitchingCamera: |
|
4404 case EIdle: |
|
4405 break; |
|
4406 |
|
4407 case EInitializingCamera: |
|
4408 handled = ETrue; |
|
4409 iState = ESwitchingCamera; |
|
4410 TRAPD( error, iLocalVideo->SelectSourceL( iStored ) ); |
|
4411 if ( error ) |
|
4412 { |
|
4413 Complete( error ); |
|
4414 } |
|
4415 break; |
|
4416 |
|
4417 case ESwitchingBlank: |
|
4418 handled = ETrue; |
|
4419 break; |
|
4420 } |
|
4421 __VTPRINTEXITR( "LocVid.LayoutCH.ProviderReady %d", handled ) |
|
4422 return handled; |
|
4423 } |
|
4424 |
|
4425 // ----------------------------------------------------------------------------- |
|
4426 // CVtEngLocalVideo::TVtEngLayoutChangeHandler::ProviderSwitchDone |
|
4427 // ----------------------------------------------------------------------------- |
|
4428 // |
|
4429 TBool CVtEngLocalVideo::TVtEngLayoutChangeHandler::ProviderSwitchDone( |
|
4430 CVSDataProvider* aOldProvider ) |
|
4431 { |
|
4432 TBool handled( EFalse ); |
|
4433 __VTPRINTENTER( "LocVid.LayoutCH.ProviderSwitchDone" ) |
|
4434 switch ( iState ) |
|
4435 { |
|
4436 case EIdle: |
|
4437 // nothing to do |
|
4438 break; |
|
4439 |
|
4440 case ESwitchingBlank: |
|
4441 { |
|
4442 __VTPRINT( DEBUG_MEDIA, |
|
4443 "LocVid.LayoutCH.ProviderSwitchDone ESwitchingBlank" ) |
|
4444 handled = ETrue; |
|
4445 iState = EInitializingCamera; |
|
4446 TProviderItem* providerItem; |
|
4447 const TInt result( |
|
4448 iLocalVideo->GetProviderByInstance( aOldProvider, providerItem ) ); |
|
4449 if ( result != KErrNotFound ) |
|
4450 { |
|
4451 iLocalVideo->DeleteProvider( *providerItem ); |
|
4452 iLocalVideo->iCameraPref->SetProvider( NULL, |
|
4453 *iLocalVideo->iActiveProvider ); |
|
4454 |
|
4455 __VTPRINT( DEBUG_MEDIA, |
|
4456 "LocVid.LayoutCH.ProviderSwitchDone initializing provider" ) |
|
4457 |
|
4458 TRAPD( error, iLocalVideo->InitializeProviderL( *providerItem ) ); |
|
4459 |
|
4460 if ( error ) |
|
4461 { |
|
4462 __VTPRINT2( DEBUG_MEDIA, |
|
4463 "LocVid.LayoutCH.ProviderSwitchDone ERROR %d in initialize", |
|
4464 error ) |
|
4465 Complete( error ); |
|
4466 } |
|
4467 } |
|
4468 else |
|
4469 { |
|
4470 __VTPRINT( DEBUG_MEDIA, |
|
4471 "LocVid.LayoutCH.ProviderSwitchDone provider NOT found" ) |
|
4472 Complete( result ); |
|
4473 } |
|
4474 } |
|
4475 break; |
|
4476 |
|
4477 case EInitializingCamera: |
|
4478 handled = ETrue; |
|
4479 break; |
|
4480 |
|
4481 case ESwitchingCamera: |
|
4482 __VTPRINT( DEBUG_MEDIA, |
|
4483 "LocVid.LayoutCH.ProviderSwitchDone ESwitchingCamera" ) |
|
4484 TRAP_IGNORE( iLocalVideo->StartViewFinderIfWasStartedL() ); |
|
4485 //Re-Set provider to camera preference. Otherwise, after layout change, the provider in camera preference will be invalid |
|
4486 iLocalVideo->iCameraPref->SetProvider( iLocalVideo->iActiveProvider->iProvider, |
|
4487 *iLocalVideo->iActiveProvider ); |
|
4488 handled = ETrue; |
|
4489 __VTPRINT( DEBUG_MEDIA, |
|
4490 "LocVid.LayoutCH.ProviderSwitchDone reinit done" ) |
|
4491 Complete( KErrNone ); |
|
4492 break; |
|
4493 } |
|
4494 __VTPRINTEXITR( "LocVid.LayoutCH.ProviderSwitchDone %d", handled ) |
|
4495 return handled; |
|
4496 } |
|
4497 |
|
4498 // ----------------------------------------------------------------------------- |
|
4499 // CVtEngLocalVideo::CreateCameraPreferencesL |
|
4500 // ----------------------------------------------------------------------------- |
|
4501 // |
|
4502 CVtEngCameraPreferences* CVtEngLocalVideo::CreateCameraPreferencesL() |
|
4503 { |
|
4504 __VTPRINTENTER( "LocVid.CreateCameraPreferencesL" ) |
|
4505 iCameraPref = CVtEngCameraPreferences::NewL(); |
|
4506 |
|
4507 // Check if provider exist and set it |
|
4508 // as provider to camera preferences |
|
4509 if ( iActiveProvider ) |
|
4510 { |
|
4511 __VTPRINT( DEBUG_MEDIA, |
|
4512 "LocVideo.CreateCameraPreferencesL SetProvider" ) |
|
4513 iCameraPref->SetProvider( iActiveProvider->iProvider, |
|
4514 *iActiveProvider ); |
|
4515 } |
|
4516 |
|
4517 __VTPRINTEXIT( "LocVid.CreateCameraPreferencesL" ) |
|
4518 return iCameraPref; |
|
4519 } |
|
4520 |
|
4521 // ----------------------------------------------------------------------------- |
|
4522 // CVtEngLocalVideo::CancelInitializeShareImage |
|
4523 // ----------------------------------------------------------------------------- |
|
4524 // |
|
4525 void CVtEngLocalVideo::CancelInitializeShareImage() |
|
4526 { |
|
4527 __VTPRINTENTER( "CVtEngLocalVideo.CancelInitializeShareImage"); |
|
4528 iShareImage->CancelInitialize(); |
|
4529 __VTPRINTEXIT( "CVtEngLocalVideo.CancelInitializeShareImage"); |
|
4530 } |
|
4531 |
|
4532 // End of File |