/*

* Copyright (c) 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:    SIMPLE Protocol implementation for Presence Framework

*

*/

#include <e32std.h>

#include <utf.h>

#include <simplefactory.h>

#include <msimpleconnection.h>

#include <pressettingsapi.h>

#include <cpresencexdm.h>

#include <rlspresxdmconsts.h>

#include <XdmErrors.h>

#include <prescondmisc.h>

#include <prescondidentityone.h>

#include <presenceactionxdm.h>

#include <presencetransformxdm.h>

#include <crlsxdm.h>

#include <XdmEngine.h>

#include <XdmDocument.h>

#include <XdmProtocolInfo.h>

#include <XdmDocumentNode.h>

#include <XdmNodeAttribute.h>

#include <XdmSettingsApi.h>

#include <XdmErrors.h>

#include "simpleplugindebugutils.h"

#include "simpleplugincommon.h"

#include "simplepluginxdmutils.h"

#include "simpleplugindata.h"

#include "simplepluginvariation.h"

#include "msimplepluginsettings.h"

// Test suite

#include "msimpleplugintestobs.h"

// This is for debugging and local test mode oly

#include <in_sock.h>

// URI prefixies

const TInt KMyLenPrefix = 4;

_LIT16( KMySip, "sip:" );

_LIT16( KMyTel, "tel:" );

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

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

// CSimplePluginXdmUtils::CSimplePluginXdmUtils

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

//

CSimplePluginXdmUtils::CSimplePluginXdmUtils(

    MSimplePluginSettings& aConnSets, TInt aXmdId )

: CActive( EPriorityStandard ),

  iConnSets(aConnSets), iSettingsId(aXmdId),

  iXdmState(EStateIdle), iOperation( ENoOperation), iTestObs( NULL )

    {

    CActiveScheduler::Add( this );

    }

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

// CSimplePluginXdmUtils::ConstructL

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

//

void CSimplePluginXdmUtils::ConstructL(  )

    {

    }

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

// CSimplePluginXdmUtils::NewL

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

//

CSimplePluginXdmUtils* CSimplePluginXdmUtils::NewL(

    MSimplePluginSettings& aConnSets,

    TInt aXmdId )

    {

    CSimplePluginXdmUtils* self =

        new( ELeave ) CSimplePluginXdmUtils( aConnSets, aXmdId );

    CleanupStack::PushL( self );

    self->ConstructL(   );

    CleanupStack::Pop( self );

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: NewL this=%d"), (TInt)self);

#endif

    return self;

    }

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

// CSimplePluginXdmUtils::~CSimplePluginXdmUtils()

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

//

CSimplePluginXdmUtils::~CSimplePluginXdmUtils()

    {

    Cancel();

    CancelWrappers();

    if ( iXdmDoc && iXdmEngine )

        {

        TRAP_IGNORE( iXdmEngine->DeleteDocumentModelL( iXdmDoc ));

        }

    delete iRlsXdm;

    delete iPresenceXdm;

    delete iXdmEngine;

    delete iAuxBuffer;

    delete iAuxBuffer2;

    }

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

// CSimplePluginXdmUtils::InitializeXdmL

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

//

void CSimplePluginXdmUtils::InitializeXdmL( TRequestStatus& aStatus )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: InitializeXdmL") );

#endif

    iOperation = EXdmInit;

    iClientStatus = &aStatus;

    if ( !iXdmOk )

        {

        GetXdmOMAListsL();

        iXdmState = EGetXdmOMALists;

        *iClientStatus = KRequestPending;

        }

    else if ( !iPresXdmOk )

        {

        GetXdmRulesL();

        *iClientStatus = KRequestPending;

        }

    else

        {

        // All is ok

        *iClientStatus = KRequestPending;

        CompleteClientReq( KErrNone );

        }

    }

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

// CSimplePluginXdmUtils::InitializeXdmsOnlyL

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

//

void CSimplePluginXdmUtils::InitializeXdmsOnlyL( TRequestStatus& aStatus )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: InitializeXdmsOnlyL") );

#endif

    iOperation = EXdmInitXdmsOnly;

    iClientStatus = &aStatus;

    if ( !iXdmOk )

        {

        GetXdmOMAListsL();

        iXdmState = EGetXdmOMAListsOnly;

        *iClientStatus = KRequestPending;

        }

    else

        {

        // All is ok

        *iClientStatus = KRequestPending;

        CompleteClientReq( KErrNone );

        }

    }

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

// CSimplePluginXdmUtils::RunL()

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

//

