/*
* Copyright (c) 2008-2009 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:
*/

// INCLUDE FILES
#include <coemain.h>
#include <gulicon.h>
#include <e32math.h>
#include <fbs.h>
#include <cntdef.h>
#include <e32property.h>

#include <CCustomIconDecisionData.h>
#include <CCustomIconIdMap.h>
#include <MCustomIconChangeObserver.h>

#include "CPbk2IconCustomApiTestPlugin.h"

#if defined(__WINS__) || defined(WINS)
_LIT( KIconFile, "Z:\\Data\\Test\\CustIconApiTestIcons.mbm" );
#else
_LIT( KIconFile, "C:\\Data\\Test\\CustIconApiTestIcons.mbm" );
#endif

// Publish/Subscribe category UID of used for configuring test environment.
// See SetPsProperty() implementation.
const TUint KStiffPsCategoryUid = 0x1000007A;
const TUint KIconApiTestPSPropertyCategoryUID = KStiffPsCategoryUid;


// Publish/Subscribe keys under KIconApiTestPSPropertyCategoryUID category.
// Make sure these are same as in Pbk2IconCustomApiTestModule.cfg
const TInt KPsKeyIconUpdaterEnabled = 1;
const TInt KPsKeyIconUpdaterIntervalMs = 2;
const TInt KPsKeyNotificationEventType = 3;
const TInt KPsKeyNotificationEmptyUidArray = 4;


// ----------------------------------------------------------------------------
// GetPsTestProperty
// Read property value from Publish/Subscribe subsystem.
// The values are set by test module dll, contacts_dom\
//      phonebook_2_contact_related_icon_customization_api\Internal\Test
// and are meant to configure this plug-in at runtime.
// ----------------------------------------------------------------------------
//
LOCAL_C TInt GetPsTestProperty( TInt aKey, TInt& aResult )
    {
    TInt value;
    TInt err = RProperty::Get(
        TUid::Uid( KIconApiTestPSPropertyCategoryUID ),
        aKey,
        value );
    if( !err )
        {
        aResult = value;
        }
    return err;
    }

// ----------------------------------------------------------------------------
// ValidateHintL
// ----------------------------------------------------------------------------
//
LOCAL_C void ValidateHintL( const CCustomIconDecisionData& aHint )
    {
    // At least one of the members should have been filled by the caller
    if( aHint.ContactLinkRef() == NULL &&
        aHint.PhoneNumber() == KNullDesC &&
        aHint.Time() == NULL)
        {
        User::Leave( KErrArgument );
        }

    }

// ----------------------------------------------------------------------------
// AppendIconToMapL
// ----------------------------------------------------------------------------
//
LOCAL_C void AppendIconToMapL( const TDesC& aMbmFileName, TInt aMbmIndex,
    TInt aId, CCustomIconIdMap* aIconMap )
    {
    CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();
    CleanupStack::PushL(bitmap);
    User::LeaveIfError( bitmap->Load( aMbmFileName, aMbmIndex ) );
    CGulIcon* icon = CGulIcon::NewL( bitmap ); // takes ownership of bitmap
    CleanupStack::Pop( bitmap );
    CleanupStack::PushL( icon );
    aIconMap->AppendL( icon, aId );            // takes ownership of icon
    CleanupStack::Pop( ); // icon
    }

