/*

* Copyright (c) 2002-2008 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:  Handles incall status bubble drawing.

*

*/

// SYSTEM INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefmacros.h>

#endif

#include    <eikimage.h>

#include    <eikenv.h>

#include    <barsread.h>            // Resource reader

#include    <bautils.h>             // erase

#include    <avkon.rsg>

#include    <AknsUtils.h>

#include    <AknsDrawUtils.h>

#include    <aknlayoutscalable_apps.cdl.h>

#include    <layoutmetadata.cdl.h>

#include    <AknIconUtils.h>

#include    <featmgr.h>

#include    <akniconconfig.h>

#include    <coeaui.h>

#include    <coemain.h>

#include    <coreapplicationuisdomainpskeys.h> // KCoreAppUIsAutolockStatus

#include <AknTasHook.h>

// USER INCLUDE FILES

#include    "AknIncallStatusBubble.h"

#include    "AknBitmapAnimation.h"  // Animation definition

#include    "AknUtils.h"

#include    "aknappui.h"

#include    "AknDef.h"

#include    "aknconsts.h"

#include    "AknStatuspaneUtils.h"

// CONSTANTS

// There does not seem to be any way to query WSERV wheter TRANSPARENCY option has been

// defined. We use this constant to decide which way we do things.

// const TBool KTransparentWindowsUsed = EFalse;  // Disabled at the moment for performance reasons.

const TUid KPhoneAppUid      = { 0x100058B3 };

const TUid KPhoneViewUid     = { 0x10282D81 };

const TUid KPhoneVievCommand = { 0x2 }; // forces call handling to foreground

const TUid KVideoCallUid     = { 0x101F8681 }; 

// Note that some icons are masked and some are non-masked.

