/*

* Copyright (c) 2007 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 <ximpdatasubscriptionstate.h>

#include <protocolpresenceauthorizationdatahost.h>

#include <ximpobjectfactory.h>

#include <presenceobjectfactory.h>

#include <ximpstatus.h>

#include <ximpidentity.h>

#include <presencegrantrequestinfo.h>

#include <ximpobjectcollection.h>

#include <presenceblockinfo.h>

#include <presenceerrors.hrh>

#include <simplefactory.h>

#include <msimpleconnection.h>

#include <msimplewinfo.h>

#include <msimpleelement.h>

#include "simplepluginauthorization.h"

#include "simpleplugindebugutils.h"

#include "simplepluginwinfo.h"

#include "simplepluginxdmutils.h"

#include "simpleplugincommon.h"

#include "simplepluginconnection.h"

/**

    The design is the following one

    1. DoGrantPresenceForEveryOneL

      modify default rule to ALLOW.

    2. DoWithdrawPresenceFromEveryOneL

      if current rule is ALLOW then

        {  BLOCK  }

        otherwise no action.

    3. DoSubscribePresenceGrantRequestListL

      modify default rule to CONFIRM.

    4. DoUnsubscribePresenceGrantRequestListL

      if current rule is CONFIRM then

        { go to ALLOW  }

        otherwise no action.

*/

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

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

// CSimplePluginAuthorization::CSimplePluginAuthorization

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

//

CSimplePluginAuthorization::CSimplePluginAuthorization(

    MSimplePluginConnectionObs& aObs )

: CActive( CActive::EPriorityStandard ),

  iConnObs(aObs),

  iOperation(ENoOperation),

  iXdmOk(EFalse), iDefRule(ERuleDef), iWinfoSubs( EFalse )

    {

    CActiveScheduler::Add( this );

    }

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

// CSimplePluginAuthorization::ConstructL

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

//

void CSimplePluginAuthorization::ConstructL( )

    {

    }

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

// CSimplePluginAuthorization::NewL

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

//

CSimplePluginAuthorization* CSimplePluginAuthorization::NewL(

    MSimplePluginConnectionObs& aObs )

    {

    CSimplePluginAuthorization* self =

        new( ELeave ) CSimplePluginAuthorization( aObs );

    CleanupStack::PushL( self );

    self->ConstructL(  );

    CleanupStack::Pop( self );

#ifdef _DEBUG

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

#endif

    return self;

    }

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

// CSimplePluginAuthorization::~CSimplePluginAuthorization

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

//

CSimplePluginAuthorization::~CSimplePluginAuthorization()

    {

    delete iPresIdentity;

    }

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

// CSimplePluginAuthorization::SetDataHost

// We assume that this method is given by PrFw right after

// constrcution.

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

//

void CSimplePluginAuthorization::SetDataHost(

    MProtocolPresenceAuthorizationDataHost& aDataHost )

    {

    iDataHost = &aDataHost;

    }

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

// CSimplePluginAuthorization::WinfoTerminatedL

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

//

void CSimplePluginAuthorization::WinfoTerminatedL( TInt /*aReason*/ )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: WinfoTerminatedL") );

#endif

    if ( iWinfoSubs )

        {

        MXIMPDataSubscriptionState* myState = iConnObs.ObjectFactory().NewDataSubscriptionStateLC();

        MXIMPStatus* myStatus = iConnObs.ObjectFactory().NewStatusLC();

        // Notice: consider error codes

        myStatus->SetResultCode( KErrCompletion );

        myState->SetSubscriptionStateL(

            MXIMPDataSubscriptionState::ESubscriptionInactive );

        // parameters' OWNERSHIP is taken

        iDataHost->SetPresenceGrantRequestDataSubscriptionStateL(

            myState,

            myStatus );

        iWinfoSubs = EFalse;

        CleanupStack::Pop( /*myStatus*/ );

        CleanupStack::Pop( /*myState*/ );

        }

 }

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

// CSimplePluginAuthorization::DoSubscribePresenceGrantRequestListL

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

//

void CSimplePluginAuthorization::DoSubscribePresenceGrantRequestListL(

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoSubscribePresenceGrantRequestListL"));

#endif

    /*

    This means Reactive authorization, i.e. modify default rule as CONFIRM.

    Also this starts the WINFO subscription.

    Once the authorization request is received the

    MProtocolPresenceAuthorizationDataHost::HandlePresenceGrantRequestReceivedL shall

    be called in the host API.

    First make the watcher list SIP subscription and after that is completed

    in HandleIfMine then continue and modify XDMS authentication rule.

    HandleIfMine can be called also immediately if there already exists an WINFO subscrption.

    */

    iOperation = ESubscribePresenceGrantRequestList;

    iPrFwId = aReqId;

    TRAPD( err, iConnObs.WinfoHandlerL()->SubscribeWinfoListL( aReqId ));

    if ( err )

        {

        iOperation = ENoOperation;

        User::Leave( CSimplePluginConnection::HarmonizeErrorCode( err ));

        }

    else

        {

        iWinfoSubs = ETrue;

        }

    }

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

