/*

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

*     Bio control for Operator Logos.

*

*/

// INCLUDE FILES

#include "OperatorLogoBioControl.h"     // COperatorLogoBioControl

#include "OperatorLogoOTAConv.h"        // converter

#include <centralrepository.h>

#include <settingsinternalcrkeys.h>

#include <StringLoader.h>               // StringLoader (iCoeEnv)

#include <msgbiocontrolObserver.h>      // MMsgBioControlObserver

#include <OpLogoBC.rsg>                 // resouce identifiers

#include <MsgBioUtils.h>                // MsgBioUtils

#include <bldvariant.hrh>

#include <featmgr.h>					// Feature manager

#include <csxhelp/smart.hlp.hrh>

#include <mmtsy_names.h>

#include <AknUtils.h>

#include <msvapi.h>                     // CMsvEntry

#include <aknlayoutscalable_apps.cdl.h>

#include <MIHLScaler.h>                 // MIHLScaler

#ifdef RD_PHONE_CLIENT_EXT

#include <CPhCltImageHandler.h>

#include <CPhCltImageParams.h>

#include <CPhCltBaseImageParams.h>

#else

#include <CPhCltExtImageHandler.h>      // CPhCltExtImageHandler

#include <CPhCltExtImageParams.h>       // CPhCltExtImageParams

#include <CPhCltExtBaseImageParams.h>

#include <PhCltExt.h>                   // CPhCltExtFactory

#endif

#include <mmsvattachmentmanager.h>

#include <mmsvattachmentmanagersync.h>

// CONSTANTS

const TInt KLogoMaxWidthPixels      = 97;

const TInt KLogoMaxHeightPixels     = 25;

const TInt KUseLogo                 = 0;

const TInt KFirstMenuItem           = 1;

const TInt KLineFeed                = 0x0a;

const TInt KOtaBitmapInfoField      = 0x00;

// for infofield containing number of animated icons one:

const TInt KOtaBitmapInfoFieldAnim  = 0x01;

const TInt KOtaBitmapColorDepth     = 0x01;

const TInt KVersionNumberZero       = 48;   // ASCII value for '0'

const TInt KNumOfBytesMccMnc        = 3;

const TInt KNumOfBytesExpDay        = 19;

const TInt KPixelsInByte            = 8;

_LIT(KOpLogoCResourceFileName, "oplogoBC.rsc");

_LIT(KTempOtaFileName,"oltmp.ota");

_LIT(KPanicOplogoBC, "OpLogo");

#ifndef RD_PHONE_CLIENT_EXT

// PhoneClient Extension library

_LIT( KDllPhoneClientExt, "PhoneClientExt.dll" );

#endif

enum TOpLogoPanics

    {

    EPanicBadImageContent = 1,

    EPanicNullFileName,

    EPanicScalingError,

    EPanicOnlyOneLibraryAllowed,

    EPanicNullPtr

    };

// ==========================================================

/**

* Helper class which allows COperatorLogoBioControl to receive a callback

* to it's callback method when an asynchronous operation has finished.

* CAsyncCallBack needed tweaking since it is ment for callback only, and

* it completes the task immediately.

*/

class COpLogoAOCallBack: public CAsyncCallBack

    {

    public:

        COpLogoAOCallBack( const TCallBack &aCallBack, TInt aPriority )

            : CAsyncCallBack( aCallBack, aPriority )

            {

            }

        ~COpLogoAOCallBack()

            {

            // Empty

            }

        void SetItActive()

            {

            SetActive();

            StartWait();

            }

    protected:

        void RunL()

            {

            StopWait();

            iCallBack.CallBack();

            }

        void StartWait()

            {

            if( !iWait.IsStarted() )

                {

                iWait.Start();

                }

            }

        void StopWait()

            {

            if( iWait.IsStarted() )

                {

                iWait.AsyncStop();

                }

            }

        void DoCancel()

            {

            }

    private:

        CActiveSchedulerWait iWait;

    };

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor.

COperatorLogoBioControl::COperatorLogoBioControl(

     MMsgBioControlObserver& aObserver,

     CMsvSession* aSession,

     TMsvId aId,

     TMsgBioMode aEditorOrViewerMode ):

     CMsgBioControl( aObserver,

                     aSession,

                     aId,

                     aEditorOrViewerMode,

                     NULL /* file handle */ )

    {

    }

// Symbian OS default constructor can leave.

