/*

* Copyright (c) 2007 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: 

*       

*

*/

// INCLUDES

#include <fbs.h>

#include <s32mem.h> 

#include <bitdev.h> 

#include <mbsaccess.h>

#include <cbsbitmap.h>

#include <cbsfactory.h>

#include "cmssession.h"

#include <AknIconUtils.h>

#include "cmspresencedata.h"

#include "cmscommondefines.h"

#include <presencetrafficlights.mbg>

#include "presencetrafficlighticons.h"

#include <contactpresencebrandids.h> 

// This must be in line with contactpresence.dll implementation

_LIT( KPresenceTrafficLightsMif, "\\resource\\apps\\presencetrafficlights.mif" );

// ----------------------------------------------------

// CCmsPresenceData::CCmsPresenceData

// 

// ----------------------------------------------------

//

CCmsPresenceData::CCmsPresenceData( RCmsContact& aContact ) 

    : iElementIdText(NULL), iContact( aContact )

    {

    }

// ----------------------------------------------------

// CCmsPresenceData::NewL

// 

// ----------------------------------------------------

//

CCmsPresenceData* CCmsPresenceData::NewL( RCmsContact& aContact )

    {

    CCmsPresenceData* self = new ( ELeave ) CCmsPresenceData( aContact );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// ----------------------------------------------------

// CCmsPresenceData::ConstructL

// 

// ----------------------------------------------------

//

void CCmsPresenceData::ConstructL()

    {

    }

// ----------------------------------------------------

// CCmsPresenceData::~CCmsPresenceData

// 

// ----------------------------------------------------

//

EXPORT_C CCmsPresenceData::~CCmsPresenceData()

    {

    //The client owns these two guys

    //delete iMask;

    //delete iBitmap;

    delete iBrandId;

    delete iBrandedText;

    delete iUserIdentity;

    delete iElementIdText;

    delete iElementIdImage;

    }

// ----------------------------------------------------

// CCmsPresenceData::Mask

// 

// ----------------------------------------------------

//

EXPORT_C CFbsBitmap* CCmsPresenceData::Mask() const

    {

    return iMask;

    }

// ----------------------------------------------------

// CCmsPresenceData::~CCmsPresenceData

// 

// ----------------------------------------------------

//

EXPORT_C CFbsBitmap* CCmsPresenceData::Bitmap() const

    {

    return iBitmap;

    }

// ----------------------------------------------------

// CCmsPresenceData::CompilePresenceDataL

// 

// ----------------------------------------------------

//

EXPORT_C TInt CCmsPresenceData::PreparePresenceDataL( TSize aBitmapSize )

    {

    #ifdef _DEBUG

        RCmsSession::WriteToLog( _L8( "CCmsPresenceData::PreparePresenceDataL()" ) );

    #endif

    TInt error = KErrNotFound;

    CBSFactory* factory = CreateBrandingFactoryL();

    if( factory )

        {

        CleanupStack::PushL( factory ); 

        //reset brand text here

        delete iBrandedText;        

        iBrandedText = NULL;

        if ( !iBrandId->Des().Length() )

            {

            // presence cache is reset

            iMask = new ( ELeave ) CFbsBitmap();

            iBitmap = new ( ELeave ) CFbsBitmap();              

            }

        else if ( iBrandId->Des().Compare( KTrafficLightService ) )

            {

            error = DoGetIconFromBrandSrvL( *factory, aBitmapSize );            

            }

        else

            {

            error = DoGetIconFromFileL( aBitmapSize );

            }

        CleanupStack::PopAndDestroy(factory);  //factory

        }

    return error;

    }

// ---------------------------------------------------------------------------

// CCmsPresenceIconHandler::ElementIdImage

//

// ---------------------------------------------------------------------------

//

TPtrC8 CCmsPresenceData::ElementIdImage()

    {

    return iElementIdImage ? iElementIdImage->Des() : TPtrC8();

    }

// ---------------------------------------------------------------------------

// CCmsPresenceIconHandler::CreateBrandingFactoryL

//

// ---------------------------------------------------------------------------

//

CBSFactory* CCmsPresenceData::CreateBrandingFactoryL()

    {

    CBSFactory* factory = NULL;

    if( iBrandId )

        {

        factory = CBSFactory::NewL( KCPBrandDefaultId, KCPBrandAppId );

        }

    else

        {

        #ifdef _DEBUG

            RCmsSession::WriteToLog( _L8( " Brand ID is NULL, cannot create branding factory" ) );

        #endif

        }

    return factory;

    }

// ---------------------------------------------------------------------------

// CCmsPresenceIconHandler::CopyBitmapL

//

// ---------------------------------------------------------------------------

//

CFbsBitmap* CCmsPresenceData::CopyBitmapL( CFbsBitmap& aBitmap )

    {

    // Create a temporary bitmap

    CFbsBitmap* newBitmap = new( ELeave ) CFbsBitmap();

    CleanupStack::PushL( newBitmap );

    User::LeaveIfError( newBitmap->Create( aBitmap.SizeInPixels(), aBitmap.DisplayMode() ) );

    // Create a bitmap device

    CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( newBitmap );

    CleanupStack::PushL( device );

    // Create a bitmap context

    CBitmapContext* context = NULL;

    User::LeaveIfError( device->CreateBitmapContext( context ) );

    CleanupStack::PushL( context );

    // Copy contents of aBitmap into the new bitmap

    context->BitBlt( TPoint( 0,0 ), &aBitmap );

    CleanupStack::PopAndDestroy( 2 ); // context, device

    CleanupStack::Pop(); //newBitmap

    return newBitmap;

    }

// ----------------------------------------------------

// CCmsPresenceData::BrandedText

// 

// ----------------------------------------------------

//

EXPORT_C TPtrC CCmsPresenceData::BrandedText() const

    {

    return iBrandedText ? iBrandedText->Des() : TPtrC();

    }

// ----------------------------------------------------

// CCmsPresenceData::UserIdentity

// 

// ----------------------------------------------------

//        

EXPORT_C TPtrC8 CCmsPresenceData::UserIdentity() const

    {

    return iUserIdentity ? iUserIdentity->Des() : TPtrC8();

    }

// ----------------------------------------------------

// CCmsPresenceData::ServiceType

// 

// ----------------------------------------------------

//

EXPORT_C TUint32 CCmsPresenceData::ServiceType() const

    {

    return ( TUint32 )iServiceType;

    }

// ----------------------------------------------------

// CCmsPresenceData::AssignDataL

// 

// ----------------------------------------------------

//

void CCmsPresenceData::AssignDataL( TInt aFieldType, const TDesC8& aFieldData )

    {

    #ifdef _DEBUG

        RCmsSession::WriteToLog( _L8( "CCmsPresenceData::AssignDataL()" ) );

    #endif

    switch( aFieldType )

        {

        case KPresenceDataBrandId:

            delete iBrandId;

            iBrandId = NULL;

            iBrandId = aFieldData.AllocL();

            break;

        case KPresenceDataElementTextId:

            delete iElementIdText;

            iElementIdText = NULL;

            iElementIdText = aFieldData.AllocL();

            break;

        case KPresenceDataElementImageId:

            delete iElementIdImage;

            iElementIdImage = NULL;

            iElementIdImage = aFieldData.AllocL();

            break;

        case KPresenceDataLanguageId:

            {

            TLex8 lex( aFieldData );

            lex.Val( iLanguageId );

            }

            break;

        case KPresenceDataServiceType:

            {

            TLex8 lex( aFieldData );

            lex.Val( iServiceType );

            }

            break;            

        case KPresenceDataUserIdentity:

            delete iUserIdentity;

            iUserIdentity = NULL;

            iUserIdentity = aFieldData.AllocL();

            break; 

        default:

            break;

        }

    }

// ---------------------------------------------------------------------------

// CCmsPresenceIconHandler::DoGetIconFromBrandSrvL

//

// ---------------------------------------------------------------------------

//

TInt CCmsPresenceData::DoGetIconFromBrandSrvL( CBSFactory& aFactory, TSize aBitmapSize )

    {

    TLanguage userLang = User::Language();

    TLanguage defLang = ELangInternationalEnglish;

    //Search for BrandPackage using PhoneLanguage

    //PhoneLanguage gets the Highest Priority

    TRAPD(err, DoGetIconFromBrandSrvL( aFactory, aBitmapSize, ( TLanguage ) userLang ));    

    if ( ( err ) && ( iLanguageId != KErrNotFound ) && ( iLanguageId != userLang ) )

        {

        //The next priority goes to BrandLanguage set in the SpSettings/service table

        //during provisioning

        //Search for BrandPackage using this BrandLanguage

        TRAP( err, DoGetIconFromBrandSrvL( aFactory, aBitmapSize, ( TLanguage ) iLanguageId ) );       

        }

    if ( ( err ) && ( userLang != defLang ) && ( iLanguageId != defLang ) )

        {

        //Fetching of brand with UserLang & with the one mentioned in the Servicetable

        //was not successfull. 

        //Finally try with Default Language ID and even if this fails

        //proceed without any brand icons/texts

        TRAP( err, DoGetIconFromBrandSrvL( aFactory, aBitmapSize, ( TLanguage ) defLang ) );        

        }   

    return err;

    }

// ---------------------------------------------------------------------------

// CCmsPresenceIconHandler::DoGetIconFromBrandSrvL

//

// ---------------------------------------------------------------------------

//

TInt CCmsPresenceData::DoGetIconFromBrandSrvL( CBSFactory& aFactory, TSize aBitmapSize, TLanguage aLanguage )

    {

    TInt error = KErrNone;

    MBSAccess* access = aFactory.CreateAccessLC( iBrandId->Des(), ( TLanguage )aLanguage );

    CFbsBitmap* mask = NULL;

    CFbsBitmap* bitmap = NULL;    

    TRAP( error, access->GetBitmapL( ElementIdImage(), bitmap, mask ) );

    if( KErrNone == error )

        {

        CleanupStack::PushL( mask );

        CleanupStack::PushL( bitmap );

        AknIconUtils::SetSize( mask, aBitmapSize );

        AknIconUtils::SetSize( bitmap, aBitmapSize );

        iMask = CopyBitmapL( *mask );

        iBitmap = CopyBitmapL( *bitmap );

        CleanupStack::PopAndDestroy( 2 );  //bitmap, mask

        }

    else

        {

        //instantiate bitmaps

        iMask = new ( ELeave ) CFbsBitmap();

        iBitmap = new ( ELeave ) CFbsBitmap();

        }

    delete iBrandedText;

    iBrandedText = NULL;

    if ( iElementIdText && iElementIdText->Length() )

        {

        iBrandedText = access->GetTextL( iElementIdText->Des() );

        }

    CleanupStack::PopAndDestroy();  //access    

    return error;

    }

// ---------------------------------------------------------------------------

// CCmsPresenceIconHandler::DoGetIconFromFileL

//

// ---------------------------------------------------------------------------

//

TInt CCmsPresenceData::DoGetIconFromFileL( TSize aBitmapSize )

    {

    TInt error = KErrNone;

    CFbsBitmap *bitmap = NULL;

    CFbsBitmap *mask = NULL;

    TInt bitmapId(0);

    TInt maskId(0);

    if ( !(ElementIdImage().CompareF( KTrafficOnline )))

        {

        bitmapId = EMbmPresencetrafficlightsQgn_prop_im_friend_on;

        maskId = EMbmPresencetrafficlightsQgn_prop_im_friend_on_mask;

        }

    else if ( !(ElementIdImage().CompareF( KTrafficOffline )))

        {

        bitmapId = EMbmPresencetrafficlightsQgn_prop_im_friend_off;

        maskId = EMbmPresencetrafficlightsQgn_prop_im_friend_off_mask;

        }

    else

        {

        }

    TRAP(error, AknIconUtils::CreateIconL(

         bitmap,

         mask,

         KPresenceTrafficLightsMif,

         bitmapId,

         maskId));

    if ( error )

        {

        //instantiate bitmaps

        iMask = new ( ELeave ) CFbsBitmap();

        iBitmap = new ( ELeave ) CFbsBitmap();     

        }

    else

        {   

        AknIconUtils::SetSize(  bitmap, aBitmapSize );  

        AknIconUtils::SetSize(  mask, aBitmapSize );          

        iBitmap = bitmap;

        iMask = mask;

        }  

    return error;    

    }

// End of File