/*
* 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:  
*
*/


#include <s32mem.h>
#include <liwcommon.h>
#include "cpclientactivenotifier.h"
#include "ccontentmap.h"
#include "cpdebug.h"
#include "cpglobals.h"
#include "cpserverdef.h"
#include "cdatasourceinterface.h"

using namespace LIW;

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

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
CCPActiveNotifier* CCPActiveNotifier::NewL( RCPServerClient& aServerClient )
    {
    CCPActiveNotifier* self = new( ELeave ) 
            CCPActiveNotifier ( aServerClient );
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// destructor
// ---------------------------------------------------------------------------
CCPActiveNotifier::~CCPActiveNotifier()
    {
    CP_DEBUG( _L8("CCPActiveNotifier::CCPActiveNotifier()" ) );
    Cancel( );
    iObservers.Close( );
    delete iObserverBuf;
    delete iSizeDes;
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CCPActiveNotifier::RegisterL( MLiwNotifyCallback* aObserver, 
                                   TInt32 aTransactionId, 
                                   CCPLiwMap* aMap,
                                   TUint aCmdOptions )
    {
    CP_DEBUG( _L8("CCPActiveNotifier::RegisterL()" ) );
    TIpcArgs args;
    
   	if(iObservers.Find( aTransactionId ))
   		{
   		User::Leave( KErrInUse );
   		}
    
   	iObservers.InsertL( aTransactionId, aObserver );
	delete iObserverBuf;
	iObserverBuf = NULL;
 	iObserverBuf = aMap->PackForServerLC( );
   	CleanupStack::Pop( iObserverBuf );
   	args.Set( KDescriptorPosition, &*iObserverBuf );
	args.Set( KTransactionPosition, aTransactionId );
    args.Set( KOptionsPosition, static_cast<TInt>( aCmdOptions ));
    if ( !IsActive( ) )
        {
        iSizeDes = new (ELeave) TPckgBuf<TInt>( );
        args.Set( KReturnPosition, iSizeDes );
        iServerClient.RegisterObserverL( iStatus, args );
        SetActive( );
        }
    else
        {
        iServerClient.AddObserver( args );
        }
    }


// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CCPActiveNotifier::UnregisterL()
    {
    CP_DEBUG( _L8("CCPActiveNotifier::UnregisterL()" ) );
    if ( !IsActive( ) )
        {
        User::Leave( KErrNotFound );
        }
    else
        {
        Cancel( );
        delete iSizeDes;
        iSizeDes = NULL;
        }
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
TBool CCPActiveNotifier::UnregisterL( TInt32 aTransactionId )
    {
    TBool last(EFalse);
    CP_DEBUG( _L8("CCPActiveNotifier::UnregisterL()" ) );

    MLiwNotifyCallback** observer = iObservers.Find(aTransactionId);
    if (observer)
        {
        CLiwGenericParamList* changeInfoList = 
                 CLiwGenericParamList::NewL( );
        CleanupStack::PushL( changeInfoList );
        CLiwGenericParamList* inParamList = CLiwGenericParamList::NewL( );
        CleanupStack::PushL( inParamList );
        
        changeInfoList->AppendL(TLiwGenericParam(EGenericParamError,
                TLiwVariant(CDataSourceInterface::ErrCodeConversion(KErrNone))));
        changeInfoList->AppendL(TLiwGenericParam(KErrorCode, TLiwVariant(
                CDataSourceInterface::ErrCodeConversion(KErrNone))));
        
		(*observer)->HandleNotifyL( aTransactionId, KLiwEventCanceled, *changeInfoList,
            *inParamList );     
        
        CleanupStack::PopAndDestroy( inParamList );
        CleanupStack::PopAndDestroy( changeInfoList );
        }
    else
        {
        User::Leave(KErrNotFound);
        }
    
    TIpcArgs args;
	args.Set( KTransactionPosition, aTransactionId );
    iServerClient.RemoveObserver( args );

    iObservers.Remove( aTransactionId );
        
	if( !iObservers.Count() )
		{
		UnregisterL();
		last = ETrue;
		}
	return last;
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CCPActiveNotifier::UnregisterAllL(  )
    {
    CP_DEBUG( _L8("CCPActiveNotifier::UnregisterAllL()" ) );
    if (!iObservers.Count())
    	{
    	User::Leave( KErrNotFound );
    	}
    THashMapIter<TInt32, MLiwNotifyCallback*> iter( iObservers );
    const TInt32* transaction = iter.NextKey();
    while( transaction )
        {
        UnregisterL( *transaction );
        transaction = iter.NextKey( );
        }    
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CCPActiveNotifier::RunL()
    {
    CP_DEBUG( _L8("CCPActiveNotifier::RunL()" ) );
    CLiwGenericParamList* eventParamList = CLiwGenericParamList::NewL();
    CleanupStack::PushL(eventParamList);

    TInt error = iStatus.Int();
    if (KErrNone == error)
        {
        RBuf8 outbuf;
        outbuf.CleanupClosePushL();
        outbuf.CreateL((*iSizeDes)());
        error = iServerClient.GetChangeInfoData(outbuf);
        RDesReadStream stream(outbuf);
        CleanupClosePushL(stream);
        eventParamList->InternalizeL(stream);
        CleanupStack::PopAndDestroy(&stream);
        delete iSizeDes;
        iSizeDes = NULL;
        CleanupStack::PopAndDestroy(&outbuf);
        }
    if (KErrNoMemory!=iStatus.Int())
        {
        RegisterAgainL();
        }
    NotifyObserversL(error, eventParamList);
    CleanupStack::PopAndDestroy(eventParamList);
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CCPActiveNotifier::NotifyObserversL( TInt aErrorCode, 
		CLiwGenericParamList* aEventParamList  )
	{
    TInt event( KLiwEventInProgress );
    if ( aErrorCode == KErrCancel )
        {
        event = KLiwEventCanceled;
        }
    else if ( aErrorCode != KErrNone )
        {
        event = KLiwEventStopped;
        }	
 
    for ( TInt i = 0; i<aEventParamList->Count(); i++ )
    	{
    	TLiwGenericParam param;
    	param.PushL();
    	TLiwVariant mapsV;
    	mapsV.PushL();
    	aEventParamList->AtL( i, param );
    	mapsV = param.Value();
    	CLiwDefaultList* listOfMatchingMaps = CLiwDefaultList::NewLC( );
    	if (mapsV.Get( *listOfMatchingMaps ))
    		{
    		TLiwVariant transV;
    		transV.PushL();
    		TInt transIndex (listOfMatchingMaps->Count()-1);
    		listOfMatchingMaps->AtL(transIndex ,transV);
    		TInt32 transactionId ( KErrNotFound );
    		transV.Get( transactionId );
    		MLiwNotifyCallback** observer = iObservers.Find( transactionId );
    		
    		if ( observer )
    			{
    			listOfMatchingMaps->Remove( transIndex );
    			CLiwGenericParamList* changeInfoList = 
											CLiwGenericParamList::NewL( );
    			CleanupStack::PushL( changeInfoList );
    		    CLiwGenericParamList* inParamList = CLiwGenericParamList::NewL( );
    		    CleanupStack::PushL( inParamList );
    			
    			changeInfoList->AppendL( TLiwGenericParam( KChangeInfo,
    							TLiwVariant( listOfMatchingMaps ) ) );
    			
    			changeInfoList->AppendL( TLiwGenericParam( EGenericParamError,
    			    TLiwVariant( CDataSourceInterface::ErrCodeConversion( aErrorCode ) ) ) );
    			changeInfoList->AppendL( TLiwGenericParam( KErrorCode,
    			    TLiwVariant( CDataSourceInterface::ErrCodeConversion( aErrorCode ) ) ) );
    			(*observer)->HandleNotifyL( transactionId, event, *changeInfoList,
    			        *inParamList );
    			
    		    CleanupStack::PopAndDestroy( inParamList );
    		    CleanupStack::PopAndDestroy( changeInfoList );
    			}//if

    		CleanupStack::PopAndDestroy( &transV );
    		}//if
    	CleanupStack::PopAndDestroy( listOfMatchingMaps );
    	CleanupStack::PopAndDestroy( &mapsV );
    	CleanupStack::PopAndDestroy( &param );
    	}//for
	}


// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CCPActiveNotifier::DoCancel()
    {
    CP_DEBUG( _L8("CCPActiveNotifier::DoCancel()" ) );
    iServerClient.UnregisterObserver( );
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
TInt CCPActiveNotifier::RunError( TInt aError )
    {
    if (KErrNoMemory!=aError)
        {
        TRAP_IGNORE( RegisterAgainL( ) );
        }
    return KErrNone;
    }
// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
CCPActiveNotifier::CCPActiveNotifier( RCPServerClient& aServerClient ) :
    CActive(EPriorityStandard)
    {
    iServerClient = aServerClient;
    CActiveScheduler::Add( this );
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CCPActiveNotifier::ConstructL()
    {

    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CCPActiveNotifier::RegisterAgainL()
    {
    CP_DEBUG( _L8("CCPActiveNotifier::RegisterAgainL()" ) );

    if (!IsActive())
        {
        TIpcArgs args;
        args.Set(KTransactionPosition, KErrAlreadyExists);
        if (iSizeDes)
            {
            delete iSizeDes;
            iSizeDes = NULL;
            }
        iSizeDes = new (ELeave) TPckgBuf<TInt> ();
        args.Set(KReturnPosition, iSizeDes);
        iServerClient.RegisterObserverL(iStatus, args);
        SetActive();
        }
    }