/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* This file implements the SifNotifier library

*

*/

#include <usif/sif/sifnotification.h>

#include <s32mem.h> 

#include <scs/cleanuputils.h>

#include <scs/streamingarray.h>

#include "sifnotification_internal.h"

#include <usif/sif/sif.h>

#include "e32property.h" 

#include "scrclient.inl"

#include "usiflog.h"

using namespace Usif;

/**

 * A global method which is used by both the publisher and subscriber code to retrieve data.

 * 

 */

void GetDataL(TUint aKey, TInt& aBufferSize, RBuf8& aData)

    {

    aData.CreateL(aBufferSize);

    aData.CleanupClosePushL();

    TInt err = RProperty::Get(KUidSystemCategory, aKey, aData);

    // If the buffer size is too small.

    while (err == KErrOverflow)

        {

        aBufferSize*=2;

        aData.ReAllocL(aBufferSize);

        err = RProperty::Get(KUidSystemCategory, aKey, aData);

        }

    User::LeaveIfError(err);

    CleanupStack::Pop();

    }

////////////////////////////

// CPublishSifOperationInfo

////////////////////////////

CPublishSifOperationInfo::CPublishSifOperationInfo():

    iBufferSize(KBufferSize)

    {

    // empty

    }

CPublishSifOperationInfo::~CPublishSifOperationInfo()

    {

    delete iDeleteTimer;

    if (iStartEndKey != 0)

        {

        RProperty::Delete(KUidSystemCategory, iStartEndKey);

        RProperty::Delete(KUidSystemCategory, (iStartEndKey+1));

        }

    }

