/*

* 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:  Implementation of MPresenceAuthorization

 *

*/

#include "presenceauthorizationimp.h"

#include "presenceinfofilterimp.h"

#include "ximpobjecthelpers.h"

#include "presenceoperationdefs.h"

#include "ximpidentityimp.h"

#include "ximpcontextinternal.h"

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

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

// CPresenceAuthorizationImp::NewL()

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

//

CPresenceAuthorizationImp* CPresenceAuthorizationImp::NewL(

    MXIMPContextInternal& aContext )

    {

    CPresenceAuthorizationImp* self =

        new( ELeave ) CPresenceAuthorizationImp( aContext );

    return self;

    }

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

// Implement supported interface access.

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

//

XIMPIMP_IF_BASE_GET_INTERFACE_BEGIN( CPresenceAuthorizationImp, 

                                     MPresenceAuthorization )

XIMPIMP_IF_BASE_GET_INTERFACE_END()

XIMPIMP_IF_BASE_GET_CONST_INTERFACE_BEGIN( CPresenceAuthorizationImp, 

                                           MPresenceAuthorization )

XIMPIMP_IF_BASE_GET_INTERFACE_END()

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

// CPresenceAuthorizationImp::~CPresenceAuthorizationImp()

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

//

CPresenceAuthorizationImp::~CPresenceAuthorizationImp()

    {

    //iContext not own

    }

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

// CPresenceAuthorizationImp::CPresenceAuthorizationImp()

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

//

CPresenceAuthorizationImp::CPresenceAuthorizationImp(

    MXIMPContextInternal& aContext )

    : iContext( aContext )

    {

    }

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

// CPresenceAuthorizationImp::SubscribePresenceGrantRequestListL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::SubscribePresenceGrantRequestListL()

    {

    return iContext.QueueOperationL(

                       NPresenceOps::EPrSubscribePresenceGrantRequestList,

                       KNullDesC8 );

    }

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

// CPresenceAuthorizationImp::UnsubscribePresenceGrantRequestListL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::UnsubscribePresenceGrantRequestListL()

    {

    return iContext.QueueOperationL(

                       NPresenceOps::EPrUnsubscribePresenceGrantRequestList,

                       KNullDesC8 );

    }

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

// CPresenceAuthorizationImp::GrantPresenceForPresentityL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::GrantPresenceForPresentityL(

    const MXIMPIdentity& aPresentityId,

    const MPresenceInfoFilter& aPif )

    {

    return QueueOperationL( NPresenceOps::EPrGrantPresenceToPresentity,

                            aPif, aPresentityId );

    }

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

// CPresenceAuthorizationImp::WithdrawPresenceGrantFromPresentityL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::WithdrawPresenceGrantFromPresentityL(

    const MXIMPIdentity& aPresentityId )

    {

    HBufC8* idPack = PackPresentityLC( aPresentityId );

    TXIMPRequestId reqId =

        iContext.QueueOperationL(

                        NPresenceOps::EPrWithdrawPresenceFromPresentity,

                        *idPack );

    CleanupStack::PopAndDestroy( idPack );

    return reqId;

    }

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

// CPresenceAuthorizationImp::GrantPresenceForPresentityGroupMembersL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::GrantPresenceForPresentityGroupMembersL(

    const MXIMPIdentity& aGroupId,

    const MPresenceInfoFilter& aPif )

    {

    return QueueOperationL( NPresenceOps::EPrGrantPresenceToPresentityGroupMembers,

                            aPif, aGroupId );

    }

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

// CPresenceAuthorizationImp::WithdrawPresenceGrantFromPresentityGroupMembersL()

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

//

TXIMPRequestId

    CPresenceAuthorizationImp::WithdrawPresenceGrantFromPresentityGroupMembersL(

    const MXIMPIdentity& aGroupId )

    {

    HBufC8* idPack = PackPresentityLC( aGroupId );

    TXIMPRequestId reqId =

        iContext.QueueOperationL(

                        NPresenceOps::EPrWithdrawPresenceFromPresentityGroupMembers,

                        *idPack );

    CleanupStack::PopAndDestroy( idPack );

    return reqId;

    }

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

// CPresenceAuthorizationImp::GrantPresenceForPresentityL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::GrantPresenceForEveryoneL( 

    const MPresenceInfoFilter& aPif )

    {

    HBufC8* pifPack = PackPresenceInfoFilterLC( aPif );

    TXIMPRequestId reqId =

        iContext.QueueOperationL( 

                        NPresenceOps::EPrGrantPresenceToEveryone,

                        *pifPack );

    CleanupStack::PopAndDestroy( pifPack );

    return reqId;            

    }

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

