/*

* Copyright (c) 2002-2009 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:  Notifier engine / server side*

*/

#include "mdsnotifier.h"

#include "mdcresult.h"

#include "mdcitem.h"

#include "mdsserversession.h"

#include "mdsnotifycomparator.h"

#include "mdslogger.h"

#include "mdcserializationbuffer.h"

#include "mdsmanipulationengine.h"

#include "mdccommon.pan"

// for CleanupResetAndDestroyPushL

#include <mmf/common/mmfcontrollerpluginresolver.h>

__USES_LOGGER

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

// NewL

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

//

CMdSNotifier* CMdSNotifier::NewL()

    {

    CMdSNotifier* that = CMdSNotifier::NewLC();

    CleanupStack::Pop( that );

    return that;

    }

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

// NewLC

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

//

CMdSNotifier* CMdSNotifier::NewLC()

    {

    CMdSNotifier* that = new(ELeave) CMdSNotifier();

    CleanupStack::PushL( that );

    that->ConstructL();

    return that;

    }

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

// Constructor

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

//

CMdSNotifier::CMdSNotifier()

    {

    }

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

// ConstructL

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

//

void CMdSNotifier::ConstructL()

    {

    iComparator = CMdSNotifyComparator::NewL();

    }

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

// Destructor

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

//

CMdSNotifier::~CMdSNotifier()

    {

    delete iComparator;

    iComparator = NULL;

    const TInt count = iEntries.Count();

    for ( TInt i = 0; i < count; ++i )

        {

        TEntry& e = iEntries[i];

        if ( e.iSerializedCondition )

            {

            delete e.iSerializedCondition;

            e.iSerializedCondition = NULL;

            }

        if ( e.iDataBuffer )

            {

            delete e.iDataBuffer;

            e.iDataBuffer = NULL;

            }

        }

    iEntries.Close();

    }

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

// Constructor

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

//

CMdSNotifier::TEntry::TEntry( TInt aId,

    TConditionType aType,

    CMdCSerializationBuffer* aSerializedBuffer,

    TDefId aNamespaceDefId, 

    CMdSServerSession& aSession, 

    TBool aConfidential)

    : iId( aId )

    , iType( aType )

    , iNamespaceDefId(aNamespaceDefId)

    , iSerializedCondition( aSerializedBuffer )

    , iSession( aSession )

    , iConfidential(aConfidential)    

    {

    iDataBuffer = NULL;

    iRemoteSizeMsgSlot = KErrNotFound;

    }

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

// TriggerL completes the client message and sends the data size

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

//

void CMdSNotifier::TEntry::TriggerL(

	TUint32 aCompleteCode,

    const RArray<TItemId>& aIdArray,

    RPointerArray<HBufC>& aUriArray )

    {

    const TInt remoteSizeMsgSlot = iRemoteSizeMsgSlot;

    iRemoteSizeMsgSlot = KErrNotFound;

    __ASSERT_DEBUG( !iDataBuffer, MMdCCommon::Panic( KErrCorrupt ) );

    if( iMessage.IsNull() )

        {

        return;

        }

    if( aIdArray.Count() )

		{

		if( iType & ( EObjectNotifyAddWithUri | EObjectNotifyModifyWithUri | EObjectNotifyRemoveWithUri  ) )

		    {

		    iDataBuffer = CopyToBufferL( aIdArray, aUriArray );

		    }

		else

		    {

		    iDataBuffer = CopyToBufferL( aIdArray );

		    }

	    iSession.SizeToRemoteL( iMessage, remoteSizeMsgSlot, iDataBuffer->Size());

		}

	else

		{

	    iSession.SizeToRemoteL( iMessage, remoteSizeMsgSlot, 0 );

		}

    __LOG2( ELogServer, "<- Notify trigger %d (%d)", iId, aCompleteCode );

    iMessage.Complete( aCompleteCode );

    }

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

// TriggerRelationItemsL completes the client

//                  message and sends the data size

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

//

void CMdSNotifier::TEntry::TriggerRelationItemsL(

	TUint32 aCompleteCode,

	CMdCSerializationBuffer& aBuffer,

	const RArray<TItemId>& aRelationIdArray)

    {

    const TInt remoteSizeMsgSlot = iRemoteSizeMsgSlot;

    iRemoteSizeMsgSlot = KErrNotFound;

    __ASSERT_DEBUG( !iDataBuffer, MMdCCommon::Panic( KErrCorrupt ) );

    if( iMessage.IsNull() )

        {

        return;

        }

    if(aRelationIdArray.Count())

		{

		iDataBuffer = CopyItemsToBufferL( aBuffer, aRelationIdArray );

	    iSession.SizeToRemoteL( iMessage, remoteSizeMsgSlot, iDataBuffer->Size());

		}

	else

		{

	    iSession.SizeToRemoteL( iMessage, remoteSizeMsgSlot, 0);

		}

    __LOG2( ELogServer, "<- Notify trigger %d (%d)", iId, aCompleteCode );

    iMessage.Complete( aCompleteCode );

    }

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