enum // Grouped by icon layout...

    {

    // Layout1

    EIndexCallstatusQgn_indi_call_active = 0,

    EIndexCallstatusQgn_indi_call_active_mask,

    EIndexCallstatusQgn_indi_call_active_2,

    EIndexCallstatusQgn_indi_call_active_2_mask,

    EIndexCallstatusQgn_indi_call_active_cyph_off,

    EIndexCallstatusQgn_indi_call_active_cyph_off_mask,

    EIndexCallstatusQgn_indi_call_disconn,

    EIndexCallstatusQgn_indi_call_disconn_mask,

    EIndexCallstatusQgn_indi_call_disconn_cyph_off,

    EIndexCallstatusQgn_indi_call_disconn_cyph_off_mask,

    EIndexCallstatusQgn_indi_call_held,

    EIndexCallstatusQgn_indi_call_held_mask,

    EIndexCallstatusQgn_indi_call_held_cyph_off,

    EIndexCallstatusQgn_indi_call_held_cyph_off_mask,

    EIndexCallstatusQgn_indi_call_muted_callsta,

    EIndexCallstatusQgn_indi_call_muted_callsta_mask,

    EIndexCallstatusQgn_indi_call_video_callsta,

    EIndexCallstatusQgn_indi_call_video_callsta_mask,

    EIndexCallstatusQgn_indi_call_video_callsta_1,

    EIndexCallstatusQgn_indi_call_video_callsta_1_mask,

    EIndexCallstatusQgn_indi_call_video_callsta_2,

    EIndexCallstatusQgn_indi_call_video_callsta_2_mask,

    EIndexCallstatusQgn_indi_call_active_emergency,

    EIndexCallstatusQgn_indi_call_active_emergency_mask,

    EIndexCallstatusQgn_indi_call_video_1,

    EIndexCallstatusQgn_indi_call_video_1_mask,

    EIndexCallstatusQgn_indi_call_video_disconn,

    EIndexCallstatusQgn_indi_call_video_disconn_mask,

    EIndexCallStatusQgn_indi_call_voip_active,

    EIndexCallStatusQgn_indi_call_voip_active_mask,

    EIndexCallStatusQgn_indi_call_voip_active_2,

    EIndexCallStatusQgn_indi_call_voip_active_2_mask,

    EIndexCallStatusQgn_indi_call_voip_disconn,

    EIndexCallStatusQgn_indi_call_voip_disconn_mask,

    EIndexCallStatusQgn_indi_call_voip_held,

    EIndexCallStatusQgn_indi_call_voip_held_mask,

    ELayout1End = EIndexCallStatusQgn_indi_call_voip_held_mask,

    // Layout2

    EIndexCallstatusQgn_graf_bubble_incall,

    EIndexCallstatusQgn_graf_bubble_incall_mask,

    EIndexCallstatusQgn_graf_bubble_incall_disconn,

    EIndexCallstatusQgn_graf_bubble_incall_disconn_mask,

    ELayout2End = EIndexCallstatusQgn_graf_bubble_incall_disconn_mask,

    // Layout3

    EIndexCallstatusQgn_indi_call_cyphering_off,

    EIndexCallstatusQgn_indi_call_cyphering_off_mask, // not used, but AknIconUtils & SVG needs this to exist

    //ELayout3End = EIndexCallstatusQgn_indi_call_cyphering_off,

    ELayout3End = EIndexCallstatusQgn_indi_call_cyphering_off_mask,

    // Layout4

    EIndexCallstatusQgn_indi_call_data,

    EIndexCallstatusQgn_indi_call_data_mask, // not used, but AknIconUtils & SVG needs this to exist

    EIndexCallstatusQgn_indi_call_data_hscsd,

    EIndexCallstatusQgn_indi_call_data_hscsd_mask, // not used, but AknIconUtils & SVG needs this to exist

    EIndexCallstatusQgn_indi_call_fax,

    EIndexCallstatusQgn_indi_call_fax_mask, // not used, but AknIconUtils & SVG needs this to exist

    //ELayout4End = EIndexCallstatusQgn_indi_call_fax,

    ELayout4End = EIndexCallstatusQgn_indi_call_fax_mask,

    // Layout5

    EIndexCallstatusQgn_indi_call_line2,

    EIndexCallstatusQgn_indi_call_line2_mask, // not used, but AknIconUtils & SVG needs this to exist

    //ELayout5End = EIndexCallstatusQgn_indi_call_line2

    ELayout5End = EIndexCallstatusQgn_indi_call_line2_mask

    };

// Cleanup stack helper.

NONSHARABLE_CLASS( CCleanupGuard ) : public CBase

    {

    public:

        inline CCleanupGuard() {}

        ~CCleanupGuard();

    public:

        inline void SetItem1( CBase* aItem ) {iItem1 = aItem;}

        inline void SetItem2( CBase* aItem ) {iItem2 = aItem;}

    private:

        CBase* iItem1;

        CBase* iItem2;

    };

CCleanupGuard::~CCleanupGuard()

    {

    delete iItem1;

    delete iItem2;

    }

// ==== CIncallAnim  CLASS ======================

/**

* Helper class for animation control

*/

NONSHARABLE_CLASS( CIncallAnim ) : public CCoeControl

    {

    public:

    enum

        {

        EDefaultCallAnim,

        EVoipCallAnim,

        EVideoCallAnim

        };

    public:

        void ConstructL( CIncallStatusBubble& aImages );

        ~CIncallAnim();

        void MakeVisible( TBool aVisible );

        void ClearAnimation();

        void SetAnimationL( CIncallStatusBubble& aImages,

                            TInt aCallAnimType = EDefaultCallAnim );

        void SetAnimationType( TInt aCallAnimType );

        void CreateBackGroundImageL( const CFbsBitmap* aBubbleBitmap,

                                     const CFbsBitmap* aBubbleMask,

                                     TRect aBubbleRect );

    private:

        void UpdateAnimationL( CIncallStatusBubble& aImages,

                               TInt aCallAnimType = EDefaultCallAnim );

        void SizeChanged();

        void Draw( const TRect& aRect ) const;

    private:

        CAknBitmapAnimation* iIndiAnim;

        CAknBitmapAnimation* iIndiVoIPAnim;

        CAknBitmapAnimation* iIndiVideoAnim;

        CFbsBitmap* iAnimBackGroundImage;

        mutable TBool iIsRunning;

        mutable TBool iIsVoIPRunning;

        mutable TBool iIsVideoRunning;

        TInt iCallAnimType;

    };

