/*

* Copyright (c) 2003-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:  The CNssTagSelectNotification class allows the client to

*               register and deregister for a voice tag select event. 

*

*/

// INCLUDE FILES

#include <e32std.h>

#include "nssvasctagselectnotification.h"

#include "nssvasmtagselecthandler.h"

#include "nssvasctagselectdata.h"

#include "rubydebug.h"

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

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

// CNssTagSelectNotification::NewL

// Two-phased constructor.

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

//

CNssTagSelectNotification* CNssTagSelectNotification::NewL()

    {

    // version of NewLC which leaves nothing on the cleanup stack

    CNssTagSelectNotification* self=NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// CNssTagSelectNotification::NewLC

// Two-phased constructor.

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

//

CNssTagSelectNotification* CNssTagSelectNotification::NewLC()

    {

    // NewLC with two stage construct

    CNssTagSelectNotification* self=new (ELeave) CNssTagSelectNotification();

    // get new, leave if can't

    CleanupStack::PushL(self);

    // push onto cleanup stack

    // (in case self->ConstructL leaves)

    self->ConstructL();      // use two-stage construct

    return self;

    }

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

// CNssTagSelectNotification::~CNssTagSelectNotification

// Destructor

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

//

CNssTagSelectNotification::~CNssTagSelectNotification()

    {

    RUBY_DEBUG0( "CNssTagSelectNotification::~CNssTagSelectNotification" );

    if ( iDBTagSelectNotifier ) 

        {

        iDBTagSelectNotifier->Deregister( this );

        }

    if ( iTagSelectDataList )

        {

        iTagSelectDataList->ResetAndDestroy();

        delete iTagSelectDataList;

        }

    CNssVASDBBuilder::RemoveInstance();  // remove iVasDBBuilder instance

    }

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

// CNssTagSelectNotification::RegisterL

// Method to register for voice tag select notification.

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

//

MNssTagSelectNotification::TNssSelectResult CNssTagSelectNotification::RegisterL(

                                         MNssContext* aContext,

                                         MNssTagSelectHandler* aTagSelectHandler )

    {

    RUBY_DEBUG_BLOCK( "CNssTagSelectNotification::RegisterL" );

    if ( iTagSelectDataList->Count() == 0 )

        {

        // register ourself

        TInt dbErrorCode;

        dbErrorCode = iDBTagSelectNotifier->RegisterForNotification( this );

        if ( dbErrorCode != KErrNone )

            {

            return EVasSelectFailed;

            }

        }

    CNssTagSelectData* tagSelectData = CNssTagSelectData::NewL( (CNssContext *) aContext,

        aTagSelectHandler );

    CleanupStack::PushL(tagSelectData);  

    iTagSelectDataList->AppendL( tagSelectData );

    CleanupStack::Pop(tagSelectData);  // do not destroy tagSelectData; it is appended

    return EVasErrorNone;

    }

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

// CNssTagSelectNotification::Deregister

// Method to deregister from voice tag select notification

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

//

MNssTagSelectNotification::TNssSelectResult CNssTagSelectNotification::Deregister(

                                          MNssContext* aContext,

                                          MNssTagSelectHandler* aTagSelectHandler )

    {

    RUBY_DEBUG0( "CNssTagSelectNotification::Deregister" );

    // if there is no registration, fail the deregister

    if ( iTagSelectDataList->Count() == 0 )

        {

        return EVasSelectFailed;

        }

    // loop through the TagSelectDataList entries

    // for each context match, check if the event handler also matches

    // if yes, delete the entry

    for ( TInt index=0; index < iTagSelectDataList->Count(); index++ )

        {

        TBool match = CompareContexts( (CNssContext *) aContext, index );

        MNssTagSelectHandler* tagSelectHandler;

        tagSelectHandler = iTagSelectDataList->At( index )->TagSelectHandler();

        if ( ( match == (TInt)ETrue ) &&

            (aTagSelectHandler == tagSelectHandler))	

            {

            CNssTagSelectData* tagSelectData = iTagSelectDataList->At( index ); 

            iTagSelectDataList->Delete( index ); 

            delete tagSelectData;

            break;  // exit the for loop

            }

        }

    if ( iTagSelectDataList->Count() == 0 )

        {

        // deregister ourself

        TInt dbErrorCode;

        dbErrorCode = iDBTagSelectNotifier->Deregister( this );

        if ( dbErrorCode != KErrNone )

            {

            RUBY_DEBUG0( "CNssTagSelectNotification, DBTagSelectNotifier->Deregister failed" );

            }

        }

    return EVasErrorNone;

    }

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

// CNssTagSelectNotification::HandleSelection

// Method called into the client by CNssDBTagSelectNotifier

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

//

void CNssTagSelectNotification::HandleSelection(CNssTag* aTag)

    {

    RUBY_DEBUG0( "CNssTagSelectNotification::HandleSelection" );

    // loop through the TagSelectDataList entries

    // for each context match, issue a HandleTagSelect response event

    for ( TInt index=0; index < iTagSelectDataList->Count(); index++ )

        {

        TBool result = CompareContexts((CNssContext *)(aTag->Context()), index);

        if ( result == (TInt)ETrue )

            {

            // make a copy of the tag for each client which registered for

            // the context of aTag

            // the client is responsible for deleting clientTag

            CNssTag* clientTag=NULL; 

            TRAPD( err, ( clientTag = aTag->CopyL() ) );

            if ( err != KErrNone )

                {

                RUBY_DEBUG0( "CNssTagSelectNotification: TRAPD CNssTag CopyL failed" );

                return;

                }

            iTagSelectDataList->At( index )->TagSelectHandler()->

                HandleTagSelect( (MNssTag*)clientTag );

            }

        }

    }

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

// CNssTagSelectNotification::CNssTagSelectNotification

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CNssTagSelectNotification::CNssTagSelectNotification()

    {

    }

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

// CNssTagSelectNotification::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNssTagSelectNotification::ConstructL()

    {	

    iTagSelectDataList = new (ELeave) CArrayPtrFlat<CNssTagSelectData>(1);

    iVasDBBuilder = CNssVASDBBuilder::InstanceL();

    iDBTagSelectNotifier = iVasDBBuilder->GetTagSelectNotifier();

    }

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

// CNssTagSelectNotification::CompareContexts

// Method to compare a context with a TagSelectDataList entry context.

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

//

TBool CNssTagSelectNotification::CompareContexts( CNssContext* aContext, TInt aIndex )

    {

    CNssContext* context;

    context = iTagSelectDataList->At( aIndex )->Context();

    if ( context->ContextName().Compare( aContext->ContextName() )==0 )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

// End of file