// TriggerSchemaL sends a schema notification

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

//

void CMdSNotifier::TEntry::TriggerSchema()

    {    

    if( iMessage.IsNull() )

        {

        return;

        }

    iRemoteSizeMsgSlot = KErrNotFound;

    iMessage.Complete( ESchemaModify );

    }

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

// TriggerError send a error message to the client

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

//

void CMdSNotifier::TEntry::TriggerError( TInt aErrorCode )

    {

    iRemoteSizeMsgSlot = KErrNotFound;

	delete iDataBuffer;

    iDataBuffer = NULL;

    __LOG2( ELogServer, "<- Notify trigger %d (%d)", iId, aErrorCode );

    if( !iMessage.IsNull() )

    	{

    	iMessage.Complete( aErrorCode );

    	}

    }

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

// CopyToBufferL copies id to buffer

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

//

CMdCSerializationBuffer* CMdSNotifier::TEntry::CopyToBufferL(const RArray<TItemId>& aIdArray)

	{

	// IDs are always stored in object ID, 

	// even if those are actually relation or event IDs

	const TUint32 count = aIdArray.Count();

	CMdCSerializationBuffer* buffer = CMdCSerializationBuffer::NewLC(

			sizeof( TMdCItemIds )

			+ count * CMdCSerializationBuffer::KRequiredSizeForTItemId );

	TMdCItemIds itemIds;

	itemIds.iNamespaceDefId = NamespaceDefId();

	itemIds.iObjectIds.iPtr.iCount = count;

	itemIds.iObjectIds.iPtr.iOffset = sizeof(TMdCItemIds);

	itemIds.SerializeL( *buffer );

	for( TInt i = 0; i < count; ++i )

		{

		buffer->InsertL( aIdArray[i] );

		}

	CleanupStack::Pop( buffer );

	return buffer;	

	}

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

// CopyToBufferL copies ids and uris to buffer

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

//

CMdCSerializationBuffer* CMdSNotifier::TEntry::CopyToBufferL(const RArray<TItemId>& aIdArray,

                                                                                                  const RPointerArray<HBufC>& aUriArray)

    {

    const TUint32 count = aIdArray.Count();

    const TUint32 uriCount = aUriArray.Count();

    TInt urisSize = CMdCSerializationBuffer::KRequiredSizeForTUint32;

    for( TInt i = uriCount - 1; i >=0; i-- )

        {

        urisSize += CMdCSerializationBuffer::RequiredSize( *aUriArray[i] );

        }

    TInt idsSize( sizeof( TMdCItemIds ) + count * CMdCSerializationBuffer::KRequiredSizeForTItemId );

    CMdCSerializationBuffer* buffer = CMdCSerializationBuffer::NewLC(

            urisSize + idsSize );

    TMdCItemIds itemIds;

    itemIds.iNamespaceDefId = NamespaceDefId();

    itemIds.iObjectIds.iPtr.iCount = count;

    itemIds.iObjectIds.iPtr.iOffset = sizeof(TMdCItemIds);

    itemIds.SerializeL( *buffer );

    // Insert IDs

    for( TInt i = 0; i < count; ++i )

        {

        buffer->InsertL( aIdArray[i] );

        }

    // Insert uri count

    buffer->InsertL( uriCount );

    // Insert uris

    for( TInt i = 0; i < uriCount; ++i )

        {

        // add uri

        const TDesC& uri =  *aUriArray[i];

        HBufC* lcUri = HBufC::NewLC( uri.Length() );

        lcUri->Des().Append( uri );

        buffer->InsertL( *lcUri );

        CleanupStack::PopAndDestroy( lcUri ); 

        lcUri = NULL;

        }

    CleanupStack::Pop( buffer );

    return buffer;  

    }

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

// CopyItemsToBufferL copies relation items to buffer

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

//

CMdCSerializationBuffer* CMdSNotifier::TEntry::CopyItemsToBufferL(

		CMdCSerializationBuffer& aRelationItemsBuffer, 

		const RArray<TItemId>& aIdArray)

	{

	const TUint32 count = aIdArray.Count();

	aRelationItemsBuffer.PositionL( KNoOffset );

	const TMdCItems& items = TMdCItems::GetFromBufferL( aRelationItemsBuffer );

	CMdCSerializationBuffer* buffer = NULL;

	if ( items.iRelations.iPtr.iCount == count )

		{

		buffer = CMdCSerializationBuffer::NewLC( aRelationItemsBuffer );

		}

	else

		{

		buffer = CMdCSerializationBuffer::NewLC( sizeof(TMdCItems)

				+ count * sizeof(TMdCRelation) );

		TMdCItems returnItems;

		returnItems.iNamespaceDefId = items.iNamespaceDefId;

		returnItems.iRelations.iPtr.iCount = count;

		returnItems.iRelations.iPtr.iOffset = sizeof(TMdCItems);

		buffer->PositionL( sizeof(TMdCItems) );

		for( TInt i = 0; i < items.iRelations.iPtr.iCount; ++i )

			{

			TMdCRelation relation;

			relation.DeserializeL( aRelationItemsBuffer );

			if ( aIdArray.Find( relation.iId ) >= 0 )

				{

				relation.SerializeL( *buffer );

				}

			}

		buffer->PositionL( KNoOffset );

		returnItems.SerializeL( *buffer );

		}

	CleanupStack::Pop( buffer );

	return buffer;

	}

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