// Constructor

void CIncallAnim::ConstructL( CIncallStatusBubble& aImages )

    {

    iCallAnimType = EDefaultCallAnim;

    iAnimBackGroundImage = new ( ELeave ) CFbsBitmap();

    SetAnimationL( aImages );

    ActivateL();

    CCoeControl::MakeVisible( EFalse );

    }

// Destructor

CIncallAnim::~CIncallAnim()

    {

    delete iIndiAnim;

    delete iIndiVoIPAnim;

    delete iIndiVideoAnim;

    delete iAnimBackGroundImage;

    }

void CIncallAnim::CreateBackGroundImageL(const CFbsBitmap* aBubbleBitmap, const CFbsBitmap* aBubbleMask, TRect aBubbleRect)

    {

    if (iAnimBackGroundImage && aBubbleBitmap && aBubbleMask)

        {

        CFbsBitmapDevice* destinationDevice = CFbsBitmapDevice::NewL(iAnimBackGroundImage);

        CleanupStack::PushL(destinationDevice);

        CFbsBitGc* destinationGc;

        User::LeaveIfError( destinationDevice->CreateContext( destinationGc ) );

        TRect rect = Rect();

        rect.Move(-aBubbleRect.iTl);

        destinationGc->BitBltMasked(TPoint(0,0), aBubbleBitmap, rect, aBubbleMask, ETrue);

        delete destinationGc;

        CleanupStack::PopAndDestroy(destinationDevice);

        }

    }

// Position/Size changed

void CIncallAnim::SizeChanged()

    {

    TRect rect( Rect() );

    if ( !iIndiAnim || !iIndiVoIPAnim || !iIndiVideoAnim )

        {

        return;

        }

    if ( Rect().IsEmpty() )

        return;

    if ( ( rect.Size() != iIndiAnim->Size() ) ||

         ( rect.Size() != iIndiVoIPAnim->Size() ) ||

         ( rect.Size() != iIndiVideoAnim->Size() ))

        {

        AknIconConfig::TPreferredDisplayMode mode;

        AknIconConfig::PreferredDisplayMode(mode, AknIconConfig::EImageTypeOffscreen);

        iAnimBackGroundImage->Create(

            Size(),

            mode.iBitmapMode);

        }

    iIndiAnim->SetRect( rect );

    iIndiVoIPAnim->SetRect( rect );

    iIndiVideoAnim->SetRect( rect );

    }

// Draws the animation

