/*

* 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:  IMPS Protocol implementation for Presence Framework

*

*/

#include <badesca.h>

#include <ximpbase.h>

#include <ximpidentity.h>

#include <ximpprotocolconnectionhost.h>

#include "cimpsprotocolpresenceauthorization.h"

#include "impsdebugprint.h"

#include "cimpspluginconnectionmanager.h"

#include "csubscribepresencegrantrequestlistrequest.h"

#include "cgrantpresenceforpresentityrequest.h"

#include "cupdatepresencegrantpifforpresentityrequest.h"

#include "cwithdrawpresencegrantfrompresentityrequest.h"

#include "cgrantpresenceforpresentitygroupmembersrequest.h"

#include "cupdatepresencegrantpifforpresentitygroupmembersrequest.h"

#include "cwithdrawpresencegrantfrompresentitygroupmembersrequest.h"

#include "cgrantpresenceforeveryonerequest.h"

#include "cupdatepresencegrantpifforeveryonerequest.h"

#include "cwithdrawpresencegrantfromeveryonerequest.h"

#include "csubscribepresenceblocklistrequest.h"

#include "cblockpresenceforpresentityrequest.h"

#include "ccancelpresenceblockfrompresentityrequest.h"

#include "cpresenceauthuserrequest.h"

#include "impspluginpanics.h"

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

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

// CImpsConnection::GetInterface()

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

//

TAny* CImpsProtocolPresenceAuthorization::GetInterface( TInt32 aInterfaceId,

                                                        TIfGetOps aOptions )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsProtocolPresenceAuthorization::GetInterface() Start" ) );

    if ( aInterfaceId == MProtocolPresenceAuthorization::KInterfaceId )

        {

        MProtocolPresenceAuthorization* self = this;

        return self;

        }

    if ( aOptions == MXIMPBase::EPanicIfUnknown )

        {

        User::Panic( KImpsProtocolPresenceAuthorization, KErrExtensionNotSupported );

        }

    IMPS_DP( D_IMPS_LIT( "CImpsProtocolPresenceAuthorization::GetInterface() End" ) );

    return NULL;

    }

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

// CImpsConnection::GetInterface()

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

//

const TAny* CImpsProtocolPresenceAuthorization::GetInterface( TInt32 aInterfaceId,

                                                              TIfGetOps aOptions ) const

    {

    IMPS_DP( D_IMPS_LIT( "CImpsProtocolPresenceAuthorization::GetInterface() Start" ) );

    if ( aInterfaceId == MProtocolPresenceAuthorization::KInterfaceId )

        {

        const MProtocolPresenceAuthorization* self = this;

        return self;

        }

    if ( aOptions == MXIMPBase::EPanicIfUnknown )

        {

        User::Panic( KImpsProtocolPresenceAuthorization, KErrExtensionNotSupported );

        }

    IMPS_DP( D_IMPS_LIT( "CImpsProtocolPresenceAuthorization::GetInterface() End" ) );

    return NULL;

    }

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

// CImpsConnection::NewInstanceLC()

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

//

TInt32 CImpsProtocolPresenceAuthorization::GetInterfaceId() const

    {

    IMPS_DP( D_IMPS_LIT( "CImpsProtocolPresenceAuthorization::GetInterfaceId() Start-End" ) );

    return MProtocolPresenceAuthorization::KInterfaceId;

    }

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

// CImpsProtocolPresenceAuthorization::CImpsProtocolPresenceAuthorization()

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

//