// CacheL caches the notification

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

//

void CMdSNotifier::TEntry::CacheL(TUint32 aCompleteCode, 

                                                         const RArray<TItemId>& aIdArray, 

                                                         const RPointerArray<HBufC>& aUriArray)

    {

    if ( aIdArray.Count() <= 0 )

    	{

    	return;

    	}

    CMdCSerializationBuffer* data( NULL );

    if( iType & ( EObjectNotifyAddWithUri | EObjectNotifyModifyWithUri | EObjectNotifyRemoveWithUri  ) )

        {

        data = CopyToBufferL( aIdArray, aUriArray );

        }

    else

        {

        data = CopyToBufferL( aIdArray );

        }

    iSession.CacheNotificationL( iId, aCompleteCode, data );

    }

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

// CacheRelationItemsL caches the notification

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

//

void CMdSNotifier::TEntry::CacheRelationItemsL(TUint32 aCompleteCode,

		CMdCSerializationBuffer& aBuffer, 

		const RArray<TItemId>& aRelationIdArray )

    {

    CMdCSerializationBuffer* data = CopyItemsToBufferL( aBuffer, 

    		aRelationIdArray );

    iSession.CacheNotificationL(iId, aCompleteCode, data);

    }

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

// CacheL for schema mods

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

//

void CMdSNotifier::TEntry::CacheL(TUint32 aCompleteCode)

    {

    iSession.CacheNotificationL(iId, aCompleteCode, NULL);

    }

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

// TriggerCachedL triggers a previously cached notification

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

//

void CMdSNotifier::TEntry::TriggerCachedL(TUint32 aCompleteCode, 

		CMdCSerializationBuffer* aData)

    {

    const TInt remoteSizeMsgSlot = iRemoteSizeMsgSlot;

    iRemoteSizeMsgSlot = KErrNotFound;

    __ASSERT_DEBUG( !iDataBuffer, MMdCCommon::Panic( KErrCorrupt ) );

    if( iMessage.IsNull() )

        {

        return;

        }

    if( aData )

    	{

    	iSession.SizeToRemoteL( iMessage, remoteSizeMsgSlot, aData->Size());

    	}

	iDataBuffer = aData;

    __LOG2( ELogServer, "<- Notify trigger %d (%d)", iId, aCompleteCode );

    iMessage.Complete( aCompleteCode );

    }

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

// SetupForCallback

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

//

void CMdSNotifier::TEntry::SetupForCallback(

    RMessage2 aMessage, TInt aRemoteSizeMsgSlot )

    {

    __ASSERT_DEBUG( !IsPending(), MMdCCommon::Panic( KErrCorrupt ) );

    iMessage = aMessage;

    iRemoteSizeMsgSlot = aRemoteSizeMsgSlot;

    }

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

// GetDataBuffer

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

//

CMdCSerializationBuffer* CMdSNotifier::TEntry::GetDataBuffer()

    {

    CMdCSerializationBuffer* data = iDataBuffer;

    iDataBuffer = NULL;

    return data;

    }

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

// CreateEntry creates a new notifier entry

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

//

CMdSNotifier::TEntry& CMdSNotifier::CreateEntryL( TInt aId,

    TConditionType aType, CMdCSerializationBuffer* aSerializedBuffer,

    TDefId aNamespaceDefId, CMdSServerSession& aSession, TBool aConfidential )

    {

    TEntry entry = TEntry( aId, aType, aSerializedBuffer, aNamespaceDefId, aSession, aConfidential ); 

    User::LeaveIfError( iEntries.InsertInOrderAllowRepeats( entry, TLinearOrder<TEntry>(CMdSNotifier::Compare) ) ); 

    return FindEntryL( aId );

    }

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

// FindEntry

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

//

CMdSNotifier::TEntry& CMdSNotifier::FindEntryL( TInt aId )

    {

    CMdSNotifier::TEntry* entry = NULL;

    TInt low( 0 );

    TInt high( iEntries.Count() );

    while( low < high )

        {

        TInt mid( (low+high)>>1 );

        const TInt compare( aId - iEntries[mid].Id() );

        if( compare == 0 )

            {

            entry = &iEntries[mid];

            break;

            }

        else if( compare > 0 )

            {

            low = mid + 1;

            }

        else

            {

            high = mid;

            }

        }    

    if( !entry )

    	{

    	User::Leave( KErrNotFound );

    	}

    return *entry;

    }

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

// RemoveEntryL

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