void CIncallAnim::Draw( const TRect& /*aRect*/ ) const

    {

    CAknBitmapAnimation* ok = NULL;

    switch (iCallAnimType)

        {

        case EDefaultCallAnim:

            ok = iIndiAnim;

            break;

        case EVoipCallAnim:

            ok = iIndiAnim;

            break;

        case EVideoCallAnim:

            ok = iIndiAnim;

            break;

        default:

            ok = NULL;

            break;

        }

    if ( !ok )

        {

        return;

        }

    // Background is no more copied from screen because it does not work very well.

    // Instead we use the image that has been set.

    if (iAnimBackGroundImage)

        {

        // Create frame for background

        CBitmapFrameData* data = NULL;

        TRAPD( error , ( data = CBitmapFrameData::NewL() ) );

        if ( error != KErrNone || data == NULL )

            {

            iIsRunning = EFalse;

            iIsVoIPRunning = EFalse;

            return;

            }

        data->SetBitmapsOwnedExternally( ETrue );

        data->SetBitmap( iAnimBackGroundImage );

        data->SetInterval( -1 );

        // Set frame to animation

        CBitmapAnimClientData* animData;

        if ( iCallAnimType == EVoipCallAnim )

            {

            animData = iIndiVoIPAnim->BitmapAnimData();

            }

        else if ( iCallAnimType == EVideoCallAnim )

            {

            animData = iIndiVideoAnim->BitmapAnimData();

            }

        else

            {

            animData = iIndiAnim->BitmapAnimData();

            }

        animData->SetBackgroundFrame( data );

        // This is a const function so mutable cast is needed

        // to change member variables

        CIncallAnim* mutableThis =

            MUTABLE_CAST( CIncallAnim* , this );

        // Start animation - we can't do a thing if this fails

        if ( iCallAnimType == EVoipCallAnim )

            {

            TRAP( error , iIndiVoIPAnim->StartAnimationL(EFalse) );

            mutableThis->iIsVoIPRunning = ETrue;

            mutableThis->iIsRunning = EFalse;

            mutableThis->iIsVideoRunning = EFalse;

            }

        else if ( iCallAnimType == EVideoCallAnim )

            {

            TRAP( error , iIndiVideoAnim->StartAnimationL(EFalse) );

            mutableThis->iIsVoIPRunning = EFalse;

            mutableThis->iIsVideoRunning = ETrue;

            mutableThis->iIsRunning = EFalse;

            }

        else

            {

            TRAP( error , iIndiAnim->StartAnimationL(EFalse) );

            mutableThis->iIsVoIPRunning = EFalse;

            mutableThis->iIsRunning = ETrue;

            mutableThis->iIsVideoRunning = EFalse;

            }

        }

    }

// Creates new animation frames

void CIncallAnim::SetAnimationL( CIncallStatusBubble& aImages, TInt aCallAnimType )

    {

    iCallAnimType = aCallAnimType;

    // Create new animation

    iIndiAnim = CAknBitmapAnimation::NewL();

    iIndiAnim->SetContainerWindowL( *this );

    iIndiVoIPAnim = CAknBitmapAnimation::NewL();

    iIndiVoIPAnim->SetContainerWindowL( *this );

    iIndiVideoAnim = CAknBitmapAnimation::NewL();

    iIndiVideoAnim->SetContainerWindowL( *this );

    TInt resourceReaderId = 0;

    resourceReaderId = R_BUBBLEMANAGER_ALERTING_ANIM;

    TResourceReader rr;

    iCoeEnv->CreateResourceReaderLC( rr , resourceReaderId );

    iIndiAnim->ConstructFromResourceL(rr);

    CleanupStack::PopAndDestroy(); // rr

    resourceReaderId = R_BUBBLEMANAGER_ALERTING_VOIP_ANIM;

    TResourceReader rr2;

    iCoeEnv->CreateResourceReaderLC( rr2 , resourceReaderId );

    iIndiVoIPAnim->ConstructFromResourceL(rr2);

    CleanupStack::PopAndDestroy(); // rr2

    resourceReaderId = R_BUBBLEMANAGER_ALERTING_VIDEO_ANIM;

    TResourceReader rr3;

    iCoeEnv->CreateResourceReaderLC( rr3 , resourceReaderId );

    iIndiVideoAnim->ConstructFromResourceL(rr3);

    CleanupStack::PopAndDestroy(); // rr3

    UpdateAnimationL( aImages, EDefaultCallAnim );// Normal CS call.

    UpdateAnimationL( aImages, EVoipCallAnim ); // VoIP call.

    UpdateAnimationL( aImages, EVideoCallAnim ); // Video call.

    }

