/*

* Copyright (c) 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:  Implementation for presence cache client.

*

*/

#include <e32std.h>

#include <prescachereadhandler.h>

#include "presencecacheclientnotification.h"

#include "presencecachedefs.h"

#include "ximpobjecthelpers.h"

#include "presenceinfoimp.h"

#include "presencebuddyinfoimp.h"

#include "personpresenceinfoimp.h"

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

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

// CPresenceCacheClientNotification::NewL

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

//

CPresenceCacheClientNotification* CPresenceCacheClientNotification::NewL(

    CPresenceCacheClient& aClient)

    {

    CPresenceCacheClientNotification* self = new(ELeave)CPresenceCacheClientNotification(aClient);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;    

    }

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

// CPresenceCacheClientNotification::~CPresenceCacheClientNotification

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

//

CPresenceCacheClientNotification::~CPresenceCacheClientNotification()

    {

    Cancel();

    }

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

// CPresenceCacheClientNotification::CPresenceCacheClientNotification

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

//

CPresenceCacheClientNotification::CPresenceCacheClientNotification(CPresenceCacheClient& aClient)

: CActive( EPriorityStandard ), iClient( aClient ), iNotificationSubscribed( EFalse )

    {        

    }

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

// CPresenceCacheClientNotification::ConstructL

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

//

void CPresenceCacheClientNotification::ConstructL()

    {

    CActiveScheduler::Add( this );   

    }

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

// CPresenceCacheClientNotification::RunL

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

//

void CPresenceCacheClientNotification::RunL()

    {    

    TInt origStatus = iStatus.Int();

    MPresCacheReadHandler* client = ClientNotifyHandler();    

    if ( origStatus )

        {

        iNotificationSubscribed = EFalse;        

        TRAP_IGNORE( client->HandlePresenceNotificationL( origStatus, NULL ));

        }

    else

        {

        StartNotifySubscription();        

        PreseneceFromServerToClientL( *client, iSizePckg() );

        }              

    }

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

// CPresenceCacheClientNotification::RunError

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

//

TInt CPresenceCacheClientNotification::RunError( TInt aError )

    {         

    if ( KErrServerTerminated == aError )

        {

        // When server is terminated we notify the clienrt about that

        iNotificationSubscribed = EFalse;         

        MPresCacheReadHandler* client = ClientNotifyHandler();

        TRAP_IGNORE( client->HandlePresenceNotificationL( aError, NULL ));        

        }

    else

        {

        // StartNotifySubscription is already called.

        }

    return KErrNone;    

    } 

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

// CPresenceCacheClientNotification::DoCancel

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

//

void CPresenceCacheClientNotification::DoCancel()

    {

    // TODO: consider when this is safe

    iClient.SendReceive( NRequest::ECancelWaitingForNotification );

    }

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

// CPresenceCacheClientNotification::SubscribePresenceBuddyChangeL

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

//    

TInt CPresenceCacheClientNotification::SubscribePresenceBuddyChangeL(

	const MXIMPIdentity& aIdentity)

    {       

    if ( !iNotificationSubscribed )

        {

        StartNotifySubscription();

        }

    HBufC8* myIdPack = iClient.PackIdentityLC(aIdentity);                

    // Package message arguments before sending to the server

    TIpcArgs args;

    args.Set(1, myIdPack);  

    TInt err = iClient.SendReceive( NRequest::ESubscribeBuddyPresenceChange, args ); 

    CleanupStack::PopAndDestroy( myIdPack );    

    return err;

    }

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

// CPresenceCacheClientNotification::UnsubscribePresenceBuddyChangeL

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

//    

void CPresenceCacheClientNotification::UnsubscribePresenceBuddyChangeL(

	const MXIMPIdentity& aIdentity)

    {           

    HBufC8* myIdPack = iClient.PackIdentityLC(aIdentity);                

    // Package message arguments before sending to the server

    TIpcArgs args;

    args.Set(1, myIdPack);  

    TInt err = iClient.SendReceive( NRequest::EUnSubscribeBuddyPresenceChange, args );        

    CleanupStack::PopAndDestroy( myIdPack );

    User::LeaveIfError( err );

    }

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

// CPresenceCacheClientNotification::StartNotifySubscriptionL

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

//    

void CPresenceCacheClientNotification::StartNotifySubscription()

    {                                    

    // Package message arguments before sending to the server

    SetActive();

    TIpcArgs args(&iSizePckg);            

    iClient.SendReceive( NRequest::EWaitingForNotification, args, iStatus );

    iNotificationSubscribed = ETrue;

    }

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

// CPresenceCacheClientNotification::ClientNotifyHandler

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

//    

MPresCacheReadHandler* CPresenceCacheClientNotification::ClientNotifyHandler()

    {

	return iClient.iNotifyClient;

    }

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

// CPresenceCacheClientNotification::PreseneceFromServerToClientL

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

//    

void CPresenceCacheClientNotification::PreseneceFromServerToClientL( 

    MPresCacheReadHandler& aClient, TInt aSize )

    {       

    CPresenceBuddyInfoImp* buddyInfo(NULL);

    buddyInfo = CPresenceBuddyInfoImp::NewLC();

    HBufC8* presInfoDes = HBufC8::NewLC( aSize );

    TPtr8 ptrBuf( presInfoDes->Des() );

    TInt err = iClient.SendReceive( NRequest::EGetLastNotifiedtPacket, TIpcArgs( &ptrBuf ));    

    if ( !err )

        {

        TXIMPObjectPacker< CPresenceBuddyInfoImp >::UnPackL( *buddyInfo, *presInfoDes );

        CleanupStack::PopAndDestroy( presInfoDes );                          

        aClient.HandlePresenceNotificationL( KErrNone, buddyInfo );

        CleanupStack::Pop( buddyInfo );         

        }

    else

        {

        CleanupStack::PopAndDestroy( presInfoDes );         

        CleanupStack::PopAndDestroy( buddyInfo );          

        }

    }

// end of file