/*

* Copyright (c) 2006-2010 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:  IETF SIMPLE Protocol implementation for XIMP Framework

*

*/

#include <e32std.h>

#include <s32strm.h>

#include <utf.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 <presenceinfofilter.h>

#include <msimplewinfo.h>

#include <msimpleelement.h>

#include <presenceinfo.h>

#include <presenceinfofieldcollection.h>

#include <personpresenceinfo.h>

#include <presenceinfofield.h>

#include <presenceinfofieldvalueenum.h>

#include <avabilitytext.h>

#include "presencepluginauthorization.h"

#include "presencepluginwinfo.h"

#include "presenceplugincommon.h"

#include "presencepluginxdmutils.h"

#include "presencepluginwatcher.h"

#include "presenceplugindata.h"

#include "presencepluginutility.h"

#include "presenceplugingroup.h"

#include "presencepluginvirtualgroup.h"

#include "presenceplugincontacts.h"

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

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

// CPresencePluginAuthorization::CPresencePluginAuthorization()

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

//

CPresencePluginAuthorization::CPresencePluginAuthorization(

    MPresencePluginConnectionObs& aObs,

    CPresencePluginData* aPresenceData )

    : CActive( CActive::EPriorityStandard ),

    iConnObs(aObs), iSubscribed( EFalse ),

    iOperation( ENoOperation ), iXdmOk( EFalse ),

    iComplete( EFalse ), iPresenceData( aPresenceData ),

    iContactIsStored( ETrue )

    {

    CActiveScheduler::Add(this);

    }

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

// CPresencePluginAuthorization::NewL()

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

//

