/*

* ==============================================================================

*  Name        : %name: previewprovider.cpp %

*  Part of     : Hg fast swap preview provider plugin

*  Description : Preview provider API

*  Version     : %version: sa1spcx1#3 %

*

*  Copyright (c) 2008 Nokia Corporation.

*  This material, including documentation and any related

*  computer programs, is protected by copyright controlled by

*  Nokia Corporation. All rights are reserved. Copying,

*  including reproducing, storing, adapting or translating, any

*  or all of this material requires the prior written consent of

*  Nokia Corporation. This material also contains confidential

*  information which may not be disclosed to others without the

*  prior written consent of Nokia Corporation.

* ==============================================================================

*/

#include "hgpreviewprovider.h"

#include "hgpreviewobserver.h"

#include "previewmsg.h"

#include "previewproviderlogging.h"

#include <w32std.h>

#include <s32mem.h>

#include <e32property.h>

#define SZ( x ) ( sizeof( x ) / sizeof( TInt ) )

// CONSTANTS

// Publish & subscribe UID (akncapserver.exe SID so that it can define the keys)

const TUid KPSUidPreviewProvider = { 0x10207218 };

// P&S keys

const TUint32 KPSKeyWgId = 0x20016BE1;

const TUint32 KPSKeyFbsBitmapId = 0x20016BE2;

const TUint32 KPSKeyOperation = 0x20016BE3;

/**

 * Operation which will be done after P&S keys have changed.

 */

enum TPreviewOperation

    {

    EOperationNone,

    EOperationUnregister,

    EOperationBitmapUpdated

    };

/**

 * CPropertyListener

 */

NONSHARABLE_CLASS( CPropertyListener ) : public CActive

    {

public:

    static CPropertyListener* NewL( MHgFastSwapPreviewObserver& aObs );

    virtual ~CPropertyListener();

protected:

    CPropertyListener( MHgFastSwapPreviewObserver& aObs );

    void ConstructL();  

private: // From CActive

    void RunL();

    void DoCancel();

private:    

    void ReadPropertiesL();

    void DefinePropertyL( TInt aPSKey ); 

    void Subscribe();

private:

    MHgFastSwapPreviewObserver& iObs;

    RProperty iProperty;

    TInt iWgId;

    TInt iFbsBitmapId;

    TPreviewOperation iOperation;

    };

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

// CPropertyListener::~CPropertyListener

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

//

CPropertyListener::~CPropertyListener()

    {

    Cancel();

    iProperty.Close();

    }

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

// CPropertyListener::CPropertyListener

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

//

CPropertyListener::CPropertyListener( MHgFastSwapPreviewObserver& aObs ) : 

    CActive( CActive::EPriorityHigh ), iObs( aObs )

    {

    }

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

// CPropertyListener::NewL

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

//

