/*

* Copyright (c) 2004 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 class CDRMEventHandler

*

*/

// INCLUDE FILES

#include <s32mem.h> 

#include "DRMEventHandler.h"

#include "drmnotifierclientserver.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CDRMEventHandler::NewL

// Two-phased constructor.

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

//

CDRMEventHandler* CDRMEventHandler::NewL()

    {

    CDRMEventHandler* self = new( ELeave ) CDRMEventHandler;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CDRMEventHandler::~CDRMEventHandler

// Destructor.

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

//

CDRMEventHandler::~CDRMEventHandler()

{

    if( iHandler )

        {

        Cancel();

        }

    if( iData )

        {

        delete iData;

        iData = NULL;

        }

    if( iDataBuffer )

        {

        delete iDataBuffer;

        iDataBuffer = NULL;

        }

    if( iEventType )

        {

        delete iEventType;

        iEventType = NULL;

        }

    if( iWaitData )

        {

        delete iWaitData;

        iWaitData = NULL;

        }

    if( iWaitDataBuffer )

        {

        delete iWaitDataBuffer;

        iWaitDataBuffer = NULL;

        }

    if( iEventTypeWait )

        {

        delete iEventTypeWait;

        iEventTypeWait = NULL;

        }

    if ( iAddRemoveObservers ) 

        {

        for( TInt i = 0; i < iAddRemoveObservers->Count();i++)

            {

            delete (*iAddRemoveObservers)[i]->iContentID;

            (*iAddRemoveObservers)[i]->iContentID = NULL;

            }

        iAddRemoveObservers->Reset();

        delete iAddRemoveObservers;

        iAddRemoveObservers = NULL;

        }

    if ( iModifyObservers ) 

        {

        for( TInt i = 0; i < iModifyObservers->Count();i++)

            {

            delete (*iModifyObservers)[i]->iContentID;

            (*iModifyObservers)[i]->iContentID = NULL;

            }

        iModifyObservers->Reset();

        delete iModifyObservers;

        iModifyObservers = NULL;

        }

    if ( iTimeChangeObservers ) 

        {

        iTimeChangeObservers->Reset();

        delete iTimeChangeObservers;

        iTimeChangeObservers = NULL;

        }

    if ( iDelayedObservers )

        {

        for( TInt i = 0; i < iDelayedObservers->Count();i++)

            {

            delete (*iDelayedObservers)[i]->iContentID;

            (*iDelayedObservers)[i]->iContentID = NULL;

            }

        iDelayedObservers->Reset();

        delete iDelayedObservers;

        iDelayedObservers = NULL;

        }

    if( iHandler )

        {

        iHandler->Close();

        delete iHandler;

        iHandler = NULL;

        }

    }

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

// CDRMEventHandler::RegisterEventObserverL

// Adds the new handler to the list of handlers.

// Checks if the handler is already in the list

// Sets the active object active if it is not active yet.

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

//

void CDRMEventHandler::RegisterEventObserverL(

    MDRMEventObserver& aObserver,

    const TDRMEventType& aEvent )

    {

    TInt count = 0;

    TBool addToServer = ETrue;

    if( iIsDelayed )

        {

        TDelayedObserverData* delayData = new (ELeave) TDelayedObserverData;

        CleanupStack::PushL( delayData);

        delayData->iRequest = KRegisterOperation;

        delayData->iObserver = &aObserver;

        delayData->iEventType = aEvent;

        delayData->iContentID = NULL;

        iDelayedObservers->AppendL( delayData );

        CleanupStack::Pop();    // delayData;

        return;

        }

    switch ( aEvent )

        {

        case KEventAddRemove:

            if ( iAddRemoveObservers )

                {

                for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

                    {

                    if ( ( *iAddRemoveObservers )[ count ]->iObserver == &aObserver &&

                         !( *iAddRemoveObservers )[ count ]->iContentID )

                        {

                        return;

                        }

                    else if( addToServer && !( *iAddRemoveObservers)[ count ]->iContentID ) 

                        {

                        addToServer = EFalse;

                        }

                    }

                }

            break;

        case KEventModify:

            if ( iModifyObservers )

                {

                for ( count = 0; count < iModifyObservers->Count(); ++count )

                    {

                    if ( ( *iModifyObservers )[ count ]->iObserver == &aObserver &&

                         !( *iModifyObservers )[ count ]->iContentID )

                        {

                        return;

                        }

                    else if( addToServer && !( *iModifyObservers)[ count ]->iContentID ) 

                        {

                        addToServer = EFalse;

                        }

                    }

                }

            break;

        case KEventTimeChange:

            if ( iTimeChangeObservers )        

                {

                for ( count = 0; count < iTimeChangeObservers->Count(); ++count )

                    {

                    if ( ( *iTimeChangeObservers )[ count ]->iObserver == &aObserver )

                        {

                        return;

                        }

                    }

                }      

            break;

        default:

            User::Leave(KErrArgument);

            break;

        }  

    struct TObserverData* observer = new (ELeave) TObserverData;

    CleanupStack::PushL(observer);

    observer->iObserver = &aObserver;

    observer->iContentID = NULL;

    switch( aEvent )

        {

        case KEventAddRemove:

            if( this->iAddRemoveObservers ) // coverity check

                {

                iAddRemoveObservers->AppendL( observer );

                }

            break;

        case KEventModify:

            if( this->iModifyObservers ) // coverity check

                {

                iModifyObservers->AppendL( observer );

                }

            break;

        case KEventTimeChange:

            if( this->iTimeChangeObservers ) // coverity check

                {

                iTimeChangeObservers->AppendL( observer );

                }

            break;

        default:

            User::Leave(KErrArgument);

            break;

        }

    if ( !IsAdded() )

        {

        CActiveScheduler::Add( this );

        }

    if ( !IsActive() )

        {

        if( iStatus != KRequestPending )

            {

            iStatus = KRequestPending;

            iHandler->WaitForCompletion(iStatus);

            }

        SetActive();

        }

    // Register the type to the server

    if( addToServer )

        {

        iHandler->RegisterForType(aEvent);

        }

    CleanupStack::Pop(); // observer

    }

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

// CDRMEventHandler::UnRegisterEventObserverL

// Removes the observer from the list of handlers.

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

//

void CDRMEventHandler::UnRegisterEventObserverL( 

    MDRMEventObserver& aObserver,

    const TDRMEventType& aEvent)

    {

    TInt count = 0;

    TBool removeFromServer = ETrue;

    if( iIsDelayed )

        {

        TDelayedObserverData* delayData = new (ELeave) TDelayedObserverData;

        CleanupStack::PushL( delayData);

        delayData->iRequest = KUnRegisterOperation;

        delayData->iObserver = &aObserver;

        delayData->iEventType = aEvent;

        delayData->iContentID = NULL;

        iDelayedObservers->AppendL( delayData );

        CleanupStack::Pop();    // delayData;

        return;

        }

    // Check if something else uses the registration for this event type, if something

    // Does set removeFromServer to EFalse so the registration is not removed from the

    // server

    switch ( aEvent )

        {

        case KEventAddRemove:

            if ( iAddRemoveObservers )

                {

                for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

                    {

                    if( removeFromServer && !( *iAddRemoveObservers)[ count ]->iContentID &&

                        ( *iAddRemoveObservers)[ count ]->iObserver != &aObserver ) 

                        {

                        removeFromServer = EFalse;

                        }

                    }

                }

            break;

        case KEventModify:

            if ( iModifyObservers )

                {

                for ( count = 0; count < iModifyObservers->Count(); ++count )

                    {

                    if( removeFromServer && !( *iModifyObservers)[ count ]->iContentID &&

                        ( *iModifyObservers)[ count ]->iObserver != &aObserver ) 

                        {

                        removeFromServer = EFalse;

                        }

                    }

                }

            break;

        case KEventTimeChange:

            if ( iTimeChangeObservers )

                {

                for ( count = 0; count < iTimeChangeObservers->Count(); ++count )

                    {

                    if( ( *iTimeChangeObservers)[ count ]->iObserver != &aObserver ) 

                        {

                        removeFromServer = EFalse;

                        }

                    }

                }

            break;        

        default:

            User::Leave(KErrArgument);

            break;

        }  

    // Remove the registrations from internal lists and possibly from the server

    switch ( aEvent )

        {

        case KEventAddRemove:

            if ( iAddRemoveObservers )

                {

                for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

                    {

                    if ( ( *iAddRemoveObservers )[ count ]->iObserver == &aObserver &&

                         !( *iAddRemoveObservers )[ count ]->iContentID )

                        {

                        if( removeFromServer )

                            {

                            // Unregister the type from the server

                            iHandler->UnRegisterFromType(aEvent);

                            }

                        // Free Memory

                        delete ( *iAddRemoveObservers )[ count ];

                        ( *iAddRemoveObservers )[ count ] = NULL;

                        // Delete the element from the table

                        iAddRemoveObservers->Delete( count );

                        iAddRemoveObservers->Compress();

                        return;

                        }

                    }

                }

            User::Leave(KErrNotFound);

            break;

        case KEventModify:

            if ( iModifyObservers )

                {

                for ( count = 0; count < iModifyObservers->Count(); ++count )

                    {

                    if ( ( *iModifyObservers )[ count ]->iObserver == &aObserver &&

                         !( *iModifyObservers )[ count ]->iContentID )

                        {

                        if( removeFromServer )

                            {

                            // Unregister the type from the server

                            iHandler->UnRegisterFromType(aEvent);

                            }

                        // Free Memory

                        delete ( *iModifyObservers )[ count ];

                        ( *iModifyObservers )[ count ] = NULL;

                        // Delete the element from the table

                        iModifyObservers->Delete( count );

                        iModifyObservers->Compress();

                        return;

                        }

                    }

                }

            User::Leave(KErrNotFound);

            break;

        case KEventTimeChange:

            if ( iTimeChangeObservers )

                {

                for ( count = 0; count < iTimeChangeObservers->Count(); ++count )

                    {

                    if ( ( *iTimeChangeObservers )[ count ]->iObserver == &aObserver )

                        {

                        if( removeFromServer )

                            {

                            // Unregister the type from the server

                            iHandler->UnRegisterFromType(aEvent);

                            }

                        // Free Memory

                        delete ( *iTimeChangeObservers )[ count ];

                        ( *iTimeChangeObservers )[ count ] = NULL;

                        // Delete the element from the table

                        iTimeChangeObservers->Delete( count );

                        iTimeChangeObservers->Compress();

                        return;

                        }

                    }

                }

            User::Leave(KErrNotFound);        

            break;

        default:

            User::Leave(KErrArgument);

            break;

        }  

    // Should never get here

    User::Leave( KErrGeneral );

    }

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

// CDRMEventHandler::RegisterEventObserverL

// Adds the new handler to the list of handlers.

// Checks is the handler is already in the list

// Sets the active object active if it is not active yet.

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

//

void CDRMEventHandler::RegisterEventObserverL(

    MDRMEventObserver& aObserver,

    const TDRMEventType& aEvent,

    const TDesC8& aContentID )

    {

    TInt count = 0;

    TBool addToServer = ETrue;

    if( iIsDelayed )

        {

        TDelayedObserverData* delayData = new (ELeave) TDelayedObserverData;

        CleanupStack::PushL( delayData);

        delayData->iRequest = KRegisterURIOperation;

        delayData->iObserver = &aObserver;

        delayData->iEventType = aEvent;

        delayData->iContentID = aContentID.AllocLC();

        iDelayedObservers->AppendL( delayData );

        CleanupStack::Pop();    // iContentID;

        CleanupStack::Pop();    // delayData;

        return;

        }

    switch ( aEvent )

        {

        case KEventAddRemove:

            if ( iAddRemoveObservers )

                {

                for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

                    {

                    if ( ( *iAddRemoveObservers )[ count ]->iObserver == &aObserver &&

                         ( *iAddRemoveObservers )[ count ]->iContentID &&

                         !( *iAddRemoveObservers )[ count ]->iContentID->Compare( aContentID ) )

                        {

                        return;

                        }

                    else if( addToServer && 

                        !( *iAddRemoveObservers)[ count ]->iContentID->Compare( aContentID ) ) 

                        {

                        addToServer = EFalse;

                        }

                    }

                }

            break;

        case KEventModify:

            if ( iModifyObservers )

                {

                for ( count = 0; count < iModifyObservers->Count(); ++count )

                    {

                    if ( ( *iModifyObservers )[ count ]->iObserver == &aObserver &&

                         ( *iModifyObservers )[ count ]->iContentID &&

                         !( *iModifyObservers )[ count ]->iContentID->Compare( aContentID ) )

                        {

                        return;

                        }

                    else if( addToServer && 

                        !( *iModifyObservers)[ count ]->iContentID->Compare( aContentID ) ) 

                        {

                        addToServer = EFalse;

                        }

                    }

                }

            break;

        default:

            User::Leave(KErrArgument);

            break;

        }  

    HBufC8* contentID = aContentID.AllocLC();

    struct TObserverData* observer = new (ELeave) TObserverData;

    CleanupStack::PushL(observer);

    observer->iObserver = &aObserver;