/*

* 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:

* Profile plug-in publisher

*

*/

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <aicontentobserver.h>

#include <aiutility.h>

#include <aipspropertyobserver.h>

#include <PUAcodes.hrh>

#include <aipluginsettings.h>

#include <badesca.h>

#include <fbs.h>

#include <gulicon.h>

#include <AknsSkinInstance.h> 

#include <AknsUtils.h> 

#include <AknsConstants.h>

#include <e32property.h>

#include <activeidle2domainpskeys.h>

#include "wrtdatapluginconst.h"

#include "wrtdatapluginuids.hrh"

#include "wrtdataplugin.h"

#include "wrtdata.h"

// CONST CLASS VARIABLES

const TImplementationProxy KImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY( KImplUidDataPlugin, CWrtDataPlugin::NewL ) 

    };

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

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

// Constructs and returns an application object.

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount )

    {

    aTableCount = sizeof( KImplementationTable ) /

        sizeof( TImplementationProxy );

    return KImplementationTable;

    }

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

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

// Symbian 2nd phase constructor can leave

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

//

CWrtDataPlugin* CWrtDataPlugin::NewL()

    {

    CWrtDataPlugin* self = new (ELeave) CWrtDataPlugin;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Default constructor

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

//

CWrtDataPlugin::CWrtDataPlugin()

    {

    }

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

// Symbian 2nd phase constructor can leave

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

//

void CWrtDataPlugin::ConstructL()

    { 

    iInfo.iUid.iUid = WRTDP_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_DATAPLUGIN; 

    iPluginState = ENone;

    iHSForeGround = EFalse;

    iKeyLockOn = EFalse;

    iNetworkStatus = EUnknown;

    iData = CWrtData::NewL(this);

    }

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

// Destructor

// Deletes all data created to heap

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

//

CWrtDataPlugin::~CWrtDataPlugin()

    {

    // deactivate the publishers

    if( iData )

        {

        if ( iPluginState != EInActive )

        	{

        	TRAP_IGNORE(iData->DeActivateL());

        	}

        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();

    }

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

// From class CAiContentPublisher

// Plug-in is requested to unload its engines due backup operation

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

//

void CWrtDataPlugin::Stop( TAiTransitionReason aReason )

    {

    if( iPluginState == EResume )

        {

        Suspend( aReason );

        }

    }

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

// From class CAiContentPublisher

// Plug-in is instructed that it is allowed to consume CPU resources

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

//

void CWrtDataPlugin::Resume( TAiTransitionReason aReason )

    {

    TRAP_IGNORE( DoResumeL( aReason ) ); 

    }

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

// From class CAiContentPublisher

// Plug-in is instructed that it is not allowed to consume CPU resources

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

//

void CWrtDataPlugin::Suspend( TAiTransitionReason aReason )

    {

    switch( aReason )

        case EAiKeylockEnabled:

        default :

    }

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

// From class CAiContentPublisher

// The plug-in MUST maintain a registry of subscribers and send 

// notification to all of them whenever the state changes or new content

// is available

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

//

void CWrtDataPlugin::SubscribeL( MAiContentObserver& aObserver )

    { 

    iObservers.AppendL( &aObserver );

    }

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

// From class CAiContentPublisher

// Plug-ins take ownership of the settings array, so it must either

// store it in a member or free it.

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

//

void CWrtDataPlugin::ConfigureL( RAiSettingsItemArray& aSettings )

    {

    if( iDataCount > 0 )

        {

        // We own the array so destroy it

         aSettings.ResetAndDestroy();

         return;

        }

    RAiSettingsItemArray contentItemsArr;

    RAiSettingsItemArray configurationItemsArr;

    RAiSettingsItemArray settingItemsArr;

    TInt count = aSettings.Count();

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

        {

        MAiPluginSettings* pluginSetting = aSettings[i];

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

            {

            contentItemsArr.Append(pluginSetting);

            }

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

            {

            configurationItemsArr.Append(pluginSetting);

            }

        else 

            {

            settingItemsArr.Append(pluginSetting);

            }

        }

    iDataCount = contentItemsArr.Count();

    if(iDataCount > 0 )

        {

        // 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;

                {

                // text

                iContentModel[i].type = KAiContentTypeText;

                {

                // 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);

        iPluginState = ESuspend;

        // Register for notifications

        iData->RegisterL();

        // Activate the publisher 

        iData->ActivateL();

        }

    settingItemsArr.Reset();

    contentItemsArr.Reset();

    configurationItemsArr.Reset();

       // We own the array so destroy it

    aSettings.ResetAndDestroy();

    // publish the initial data

    PublishL();

    }

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

// From class CAiContentPublisher

// Returns the extension interface. Actual type depends on the passed 

// aUid argument.

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

//

TAny* CWrtDataPlugin::Extension( TUid aUid )

    {    

    if ( aUid == KExtensionUidProperty )

        return static_cast<MAiPropertyExtension*>( this );

    else if (aUid == KExtensionUidEventHandler)

        return static_cast<MAiEventHandlerExtension*>( this );

    else

        return NULL;

    }

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

// From class MAiPropertyExtension

// Read property of publisher plug-in.

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

//

TAny* CWrtDataPlugin::GetPropertyL( TInt aProperty )

    {

    TAny* property = NULL;

    switch ( aProperty )

        {

    case EAiPublisherInfo:

        {

         property = static_cast<TAiPublisherInfo*>( &iInfo );

        break;  

        }       

    case EAiPublisherContent:

        {

        property = static_cast<MAiContentItemIterator*>( iContent );

        break;    

        }        

    default:

        break;

        }

    return property;

    }

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

// From class MAiPropertyExtension

// Write property value to optimize the content model.

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

//

void CWrtDataPlugin::SetPropertyL( TInt aProperty, TAny* aValue )

    {  

    switch ( aProperty )

        {

        }

    }

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

// From class MAiEventHandlerExtension.

// Handles an event sent by the AI framework.

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

//

void CWrtDataPlugin::HandleEvent( TInt /*aEvent*/, const TDesC& /*aParam*/ )

    // This is not as there is no event id to retrieve in this dynamic plugin. 

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

// From class MAiEventHandlerExtension.

// Handles an event sent by the AI framework.

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

//

void CWrtDataPlugin::HandleEvent( const TDesC& aEventName, const TDesC& aParam )

    {

    // We have no way of reporting errors to framework so just ignore them.

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

    }

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

// From class MAiEventHandlerExtension.

// Invoked by the framework for querying if plugin has menu item

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

//

TBool CWrtDataPlugin::HasMenuItem( const TDesC16& aMenuItem )

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

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

//

    {

    }

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

// Is plugin active to publish the data 

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

//

TBool CWrtDataPlugin::IsActive()

    {

    return (iPluginState == EResume );

    }