// ----------------------------------------------------------------------------
// ESMRHelper::LocateResourceFile
// ----------------------------------------------------------------------------
//
LOCAL_C TInt LocateResourceFile(
        const TDesC& aResource,
        const TDesC& aPath,
        TFileName &aResourceFile)
    {
    RFs* fsSession;

    fsSession=&CCoeEnv::Static()->FsSession();//codescanner::eikonenvstatic

    TFindFile resourceFile( *fsSession );
    TInt err = resourceFile.FindByDir(
            aResource,
            aPath );

    if ( KErrNone == err )
        {
        aResourceFile.Copy( resourceFile.File() );
        }

    return err;
    }

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

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::CPbk2IconCustomApiTestPlugin
// ----------------------------------------------------------------------------
//
CPbk2IconCustomApiTestPlugin::CPbk2IconCustomApiTestPlugin()
    {
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::~CPbk2IconCustomApiTestPlugin
// ----------------------------------------------------------------------------
//
CPbk2IconCustomApiTestPlugin::~CPbk2IconCustomApiTestPlugin()
    {
    iObservers.Close();
    delete iTimer;
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::ConstructL
// ----------------------------------------------------------------------------
//
void CPbk2IconCustomApiTestPlugin::ConstructL()
    {
    TTime now;
    now.HomeTime();
    iSeed = now.Int64();

    // If the test case has defined icon update property, initialize
    // periodical timer for generating icon update events
    TInt psResult( EFalse );
    if( GetPsTestProperty( KPsKeyIconUpdaterEnabled, psResult ) == KErrNone &&
        psResult )
        {
        if( GetPsTestProperty(
            KPsKeyIconUpdaterIntervalMs, psResult ) == KErrNone )
            {
            iTimer = CPeriodic::NewL( CActive:: EPriorityStandard );
            TInt tickIntevalMicroseconds = 1000 * psResult;
            iTimer->Start( tickIntevalMicroseconds,
                tickIntevalMicroseconds,
                TCallBack( Tick, this) );
            }
        }
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::AddObserverL
// ----------------------------------------------------------------------------
//
void CPbk2IconCustomApiTestPlugin::AddObserverL(
    MCustomIconChangeObserver* aObserver )
    {
    iObservers.AppendL( aObserver );
    // Test that observer interface returns NULL extension for NULL UID.
    if( aObserver->IconChangeNotificationExtension( KNullUid ) )
        {
        User::Leave( KErrGeneral );
        }
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::RemoveObserver
// ----------------------------------------------------------------------------
//
void CPbk2IconCustomApiTestPlugin::RemoveObserver(
    MCustomIconChangeObserver* aObserver )
    {
    TInt index = iObservers.Find( aObserver );
    if( index > 0 )
        {
        iObservers.Remove( index );
        }
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::IconsL
// ----------------------------------------------------------------------------
//
CCustomIconIdMap* CPbk2IconCustomApiTestPlugin::IconsL(
    TUid /*aContext*/,
    TIconSizeHint /*aSizeHint*/ )
    {

    CCustomIconIdMap* iconMap = new( ELeave )CCustomIconIdMap( 2 );
    CleanupStack::PushL( iconMap );
    
    AppendIconToMapL( KIconFile, 0, 653, iconMap );
    AppendIconToMapL( KIconFile, 1, 145, iconMap );

    CleanupStack::Pop( iconMap );
    return iconMap;
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::IconChoiceL
// ----------------------------------------------------------------------------
//
TBool CPbk2IconCustomApiTestPlugin::IconChoiceL(
    const CCustomIconDecisionData& aHint, TInt& aIdResult )
    {
    ValidateHintL( aHint );
    TInt random = Math::Rand( iSeed ) % 2;
    if( random == 0)
        {
        aIdResult = 653;
        }
    else
        {
        aIdResult = 145;
        }
    return ETrue;
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::IconL
// ----------------------------------------------------------------------------
//
CGulIcon* CPbk2IconCustomApiTestPlugin::IconL(
    const CCustomIconDecisionData& aHint, TIconSizeHint /*aSizeHint*/ )
    {
    ValidateHintL( aHint );
    CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();
    CleanupStack::PushL( bitmap );
    TInt context = aHint.Context().iUid;
    const TTime* time = aHint.Time();
    // Icon depends on context param & time, here simply whether they
    // has bee defined..
    if( context || time )
        {
        User::LeaveIfError( bitmap->Load( KIconFile, 0 ) );
        }
    else
        {
        User::LeaveIfError( bitmap->Load( KIconFile, 1 ) );
        }
    CGulIcon* icon = CGulIcon::NewL( bitmap ); // takes ownership of bitmap
    CleanupStack::Pop( bitmap );
    return icon;
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::IconL
// ----------------------------------------------------------------------------
//
CGulIcon* CPbk2IconCustomApiTestPlugin::IconL( TUid /*aContext*/,
    TCustomIconId aIconId,
    TIconSizeHint /*aSizeHint*/ )
    {
    TInt mbmIndex = KErrNotFound;
    if( aIconId == 653 )
        {
        mbmIndex = 0;
        }
    else if( aIconId == 145 )
        {
        mbmIndex = 1;
        }
    CGulIcon* icon = NULL;
    if( mbmIndex != KErrNotFound )
        {
        CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();
        CleanupStack::PushL( bitmap );
        
        User::LeaveIfError( bitmap->Load( KIconFile, 0 ) );
        icon = CGulIcon::NewL( bitmap ); // takes ownership of bitmap
        CleanupStack::Pop( bitmap );
        }
    return icon;
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::Tick
// ----------------------------------------------------------------------------
//
TInt CPbk2IconCustomApiTestPlugin::Tick( TAny* aObject )
    {
    // cast, and call non-static function
    TRAP_IGNORE(((CPbk2IconCustomApiTestPlugin*)aObject)->NotifyObserversL();)
    return ETrue; // continue ticking
    }

// ----------------------------------------------------------------------------
// CPbk2IconCustomApiTestPlugin::NotifyObserversL
// ----------------------------------------------------------------------------
//
void CPbk2IconCustomApiTestPlugin::NotifyObserversL()
    {
    TInt i;
    TInt count = iObservers.Count();
    MCustomIconChangeObserver* observer;
    for( i=0; i<count; i++ )
        {
        observer = iObservers[i];
        if( observer )
            {
            // Setup notification parameters from the values defined by the
            // Publish/Subscribe system (test case being the definer)
            // If values not found, use default values
            TInt eventType( MCustomIconChangeObserver::EIconsMajorChange );
            TBool emptyArray( ETrue );
            GetPsTestProperty( KPsKeyNotificationEventType, eventType );
            GetPsTestProperty( KPsKeyNotificationEmptyUidArray, emptyArray );

            RArray<TCustomIconId> array;
            CleanupClosePushL( array );
            if( !emptyArray )
                {
                array.AppendL( TCustomIconId( 653 ) );
                array.AppendL( TCustomIconId( 145 ) );
                }
            observer->CustomIconEvent( *this,
                (MCustomIconChangeObserver::TEventType)eventType,
                array.Array() );

            CleanupStack::PopAndDestroy( &array );
            }
        }
    }

// End of file