/*

* Copyright (c) 2003 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:  Implementation of the DRM Rights Database

*

*/

// INCLUDE FILES

#include <e32std.h>		// RPointerArray

#include <e32def.h>		// Type definitions

#include <caf/caf.h>

#include <dcfrep.h>

#include "DRMCommon.h"	// DRM Error messages

#include "DRMObsoleteFinder.h"

#include "DRMRightsDB.h"

#include "drmlog.h"

#include <dcfrep.h>

#include <SysUtil.h>    // Disk space checking

#ifdef RD_MULTIPLE_DRIVE

#include <DriveInfo.h>

#endif

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TInt KScanFileSystem = 1;

const TInt KScanContents = 2;

const TInt KRemoveUsedParents = 3;

const TInt KWriteTempFile = 4;

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

LOCAL_C TInt CompareHBufC8( const HBufC8& aFirst, const HBufC8& aSecond );

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

LOCAL_C TInt CompareHBufC8( const HBufC8& aFirst, const HBufC8& aSecond )

    {

	return aFirst.Compare( aSecond );

    };

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

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

// CDRMObsoleteFinder::NewL

// Two-phased constructor.

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

//

CDRMObsoleteFinder* CDRMObsoleteFinder::NewL( RFs& aFs,

                                            CDRMRightsDB* aDatabase,

                                            TRequestStatus& aStatus,

                                            RWriteStream& aStream,

                                            TBool aPerformScan )

    {

    CDRMObsoleteFinder* self = new( ELeave ) CDRMObsoleteFinder( aFs, 

                                                        aDatabase, aStatus, 

                                                        aStream );

    CleanupStack::PushL( self );

    self->ConstructL( aPerformScan );

    CleanupStack::Pop();

    return self;

    }

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

// Destructor        

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

//

CDRMObsoleteFinder::~CDRMObsoleteFinder()

    {

    // just in case

    Cancel();

    if( iDcfClient )

        {

        delete iDcfClient;

        iDcfClient = NULL;    

        }

    if( iContents )

        {

        delete iContents;

        iContents = NULL;   

        }

    if( iParents )

        {

        delete iParents;

        iParents = NULL;            

        }

    if( iNoContents )

        {

        delete iNoContents;

        iNoContents = NULL;            

        }            

    };

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

// CDRMObsoleteFinder::ExecuteCleanupLD        

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

//    

void CDRMObsoleteFinder::ExecuteFinderLD()

    {

    TRequestStatus* status = 0;

    if( !IsAdded() ) 

        {

        CActiveScheduler::Add(this);        

        }

    if ( !IsActive() ) 

        {

        SetActive();        

        }

    iOperationStatus = KRequestPending;

    status = &iStatus;

    User::RequestComplete(status,KErrNone);        

    };

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

// Default Constructor - First phase.

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

//

CDRMObsoleteFinder::CDRMObsoleteFinder( RFs& aFs,

                                        CDRMRightsDB* aDatabase,

                                        TRequestStatus& aStatus,

                                        RWriteStream& aStream ) :

    CActive( EPriorityLow ),

    iContents( NULL ),

    iParents( NULL ),

    iNoContents( NULL ),

    iIndex( -1 ),

    iFileServer( aFs ),

    iStream( aStream ),

    iRightsDb( aDatabase ),

    iOperationStatus( aStatus ),

    iState( KScanFileSystem )                         

    {

    }; 

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

// CDRMObsoleteFinder::ConstructL

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

// 

void CDRMObsoleteFinder::ConstructL( const TBool aPerformScan )

    {

    // if the scan needs to be done, the initial state is different:

    if( aPerformScan )

        {

        iState = KScanFileSystem;    

        }

    else

        {

        iState = KScanContents;    

        } 

    // connect to dcf repository

    iDcfClient = CDcfRep::NewL();

    // Create a new list

    iContents = CDRMPointerArray<HBufC8>::NewL();    

    // Create a new list

    iParents = CDRMPointerArray<HBufC8>::NewL();  

    // Create a new list

    iNoContents = CDRMPointerArray<HBufC8>::NewL();  

    };  

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

// CDRMObsoleteFinder::RunError

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

//  

TInt CDRMObsoleteFinder::RunError(TInt aError)

    {

    TRequestStatus* status = 0;

    if( aError != KErrNone )

        {

        status = &iOperationStatus;

        User::RequestComplete( status, aError );                

        delete this;            

        }

    return KErrNone;

    };

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

// CDRMObsoleteFinder::RunL

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

//      

