/*

* 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 <ecom\ecom.h>

#include <e32property.h>

#include <e32cmn.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include <CContactCustomIconPluginBase.h>

#include <CCustomIconIdMap.h>

#include <CCustomIconDecisionData.h>

#include "CIconCustomApiTestModule.h"

_LIT( KTestPluginDisplayName, "Custom Icon test plugin" );

const TInt KExecutableUidIndex = 0;

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

// CleanUpEComInfoArray

// CleanupStack support for RImplInfoPtrArray.

// See LoadTestPluginL how it is used

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

//

LOCAL_C void CleanUpEComInfoArray( TAny* aInfoArray )

    {

    RImplInfoPtrArray* infoArray = (static_cast<RImplInfoPtrArray*>(aInfoArray));

    infoArray->ResetAndDestroy();

    infoArray->Close();

    }

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

// ProcessSID

// Figure out current process SID (this should be STIFF SID)

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

//

LOCAL_C TUid ProcessSID()

    {

    RProcess process;

    TUidType type = process.Type();

    // current process SID (STIFF executable SID = 0x1000007A)

    TUid uid = type[KExecutableUidIndex];

    return uid;

    }

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

// BuildDecisionDataLC

// Utility to build decision data object.

// See LoadTestPluginL how it is used

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

//

LOCAL_C CCustomIconDecisionData* BuildDecisionDataLC(  CStifItemParser& aItem )

    {

    CCustomIconDecisionData* decisionData =

        new ( ELeave ) CCustomIconDecisionData();

    CleanupStack::PushL( decisionData );

    TUid contextParam = ProcessSID();

    TTime* time = new (ELeave) TTime;

    decisionData->SetTime( time ); // ownership taken

    time->UniversalTime();

    TPtrC phoneNumber;

    aItem.GetNextString( phoneNumber );

    decisionData->SetPhoneNumberL( phoneNumber );

    decisionData->SetContactLinkRef( NULL );

    decisionData->SetContext( contextParam );

    return decisionData;

    }

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

// ReplaceIconL

// Find an icon and replace it

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

//

LOCAL_C void ReplaceIconL( CCustomIconIdMap* aIcons,

    CGulIcon* aIcon, TCustomIconId aIconId )

    {

    TInt i;

    TInt count = aIcons->Count();

    TInt err( KErrNotFound );

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

        {

        TCustomIconIdMapItem& item( (*aIcons)[i] );

        if( item.iId == aIconId )

            {

            // Change the icon

            delete item.iIconPtr;

            item.iIconPtr = aIcon;

            err = KErrNone;

            break;

            }

        }

    User::LeaveIfError( err );

    }

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

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

// CIconCustomApiTestModule::CleanupPsKeys

// Remove all key definitions and/or values, which have been

// defined/set by this test module.

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

//

void CIconCustomApiTestModule::CleanupPsKeys()

    {

    TInt count = iPublishedPsKeys.Count();

    TInt i;

    TUid sid = ProcessSID();

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

        {

        // Ignore return value, because key may not exist

        RProperty::Delete( sid, iPublishedPsKeys[i] );

        }

    }

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

// CIconCustomApiTestModule::RunMethodL

// Run specified method. Contains also table of test methods and their names.

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

//

TInt CIconCustomApiTestModule::RunMethodL(

    CStifItemParser& aItem )

    {

    static TStifFunctionInfo const KFunctions[] =

        {

        ENTRY( "LoadTestPluginL", CIconCustomApiTestModule::LoadTestPluginL ),

        ENTRY( "LoadIconsL", CIconCustomApiTestModule::LoadIconsL ),

        ENTRY( "LoadIconL", CIconCustomApiTestModule::LoadIconL ),

        ENTRY( "UpdateIconsWithLastIconIdsL", CIconCustomApiTestModule::UpdateIconsWithLastIconIdsL ),

        ENTRY( "DeleteIconsL", CIconCustomApiTestModule::DeleteIconsL ),

        ENTRY( "DeleteIconL", CIconCustomApiTestModule::DeleteIconL ),

        ENTRY( "IconChoiceL", CIconCustomApiTestModule::IconChoiceL ),

        ENTRY( "SetPsProperty", CIconCustomApiTestModule::SetPsProperty ),

        ENTRY( "DeletePsProperty", CIconCustomApiTestModule::DeletePsProperty ),

        ENTRY( "SetTestCaseAsObserverL", CIconCustomApiTestModule::SetTestCaseAsObserverL ),

        ENTRY( "CheckIfHasExtensionL", CIconCustomApiTestModule::CheckIfHasExtensionL ),

        };

    const TInt count = sizeof( KFunctions ) /

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CIconCustomApiTestModule::CustomIconsChangedL

// Notification handler, called by plugin.

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

//

void CIconCustomApiTestModule::CustomIconEvent(

            CContactCustomIconPluginBase& /*aPlugin*/,

            TEventType aEventType,

            const TArray<TCustomIconId>& aIconIds)

    {

    iLastEventType = aEventType;

    TInt signalCode( aEventType );

    TRAPD( err,

        iLastIconIds.Reset();

        TInt i;

        TInt count = aIconIds.Count();

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

            {

            iLastIconIds.AppendL( aIconIds[i] );

            }

        );

    if( err )

        {

        signalCode = err;

        }

    Signal( signalCode );

    }

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