void COperatorLogoBioControl::ConstructL()

    {

	//we take the file server session to own variable in order

	//to avoid constant use of CCoeEnv::Static() and to reduce the usage

	//of TLS

    iFs = CCoeEnv::Static()->FsSession();

    if ( !CheckMsgValidityL() )

        {

        User::Leave( KErrMsgBioMessageNotValid );

        }

	FeatureManager::InitializeLibL();

    if( IsEditor() ) //This control doesnt support editing mode.

        {

        User::Leave( KErrNotSupported );

        }

    User::LeaveIfError( iPhoneServer.Connect() );

    LoadStandardBioResourceL();

    LoadResourceL( KOpLogoCResourceFileName );

    iScaler = IHLScaler::CreateL();

    iScalingAO = new ( ELeave ) COpLogoAOCallBack(

        TCallBack( ScalingReady, this ), CActive::EPriorityStandard );

    CreateBitmapL();

    // We want to scale the image now:

    SetRect( Rect() );

    // logo will be shown after asynch. scaling,

    // see COperatorLogoBioControl::DoScalingReady()

    }

// Two-phased constructor.

EXPORT_C CMsgBioControl* COperatorLogoBioControl::NewL(

    MMsgBioControlObserver& aObserver,

    CMsvSession* aSession,

    TMsvId aId,

    TMsgBioMode aEditorOrViewerMode,

    const RFile* /* aFile */ )

    {

    COperatorLogoBioControl* self =

        new( ELeave ) COperatorLogoBioControl( aObserver,

                                               aSession,

                                               aId,

                                               aEditorOrViewerMode );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

COperatorLogoBioControl::~COperatorLogoBioControl()

    {

    FeatureManager::UnInitializeLib();

    iPhoneServer.Close();

    if( iTempFileExists )

        {

        //delete tempfile if exists

        iFs.Delete(iTempPathAndName);

        }

	delete iBitmap;

    delete iScaledBitmap;

    delete iScaler;

    delete iScalingAO;

    }

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

// COperatorLogoBioControl::SetAndGetSizeL

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

//

void COperatorLogoBioControl::SetAndGetSizeL( TSize& aSize )

    {

    // Size proposed in aSize parameter is used, only height is

    // proposed by this control.

    if (AknLayoutUtils::ScalableLayoutInterfaceAvailable())

        {

        TAknWindowComponentLayout layout =

            AknLayoutScalable_Apps::mce_image_pane_g2();

        TAknLayoutRect layoutRect;

    	layoutRect.LayoutRect( Rect(), layout.LayoutLine() );

    	aSize.iHeight = layoutRect.Rect().Height();

        }

    else

        { // use old sizing functionality if scalable IF isn't available:

        aSize.iHeight /= 2; // get in to the middle of pane

        }

    SetSizeWithoutNotification( aSize );

    }

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

// COperatorLogoBioControl::SetMenuCommandSetL

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

//

void COperatorLogoBioControl::SetMenuCommandSetL( CEikMenuPane& aMenuPane )

    {

    AddMenuItemL( aMenuPane, R_USE_LOGO, KUseLogo, KFirstMenuItem );

    }

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

// COperatorLogoBioControl::CurrentLineRect

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

//

TRect COperatorLogoBioControl::CurrentLineRect() const

    {

    return Rect();

    }

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

// COperatorLogoBioControl::IsFocusChangePossible

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

//

TBool COperatorLogoBioControl::IsFocusChangePossible(

    TMsgFocusDirection /*aDirection*/ ) const

    {

    return EFalse;

    }

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

// COperatorLogoBioControl::HeaderTextL

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

//

HBufC* COperatorLogoBioControl::HeaderTextL() const

    {

    HBufC* titleText = StringLoader::LoadL( R_TITLE_OPERATOR_LOGO );

    return titleText;

    }

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

// COperatorLogoBioControl::HandleBioCommandL

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

//

TBool COperatorLogoBioControl::HandleBioCommandL(TInt aCommand)

    {

    aCommand -= iBioControlObserver.FirstFreeCommand();

    TBool retVal( EFalse );

    switch ( aCommand )

        {

        case KUseLogo:

            {

            TrySaveBitmapL();

            retVal = ETrue;

            break;

            }

        default:

            {

            retVal = EFalse;

            break;

            }

        }

    return retVal;

    }

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

// COperatorLogoBioControl::OptionMenuPermissionsL

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

//

TUint32 COperatorLogoBioControl::OptionMenuPermissionsL() const

    {

    return EMsgBioDelete

        | EMsgBioMessInfo

        | EMsgBioMove

        | EMsgBioHelp

        | EMsgBioExit;

    }

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

// COperatorLogoBioControl::OfferKeyEventL

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

//

TKeyResponse COperatorLogoBioControl::OfferKeyEventL(

    const TKeyEvent& /*aKeyEvent*/,

    TEventCode /*aType*/ )

    {

	return EKeyWasConsumed;

    }

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

// COperatorLogoBioControl::GetHelpContext

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

//

void COperatorLogoBioControl::GetHelpContext(

    TCoeHelpContext& aHelpContext ) const

	{

	if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

		{

		const TUid KUidSmart = {0x101F4CDA};

		aHelpContext.iContext = KSMART_HLP_OPLOGOVIEWER();

		aHelpContext.iMajor = KUidSmart;

		}

    }

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

// COperatorLogoBioControl::CountComponentControls

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

//

TInt COperatorLogoBioControl::CountComponentControls() const

    {

    return 0;

    }

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

// COperatorLogoBioControl::ComponentControl

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

//

CCoeControl* COperatorLogoBioControl::ComponentControl(

    TInt /*aIndex*/ ) const

    {

    return NULL;

    }

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

// COperatorLogoBioControl::SizeChanged

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

//

void COperatorLogoBioControl::SizeChanged()

    {

    TRect imageRect( Rect() );

    if (AknLayoutUtils::ScalableLayoutInterfaceAvailable())

        {

        TAknWindowComponentLayout layout =

            AknLayoutScalable_Apps::mce_image_pane_g2();

        TAknLayoutRect layoutRect;

    	layoutRect.LayoutRect( Rect(), layout.LayoutLine() );

    	imageRect = layoutRect.Rect();

        // If leave occurs then scaling is not performed

        TRAP_IGNORE( ScaleIfPossibleL( imageRect.Size() ) );

        }

    else

        {

        TSize imageSize( KLogoMaxWidthPixels, KLogoMaxHeightPixels );

        if ( imageRect.Width() < KLogoMaxWidthPixels ||

             imageRect.Height() < KLogoMaxHeightPixels )

            { // size of the control is smaller than the maximum size we

              // would use otherwise.

            imageSize = imageRect.Size();

            }

        // If leave occurs then scaling is not performed

        TRAP_IGNORE( ScaleIfPossibleL( imageSize ) );

        }

    }

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

// COperatorLogoBioControl::FocusChanged

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

//

void COperatorLogoBioControl::FocusChanged( TDrawNow /*aDrawNow*/ )

    {

    }

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

// COperatorLogoBioControl::SetContainerWindowL

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

//

void COperatorLogoBioControl::SetContainerWindowL(

    const CCoeControl& aContainer )

    {

    CCoeControl::SetContainerWindowL( aContainer );

    }

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

// COperatorLogoBioControl::CheckMsgValidityL

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

//

TBool COperatorLogoBioControl::CheckMsgValidityL()

    {

    RFile file;

    TFileName fileName;

    TInt fileSize(0);

    HBufC8* fileBuffer;

    CMsvEntry* entry = this->MsvSession(). GetEntryL(iId);

    CleanupStack::PushL( entry );

	CMsvStore* store = entry->ReadStoreL();

	CleanupStack::PushL(store);

	MMsvAttachmentManager& manager = store->AttachmentManagerL();

	file = manager.GetAttachmentFileL(0);

    CleanupClosePushL(file);

    // get the size of file for descriptor

    User::LeaveIfError(file.Size(fileSize));

    fileBuffer = HBufC8::NewLC(fileSize);

    TPtr8 filePtr = fileBuffer->Des();

    User::LeaveIfError(file.Read(filePtr));

    TInt ret(CheckMsgFormatL(file, filePtr));

    CleanupStack::PopAndDestroy(fileBuffer);

    CleanupStack::PopAndDestroy( &file );

    CleanupStack::PopAndDestroy( store );

    CleanupStack::PopAndDestroy( entry );

    return ret;

    }

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

// COperatorLogoBioControl::CheckMsgFormatL

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

//

TBool COperatorLogoBioControl::CheckMsgFormatL( RFile aFile, TPtr8 aPtr )

    {

    TInt len = aPtr.Length();

    TInt descPosition( 0 );

    TUint8 byte;

    // first byte

    if (len > descPosition)

        {

        byte = aPtr[descPosition];

        }

    else

        {

        return EFalse;

        }

    if (byte == KVersionNumberZero)

        {

        descPosition++;

        if (len > descPosition)

            {

            byte = aPtr[descPosition];

            }

        else

            {

            return EFalse;

            }

        TInt count( 1 );

        while (byte != KLineFeed && count <= KNumOfBytesExpDay )

            {

            // loop Mcc, Mnc and expiration date bytes off.

            descPosition++;

            if (len > descPosition)

                {

                byte = aPtr[descPosition];

                }