void CSimplePluginXdmUtils::RunL(  )

    {

    TPluginXdmState origState = iXdmState;

    iXdmState = EStateIdle;

    TInt myStatus = iStatus.Int();

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: RunL %d"), myStatus );

#endif

    if ( iTestObs )

        {

        // Test suite

        iTestObs->TestCallbackInRunL(

            myStatus, origState, iOperation, KNullDesC );

        }

#ifdef FAKE_XDM_OK

#ifdef _DEBUG

    // -191 = KErrHostUnreach in_sock.h

    if ( myStatus == KErrTimedOut || myStatus == KXcapErrorNetworkNotAvailabe || -191 )

        {

        PluginLogger::Log(_L("PluginXdmUtils : RunL FAKE_XDM_OK resets error code %d"), myStatus );

        myStatus = 0;

        }

#endif

#endif

    DoXdmRunL( origState, myStatus );

    }

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

// CSimplePluginXdmUtils::DoXdmRunL()

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

//

void CSimplePluginXdmUtils::DoXdmRunL( TPluginXdmState aOrigState, TInt aStatus )

    {

    switch ( aOrigState )

        {

        case EGetXdmOMALists:

        case EGetXdmOMAListsOnly:

            {

            // no OMA resource-list, let's start to create it.

            if ( CreateXdmOMAListsIfNeededL() )

                {

                iXdmState = aOrigState == EGetXdmOMALists ? ECreateXdmOMALists : ECreateXdmOMAListsOnly;

                }

            else

                {

                iXdmOk = ETrue;

                if ( !iPresXdmOk && aOrigState == EGetXdmOMALists )

                    {

                    GetXdmRulesL();

                    }

                else

                    {

                    CompleteClientReq( KErrNone );

                    }

                }

            }

            break;

        case ECreateXdmOMALists:

            {

            if ( aStatus )

                {

                CompleteClientReq( aStatus );

                }

            else

                {

                iXdmOk = ETrue;

                GetXdmRulesL();

                }

            }

            break;

        case ECreateXdmOMAListsOnly:

            {

            if ( !aStatus )

                {

                iXdmOk = ETrue;

                }

            CompleteClientReq( aStatus );

            }

            break;

        default:

            // complete reqular request

            CompleteClientReq( aStatus );

            break;

        };

    }

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

// CSimplePluginXdmUtils::CancelWrappers()

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

//

void CSimplePluginXdmUtils::CancelWrappers( )

    {

    iOperation = EXdmCancel;

    // Cancel M-class interface methods that calls callback method.

    if ( iXdmState == EGetRlsServices ||

         iXdmState == EUpdateRlsServices ||

         iXdmState == EReUpdateRlsServices )

        {

        iXdmState = ECancelDocument;

#ifdef _DEBUG

        PluginLogger::Log(_L("PluginXdm: -> iRlsXdm->Cancel"));

#endif

        // Better call Cancel() instead of CancelUpdateL().

        // It works and is easier to implement. Otherwise we should have here

        // SetActive(); iStatus=KRequestPending; User::WaitForRequest(iStatus)

        // and we should have implemented HandleRLSUpdateCancelL that completes

        // own iStatus.

        iRlsXdm->Cancel();

        }

    else if ( iXdmState == EGetXdmRules ||

              iXdmState == EUpdateXdmRules )

        {

        iXdmState = ECancelDocument;

#ifdef _DEBUG

        PluginLogger::Log(_L("PluginXdm: -> iPresenceXdm->Cancel"));

#endif

        iPresenceXdm->Cancel();

        }

    else

        {

        }

    }

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

// CSimplePluginXdmUtils::DoCancel()

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

//

void CSimplePluginXdmUtils::DoCancel(  )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: DoCancel"));

#endif

    iOperation = EXdmCancel;

    if ( iXdmState == EGetXdmOMALists || iXdmState == ECreateXdmOMALists ||

         iXdmState == EGetXdmOMAListsOnly || iXdmState == ECreateXdmOMAListsOnly ||

         iXdmState == EUpdateXdmOMAList )

        {

        // Cancel a request made to XDM Engine.

        iXdmState = ECancelDocument;

#ifdef _DEBUG

      PluginLogger::Log(_L("PluginXdm: iXdmEngine->CancelUpdate"));

#endif

        iXdmEngine->CancelUpdate( iXdmDoc );

        CompleteClientReq( KErrCancel );

        }

    else

        {

        // Cancel a request where we have completed our own iStatus.

        // Very rare posibility that this happens when GetXdmOMALists is not ready.

        // It's very hard to make it happen in test suite.

        }

    }

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

// CSimplePluginXdmUtils::RunError

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

//

TInt CSimplePluginXdmUtils::RunError( TInt aError )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: RunError"));

#endif

    // complete the open request

    CompleteClientReq( aError );

    return KErrNone;

    }

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

// CSimplePluginXdmUtils::FetchRlsL

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

//

