/*
* 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:  Shortcut plug-in engine extension
*
*/

#include <gslauncher.h>
#include <gulicon.h>
#include <viewcli.h>
#include <coemain.h>

#include <aiscutextdefs.h>

#include "caiscutengineext.h"
#include "caiscutextserver.h"
#include "taiscutparser.h"
#include "caiscutshortcut.h"
#include "caiscutplugin.h"
#include "aiscutcontentmodel.h"
#include "caiscutextdata.h"
#include "caiscutextdatamodel.h"

// ======== LOCAL DEFINITIONS ========

namespace
    {
    //  LOCAL CONSTANTS
    /**
     * Target id hex format
     */
    _LIT( KTargetIdFormat, "0x%08x" );

    /**
     * Maximum length of target id
     */
    const TInt KTargetIdMaxLength = 11;
    }

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

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

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CAiScutEngineExt::~CAiScutEngineExt()
    {
    delete iAiScutExtServer;
    delete iExtDataModel;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CAiScutEngineExt::CAiScutEngineExt( CAiScutPlugin& aPlugin )
    : CAiScutEngine( aPlugin )
    {
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutEngineExt::ConstructL()
    {
    CAiScutEngine::ConstructL();

    iExtDataModel = CAiScutExtDataModel::NewL();
    iAiScutExtServer = new( ELeave ) CAiScutExtServer( *this, Env()->WsSession() );
    iAiScutExtServer->ConstructL();
    TRAPD( err, iAiScutExtServer->StartL( KAiScutExtServerName ) );

    if( err != KErrNone && err != KErrAlreadyExists )
        {
        User::Leave( err );
        }
    
    //Send EAiScutEventGainFocus to the leftmost shortcut in order to put
    //its state machine in correct state
    if( iShortcuts.Count() > 0 )
    {
        static_cast< CAiScutShortcutExt* >( iShortcuts[ 0 ] )->HandleAIEventL(
            EAiScutEventGainFocus );
        }
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutEngineExt::CheckAccessAndPublish( CAiScutShortcut& aShortcut )
    {
    TRAPD( err,
        RAiShortcutArray shortcutArray;
        CleanupClosePushL( shortcutArray );
        shortcutArray.AppendL( &aShortcut );
        aShortcut.SetToBePublished( ETrue );
        iPlugin.PublishShortcutsL( shortcutArray );
        CleanupStack::PopAndDestroy( &shortcutArray );
        );

    if( err != KErrNone )
        {
        //Delegate publishing to the original engine
        CAiScutEngine::CheckAccessAndPublish( EScutCheckAll, ETrue );
        }
    }

// ---------------------------------------------------------------------------
// Handles an event sent by the AI framework.
// ---------------------------------------------------------------------------
//
void CAiScutEngineExt::HandleAiEventL( TInt aEvent, const TDesC& aParam )
    {
    CAiScutShortcutExt* shortcut = FindShortcutById( aParam );
    if( shortcut )
        {
        shortcut->HandleAIEventL( aEvent );
        }
    CAiScutEngine::HandleAiEventL( aEvent, aParam );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutEngineExt::ResumeL( TBool aPublishAll, TAiTransitionReason aReason )
    {
    TArray<CAiScutExtData*> extDataArray = iExtDataModel->AiScutExtDataArray();
    const TInt count = extDataArray.Count();
    //Iterate extension data items and populate to matching shortcuts.
    //Remove the items that are not used in any shortcut.
    for( TInt i = 0; i < count; i++ )
        {
        CAiScutExtData* extData = extDataArray[ i ];
        const TDesC& targetDefinition = extData->TargetDefinition();
        if( !PopulateExtData( targetDefinition, extData ) )
            {
            iExtDataModel->RemoveAiScutExtData( targetDefinition );
            }
        }

    TAiTransitionReason resumeReason = iPlugin.ResumeReason();
    const TInt shortcutCount = iShortcuts.Count();
    for( TInt i = 0; i < shortcutCount; i++ )
        {
        CAiScutShortcutExt* shortcut = static_cast< CAiScutShortcutExt* >
            ( iShortcuts[ i ] );
        shortcut->HandleResumed( resumeReason );
        }

    iAiScutExtServer->ResumeL( aReason );

    CAiScutEngine::ResumeL( aPublishAll, aReason );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutEngineExt::HandleSetPopupLineArrayL( const TDesC& aDefinition,
    CDesCArray* aLineArray )
    {
    CAiScutExtData* extData = iExtDataModel->SetPopupLineArrayL(
        aDefinition, aLineArray );
    TBool shortcutsFound = PopulateExtData(
        aDefinition, extData );
    if( !shortcutsFound )
        {
        iExtDataModel->RemoveAiScutExtData( aDefinition );
        }
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutEngineExt::HandleResetPopupLineArrayL( const TDesC& aDefinition )
    {
    CAiScutExtData* extData = iExtDataModel->ResetPopupLineArray( aDefinition );
    TBool shortcutsFound = PopulateExtData(
        aDefinition, extData );
    if( !shortcutsFound )
        {
        iExtDataModel->RemoveAiScutExtData( aDefinition );
        }
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutEngineExt::HandleSetIconL( const TDesC& aDefinition, CGulIcon* aIcon )
    {
    CAiScutExtData* extData = iExtDataModel->SetIconL( aDefinition, aIcon );
    TBool shortcutsFound = PopulateExtData(
        aDefinition, extData );
    if( !shortcutsFound )
        {
        iExtDataModel->RemoveAiScutExtData( aDefinition );
        }
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutEngineExt::HandleResetIconL( const TDesC& aDefinition )
    {
    CAiScutExtData* extData = iExtDataModel->ResetIcon( aDefinition );
    TBool shortcutsFound = PopulateExtData(
        aDefinition, extData );
    if( !shortcutsFound )
        {
        iExtDataModel->RemoveAiScutExtData( aDefinition );
        }
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CAiScutEngineExt::HandleIsInShortcutsL( const TDesC& aDefinition ) const
    {
    const TInt shortcutCount = iShortcuts.Count();
    for( TInt i = 0; i < shortcutCount; i++ )
        {
        CAiScutShortcutExt* shortcut = static_cast< CAiScutShortcutExt* >
            ( iShortcuts[ i ] );
        TPtrC activeTargetDefinition = shortcut->ActiveTargetDefinition();
        if( activeTargetDefinition.CompareF( aDefinition ) == 0 )
            {
            return ETrue;
            }
        }

    return EFalse;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutEngineExt::HandleIssuePutInShortcutsL( const TDesC& /*aDefinition*/ )
    {
    CGSLauncher* l = CGSLauncher::NewLC();
    l->LaunchGSViewL ( TUid::Uid( AI_UID_ECOM_IMPLEMENTATION_SETTINGS_SCUTPLUGIN ),
                       KScutActiveIdleUid,
                       KNullDesC8 );    
    CleanupStack::PopAndDestroy( l );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CAiScutEngineExt::PopulateExtData( const TDesC& aDefinition,
    const MAiScutExtData* aAiScutExtData )
    {
    //Iterate shortcuts and update matching ones with new extData
    TBool shortcutsFound = EFalse;
    const TInt shortcutCount = iShortcuts.Count();
    for( TInt i = 0; i < shortcutCount; i++ )
        {
        CAiScutShortcutExt* shortcut = static_cast< CAiScutShortcutExt* >
            ( iShortcuts[ i ] );
        TPtrC activeTargetDefinition = shortcut->ActiveTargetDefinition();
        if( activeTargetDefinition.CompareF( aDefinition ) == 0 )
            {
            shortcut->SetAiScutExtData( aAiScutExtData );
            shortcutsFound = ETrue;
            }
        }

    return shortcutsFound;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CAiScutShortcutExt* CAiScutEngineExt::FindShortcutById(
    const TDesC& aId ) const
    {
    const TInt shortcutCount = iShortcuts.Count();
    for( TInt i = 0; i < shortcutCount; i++ )
        {
        CAiScutShortcutExt* shortcut = static_cast< CAiScutShortcutExt* >
            ( iShortcuts[ i ] );

        TBuf< KTargetIdMaxLength > id;
        id.Format( KTargetIdFormat, shortcut->Id() );

        if( id.CompareF( aId ) == 0 )
            {
            return shortcut;
            }
        }
    return NULL;
    }

// End of File.