/*
* Copyright (c) 2007-2008 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:  Oss Protocol implementation for Presence Framework
*
*/


#include <badesca.h>

#include <ximpbase.h>
#include <ximpidentity.h>
#include <ximpprotocolconnectionhost.h>

#include "cossprotocolpresenceauthorization.h"
#include "ossprotocolpluginlogger.h"
#include "cossprotocolconnectionmanager.h"

#include "csubscribepresencegrantrequestlistrequest.h"
#include "ossprotocolpluginpanics.h"
#include "cpresenceauthuserrequest.h"
#include "cwithdrawpresencegrantfrompresentityrequest.h"


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

// ---------------------------------------------------------------------------
// CImpsConnection::GetInterface()
// ---------------------------------------------------------------------------
//
TAny* COssProtocolPresenceAuthorization::GetInterface( TInt32 aInterfaceId,
                                TIfGetOps aOptions )
    {
    LOGGER ( TXT("COssProtocolPresenceAuthorization::GetInterface() Start") );
    if( aInterfaceId == MProtocolPresenceAuthorization::KInterfaceId )
        {
        MProtocolPresenceAuthorization* self = this;
        return self;
        }

    if( aOptions == MXIMPBase::EPanicIfUnknown ) 
        {
        User::Panic( KOSSProtocolPresenceAuthorization, KErrExtensionNotSupported );
        }
	LOGGER ( TXT("COssProtocolPresenceAuthorization::GetInterface() End") );
    return NULL;
    }


// ---------------------------------------------------------------------------
// CImpsConnection::GetInterface()
// ---------------------------------------------------------------------------
//
const TAny* COssProtocolPresenceAuthorization::GetInterface( TInt32 aInterfaceId,
                                      TIfGetOps aOptions ) const
    {
    LOGGER ( TXT("COssProtocolPresenceAuthorization::GetInterface() Start") );
    if( aInterfaceId == MProtocolPresenceAuthorization::KInterfaceId )
        {
        const MProtocolPresenceAuthorization* self = this;
        return self;
        }

    if( aOptions == MXIMPBase::EPanicIfUnknown ) 
        {
        User::Panic( KOSSProtocolPresenceAuthorization, KErrExtensionNotSupported );
        }
	LOGGER ( TXT("COssProtocolPresenceAuthorization::GetInterface() End") );
    return NULL;
    }


// ---------------------------------------------------------------------------
// CImpsConnection::NewInstanceLC()
// ---------------------------------------------------------------------------
//
TInt32 COssProtocolPresenceAuthorization::GetInterfaceId() const
    {
    LOGGER ( TXT("COssProtocolPresenceAuthorization::GetInterfaceId() Start-End") );
    return MProtocolPresenceAuthorization::KInterfaceId;
    }



// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::COssProtocolPresenceAuthorization()
// ---------------------------------------------------------------------------
//
COssProtocolPresenceAuthorization::COssProtocolPresenceAuthorization(
									MOSSProtocolConnectionManager& aConnMan)
	:iConnMan(aConnMan)
    {
   	LOGGER ( TXT("::COssProtocolPresenceAuthorization() Start-End") );
    }


// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::ConstructL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::ConstructL()
    {
    LOGGER ( TXT("COssProtocolPresenceAuthorization::ConstructL() Start") );                                    
    LOGGER ( TXT("COssProtocolPresenceAuthorization::ConstructL() End") );
    }


// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::NewL()
// ---------------------------------------------------------------------------
//
COssProtocolPresenceAuthorization* COssProtocolPresenceAuthorization::NewL( 
						MOSSProtocolConnectionManager& aConnMan )
    {
    LOGGER ( TXT("COssProtocolPresenceAuthorization::NewL() Start") );

    COssProtocolPresenceAuthorization* self = 
    					new( ELeave ) COssProtocolPresenceAuthorization( aConnMan);
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    LOGGER ( TXT("COssProtocolPresenceAuthorization::NewL() End") );
    return self;
    }


// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::~COssProtocolPresenceAuthorization()
// ---------------------------------------------------------------------------
//
COssProtocolPresenceAuthorization::~COssProtocolPresenceAuthorization()
    {
    LOGGER ( TXT("Authorization::~COssProtocolPresenceAuthorization() Start") );
    
        
	LOGGER ( TXT("Authorization::~COssProtocolPresenceAuthorization() End") );
    }


// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoUnsubscribePresenceWatcherListL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoSubscribePresenceGrantRequestListL( 
			TXIMPRequestId aReqId )
    {
    LOGGER ( TXT("Authorization::DoSubscribePresenceGrantRequestListL() Start") );
    if( ! iConnMan.GetContactManager().IsFetchInvitationsForFirstTime() )
        {
        iConnMan.GetContactManager().SetFetchInvitationsForFirstTime(ETrue);
        CreateDataHandlerL();

        iConnMan.GetAddNotificationHandler().StartListeningL();
        iConnMan.HandleToHost().HandleRequestCompleted( aReqId, KErrNone );
        }	
	else
	    {
	    iConnMan.GetContactManager().ReturnInvitationListL();
	    iConnMan.HandleToHost().HandleRequestCompleted ( aReqId, KErrNone );
	    }
    
    LOGGER ( TXT("Authorization::DoSubscribePresenceGrantRequestListL() End") );
    }

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoUnsubscribePresenceWatcherListL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoUnsubscribePresenceGrantRequestListL( 
			TXIMPRequestId aReqId )
    {
    LOGGER ( TXT("Authorization::DoUnsubscribePresenceGrantRequestListL() Start") );
  
    // complete the request successfully
    iConnMan.HandleToHost().HandleRequestCompleted( aReqId, KErrNone );
    	
    LOGGER ( TXT("Authorization::DoUnsubscribePresenceGrantRequestListL() End") );
    }

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoGrantPresenceForPresentityL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoGrantPresenceForPresentityL( 
												const MXIMPIdentity& aIdentity,
                                                const MPresenceInfoFilter& aPif,
                                                TXIMPRequestId aReqId )
    {
    LOGGER ( TXT("Authorization::DoGrantPresenceForPresentityL() Start") );
	CreateDataHandlerL();
 		
 	CPresenceAuthUserRequest* req = 
 	CPresenceAuthUserRequest::NewLC( iConnMan, aReqId );
 	
 	
	req->PresenceAuthUserRequestL(aIdentity,aPif);
	
	CleanupStack::Pop( req );
    LOGGER ( TXT("Authorization::DoGrantPresenceForPresentityL() End") );
    }

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoUpdateGrantPresenceForPresentityL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoUpdatePresenceGrantPifForPresentityL( 
											const MXIMPIdentity&/*aIdentity*/,
                                            const MPresenceInfoFilter &/*aPif*/,
                                            TXIMPRequestId /*aReqId*/ )
    {
    LOGGER ( TXT("Authorization::DoUpdatePresenceGrantPifForPresentityL() Start") );
    LOGGER ( TXT("Authorization::DoUpdatePresenceGrantPifForPresentityL() End") );
    }

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoUpdateGrantPresenceForPresentityGroupMembersL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoWithdrawPresenceGrantFromPresentityL( 
											const MXIMPIdentity &aIdentity,
                                            TXIMPRequestId aReqId )
    {
    LOGGER ( TXT("Authorization::DoWithdrawPresenceGrantFromPresentityL() Start") );
    CreateDataHandlerL();
 		
 	CWithdrawPresenceGrantFromPresentityRequest* req = 
 	CWithdrawPresenceGrantFromPresentityRequest::NewLC( iConnMan, aReqId );
 	
 	
	req->WithdrawPresenceGrantFromPresentityL( aIdentity );
	
	CleanupStack::Pop( req );

    
    LOGGER ( TXT("Authorization::DoWithdrawPresenceGrantFromPresentityL() End") );
    }

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoGrantPresenceForPresentityGroupMembersL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoGrantPresenceForPresentityGroupMembersL( 
											const  MXIMPIdentity&/*aIdentity*/,
                                            const MPresenceInfoFilter& /*aPif*/,
                                            TXIMPRequestId /*aReqId*/ )
    {
    LOGGER ( TXT("Authorization::DoGrantPresenceForPresentityGroupMembersL() Start") );
    
    LOGGER ( TXT("Authorization::DoGrantPresenceForPresentityGroupMembersL() End") );
    }

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoUpdateGrantPresenceForPresentityGroupMembersL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoUpdatePresenceGrantPifForPresentityGroupMembersL( 
											const MXIMPIdentity&/*aIdentity*/,
                                            const MPresenceInfoFilter&/*aPif*/,
                                            TXIMPRequestId /*aReqId*/ )
    {
    LOGGER ( TXT("DoUpdatePresenceGrantPifForPresentityGroupMembersL() Start") );
    
    LOGGER ( TXT("DoUpdatePresenceGrantPifForPresentityGroupMembersL() End") );
    }


// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoUpdateGrantPresenceForPresentityGroupMembersL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoWithdrawPresenceGrantFromPresentityGroupMembersL( 
											const MXIMPIdentity&/*aIdentity*/,
											TXIMPRequestId /*aReqId*/ )
    {
    LOGGER ( TXT("DoWithdrawPresenceGrantFromPresentityGroupMembersL() Start") );
    
    LOGGER ( TXT("DoWithdrawPresenceGrantFromPresentityGroupMembersL() End") );
    }

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoGrantPresenceForEveryoneL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoGrantPresenceForEveryoneL( 
											const MPresenceInfoFilter& /*aPif*/,
 											TXIMPRequestId /*aReqId*/ )
	{
	LOGGER ( TXT("Authorization::DoGrantPresenceForEveryoneL() Start") );
	
    LOGGER ( TXT("Authorization::DoGrantPresenceForEveryoneL() End") );
	}

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoUpdatePresenceGrantPifForEveryoneL()
// ---------------------------------------------------------------------------
//											 
void COssProtocolPresenceAuthorization::DoUpdatePresenceGrantPifForEveryoneL(
											const MPresenceInfoFilter& /*aPif*/,
						                    TXIMPRequestId /*aReqId*/ )
	{
	LOGGER ( TXT("Authorization::DoUpdatePresenceGrantPifForEveryoneL() Start") );
	
    LOGGER ( TXT("Authorization::DoUpdatePresenceGrantPifForEveryoneL() End") );
	}

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoWithdrawPresenceGrantFromEveryoneL()
// ---------------------------------------------------------------------------
//                  
void COssProtocolPresenceAuthorization::DoWithdrawPresenceGrantFromEveryoneL( 
						TXIMPRequestId /*aReqId*/ )
	{
	LOGGER ( TXT("Authorization::DoWithdrawPresenceGrantFromEveryoneL() Start") );
	
    LOGGER ( TXT("Authorization::DoWithdrawPresenceGrantFromEveryoneL() End") );
	} 
	
// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoSubscribePresenceBlockListL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoSubscribePresenceBlockListL( 
						TXIMPRequestId /*aReqId*/ )
    {
    LOGGER ( TXT("Authorization::DoSubscribePresenceBlockListL() Start") );
    
    LOGGER ( TXT("Authorization::DoSubscribePresenceBlockListL() End") );
    }
    

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoUnsubscribePresenceBlockListL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoUnsubscribePresenceBlockListL( 
				TXIMPRequestId /*aReqId*/ )
    {
    LOGGER ( TXT("Authorization::DoUnsubscribePresenceBlockListL() Start") );
    LOGGER ( TXT("Authorization::DoUnsubscribePresenceBlockListL() End") );
    }


// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoBlockPresenceForPresentityL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoBlockPresenceForPresentityL( 
											const MXIMPIdentity& /*aPresentityId*/,
											TXIMPRequestId /*aReqId*/ )
    {
    LOGGER ( TXT("Authorization::DoBlockPresenceForPresentityL() Start") );
    
    LOGGER ( TXT("Authorization::DoBlockPresenceForPresentityL() End") );
    }

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::DoCancelPresenceBlockFromPresentityL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::DoCancelPresenceBlockFromPresentityL( 
											const MXIMPIdentity& /*aPresentityId*/,
											TXIMPRequestId /*aReqId*/ )
    {
    LOGGER ( TXT("Authorization::DoCancelPresenceBlockFromPresentityL() Start") );
  
    LOGGER ( TXT("Authorization::DoCancelPresenceBlockFromPresentityL() End") );
    }

// ---------------------------------------------------------------------------
// COssProtocolPresenceAuthorization::CreateDataHandlerL()
// ---------------------------------------------------------------------------
//
void COssProtocolPresenceAuthorization::CreateDataHandlerL()
	{
	LOGGER ( TXT("Authorization::CreateDataHandler() Start"));
	iConnMan.ManufactureDataHandlerL();		
	LOGGER ( TXT("Authorization::CreateDataHandler() End"));
	}
	

// End of file