/*

* Copyright (c) 2005-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:  Sub Session image handler.

*                Does image saving and loading.

*

*/

// INCLUDE FILES

#include    "CPhSrvSubSessionImageHandler.h"

#include    "CPhSrvSession.h"

#include    "CPhSrvServer.h"

#include    <e32property.h>

#include    <PhCltTypes.h>

#include    "PhSrvDebugInfo.h"  

// CONSTANTS

_LIT( KPhSrvImageDriveRom, "z:" );

_LIT( KPhSrvVTImageName, "vtstillimage" );

_LIT( KPhSrvVTDefaultImageName, "vtdefaultimage." );

_LIT( KPhSrvImageSuffix, ".mbm" );

_LIT( KPhSrvImageWildCard, "*" );

_LIT( KPhSrvLogoMncMccSeparator, "_" );

_LIT( KPhSrvLogoTypeIndicatorOTA, "OTA" );

_LIT( KPhSrvLogoTypeIndicatorProg, "Prog" );

_LIT( KPhSrvOperatorLogoPrefix, "Logo" );

const TInt KPhSrvNameMaxLen = 1024;

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

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

// CPhSrvSubSessionImageHandler::CPhSrvSubSessionImageHandler

// 

// Constructor.

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

//

CPhSrvSubSessionImageHandler::CPhSrvSubSessionImageHandler( 

    CPhSrvSession& aSession )

:   CPhSrvSubSessionBase( aSession, EPhSrvSubSessionTypeImageHandler )

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Ctor" )

    }

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

// CPhSrvSubSessionImageHandler::~CPhSrvSubSessionImageHandler

// 

// Destructor.

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

//

CPhSrvSubSessionImageHandler::~CPhSrvSubSessionImageHandler()

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Dtor" )

    iVTBitMaps.ResetAndDestroy();

    iOperatorLogos.ResetAndDestroy();

    PhoneSession().PhoneServer().DisconnectFBS();

    iFs.Close();

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Dtor>" )    

    }

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

// CPhSrvSubSessionImageHandler::NewL

// 

// Two-phased constructor.

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

//

CPhSrvSubSessionBase* CPhSrvSubSessionImageHandler::NewL(

    CPhSrvSession& aSession )

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::NewL" )    

    CPhSrvSubSessionBase* self = 

        new( ELeave ) CPhSrvSubSessionImageHandler( aSession );

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::NewL>" )        

    return self;

    }

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

// CPhSrvSubSessionImageHandler::ImageSaved

// 

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

//

void CPhSrvSubSessionImageHandler::ImageSaved( TInt aResult )

    {

    iImageSaver = NULL;

    // Message for save request

    iSaveVtImageMessage.Complete( aResult );

    }

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

// CPhSrvSubSessionImageHandler::PhSrvMessageDecoderCanProcessMessage

// 

// Framework function. Returns ETrue for the op codes that

// this subsession can handle.

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

//

TBool CPhSrvSubSessionImageHandler::PhSrvMessageDecoderCanProcessMessage( 

    TInt aFunction )

    {

    _DDPRINT( 4, "CPhSrvSubSessionImageHandler::CanProcess", aFunction )    

    switch( aFunction )

        {

        case EPhoneServerImageHandlerSubSessionOpen:

        case EPhoneServerImageHandlerSubSessionClose:

        case EPhoneServerImageHandlerSubSessionSave:

        case EPhoneServerImageHandlerSubSessionLoad:

        case EPhoneServerImageHandlerSubSessionCommitLoad:

        case EPhoneServerOpenVtImage:

        // new saving scheme 

        case EPhoneServerSaveVtImage:

        case EPhoneServerSaveVtImageCancel:

            return ETrue;

        default:

            return EFalse;

        }

    }

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

// CPhSrvSubSessionImageHandler::PhSrvMessageProcessorHandleMessageL

// 

// Framework function. Handle any op-codes here.

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

//

