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