void CDRMObsoleteFinder::RunL()

    {

    TRequestStatus* status = 0;    

    TInt error = KErrNone;

    HBufC8* buffer = NULL;

    // If the status of the cleaning is other than KErrNone

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

    switch( iState )

        {

        case KScanFileSystem:

            iState = KScanContents;

            iDcfClient->RefreshDcf( iStatus );            

            SetActive();    

            break;

        case KScanContents:

            if( iIndex == -1 )

                {

                // Get the contents

                iRightsDb->GetContentIDListL( *iContents );

                // Reset the index

                iIndex = 0;  

                }

            else 

                {

                iIndex++;                     

                }  

            if( iIndex >= iContents->Count() )

                {

                iState = KRemoveUsedParents;

                iIndex = -1;   

                }

            else 

                {

                // Check if there is content

                TRAP( error, iDcfClient->OrderListL( *(*iContents)[iIndex] ));

                // If an error occurs, leave if it's ok, continue

                if( error != KErrNotFound )

                    {

                    User::LeaveIfError( error ); 

                    // Get all the parents

                    if( !error ) 

                        {

                        GetParentsL( *(*iContents)[iIndex], *iParents );   

                        }                      

                    }

                // If the error is not found, add to the no content list    

                else

                    {

                    buffer = (*iContents)[iIndex]->AllocLC();

                    iNoContents->AppendL( buffer );

                    CleanupStack::Pop();    

                    }                       

                }

            SetActive();

            status = &iStatus;

            User::RequestComplete(status,KErrNone);              

            break;

        case KRemoveUsedParents:

            if( iIndex == -1 )

                {

                iIndex = 0;  

                }

            else 

                {

                iIndex++;                     

                }

            if( iIndex >= iParents->Count() )

                {

                iState = KWriteTempFile;

                iIndex = -1; 

                }

            else

                {

                // Find the parent

                error = iNoContents->FindInOrder( (*iParents)[iIndex], 

                                       TLinearOrder<HBufC8>(CompareHBufC8));

                if( error != KErrNotFound )

                    {

                    buffer = (*iNoContents)[error];

                    iNoContents->Remove( error );

                    delete buffer;

                    buffer = 0;    

                    }                                                           

                }

            SetActive();

            status = &iStatus;

            User::RequestComplete(status,KErrNone);                 

            break;

        case KWriteTempFile:

            ObsoleteToStreamL();

            // we are complete:

            status = &iOperationStatus;

            User::RequestComplete( status, KErrNone );                

            delete this; 

            return;                          

        default:

            // illegal status, return error and delete object

            status = &iOperationStatus;

            User::RequestComplete( status, KErrGeneral );

            delete this; 

            return;                       

        }

    };    

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

// CDRMObsoleteFinder::GetParentsL

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

//

void CDRMObsoleteFinder::GetParentsL( const TDesC8& aContentId,

                                      RPointerArray<HBufC8>& aParents )

    {

    HBufC8* parentId = NULL;

    TInt error = KErrNone;

    CDRMPointerArray<CDRMPermission>* permissions = 

      CDRMPointerArray<CDRMPermission>::NewLC();

    permissions->SetAutoCleanup( ETrue );

    CDRMPointerArray<CDRMPermission>& perm = *permissions;  

    TRAP( error, iRightsDb->GetDBEntryByContentIDL( aContentId, *permissions ) );

    // If there are no keys it means that there is encryption key and such, but

    // no available permissions

    if( error == KErrCANoRights )

        {

        CleanupStack::PopAndDestroy(); // permissions

        return;    

        }

    else 

        {

        User::LeaveIfError(error);    

        }

    for( TInt i = 0; i < permissions->Count(); i++, error = KErrNone )

        {

        // Check if the permission has a parent

        if( perm[i]->iParentUID ) 

            {

            // if it does, insert it to the aParents array

            error = aParents.FindInOrder( perm[i]->iParentUID, 

                                          TLinearOrder<HBufC8>(CompareHBufC8));

            if( error == KErrNotFound )

                {

                parentId = perm[i]->iParentUID->AllocLC();

                User::LeaveIfError( aParents.InsertInOrder(parentId, 

                                    TLinearOrder<HBufC8>(CompareHBufC8)) );

                CleanupStack::Pop();       

                }

            }

        }

    CleanupStack::PopAndDestroy(); // permissions     

    }; 

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

// CDRMObsoleteFinder::ObsoleteToStreamL

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

//

void CDRMObsoleteFinder::ObsoleteToStreamL()

    {

    TInt count( 0 );

    TInt size( 4 ); // size of the count

    for( count = 0; count < iNoContents->Count(); count++ )

        {

        size += (*iNoContents)[ count ]->Size();

        size += sizeof(TUint16);

        }

    // Reset count variable:

    count = 0;

#ifndef RD_MULTIPLE_DRIVE

    if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFileServer, 

                                                size, 

                                                EDriveC ) )

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

    if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFileServer, 

                                                size, 

                                                driveNumber ) )

#endif

        {

        DRMLOG( _L( "CDRMDbSession::UriListToFileL: KErrDiskFull" ) );

        User::Leave( KErrDiskFull );

        }     

    // Write the whole stuff into the file.

    while( count < iNoContents->Count() )

        {

        iStream.WriteUint16L( (*iNoContents)[count]->Length() );

        iStream.WriteL( *(*iNoContents)[count] );

        ++count;

        }

    // Finish with a 0    

    iStream.WriteUint16L( 0 );    

    iStream.CommitL();

    }

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

// CDRMObsoleteFinder::DoCancel

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

//      

void CDRMObsoleteFinder::DoCancel()

    {  

    }; 

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

// CDRMObsoleteFinder::DoCleanup

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

//      

void CDRMObsoleteFinder::DoCleanup()

    {

    TRequestStatus* status = 0;      

    if( iCancel <= 0 )

        {

        iCancel = 1;

        status = &iStatus;

        User::RequestComplete(status, KErrCancel);

        }       

    };