/*

* Copyright (c) 2006-2010 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:  SAT Active Idle publisher

*

*/

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <aicontentobserver.h>

#include <aiutility.h>

#include <aipluginsettings.h>

#include <flogger.h>

#include <AknUtils.h>

#include <gulicon.h>            // For CGulIcon

#include <fbs.h>                // For CFbsBitmap

#include <SATInternalPSKeys.h>

#include "aisatcontentmodel.h"

#include "caisatplugin.h"

#include "caisatengine.h"

#include "tflogger.h"

const TImplementationProxy KImplementationTable[] =

    {

    //lint -e{611,1924} Warning "Suspicious cast" can not be avoided.

    IMPLEMENTATION_PROXY_ENTRY( KImplUidSatPlugin, CAiSatPlugin::NewL )

    };

// static cleanup function

static void TransactionCleanup( TAny* aAny )

    {

    static_cast<MAiContentObserver*>( aAny )->

        CancelTransaction( KImplUidSatPlugin );

    }

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

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

// Symbian 2nd phase constructor can leave

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

//

CAiSatPlugin* CAiSatPlugin::NewL()

    {

    TFLOGSTRING( "CAiSatPlugin::NewL() starts" )

    CAiSatPlugin* self = new ( ELeave ) CAiSatPlugin;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TFLOGSTRING( "CAiSatPlugin::NewL() exits" )

    return self;

    }

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

// Destructor

// Deletes all data created to heap

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

//

CAiSatPlugin::~CAiSatPlugin()

    {

    TFLOGSTRING( "CAiSatPlugin::~CAiSatPlugin() starts" )

    Release( iContent );

    iContent = NULL;

    Release( iResources );

    iResources = NULL;

    Release( iEvents );

    iEvents = NULL;

    delete iEngine;

    iObservers.Close();

    TFLOGSTRING( "CAiSatPlugin::~CAiSatPlugin() exits" )

    }

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

// Publish a icon to the idle area.

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

//

TInt CAiSatPlugin::PublishIcon(

    MAiContentObserver& aObserver,

    CGulIcon* aIcon )

    {

    TFLOGSTRING( "CAiSatPlugin::PublishIcon() starts" )

    TInt error( KErrNotSupported );

    // Check whether the icon can be published or not.

    if ( aIcon && aObserver.CanPublish( *this, KSatContent[ESatContentIcon].id,

                                        ESatContentIcon ) )

        {

        // If the icon can be published, and then publish it.        

        error = aObserver.Publish( *this, KSatContent[ESatContentIcon].id,

                                    TPckgC<TAny*>( aIcon ), ESatContentIcon );

        }

    TFLOGSTRING2( "CAiSatPlugin::PublishIcon() exits, error: %d", error )

    return error;

    }

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

// Clean idle area icon

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

// 

TInt CAiSatPlugin::CleanIcon( MAiContentObserver& aObserver )

    {

    TFLOGSTRING( "CAiSatPlugin::CleanIcon() starts" )

    TInt error( KErrNotSupported );

    error = aObserver.Clean( *this, KSatContent[ESatContentIcon].id,

                             ESatContentIcon );    

    TFLOGSTRING2( "CAiSatPlugin::CleanIcon() exits, error %d", error )    

    return error;                        

    }

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

// Publish a SetUpIdleModeText string.

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

//