CImpsProtocolPresenceAuthorization::CImpsProtocolPresenceAuthorization(

    MImpsPrtPluginConnectionManager& aConnMan )

        : iConnMan( aConnMan )

    {

    IMPS_DP( D_IMPS_LIT( "::CImpsProtocolPresenceAuthorization() Start-End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::ConstructL()

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

//

void CImpsProtocolPresenceAuthorization::ConstructL()

    {

    IMPS_DP( D_IMPS_LIT( "CImpsProtocolPresenceAuthorization::ConstructL() Start" ) );

    IMPS_DP( D_IMPS_LIT( "CImpsProtocolPresenceAuthorization::ConstructL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::NewL()

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

//

CImpsProtocolPresenceAuthorization* CImpsProtocolPresenceAuthorization::NewL(

    MImpsPrtPluginConnectionManager& aConnMan )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsProtocolPresenceAuthorization::NewL() Start" ) );

    CImpsProtocolPresenceAuthorization* self =

        new( ELeave ) CImpsProtocolPresenceAuthorization( aConnMan );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    IMPS_DP( D_IMPS_LIT( "CImpsProtocolPresenceAuthorization::NewL() End" ) );

    return self;

    }

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

// CImpsProtocolPresenceAuthorization::~CImpsProtocolPresenceAuthorization()

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

//

CImpsProtocolPresenceAuthorization::~CImpsProtocolPresenceAuthorization()

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::~CImpsProtocolPresenceAuthorization() Start" ) );

    IMPS_DP( D_IMPS_LIT( "Authorization::~CImpsProtocolPresenceAuthorization() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoUnsubscribePresenceWatcherListL()

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

//

void CImpsProtocolPresenceAuthorization::DoSubscribePresenceGrantRequestListL(

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoSubscribePresenceGrantRequestListL() Start" ) );

    CreateDataHandlerL();

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CSubscribePresenceGrantRequestListRequest* req =

        CSubscribePresenceGrantRequestListRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->SubscribePresenceGrantRequestListL();

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoSubscribePresenceGrantRequestListL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoUnsubscribePresenceWatcherListL()

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

//

void CImpsProtocolPresenceAuthorization::DoUnsubscribePresenceGrantRequestListL(

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoUnsubscribePresenceGrantRequestListL() Start" ) );

    // complete the request successfully

    iConnMan.HandleToHost().HandleRequestCompleted( aReqId, KErrNone );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoUnsubscribePresenceGrantRequestListL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoGrantPresenceForPresentityL()

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

//

void CImpsProtocolPresenceAuthorization::DoGrantPresenceForPresentityL(

    const MXIMPIdentity & aIdentity,

    const MPresenceInfoFilter & aPif,

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoGrantPresenceForPresentityL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    HBufC* PresentityName;

    // find to the iPendingReactiveAuthPresenceGrantList array

    PresentityName = aIdentity.Identity().AllocL();

    TInt index = iConnMan.PresenceAuthGrantReqList()->Find( *PresentityName );

    TInt count = iConnMan.PresenceAuthGrantReqList()->Count();

    delete PresentityName;

    if ( index != KErrNotFound )

        {

        IMPS_DP( D_IMPS_LIT( "iPresenceAuthGrantReqList Find returns %d" ), index );

        // send response to presence-auth request to the server

        SendResponseForReactiveAuthRequestL( aIdentity, aPif, aReqId );

        return;

        }

    IMPS_DP( D_IMPS_LIT( " No pending ReactiveAuthrequest " ) );

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CGrantPresenceForPresentityRequest* req =

        CGrantPresenceForPresentityRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->GrantPresenceForPresentityL( aIdentity, aPif );

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoGrantPresenceForPresentityL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoUpdateGrantPresenceForPresentityL()

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

//

void CImpsProtocolPresenceAuthorization::DoUpdatePresenceGrantPifForPresentityL(

    const MXIMPIdentity &aIdentity,

    const MPresenceInfoFilter &aPif,

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoUpdatePresenceGrantPifForPresentityL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CUpdatePresenceGrantPifForPresentityRequest* req =

        CUpdatePresenceGrantPifForPresentityRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->UpdatePresenceGrantPifForPresentityL( aIdentity, aPif );

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoUpdatePresenceGrantPifForPresentityL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoUpdateGrantPresenceForPresentityGroupMembersL()

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

//

void CImpsProtocolPresenceAuthorization::DoWithdrawPresenceGrantFromPresentityL(

    const MXIMPIdentity &aIdentity,

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoWithdrawPresenceGrantFromPresentityL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    // Append to the iWithDrawnPresenceGrantList array

    // check for pending reactive authorization requests

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CWithdrawPresenceGrantFromPresentityRequest* req =

        CWithdrawPresenceGrantFromPresentityRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->WithdrawPresenceGrantFromPresentityL( aIdentity );

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    // remove from the array

    //TInt removestatus = iWithDrawnPresenceGrantList.Remove(findstatus);

    IMPS_DP( D_IMPS_LIT( "Authorization::DoWithdrawPresenceGrantFromPresentityL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoGrantPresenceForPresentityGroupMembersL()

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

//

void CImpsProtocolPresenceAuthorization::DoGrantPresenceForPresentityGroupMembersL(

    const  MXIMPIdentity &aIdentity,

    const MPresenceInfoFilter &aPif,

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoGrantPresenceForPresentityGroupMembersL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CGrantPresenceForPresentityGroupMembersRequest* req =

        CGrantPresenceForPresentityGroupMembersRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->GrantPresenceForPresentityGroupMembersL( aIdentity, aPif );

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoGrantPresenceForPresentityGroupMembersL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoUpdateGrantPresenceForPresentityGroupMembersL()

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

//

void CImpsProtocolPresenceAuthorization::DoUpdatePresenceGrantPifForPresentityGroupMembersL(

    const MXIMPIdentity &aIdentity,

    const MPresenceInfoFilter &aPif,

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "DoUpdatePresenceGrantPifForPresentityGroupMembersL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CUpdatePresenceGrantPifForPresentityGroupMembersRequest* req =

        CUpdatePresenceGrantPifForPresentityGroupMembersRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->UpdatePresenceGrantPifForPresentityGroupMembersL( aIdentity, aPif );

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "DoUpdatePresenceGrantPifForPresentityGroupMembersL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoUpdateGrantPresenceForPresentityGroupMembersL()

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

//

void CImpsProtocolPresenceAuthorization::DoWithdrawPresenceGrantFromPresentityGroupMembersL(

    const MXIMPIdentity &aIdentity,

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "DoWithdrawPresenceGrantFromPresentityGroupMembersL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CWithdrawPresenceGrantFromPresentityGroupMembersRequest* req =

        CWithdrawPresenceGrantFromPresentityGroupMembersRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->WithdrawPresenceGrantFromPresentityGroupMembersL( aIdentity );

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "DoWithdrawPresenceGrantFromPresentityGroupMembersL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoGrantPresenceForEveryoneL()

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

//

void CImpsProtocolPresenceAuthorization::DoGrantPresenceForEveryoneL(

    const MPresenceInfoFilter& aPif,

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoGrantPresenceForEveryoneL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CGrantPresenceForEveryoneRequest* req =

        CGrantPresenceForEveryoneRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->GrantPresenceForEveryoneL( aPif );

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoGrantPresenceForEveryoneL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoUpdatePresenceGrantPifForEveryoneL()

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

//

void CImpsProtocolPresenceAuthorization::DoUpdatePresenceGrantPifForEveryoneL(

    const MPresenceInfoFilter& aPif,

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoUpdatePresenceGrantPifForEveryoneL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CUpdatePresenceGrantPifForEveryoneRequest* req =

        CUpdatePresenceGrantPifForEveryoneRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->UpdatePresenceGrantPifForEveryoneL( aPif );

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoUpdatePresenceGrantPifForEveryoneL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoWithdrawPresenceGrantFromEveryoneL()

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

//

void CImpsProtocolPresenceAuthorization::DoWithdrawPresenceGrantFromEveryoneL(

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoWithdrawPresenceGrantFromEveryoneL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CWithdrawPresenceGrantFromEveryoneRequest* req =

        CWithdrawPresenceGrantFromEveryoneRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->WithdrawPresenceGrantFromEveryoneL();

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoWithdrawPresenceGrantFromEveryoneL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoSubscribePresenceBlockListL()

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

//

void CImpsProtocolPresenceAuthorization::DoSubscribePresenceBlockListL(

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoSubscribePresenceBlockListL() Start" ) );

    iRequestId = aReqId;

    CreateDataHandlerL();

    iConnMan.ReserveSpaceForOneMoreRequestL();

    CSubscribePresenceBlockListRequest* req =

        CSubscribePresenceBlockListRequest::NewLC( iConnMan, aReqId );

    CleanupStack::Check( req );

    req->SubscribePresenceBlockListL();

    iConnMan.AddRequest( req );

    CleanupStack::Pop( req );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoSubscribePresenceBlockListL() End" ) );

    }

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

// CImpsProtocolPresenceAuthorization::DoUnsubscribePresenceBlockListL()

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

//

void CImpsProtocolPresenceAuthorization::DoUnsubscribePresenceBlockListL(

    TXIMPRequestId aReqId )

    {

    IMPS_DP( D_IMPS_LIT( "Authorization::DoUnsubscribePresenceBlockListL() Start" ) );

    // complete the request successfully

    iConnMan.HandleToHost().HandleRequestCompleted( aReqId, KErrNone );

    IMPS_DP( D_IMPS_LIT( "Authorization::DoUnsubscribePresenceBlockListL() End" ) );

    }