CPropertyListener* CPropertyListener::NewL( MHgFastSwapPreviewObserver& aObs )

    {

    CPropertyListener* self = new ( ELeave ) CPropertyListener( aObs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

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

// CPropertyListener::RunL

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

//

void CPropertyListener::RunL()

    {

    // Resubscribe before processing new value to prevent missing updates

    Subscribe();

    // Read all properties to member variables

    ReadPropertiesL();

    // Do the callback

    switch( iOperation )

        {

        case EOperationUnregister:

            {

            iObs.HandleFswPpApplicationUnregistered( iWgId );

            break;            

            }        

        case EOperationBitmapUpdated:

            {

            iObs.HandleFswPpApplicationChange( iWgId, iFbsBitmapId );

            break;

            }

        default:

            break;

        }

    }

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

// CPropertyListener::DoCancel

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

//

void CPropertyListener::DoCancel()

    {

    iProperty.Cancel();

    }

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

// CPropertyListener::ReadProperties

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

//

void CPropertyListener::ReadPropertiesL()

    {

    // Read all properties

    User::LeaveIfError( iProperty.Get( KPSUidPreviewProvider, KPSKeyWgId, iWgId ) );

    User::LeaveIfError( iProperty.Get( KPSUidPreviewProvider, KPSKeyFbsBitmapId, iFbsBitmapId ) );

    TInt operation( 0 );

    User::LeaveIfError( iProperty.Get( KPSUidPreviewProvider, KPSKeyOperation, operation ) );

    iOperation = static_cast<TPreviewOperation>( operation );    

    }

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

// CPropertyListener::DefinePropertyL

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

//

void CPropertyListener::DefinePropertyL( TInt aPSKey )

    {

    TInt err = RProperty::Define( KPSUidPreviewProvider, aPSKey, RProperty::EInt );

    // Don't mind the already exists error

    if ( err != KErrAlreadyExists && err != KErrPermissionDenied )

        {

        User::LeaveIfError( err );

        }    

    }

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

// CPropertyListener::Subscribe

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

//

void CPropertyListener::Subscribe()

    {

    iProperty.Subscribe( iStatus );

    SetActive();  

    }

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

// CPropertyListener::ConstructL

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

//

void CPropertyListener::ConstructL()

    {

    HGLOG_CONTEXT( ConstructL, HGLOG_LOCAL );

    HGLOG_IN();

    DefinePropertyL( KPSKeyWgId );

    DefinePropertyL( KPSKeyFbsBitmapId );

    DefinePropertyL( KPSKeyOperation );

    User::LeaveIfError( iProperty.Attach( KPSUidPreviewProvider, KPSKeyWgId ) );

    CActiveScheduler::Add( this );

    // initial subscription

    Subscribe();

    HGLOG_OUT();    

    }

/**

 * CHgFastSwapPreviewProviderClient

 */

NONSHARABLE_CLASS( CHgFastSwapPreviewProviderClient ) : public CWsGraphic

    {

public:

    CHgFastSwapPreviewProviderClient( MHgFastSwapPreviewObserver& aObs );

    void ConstructL();

    void Register( TInt aWgId );

    void Unregister( TInt aWgId );

    void ChangeScreen( TInt aScreenNo );

    void SetPreviewParam( const TSize& aSize, TDisplayMode aMode );

    void TakePreview();

    void AckPreview( TInt aPreviewId );

    virtual ~CHgFastSwapPreviewProviderClient();

private:

    void HandleMessage( const TDesC8& aData );

    void OnReplace();

private:

    void DoHandleMessageL( const TDesC8& aData );

    void SetProperties( TInt aHandle, TInt aWgId, TInt aOp );    

private:

    MHgFastSwapPreviewObserver& iObs;

    CPropertyListener* iListener;

    };

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

// CHgFastSwapPreviewProviderClient::CHgFastSwapPreviewProviderClient

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

//

CHgFastSwapPreviewProviderClient::CHgFastSwapPreviewProviderClient(

        MHgFastSwapPreviewObserver& aObs ) : iObs( aObs )

    {

    }

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

// CHgFastSwapPreviewProviderClient::~CHgFastSwapPreviewProviderClient

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

//

CHgFastSwapPreviewProviderClient::~CHgFastSwapPreviewProviderClient()

    {

    delete iListener;

    }

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

// CHgFastSwapPreviewProviderClient::ConstructL

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

//

void CHgFastSwapPreviewProviderClient::ConstructL()

    {

    HGLOG_CONTEXT( ConstructL, HGLOG_LOCAL );

    HGLOG_IN();

    const TUid id = { 0x20016BEC };

    BaseConstructL( id, KNullDesC8 );

    iListener = CPropertyListener::NewL( iObs );

    HGLOG_OUT();        

    }    

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

// CHgFastSwapPreviewProviderClient::Register

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

//    

void CHgFastSwapPreviewProviderClient::Register( TInt aWgId )

    {

    HGLOG_CONTEXT( Register, HGLOG_LOCAL );

    HGLOG_IN();

    const TInt msg[] = {

        NPreviewMsg::ERegister,

        aWgId

        };

    TPckgC<TInt[SZ(msg)]> buf(msg);

    SendMessage(buf);

    Flush();

    HGLOG_OUT();

    }

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

// CHgFastSwapPreviewProviderClient::Unregister

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

//    

void CHgFastSwapPreviewProviderClient::Unregister( TInt aWgId )

    {

    HGLOG_CONTEXT( Unregister, HGLOG_LOCAL );

    HGLOG_IN();

    const TInt msg[] = {

        NPreviewMsg::EUnregister,

        aWgId

        };

    TPckgC<TInt[SZ(msg)]> buf(msg);

    SendMessage(buf);

    Flush();

    HGLOG_OUT();

    }

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

// CHgFastSwapPreviewProviderClient::ChangeScreen

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

//    

void CHgFastSwapPreviewProviderClient::ChangeScreen( TInt aScreenNo )

    {

    HGLOG_CONTEXT( ChangeScreen, HGLOG_LOCAL );

    HGLOG_IN();

    const TInt msg[] = {

        NPreviewMsg::EChangeScreen,

        aScreenNo

        };

    TPckgC<TInt[SZ(msg)]> buf(msg);

    SendMessage(buf);

    Flush();

    HGLOG_OUT();     

    }

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

// CHgFastSwapPreviewProviderClient::SetPreviewParam

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

//    

void CHgFastSwapPreviewProviderClient::SetPreviewParam(const TSize& aSize,

        TDisplayMode aMode)

    {

    HGLOG_CONTEXT( SetPreviewParam, HGLOG_LOCAL );

    HGLOG_IN();

    const TInt msg[] = {

        NPreviewMsg::ESetPreviewParam,

        aSize.iWidth,

        aSize.iHeight,

        static_cast<TInt>(aMode)

        };

    TPckgC<TInt[SZ(msg)]> buf(msg);

    SendMessage(buf);

    Flush();

    HGLOG_OUT();

    }

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

// CHgFastSwapPreviewProviderClient::TakePreview 

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

//    

void CHgFastSwapPreviewProviderClient::TakePreview()

    {

    HGLOG_CONTEXT( TakePreview, HGLOG_LOCAL );

    HGLOG_IN();

    TPckgC<TInt> buf(NPreviewMsg::ETakePreview);

    SendMessage(buf);

    Flush();

    HGLOG_OUT();      

    }

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

// CHgFastSwapPreviewProviderClient::AckPreview 

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

//

void CHgFastSwapPreviewProviderClient::AckPreview( TInt aPreviwId )

    {

    HGLOG_CONTEXT( TakePreview, HGLOG_LOCAL );

    HGLOG_IN();

    const TInt msg[] = { NPreviewMsg::EAckPreviewReady,

                         aPreviwId };

    TPckgC<TInt[SZ(msg)]> buf(msg);

    SendMessage(buf);

    Flush();

    HGLOG_OUT();

    }

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

// CHgFastSwapPreviewProviderClient::HandleMessage

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

//    

void CHgFastSwapPreviewProviderClient::HandleMessage( const TDesC8& aData )

    {

    TRAP_IGNORE(DoHandleMessageL(aData));

    }

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

// CHgFastSwapPreviewProviderClient::DoHandleMessageL

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

//

void CHgFastSwapPreviewProviderClient::DoHandleMessageL( const TDesC8& aData )

    {

    HGLOG_CONTEXT( DoHandleMessageL, HGLOG_LOCAL );

    HGLOG_IN();

    RDesReadStream in( aData );

    TInt message = in.ReadInt32L();

    switch ( message )

        {

        case NPreviewMsg::EPreviewReady:

            {

            const TInt id = in.ReadInt32L();

            const TInt handle = in.ReadInt32L();    

            SetProperties( handle, id, EOperationBitmapUpdated );

            }

            break;

        case NPreviewMsg::EUnregisterReady:

            {

            const TInt id = in.ReadInt32L();

            const TInt handle = in.ReadInt32L();

            SetProperties( handle, id, EOperationUnregister );

            }

            break;

        }

    HGLOG_OUT();

    }

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

// CHgFastSwapPreviewProviderClient::SetProperties

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

//

void CHgFastSwapPreviewProviderClient::SetProperties(TInt aHandle, TInt aWgId,

        TInt aOp)

    {

    // Notify CPropertyListener via P&S

    RProperty::Set( KPSUidPreviewProvider, KPSKeyFbsBitmapId, aHandle );

    RProperty::Set( KPSUidPreviewProvider, KPSKeyOperation, aOp );

    // KPSKeyWgId should be notified first since that is being listened 

    // by CPropertyListener 

    RProperty::Set( KPSUidPreviewProvider, KPSKeyWgId, aWgId );    

    }

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

// CHgFastSwapPreviewProviderClient::OnReplace

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

//

void CHgFastSwapPreviewProviderClient::OnReplace()

    {

    }

/////////////////////////////////////////////////////////////////////////////

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

// CHgFastSwapPreviewProvider::NewL

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

//

EXPORT_C CHgFastSwapPreviewProvider* CHgFastSwapPreviewProvider::NewL(

        MHgFastSwapPreviewObserver& aObs)

    {

    CHgFastSwapPreviewProvider* p = new (ELeave) CHgFastSwapPreviewProvider();

    CleanupStack::PushL( p );

    p->ConstructL( aObs );

    CleanupStack::Pop( p );

    return p;

    }

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

// CHgFastSwapPreviewProvider::~CHgFastSwapPreviewProvider

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

//    

EXPORT_C CHgFastSwapPreviewProvider::~CHgFastSwapPreviewProvider()

    {

    if ( iClient )

        {

        iClient->Destroy();

        }

    delete iClient;

    }

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

// CHgFastSwapPreviewProvider::Register

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

//    

EXPORT_C TInt CHgFastSwapPreviewProvider::Register( TInt aWgId )

    {

    iClient->Register( aWgId );

    return KErrNone;

    }

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

// CHgFastSwapPreviewProvider::Unregister

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

//    

EXPORT_C TInt CHgFastSwapPreviewProvider::Unregister( TInt aWgId )    

    {

    iClient->Unregister( aWgId );

    return KErrNone;

    }

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

// CHgFastSwapPreviewProvider::ChangeScreen

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

//    

EXPORT_C TInt CHgFastSwapPreviewProvider::ChangeScreen( TInt aScreenId )

    {

    iClient->ChangeScreen( aScreenId );

    return KErrNone;

    }    

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

// CHgFastSwapPreviewProvider::SetPreviewParam

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

//

EXPORT_C TInt CHgFastSwapPreviewProvider::SetPreviewParam(const TSize& aSize,

        TDisplayMode aMode)

    {

    HGLOG_CONTEXT( SetPreviewParam, HGLOG_LOCAL );

    HGLOG_IN();

    TInt error( KErrNone );

    if ( aMode == ENone || aMode == EColor64K )

        {

        iClient->SetPreviewParam( aSize, aMode );