// CSimplePluginAuthorization::DoUnsubscribePresenceGrantRequestListL

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

//

void CSimplePluginAuthorization::DoUnsubscribePresenceGrantRequestListL(

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoUnsubscribePresenceGrantRequestListL TEST COVERS 4"));

#endif

    // First modify XDMS authentication rule and then unsubscribe

    // SIP watcher list subscription.

    TRAPD( err, DoStartXdmOperationL( aReqId, EUnsubscribePresenceGrantRequestList ));

    if ( err )

        {

        User::Leave( CSimplePluginConnection::HarmonizeErrorCode( err ));

        }

    iPrFwId = aReqId;

    }

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

// CSimplePluginAuthorization::DoGrantPresenceForPresentityL

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

//

void CSimplePluginAuthorization::DoGrantPresenceForPresentityL(

    const MXIMPIdentity& aPresentityId,

    const MPresenceInfoFilter& /*aPif*/,  // notice: pif not supported

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoGrantPresenceForPresentityL"));

#endif

    StartXdmOperationL( aPresentityId, aReqId, EGrantPresenceForPresentity );

    }

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

// CSimplePluginAuthorization::DoUpdatePresenceGrantPifForPresentityL

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

//

void CSimplePluginAuthorization::DoUpdatePresenceGrantPifForPresentityL(

    const MXIMPIdentity& /*aPresentityId*/,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoUpdatePresenceGrantPifForPresentityL"));

#endif

    // Notice: aPif filter not supported.

    User::Leave( KErrNotSupported );

    }

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

// CSimplePluginAuthorization::DoWithdrawPresenceGrantFromPresentityL

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

//

void CSimplePluginAuthorization::DoWithdrawPresenceGrantFromPresentityL(

    const MXIMPIdentity& aPresentityId,

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoWithdrawPresenceGrantFromPresentityL"));

#endif

    StartXdmOperationL( aPresentityId, aReqId, EWithdrawFromPresentity );

    }

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

// CSimplePluginAuthorization::DoGrantPresenceForPresentityGroupMembersL

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

//

void CSimplePluginAuthorization::DoGrantPresenceForPresentityGroupMembersL(

    const MXIMPIdentity& aGroupId,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoGrantPresenceForPresentityGroupMembersL"));

#endif

    StartXdmOperationL( aGroupId, aReqId, EGrantPresenceForPresentityGroupMembers );

    }

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

// CSimplePluginAuthorization::DoUpdatePresenceGrantPifForPresentityGroupMembersL

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

//

void CSimplePluginAuthorization::DoUpdatePresenceGrantPifForPresentityGroupMembersL(

    const MXIMPIdentity& /*aGroupId*/,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoUpdatePresenceGrantPifForPresentityGroupMembersL"));

#endif

    // Notice: aPif filter not supported

    User::Leave( KErrNotSupported );

    }

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

// CSimplePluginAuthorization::DoWithdrawPresenceGrantFromPresentityGroupMembersL

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

//

void CSimplePluginAuthorization::DoWithdrawPresenceGrantFromPresentityGroupMembersL(

    const MXIMPIdentity& aGroupId,

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoWithdrawPresenceGrantFromPresentityGroupMembersL"));

#endif

    StartXdmOperationL( aGroupId, aReqId, EWithdrawFromGroupMembers );

    }

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

// CSimplePluginAuthorization::DoGrantPresenceForEveryoneL()

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

//

void CSimplePluginAuthorization::DoGrantPresenceForEveryoneL(

    const MPresenceInfoFilter& /*aPif*/,   // // Notice: aPif filter not supported

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoGrantPresenceForEveryoneL"));

#endif

    MXIMPIdentity* nobody = iConnObs.ObjectFactory().NewIdentityLC();  // << nobody

    StartXdmOperationL( *nobody, aReqId, EGrantForEveryone );

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

    }

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

// CSimplePluginAuthorization::DoUpdatePresenceGrantPifForEveryoneL()

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

//

void CSimplePluginAuthorization::DoUpdatePresenceGrantPifForEveryoneL(

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoUpdatePresenceGrantPifForEveryoneL"));

#endif

    // Notice: aPif filter not supported

    User::Leave( KErrNotSupported );

    }

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

// CSimplePluginAuthorization::DoWithdrawPresenceGrantFromEveryoneL()

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

//

void CSimplePluginAuthorization::DoWithdrawPresenceGrantFromEveryoneL(

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoWithdrawPresenceGrantFromEveryoneL"));

#endif

    MXIMPIdentity* nobody = iConnObs.ObjectFactory().NewIdentityLC();  // << nobody

    StartXdmOperationL( *nobody, aReqId, EWithdrawFromEveryone );

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

    }

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

// CSimplePluginAuthorization::DoSubscribePresenceBlockListL()

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

//

