/*
* Copyright (c) 2005-2006 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:  Plug-in main class
*
*/


#include <ecom/implementationproxy.h>
#include <centralrepository.h>

#include <aicontentobserver.h>
#include <aipluginsettings.h>

#include <platform/mw/aiscutuids.hrh>
#include "aiscutpluginprivatecrkeys.h"
#include "aiscutdefs.h"
#include "aiscutcontentmodel.h"
#include "caiscutplugin.h"
#include "caiscutengine.h"
#include "aiscutfactory.h"
#include "caiscutshortcut.h"

#include "debug.h"

const TImplementationProxy KImplementationTable[] =
{
    IMPLEMENTATION_PROXY_ENTRY(KImplUidScutPlugin, CAiScutPlugin::NewL)
};

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

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CAiScutPlugin::CAiScutPlugin()
{
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::ConstructL()
{
    // Initialize the info which the fw uses to identify the plug-in.
    // Fill in only the uid at this point, the fw will send this back with the
    // name filled in later through SetPropertyL().
    iInfo.iUid.iUid = AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_SCUTPLUGIN;

    iContent = AiUtility::CreateContentItemArrayIteratorL(KAiScutContent);
    iResources = AiUtility::CreateContentItemArrayIteratorL(KAiScutResources);
    iEvents = AiUtility::CreateContentItemArrayIteratorL(KAiScutEvents);

    CRepository* repository = NULL;
    TRAP_IGNORE(repository = CRepository::NewL(KCRUidShortcutItems));
    // No leaving code here since 'repository' is not in cleanup stack.
    if (repository)
    {
        // A theme might not contain any publishable shortcuts at all, only
        // locked ones. To take this into account we must always delete old
        // theme-default settings to make sure the engine won't create any
        // unwanted shortcut objects. Any errors that might happen during
        // deletion are ignored to make sure the plug-in is kept alive.
        TUint32 errorKey;

        repository->Delete(KScutCenRepKeyThemeDefault, KScutCenRepKeyMask, errorKey);
    }
    delete repository;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CAiScutPlugin* CAiScutPlugin::NewL()
{
    CAiScutPlugin* self = new (ELeave) CAiScutPlugin;
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CAiScutPlugin::~CAiScutPlugin()
{
    TRAP_IGNORE( DeleteDefaultShortcutsL() );
    Release(iContent);
    Release(iResources);
    Release(iEvents);
    delete iEngine;
    iObservers.Close();
}

// ---------------------------------------------------------------------------
// Publishes the given shortcut.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::PublishShortcutsL(RAiShortcutArray& aShortcuts)
{
    TInt err = KErrNone;
    TInt observers = iObservers.Count();
    TInt shortcuts = aShortcuts.Count();
    
    for (TInt i = 0; i < observers; ++i)
    {
        MAiContentObserver* observer = iObservers[i];
        TBool transactionStarted = EFalse;
        TInt transactionId = reinterpret_cast<TInt>(this);
        err = observer->StartTransaction(transactionId);

        if (err != KErrNotSupported)
        {
            // The observer does not support transactions, check for real errors.
            User::LeaveIfError(err);
            transactionStarted = ETrue;
        }
        err = KErrAlreadyExists;
        for (TInt j = 0; j < shortcuts; j++)
        {
            CAiScutShortcut* shortcut = aShortcuts[j];

            if (shortcut->NeedsToBePublished())
            {
                shortcut->Publish(*this, *observer);
                err = KErrNone;
            }
        }

        if ( transactionStarted && err == KErrNone )
            {
            User::LeaveIfError(observer->Commit(transactionId));
            }
        else if ( transactionStarted )
            {
            User::LeaveIfError(observer->CancelTransaction(transactionId));
            }
    }
}

// ---------------------------------------------------------------------------
// Is plug-in suspended or not.
// ---------------------------------------------------------------------------
//
TBool CAiScutPlugin::IsAlive() const
{
    return iAlive;
}

// ---------------------------------------------------------------------------
// Resume reason
// ---------------------------------------------------------------------------
//
TAiTransitionReason CAiScutPlugin::ResumeReason() const
    {
    return iResumeReason;
    }

// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Resumes the plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::Resume(TAiTransitionReason aReason)
{
    TRAP_IGNORE(DoResumeL(aReason));    
}

// ---------------------------------------------------------------------------
// Resumes the plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::DoResumeL(TAiTransitionReason aReason)
{
	__PRINT( __DBG_FORMAT( "XAI: CAiScutPlugin::Resume reason %d alive = %d"), aReason, iAlive);
    iResumeReason = aReason;
	// Reload the engine in case general theme changed or
	// the engine has been suspended. 
    if (aReason == EAiGeneralThemeChanged || !iAlive)
    {
        // if general theme changed, free engine so that is will be
        // loaded again because shortcut icons must be re-created.
        FreeEngine();
    }

    if (!iEngine)
    {
		iEngine = AiScutFactory::CreateAiScutEngineL(*this);
    }

    iEngine->ResumeL( (iAlive == EFalse) ||
        (
        aReason != EAiBacklightOn    &&
        aReason != EAiBacklightOff   &&
        aReason != EAiIdleBackground &&
        aReason != EAiIdleForeground
        ),
        aReason
    );
    
    iAlive = ETrue;
}

// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Suspends the plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::Suspend(TAiTransitionReason aReason)
{
	__PRINT( __DBG_FORMAT( "XAI: CAiScutPlugin::Suspend reason %d"), aReason);

    if (iEngine)
    {
        iEngine->Suspend();
    }

    iAlive = EFalse;
}

// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Frees the plug-in engine.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::Stop(TAiTransitionReason aReason)
{
	__PRINT( __DBG_FORMAT( "XAI: CAiScutPlugin::Stop reason %d"), aReason);

	if ( aReason == EAiBackupRestoreStarted )
	    {
	    Suspend( aReason );
	    }
	else
	    {
	    FreeEngine();
	    }
}
// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Adds the content observer / subscriber to plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::SubscribeL(MAiContentObserver& aObserver)
{
    iObservers.AppendL(&aObserver);
}

void CAiScutPlugin::DeleteDefaultShortcutsL()
    {
    // Ignore any errors that might occur when deleting
    // the default keys
    TUint32 errorKey;
    CRepository* cr = CRepository::NewL(KCRUidShortcutItems);
    cr->Delete(KScutCenRepKeyThemeDefault, KScutCenRepKeyMask, errorKey);
    delete cr;
    }

// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Configures the plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::ConfigureL(RAiSettingsItemArray& aSettings)
{
    CRepository* repository = NULL;

    TRAPD(err, repository = CRepository::NewL(KCRUidShortcutItems));

    if (err == KErrNotFound)
    {
        // CenRep file is missing from the image, this is a serious error.
        User::Leave(err);
    }

    // Write settings if repository was successfully opened. All other errors
    // are ignored to ensure that the plug-in is up and running, even if
    // crippled.

    // No leaving code here since 'repository' is not in cleanup stack.
    if (repository)
    {
        repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

        // A theme might not contain any publishable shortcuts at all, only
        // locked ones. To take this into account we must always delete old
        // theme-default settings to make sure the engine won't create any
        // unwanted shortcut objects. Any errors that might happen during
        // deletion are ignored to make sure the plug-in is kept alive.
        TUint32 errorKey;

        repository->Delete(KScutCenRepKeyThemeDefault, KScutCenRepKeyMask, errorKey);
        
		__PRINTS( "XAI: CAiScutPlugin::ConfigureL");

        TInt count = aSettings.Count();
        if (count > 0)
        {
            // Write new shortcut definitions.
            for (TInt i = 0; i < count; ++i)
            {
                MAiPluginSettings* settings = aSettings[ i ];
                
                if( settings->AiPluginItemType() == EAiPluginSettingsItem )
                    {
                    MAiPluginSettingsItem& item = settings->AiPluginSettingsItem();
                    TUint32 key = item.Key(); // implicit cast from TInt32 to TUint32.
    
    				__PRINT( __DBG_FORMAT( "XAI:   %d. key = 0x%x"), i+1, key);
    
                    // Add the bit that indicates this is a default shortcut setting.
                    key |= KScutFlagBitThemeDefault;
    
                    // Ignore possible error and keep going.
                    repository->Create(key, item.Value());
                    }
            }
        }

        TUint32 info = 0;
        repository->CommitTransaction(info);

        delete repository;
        repository = NULL;
        
        if (iEngine)
        {
            iEngine->CreateShortcutsL();
            iEngine->ResumeL( ETrue, EAiGeneralThemeChanged );
        }
    }

    // We don't need to store the settings so clear the array.
    aSettings.ResetAndDestroy();
}

// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Returns the extension interface.
// ---------------------------------------------------------------------------
//
TAny* CAiScutPlugin::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 MAiEventHandlerExtension.
// Handles an event sent by the AI framework.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::HandleEvent(TInt aEvent, const TDesC& aParam)
{
    if (iEngine)
    {
        // We have no way of reporting errors to framework so just ignore them.
        TRAP_IGNORE(iEngine->HandleAiEventL(aEvent, aParam));
    }
}

// ---------------------------------------------------------------------------
// CAiScutPlugin::HasMenuItem
//
// ---------------------------------------------------------------------------
//
TBool CAiScutPlugin::HasMenuItem(const TDesC16& /*aMenuItem*/)
    {
    return EFalse;
    }

// ---------------------------------------------------------------------------
// From class MAiPropertyExtension
// Returns a plug-in property.
// ---------------------------------------------------------------------------
//
TAny* CAiScutPlugin::GetPropertyL(TInt aProperty)
{
    switch (aProperty)
    {
    case EAiPublisherInfo:
        return static_cast<TAiPublisherInfo*>(&iInfo);

    case EAiPublisherContent:
        return static_cast<MAiContentItemIterator*>(iContent);

    case EAiPublisherResources:
        return static_cast<MAiContentItemIterator*>(iResources);

    case EAiPublisherEvents:
        return static_cast<MAiContentItemIterator*>(iEvents);

    default:
        break;
    }

    return NULL;
}

// ---------------------------------------------------------------------------
// From class MAiPropertyExtension
// Sets a plug-in property to optimize the content model.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::SetPropertyL(TInt aProperty, TAny* aValue)
    {
    if( aProperty == EAiPublisherInfo )
        {
        ASSERT( aValue );
        
        const TAiPublisherInfo* info( 
                static_cast<const TAiPublisherInfo*>( aValue ) );
        
        iInfo = *info;               
        }    
    }

// ---------------------------------------------------------------------------
//
//
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::FreeEngine()
{
    delete iEngine;
    iEngine = NULL;
    iAlive = EFalse;    
}

// ======== GLOBAL FUNCTIONS ========

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
{
    aTableCount = sizeof(KImplementationTable) / sizeof(TImplementationProxy);
    return KImplementationTable;
}

// End of File.