void CIncallAnim::UpdateAnimationL( CIncallStatusBubble& aImages, TInt aCallAnimType )

    {

    // Clear old data:

    CBitmapAnimClientData* animData;

    if ( aCallAnimType == EVoipCallAnim )

        {

        animData = iIndiVoIPAnim->BitmapAnimData();

        }

    else if (iCallAnimType == EVideoCallAnim)

        {

        animData = iIndiVideoAnim->BitmapAnimData();

        }

    else

        {

        animData = iIndiAnim->BitmapAnimData();

        }

    animData->ResetFrameArray();

    // Create frame 1

    CEikImage* image1 = new (ELeave) CEikImage;

    image1->SetPictureOwnedExternally( ETrue );

    CleanupStack::PushL( image1 );

    if ( aCallAnimType == EVoipCallAnim )

        {

        aImages.GetImage(

            *image1,

            EIndexCallStatusQgn_indi_call_voip_active,

            EIndexCallStatusQgn_indi_call_voip_active_mask

            );

        }

    else if (iCallAnimType == EVideoCallAnim)

        {

        aImages.GetImage(

            *image1,

            EIndexCallstatusQgn_indi_call_video_callsta_1,

            EIndexCallstatusQgn_indi_call_video_callsta_1_mask

            );

        }

    else

        {

        aImages.GetImage(

            *image1,

            EIndexCallstatusQgn_indi_call_active,

            EIndexCallstatusQgn_indi_call_active_mask

            );

        }

    CBitmapFrameData* frame1 = CBitmapFrameData::NewL(

        MUTABLE_CAST( CFbsBitmap*, image1->Bitmap() ),

        MUTABLE_CAST( CFbsBitmap*, image1->Mask() ) );

    frame1->SetInterval( KErrNotFound );

    frame1->SetBitmapsOwnedExternally( ETrue );

    CleanupStack::PushL( frame1 );

    animData->AppendFrameL( frame1 ); // Takes ownership

    CleanupStack::Pop( frame1 );

    CleanupStack::PopAndDestroy( image1 );

    // Create frame 2

    CEikImage* image2 = new (ELeave) CEikImage;

    image2->SetPictureOwnedExternally( ETrue );

    CleanupStack::PushL( image2 );

    if ( aCallAnimType == EVoipCallAnim )

        {

        aImages.GetImage(

            *image2,

            EIndexCallStatusQgn_indi_call_voip_active_2,

            EIndexCallStatusQgn_indi_call_voip_active_2_mask

            );

        }

    else if (iCallAnimType == EVideoCallAnim)

        {

        aImages.GetImage(

            *image2,

            EIndexCallstatusQgn_indi_call_video_callsta_2,

            EIndexCallstatusQgn_indi_call_video_callsta_2_mask

            );

        }

    else

        {

        aImages.GetImage(

            *image2,

            EIndexCallstatusQgn_indi_call_active_2,

            EIndexCallstatusQgn_indi_call_active_2_mask

            );

        }

    CBitmapFrameData* frame2 = CBitmapFrameData::NewL(

        MUTABLE_CAST( CFbsBitmap*, image2->Bitmap() ),

        MUTABLE_CAST( CFbsBitmap*, image2->Mask() ) );

    frame2->SetInterval( KErrNotFound );

    frame2->SetBitmapsOwnedExternally( ETrue );

    CleanupStack::PushL( frame2 );

    animData->AppendFrameL( frame2 ); // Takes ownership

    CleanupStack::Pop( frame2 );

    CleanupStack::PopAndDestroy( image2 );

    }

void CIncallAnim::SetAnimationType( TInt aCallAnimType )

    {

    iCallAnimType = aCallAnimType;

    }

// Clears current animation

void CIncallAnim::ClearAnimation()

    {

    if ( iIndiAnim )

        {

        CBitmapAnimClientData* animData = iIndiAnim->BitmapAnimData();

        animData->ResetFrameArray();

        }

    delete iIndiAnim;

    iIndiAnim = NULL;

    if ( iIndiVoIPAnim )

        {

        CBitmapAnimClientData* animData = iIndiVoIPAnim->BitmapAnimData();

        animData->ResetFrameArray();

        }

    delete iIndiVoIPAnim;

    iIndiVoIPAnim = NULL;