/*

* Copyright (c) 2002-2004 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:  ?Description

*

*/

// ========== INCLUDE FILES ===================================================

#include "AiFwTestContentPlugin.h"

#include "AiFwTestDefines.h"

#include "AiFwTestContentModel.h"

#include <aicontentobserver.h>

#include <aipluginsettings.h>

#include <aiutility.h>

// ========== EXTERNAL DATA STRUCTURES ========================================

// ========== EXTERNAL FUNCTION PROTOTYPES ====================================

// ========== CONSTANTS =======================================================

// ========== MACROS ==========================================================

// ========== LOCAL CONSTANTS AND MACROS ======================================

// ========== MODULE DATA STRUCTURES ==========================================

// ========== LOCAL FUNCTION PROTOTYPES =======================================

// ========== FORWARD DECLARATIONS ============================================

// ========== LOCAL FUNCTIONS =================================================

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

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

//

//

//

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

//

CAiFwTestContentPlugin::CAiFwTestContentPlugin()

{}

EXPORT_C CAiFwTestContentPlugin* CAiFwTestContentPlugin::Instance()

    {

    TAny* ptr = Dll::Tls();

    if ( ptr )

		{

    	TAiTestTLSStorage* tlsSet = static_cast<TAiTestTLSStorage*>( ptr );

    	return tlsSet->iContentPlugin;

		}

	return NULL;

    }

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

//

//

//

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

//

void CAiFwTestContentPlugin::ConstructL()

{

    iText = HBufC8::NewL(128);

    iInfo = new (ELeave) TAiPublisherInfo;

    iContent   = AiUtility::CreateContentItemArrayIteratorL(KTestPluginContent);

    iResources = AiUtility::CreateContentItemArrayIteratorL(KTestPluginResources);

    iEvents    = AiUtility::CreateContentItemArrayIteratorL(KTestPluginEvents);

   	TAiTestTLSStorage* tlsSet = TAiTestTLSStorage::CreateInstanceL();

	tlsSet->iContentPlugin = this;

}

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

//

//

//

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

//

CAiFwTestContentPlugin* CAiFwTestContentPlugin::NewL()