EXPORT_C CPublishSifOperationInfo* CPublishSifOperationInfo::NewL()

    {

    CPublishSifOperationInfo *self = CPublishSifOperationInfo::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CPublishSifOperationInfo* CPublishSifOperationInfo::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

void CPublishSifOperationInfo::ConstructL()

    {

    }

TUint CPublishSifOperationInfo::AvailableKeyL()

    {

    TBuf8<KMaxNumberOfOperations*sizeof(TInt)> buf;

    for(TInt i=0; i< KMaxNumberOfOperations-1; ++i)

        {

        if(KErrNotFound == RProperty::Get(KUidSystemCategory, KSifPropertyTable[i], buf))

            {

            return KSifPropertyTable[i];

            }

        }

	User::Leave(KErrInUse);

    return KErrNone; // Keep compiler happy.

    }

TUint CPublishSifOperationInfo::KeyForGlobalComponentIdL(const TDesC& aGlobalComponentId)

    {

    TBuf8<KMaxNumberOfOperations*sizeof(TInt)> buf;

    //Get all ongoing operations

    User::LeaveIfError(RProperty::Get(KUidSystemCategory, KSifOperationKey, buf));

    RDesReadStream readStream(buf);

    CleanupClosePushL(readStream);

    CSifOperationKey* opKey = CSifOperationKey::NewL(readStream);

    CleanupStack::PopAndDestroy(&readStream);

    CleanupStack::PushL(opKey);

    RArray<TUint> startEndKeyArr = opKey->StartEndKeys();

	// Get the data for all the ongoing operations and check for global component id

    for (TInt i=0; i<startEndKeyArr.Count(); ++i)

        {

        RBuf8 startDatabuf;

        startDatabuf.CleanupClosePushL();

		GetDataL(startEndKeyArr[i], iBufferSize, startDatabuf);

        RDesReadStream readStream(startDatabuf);

        CleanupClosePushL(readStream);

        // Read the first 4 bytes

        TSifOperation opType = static_cast<TSifOperation>(readStream.ReadInt32L());         

        if(opType != ESifOperationStart)

            {

            CleanupStack::PopAndDestroy(2, &startDatabuf);

            continue;

            }

        // Release the stream and reopen it.

        readStream.Release();

        readStream.Open(startDatabuf);

        CSifOperationStartData* startObj = CSifOperationStartData::NewL(readStream);

        CleanupStack::PushL(startObj);

		// Check if the global component id is the same as what we are looking for

        if( KErrNone == aGlobalComponentId.Compare(startObj->GlobalComponentId()))

            {

            TInt key = startEndKeyArr[i];

            CleanupStack::PopAndDestroy(4, opKey);

            return key;

            }

        CleanupStack::PopAndDestroy(3, &startDatabuf);

        }

    CleanupStack::PopAndDestroy(opKey);

    // Could not find corresponding key

    User::Leave(KErrNotFound);

    return KErrNone; // Keep compiler happy.

    }

void CPublishSifOperationInfo::SetKeyToDelete(TUint aStartEndKey)

    {

    iStartEndKey = aStartEndKey;

    }

EXPORT_C void CPublishSifOperationInfo::PublishStartL(CSifOperationStartData& aSifOperationStartData)

    {

    // Get Property key from free pool which could be used for this operation.

    TUint key = AvailableKeyL();    

    // Define key from free pool. Start data could be bigger than 512 bytes, hence using ELargeByteArray.

    User::LeaveIfError(RProperty::Define(KUidSystemCategory, key, RProperty::ELargeByteArray,KSecurityPolicyWDD,KSecurityPolicyNone,KStartBufLength));

    // Store this key and delete it in case of any leaves

    SetKeyToDelete(key);

    // Publish start info of operation in defined key.

    RBuf8 bufStartData;

    bufStartData.CleanupClosePushL();

    ExternalizeRefObjectL(aSifOperationStartData, bufStartData);

    User::LeaveIfError(RProperty::Set(KUidSystemCategory, key, bufStartData));

    CleanupStack::PopAndDestroy(&bufStartData);

    // Define key for progress data for this operation.

    User::LeaveIfError(RProperty::Define(KUidSystemCategory, (key+1), RProperty::EByteArray,KSecurityPolicyWDD,KSecurityPolicyNone, KProgressBufLength));

    // Publish(append this key to existing info) the newly defined key in the global SIF key.

    TBuf8<KMaxNumberOfOperations*sizeof(TUint)> buf;

    User::LeaveIfError(RProperty::Get(KUidSystemCategory, KSifOperationKey, buf));

    RDesReadStream stream(buf);

    CleanupClosePushL(stream);      

    // Retrieve current keys.

    CSifOperationKey* currentKeys = CSifOperationKey::NewL(stream);

    CleanupStack::PopAndDestroy(&stream);

    CleanupStack::PushL(currentKeys);

    // Append the new key.

    currentKeys->AddKeyL(key);

    RBuf8 bufOperationKeys;

    bufOperationKeys.CleanupClosePushL();

    ExternalizeRefObjectL(*currentKeys, bufOperationKeys);

    // Publish the new set of keys.

    User::LeaveIfError(RProperty::Set(KUidSystemCategory, KSifOperationKey, bufOperationKeys));

    // Everything finished fine, we need not delete the keys defined above.

    SetKeyToDelete(0);

    CleanupStack::PopAndDestroy(2, currentKeys);

    }

EXPORT_C void CPublishSifOperationInfo::PublishProgressL(CSifOperationProgressData& aSifOperationProgressData)

    {

    TUint startEndKey = 0;

    HBufC16 *compGlobalId = aSifOperationProgressData.GlobalComponentId().AllocLC();

	//Get the key defined for this operation

    startEndKey = KeyForGlobalComponentIdL(compGlobalId->Des());

    CleanupStack::PopAndDestroy(compGlobalId);

    //Publish progress info of operation in defined key

    RBuf8 bufProgressData;

    bufProgressData.CleanupClosePushL();

    ExternalizeRefObjectL(aSifOperationProgressData, bufProgressData);

    User::LeaveIfError(RProperty::Set(KUidSystemCategory, (startEndKey+1), bufProgressData));

    CleanupStack::PopAndDestroy(&bufProgressData);

    }

EXPORT_C void CPublishSifOperationInfo::PublishCompletionL(CSifOperationEndData& aSifOperationEndData)

    {

    TUint endKey = 0;

    HBufC *compGlobalId = aSifOperationEndData.GlobalComponentId().AllocLC();

	//Get the key defined for this operation

    endKey = KeyForGlobalComponentIdL(compGlobalId->Des());

    CleanupStack::PopAndDestroy(compGlobalId);

    // Store this key and delete it in case of any leaves

    SetKeyToDelete(endKey);

    //Publish end info of operation in defined key

    RBuf8 bufEndData;

    bufEndData.CleanupClosePushL();

    ExternalizeRefObjectL(aSifOperationEndData, bufEndData);

    User::LeaveIfError(RProperty::Set(KUidSystemCategory, endKey, bufEndData));

    CleanupStack::PopAndDestroy(&bufEndData);

    // Wait for KDeleteKeyDelay seconds before deleting this key.

    if(iDeleteTimer)

        iDeleteTimer->Cancel();

    delete iDeleteTimer;

    iDeleteTimer = CDeleteKeyTimer::NewL(endKey);

    // Everything finished fine, we need not delete the keys defined for this operation

    SetKeyToDelete(0);

    iDeleteTimer->Start();

    }

//////////////////////////

// CSifOperationsNotifier

//////////////////////////

EXPORT_C CSifOperationsNotifier* CSifOperationsNotifier::NewL(MSifOperationsHandler& aHandler)

    {

    CSifOperationsNotifier* self = CSifOperationsNotifier::NewLC(aHandler);

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CSifOperationsNotifier* CSifOperationsNotifier::NewLC(MSifOperationsHandler& aHandler)

    {

    CSifOperationsNotifier* self = new (ELeave) CSifOperationsNotifier(aHandler);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CSifOperationsNotifier::CSifOperationsNotifier(MSifOperationsHandler& aHandler):

    CActive(EPriorityNormal),

    iHandler(aHandler),

    iBufferSize(KBufferSize) 

    {

    //Empty

    }

void CSifOperationsNotifier::ConstructL()

    {

    CActiveScheduler::Add(this);

    iProperty.Attach(KUidSystemCategory,KSifOperationKey,EOwnerThread);

    // On first start, the notifier looks for any active operations and 

    // notifies the client.

    iNotifierState = EFirstStart;

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

    SetActive();

    }

void CSifOperationsNotifier::RunL()

    {  

    User::LeaveIfError(iStatus.Int());

    // Resubscribe for any changes to the global key.

    WaitForChangeL();

    if( iNotifierState == EFirstStart)

        {

        // Notify the client of any active operation.

        ActiveOperationsNotificationL();

        iNotifierState = EWaitForChange;    

        return;

        }

   // Global key change notification received.      

    RArray<TUint> newKeyArray;

    GetKeysL(newKeyArray);

    CleanupClosePushL(newKeyArray);

    if(iKeyArray.Count() < newKeyArray.Count())

        {

        // New Keys added.

        RBuf8 externalizedBuffer;

        externalizedBuffer.CleanupClosePushL();

        // Retrieve the new keys and send the start operation notification to each.

        for(TInt i = iKeyArray.Count(); i< newKeyArray.Count(); ++i)

            {

            externalizedBuffer.Close();

            GetDataL(newKeyArray[i], iBufferSize, externalizedBuffer);

            RDesReadStream stream(externalizedBuffer);

            CleanupClosePushL(stream);

            // Read the first 4 bytes

            TSifOperation opType = static_cast<TSifOperation>(stream.ReadInt32L());         

            if(opType != ESifOperationStart)

                {

                CleanupStack::PopAndDestroy(&stream);

                continue;

                }

            // Release the stream and reopen it.

            stream.Release();

            stream.Open(externalizedBuffer);

            CSifOperationStartData* startData = CSifOperationStartData::NewL(stream);

            CleanupStack::PushL(startData);

            //Update iKeyArray with the new key.

            iKeyArray.AppendL(newKeyArray[i]);

            iHandler.StartOperationHandler(newKeyArray[i], *startData);

            CleanupStack::PopAndDestroy(2, &stream);            

            }

        CleanupStack::PopAndDestroy(&externalizedBuffer);

        }

    else if (iKeyArray.Count() > newKeyArray.Count())

        {

        // Keys removed.

        for(TInt i = 0; i<iKeyArray.Count(); ++i)

            {

            // Key present in iKeyArray (the previous array of keys) is no longer

            // present in the newKeyArray.

            if(newKeyArray.Find(iKeyArray[i]) == KErrNotFound)

                {

                CancelSubscribeL(iKeyArray[i]);

                iKeyArray.Remove(i);

                }

            }

        }   

    CleanupStack::PopAndDestroy(&newKeyArray);

    }

void CSifOperationsNotifier::ActiveOperationsNotificationL()

    {

    // Notify the caller of any operation currently in progress.

    GetKeysL(iKeyArray);

    RBuf8 externalizedBuffer;

    for(TInt i=0; i<iKeyArray.Count(); ++i)

        {

        externalizedBuffer.Close();

        GetDataL(iKeyArray[i], iBufferSize, externalizedBuffer);

        CleanupClosePushL(externalizedBuffer);

        RDesReadStream stream(externalizedBuffer);

        CleanupClosePushL(stream);

        //Read the first 4 bytes

        TSifOperation opType = static_cast<TSifOperation>(stream.ReadUint32L());

        if(opType != ESifOperationStart)

            {

            // Ignore this key and continue.

            CleanupStack::PopAndDestroy(2, &externalizedBuffer);

            continue;

            }

        // Release the stream and reopen it.

        stream.Release();

        stream.Open(externalizedBuffer);

        CSifOperationStartData* startData = CSifOperationStartData::NewL(stream);

        CleanupStack::PushL(startData);

        iHandler.StartOperationHandler(iKeyArray[i], *startData); 

        CleanupStack::PopAndDestroy(startData);  

        CleanupStack::PopAndDestroy(2, &externalizedBuffer);  

        }

    }

void CSifOperationsNotifier::WaitForChangeL()

    {   

    iProperty.Subscribe(iStatus);

    SetActive();

    }

void CSifOperationsNotifier::GetKeysL(RArray<TUint>& aKeys)

    {

    TBuf8<KMaxNumberOfOperations * sizeof(TInt)> keysBuffer;

    User::LeaveIfError(iProperty.Get(keysBuffer));

    RDesReadStream stream(keysBuffer);

    CleanupClosePushL(stream);

    // Construct the CSifOperationKey object from the buffer.

    CSifOperationKey* opKey = CSifOperationKey::NewL(stream);

    CleanupStack::PushL(opKey);

    for(TInt i=0; i<opKey->StartEndKeys().Count(); ++i)

        {

        aKeys.AppendL(opKey->StartEndKeys()[i]);

        }

    CleanupStack::PopAndDestroy(2, &stream);

    }

EXPORT_C void CSifOperationsNotifier::SubscribeL(TUint aKey, TBool aSubscribeForProgressNotifications)

    {

    User::LeaveIfError(iKeyArray.Find(aKey));

    // Start End notifier.

    CSifNotifierBase* startEndNotifier = CSifNotifierBase::NewLC(iHandler, aKey, CSifNotifierBase::EStartEndNotifier);

    iNotifierArray.AppendL(startEndNotifier);

    CleanupStack::Pop(startEndNotifier);

    if(aSubscribeForProgressNotifications)

        {

        // Progress Notifier.

        CSifNotifierBase* progressNotifier = CSifNotifierBase::NewLC(iHandler, aKey+1, CSifNotifierBase::EProgressNotifier);

        iNotifierArray.AppendL(progressNotifier);

        CleanupStack::Pop(progressNotifier);

        }

    }

EXPORT_C void CSifOperationsNotifier::CancelSubscribeL(TUint aKey)

    {

    TInt index = iKeyArray.Find(aKey);

    if(index == KErrNotFound)

        {

        // No need to leave.

        return;

        }

    for(TInt i=0; i< iNotifierArray.Count(); ++i)

        {

        if(iNotifierArray[i]->Key() == aKey)

            {

            delete iNotifierArray[i];

            iNotifierArray.Remove(i);

            // Delete progress notification object also, if present.

            // i now points to the next element

            if( i <= iNotifierArray.Count()-1 && iNotifierArray[i]->Key() == aKey+1)

                {

                delete iNotifierArray[i];

                iNotifierArray.Remove(i);

                }

            }

        }

    }

EXPORT_C void CSifOperationsNotifier::CancelSubscribeL()

    {

    //Destroy all the notifiers.

    Cancel();

    }

void CSifOperationsNotifier::DoCancel()

    {

    iProperty.Cancel();

    iNotifierArray.ResetAndDestroy();

    }

TInt CSifOperationsNotifier::RunError(TInt aError)

    {

    DEBUG_PRINTF2(_L8("CSifOperationsNotifier::RunError : Error code %d"), aError);

    // If RunL() leaves due to ActiveOperationsNotificationL(), change the state.

    if(iNotifierState == EFirstStart)

        {

        iNotifierState = EWaitForChange;

        }

    (void)aError;

    return KErrNone;