void CPhSrvSubSessionImageHandler::PhSrvMessageProcessorHandleMessageL( 

    const RMessage2& aMessage )

    {

    _DDPRINT( 4, "CPhSrvSubSessionImageHandler::Handle", 

        aMessage.Function() )

    TBool permissionStatus ( EFalse );

    // Check needed capabilities    

    TBool hasCapWriteDeviceData( EFalse );

    hasCapWriteDeviceData = aMessage.HasCapability( ECapabilityWriteDeviceData );

    TBool hasCapReadDeviceData( EFalse );

    hasCapReadDeviceData = aMessage.HasCapability( ECapabilityReadDeviceData );

    switch( aMessage.Function() )

        {

        case EPhoneServerImageHandlerSubSessionClose:

            CmdSubSessionClose( aMessage );

            permissionStatus = ETrue;

            break;

        case EPhoneServerImageHandlerSubSessionSave:

            if ( hasCapWriteDeviceData )

                {        

                CmdSubSessionSaveImagesL( aMessage );

                permissionStatus = ETrue;

                }

            break;

        case EPhoneServerImageHandlerSubSessionCommitLoad:

            if ( hasCapReadDeviceData )

                {        

                CmdSubSessionCommitLoadL( aMessage );

                permissionStatus = ETrue;

                }

            break;

        case EPhoneServerImageHandlerSubSessionLoad:

            if ( hasCapReadDeviceData )

                {        

                CmdSubSessionLoadImagesL( aMessage );

                permissionStatus = ETrue;

                }

            break;

        case EPhoneServerOpenVtImage:

            if ( hasCapReadDeviceData )

                {        

                CmdSubSessionOpenDefaultVtImageL( aMessage );

                permissionStatus = ETrue;

                }

            break;

        case EPhoneServerSaveVtImage:

            if ( hasCapWriteDeviceData )

                {

                CmdSubSessionSaveVtImageL( aMessage );

                permissionStatus = ETrue;

                }

            break;

        case EPhoneServerSaveVtImageCancel:            

            if ( hasCapWriteDeviceData )

                {

                permissionStatus = ETrue;

                if ( iImageSaver )

                    {

                    // saving in progress, cancel it.

                    iImageSaver->Cancel();

                    }

                else

                    {

                    // nothing to cancel or too late cancellation 

                    iSaveVtImageMessage.Complete( KErrNotReady );

                    }

                }

            break;

        default:

            _DPRINT( 4, "CPhSrvSubSessionImageHandler::Handle: PANIC" )        

            PhoneSession().PanicClient(

                aMessage,

                EPhCltServerInitiatedPanicInvalidRequest );

            break;

        }

    // If caps are not ok

    if( !permissionStatus )

        {

        aMessage.Complete( KErrPermissionDenied );

        }   

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Handle>" )

    }

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

// CPhSrvSubSessionImageHandler::CmdSubSessionClose

// 

// Close the sub-session.

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

//

void CPhSrvSubSessionImageHandler::CmdSubSessionClose( 

    const RMessage2& aMessage )

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Close" )    

    PhoneSession().CloseSubSession( aMessage );

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Close>" )    

    }

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

// CPhSrvSubSessionImageHandler::CmdSubSessionSaveImagesL

// 

// 

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

//

void CPhSrvSubSessionImageHandler::CmdSubSessionSaveImagesL( 

    const RMessage2& aMessage )

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Save" )    

    TPhCltImageArray handles;

    TPckg< TPhCltImageArray > pHandles( handles );

    Read( aMessage, 0, pHandles );

    // Version check in here, if multiple possibilities.

    switch( pHandles().iType )

        {

        case EPhCltTypeVTStill:

            DoSaveVTImageL( handles );

            break;

        case EPhCltTypeOperatorLogo:

            DoSaveOperatorLogoL( handles );

            break;

        default:

            _DPRINT( 4, "CPhSrvSubSessionImageHandler::Save US" )        

            User::Leave( KErrNotSupported );

        }

    // Leave is propagated into framework.

    aMessage.Complete( KErrNone );

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Save>" )    

    }

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

// CPhSrvSubSessionImageHandler::CmdSubSessionLoadImagesL

// 

// 

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

//