{

    CAiFwTestContentPlugin* self = new (ELeave) CAiFwTestContentPlugin;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

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

//

//

//

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

//

CAiFwTestContentPlugin::~CAiFwTestContentPlugin()

{

   	TAiTestTLSStorage::DestroyInstance();

    delete iText;

    iObservers.Close();

    delete iInfo;

    Release( iContent );

    Release( iResources );

    Release( iEvents );

    if( iTicker )

        iTicker->Cancel();

    delete iTicker;

}

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

//

//

//

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

//

TInt CAiFwTestContentPlugin::Callback(TAny* aPtr)

{

    CAiFwTestContentPlugin* plugin = reinterpret_cast<CAiFwTestContentPlugin*> (aPtr);

    plugin->iCounter++;

    plugin->iText->Des().Copy(_L8("Count:"));

    plugin->iText->Des().AppendNum(plugin->iCounter);

    // Notify

    for (TInt i = 0; i < plugin->iObservers.Count(); i++)

    {

        MAiContentObserver* observer = plugin->iObservers[i];

        observer->StartTransaction(0);

        HBufC* value = HBufC::NewLC(plugin->iText->Length());

        value->Des().Copy(*plugin->iText);

        observer->Publish((MAiPropertyExtension&) *plugin, KTestPluginContent[0].id, *value, 0);

        if (plugin->iCounter % 2 == 0)

        {

            observer->Publish((MAiPropertyExtension&) *plugin, KTestPluginContent[1].id, KTestPluginResources[0].id, 0);

        }

        else

        {

            observer->Publish((MAiPropertyExtension&) *plugin, KTestPluginContent[1].id, KTestPluginResources[1].id, 0);

        }

        observer->Commit(0);

        CleanupStack::PopAndDestroy(); // value

    }

    return KErrNone;

}

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

//

//

//

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

//

void CAiFwTestContentPlugin::LoadEngineL(TAiTransitionReason /*aReason*/)

{

    iPluginLoaded = ETrue;

    if( !iTicker )

        {

        iTicker = CPeriodic::NewL(CActive::EPriorityStandard);

        }

}

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

//

//

//

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

//

void CAiFwTestContentPlugin::Resume(TAiTransitionReason aReason)

{

    TRAP_IGNORE( LoadEngineL( aReason ) );

    iPluginResumed = ETrue;

    if( iTicker && !iTicker->IsActive() )

        {

        TCallBack cb(Callback, this);

        iTicker->Start(1000000, 1000000, cb);

        }

}

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

//

//

//

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

//

void CAiFwTestContentPlugin::Suspend(TAiTransitionReason /*aReason*/)

{

    if( iTicker && iTicker->IsActive() )

    {

        iTicker->Cancel();

    }

}

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

//

//

//

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

//

void CAiFwTestContentPlugin::Stop(TAiTransitionReason /*aReason*/)

{

    if( iTicker )

        {

        iTicker->Cancel();

        delete iTicker;

        iTicker = NULL;

        }

}

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

//

//

//

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

//

void CAiFwTestContentPlugin::SubscribeL(MAiContentObserver& aObserver)

{

    return iObservers.AppendL(&aObserver);

}

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

//

//

//

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

//

void CAiFwTestContentPlugin::ConfigureL(RAiSettingsItemArray& aSettings)

    {

    iSettingFound = ETrue;

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

        {

        MAiPluginSettingsItem& item = aSettings[i]->AiPluginSettingsItem();

        if( item.Value().Compare( _L("DesValue") ) == 0 )

            {

            // pass

            if( item.Key() == 1 )

                {

                }

            item.PublisherId();

            }

        /*TRAP_IGNORE(

        item.UpdateFromCenRepL();

        item.SetKey( -1 );

        item.UpdateFromCenRepL();

        item.SetKey( 0 );

        item.SetPublisherId( TUid::Uid( 0 ) );

        item.UpdateFromCenRepL();

        );*/

        }

    aSettings.ResetAndDestroy();

    }

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

//

//

//

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

//

TAny* CAiFwTestContentPlugin::Extension(TUid aUid)

{

    if (aUid == KExtensionUidProperty)

    {

        return static_cast<MAiPropertyExtension*>(this);

    }

    else if (aUid == KExtensionUidEventHandler)

        {

        return static_cast<MAiEventHandlerExtension*>(this);

        }

    return NULL;

}

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

//

//

//

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

//

TAny* CAiFwTestContentPlugin::GetPropertyL(TInt aProperty)

{

    switch (aProperty)

    {

    case EAiPublisherInfo:

        return iInfo;

    case EAiPublisherContent:

        return static_cast<MAiContentItemIterator*>( iContent );

    case EAiPublisherResources:

        return static_cast<MAiContentItemIterator*>( iResources );

    case EAiPublisherEvents:

        return static_cast<MAiContentItemIterator*>( iEvents );

    case EAiContentRequest:

        return static_cast<MAiContentRequest*>(this);

    case EAiResourceRequest:

        return static_cast<MAiContentRequest*>(this);

    }

    User::Leave(KErrNotSupported);

    return NULL;

}

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

//

//

//

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

//

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

    {

    if( aValue )

        {

        switch( aProperty )

            {

            case EAiPublisherInfo:

                {

                const TAiPublisherInfo* info =

                    static_cast<const TAiPublisherInfo*>(aValue);

                iInfo->iUid.iUid = info->iUid.iUid;

                iInfo->iName.Copy( info->iName );

                iInfo->iNamespace.Copy( info->iNamespace );

                break;

                }

            }

        }

    }

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

//

//

//

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

//

void CAiFwTestContentPlugin::HandleEvent(TInt aEvent, const TDesC& aParam)

    {

    if( i2ndEvent )

        {

        return;

        }

    if( aEvent == 3 && aParam.Length() == 0 )

        {

        iEventReceived = ETrue;

        }

    i2ndEvent = ETrue;

    }

TBool CAiFwTestContentPlugin::RefreshContent( TInt aContentId )

    {

    iContentRefreshed = ETrue;

    return ETrue;

    }

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

//

//

//

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

//

EXPORT_C TBool CAiFwTestContentPlugin::ContentRefreshed()

    {

    return iContentRefreshed;

    }

EXPORT_C RPointerArray<MAiContentObserver>& CAiFwTestContentPlugin::Observers()

    {

    return iObservers;

    }

EXPORT_C TBool CAiFwTestContentPlugin::WasLoaded()

    {

    return iPluginLoaded;

    }

EXPORT_C TBool CAiFwTestContentPlugin::WasResumed()

    {

    return iPluginResumed;

    }

EXPORT_C TBool CAiFwTestContentPlugin::WasConfigured()

    {

    return iSettingFound;

    }

EXPORT_C TBool CAiFwTestContentPlugin::EventReceived()

    {

    return iEventReceived;

    }

// ========== OTHER EXPORTED FUNCTIONS ========================================

// End of File.