/*
* ==============================================================================
*  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 );        
        }
    else
        {
        error = KErrNotSupported;
        }
   
    HGLOG_OUT();
    return error;
    }

// --------------------------------------------------------------------------
// CHgFastSwapPreviewProvider::TakePreview
// --------------------------------------------------------------------------
//    
EXPORT_C TInt CHgFastSwapPreviewProvider::TakePreview()
    {
    // Reset timer for screensaver (dismiss screensaver)
    User::ResetInactivityTime(); 
           
    iClient->TakePreview();
    return KErrNone;
    }

// --------------------------------------------------------------------------
// CHgFastSwapPreviewProvider::AckPreview
// --------------------------------------------------------------------------
//
EXPORT_C void CHgFastSwapPreviewProvider::AckPreview( TInt aPreviewId )
    {
    iClient->AckPreview( aPreviewId );
    }

// --------------------------------------------------------------------------
// CHgFastSwapPreviewProvider::CHgFastSwapPreviewProvider
// --------------------------------------------------------------------------
//    
CHgFastSwapPreviewProvider::CHgFastSwapPreviewProvider()
    {
    }

// --------------------------------------------------------------------------
// CHgFastSwapPreviewProvider::ConstructL
// --------------------------------------------------------------------------
//    
void CHgFastSwapPreviewProvider::ConstructL( MHgFastSwapPreviewObserver& aObs )
    {
    HGLOG_CONTEXT( ConstructL, HGLOG_LOCAL );
    HGLOG_IN();
    
    iClient = new ( ELeave ) CHgFastSwapPreviewProviderClient( aObs );
    iClient->ConstructL();
    
    HGLOG_OUT();
    }

// End of file