/*
 * Copyright (c) 2008 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:  ?Description
 *
 */

#include "s32mem.h"

#include <usif/usifcommon.h> 
#include <usif/scr/scr.h>
#include <usif/scr/screntries.h>

#include "caprogressnotifier.h"
#include "castorageproxy.h"
#include "cainnerquery.h"
#include "cainnerentry.h"
#include "caarraycleanup.inl"

using namespace Usif;

//fake constants
const TInt KMaxProgressValue = 100;
const TInt KDelayTimeBetweenNotifications(500000);


#ifdef COVERAGE_MEASUREMENT
#pragma CTC SKIP
#endif //COVERAGE_MEASUREMENT (fake notifier timer)

EXPORT_C CCaFakeProgressNotifier* CCaFakeProgressNotifier::NewL(
        MCaFakeProgressListener& aListener )
    {
    CCaFakeProgressNotifier* self = new ( ELeave ) CCaFakeProgressNotifier( aListener );
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop( self );
    return self;
    }

CCaFakeProgressNotifier::~CCaFakeProgressNotifier()
    {
    Cancel();
    iTimer.Close();
    }

CCaFakeProgressNotifier::CCaFakeProgressNotifier( MCaFakeProgressListener& aListener ) :
    CActive( EPriorityNormal ), iListener( aListener ), iCount( 0 ) 
    {
    CActiveScheduler::Add( this );
    }

void CCaFakeProgressNotifier::ConstructL(  )
    {
    User::LeaveIfError( iTimer.CreateLocal() );
    }

void CCaFakeProgressNotifier::StartNotifying()
    {
    iCount = 0;
    Cancel();
    iTimer.After( iStatus, TTimeIntervalMicroSeconds32( KDelayTimeBetweenNotifications ) );
    SetActive();
    }

void CCaFakeProgressNotifier::DoCancel()
    {    
    iTimer.Cancel();
    }

void CCaFakeProgressNotifier::RunL()
    {
    User::LeaveIfError( iStatus.Int() );
    
    if ( iCount <= KMaxProgressValue )
        {
        if( iCount > 20 )
            {            
            iListener.HandleFakeProgressNotifyL(iCount); 
            }     
        iTimer.After( iStatus, TTimeIntervalMicroSeconds32( KDelayTimeBetweenNotifications ) );
        SetActive();
        iCount += 20;
        }
    }

TInt CCaFakeProgressNotifier::RunError( TInt /*aError*/)
    {
    // No need to do anything
    return KErrNone;
    }

#ifdef COVERAGE_MEASUREMENT
#pragma CTC ENDSKIP
#endif //COVERAGE_MEASUREMENT  (fake notifier)



// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C CCaProgressNotifier* CCaProgressNotifier::NewL(
        CCaStorageProxy& aCaStorageProxy )
    {
    CCaProgressNotifier* self = new ( ELeave ) CCaProgressNotifier(  );
    CleanupStack::PushL( self );
    self->ConstructL( aCaStorageProxy );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CCaProgressNotifier::~CCaProgressNotifier()
    {
    // TODO: Commented out since USIF notifications do not 
    // work on MCL wk20
    /*
    iNotifier->CancelSubscribeL();
    delete iNotifier;
    */
    
    // needed for fake:
    delete iUsifUninstallNotifier;
    delete iJavaInstallNotifier;
    delete iFakeProgressNotifier;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CCaProgressNotifier::CCaProgressNotifier()
    {
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaProgressNotifier::ConstructL( CCaStorageProxy& aCaStorageProxy )
    {
    // TODO: Commented out since USIF notifications do not 
    // work on MCL wk20
    /*
    iNotifier = CSifOperationsNotifier::NewL(*this);
    */
    
    iStorageProxy = &aCaStorageProxy;
    
    iUsifUninstallNotifier = CCaInstallNotifier::NewL( *this,
            CCaInstallNotifier::EUsifUninstallNotification );

    iJavaInstallNotifier = CCaInstallNotifier::NewL( *this,
                CCaInstallNotifier::EJavaInstallNotification );

    iFakeProgressNotifier = CCaFakeProgressNotifier::NewL(*this);    
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaProgressNotifier::StartOperationHandler(TUint /*aKey*/, const CSifOperationStartData& /*aStartData*/)
    {
    // TODO: Commented out since USIF notifications do not 
    // work on MCL wk20
    /*
    iNotifier->SubscribeL( aKey, ETrue );
    */
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaProgressNotifier::EndOperationHandler(const CSifOperationEndData& /*aEndData*/)
    {
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCaProgressNotifier::ProgressOperationHandler(const CSifOperationProgressData& /*aProgressData*/)
    {
    
    // TODO: Commented out since USIF notifications do not 
    // work on MCL wk20
    
    /* 
    // extract component ID
    TBuf8<20> globalIdBuf;
    globalIdBuf.Copy( aProgressData.GlobalComponentId() );
    
    RDesReadStream readStream( globalIdBuf );
    CleanupClosePushL( readStream );
    CGlobalComponentId *globalId = CGlobalComponentId::NewL( readStream );
    CleanupStack::PushL(globalId);
     
    RSoftwareComponentRegistry iScrSession;
    TComponentId componentId = iScrSession.GetComponentIdL( globalId->GlobalIdName(), 
            globalId->SoftwareTypeName() );

    CleanupStack::PopAndDestroy( globalId );
    CleanupStack::PopAndDestroy( &readStream );

    RBuf componentIdBuf;
    componentIdBuf.CleanupClosePushL();
    componentIdBuf.CreateL( sizeof(TComponentId) + 1 );
    componentIdBuf.AppendNum( componentId );

    // find entry by componentID
    CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
    innerQuery->SetRole( CCaInnerQuery::Item );
    innerQuery->AddAttributeL( KCaAttrComponentId,
            componentIdBuf );

    RPointerArray<CCaInnerEntry> resultArrayItems;
    CleanupResetAndDestroyPushL( resultArrayItems );
    iStorageProxy->GetEntriesL( innerQuery, resultArrayItems );
   
    RBuf totalProgressBuf;
    totalProgressBuf.CleanupClosePushL();
    totalProgressBuf.CreateL( sizeof(TComponentId) + 1 );
    totalProgressBuf.AppendNum( aProgressData.CurrentProgess() );

    if (resultArrayItems.Count() && aProgressData.Phase() == EUninstalling)
        {
        CCaInnerEntry* appEntry = resultArrayItems[0];
        appEntry->AddAttributeL(KCaAppUninstallProgress, totalProgressBuf);

        iStorageProxy->AddL(appEntry, ETrue, EItemUninstallProgressChanged );
        }
    CleanupStack::PopAndDestroy( &totalProgressBuf );
    CleanupStack::PopAndDestroy( &resultArrayItems );
    CleanupStack::PopAndDestroy( innerQuery );
    CleanupStack::PopAndDestroy( &componentIdBuf );
    */
    }

void CCaProgressNotifier::HandleInstallNotifyL( TInt /*aUid*/)
    {
    // start sending fake notifications
    iFakeProgressNotifier->StartNotifying();
    }

void CCaProgressNotifier::HandleFakeProgressNotifyL(TInt aCurrentProgress)
    {
    //update storage with new info
    
    // find entry by componentID
    CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
    innerQuery->SetRole( CCaInnerQuery::Item );
    innerQuery->SetFlagsOn(EUninstall);
    
    RPointerArray<CCaInnerEntry> resultArrayItems;
    CleanupResetAndDestroyPushL( resultArrayItems );
    iStorageProxy->GetEntriesL( innerQuery, resultArrayItems );
    
    
    RBuf totalProgressBuf;
    totalProgressBuf.CleanupClosePushL();
    totalProgressBuf.CreateL( sizeof( TInt ) + 1 );
    totalProgressBuf.AppendNum( aCurrentProgress );
    
    for ( TInt i = 0; i<resultArrayItems.Count(); i++ )
       {
       CCaInnerEntry* appEntry = resultArrayItems[i];
       appEntry->AddAttributeL(KCaAppUninstallProgress, totalProgressBuf);
       iStorageProxy->AddL(appEntry, ETrue, EItemUninstallProgressChanged );
       }
    
    CleanupStack::PopAndDestroy( &totalProgressBuf );
    CleanupStack::PopAndDestroy( &resultArrayItems );
    CleanupStack::PopAndDestroy( innerQuery );
    }