diff -r 000000000000 -r 5f000ab63145 phoneuis/BubbleManager/Src/BMCallObjectManager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phoneuis/BubbleManager/Src/BMCallObjectManager.cpp Mon Jan 18 20:18:27 2010 +0200 @@ -0,0 +1,648 @@ +/* +* Copyright (c) 2002-2006 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Call object loading. +* +*/ + + + +// INCLUDE FILES +#include +#include +#include "BMCallObjectManager.h" +#include "BMUtils.h" +#include "BMCallObjectUtils.h" +#include "BMPanic.h" +#include "BMMediaReaderFactory.h" +#include "BMMediaReaderInterface.h" +#include "BMBubbleImageManager.h" + +// CONSTANTS + +// MACROS + +// LOCAL CONSTANTS AND MACROS +const TInt KBMBubbleIdNone = -2; +const TInt KBMCallTextAlphaValue = 128; + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CBubbleCallObjectManager::CBubbleCallObjectManager +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CBubbleCallObjectManager::CBubbleCallObjectManager( + CBubbleManager& aBubbleManager ) : iBubbleManager( aBubbleManager ) + { + } + +// ----------------------------------------------------------------------------- +// CBubbleCallObjectManager::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::ConstructL() + { + iIdleProcessor = CIdle::NewL( CActive::EPriorityIdle ); + iLoadingState = EBMLoaderReady; + iBubbleId = KBMBubbleIdNone; + } + +// ----------------------------------------------------------------------------- +// CBubbleCallObjectManager::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CBubbleCallObjectManager* CBubbleCallObjectManager::NewL( + CBubbleManager& aBubbleManager ) + { + CBubbleCallObjectManager* self = + new( ELeave ) CBubbleCallObjectManager( aBubbleManager ); + + CleanupStack::PushL( self ); + self->ConstructL( ); + CleanupStack::Pop( self ); + + return self; + } + +// Destructor +CBubbleCallObjectManager::~CBubbleCallObjectManager() + { + Reset(); + + if ( iIdleProcessor ) + { + iIdleProcessor->Cancel(); + delete iIdleProcessor; + } + + delete iCallThemeImageIcon; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::Reset +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::Reset() + { + iLoadingState = EBMLoaderReady; + iBubbleId = KBMBubbleIdNone; + delete iMediaReader; + iMediaReader = NULL; + delete iCallText; + iCallText = NULL; + delete iCallImage; + iCallImage = NULL; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::LoadImageFromFile +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::LoadImageFromFile( + const CBubbleManager::TBubbleId& aBubbleId, + const TDesC& aFileName, + const TImageLoadingParams& aParams ) + { + if ( !aFileName.Length() ) + { + return; + } + + if ( iLoadingState == EBMSuspended ) + { + delete iCallImage; + iCallImage = aFileName.Alloc(); + iImageLoadParams = aParams; + iBubbleId = aBubbleId; + return; // wait for resume + } + + // queueing not supported, keep the existing + if ( iLoadingState == EBMLoaderReady ) + { + TRAPD( err, ReadFromFileL( aFileName, + aParams.iPreferredSize, + aParams.iTinyImageSize ) ); + if ( err == KErrNone ) + { + iLoadingState = EBMLoadingImage; + delete iCallImage; + iCallImage = aFileName.Alloc(); + iImageLoadParams = aParams; + iBubbleId = aBubbleId; + } + } + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::ReadFromFileL +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::ReadFromFileL( + const TDesC& aFileName, + const TSize& aPreferredImageSize, + const TSize& aTinyImageSize ) + { + delete iMediaReader; + iMediaReader = NULL; + iMediaReader = BubbleMediaReaderFactory::CreateReaderL( aFileName ); + + TSize sourceSize( iMediaReader->SourceSize() ); + + TReal scaleFactor; + TRect clipRect; + TSize targetSize; + if ( BubbleCallObjectUtils::GetScaleFactorAndClipRect( + sourceSize, + aPreferredImageSize, + BubbleCallObjectUtils::EFillTarget, + scaleFactor, + clipRect ) && + aTinyImageSize != TSize(0,0) ) + { + // Tiny image + BubbleCallObjectUtils::GetScaleFactorAndClipRect( + sourceSize, + aTinyImageSize, + BubbleCallObjectUtils::EMaximumFit, + scaleFactor, + clipRect ); + + targetSize = aTinyImageSize; + } + else + { + targetSize = aPreferredImageSize; + } + + iMediaReader->StartReadingL( targetSize, + scaleFactor, + clipRect, + this ); + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::LoadImageFromText +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::LoadImageFromText( + const CBubbleManager::TBubbleId& aBubbleId, + const TDesC& aText, + const TImageLoadingParams& aParams ) + { + if ( !aText.Length() ) + { + return; + } + + if ( iLoadingState == EBMSuspended ) + { + delete iCallText; + iCallText = aText.Alloc(); + iImageLoadParams = aParams; + iBubbleId = aBubbleId; + return; // wait for resume + } + + // queueing not supported, keep the existing + if ( iLoadingState == EBMLoaderReady ) + { + delete iCallText; + iCallText = aText.Alloc(); + iBubbleId = aBubbleId; + iImageLoadParams = aParams; + TCallBack idleCallback( IdleProcessorCallback, this ); + iIdleProcessor->Cancel(); + iIdleProcessor->Start( idleCallback ); + iLoadingState = EBMLoadingText; + } + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::CancelCallObjectLoading +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::CancelCallObjectLoading( + const CBubbleManager::TBubbleId& aBubbleId ) + { + if ( iLoadingState != EBMLoaderReady && + iBubbleId == aBubbleId ) + { + Reset(); + iIdleProcessor->Cancel(); + } + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::Suspend +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::Suspend() + { + if ( iLoadingState != EBMLoaderReady ) + { + // Cancel image/text reading + delete iMediaReader; + iMediaReader = NULL; + iIdleProcessor->Cancel(); + } + + // Set suspended state + iLoadingState = EBMSuspended; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::Resume +// +// --------------------------------------------------------------------------- +// +TInt CBubbleCallObjectManager::Resume() + { + TInt err = KErrNone; + + if ( iLoadingState == EBMSuspended ) + { + TRAP( err, DoResumeL() ); + } + + return err; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::DoResumeL +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::DoResumeL() + { + if ( iCallImage ) + { + CBubbleManager::TPhoneCallState callState = + iBubbleManager.CallState( iBubbleId ); + + if ( callState < CBubbleManager::EIncoming && + iImageLoadParams.iThumbnailSize != TSize(0,0) ) + { + // switch to incall image size + iImageLoadParams.iPreferredSize = + iImageLoadParams.iThumbnailSize; + iImageLoadParams.iThumbnailSize = TSize(0,0); + iImageLoadParams.iTinyImageSize = TSize(0,0); + } + + ReadFromFileL( *iCallImage, + iImageLoadParams.iPreferredSize, + iImageLoadParams.iTinyImageSize ); + + iLoadingState = EBMLoadingImage; + delete iCallImage; + iCallImage = NULL; + } + else if ( iCallText ) + { + TCallBack idleCallback( IdleProcessorCallback, this ); + iIdleProcessor->Cancel(); + iIdleProcessor->Start( idleCallback ); + iLoadingState = EBMLoadingText; + } + else + { + Reset(); + } + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::LoadCallThemeImage +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::LoadCallThemeImage( + CBubbleImageManager& aImageManager, + const TSize& aSize ) + { + delete iCallThemeImageIcon; + iCallThemeImageIcon = NULL; + + TRAPD( err, AllocateCallThemeImageIconL( aImageManager ) ); + if ( !err ) + { + iCallThemeImageSize = aSize; + + if ( iLoadingState == EBMLoaderReady ) + { + TCallBack idleCallback( IdleProcessorCallback, this ); + iIdleProcessor->Cancel(); + iIdleProcessor->Start( idleCallback ); + iLoadingState = EBMInitializingIcon; + } + } + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::AllocateCallThemeImageIconL +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::AllocateCallThemeImageIconL( + CBubbleImageManager& aImageManager ) + { + CEikImage* themeImage = new( ELeave ) CEikImage; + CleanupStack::PushL( themeImage ); + aImageManager.SetBitmapToImage( themeImage, + EQgn_graf_call_image_1, + EQgn_graf_call_image_1_mask ); + + if ( themeImage->Bitmap() ) + { + iCallThemeImageIcon = CGulIcon::NewL( + const_cast (themeImage->Bitmap()), + const_cast (themeImage->Mask())); + } + themeImage->SetPictureOwnedExternally( ETrue ); + CleanupStack::PopAndDestroy( themeImage ); + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::ReleaseCallThemeImage +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::ReleaseCallThemeImage() + { + delete iCallThemeImageIcon; + iCallThemeImageIcon = NULL; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::ResizeCallThemeImage +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::ResizeCallThemeImage( const TSize& aSize ) + { + iCallThemeImageSize = aSize; + AknIconUtils::SetSize( iCallThemeImageIcon->Bitmap(), + iCallThemeImageSize, + EAspectRatioPreservedSlice ); + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::CallThemeImageIcon +// +// --------------------------------------------------------------------------- +// +CGulIcon* CBubbleCallObjectManager::CallThemeImageIcon() + { + return iCallThemeImageIcon; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::IdleProcessorCallback +// +// --------------------------------------------------------------------------- +// +TInt CBubbleCallObjectManager::IdleProcessorCallback( TAny* aThis ) + { + __ASSERT_ALWAYS( aThis, + Panic( EBMPanicCallObjectManager ) ); + + CBubbleCallObjectManager* self = + static_cast( aThis ); + + TLoadingState state = self->iLoadingState; + + if ( state == EBMLoadingText ) + { + TRAP_IGNORE( self->DoLoadImageInIdleL() ); + } + else if ( state == EBMInitializingIcon ) + { + self->DoInitializeIcons(); + } + else if ( state == EBMDeleting ) + { + self->DoDeleteReaderInIdle(); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::DoLoadImageInIdleL +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::DoLoadImageInIdleL() + { + if ( iLoadingState == EBMLoadingText && iCallText ) + { + AknIconConfig::TPreferredDisplayMode mode; + AknIconConfig::PreferredDisplayMode( mode, + AknIconConfig::EImageTypeIcon); + + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + TRgb skinColor; + User::LeaveIfError( AknsUtils::GetCachedColor( + skin, + skinColor, + KAknsIIDQsnTextColors, + EAknsCIQsnTextColorsCG51 ) ); + + CFbsBitmap* bitmap = NULL; + CFbsBitmap* mask = NULL; + + BubbleCallObjectUtils::CreateImageBitmapsFromTextLC( + *iCallText, + iBubbleManager.Rect(), + iImageLoadParams.iPreferredSize, + skinColor, // text color + KBMCallTextAlphaValue, // semitransparent + mode.iBitmapMode, + bitmap, + mask ); + CleanupStack::Pop(2); // bitmap, mask + + iBubbleManager.StartChanges(); + iBubbleManager.SetCallObjectImage( iBubbleId, + bitmap, + mask, + ETrue ); + iBubbleManager.EndChanges(); + + delete iCallText; + iCallText = NULL; + } + + iLoadingState = EBMLoaderReady; + iBubbleId = KBMBubbleIdNone; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::DoDeleteReaderInIdle +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::DoDeleteReaderInIdle() + { + Reset(); + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::DoInitializeIcons +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::DoInitializeIcons() + { + AknIconUtils::ExcludeFromCache( iCallThemeImageIcon->Bitmap() ); + AknIconUtils::SetSize( iCallThemeImageIcon->Bitmap(), + iCallThemeImageSize, + EAspectRatioPreservedSlice ); + iLoadingState = EBMLoaderReady; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::FrameBufferDataChanged +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::FrameBufferDataChanged() + { + TRAPD( err, DoHandleFrameBufferDataL() ); + + if ( err != KErrNone ) + { + TCallBack idleCallback( IdleProcessorCallback, this ); + iIdleProcessor->Cancel(); + iIdleProcessor->Start( idleCallback ); + iLoadingState = EBMDeleting; + } + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::SetCallObjectImageL +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::DoHandleFrameBufferDataL() + { + const CFbsBitmap* bitmap = iMediaReader->FrameBuffer(); + const CFbsBitmap* mask = iMediaReader->Mask(); + + if ( bitmap ) + { + CBubbleManager::TPhoneCallState callState = + iBubbleManager.CallState( iBubbleId ); + + // copy the current frame + CFbsBitmap* d_bitmap = new( ELeave ) CFbsBitmap; + CleanupStack::PushL( d_bitmap ); + User::LeaveIfError( d_bitmap->Duplicate( bitmap->Handle() ) ); + + CFbsBitmap* d_mask = NULL; + if ( mask ) + { + d_mask = new( ELeave ) CFbsBitmap; + CleanupStack::PushL( d_mask ); + User::LeaveIfError( d_mask->Duplicate( mask->Handle() ) ); + CleanupStack::Pop( d_mask ); + } + CleanupStack::Pop( d_bitmap ); + + // assign the copy to call header. + if ( ( iLoadingState == EBMLoadingThumbnail ) && + ( callState > CBubbleManager::EActive ) ) + { + // displaying fullscreen image, set as thumbnail + iBubbleManager.SetThumbnail( iBubbleId, + d_bitmap, + d_mask, + ETrue ); // Ownership transfer + } + else + { + iBubbleManager.StartChanges(); + iBubbleManager.SetCallObjectImage( iBubbleId, + d_bitmap, + d_mask, + ETrue ); // Ownership transfer + iBubbleManager.EndChanges(); + } + + } + + // Delete media reader + iBubbleId = KBMBubbleIdNone; + TCallBack idleCallback( IdleProcessorCallback, this ); + iIdleProcessor->Cancel(); + iIdleProcessor->Start( idleCallback ); + iLoadingState = EBMDeleting; + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::LoadThumbnailVersion +// +// --------------------------------------------------------------------------- +// +TBool CBubbleCallObjectManager::LoadThumbnailVersion() + { + TSize sourceSize( iMediaReader->SourceSize() ); + TReal scaleFactor; + TRect clipRect; + TBool isTiny = BubbleCallObjectUtils::GetScaleFactorAndClipRect( + sourceSize, + iImageLoadParams.iThumbnailSize, + BubbleCallObjectUtils::EFillTarget, + scaleFactor, + clipRect ); + + if ( !isTiny ) + { + // scale image to thumbnail version + iMediaReader->SetScaleAndClip( iImageLoadParams.iThumbnailSize, + scaleFactor, + clipRect ); + return ETrue; + } + else + { + // image is smaller than thumnail size + return EFalse; + } + } + +// --------------------------------------------------------------------------- +// CBubbleCallObjectManager::ReaderError +// +// --------------------------------------------------------------------------- +// +void CBubbleCallObjectManager::ReaderError( TInt /*aError*/ ) + { + TCallBack idleCallback( IdleProcessorCallback, this ); + iIdleProcessor->Cancel(); + iIdleProcessor->Start( idleCallback ); + iLoadingState = EBMDeleting; + } + +// End of File