TInt CAiSatPlugin::PublishText( MAiContentObserver& aObserver,

                                const TDesC& aText )

    {

    TFLOGSTRING( "CAiSatPlugin::PublishText() starts" )

    TFLOGSTRING2( "CAiSatPlugin::PublishText() length %i", aText.Length() )

    TInt error( KErrNotSupported );

    // Check whether the SetUpIdleModeText string can be published or not

    if ( aText.Length() && 

         aObserver.CanPublish( *this, KSatContent[ESatContentText].id,

                               ESatContentText ) )

        {

        // If SetUpIdleModeText can be published, and then publish it.

        error = aObserver.Publish( *this, KSatContent[ESatContentText].id,

                                   aText, ESatContentText );

        }        

    TFLOGSTRING2( "CAiSatPlugin::PublishText() exits, error: \

        %d", error )

    return error;

    }

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

// Clean idle area text

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

// 

TInt CAiSatPlugin::CleanText( MAiContentObserver& aObserver )

    {

    TFLOGSTRING( "CAiSatPlugin::CleanText() starts" )

    TInt error( KErrNotSupported );

    error = aObserver.Clean( *this, KSatContent[ESatContentText].id,

                             ESatContentText );  

    TFLOGSTRING2( "CAiSatPlugin::CleanText() exits, error %d", error )   

    return error;                          

    }

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

// Publishes the SAT Set Up Idle Mode Text and or Icon

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

//

void CAiSatPlugin::PublishSatL()

    {

    TFLOGSTRING( "CAiSatPlugin::PublishSatL() starts" )

    TInt error( KErrNone );

    TInt iconError( KErrNone );

    TInt textError( KErrNone );

    TInt observers( iObservers.Count() );

    TInt transactionId( KImplUidSatPlugin );

    MAiContentObserver* observer( NULL );

    CGulIcon* icon( NULL ); // The icon for publishing.

    TInt i( 0 );

    TBool commitNeeded( EFalse );

    // Publish sat data to all observers.

    TFLOGSTRING2( "CAiSatPlugin::PublishSatL() observer count: %i", observers )        

    for ( i = 0; i < observers; i++ )

        {

        commitNeeded = EFalse;

        observer = iObservers[i];

        TFLOGSTRING2( "CAiSatPlugin::PublishSatL() observer id: %i", observer )

        // Start publish transaciton.

        error = observer->StartTransaction( transactionId );

        TCleanupItem item( TransactionCleanup, observer );

        CleanupStack::PushL( item );

        // Publish icon and text to idle mode area.

        iEngine->ContentIconL( icon ); 

        TPtrC text( KNullDesC );

        iEngine->ContentText( text );  

        if ( !icon && !text.Length() ) // Nothing

            {

            if ( !iDupIcon ) 

                {

                error = CleanIcon( *observer ); 

                commitNeeded = ETrue;

                }

            if ( !iDupText )

                {

                error = CleanText( *observer );

                commitNeeded = ETrue;                

                }

            }

        else if ( icon && !text.Length() ) // Icon only

            {

            if ( !iDupIcon )                

                { 

                error = CleanIcon( *observer ); 

                iconError = PublishIcon( *observer, icon );

                commitNeeded = ETrue;

                }  

            if ( !iDupText )

                {

                error = CleanText( *observer );  

                commitNeeded = ETrue;

                }

            }            

        else if ( !icon && text.Length() ) // Text only

            {   

            if ( !iDupIcon ) 

                {

                error = CleanIcon( *observer );

                commitNeeded = ETrue;

                }

            if ( !iDupText )

                {

                error = CleanText( *observer );

                textError = PublishText( *observer, text );

                commitNeeded = ETrue;

                }

            }

        else // Text and icon

            {

            if ( !iDupIcon )                

                {

                error = CleanIcon( *observer );

                iconError = PublishIcon( *observer, icon );

                commitNeeded = ETrue;

                }            

            if ( !iDupText )

                {

                error = CleanText( *observer );

                textError = PublishText( *observer, text );

                commitNeeded = ETrue;

                }              

            }    

        // Commit the publishing of the icon and text.

        if ( !textError && !iconError && commitNeeded )

            {

            TFLOGSTRING( "CAiSatPlugin::PublishSatL() commit transaction" )  

            error = observer->Commit( transactionId );

            }

        else

            {

            TFLOGSTRING( "CAiSatPlugin::PublishSatL() cancel transaction" )  

            error = observer->CancelTransaction( transactionId );

            }   

        CleanupStack::Pop();

        }

    TFLOGSTRING( "CAiSatPlugin::PublishSatL() exits" )

    }

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

// CAiSatPlugin::Start

// 

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

//

void CAiSatPlugin::Start( TStartReason /*aReason*/ )

    {    

    TFLOGSTRING( "CAiSatPlugin::Start() starts" )

    iPublishRequired = ETrue;

    TFLOGSTRING( "CAiSatPlugin::Start() exits" )

    }

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

// CAiSatPlugin::Stop

// 

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

//

void CAiSatPlugin::Stop( TStopReason /*aReason*/ )

    {

    TFLOGSTRING( "CAiSatPlugin::Stop() starts - exits" )

    }

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

// CAiSatPlugin::Resume

// 

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

//

void CAiSatPlugin::Resume( TResumeReason aReason )

    {

    TFLOGSTRING2( "CAiSatPlugin::Resume() reason %d", aReason )

    if ( aReason == EForeground )

        {

        if ( iPublishRequired )

            {

            iPublishRequired = EFalse;

            TRAP_IGNORE( UpdateSatL() )                       

            }

        }

    TFLOGSTRING( "CAiSatPlugin::Resume() exits" )

    }

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

// CAiSatPlugin::Suspend

// 

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

//

void CAiSatPlugin::Suspend( TSuspendReason aReason )

    {

    TFLOGSTRING( "CAiSatPlugin::Suspend() starts" )

    if ( aReason == EGeneralThemeChange )

        {

        iPublishRequired = ETrue;

        }

    TFLOGSTRING( "CAiSatPlugin::Suspend() exits" )

    }

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

// CAiSatPlugin::SubscribeL

// 

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

//

void CAiSatPlugin::SubscribeL( MAiContentObserver& aObserver )

    {

    TFLOGSTRING( "CAiSatPlugin::SubscribeL() starts" )

    iObservers.AppendL( &aObserver );

    TFLOGSTRING( "CAiSatPlugin::SubscribeL() exits" )

    }

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

// CAiSatPlugin::ConfigureL

// 

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

//

void CAiSatPlugin::ConfigureL( RAiSettingsItemArray& aSettings )

    {

    TFLOGSTRING( "CAiSatPlugin::ConfigureL() starts" )

    TInt count = aSettings.Count();

    TFLOGSTRING2( "CAiSatPlugin::ConfigureL  count: %d", count )

    if ( count > 0 )

        {

        TInt i( 0 );

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

            {

            MAiPluginSettings* settings = aSettings[i];

            MAiPluginSettingsItem& item = settings->AiPluginSettingsItem();

            item.SetValueL( item.Value(), EFalse );

            }

        TFLOGSTRING2( "CAiSatPlugin::ConfigureL  i: %d", i )    

        }

    TFLOGSTRING( "CAiSatPlugin::ConfigureL() exits" )

    }

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

// CAiSatPlugin::GetProperty

// 

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

//

TAny* CAiSatPlugin::GetProperty( TProperty aProperty )

    {

    TFLOGSTRING( "CAiSatPlugin::GetProperty() starts" )

    TAny* property( NULL );

    TFLOGSTRING2( "CAiSatPlugin::GetProperty aProperty: %d", aProperty )

    if ( aProperty == EPublisherContent )

        {            

        property = iContent;            

        }

    else if ( aProperty == EPublisherResources )

        {

        property = iResources;

        }

    else if ( aProperty == EPublisherEvents )

        {

        property = iEvents;

        }

    TFLOGSTRING( "CAiSatPlugin::GetProperty() exits" )

    return property;

    }

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

// This method is called from the engine, when the P&S

// data content has been changed. Method call is made through

// the MPluginAPI interface.

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

//

void CAiSatPlugin::NotifyContentUpdate()

    {

    TFLOGSTRING( "CAiSatPlugin::NotifyContentUpdate() starts" )

    if ( iEngine )

        {

        // Get the idle mode data first.

        TRAP_IGNORE( iEngine->PrepareIdleModeDataL( iDupIcon, iDupText ) );

        // Send response to client side

        TRAP_IGNORE( iEngine->HandleNotifyL() );   

        // Publish set up idle mode data           

        TRAP_IGNORE( PublishSatL() );  

        }

    TFLOGSTRING( "CAiSatPlugin::NotifyContentUpdate() exits" )

    }

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

// Default constructor

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

//

CAiSatPlugin::CAiSatPlugin()

    {

    TFLOGSTRING( "CAiSatPlugin::CAiSatPlugin() starts-exits" )

    }

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

// Symbian 2nd phase constructor can leave

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

//

void CAiSatPlugin::ConstructL()

    {

    TFLOGSTRING( "CAiSatPlugin::ConstructL() starts" )

    iContent = AiUtility::CreateContentItemArrayIteratorL( KSatContent );

    iResources = AiUtility::CreateContentItemArrayIteratorL( KSatResources );

    iEvents = AiUtility::CreateContentItemArrayIteratorL( KSatEvents );

    iEngine = CAiSatEngine::NewL( *this );

    TFLOGSTRING( "CAiSatPlugin::ConstructL() exits" )

    }

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

// Update idle area when plug in reload.

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

//

void CAiSatPlugin::UpdateSatL()

    {

    TFLOGSTRING( "CAiSatPlugin::UpdateSatL() starts" )

    iEngine->PrepareIdleModeDataL( iDupIcon, iDupText );

    PublishSatL();                

    TFLOGSTRING( "CAiSatPlugin::UpdateSatL() exits" )

    }

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

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

// Constructs and returns an application object.

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(

    TInt& aTableCount )

    {

    TFLOGSTRING( "CAiSatPlugin::ImplementationGroupProxy() starts-exits" )

    aTableCount =

        sizeof( KImplementationTable ) / sizeof( TImplementationProxy );

    return KImplementationTable;

    }