/*

* Copyright (c) 2005-2007 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: WRT data plug-in publisher

* 

*/

// System includes

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <PUAcodes.hrh>

#include <badesca.h>

#include <fbs.h>

#include <gulicon.h>

#include <AknsSkinInstance.h> 

#include <AknsUtils.h> 

#include <AknsConstants.h>

#include <e32property.h>

// User includes

#include <hspublisherinfo.h>

#include <aicontentobserver.h>

#include <aiutility.h>

#include <aipspropertyobserver.h>

#include <aipluginsettings.h>

#include <activeidle2domainpskeys.h>

#include <debug.h>

#include "wrtdatapluginconst.h"

#include "wrtdatapluginuids.hrh"

#include "wrtdataplugin.h"

#include "wrtdata.h"

// Constants

const TImplementationProxy KImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY( KImplUidDataPlugin, CWrtDataPlugin::NewL ) 

    };

const TInt KTryAgainDelay( 3000000 ); // 3 sec

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

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

// ImplementationGroupProxy

//

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( 

    TInt& aTableCount )

    {

    aTableCount = sizeof( KImplementationTable ) /

        sizeof( TImplementationProxy );

    return KImplementationTable;

    }

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

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

// CWrtDataPlugin::NewL()

//

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

//

CWrtDataPlugin* CWrtDataPlugin::NewL()

    {

    CWrtDataPlugin* self = new (ELeave) CWrtDataPlugin;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWrtDataPlugin::CWrtDataPlugin()

//

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

//

CWrtDataPlugin::CWrtDataPlugin()

    : iNetworkStatus( EUnknown ), iPluginState( EStopped ) 

    {

    }

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

// CWrtDataPlugin::ConstructL()

//

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

//

void CWrtDataPlugin::ConstructL()

    {

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

    iData = CWrtData::NewL( this );

    }

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

// Destructor

// Deletes all data created to heap

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

//

CWrtDataPlugin::~CWrtDataPlugin()

    {

    if ( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        }

    delete iData;

    iObservers.Close();

    Release( iContent );

    iDataArray.ResetAndDestroy();

    if( iContentModel)

        {

        for( TInt i = iDataCount-1;i>=0  ; i-- )

            {

            User::Free((TAny*)iContentModel[i].cid);   

            }

        delete []iContentModel;

        }

    iIconArray.Reset();

    iRfs.Close();

    }

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

// CWrtDataPlugin::Start

//

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

//

void CWrtDataPlugin::Start( TStartReason aReason )

    {

    iPluginState = EStarted;

    if( aReason == ESystemStartup || 

        aReason == EPluginStartup )

        {

        // Publish the initial data

        TRAP_IGNORE( PublishInitialDataL() );

        }

    }

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

// CWrtDataPlugin::Stop

//

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

//

void CWrtDataPlugin::Stop( TStopReason aReason )

    {

    iPluginState = EStopped;

    if( aReason == EPluginShutdown ||

        aReason == ESystemShutdown )

        {

        TRAP_IGNORE(iData->NotifyPublisherL( KDeActive ));

        }

    }

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

// CWrtDataPlugin::Resume

//

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

//

void CWrtDataPlugin::Resume( TResumeReason aReason )

    {

    if ( aReason == EForeground && iPluginState != EStopped )

        {

        iPluginState = EResume;

        TRAP_IGNORE( iData->NotifyPublisherL( KResume ));        

        }    

    }

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

// CWrtDataPlugin::Suspend

//

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

//

void CWrtDataPlugin::Suspend( TSuspendReason aReason )

    {    

    if ( aReason == EBackground && iPluginState != EStopped )

        {

        iPluginState = ESuspend;

        TRAP_IGNORE ( iData->NotifyPublisherL( KSuspend ));        

        }        

    }

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

// CWrtDataPlugin::SetOnline

//

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

//

void CWrtDataPlugin::SetOnline()

    {    

    if ( iPluginState != EStopped )

        {

        iNetworkStatus = EOnline;

        TRAP_IGNORE( iData->NotifyPublisherL( KOnLine ));                

        }

    }

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

// CWrtDataPlugin::SetOffline

//

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

//

void CWrtDataPlugin::SetOffline()

    {

    if ( iPluginState != EStopped )

        {   

        iNetworkStatus = EOffline;

        TRAP_IGNORE( iData->NotifyPublisherL( KOffLine ));

        }

    }

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

// CWrtDataPlugin::SubscribeL

//

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

//

void CWrtDataPlugin::SubscribeL( MAiContentObserver& aObserver )

    {

    iObservers.AppendL( &aObserver );

    }

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

// CWrtDataPlugin::ConfigureL

//

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

//

void CWrtDataPlugin::ConfigureL( RAiSettingsItemArray& aSettings )

    {

    RAiSettingsItemArray contentItemsArr;

    RAiSettingsItemArray configurationItemsArr;

    TInt count( aSettings.Count() );

    for ( TInt i = 0; i < count; i++ )

        {

        MAiPluginSettings* setting( aSettings[i] );

        if( setting->AiPluginItemType() == EAiPluginContentItem )

            {

            contentItemsArr.Append( setting );

            }

        else if( setting->AiPluginItemType() == EAiPluginConfigurationItem )

            {

            configurationItemsArr.Append( setting );

            }

        }

    iDataCount = contentItemsArr.Count();

    // Create the content Model

    HBufC16* contentId = HBufC16::NewLC( 

        KAiContentIdMaxLength + KAiPluginNameMaxLength );

    iContentModel = new TAiContentItem[iDataCount];

    for( TInt i = 0; i < iDataCount; i++ )

        {

        MAiPluginContentItem& contentItem( 

            contentItemsArr[i]->AiPluginContentItem() );

        iContentModel[i].id = i;

        if( contentItem.Type() == KText() )

            {

            // text

            iContentModel[i].type = KAiContentTypeText;

            }

        if( contentItem.Type() == KImage() || 

            contentItem.Type() == KAnimation() )

            {

            // image

            iContentModel[i].type = KAiContentTypeBitmap;

            }

        contentId->Des().Copy( contentItem.Name() );

        contentId->Des().Delete( 0, 

            contentId->Des().LocateReverse( KPluginNameSeprator ) + 1 );

        TInt sizeOfContentId( contentId->Des().Size()+sizeof( wchar_t ) );

        iContentModel[i].cid = 

            static_cast< const wchar_t* >( User::Alloc( sizeOfContentId ) );

        Mem::Copy( ( TAny* )iContentModel[i].cid, 

            contentId->Des().PtrZ(), sizeOfContentId );

        contentId->Des().Delete( 0, contentId->Des().Length() );

        }    

    CleanupStack::PopAndDestroy( contentId );

    iContent = AiUtility::CreateContentItemArrayIteratorL( 

            iContentModel, iDataCount );

    // Configurations 

    iData->ConfigureL( configurationItemsArr );

    // Register for notifications

    iData->RegisterL();

    // Activate the publisher 

    iData->NotifyPublisherL( KActive );

    contentItemsArr.Reset();

    configurationItemsArr.Reset();

    // We own the array so destroy it

    aSettings.ResetAndDestroy();

    }

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

// CWrtDataPlugin::SetProperty

//

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

//

void CWrtDataPlugin::SetProperty( TProperty aProperty, TAny* aAny )

    {

    if (aProperty == ECpsCmdBuffer )

        {   

        iData->SetCommandBuffer( aAny, PublisherInfo().Namespace() );

        }

    }

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

// CWrtDataPlugin::GetProperty

//

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

//

TAny* CWrtDataPlugin::GetProperty( TProperty aProperty )

    {

    if ( aProperty == EPublisherContent )

        {

        return static_cast< MAiContentItemIterator* >( iContent );      

        }

    return NULL;

    }

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

// CWrtDataPlugin::HandleEvent

//

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

//

void CWrtDataPlugin::HandleEvent( const TDesC& aEventName, 

    const TDesC& aParam )

    {

    TRAP_IGNORE( iData->ExecuteActionL( aEventName , aParam ) );    

    }

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

// CWrtDataPlugin::IsActive

//

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

//

TBool CWrtDataPlugin::IsActive() const

    {

    return iPluginState == EResume;

    }

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

// CWrtDataPlugin::IsStopped

//

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

//

TBool CWrtDataPlugin::IsStopped() const

    {

    return iPluginState == EStopped;

    }

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

// CWrtDataPlugin::Data

//

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

//

CWrtData* CWrtDataPlugin::Data() const

    {

    return iData;

    }

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

// CWrtDataPlugin::NetworkStatus

//

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

//

CWrtDataPlugin::TPluginNetworkStatus CWrtDataPlugin::NetworkStatus() const

    {

    return iNetworkStatus;

    }

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

// CWrtDataPlugin::GetIdL

// Gets the id of a content  

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

//

TInt CWrtDataPlugin::GetIdL( TDesC16& aObjectId)

    {

    TInt id = KErrNotFound;

    HBufC16* objectId = HBufC16::NewLC( KAiContentIdMaxLength );

    for( TInt i = 0;i<  iDataCount; i++ )

        {

         objectId->Des().Copy((TUint16*)iContentModel[i].cid);

         if( aObjectId == objectId->Des() )

             {

             id = iContentModel[i].id;

             break;

             }

        }

    CleanupStack::PopAndDestroy( objectId );

    return id;

    }

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

// CWrtDataPlugin::GetTypeL

// Gets type of a content

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

//

void CWrtDataPlugin::GetTypeL(TDesC16& aObjectId, TDes16& aType )

    {

    HBufC16* objectId = HBufC16::NewLC( KAiContentIdMaxLength );

    for( TInt i = 0;i<  iDataCount; i++ )

        {

        objectId->Des().Copy((TUint16*)iContentModel[i].cid);

         if( aObjectId == objectId->Des() )

             {

             if( iContentModel[i].type ==  KAiContentTypeText)

                 {

                 aType.Copy( KText );

                 }

             else if( iContentModel[i].type == KAiContentTypeBitmap)

                 {

                 aType.Copy( KImage );

                 }

             break;

             }

        }

    CleanupStack::PopAndDestroy( objectId );

    }

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

//Refresh a specific image or text in the widget

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

//

void CWrtDataPlugin::RefreshL( TDesC16& aOperation, CLiwDefaultMap* aDataMap )

    {

    __PRINTS("*** CWrtDataPlugin::RefreshL ***");

    __PRINT( __DBG_FORMAT( "* Publisher name: %S, uid: 0x%x, operation: %S" ),          

        &PublisherInfo().Name(), PublisherInfo().Uid().iUid, &aOperation ); 

    TInt observers( iObservers.Count() );        

    TInt transactionId = reinterpret_cast<TInt>( this );

    for ( TInt obsIndex = 0; obsIndex < observers; obsIndex++ )

        {

        MAiContentObserver* observer = iObservers[obsIndex];

        if ( observer->StartTransaction( transactionId ) == KErrNone )       

            {

            if( ( aOperation == KOperationUpdate 

                  || aOperation == KOperationAdd )

                  && aDataMap )

                {

                iData->PublishL( observer, aDataMap );

                }

            else if ( aOperation == KOperationDelete )

                {

                Clean( observer , EImage1 ) ;

                }

            observer->Commit( transactionId );

            }

        // Relese memory of the published text

        iDataArray.ResetAndDestroy();

        // Release memory of the published icons

        iIconArray.Reset();

        }

    __PRINTS("*** CWrtDataPlugin::RefreshL - done ***");        

    }

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

// Publish a specific text of the widget  

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

//

void CWrtDataPlugin::PublishTextL(MAiContentObserver* aObserver, 

        TInt aContentId, const TDesC16& aContentValue)

    {

    if ( aObserver->CanPublish( *this,  aContentId  ,  aContentId  ) )

        {

        if( aContentValue.Length() > 0 )

            {

            HBufC* contentText = HBufC::NewLC(aContentValue.Size());

            TPtr16 cDes = contentText->Des();

            cDes.Copy(aContentValue);

            aObserver->Publish( *this, aContentId, cDes, aContentId );  

            iDataArray.AppendL( contentText );

            CleanupStack::Pop( contentText );

            }

        else

            {

            aObserver->Clean( *this, aContentId, aContentId );

            }

        }

    }

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

// Publish a specific image of the widget  

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

//

void CWrtDataPlugin::PublishImageL(MAiContentObserver* aObserver,

		TContentItem aContentId, const TDesC16& aPath )

    {

    TInt err = KErrNone;

    TAknsItemID iconId;

    iconId.iMajor=0;

    iconId.iMinor=0;

    TInt bitmapId(0);