// Copyright (c) 2004-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 <e32std.h>

 #include <e32svr.h>

 #include <centralrepository.h>

 #include "cenrepnotifyhandler.h"

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

 /**

 * Constructor used for single key listening.

 *

 * @param aCallback Reference to a callback instance.

 * @param aSession Reference to an existing repository session.

 * @param aKeyType  Type of the key identified by aId parameter.

 * @param aId       Id of the key that change notifications are needed for.

 * @capability      None

 */

 CCenRepNotifyHandler::CCenRepNotifyHandler(

     MCenRepNotifyHandlerCallback& aCallback, 

     CRepository& aSession, 

     TCenRepKeyType aKeyType, 

     TUint32 aId)

     : CActive(EPriorityStandard), iSession(aSession), 

     iCallback(aCallback), iKeyType(aKeyType), iId(aId), iWholeRepository(EFalse)

     {

     CActiveScheduler::Add(this);

     }

 /**

 * Constructor used for whole repository listening.

 *

 * @param aCallback Reference to a callback instance.

 * @param aSession Reference to an existing repository session.

 * @capability None

 */

 CCenRepNotifyHandler::CCenRepNotifyHandler(

     MCenRepNotifyHandlerCallback& aCallback, 

     CRepository& aSession)

     : CActive(EPriorityStandard), iSession(aSession), iCallback(aCallback), 

     iKeyType(EIntKey), iId(0), iWholeRepository(ETrue)

     {

     CActiveScheduler::Add(this);

     }

 /**

 * This is a two-phase constructor method that is used to

 * create a new instance for listening to the changes in a single key.

 *

 * @param aCallback Reference to a callback instance.

 * @param aSession  Reference to an existing repository session.

 *                  Do not close this session until all CCenRepNotifyHandler

 *                  instances referring to it have been deleted.

 * @param aKeyType  Type of the key identified by aId parameter. 

 * @param aId       Id of the key that change notifications are needed for.

 * @return          A pointer to a new instance of the CCenRepNotifyHandler class.

 * 

 * @leave           KErrArgument if invalid key type is passed as a parameter.

 * @capability      None

 */

 EXPORT_C CCenRepNotifyHandler* CCenRepNotifyHandler::NewL(

     MCenRepNotifyHandlerCallback& aCallback, 

     CRepository& aSession, 

     TCenRepKeyType aKeyType, 

     TUint32 aId)

     {

     CCenRepNotifyHandler* newInstance = NewLC(aCallback, aSession, aKeyType, aId);

     CleanupStack::Pop();

     return newInstance;

     }

 /**

 * This is a two-phase constructor method that is used to create a new

 * instance for listening to the changes in all keys in the repository. 

 *

 * Type specific callback methods of MCenRepNotifyHandlerCallback will not

 * be used when notifying about changes in this case,

 * only HandleNotifyGeneric() is used.

 *

 * @param aCallback Reference to a callback instance.

 * @param aSession  Reference to an existing repository session.

 *                  Do not close this session until all CCenRepNotifyHandler

 *                  instances referring to it have been deleted.

 * @return          A pointer to a new instance of the CCenRepNotifyHandler class.

 * @capability      None

 */

 EXPORT_C CCenRepNotifyHandler* CCenRepNotifyHandler::NewL(

     MCenRepNotifyHandlerCallback& aCallback, 

     CRepository& aSession)

     {

     CCenRepNotifyHandler* newInstance = NewLC(aCallback, aSession);

     CleanupStack::Pop();

     return newInstance;

     }

 /**

 * This is a two-phase constructor method that is used to create a new

 * instance for listening to the changes in a single key.

 * Leaves the constructed instance to cleanup stack.

 *

 * @param aCallback Reference to a callback instance.

 * @param aSession  Reference to an existing repository session.

 *                  Do not close this session until all CCenRepNotifyHandler

 *                  instances referring to it have been deleted.

 * @param aKeyType  Type of the key identified by aId parameter.

 * @param aId       Id of the key that change notifications are needed for.

 * @return          A pointer to a new instance of the CCenRepNotifyHandler class.

 * 

 * @leave           KErrArgument if invalid key type is passed as a parameter.

 * @capability      None

 */

 EXPORT_C CCenRepNotifyHandler* CCenRepNotifyHandler::NewLC(

     MCenRepNotifyHandlerCallback& aCallback, 

     CRepository& aSession, 

     TCenRepKeyType aKeyType, 

     TUint32 aId)

     {

     if ( aKeyType != EIntKey && 

          aKeyType != ERealKey && 

          aKeyType != EStringKey  && 

          aKeyType != EBinaryKey ) 

         { 

         User::Leave( KErrArgument ); 

         } 

     CCenRepNotifyHandler* newInstance = new (ELeave) CCenRepNotifyHandler( aCallback, aSession, 

                                                                            aKeyType, aId);

     CleanupStack::PushL( newInstance );

     return newInstance;

     }

 /**

 * This is a two-phase constructor method that is used to create a new

 * instance for listening to the changes in all keys in the repository.

 * Leaves the constructed instance to cleanup stack. 

 *

 * Type specific callback methods of MCenRepNotifyHandlerCallback will

 * not be used when notifying about changes in this case,

 * only HandleNotifyGeneric() is used.

 *

 * @param aCallback Reference to a callback instance.

 * @param aSession  Reference to an existing repository session.

 *                  Do not close this session until all CCenRepNotifyHandler

 *                  instances referring to it have been deleted.

 * @return          A pointer to a new instance of the CCenRepNotifyHandler class.

 * @capability      None

 */

 EXPORT_C CCenRepNotifyHandler* CCenRepNotifyHandler::NewLC(

     MCenRepNotifyHandlerCallback& aCallback, 

     CRepository& aSession)

     {

     CCenRepNotifyHandler* newInstance = new (ELeave) CCenRepNotifyHandler(aCallback, aSession);

     CleanupStack::PushL( newInstance );

     return newInstance;

     }

 // Destructor

 EXPORT_C CCenRepNotifyHandler::~CCenRepNotifyHandler()

     {

     Cancel();

     }

 /**

 * When this method is called, the CCenRepNotifyHandler starts

 * listening for notifications. If it is already listening, nothing happens.

 *

 * For single setting handler when there is already an existing notification

 * on the same setting and session,the HandleNotifyError will be trigerred with

 * KErrAlreadyExists error

 * @leave KErrNotFound if setting does not exist

 * 		 KErrPermissionDenied if client does not have the necessary capability

 * plus other system-wide error codes.

 * For whole settings handler, the HandleNotifyError will be trigerred with the 

 * error code

 * @capability Dependent Capability required depends on platform security of keyspace.

 */

 EXPORT_C void CCenRepNotifyHandler::StartListeningL()

     {

     if(IsActive())

         {

         return;

         }

     User::LeaveIfError(OrderNotification());

     SetActive();

     }

 /**

 * When this method is called, the CCenRepNotifyHandler stops

 * listening for notifications. If it is already stopped, nothing happens.

 * @capability      None

 */

 EXPORT_C void CCenRepNotifyHandler::StopListening()

     {

     if(IsActive())

         {

         Cancel();

         }

     }

 /**

 * Implements CActive

 */    

 void CCenRepNotifyHandler::RunL()

     {

     // Check that notification was for correct ID or it was caused by

     // a repository wide reset (KInvalidNotificationId).

     TUint32 status = static_cast<TUint32>(iStatus.Int());

     if( !iWholeRepository && status != iId && 

         status != NCentralRepositoryConstants::KInvalidNotificationId )

         {

 #ifdef _DEBUG

         RDebug::Print(_L("CCenRepNotifyHandler::RunL(): Received notif about unknown key: %d"), 

         status);

         RDebug::Print(_L("CCenRepNotifyHandler::RunL(): Notification not renewed."));

 #endif

         // We are not listening to key notified for us. Do not reorder notification 

         // as there is clearly some problems in central repository.

         iCallback.HandleNotifyError(status, KErrArgument, this);

         return;

         }

     if (iWholeRepository && iStatus.Int() == KErrPermissionDenied)

     	{

         RArray<TUint32> allKeyList;

         //check every single settings that we have read permission

         TRAPD(err,iSession.FindL(0x00000000,0x00000000,allKeyList));

         if (err==KErrNone)

         	{

         	TInt arrayCount=allKeyList.Count();

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

         		{

         		TUint32 dummyMeta;

         		err=iSession.GetMeta(allKeyList[i],dummyMeta);

         		//potential error at this stage likely to include only

         		//KErrPermissionDenied plus other resource allocation

         		//error such as KErrNoMemory

         		if (err!=KErrNone)

         			{

         			TInt errorkey=allKeyList[i];

         			allKeyList.Close();

         			iCallback.HandleNotifyError(errorkey, err, this);

 					return;

         			}

                 }

         	}

         else

             {

             iCallback.HandleNotifyError( NCentralRepositoryConstants::KUnspecifiedKey , err, this );

             return;

             }

     	}

     // Reorder notification

     TInt err = OrderNotification();

     // Handle notification

     if ( err == KErrNone )

         {

         SetActive();

         if ( iWholeRepository )

             {

             iCallback.HandleNotifyGeneric(status);

             }

         else

             {

             switch (iKeyType)

                 {

                 case EIntKey:

                     {

                     TInt newValue;

                     err=iSession.Get(iId, newValue);

                     if (err==KErrNone)

                     	{

                     	iCallback.HandleNotifyInt(iId, newValue);

                     	}

                     }

                     break;

                 case ERealKey:            

                     {

                     TReal newValue;

                     err=iSession.Get(iId, newValue);

                     if (err==KErrNone)

                     	{

                     	iCallback.HandleNotifyReal(iId, newValue);

                     	}

                     }

                     break;

                 case EStringKey:

                     {

                     TBuf16<NCentralRepositoryConstants::KMaxUnicodeStringLength> newValue;

                     err=iSession.Get(iId, newValue);

                     if (err==KErrNone)

                     	{

                     	iCallback.HandleNotifyString(iId, newValue);

                     	}

                     }

                     break;

                 case EBinaryKey:

                     {

                     TBuf8<NCentralRepositoryConstants::KMaxBinaryLength> newValue;

                     err=iSession.Get(iId, newValue);

                     if (err==KErrNone)

                     	{

                     	iCallback.HandleNotifyBinary(iId, newValue);

                     	}

                     }

                     break;

                 default:

                     break;

                 }

             if (err!=KErrNone)

             	{           	

             	iCallback.HandleNotifyError(iId,err,this);

             	}

             }

         }

     else

         {

         iCallback.HandleNotifyError(status, err, this);

         }

     }

 /**

 * Implements CActive

 * @param aError the error returned

 * @return error

 */

 TInt CCenRepNotifyHandler::RunError(TInt aError)

     {

     if ( iWholeRepository )

         {

         iCallback.HandleNotifyError(NCentralRepositoryConstants::KInvalidNotificationId, 

                                     aError, this);    

         }

     else

         {

         iCallback.HandleNotifyError(iId, aError, this);    

         }

     return KErrNone;

     }

 /**

 * Implements CActive

 */    

 void CCenRepNotifyHandler::DoCancel()

     {

     if ( iWholeRepository )

         {

         iSession.NotifyCancelAll();

         }

     else

         {

         iSession.NotifyCancel(iId);

         }

     }

 /* 

 * Order notification

 * @return error code from CenRep

 */

 TInt CCenRepNotifyHandler::OrderNotification()

     {

     if ( iWholeRepository )

         {

         // order notification for all keys in repository

         return iSession.NotifyRequest(0x00000000, 0x00000000, iStatus);

         }

     else

         {

         return iSession.NotifyRequest(iId, iStatus);

         }

     }

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

 // MCenRepNotifyHandlerCallback::HandleNotifyXXX

 // Default implementations for callback interface. 

 // In debug build these methods print trace. 

 // In release build they do nothing.

 //

 // These methods are documented in cenrepnotifierhandler.h. Don't redocument

 // here.

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

 // 

 #ifdef _DEBUG

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyInt(TUint32 aId, TInt aNewValue)

     {

     RDebug::Print(_L("MCenRepNotifyHandlerCallback: Integer key %d changed, new value: %d"), 

     aId, aNewValue);

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyReal(TUint32 aId, TReal aNewValue)

     {

     RDebug::Print(_L("MCenRepNotifyHandlerCallback: Real key %d changed, new value: %e"), 

     aId, aNewValue);

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyString(TUint32 aId, 

                                                                const TDesC16&  aNewValue)

     {

     RDebug::Print(_L("MCenRepNotifyHandlerCallback: String key %d changed, new value: %S"), 

     aId, &aNewValue);

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyBinary(TUint32 aId, 

                                                                const TDesC8&  aNewValue)

     {

     RDebug::Print(_L("MCenRepNotifyHandlerCallback: Binary key %d changed, new value: %s"), 

     aId, aNewValue.Ptr());

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyGeneric(TUint32 aId)

     {

     if ( aId == NCentralRepositoryConstants::KInvalidNotificationId )

         {

         RDebug::Print(_L("MCenRepNotifyHandlerCallback: "));

         RDebug::Print(_L("Repository wide reset caused generic notification"));

         }

     else

         {

         RDebug::Print(_L("MCenRepNotifyHandlerCallback: Generic key %d changed"), aId);

         }

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyError(TUint32 aId, TInt aError, 

                                                               CCenRepNotifyHandler* aHandler)

     {

     RDebug::Print(_L("MCenRepNotifyHandlerCallback %d notifies error for id: %d, error: %d"), 

     aHandler, aId, aError);

     }

 #else

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyInt(TUint32 /*aId*/, TInt /*aNewValue*/)

     {

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyReal(TUint32 /*aId*/, TReal /*aNewValue*/)

     {

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyString(TUint32 /*aId*/, 

     const TDesC16&  /*aNewValue*/)

     {

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyBinary(TUint32 /*aId*/, 

     const TDesC8&  /*aNewValue*/)

     {

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyGeneric(TUint32 /*aId*/)

     {

     }

 EXPORT_C void MCenRepNotifyHandlerCallback::HandleNotifyError(TUint32 /*aId*/, TInt /*aError*/, 

     CCenRepNotifyHandler* /*aHandler*/)

     {

     }

 #endif // _DEBUG

 // End of File