void CSimplePluginAuthorization::DoSubscribePresenceBlockListL(

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoSubscribePresenceBlockListL"));

#endif

    MXIMPIdentity* nobody = iConnObs.ObjectFactory().NewIdentityLC();  // << nobody

    StartXdmOperationL( *nobody, aReqId, ESubscribeBlockList );

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

    }

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

// CSimplePluginAuthorization::DoUnsubscribePresenceBlockListL()

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

//

void CSimplePluginAuthorization::DoUnsubscribePresenceBlockListL(

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoUnsubscribePresenceBlockListL"));

#endif

    MXIMPIdentity* nobody = iConnObs.ObjectFactory().NewIdentityLC();  // << nobody

    StartXdmOperationL( *nobody, aReqId, EUnsubscribeBlockList );

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

    }

// Blocking presence information access from single presentities

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

// CSimplePluginAuthorization::DoBlockPresenceForPresentityL()

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

//

void CSimplePluginAuthorization::DoBlockPresenceForPresentityL(

    const MXIMPIdentity& aPresentityId,

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoBlockPresenceForPresentityL"));

#endif

    StartXdmOperationL( aPresentityId, aReqId, EBlockPresentity );

    }

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

// CSimplePluginAuthorization::DoCancelPresenceBlockFromPresentityL()

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

//

void CSimplePluginAuthorization::DoCancelPresenceBlockFromPresentityL(

    const MXIMPIdentity& aPresentityId,

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: DoCancelPresenceBlockFromPresentityL"));

#endif

    StartXdmOperationL( aPresentityId, aReqId, EUnblockPresentity );

    }

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

// CSimplePluginAuthorization::DoCancel()

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

//

void CSimplePluginAuthorization::DoCancel(  )

    {

    iXdmUtils->Cancel();

    }

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

// CSimplePluginAuthorization::RunL()

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

//

void CSimplePluginAuthorization::RunL(  )

    {

    TInt myStatus = iStatus.Int();

#ifdef _DEBUG

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

#endif

    if ( iOperation == EUnsubscribePresenceGrantRequestList && !myStatus )

        {

        // unsubscribe watcher list after successful default rule modification.

        TRAPD( err, iConnObs.WinfoHandlerL()->UnsubscribeWinfoListL( iPrFwId ));

        if ( err )

            {

            User::Leave( CSimplePluginConnection::HarmonizeErrorCode( err ));

            }

        else

            {

            // This will end to HandleIfMine.

            }

        }

    else if ( !iXdmOk && !myStatus )

        {

        iXdmOk = ETrue;

        CallActualXdmOperationL();

        }

    else // iXdmOK or myStatus

        {

        CompletePrFwReq( myStatus );

        }

    }

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

// CSimplePluginAuthorization::CallActualXdmOperationL

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

//

void CSimplePluginAuthorization::CallActualXdmOperationL()

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginAuthorization: CallActualXdmOperationL") );

#endif

    switch ( iOperation )

        {

        case EGrantPresenceForPresentity:

            // iPresIdentity can't be null in this case

            iXdmUtils->AddEntityToGrantedL( iPresIdentity->Des(), iStatus );

            SetActive();

            break;

        case EWithdrawFromPresentity:

            // iPresIdentity can't be null in this case

            iXdmUtils->RemoveEntityFromGrantedL( iPresIdentity->Des(),iStatus );

            SetActive();

            break;

        case EGrantPresenceForPresentityGroupMembers:

            // iPresIdentity can't be null in this case

            iXdmUtils->AddGroupToGrantedL( iPresIdentity->Des(), iStatus );

            SetActive();

            break;

        case EWithdrawFromGroupMembers:

            // iPresIdentity can't be null in this case

            iXdmUtils->RemoveGroupFromGrantedL( iPresIdentity->Des(), iStatus );

            SetActive();

            break;

        case EGrantForEveryone:

            iXdmUtils->GrantForEveryoneL( iStatus );

            SetActive();

            break;

        case EWithdrawFromEveryone:

            iXdmUtils->WithdrawFromEveryoneL( iStatus );

            SetActive();

            break;

        case ESubscribeBlockList:

            HandleSubscribeBlockListL();

            break;

        case EUnsubscribeBlockList:

            iXdmUtils->UnsubscribeBlockListL( iStatus );

            SetActive();

            break;

        case EBlockPresentity:

            // iPresIdentity can't be null in this case

            iXdmUtils->AddEntityToBlockedL( iPresIdentity->Des(), iStatus );

            SetActive();

            break;

        case EUnblockPresentity:

            // iPresIdentity can't be null in this case

            iXdmUtils->RemoveEntityFromBlockedL( iPresIdentity->Des(), iStatus );

            SetActive();

            break;

        case ESubscribePresenceGrantRequestList:

            iXdmUtils->SetReactiveAuthL( iStatus );

            SetActive();

            break;

        case EUnsubscribePresenceGrantRequestList:

        default:

            iXdmUtils->SetProactiveAuthL( iStatus );

            SetActive();

            break;