/*
* 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;
    }