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