// CPresenceAuthorizationImp::WithdrawPresenceGrantFromPresentityL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::WithdrawPresenceGrantFromEveryoneL()

    {

    TXIMPRequestId reqId =

        iContext.QueueOperationL( 

                        NPresenceOps::EPrWithdrawPresenceFromEveryone,

                        KNullDesC8 );

    return reqId;

    }

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

// CPresenceAuthorizationImp::SubscribePresenceBlockListL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::SubscribePresenceBlockListL()

    {

    // Queue the operation

    return  iContext.QueueOperationL(

                        NPresenceOps::EPrSubscribeBlockList,

                        KNullDesC8 );

    }

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

// CPresenceAuthorizationImp::UnsubscribePresenceBlockListL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::UnsubscribePresenceBlockListL()

    {

    // Queue the operation

    return iContext.QueueOperationL(

                        NPresenceOps::EPrUnsubscribeBlockList,

                        KNullDesC8 );

    }

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

// CPresenceAuthorizationImp::BlockPresenceForPresentityL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::BlockPresenceForPresentityL(

    const MXIMPIdentity& aPresentityId )

    {

    HBufC8* idPack = PackPresentityLC( aPresentityId );

    TXIMPRequestId reqId =

        iContext.QueueOperationL(

                        NPresenceOps::EPrBlockPresenceForPresentity,

                        *idPack );

    CleanupStack::PopAndDestroy( idPack );

    return reqId;

    }

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

// CPresenceAuthorizationImp::CancelPresenceBlockFromPresentityL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::CancelPresenceBlockFromPresentityL(

    const MXIMPIdentity& aPresentityId )

    {

    HBufC8* idPack = PackPresentityLC( aPresentityId );

    TXIMPRequestId reqId =

        iContext.QueueOperationL(

                        NPresenceOps::EPrCancelPresenceBlockFromPresentity,

                        *idPack );

    CleanupStack::PopAndDestroy( idPack );

    return reqId;

    }

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

// CPresenceAuthorizationImp::PackPresenceDocLC()

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

//

HBufC8* CPresenceAuthorizationImp::PackPresenceInfoFilterLC(

    const MPresenceInfoFilter& aPif )

    {

    const CPresenceInfoFilterImp* pifImp = 

        TXIMPGetImpClassOrPanic< const CPresenceInfoFilterImp >::From( aPif );

    HBufC8* pack = TXIMPObjectPacker< CPresenceInfoFilterImp>::PackL( *pifImp );

    CleanupStack::PushL( pack );

    return pack;

    }

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

// CPresenceAuthorizationImp::QueueOperationL()

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

//

TXIMPRequestId CPresenceAuthorizationImp::QueueOperationL(

    NPresenceOps::TPresenceOpTypes aOperation,

    const MPresenceInfoFilter& aPif,

    const MXIMPIdentity& aIdentity )

    {

    CBufFlat* buffer = CBufFlat::NewL( 10 );

    CleanupStack::PushL( buffer );

    RBufWriteStream ws;

    CleanupClosePushL( ws );

    ws.Open( *buffer ); // CSI: 65 # Does not return a value

    // pif

    const CPresenceInfoFilterImp* pifImp =

        TXIMPGetImpClassOrPanic< const CPresenceInfoFilterImp >::From( aPif );

    pifImp->ExternalizeL( ws );

    // identity

    const CXIMPIdentityImp* identityImp =

        TXIMPGetImpClassOrPanic< const CXIMPIdentityImp >::From( aIdentity );

    identityImp->ExternalizeL( ws );

    ws.CommitL();

    CleanupStack::PopAndDestroy();  //ws

    HBufC8* packedBuf = buffer->Ptr( 0 ).AllocL();

    CleanupStack::PopAndDestroy( buffer );

    CleanupStack::PushL( packedBuf );

    // Queue the operation

    TXIMPRequestId reqId =

        iContext.QueueOperationL( aOperation, *packedBuf );

    CleanupStack::PopAndDestroy( packedBuf );

    return reqId;

    }

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

// CPresenceAuthorizationImp::PackPresentityLC()

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

//

HBufC8* CPresenceAuthorizationImp::PackPresentityLC( const MXIMPIdentity& aIdentity )

    {

    const CXIMPIdentityImp* identityImp =

            TXIMPGetImpClassOrPanic< const CXIMPIdentityImp >::From( aIdentity );

    HBufC8* pack = TXIMPObjectPacker< const CXIMPIdentityImp >::PackL( *identityImp );

    CleanupStack::PushL( pack );

    return pack;

    }

// End of file