/*

* 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

*

*/

// System includes

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <PUAcodes.hrh>

#include <AknUtils.h>

// User includes

#include <aiprofilepluginuids.hrh>

#include <aicontentobserver.h>

#include <aiutility.h>

#include "aiprofileplugincontentmodel.h"

#include "caiprofileplugin.h"

#include "caiprofileengine.h"

#include "aipluginsettings.h"

// Constants

// PUA code for the timed profile, missing from PUAcodes.hrh

#define KAiTimedProfilePUA 0xF815

#define KAiRTL 0x200F

const TImplementationProxy KImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY( KImplUidProfilePlugin, CAiProfilePlugin::NewL ) 

    };

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

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

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

// CAiProfilePlugin::NewL

//

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

//

CAiProfilePlugin* CAiProfilePlugin::NewL()

    {

    CAiProfilePlugin* self = new ( ELeave ) CAiProfilePlugin;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAiProfilePlugin::CAiProfilePlugin()

// 

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

//

CAiProfilePlugin::CAiProfilePlugin()

    {

    }

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

// CAiProfilePlugin::ConstructL

// 

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

//

void CAiProfilePlugin::ConstructL()

    { 

    iContent = 

        AiUtility::CreateContentItemArrayIteratorL( KAiProfileContent );

    iEvents = 

        AiUtility::CreateContentItemArrayIteratorL( KAiProfileEvents );

    iResources = 

        AiUtility::CreateContentItemArrayIteratorL( KAiProfileResources );

    iEngine = CAiProfileEngine::NewL( this );

    iEngine->UpdateProfileNamesL();        

    }

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

// CAiProfilePlugin::~CAiProfilePlugin

// Deletes all data created to heap

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

//

CAiProfilePlugin::~CAiProfilePlugin()

    {    	

    Release( iContent );

    Release( iEvents );

    Release( iResources );

    delete iActiveProfileAndChar;

    delete iPreviousProfileNameAndChar;

    delete iEngine;

    iObservers.Close();

    }

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

// CAiProfilePlugin::PublishL

// Publishes the profiles

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

//

void CAiProfilePlugin::PublishL()

    {

    TInt err( KErrNone );

    TInt observers( iObservers.Count() );        

    TInt transactionId ( reinterpret_cast<TInt>( this ) );

    iCurrentCount = iEngine->NumberOfProfiles();

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

        {

        MAiContentObserver* observer( iObservers[i] );

        err = observer->StartTransaction( transactionId );

		if ( err == KErrNotSupported )

            {

            // The observer does not support transactions, check for real errors.

            return;

            }

        //Active Profile name    

        if ( observer->CanPublish( *this, EAiProfileContentActiveProfileName, EAiProfileContentActiveProfileName ) )

        	{        	

       		observer->Publish( *this, EAiProfileContentActiveProfileName, iEngine->ActiveProfileName(), EAiProfileContentActiveProfileName );

        	}

        if ( observer->CanPublish( *this, EAiProfileActiveProfileNameAndIconChar, 0 ) )

            {

            delete iActiveProfileAndChar;

            iActiveProfileAndChar = NULL;

            // silent/non-silent icon + timed icon + space + possible RTL*2 = 5

            TInt maxChars( iEngine->ActiveProfileName().Length() + 5 );

            iActiveProfileAndChar = HBufC::NewL( maxChars );

            TPtr profileNamePtr( iActiveProfileAndChar->Des() );

            if( AknLayoutUtils::LayoutMirrored() )

                {

                profileNamePtr.Append( KAiRTL );

                }

            if ( iEngine->IsActiveProfileTimedL() )

                {

                profileNamePtr.Append( KAiTimedProfilePUA );                

                }

            if ( iEngine->IsActiveProfileSilentL() )

                {                

                profileNamePtr.Append( KPuaCodeSilentSymbol );

                }

            else

                {

                profileNamePtr.Append( KPuaCodeAprofSound );

                }

            _LIT( KSpace, " " ); 

            profileNamePtr.Append( KSpace );

            if ( AknLayoutUtils::LayoutMirrored() )

                {

                profileNamePtr.Append( KAiRTL );

                }

            profileNamePtr.Append( iEngine->ActiveProfileName() );

            if ( !iPreviousProfileNameAndChar || 

                    iPreviousProfileNameAndChar->CompareC( *iActiveProfileAndChar ) != 0 )

                {

                delete iPreviousProfileNameAndChar;

                iPreviousProfileNameAndChar = NULL;

                observer->Publish( *this, EAiProfileActiveProfileNameAndIconChar, profileNamePtr, 0 );

                iPreviousProfileNameAndChar = iActiveProfileAndChar->AllocL();

                }

            }

        //Swap Profile name ( 1.phase: General or Silent )

       	if ( observer->CanPublish( *this, EAiProfileContentSwapProfileName, EAiProfileContentSwapProfileName ) )

        	{

        	observer->Publish( *this, EAiProfileContentSwapProfileName, iEngine->SwapProfileName(), EAiProfileContentSwapProfileName );

        	}      

		//All profile names

       	// clean profiles that are already deleted.

       	// Cleans the array blindly from the end, because in the next

       	// step all the profiles are republished

        if ( iPreviousCount > iCurrentCount )

            {

            for( TInt k = iCurrentCount; k < iPreviousCount; k++ )

                {

                observer->Clean( *this, EAiProfileContentProfileName, k + 1 );

                }

            }

		for ( TInt j = 0; j < iCurrentCount; j++ )

			{

			if ( observer->CanPublish( *this, EAiProfileContentProfileName, j + 1 ) )

				{

				observer->Publish(*this, EAiProfileContentProfileName, iEngine->ProfileNameByIndex( j ), j + 1 );

				}

			}

      	//Active Profile silent indicator char

        if ( observer->CanPublish( *this, EAiProfileActiveProfileSilentChar, EAiProfileActiveProfileSilentChar ) )

        	{

        	if ( iEngine->IsActiveProfileSilentL() )

        		{

        		TBuf<1> silent; // one character

        		silent.Append( KPuaCodeSilentSymbol );

        		observer->Publish( *this, EAiProfileActiveProfileSilentChar, silent, EAiProfileActiveProfileSilentChar );

        		}

        	else

        		{

        		observer->Clean( *this, EAiProfileActiveProfileSilentChar, EAiProfileActiveProfileSilentChar );

        		}

        	}

        //Active Profile silent indicator resource

        if ( observer->CanPublish( *this, EAiProfileActiveProfileIcon, EAiProfileActiveProfileIcon ) )

        	{

    		observer->Clean( *this, EAiProfileActiveProfileIcon, EAiProfileActiveProfileSilentIconResource );

    		observer->Clean( *this, EAiProfileActiveProfileIcon, EAiProfileActiveProfileGeneralIconResource );

    		observer->Clean( *this, EAiProfileActiveProfileIcon, EAiProfileActiveProfileTimedIconResource );

    		if ( iEngine->IsActiveProfileTimedL() )

        		{

        		observer->Publish( *this, 

        							EAiProfileActiveProfileIcon, 

        							EAiProfileActiveProfileTimedIconResource, 

        							EAiProfileActiveProfileTimedIconResource );

        		}

        	else if ( iEngine->IsActiveProfileSilentL() )

        		{

        		observer->Publish( *this, 

        							EAiProfileActiveProfileIcon, 

        							EAiProfileActiveProfileSilentIconResource, 

        							EAiProfileActiveProfileSilentIconResource );

        		}

        	else

        		{

        		observer->Publish( *this, 

        							EAiProfileActiveProfileIcon, 

        							EAiProfileActiveProfileGeneralIconResource, 

        							EAiProfileActiveProfileGeneralIconResource );

        		}

        	}

		// in case of Offline profile profile indicator is not shown

        if ( observer->CanPublish( *this, EAiProfileContentActiveProfileName, EAiProfileContentActiveProfileName ) &&

        		iEngine->IsOffline() )

        	{

    		observer->Clean( *this, EAiProfileActiveProfileSilentChar, EAiProfileActiveProfileSilentChar );

    		observer->Clean( *this, EAiProfileActiveProfileIcon, 1 );

    		observer->Clean( *this, EAiProfileActiveProfileIcon, 2 );

    		// uncomment also this and respective policy lines in profiles.xml if whole widget needs to be hidden in AI3 

    		//observer->Clean( *this, EAiProfileContentActiveProfileName, EAiProfileContentActiveProfileName );        		    		

    		}

        if ( err == KErrNone )

            {

            err = observer->Commit( transactionId );

            if ( err == KErrNotSupported)

                {

                return;

                }

            }                

        }

    iPreviousCount = iCurrentCount;

    }

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

// CAiProfilePlugin::Start

// 

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

//

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

    {   

    iPublishRequired = ETrue;

    }

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

// CAiProfilePlugin::Stop

// 

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

//

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

    {    

    CleanPublishedProfileNames();

    }

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

// CAiProfilePlugin::Resume

// 

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

//

void CAiProfilePlugin::Resume( TResumeReason aReason )

    {

    if ( aReason == EForeground )

        {

        TRAP_IGNORE( DoResumeL() );

        }

    }

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

// CAiProfilePlugin::Suspend

// 

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

//

void CAiProfilePlugin::Suspend( TSuspendReason /*aReason*/ )

    {    

    }

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

// CAiProfilePlugin::SubscribeL

// 

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

//

void CAiProfilePlugin::SubscribeL( MAiContentObserver& aObserver )

    {

    iObservers.AppendL( &aObserver );

    }

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

// CAiProfilePlugin::ConfigureL

// 

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

//

void CAiProfilePlugin::ConfigureL( RAiSettingsItemArray& /*aSettings*/ )

    {    

    }

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

// CAiProfilePlugin::GetProperty

// 

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

//

TAny* CAiProfilePlugin::GetProperty( TProperty aProperty )

    {

    if ( aProperty == EPublisherContent )

        {

        return static_cast< MAiContentItemIterator* >( iContent );        

        }

    else if ( aProperty == EPublisherEvents )

        {

        return static_cast< MAiContentItemIterator* >( iEvents );

        }

    else if ( aProperty == EPublisherResources )

        {

        return static_cast< MAiContentItemIterator* >( iResources );        

        }

    return NULL;

    }

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

// CAiProfilePlugin::HandleEvent

// 

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

//

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

    {    

    TRAP_IGNORE( iEngine->HandleAiEventL( aEvent, aParam ) );    

    }

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

// CAiProfilePlugin::DoResumeL

//

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

//

void CAiProfilePlugin::DoResumeL()

    {

    if ( iPublishRequired )

        {

        iPublishRequired = EFalse;

        PublishL();

        }

    }

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

// CAiProfilePlugin::NotifyContentUpdate()

// This method is called from the engine, when the profile data has changed

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

//

void CAiProfilePlugin::NotifyContentUpdate()

    {        

    iPublishRequired = ETrue;

    TRAP_IGNORE( DoResumeL() );

    }

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

// CAiProfilePlugin::CleanPublishedProfileNames

// Clean profile names from content

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

//    

void CAiProfilePlugin::CleanPublishedProfileNames()

    {

    TInt obsCount( iObservers.Count() );

    for ( TInt i( 0 ); i < obsCount; i++ )

        {

        MAiContentObserver* observer( iObservers[i] );

        for ( TInt j( 0 ); j < iCurrentCount && observer; j++ )

            {

            observer->Clean( *this, EAiProfileContentProfileName, j + 1 );

            }

        }

    delete iPreviousProfileNameAndChar;

    iPreviousProfileNameAndChar = NULL;

    iPreviousCount = 0;

    }

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

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

// Constructs and returns an application object.

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( 

    TInt& aTableCount )

    {

    aTableCount = sizeof( KImplementationTable ) / 

        sizeof( TImplementationProxy );

    return KImplementationTable;

    }