// Copyright (c) 2007-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:
//



// INCLUDE FILES
#include <featmgr/featurenotifier.h>
#include "featmgrdebug.h"
#include <featmgr/featurecmn.h>
#include "featmgrclient.h"

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// FindByUid
// Returns Zero if UIDs do match.
// -----------------------------------------------------------------------------
//  
static TInt FindByUid( const TUid* aFeature, const TUid& aItem )
    {
    if ( aFeature->iUid == aItem.iUid )
        {
        return 1;
        }

    return 0;
    }

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

// -----------------------------------------------------------------------------
// CFeatureNotifier::CFeatureNotifier()
// -----------------------------------------------------------------------------
//
CFeatureNotifier::CFeatureNotifier( MFeatureObserver& aObserver ) :
    CActive( EPriorityStandard ),
    iObserver( aObserver )
    {
    }

// -----------------------------------------------------------------------------
// CFeatureNotifier::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CFeatureNotifier* CFeatureNotifier::NewL( MFeatureObserver& aObserver )
    {
    CFeatureNotifier* self = new( ELeave ) CFeatureNotifier( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
    
// -----------------------------------------------------------------------------
// CFeatureNotifier::ConstructL
// -----------------------------------------------------------------------------
//
void CFeatureNotifier::ConstructL()
    {
    FUNC_LOG

    iFeatMgrClient = new (ELeave) RFeatMgrClient;
    // Connect to Feature Manager server
    TInt err( iFeatMgrClient->Connect() );
    if (err!=KErrNone)
      {
      delete iFeatMgrClient;
      iFeatMgrClient=NULL;
      }
    User::LeaveIfError(err);

    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// CFeatureNotifier::~CFeatureNotifier()
// -----------------------------------------------------------------------------
//
EXPORT_C CFeatureNotifier::~CFeatureNotifier()
    {
    FUNC_LOG
    
    if( iFeatMgrClient )
    	{
    	iFeatMgrClient->RequestNotifyCancelAll();
        iFeatMgrClient->Close();
        delete iFeatMgrClient;
    	}
    Cancel();

    iFeatures.Close();
    }

// -----------------------------------------------------------------------------
// CFeatureNotifier::NotifyRequest(TUid)
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CFeatureNotifier::NotifyRequest( TUid aFeature )
    {
    if(IsActive())
        {
        return KErrAlreadyExists;
        }

    iFeatures.Reset();
    TInt err=iFeatures.Append( aFeature );
    if (err!=KErrNone)
      {
      return err;
      }
    err = iFeatMgrClient->RequestNotification( iFeatures, iFeatureChanged, iStatus );
    if ( err == KErrNone )
    	{
        SetActive();
     	}
    else
      {
      iFeatures.Reset();
      }
     	    
    return err;
    }
    
// -----------------------------------------------------------------------------
// CFeatureNotifier::NotifyRequest(RFeatureUidArray&)
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CFeatureNotifier::NotifyRequest( RFeatureUidArray& aFeatures )
    {
    if(IsActive())
        {
        return KErrAlreadyExists;
        }

    iFeatures.Reset();
    TInt count = aFeatures.Count();
    TInt err=KErrNone;
    for(TInt i = 0; i < count; i++ )
        {
        // Do not append duplicate entries
        const TUid& uid( aFeatures[i] );
        TInt index = iFeatures.Find( uid, FindByUid );
        if( index == KErrNotFound )
            {
            err=iFeatures.Append( uid );
            if (err!=KErrNone)
              {
              iFeatures.Reset();
              return err;
              }
            }
        }

    err = iFeatMgrClient->RequestNotification( iFeatures, iFeatureChanged, iStatus );
    if ( err == KErrNone )
    	{
        SetActive();
     	}
    else
      {
      iFeatures.Reset();
      }
    return err;
    }
    
// -----------------------------------------------------------------------------
// CFeatureNotifier::NotifyCancel(TUid aFeature)
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CFeatureNotifier::NotifyCancel( TUid aFeature )
    {
    TInt err( KErrNotFound );
    TInt count = iFeatures.Count();
    
    for(TInt i = 0; i < count; i++ )
        {
        if( iFeatures[i].iUid == aFeature.iUid )
            {
            err = iFeatMgrClient->RequestNotifyCancel( aFeature );
            
            if( err == KErrNone )
                {
                iFeatures.Remove( i );
                // If this is the last feature in the list, then also cancel the Active Object
                if( 0 == iFeatures.Count() )
                	{
	                Cancel();
                	}
                break;
                }
            }
        }

    return err;
    }
    
// -----------------------------------------------------------------------------
// CFeatureNotifier::NotifyCancelAll()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CFeatureNotifier::NotifyCancelAll()
    {
    iFeatures.Reset();
    TInt err = iFeatMgrClient->RequestNotifyCancelAll( );
   	Cancel();
    
    return err;
    }

/**
 Gets the number of features in the server's array.
 This API is only for internal use and testing purposes.

 @return The number of features on the server for debug builds, otherwise it returns KErrNotSupported in release builds.
 @internalComponent
*/
EXPORT_C TInt CFeatureNotifier::NumberOfNotifyFeatures()
    {
#ifdef EXTENDED_FEATURE_MANAGER_TEST
    TInt count = iFeatMgrClient->NumberOfNotifyFeatures();
    return count;
#else
    return KErrNotSupported;
#endif
    }

/**
 Gets the number of heap cells in the thread.
 This API is only for internal use and testing purposes.

 @return The number of heap cells for debug build, otherwise it returns KErrNotSupported in release builds.
 @internalComponent
*/
EXPORT_C TInt CFeatureNotifier::CountAllocCells()
    {
#ifdef EXTENDED_FEATURE_MANAGER_TEST
    TInt count = iFeatMgrClient->CountAllocCells();
    return count;
#else
    return KErrNotSupported;
#endif
    }

// -----------------------------------------------------------------------------
// CFeatureNotifier::RunL()
// -----------------------------------------------------------------------------
//
void CFeatureNotifier::RunL( )
    {
    FUNC_LOG

    TInt status = iStatus.Int();
    if( status < 0 )
        {
        // Got an error
        if( status != KErrCancel )
            {
            iObserver.HandleNotifyError( status );
            }
        return;
        }

    // iStatus >= 0 means it contains the change type
    TFeatureChangeType changeType = static_cast<TFeatureChangeType>(status);

	// If the feature was deleted, remove it from the array of features with notifications requested
    if( changeType == EFeatureFeatureDeleted )
    	{
        TInt index = iFeatures.Find( iFeatureChanged, FindByUid );
        if( index != KErrNotFound )
            {
            iFeatures.Remove( index );
            }
    	}
    // Should we validate whether iFeatureChanged matches 
    // to any UID in the array of requested features?

    TFeatureEntry feature( iFeatureChanged );
    if( iFeatures.Count() > 0 )
        {
        // Asynchronously resubscribe notify request
        iFeatMgrClient->ReRequestNotification( iFeatureChanged, iStatus );
        // Next inform client about changed feature 
        // Should we validate whether iFeatureChanged matches 
        // to any UID in the array of requested features
        iObserver.HandleNotifyChange( changeType, feature );
        // Set us active
        SetActive();
        }
    else
        {
        // All features with notifications requested were deleted,
        // so don't need to resubscribe notify request -
        // just notify client about the deleted feature
        iObserver.HandleNotifyChange( changeType, feature );
        }
    }

// -----------------------------------------------------------------------------
// CFeatureNotifier::DoCancel()
// -----------------------------------------------------------------------------
//
void CFeatureNotifier::DoCancel( )
    {
    }

// -----------------------------------------------------------------------------
// CFeatureNotifier::RunError()
// -----------------------------------------------------------------------------
//
TInt CFeatureNotifier::RunError( TInt aError )
    {
    iObserver.HandleNotifyError( aError );

    return KErrNone;
    }

//  End of File