void CPhSrvSubSessionImageHandler::CmdSubSessionLoadImagesL( 

    const RMessage2& aMessage )

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Load" )    

    TPhCltImageArray handles;

    TPckg< TPhCltImageArray > pHandles( handles );

    Read( aMessage, 0, pHandles );

    // Version check in here, if multiple possibilities.

    switch( pHandles().iType )

        {

        case EPhCltTypeVTStill:

        case EPhCltTypeVTDefault:

            DoLoadVTImagesL( handles );

            break;

        case EPhCltTypeOperatorLogo:

            DoLoadOperatorLogoL( handles );

            break;

        default:

            _DPRINT( 4, "CPhSrvSubSessionImageHandler::Load US" )        

            User::Leave( KErrNotSupported );

        }

    Write( aMessage, 0, pHandles );

    aMessage.Complete( KErrNone );

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Load>" )    

    }

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

// CPhSrvSubSessionImageHandler::CmdSubSessionOpenDefaultVtImageL

// 

// 

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

//

void CPhSrvSubSessionImageHandler::CmdSubSessionOpenDefaultVtImageL( 

    const RMessage2& aMessage )

    {

    _DPRINT( 4, 

        "CPhSrvSubSessionImageHandler::CmdSubSessionOpenDefaultVtImageL<" )

    TBool defaultImage( ETrue );

    TPckg< TBool > pckg( defaultImage );

    Read( aMessage, 1, pckg );

    // Currently only default still image uses file handle sharing. User

    // defined image uses legacy scheme. If user defined image is attempted

    // to open here, complete with error.

    if ( !defaultImage )

        {

        User::Leave( KErrNotSupported );

        }

    RFs fs;

    RFile defaultVtImageFile;    

    TFileName fileName;

    // File extension may be any supported file type. Resolve which one is used.

    User::LeaveIfError( ResolveDefaultVtImageFileName( fileName ) );    

    // Open separate session because ownwership of transferred file's

    // session goes with the file (when file is closed by the client,

    // related session is also closed)

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

    CleanupClosePushL( fs );

    User::LeaveIfError( defaultVtImageFile.Open( fs, fileName, EFileRead ) );

    // Transfer file handle to client by writing file handle value to

    // message argument 0

    User::LeaveIfError( 

        defaultVtImageFile.TransferToClient( aMessage, 0 ) );    

    defaultVtImageFile.Close(); // file handle duplicated for client

    CleanupStack::PopAndDestroy(); // fs, can be closed, handle duplicated

    _DPRINT( 4, 

        "CPhSrvSubSessionImageHandler::CmdSubSessionOpenDefaultVtImageL>" )

    }

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

// CPhSrvSubSessionImageHandler::ResolveDefaultVtImageFileName

// 

// Resolves file name of default VT image. Extension cannot be known

// in advance and directory entries must be read and parsed.

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

//

TInt CPhSrvSubSessionImageHandler::ResolveDefaultVtImageFileName(

    TDes& aFileName )

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::ResolveDefaultVtImageFileName<" )

    CDir* entries = NULL;    

    TFileName path = KPhSrvImageDriveRom();

    // read directory entries in the server private path

    path.Append( iFilePath );    

    TInt result = iFs.GetDir( path, KEntryAttNormal, EDirsLast, entries );

    if ( result == KErrNone && entries )

        {

        const TInt entryCount( entries->Count() );

        // go through entries and stop when VT image file is found

        for ( TInt index = 0; index < entryCount; index++ )

            {

            const TEntry& entry = ( *entries )[index];  

            if ( entry.iName.Find( KPhSrvVTDefaultImageName() ) > KErrNotFound )

                {

                aFileName = path;

                aFileName.Append( entry.iName );

                // fileName now contains full path

                index = entryCount; // break loop

                result = KErrNone;

                }

            }

        }

    delete entries;

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::ResolveDefaultVtImageFileName>" )

    return result;

    }

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

// CPhSrvSubSessionImageHandler::CmdSubSessionSaveVtImageL

// 

// 

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

//

