/*
* 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:  The API supports attributes not present in MCS from SAT Api
*
*/


#include "mcsdrmscanner.h"
#include "menueng.h"
#include "menusrveng.h"
#include "menuengobject.h"
#include "menusrvengutils.h"

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

// ---------------------------------------------------------------------------
// Creates an instance of CMcsDrmScanner implementation
// ---------------------------------------------------------------------------
//
CMcsDrmScanner* CMcsDrmScanner::NewL( 
    MMcsDrmAppScanner& aObserver, 
    CMenuSrvEng& aSrvEng,
    CMenuSrvEngUtils& aUtils )
    {
    CMcsDrmScanner* self = new (ELeave) CMcsDrmScanner( 
        aObserver, aSrvEng, aUtils );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CMcsDrmScanner::~CMcsDrmScanner()
    {
    Cancel();
    iSrvEng.Engine().DequeueOperation( *this );
    iNotProtectedAppArray.Close();
    iDrmExpiredAppArray.Close();
    iDrmProtectedAppArray.Close();
    iChangedAppArray.Close();
    }
    
// -----------------------------------------------------------------------------
// CMcsDrmScanner::CMcsDrmScanner
// C++ default constructor
// -----------------------------------------------------------------------------
//
CMcsDrmScanner::CMcsDrmScanner( 
    MMcsDrmAppScanner& aObserver, 
    CMenuSrvEng& aSrvEng,
    CMenuSrvEngUtils& aUtils ): 
    CActive( EPriorityNormal ), iObserver( aObserver ), 
    iSrvEng( aSrvEng ), iUtils( aUtils )
    {    
    CActiveScheduler::Add( this );
    iOpStatus = EFalse;
    }

// -----------------------------------------------------------------------------
// CMcsDrmScanner::ConstructL
// S2nd phase constructor.
// -----------------------------------------------------------------------------
//
void CMcsDrmScanner::ConstructL()
    {
    Scan();
    }

// ---------------------------------------------------------------------------
// CMcsDrmScanner::DoCancel
// ---------------------------------------------------------------------------
//
void CMcsDrmScanner::DoCancel()
    {
    }

// ---------------------------------------------------------------------------
// CMcsDrmScanner::RunL
// ---------------------------------------------------------------------------
//
void CMcsDrmScanner::RunL()
    {
    User::LeaveIfError( iStatus.Int() ); // Handle errors in RunL.
    iSrvEng.Engine().QueueOperationL( *this );    
    }    

// ---------------------------------------------------------
// CMcsDrmScanner::RunError()
// ---------------------------------------------------------
//
TInt CMcsDrmScanner::RunError( TInt /*aError*/ )
    {
    // Ignore the error (what else could we do?).
    return KErrNone;
    }

// ---------------------------------------------------------
// CMcsDrmScanner::RunMenuEngOperationL
// ---------------------------------------------------------
//
void CMcsDrmScanner::RunMenuEngOperationL()
    {
    ScanDrmApplicationsL();
    iOpStatus = EFalse;
    }  
    
// ---------------------------------------------------------
// CMcsDrmScanner::CompletedMenuEngOperation
// ---------------------------------------------------------
//
void CMcsDrmScanner::CompletedMenuEngOperation( TInt /*aErr*/ )
    {
    }          

// ---------------------------------------------------------
// 
// ---------------------------------------------------------
//
void CMcsDrmScanner::GetAppItemsL( 
    RArray<TMenuItem>& aItemArray, 
    RArray<TAppItem>& aAppItemArray )
    {
    //for every item in apaAndCrItems array
    CMenuEng& eng = iSrvEng.Engine();
    for ( TInt i = 0; i<aItemArray.Count(); i++ )
        {        
        TUid appUid;
        if ( KErrNone == 
            CMenuSrvEngUtils::GetAppUid( 
            	eng.ObjectL(aItemArray[i].Id()), appUid) )
            {
            TAppItem appItem( aItemArray[i].Id(), appUid );
            aAppItemArray.AppendL(appItem);        
            }        
        }
    }

// ---------------------------------------------------------
// 
// ---------------------------------------------------------
//
void CMcsDrmScanner::GetUidsL( 
    RArray<TAppItem>& aAppItemArray, 
    RArray<TUid>& aUidArray )
    {
    for ( TInt i = 0; i<aAppItemArray.Count(); i++ )
        {  
        aUidArray.AppendL( aAppItemArray[i].Uid() );               
        }
    }

// ---------------------------------------------------------
// 
// ---------------------------------------------------------
//
TBool CMcsDrmScanner::RemoveNotExistingApps( 
    RArray<TUid>& aArrayToModify, 
    const RArray<TUid>& aUidArray )
    {  
    TInt index = 0;
    TBool changed = EFalse;
    while ( index < aArrayToModify.Count() )
        {
        if ( aUidArray.Find( aArrayToModify[index] ) == KErrNotFound )
            {
            aArrayToModify.Remove( index );
            changed = ETrue;
            }
        else
            {
            index++;
            }       
        }
    return changed;
    }        


// ---------------------------------------------------------
// 
// ---------------------------------------------------------
//
TBool CMcsDrmScanner::RemoveChangedApps( )
    {   
    TBool changed = EFalse;
    for( TInt i = 0; i< iChangedAppArray.Count(); i++ )
    	{
    	TInt index = iDrmExpiredAppArray.Find( iChangedAppArray[i] );
        if ( index != KErrNotFound )
               {
               iDrmExpiredAppArray.Remove( index );
               changed = ETrue;
               }
    	index = iDrmProtectedAppArray.Find( iChangedAppArray[i] );
        if ( index != KErrNotFound )
               {
               iDrmProtectedAppArray.Remove( index );
               changed = ETrue;
               }   	
    	}
    iChangedAppArray.Reset();
    return changed;
    }

// ---------------------------------------------------------
// 
// ---------------------------------------------------------
//
TBool CMcsDrmScanner::RemoveMissingApps( const RArray<TUid>& aUidArray )
    {    
    RemoveNotExistingApps( iNotProtectedAppArray, aUidArray );    
    
    TBool expiredChanged = 
        RemoveNotExistingApps( iDrmExpiredAppArray, aUidArray );    
        
    TBool protectedChanged = 
        RemoveNotExistingApps( iDrmProtectedAppArray, aUidArray );    

    TInt changed = EFalse;
    if ( expiredChanged || protectedChanged )
        {
        changed = ETrue;
        }
    return changed;
    }

// ---------------------------------------------------------
// 
// ---------------------------------------------------------
//
TBool CMcsDrmScanner::CheckDrmAppsL( const RArray<TAppItem>& aUidArray )
    {    
    TInt changed = EFalse;
    
    for ( TInt i = 0; i<aUidArray.Count(); i++ )
        {                        
        if ( iNotProtectedAppArray.Find( aUidArray[i].Uid() ) == KErrNotFound )
            {
            if ( iDrmProtectedAppArray.Find( aUidArray[i].Uid() ) == KErrNotFound &&
                iDrmExpiredAppArray.Find( aUidArray[i].Uid() ) == KErrNotFound )
                {
		        TBool attrExists;
		        RBuf attrVal;
        	    attrVal.CleanupClosePushL();
        	    attrVal.CreateL(KMenuMaxAttrValueLen);
        	    
                iSrvEng.GetAttributeL( 
                    aUidArray[i].Id(), 
                    KMenuAttrDrmProtection,
                    attrExists,
                    attrVal );

                if ( attrVal == KMenuDrmProtected )
                    {                       
                    iDrmProtectedAppArray.AppendL( aUidArray[i].Uid() );
                    changed = ETrue;
                    }
                else if ( attrVal == KMenuDrmRightsExpired )
                    {       
                    iDrmExpiredAppArray.AppendL( aUidArray[i].Uid() );
                    changed = ETrue;    
                    }
                else
                    {
                    iNotProtectedAppArray.AppendL( aUidArray[i].Uid() );        
                    }     
                CleanupStack::PopAndDestroy( &attrVal );                   
                }                                    
            }
        }
    
    return changed;
    }
    
// ---------------------------------------------------------
// CMcsDrmScanner::GetMcsItemsL
// ---------------------------------------------------------
//
void CMcsDrmScanner::ScanDrmApplicationsL()
    {    
    RArray<TMenuItem> mcsItems; 
    CleanupClosePushL( mcsItems );
    GetMcsAppItemsL( mcsItems );
          
    RArray<TAppItem> appArray;
    CleanupClosePushL( appArray );
    
    GetAppItemsL( mcsItems, appArray );
    
    RArray<TUid> uidArray;
    CleanupClosePushL( uidArray );
    
    GetUidsL( appArray, uidArray );
    
    TBool removeChanged = RemoveChangedApps( );     
    
    TBool removeMissing = RemoveMissingApps( uidArray );     
    
    TBool drmChanged = CheckDrmAppsL( appArray );
    
    CleanupStack::PopAndDestroy( &uidArray );        
    CleanupStack::PopAndDestroy( &appArray );
    CleanupStack::PopAndDestroy( &mcsItems );
    
    if ( removeChanged || removeMissing || drmChanged )
        {
        iObserver.HandleDrmAppEvent();    
        }        
    iOpStatus = EFalse;
    }

// ---------------------------------------------------------
// CMcsDrmScanner::GetMcsItemsL
// ---------------------------------------------------------
//
void CMcsDrmScanner::GetMcsAppItemsL( RArray<TMenuItem>& aArray )
    {
    TInt root;
    iSrvEng.Engine().RootFolderL( root );
    TMenuSrvTypeFilter appFilter;
    appFilter.SetType( KMenuTypeApp() );
    iSrvEng.Engine().GetItemsL( aArray, root, &appFilter, ETrue );
    }

// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
const RArray<TUid>& CMcsDrmScanner::DrmExpiredAppArray()
    {
    return iDrmExpiredAppArray;
    }

// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
const RArray<TUid>& CMcsDrmScanner::DrmProtectedAppArray()
    {
    return iDrmProtectedAppArray;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CMcsDrmScanner::Scan()
    {
    if ( !IsActive() && !iOpStatus )
        {
        iOpStatus = ETrue;
        TRequestStatus* ownStatus = &iStatus;
        *ownStatus = KRequestPending;
        SetActive();
        User::RequestComplete( ownStatus, KErrNone );
        } 
    }  

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CMcsDrmScanner::RemoveObserverAndScanL( TUid aUid )
    {
    iChangedAppArray.AppendL( aUid );
    Scan( );
    }
    
// End of File