/*
* 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:  Device status plugin interface.
*
*/


#include <ecom/ecom.h>
#include <ecom/implementationproxy.h>
#include <coemain.h>
#include <data_caging_path_literals.hrh>
#include <bautils.h>
#include <aiutility.h>
#include <featmgr.h>
#include "aidevicestatusplugin.h"
#include "aidevicestatuspluginengine.h"
#include "aipublishprioritizer.h"
#include "aidevicestatuscontentmodel.h"
#include "aimulticontentobserver.h"
#include "aipluginsettings.h"
#include "ainetworkinfolistener.h"

_LIT( KResourceDrive, "Z:" );
_LIT( KResourceFile, "aidevstaplgres.rsc" );
#define KResourcePath KDC_APP_RESOURCE_DIR

// ECOM implementation table
const TImplementationProxy KImplementationTable[] =
    {
    IMPLEMENTATION_PROXY_ENTRY(KImplUidDevStaPlugin, CAiDeviceStatusPlugin::NewL)
    };


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

CAiDeviceStatusPlugin::CAiDeviceStatusPlugin() :
   	iResourceOffset( KErrNotFound )
    {
    }


void CAiDeviceStatusPlugin::ConstructL()
    {
    iInfo.iUid.iUid = AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_DEVSTAPLUGIN; 

    FeatureManager::InitializeLibL();
    
    // Create master instance to prevent deletion on Stop()
    iListener = CAiNetworkInfoListener::InstanceL();
    
	//Create content here since this is needed in optimization phase.
    iContent = AiUtility::CreateContentItemArrayIteratorL( KAiDeviceStatusContent );
    iResources = AiUtility::CreateContentItemArrayIteratorL( KAiDeviceStatusResources );
    iContentObservers = CAiMultiContentObserver::NewL();
    iPrioritizer = CAiPublishPrioritizer::NewL( *iContentObservers, *this );
    }


CAiDeviceStatusPlugin* CAiDeviceStatusPlugin::NewL()
    {
    CAiDeviceStatusPlugin* self = CAiDeviceStatusPlugin::NewLC();
    CleanupStack::Pop( self );
    return self;
    }