// CIconCustomApiTestModule::LoadTestPluginL

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

//

TInt CIconCustomApiTestModule::LoadTestPluginL( CStifItemParser& /*aItem*/ )

    {

    if( iTestPlugin )

        {

        return KErrAlreadyExists;

        }

    CContactCustomIconPluginBase* result = NULL;

    RImplInfoPtrArray implementationInfoArray;

    TCleanupItem cleanup( CleanUpEComInfoArray, &implementationInfoArray );

    CleanupStack::PushL( cleanup );

    TUid uid( KContactIconCustomizationInterfaceUid );

    REComSession::ListImplementationsL( uid,

        implementationInfoArray );

    TInt count = implementationInfoArray.Count();

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

        {

        CImplementationInformation* info = implementationInfoArray[i];

        if( !(info->DisplayName().Compare( KTestPluginDisplayName ) == 0) )

            {

            continue;

            }

        // Test plugin was found. Try to load it.

        TUid pluginUid = info->ImplementationUid();

        TRAPD( err, result = static_cast<CContactCustomIconPluginBase*>

            (REComSession::CreateImplementationL(pluginUid,

                                            _FOFF(CContactCustomIconPluginBase,

                                            iDtorKey)));

            );

        if( err )

            {

            result = NULL;

            }

        break;

        }

    CleanupStack::PopAndDestroy(&implementationInfoArray);

    iTestPlugin = result;

    if( !iTestPlugin )

        {

        return KErrNotFound;

        }

    return KErrNone;

    }

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

// CIconCustomApiTestModule::LoadIconsL

// Load icon array

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

//

TInt CIconCustomApiTestModule::LoadIconsL( CStifItemParser& aItem )

    {

    User::LeaveIfNull( iTestPlugin );

    if( iIcons )

        {

        User::Leave( KErrAlreadyExists );

        }

    TInt sizeHint( 0 );

    aItem.GetNextInt( sizeHint );

    iIcons = iTestPlugin->IconsL(

        ProcessSID(), // use SID as context parameter

        (CContactCustomIconPluginBase::TIconSizeHint)sizeHint );

    return KErrNone;

    }

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

// CIconCustomApiTestModule::LoadIconL

// Load individual icon

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

//

TInt CIconCustomApiTestModule::LoadIconL( CStifItemParser& aItem )

    {

    User::LeaveIfNull( iTestPlugin );

    if( iIcon )

        {

        User::Leave( KErrAlreadyExists );

        }

    TInt sizeHint( 0 );

    aItem.GetNextInt( sizeHint );

    CCustomIconDecisionData* decisionData = BuildDecisionDataLC( aItem );

    iIcon = iTestPlugin->IconL( *decisionData,

        (CContactCustomIconPluginBase::TIconSizeHint)sizeHint );

    CleanupStack::PopAndDestroy( decisionData );

    return KErrNone;

    }

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

// CIconCustomApiTestModule::UpdateIconsWithLastIconIdsL

// Replace current icons with new ones

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

//

TInt CIconCustomApiTestModule::UpdateIconsWithLastIconIdsL(

    CStifItemParser& aItem )

    {

    User::LeaveIfNull( iTestPlugin );

    if( !iIcons )

        {

        User::Leave( KErrNotFound );

        }

    TInt sizeHint( 0 );

    aItem.GetNextInt( sizeHint );

    TInt i;

    TInt count = iLastIconIds.Count();

    CGulIcon* icon;

    TCustomIconId iconId;

    TUid contextParam = ProcessSID(); // use process SID as context parameter

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

        {

        iconId = iLastIconIds[i];

        icon = iTestPlugin->IconL( contextParam,

            iconId,

            (CContactCustomIconPluginBase::TIconSizeHint)sizeHint );

        CleanupStack::PushL( icon );

        ReplaceIconL( iIcons, icon, iconId ); // Takes ownership

        CleanupStack::Pop( icon );

        }

    return KErrNone;

    }

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