CPresencePluginAuthorization* CPresencePluginAuthorization::NewL(

    MPresencePluginConnectionObs& aObs,

    CPresencePluginData* aPresenceData )

    {

    DP_SDA("CPresencePluginAuthorization::NewL ");

    CPresencePluginAuthorization* self =

        new( ELeave ) CPresencePluginAuthorization( aObs, aPresenceData );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPresencePluginAuthorization::ConstructL()

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

//

void CPresencePluginAuthorization::ConstructL()

    {

    HBufC* serviceName =

        iPresenceData->ServiceNameLC( iPresenceData->ServiceId() );

    iContacts = CPresencePluginContacts::NewL(

        iPresenceData->ServiceId(), *serviceName, *this );

    CleanupStack::PopAndDestroy( serviceName );

    }

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

// CPresencePluginAuthorization::~CPresencePluginAuthorization()

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

//

CPresencePluginAuthorization::~CPresencePluginAuthorization()

    {

    delete iPresIdentity;

    delete iContacts;

    }

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

// CPresencePluginAuthorization::SetDataHost()

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

//

void CPresencePluginAuthorization::SetDataHost( 

    MProtocolPresenceAuthorizationDataHost& aDataHost )

    {

    DP_SDA("CPresencePluginAuthorization::SetDataHost ");

    iDataHost = &aDataHost;

    }

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

// CPresencePluginAuthorization::WinfoTerminatedL()

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

// 

void CPresencePluginAuthorization::WinfoTerminatedL( TInt aReason )

    {

    DP_SDA("CPresencePluginAuthorization::WinfoTerminatedL ");

    if ( iSubscribed )

        {

        MXIMPDataSubscriptionState* myState =

            iConnObs.ObjectFactory().NewDataSubscriptionStateLC();

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

        myStatus->SetResultCode( aReason ? aReason : KErrCompletion );

        myState->SetSubscriptionStateL( 

            MXIMPDataSubscriptionState::ESubscriptionInactive );

        // parameters' OWNERSHIP is taken   

        iDataHost->SetPresenceGrantRequestDataSubscriptionStateL( 

            myState,  

            myStatus );

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

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

        }

    DP_SDA("CPresencePluginAuthorization::WinfoTerminatedL end");

    }

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

// CPresencePluginAuthorization::DoSubscribePresenceGrantRequestListL()

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

//

void CPresencePluginAuthorization::DoSubscribePresenceGrantRequestListL(

    TXIMPRequestId aReqId )

    {

    DP_SDA("DoSubscribePresenceGrantRequestListL ");

    iConnObs.WinfoHandlerL()->SubscribeWinfoListL( aReqId );

    iSubscribed = ETrue;

    }

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

// CPresencePluginAuthorization::DoUnsubscribePresenceGrantRequestListL()

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

//

void CPresencePluginAuthorization::DoUnsubscribePresenceGrantRequestListL(

    TXIMPRequestId aReqId )

    {

    DP_SDA("DoUnsubscribePresenceGrantRequestListL ");

    iConnObs.WinfoHandlerL()->UnsubscribeWinfoListL( aReqId );

    iSubscribed = EFalse;

    }

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

// CPresencePluginAuthorization::DoGrantPresenceForPresentityL()

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

//

void CPresencePluginAuthorization::DoGrantPresenceForPresentityL(

    const MXIMPIdentity& aPresentityId,

    const MPresenceInfoFilter& /*aPif*/,  // notice: pif support

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginAuthorization::DoGrantPresenceForPresentityL ");

    // Workaround for clients that can only grant when accepting buddy request.

    // SIMPLE also requires grant + subscribe so do both here even though

    // it is agains ximp api definitions.

    _LIT( KDefaultBuddyList, "buddylist" );

    iAuthState = EStateAcceptBuddyRequest;

    MXIMPIdentity* buddyList = iConnObs.ObjectFactory().NewIdentityLC(); 

    buddyList->SetIdentityL( KDefaultBuddyList() ); 

    iConnObs.GroupsL().DoAddPresentityGroupMemberL( *buddyList, aPresentityId,

        KNullDesC(), aReqId );

    CleanupStack::PopAndDestroy( 1 ); // buddyList 

    }

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

// CPresencePluginAuthorization::DoPerformGrantPresenceForPresentityL()

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

//

void CPresencePluginAuthorization::DoPerformGrantPresenceForPresentityL(

    const MXIMPIdentity& aPresentityId,

    TRequestStatus& aClientStatus )

    {

    DP_SDA("CPresencePluginAuthorization::DoPerformGrantPresenceForPresentityL");

    StartXdmOperationL( aPresentityId, 

        EGrantPresenceForPresentity, aClientStatus );

    }

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

// CPresencePluginAuthorization::DoUpdatePresenceGrantPifForPresentityL()

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

//

void CPresencePluginAuthorization::DoUpdatePresenceGrantPifForPresentityL(

    const MXIMPIdentity& /*aPresentityId*/,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

    // Notice: later

    User::Leave( KErrNotSupported );

    }

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

// CPresencePluginAuthorization::DoWithdrawPresenceGrantFromPresentityL()

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

//

void CPresencePluginAuthorization::DoWithdrawPresenceGrantFromPresentityL(

    const MXIMPIdentity& aPresentityId,

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginAuth::DoWithdrawPresenceGrantFromPresentityL ");

    StartXdmOperationL( aPresentityId, aReqId, EWithdrawFromPresentity );

    }

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

// CPresencePluginAuthorization::DoPerformWithdrawPresGrantFromPresentityL()

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

//

void CPresencePluginAuthorization::DoPerformWithdrawPresGrantFromPresentityL(

    const MXIMPIdentity& aPresentityId,

    TRequestStatus& aClientStatus )

    {

    DP_SDA("CPresencePluginAuthorization");

    DP_SDA(" -> DoPerformWithdrawPresGrantFromPresentityL");

    StartXdmOperationL( aPresentityId,

        EWithdrawFromPresentity, aClientStatus );

    }

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

// CPresencePluginAuthorization::DoGrantPresenceForPresentityGroupMembersL()

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

//

void CPresencePluginAuthorization::DoGrantPresenceForPresentityGroupMembersL(

    const MXIMPIdentity& /*aGroupId*/,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_SDA("CPresencePluginAuthorization::DoGrantPresenceForPresentityGroupMembersL -not supported");

    User::Leave( KErrNotSupported );

    }

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

// CPresencePluginAuthorization::

// DoUpdatePresenceGrantPifForPresentityGroupMembersL()

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

//

void CPresencePluginAuthorization::

    DoUpdatePresenceGrantPifForPresentityGroupMembersL(

    const MXIMPIdentity& /*aGroupId*/,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_SDA("CPresencePluginAuthorization::DoUpdatePresenceGrantPifForPresentityGroupMembersL -not supported");

    User::Leave( KErrNotSupported );

    }

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

// CPresencePluginAuthorization::

// DoWithdrawPresenceGrantFromPresentityGroupMembersL()

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

//

void CPresencePluginAuthorization::

    DoWithdrawPresenceGrantFromPresentityGroupMembersL(

    const MXIMPIdentity& /*aGroupId*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_SDA("CPresencePluginAuthorization::DoWithdrawPresenceGrantFromPresentityGroupMembersL -not supported");

    User::Leave( KErrNotSupported );

    }

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

// CPresencePluginAuthorization::DoGrantPresenceForEveryoneL()

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

//

void CPresencePluginAuthorization::DoGrantPresenceForEveryoneL(

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_SDA("CPresencePluginAuthorization::DoGrantPresenceForEveryoneL -not supported");

    User::Leave( KErrNotSupported );

    }

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

// CPresencePluginAuthorization::DoUpdatePresenceGrantPifForEveryoneL()

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

//

void CPresencePluginAuthorization::DoUpdatePresenceGrantPifForEveryoneL(

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

    DP_SDA("CPresencePluginAuthorization::DoUpdatePresenceGrantPifForEveryoneL -not supported");

    User::Leave( KErrNotSupported );

    }

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

// CPresencePluginAuthorization::DoWithdrawPresenceGrantFromEveryoneL()

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

//

void CPresencePluginAuthorization::DoWithdrawPresenceGrantFromEveryoneL(

    TXIMPRequestId /*aReqId*/ )

    {

    DP_SDA("CPresencePluginAuthorization::DoWithdrawPresenceGrantFromEveryoneL -not supported");

    User::Leave( KErrNotSupported );

    }

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

// CPresencePluginAuthorization::DoSubscribePresenceBlockListL()

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

//

void CPresencePluginAuthorization::DoSubscribePresenceBlockListL(

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginAuthorization::DoSubscribePresenceBlockListL ");

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

    StartXdmOperationL( *nobody, aReqId, ESubscribeBlockList );

    // Cannot PopAndDestroy by name

    CleanupStack::PopAndDestroy( );

    }

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

// CPresencePluginAuthorization::DoUnsubscribePresenceBlockListL()

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

//

void CPresencePluginAuthorization::DoUnsubscribePresenceBlockListL(

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginAuthorization::DoUnsubscribePresenceBlockListL ");

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

    StartXdmOperationL( *nobody, aReqId, EUnsubscribeBlockList );

    // Cannot PopAndDestroy by name

    CleanupStack::PopAndDestroy();

    }

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

// CPresencePluginAuthorization::DoBlockPresenceForPresentityL()

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

//

void CPresencePluginAuthorization::DoBlockPresenceForPresentityL(

    const MXIMPIdentity& aPresentityId,

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginAuthorization::DoBlockPresenceForPresentityL ");

    StartXdmOperationL( aPresentityId, aReqId, EBlockPresentity );

    }

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

// CPresencePluginAuthorization::DoPerformBlockPresenceForPresentityL()

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

//

void CPresencePluginAuthorization::DoPerformBlockPresenceForPresentityL(

    const MXIMPIdentity& aPresentityId,

    TRequestStatus& aClientStatus )

    {

    DP_SDA(

        "CPresencePluginAuthorization::DoPerformBlockPresenceForPresentityL");

    StartXdmOperationL( aPresentityId, EBlockPresentity, aClientStatus );

    }

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

// CPresencePluginAuthorization::DoCancelPresenceBlockFromPresentityL()

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

//

void CPresencePluginAuthorization::DoCancelPresenceBlockFromPresentityL(

    const MXIMPIdentity& aPresentityId,

    TXIMPRequestId aReqId )

    {

    DP_SDA(" DoCancelPresenceBlockFromPresentityL ");

    StartXdmOperationL( aPresentityId, aReqId, EUnblockPresentity );

    }

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

// CPresencePluginAuthorization::DoPerformCancelPresenceBlockFromPresentityL()

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

//

void CPresencePluginAuthorization::DoPerformCancelPresenceBlockFromPresentityL(

    const MXIMPIdentity& aPresentityId,

    TRequestStatus& aClientStatus )

    {

    DP_SDA(" DoPerformCancelPresenceBlockFromPresentityL (list)");

    StartXdmOperationL( aPresentityId, EUnblockPresentity, aClientStatus );

    }

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

// CPresencePluginAuthorization::DoCancel()

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

//

void CPresencePluginAuthorization::DoCancel(  )

    {

    iXdmUtils->Cancel();

    }

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

// CPresencePluginAuthorization::RunL()

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

//

void CPresencePluginAuthorization::RunL(  )

    {

    TInt myStatus = iStatus.Int();

    DP_SDA2( "CPresencePluginAuthorization::RunL mystatus %d ", myStatus );

    DP_SDA2( "CPresencePluginAuthorization::RunL state %d ",iOperation );

    if ( !iXdmOk && !myStatus )

        {

        DP_SDA( "CPresencePluginAuthorization::RunL !iXdmOk && !myStatus" );

        iXdmOk = ETrue;

        CallActualXdmOperationL();

        }

    else if ( iClientStatus )

        {

        DP_SDA( "CPresencePluginAuthorization::RunL - complete client" );

        TRequestStatus* s = iClientStatus;

        User::RequestComplete( s, myStatus );

        iClientStatus = NULL;

        DP_SDA( "CPresencePluginAuthorization::RunL - complete client ok" );

        }

    else if ( !myStatus )

        {

        switch ( iAuthState )

            {

            case EStateDoBlock:

                {

                DP_SDA( "CPresencePluginAuthorization::RunL - Block presentity" );

                BlockPresentityL();

                iAuthState = EStateRemovePresentityFromGranted;

                }

                break;

            case EStateRemovePresentityFromGranted:

                {

                DP_SDA( "CPresencePluginAuthorization::RunL - Remove presentity from granted" );

                WithdrawFromPresentityL();

                iAuthState = EStateBlocked;

                }

                break;

            case EStateBlocked:

                {

                DP_SDA( "CPresencePluginAuthorization::RunL - Blocked" );

                SetPresentityBlockedToXIMPL();

                iAuthState = EStateIdle;

                CompleteXIMPReq( myStatus );

                }

                break;

            case EStateIsContactBlockedBuddyRequest:

                {

                DP_SDA( "CPresencePluginAuthorization::RunL - Resolve contact type" );

                // resolve is contact blocked friend request

                HBufC* withoutPrefix = iPresenceData->RemovePrefixLC( *iPresIdentity );

                IsBlockedContactFriendRequestL( *withoutPrefix, *this, iStatus );

                CleanupStack::PopAndDestroy( withoutPrefix );

                SetActive();

                iAuthState = EStateDoUnBlock;

                }

                break;

            case EStateDoUnBlock:

                {

                if ( iContactIsStored )

                    {

                    DP_SDA( "CPresencePluginAuthorization::RunL - Grant presence for presentity" );

                    GrantPresenceForPresentityL();

                    iAuthState = EStatePresenceGranted;

                    }

                else

                    {

                    DP_SDA( "CPresencePluginAuthorization::RunL - Complete unblock" );

                    iAuthState = EStateIdle;

                    CompleteXIMPReq( myStatus );

                    }

                }

                break;

            case EStatePresenceGranted:

                {

                DP_SDA( "CPresencePluginAuthorization::RunL -Subscribe presentity presence" );  

                MXIMPIdentity* identity = iConnObs.ObjectFactory().NewIdentityLC();

                identity->SetIdentityL( iPresIdentity->Des() ); 

                iConnObs.WatcherHandlerL()->DoPerformSubscribePresentityPresenceL( *identity, iStatus );

                CleanupStack::PopAndDestroy( ); //identity 

                iAuthState = EStateIdle;

                SetActive();

                }

                break;

            default:

                {

                DP_SDA( "CPresencePluginAuthorization::RunL - default case" );

                CompleteXIMPReq( myStatus );

                }

                break;

            }

        }