CAiDeviceStatusPlugin* CAiDeviceStatusPlugin::NewLC()
    {
    CAiDeviceStatusPlugin* self = new( ELeave ) CAiDeviceStatusPlugin;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


CAiDeviceStatusPlugin::~CAiDeviceStatusPlugin()
    {
    delete iPrioritizer;
    FreeResources();
    delete iContentObservers;
    Release( iResources );
    Release( iContent );
    FeatureManager::UnInitializeLib();
    if( iListener )
        {
        iListener->Release();
        }
    }


/**
 * Allocates all resourcers required for plug-in operation.
 */
void CAiDeviceStatusPlugin::AllocateResourcesL()
    {
    //create engine
    if( !iEngine )
    	{
   	    iEngine = CAiDeviceStatusPluginEngine::NewL( *iContentObservers,
   	                                                    *this,
   	                                                    *iPrioritizer);
    	}

	if( iResourceOffset < 0 )
		{
		CCoeEnv* coe = CCoeEnv::Static();

		if( !coe )
		    {
		    User::Leave( KErrNotReady );
		    }

		//Add resource file to cone
		TFullName resourceFile( KResourceDrive );
		resourceFile.Append( KResourcePath );
		resourceFile.Append( KResourceFile );
		BaflUtils::NearestLanguageFile( CCoeEnv::Static()->FsSession(), resourceFile );
		iResourceOffset = coe->AddResourceFileL( resourceFile );
		}
    }


/**
 * Frees all allocated resources.
 */
void CAiDeviceStatusPlugin::FreeResources()
    {
	if( iResourceOffset >= 0 )
	    {
	    CCoeEnv* coe = CCoeEnv::Static();
    	//If device status plugin is created when CCoeEnv is available and
    	//destroyed when it is not anymore available, cone will inform about
    	//resource leak.
	    if ( coe )
	        {
        	coe->DeleteResourceFile( iResourceOffset );
        	iResourceOffset = KErrNotFound;
        	}
	    }

	delete iEngine;
	iEngine = NULL;
    }


void CAiDeviceStatusPlugin::Resume(TAiTransitionReason aReason)
    {
    if( IgnoreReason( aReason ) )
        {
        return;
        }
    // resume all publishers only in startup
    if( iEngine )
        {
        if (  aReason == EAiIdleForeground || aReason == EAiKeylockDisabled )
        	{
        	// not much can be done if some publisher cannot be refreshed
        	TRAP_IGNORE( iEngine->RefreshPublishersL( 
        	                EAiDeviceStatusContentNetworkIdentity, ETrue ) );
        	
        	TRAP_IGNORE( iEngine->RefreshPublishersL( 
        					EAiDeviceStatusContentCUGMCNIndicator, ETrue ) );
        	}
        // if layout changed republish some information
        else if ( aReason == EAiScreenLayoutChanged )
            {
            TRAP_IGNORE( iEngine->RefreshPublishersL( EAiDeviceStatusContentDate, ETrue )); 
            TRAP_IGNORE( iEngine->RefreshPublishersL( EAiDeviceStatusContentCUGMCNIndicator, ETrue ));
            TRAP_IGNORE( iEngine->RefreshPublishersL( EAiDeviceStatusContentVHZText, ETrue ));
            TRAP_IGNORE( iEngine->RefreshPublishersL( EAiDeviceStatusContentNetworkIdentity, ETrue ));
            }
        return;
        }
    // If engine has been deleted. create it again.
    else
        {
        iContentObservers->StartTransaction( KImplUidDevStaPlugin );

        TRAPD( err, DoResumeL(aReason) );

        if( err == KErrNone )
            {
            iContentObservers->Commit( KImplUidDevStaPlugin );
            }
        else
            {
            iContentObservers->CancelTransaction( KImplUidDevStaPlugin );
            }
        }
    }


void CAiDeviceStatusPlugin::DoResumeL(TAiTransitionReason /*aReason*/)
    {
    AllocateResourcesL( );
    iEngine->ResumePublishersL();
    iEngine->RefreshPublishersL( EFalse );
    }
    

TBool CAiDeviceStatusPlugin::IgnoreReason( TAiTransitionReason aReason )
    {
    switch( aReason )
        {
        case EAiBacklightOff:
            return ETrue;
        }
    return EFalse;
    }


void CAiDeviceStatusPlugin::Stop(TAiTransitionReason /*aReason*/)
    {
    FreeResources();
    }


void CAiDeviceStatusPlugin::Suspend(TAiTransitionReason /*aReason*/)
    {
    }


void CAiDeviceStatusPlugin::SubscribeL(MAiContentObserver& aObserver)
    {
    iContentObservers->AddObserverL( aObserver );
    }


TAny* CAiDeviceStatusPlugin::Extension(TUid aUid)
    {
	//Access to extensions
    if( aUid == KExtensionUidProperty )
        {
        return static_cast<MAiPropertyExtension*>(this);
        }

    return NULL;
    }


void CAiDeviceStatusPlugin::ConfigureL(RAiSettingsItemArray& aSettings)
    {
	aSettings.ResetAndDestroy();
    }

TAny* CAiDeviceStatusPlugin::GetPropertyL(TInt aProperty)
    {
	//Return properties.
    switch (aProperty)
        {
        case EAiPublisherInfo:
                return &iInfo;

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

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

        case EAiContentRequest:
            return static_cast<MAiContentRequest*>(this);
        }

    return NULL;
    }

void CAiDeviceStatusPlugin::SetPropertyL(TInt aProperty, TAny* aValue)
    {
    if( aProperty == EAiPublisherInfo )
        {
        ASSERT( aValue );
        
        const TAiPublisherInfo* info( 
                static_cast<const TAiPublisherInfo*>( aValue ) );
        
        iInfo = *info;
        }
    }

TBool CAiDeviceStatusPlugin::RefreshContent( TInt aContentId )
    {
    TBool result = EFalse;

    TRAP_IGNORE( result = iEngine->RefreshPublishersL( aContentId, EFalse ) );
    return result;
    }


/**
 * ECom component entry point.
 */
EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )
    {
    aTableCount = sizeof(KImplementationTable) / sizeof(TImplementationProxy);
    return KImplementationTable;
    }