void CPhSrvSubSessionImageHandler::CmdSubSessionSaveVtImageL( 

    const RMessage2& aMessage )

    {

    TFileName sourceFile;

    TPckg<TFileName> pckg( sourceFile );

    Read( aMessage, 0, pckg );

    CPhSrvImageSaver* saver = CPhSrvImageSaver::NewL( iFs, iFilePath, *this );

    CleanupStack::PushL( saver );

    saver->SaveImageL( sourceFile );

    CleanupStack::Pop();

    iImageSaver = saver;

    }

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

// CPhSrvSubSessionImageHandler::CmdSubSessionCommitLoadL

// 

// 

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

//

void CPhSrvSubSessionImageHandler::CmdSubSessionCommitLoadL( 

    const RMessage2& aMessage )

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Commit" )    

    TPhCltImageArray handles;

    TPckg< TPhCltImageArray > pHandles( handles );

    Read( aMessage, 0, pHandles );

    switch ( pHandles().iType )

        {

        case EPhCltTypeVTStill:

        case EPhCltTypeVTDefault:

            DoCommitLoadVTL();

            break;

        case EPhCltTypeOperatorLogo:

            DoCommitLoadLogo( handles );

            break;

        default:

            _DPRINT( 4, "CPhSrvSubSessionImageHandler::Commit US" )        

            User::Leave( KErrNotSupported );        

        }

    aMessage.Complete( KErrNone );

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::Commit" )    

    }

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

// CPhSrvSubSessionImageHandler::DoCommitLoadVTL

// 

// 

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

//

void CPhSrvSubSessionImageHandler::DoCommitLoadVTL()

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::CommitVT" )    

    iVTBitMaps.ResetAndDestroy(); 

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::CommitVT>" )        

    }

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

// CPhSrvSubSessionImageHandler::DoCommitLoadLogo

// 

// 

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

//

void CPhSrvSubSessionImageHandler::DoCommitLoadLogo( TPhCltImageArray& aImages )

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::CommitLogo" )        

    for ( TInt i = 0; i < iOperatorLogos.Count(); i ++ )

        {

        if ( aImages.iImages[ EPhCltExtCountryCodeIndex ] == 

            iOperatorLogos[ i ]->iCountryCode && 

            aImages.iImages[ EPhCltExtNetworkCodeIndex ] == 

            iOperatorLogos[ i ]->iNetworkCode )

            {

            _DPRINT( 4, "CPhSrvSubSessionImageHandler::CommitLogo found" )                

            delete iOperatorLogos[ i ];

            iOperatorLogos.Remove( i );

            break;

            }

        }

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::CommitLogo>" )            

    }

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

// CPhSrvSubSessionImageHandler::DoSaveVTImage

// 

// 

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

//

void CPhSrvSubSessionImageHandler::DoSaveVTImageL( TPhCltImageArray& aImages )

    {

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::SaveVT" )        

    HBufC* hbuf = HBufC::NewLC(KPhSrvNameMaxLen);

    TPtr buf = hbuf->Des();

    for ( TInt i = 0; i < aImages.iImageCount; i++ )

        {

        buf.Zero();

        buf.Append( iDriveName );

        buf.Append( iFilePath );

        buf.Append( KPhSrvVTImageName );

        buf.AppendNum( i );

        buf.Append( KPhSrvImageSuffix );

        buf.ZeroTerminate();

#ifdef __PHENG_DEBUG_INFO__

        RDebug::Print( _L("CPhSrvSubSessionImageHandler::SaveVT: %S"), &buf );

#endif

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

        CleanupStack::PushL( bitMap );

        User::LeaveIfError( bitMap->Duplicate( aImages.iImages[ i ] ) );

        User::LeaveIfError( bitMap->Save( buf ) );

        CleanupStack::PopAndDestroy( bitMap );

        }

    CleanupStack::PopAndDestroy( hbuf );

    _DPRINT( 4, "CPhSrvSubSessionImageHandler::SaveVT>" )        

    }

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

// CPhSrvSubSessionImageHandler::DoLoadVTImagesL

// 

// Loads images.

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

//