// CIconCustomApiTestModule::DeleteIconsL

// Delete icon array

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

//

TInt CIconCustomApiTestModule::DeleteIconsL( CStifItemParser& /*aItem*/ )

    {

    if( !iIcons )

        {

        User::Leave( KErrNotFound );

        }

    delete iIcons;

    iIcons = NULL;

    return KErrNone;

    }

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

// CIconCustomApiTestModule::DeleteIconL

// Delete individual icon instance

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

//

TInt CIconCustomApiTestModule::DeleteIconL( CStifItemParser& /*aItem*/ )

    {

    if( !iIcon )

        {

        User::Leave( KErrNotFound );

        }

    delete iIcon;

    iIcon = NULL;

    return KErrNone;

    }

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

// CIconCustomApiTestModule::IconChoiceL

// Query plug-in for a icon choice to the previously given icon array

// Expect plug-in to provide a icon or otherwise fail

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

//

TInt CIconCustomApiTestModule::IconChoiceL( CStifItemParser& aItem )

    {

    User::LeaveIfNull( iTestPlugin );

    User::LeaveIfNull( iIcons );

    CCustomIconDecisionData* decisionData = BuildDecisionDataLC( aItem );

    TInt iconId( 0 );

    TBool iconFound = iTestPlugin->IconChoiceL( *decisionData, iconId );

    if( iconFound )

        {

        // Plug-in gave us an icon identifier. Now check if we have the

        // corresponding icon.

        CGulIcon* icon = NULL;

        TCustomIconIdMapItem item;

        for( TInt i=0; i<iIcons->Count(); i++ )

            {

            item = iIcons->At( i );

            if( item.iId == iconId )

                {

                icon = item.iIconPtr; // may return NULL

                break;

                }

            }

        if( !icon )

            {

            // icon in the icon array was NULL, or

            // icon was not found by given icon identifier

            //

            User::Leave( KErrNotFound );

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( decisionData );

    return KErrNone;

    }

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

// CIconCustomApiTestModule::SetPsProperty

// Define and set publish/subscribe property. This is used for configuring

// testing environment. For example the test plug-in reads the P/S values

// on its initialization phase.

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

//

TInt CIconCustomApiTestModule::SetPsProperty( CStifItemParser& aItem )

    {

    TInt key;

    TInt value;

    aItem.GetNextInt( key );

    aItem.GetNextInt( value );

    TSecurityPolicy readwritePolicy( TSecurityPolicy::EAlwaysPass );

    TUid sid = ProcessSID();

    TInt err = RProperty::Define(

        sid,

        key,

        RProperty::EInt,

        readwritePolicy,

        readwritePolicy );

    if(err == KErrNone || err == KErrAlreadyExists)

        {

        iPublishedPsKeys.Append( key );

        err = RProperty::Set( sid, key, value );

        }

    return err;

    }

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

// CIconCustomApiTestModule::DeletePsProperty

//

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

//

TInt CIconCustomApiTestModule::DeletePsProperty( CStifItemParser& aItem )

    {

    TInt key;

    aItem.GetNextInt( key );

    TInt err = RProperty::Delete( ProcessSID(), key );

    if( !err )

        {

        TInt index = iPublishedPsKeys.Find ( key );

        if( index >= 0 )

            {

            iPublishedPsKeys.Remove( index );

            }

        }

    return err;

    }

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

// CIconCustomApiTestModule::SetTestCaseAsObserver

//

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

//

TInt CIconCustomApiTestModule::SetTestCaseAsObserverL( CStifItemParser& aItem )

    {

    TBool setAsObserver;

    aItem.GetNextInt( setAsObserver );

    if( setAsObserver )

        {

        iTestPlugin->AddObserverL( this );

        }

    else

        {

        iTestPlugin->RemoveObserver( this );

        }

    return KErrNone;

    }

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

// CIconCustomApiTestModule::CheckIfHasExtensionL

//

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

//

TInt CIconCustomApiTestModule::CheckIfHasExtensionL( CStifItemParser& aItem )

    {

    TInt extensionUid;

    TBool expectedResult;

    User::LeaveIfError( aItem.GetNextInt( extensionUid ) );

    User::LeaveIfError( aItem.GetNextInt( expectedResult ) );

    TAny* extension =

        iTestPlugin->ContactCustomIconExtension( TUid::Uid( extensionUid ) );

    delete extension;

    if( expectedResult && extension ||

        !expectedResult && !extension )

        {

        return KErrNone;

        }

    else

        {

        return KErrGeneral;

        }

    }

//  End of File