/*

* Copyright (c) 2002-2005 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:  Test utilities for WV engine

*

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    <CoreApplicationUIsSDKCRKeys.h>

#include    "impsservercommon.h"

#include    "impsutils.h"

#include    "impserrors.h"

#include    "impsservices.h"

#include    "impssrvutils.h"

#include    "impskey.h"

#include    "impssdatautils.h"

#include    "impsfields.h"

#include    "wvengineinternalcrkeys.h"

// MACROS

#ifdef _DEBUG

#define _IMPS_LOGGING_

#endif

// CONSTANTS

#ifdef _DEBUG

_LIT8( KImpsIniPollTime, "PollTime" );

_LIT8( KImpsIniXmlLog, "XmlLog" );

_LIT8( KImpsIniXmlPollingLog, "XmlPollingLog" );

_LIT8( KImpsIniNoWAPSMSCIR, "NoWAPSMSCIR" );

_LIT8( KImpsIniNoWAPUDPCIR, "NoWAPUDPCIR" );

_LIT8( KImpsIniNoTCPSCIR, "NoTCPSCIR" );

_LIT8( KImpsIniNoUDPSCIR, "NoUDPSCIR" );

_LIT8( KImpsIniKeepAlive, "KeepAlive" );

_LIT8( KImpsIniCIRModePollTime, "CIRModePollTime" );

_LIT8( KImpsIniMultiTrans, "MultiTrans" );

_LIT8( KImpsIniACExpiry, "ACExpiry" );

_LIT8( KImpsIniGRExpiry, "GRExpiry" );

_LIT8( KImpsIniPRExpiry, "PRExpiry" );

_LIT8( KImpsIniFUExpiry, "FUExpiry" );

_LIT8( KImpsIniIMExpiry, "IMExpiry" );

_LIT8( KImpsIniPDPExpiry, "PDPExpiry" );

_LIT8( KImpsIni4WayLogin, "4WayLogin" );

_LIT8( KImpsIniMaxMessageSize, "MaxMessageSize" );

#endif

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

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

// TImpsSrvUtils::InitializeServices

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

//

void TImpsSrvUtils::InitializeServices(

    TImpsServices& aServices, TBool aReactive )

    {

    // clear the service tree

    Mem::FillZ( &aServices, sizeof( TImpsServices ) );

    // IM Send NewMessage and receive are requested plus IMAuthFunc

    TImpsFeature* feat = aServices.Feature( EIMFeat );

    feat->SetSupported( ETrue );

    feat->SetFunction( EAllFuncs , ETrue );

    feat->SetCapability( KImpsServiceNEWM | KImpsServiceGLBLU

                         | KImpsServiceBLENT , ETrue );

    // All group features are requested

    feat = aServices.Feature( EGroupFeat );

    feat->SetSupported( ETrue );

    feat->SetFunction( EAllFuncs, ETrue );

    feat->SetCapability( 0xFFFFFFFF , ETrue );  //lint !e569

    // Reactive Presence is optional, if it is supported

    // then the entire Presence is supported.

    // WV 1.2 contains a new element GETAUT but there is no

    // need to handle that separately, since the entire Presence

    // is negotiated then.

    feat = aServices.Feature( EPresenceFeat );

    feat->SetSupported( ETrue );

    if ( aReactive )

        {

        feat->SetFunction( EAllFuncs, ETrue );

        feat->SetCapability( 0xFFFFFFFF , ETrue );  //lint !e569

        }

    else

        {

        // Part of presence features are requested

        // PresenceAuth functions has limited support.

        feat->SetFunction( EPresenceAuthFunc, ETrue );

        feat->SetCapability(

            KImpsServiceGETWL, ETrue );

        feat->SetFunction( EContListFunc, ETrue );

        feat->SetCapability( KImpsServiceGCLI |

                             KImpsServiceCCLI | KImpsServiceDCLI | KImpsServiceMCLS, ETrue );

        feat->SetFunction( EAttrListFunc, ETrue );

        feat->SetCapability(

            KImpsServiceCALI | KImpsServiceDALI | KImpsServiceGALS , ETrue );

        feat->SetFunction( EPresenceDeliverFunc, ETrue );

        feat->SetCapability( KImpsServiceGETPR | KImpsServiceUPDPR, ETrue );

        }

    // Part of fundamental features are requested:

    //   SearchFunc and InviteFunc supported.

    //   ServiceFunc not supported.

    feat = aServices.Feature( EFundamentalFeat );

    feat->SetSupported( ETrue );

    feat->SetFunction( EInviteFunc, ETrue );

    feat->SetFunction( ESearchFunc , ETrue );

    feat->SetCapability( KImpsServiceINVIT | KImpsServiceCAINV |

                         KImpsServiceSRCH | KImpsServiceSTSRC, ETrue );

    }

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

// TImpsSrvUtils::DiscardServicesL

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

void TImpsSrvUtils::DiscardServicesL(

    MImpsDataAccessor* aData,

    TImpsServices* aServices  )

    {

    CImpsKey* myKey = CImpsKey::NewLC();   // <<< myKey

    TImpsSDataUtils::AddValuesFromArrayL(

        myKey,

        KClientServiceResElements,

        sizeof( KClientServiceResElements ) /

        sizeof( KClientServiceResElements[0] ) );

    // notice: ignore Client id this time

    // Discareded Functions

    myKey->AddL( CREATEKEY( EImpsKeyFunctions, 0 ) );

    if ( !aData->CheckBranchExistenceL( myKey ) )

        {

        // Nothing is denied.

        CleanupStack::PopAndDestroy( 1 );

        return;

        }

    myKey->AddL( CREATEKEY( EImpsKeyWVCSPFeat, 0 ) );

    TInt enumi( 0 );

    TInt index( 0 );

    TImpsKeyType kType;

    if ( aData->CheckBranchExistenceL( myKey ) )

        {

        // Check if empty WVCSPFeat. That means deny all.

        // Decoder may have inserted the element with empty data although

        // it has a child. Therefore RestoreEmptyL cannot be used here.

        if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

            {

            // All is denied

            TImpsFeature* imF = aServices->Feature( EIMFeat );

            imF->SetSupported( EFalse );

            imF->SetFunction( EAllFuncs, EFalse );

            imF->SetCapability( 0xFFFFFFFF , EFalse );

            TImpsFeature* prF = aServices->Feature( EPresenceFeat );

            prF->SetSupported( EFalse );

            prF->SetFunction( EAllFuncs, EFalse );

            prF->SetCapability( 0xFFFFFFFF , EFalse );

            TImpsFeature* funF = aServices->Feature( EFundamentalFeat );

            funF->SetSupported( EFalse );

            funF->SetFunction( EAllFuncs, EFalse );

            funF->SetCapability( 0xFFFFFFFF , EFalse );

            TImpsFeature* grF = aServices->Feature( EGroupFeat );

            grF->SetSupported( EFalse );

            grF->SetFunction( EAllFuncs, EFalse );

            grF->SetCapability( 0xFFFFFFFF , EFalse );

            CleanupStack::PopAndDestroy( 1 );

            return;

            }

        // IM

        myKey->AddL( CREATEKEY( EImpsKeyIMFeat, 0 ) );

        if ( aData->CheckBranchExistenceL( myKey ) )

            {

            TImpsFeature* imF = aServices->Feature( EIMFeat );

            if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                {

                // Whole IM denied

                imF->SetSupported( EFalse );

                imF->SetFunction( EAllFuncs, EFalse );

                imF->SetCapability( 0xFFFFFFFF , EFalse );

                }

            else

                {

                // Let's check functions too, although server should not send these

                // because of we have not ordered them.

                myKey->AddL( CREATEKEY( EImpsKeyIMSendFunc, 0 ) );

                if ( aData->CheckBranchExistenceL( myKey ) )

                    {

                    if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                        {

                        // EImpsKeyIMSendFunc not supported

                        imF->SetFunction( EIMSendFunc, EFalse );

                        }

                    // we are not interested in IMSendFunc details now.

                    }

                // IMReceiveFunc

                myKey->ReplaceLastL( CREATEKEY( EImpsKeyIMReceiveFunc, 0 ) );

                if ( aData->CheckBranchExistenceL( myKey ) )

                    {

                    if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                        {

                        // EImpsKeyIMReceiveFunc not supported

                        imF->SetFunction( EIMReceiveFunc, EFalse );

                        imF->SetCapability( KImpsServiceNEWM , EFalse );

                        }

                    else

                        {

                        // Check if NEWM not supported

                        myKey->AddL( CREATEKEY( EImpsKeyNEWM , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            imF->SetCapability( KImpsServiceNEWM, EFalse );

                            }

                        myKey->PopL();

                        }

                    }

                // IMAuthFunc

                myKey->ReplaceLastL( CREATEKEY( EImpsKeyIMAuthFunc , 0 ) );

                if ( aData->CheckBranchExistenceL( myKey ) )

                    {

                    if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                        {

                        // IMAuthFunc not supported

                        imF->SetFunction( EIMAuthFunc, EFalse );

                        imF->SetCapability( KImpsServiceGLBLU | KImpsServiceBLENT, EFalse );

                        }

                    else

                        {

                        // Check if GLBLU not supported

                        myKey->AddL( CREATEKEY( EImpsKeyGLBLU , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            imF->SetCapability( KImpsServiceGLBLU, EFalse );

                            }

                        // Check if BLENT not supported

                        myKey->ReplaceLastL( CREATEKEY( EImpsKeyBLENT , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            imF->SetCapability( KImpsServiceBLENT, EFalse );

                            }

                        myKey->PopL();

                        }

                    }

                myKey->PopL();

                }

            } // IM

        // Presence

        myKey->ReplaceLastL( CREATEKEY( EImpsKeyPresenceFeat, 0 ) );

        if ( aData->CheckBranchExistenceL( myKey ) )

            {

            TImpsFeature* prF = aServices->Feature( EPresenceFeat );

            if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                {

                // Presence totally denied

                prF->SetSupported( EFalse );

                prF->SetFunction( EAllFuncs, EFalse );

                prF->SetCapability( 0xFFFFFFFF , EFalse );

                }

            else

                {

                // Check first AttListFunc

                myKey->AddL( CREATEKEY( EImpsKeyAttListFunc, 0 ) );

                if ( aData->CheckBranchExistenceL( myKey ) )

                    {

                    if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                        {

                        // AttListFunc not supported

                        prF->SetFunction( EAttrListFunc, EFalse );

                        prF->SetCapability( KImpsServiceCALI | KImpsServiceDALI |

                                            KImpsServiceGALS, EFalse );

                        }

                    else

                        {

                        // Check CALI

                        myKey->AddL( CREATEKEY( EImpsKeyCALI , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            prF->SetCapability( KImpsServiceCALI, EFalse );

                            }

                        // Check DALI

                        myKey->ReplaceLastL( CREATEKEY( EImpsKeyDALI , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            prF->SetCapability( KImpsServiceDALI, EFalse );

                            }

                        // Check GALS

                        myKey->ReplaceLastL( CREATEKEY( EImpsKeyGALS , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            prF->SetCapability( KImpsServiceGALS, EFalse );

                            }

                        myKey->PopL();

                        }

                    }

                // PresenceDeliverFunc

                myKey->ReplaceLastL( CREATEKEY( EImpsKeyPresenceDeliverFunc, 0 ) );

                if ( aData->CheckBranchExistenceL( myKey ) )

                    {

                    if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                        {

                        // PresenceDeliverFunc not supported

                        prF->SetFunction( EPresenceDeliverFunc, EFalse );

                        prF->SetCapability( KImpsServiceGETPR | KImpsServiceUPDPR, EFalse );

                        }

                    else

                        {

                        // Check GETPR

                        myKey->AddL( CREATEKEY( EImpsKeyGETPR , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            prF->SetCapability( KImpsServiceGETPR, EFalse );

                            }

                        // Check UPDPR

                        myKey->ReplaceLastL( CREATEKEY( EImpsKeyUPDPR , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            prF->SetCapability( KImpsServiceUPDPR, EFalse );

                            }

                        myKey->PopL();

                        }

                    }

                // PresenceAuthFunc

                // Get the WV version since WV 1.2 includes a brand new

                // element GETAUT.

                CImpsFields* f = aData->GetImpsFields();

                TImpsCspVersion ver = f->CspVersion();

                myKey->ReplaceLastL( CREATEKEY( EImpsKeyPresenceAuthFunc, 0 ) );

                if ( aData->CheckBranchExistenceL( myKey ) )

                    {

                    if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                        {

                        // PresenceAuthFunc not supported

                        prF->SetFunction( EPresenceAuthFunc, EFalse );

                        prF->SetCapability( KImpsServiceGETWL | KImpsServiceREACT |

                                            KImpsServiceCAAUT, EFalse );

                        }

                    else

                        {

                        // Check GETWL

                        myKey->AddL( CREATEKEY( EImpsKeyGETWL, 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            prF->SetCapability( KImpsServiceGETWL, EFalse );

                            }

                        // Check REACT

                        myKey->ReplaceLastL( CREATEKEY( EImpsKeyREACT, 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            prF->SetCapability( KImpsServiceREACT, EFalse );

                            }

                        // Check CAAUT

                        myKey->ReplaceLastL( CREATEKEY( EImpsKeyCAAUT, 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            prF->SetCapability( KImpsServiceCAAUT, EFalse );

                            }

                        // Check GETAUT, clear it always in WV 1.1

                        myKey->ReplaceLastL( CREATEKEY( EImpsKeyGETAUT, 0 ) );

                        if ( ver == EImpsCspVersion11 ||

                             ( aData->RestoreEmptyL( myKey ) ) )

                            {

                            prF->SetCapability( KImpsServiceGETAUT, EFalse );

                            }

                        myKey->PopL();

                        }

                    // ContactListFunc

                    myKey->ReplaceLastL( CREATEKEY( EImpsKeyContListFunc, 0 ) );

                    if ( aData->CheckBranchExistenceL( myKey ) )

                        {

                        if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                            {

                            // ContactListFunc not supported

                            prF->SetFunction( EContListFunc, EFalse );

                            prF->SetCapability( KImpsServiceGCLI | KImpsServiceCCLI |

                                                KImpsServiceDCLI | KImpsServiceMCLS, EFalse );

                            }

                        else

                            {

                            // Check GCLI

                            myKey->AddL( CREATEKEY( EImpsKeyGCLI, 0 ) );

                            if ( aData->RestoreEmptyL( myKey ) )

                                {

                                prF->SetCapability( KImpsServiceGCLI, EFalse );

                                }

                            // Check CCLI

                            myKey->ReplaceLastL( CREATEKEY( EImpsKeyCCLI, 0 ) );

                            if ( aData->RestoreEmptyL( myKey ) )

                                {

                                prF->SetCapability( KImpsServiceCCLI, EFalse );

                                }

                            // Check DCLI

                            myKey->ReplaceLastL( CREATEKEY( EImpsKeyDCLI, 0 ) );

                            if ( aData->RestoreEmptyL( myKey ) )

                                {

                                prF->SetCapability( KImpsServiceDCLI, EFalse );

                                }

                            // Check MCLS

                            myKey->ReplaceLastL( CREATEKEY( EImpsKeyMCLS, 0 ) );

                            if ( aData->RestoreEmptyL( myKey ) )

                                {

                                prF->SetCapability( KImpsServiceMCLS, EFalse );

                                }

                            myKey->PopL();

                            }

                        }

                    }

                myKey->PopL();

                }

            } // Presence

        // Fundamental

        myKey->ReplaceLastL( CREATEKEY( EImpsKeyFundamentalFeat, 0 ) );

        if ( aData->CheckBranchExistenceL( myKey ) )

            {

            TImpsFeature* fF = aServices->Feature( EFundamentalFeat );

            if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                {

                // Fundamental totally denied

                fF->SetSupported( EFalse );

                fF->SetFunction( EAllFuncs, EFalse );

                fF->SetCapability( 0xFFFFFFFF , EFalse );

                }

            else

                {

                // Check first SearchFunc

                myKey->AddL( CREATEKEY( EImpsKeySearchFunc, 0 ) );

                if ( aData->CheckBranchExistenceL( myKey ) )

                    {

                    if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                        {

                        // SearchFunc not supported

                        fF->SetFunction( ESearchFunc, EFalse );

                        fF->SetCapability( KImpsServiceSRCH | KImpsServiceSTSRC, EFalse );

                        }

                    else

                        {

                        // Check SRCH

                        myKey->AddL( CREATEKEY( EImpsKeySRCH , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            fF->SetCapability( KImpsServiceSRCH, EFalse );

                            }

                        // Check STSRC

                        myKey->ReplaceLastL( CREATEKEY( EImpsKeySTSRC , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            fF->SetCapability( KImpsServiceSTSRC, EFalse );

                            }

                        myKey->PopL();

                        }

                    }

                // InviteFunc

                myKey->ReplaceLastL( CREATEKEY( EImpsKeyInviteFunc, 0 ) );

                if ( aData->CheckBranchExistenceL( myKey ) )

                    {

                    if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                        {

                        // InviteFunc not supported

                        fF->SetFunction( EInviteFunc, EFalse );

                        fF->SetCapability( KImpsServiceINVIT | KImpsServiceCAINV, EFalse );

                        }

                    else

                        {

                        // Check INVIT

                        myKey->AddL( CREATEKEY( EImpsKeyINVIT , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            fF->SetCapability( KImpsServiceINVIT, EFalse );

                            }

                        // Check CAINV

                        myKey->ReplaceLastL( CREATEKEY( EImpsKeyCAINV , 0 ) );

                        if ( aData->RestoreEmptyL( myKey ) )

                            {

                            fF->SetCapability( KImpsServiceCAINV, EFalse );

                            }

                        myKey->PopL();

                        }

                    }

                myKey->PopL();

                }

            // We are not interested in ServiceFunc now

            } // Fundamental

        // Group

        TImpsFeature* grF = aServices->Feature( EGroupFeat );

        myKey->ReplaceLastL( CREATEKEY( EImpsKeyGroupFeat, 0 ) );

        if ( aData->CheckBranchExistenceL( myKey ) )

            {

            if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )

                {

                // Group totally denied

                grF->SetSupported( EFalse );

                grF->SetFunction( EAllFuncs, EFalse );

                grF->SetCapability( 0xFFFFFFFF , EFalse );

                }

            else

                {

                // Check first GroupMgmtFunc

                myKey->AddL( CREATEKEY( EImpsKeyGroupMgmtFunc, 0 ) );

                if ( aData->CheckBranchExistenceL( myKey ) )

                    {

                    if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) )