void CSimplePluginXdmUtils::FetchRlsL(

    TRequestStatus& aStatus )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: FetchRlsL"));

#endif

    _LIT( KMyOper, "FetchRlsL");

    iClientStatus = &aStatus;

    iOperation = EXdmRlsFetch;

    if ( !iRlsXdm )

        {

        iRlsXdm = CRLSXDM::NewL( iSettingsId );

        }

    if ( iTestObs )

        {

        // Test suite

        iTestObs->TestCallbackAsynchL(

            KErrNone, iXdmState, iOperation, KMyOper );

        }

    // The following returns in MRLSPresXDMAsyncHandler callback

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: -> iRlsXdm->UpdateAllFromServerL"));

#endif

    User::LeaveIfError( iRlsXdm->UpdateAllFromServerL( this ));

    *iClientStatus = KRequestPending;

    iXdmState = EGetRlsServices;

    }

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

// CSimplePluginXdmUtils::AddRlsGroupL

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

//

void CSimplePluginXdmUtils::AddRlsGroupL(

    const TDesC&  aName )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: AddRlsGroupL"));

#endif

    iOperation = EXdmRlsAdd;

    HBufC16* buf = CreateRlsDocumentUri16LC(

        aName, iConnSets.CurrentSipPresentity(), iConnSets.CurrentDomain() );

    // KErrAlreadyExists

    TInt errx = iRlsXdm->AddServiceURIL( buf->Des() );

    if ( errx && errx != KErrAlreadyExists )

        {

        User::Leave( errx );

        }

    User::LeaveIfError( iRlsXdm->SwitchToServiceURIL( buf->Des() ));

    HBufC* xcapUri = TXdmSettingsApi::PropertyL( iSettingsId, EXdmPropUri );

    CleanupStack::PushL( xcapUri );             // << xcapUri

    HBufC* listUri = MakeRlsBuddyUriL( xcapUri->Des(), aName );

    CleanupStack::PushL( listUri );             // << listUri

    TInt err = iRlsXdm->AddElementL( KPresResourceList,

        listUri->Des(), aName );

    if ( err && err != KErrAlreadyExists )

        {

        User::Leave( err );

        }

    // Save aName for RLS Service URI negoriation handling (HTTP error 409).

    // Notice: We assume that only one AddRlsGroupL is called between CommitRlsL methods.

    delete iAuxBuffer;

    iAuxBuffer = NULL;

    iAuxBuffer = aName.AllocL();

    CleanupStack::PopAndDestroy( listUri );     // >> listUri

    CleanupStack::PopAndDestroy( xcapUri );     // >> xcapUri

    CleanupStack::PopAndDestroy( buf );

    }

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

// CSimplePluginXdmUtils::RemoveRlsGroupL

// Use RemoveRlsServiceByResourceListL when possible

//

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

//

void CSimplePluginXdmUtils::RemoveRlsGroupL(

    const TDesC&  aName )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: RemoveRlsGroupL"));

#endif

    iOperation = EXdmRlsRemove;

    HBufC16* buf = CreateRlsDocumentUri16LC(

        aName, iConnSets.CurrentSipPresentity(), iConnSets.CurrentDomain() );

    User::LeaveIfError( iRlsXdm->RemoveServiceURIL( buf->Des()));

    CleanupStack::PopAndDestroy( buf );

    }

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

// CSimplePluginXdmUtils::AddEntityToGrantedL

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

//

void CSimplePluginXdmUtils::AddEntityToGrantedL(

    const TDesC&  aUri, TRequestStatus& aStatus )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: AddEntityToGrantedL"));

#endif

    iClientStatus = &aStatus;

    iOperation = EXdmAddUserToGroup;

    DoAddUserToListL( iConnSets.Variation().GrantListName(), aUri );

    // send to the server and start wait a response

    UpdateXdmsL();

    iXdmState = EUpdateXdmOMAList;

    *iClientStatus = KRequestPending;

    }

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

// CSimplePluginXdmUtils::AddEntityToBlockedL

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

//

void CSimplePluginXdmUtils::AddEntityToBlockedL(

    const TDesC&  aUri, TRequestStatus& aStatus )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginXdm: AddEntityToBlockedL"));

#endif

    iClientStatus = &aStatus;

    iOperation = EXdmAddUserToGroup;

    DoAddUserToListL( KSimpleOMABlockedList, aUri );

    // send to the server and start wait a response

    UpdateXdmsL();

    iXdmState = EUpdateXdmOMAList;

    *iClientStatus = KRequestPending;

    }

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

// CSimplePluginXdmUtils::DoAddUserToListL

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

//

void CSimplePluginXdmUtils::DoAddUserToListL(

    const TDesC& aList, const TDesC&  aUri )

    {