/*

* Copyright (c) 2004-2005 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:  TPhoneServer interface for image handling.

*

*/

// INCLUDES

#include    <e32std.h>

#include    <e32base.h>

#include    <fbs.h>

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

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

// RPhCltImageHandler::RPhCltImageHandler

// 

// C++ constructor can NOT contain any code, that might leave.

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

//

RPhCltImageHandler::RPhCltImageHandler()

:   RSubSessionBase()

    {

    }

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

// RPhCltImageHandler::Open

// 

// Open subsession to Phone Server.

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

//

TInt RPhCltImageHandler::Open( RPhCltServer& aServer )

    {

    __ASSERT_ALWAYS( aServer.Handle(), User::Panic( 

            KPhClientPanicCategory, 

            EPhCltClientSidePanicNullHandle ) );

    return CreateSubSession( 

        aServer, 

        EPhoneServerImageHandlerSubSessionOpen, 

        TIpcArgs() );

    }

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

// RPhCltImageHandler::Close

// 

// Close subsession.

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

//

void RPhCltImageHandler::Close()

    {

    iVTBitMaps.ResetAndDestroy();

    iOperatorLogos.ResetAndDestroy();

    CloseSubSession( EPhoneServerImageHandlerSubSessionClose );

    }

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

// RPhCltImageHandler::SaveImages

// 

// Saves images to Phoneserver.

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

//

TInt RPhCltImageHandler::SaveImages( CPhCltImageParams& aParams )

    {

    __ASSERT_ALWAYS( 

        SubSessionHandle(), User::Panic( 

            KPhClientPanicCategory, EPhCltClientSidePanicNullHandle ) );

    return SendReceive( 

        EPhoneServerImageHandlerSubSessionSave, 

        TIpcArgs( 

            &aParams.Images()) );

    }     

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

// RPhCltImageHandler::LoadImages

// 

// Loads images from Phoneserver.

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

//

TInt RPhCltImageHandler::LoadImages( CPhCltImageParams*& aParams )

    {

    __ASSERT_ALWAYS( 

        SubSessionHandle(), User::Panic( 

            KPhClientPanicCategory, EPhCltClientSidePanicNullHandle ) );

    const TInt ret = SendReceive( EPhoneServerImageHandlerSubSessionLoad, 

        TIpcArgs( &aParams->Images() ) );

    // No point in commiting if failed.

    if ( ret != KErrNone )

        {

        return ret;

        }

    return FinalizeLoad( aParams->Images() );

    }

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

// RPhCltImageHandler::FinalizeLoad

// 

// Duplicates loaded images, and commits transaction.

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

//    

TInt RPhCltImageHandler::FinalizeLoad( TPckgBuf< TPhCltImageArray >& aImages )

    {

    TRAPD( err, 

        {

        switch( aImages.operator()().iType )

            {

            case EPhCltTypeVTStill:

            case EPhCltTypeVTDefault:

                CopyStillsL( aImages.operator()() );

                break;

            case EPhCltTypeOperatorLogo:

                CopyLogosL( aImages.operator()() );

                break;

            default:

                break;

            }

        } );

    // Must release in any case

    const TInt ret = SendReceive( EPhoneServerImageHandlerSubSessionCommitLoad, 

        TIpcArgs( &aImages ) );

    return err != KErrNone ? err : ret;

    }

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

// RPhCltImageHandler::CopyLogos

// 

// Replaces / appends a new logo.

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

//    

void RPhCltImageHandler::CopyLogosL( TPhCltImageArray& aImages )

    {

    TBool found( EFalse );

    CFbsBitmap* bitMap = 

        CreateBitMapL( aImages.iImages[ EPhCltExtOperatorLogoIndex ] );

    // Check if there is one stored already, replace handle if so.

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

        {

        if ( aImages.iImages[ EPhCltExtCountryCodeIndex ] == 

            iOperatorLogos[ i ]->iCountryCode && 

            aImages.iImages[ EPhCltExtNetworkCodeIndex ] == 

            iOperatorLogos[ i ]->iNetworkCode && 

            aImages.iImages[ EPhCltExtLogoTypeIndex ] == 

            iOperatorLogos[ i ]->iLogoType            

             )

            {

            delete iOperatorLogos[ i ]->iBitmap;

            iOperatorLogos[ i ]->iBitmap = bitMap;

            found = ETrue;

            break;

            }

        }

    // Else add a new one.

    if ( !found )

        {

        CPhCltOperatorLogoContainer* logo = 

            new (ELeave)CPhCltOperatorLogoContainer(

            aImages.iImages[ EPhCltExtCountryCodeIndex ], 

            aImages.iImages[ EPhCltExtNetworkCodeIndex ],

            ( TPhCltExtOperatorLogoType )

            aImages.iImages[ EPhCltExtLogoTypeIndex ],

            bitMap );

        }

    }

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

// RPhCltImageHandler::CopyStillsL

// 

// Creates new duplicates of still images.

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

//   

void RPhCltImageHandler::CopyStillsL( TPhCltImageArray& aImages ) 

    {

    // Remove all first.

    iVTBitMaps.ResetAndDestroy();

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

        {

        CFbsBitmap* bitMap = 

            CreateBitMapL( aImages.iImages[ i ] );

        }

    }

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

// RPhCltImageHandler::CreateBitMapL

// 

// Creates new duplicate of still image.

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

//   

CFbsBitmap* RPhCltImageHandler::CreateBitMapL( const TInt aHandle )

    {

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

    CleanupStack::PushL( bitMap );

    User::LeaveIfError( bitMap->Duplicate( aHandle ) );

    CleanupStack::Pop( bitMap );

    return bitMap;

    }

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

// RPhCltImageHandler::SaveVtImage

// 

// Saves VT Image.

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

//   

void RPhCltImageHandler::SaveVtImage( 

    TRequestStatus& aStatus, 

    const TDesC& aFilePath )

    {

    __ASSERT_ALWAYS( 

        SubSessionHandle(), User::Panic( 

            KPhClientPanicCategory, EPhCltClientSidePanicNullHandle ) );

    const TPtrC8 ptr8( reinterpret_cast<const TUint8*> ( aFilePath.Ptr() ), 

        aFilePath.Size() );

    TIpcArgs args( &ptr8 );

    SendReceive( 

        EPhoneServerSaveVtImage,

        args,

        aStatus );

    }

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

// RPhCltImageHandler::CancelSaveVtImage

// 

// 

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

//   

void RPhCltImageHandler::CancelSaveVtImage()

    {

    SendReceive( EPhoneServerSaveVtImageCancel );

    }

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

// RPhCltImageHandler::OpenVtImage

// 

// Opens VT Image file.

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

//   

TInt RPhCltImageHandler::OpenVtImage( 

    TInt& aFileHandle,

    const TBool aOpenDefault )

    {

    __ASSERT_ALWAYS( 

        SubSessionHandle(), User::Panic( 

            KPhClientPanicCategory, EPhCltClientSidePanicNullHandle ) );

    TPckg<TInt> pckg1( aFileHandle );

    TPckg<TBool> pckg2( aOpenDefault );

    TIpcArgs args( &pckg1, &pckg2 );

    return SendReceive(

        EPhoneServerOpenVtImage, args );

    }

// End of File