/*

* 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 <caf/caf.h>

#include "DRMObsoleteFinder.h"

#include "drmlog.h"

#ifdef RD_MULTIPLE_DRIVE

#endif

// EXTERNAL DATA STRUCTURES

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

    {

    };

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

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

// CDRMObsoleteFinder::NewL

// Two-phased constructor.

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

//

CDRMObsoleteFinder* CDRMObsoleteFinder::NewL( RFs& aFs,

                                            CDRMRightsDB* aDatabase,

                                            TRequestStatus& aStatus,

                                            RWriteStream& aStream,

                                            TBool aPerformScan )

    {

                                                        aStream );

    CleanupStack::PushL( self );

    self->ConstructL( aPerformScan );

    CleanupStack::Pop();

    return self;

    }

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

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

//

CDRMObsoleteFinder::~CDRMObsoleteFinder()

    {

    // just in case

    Cancel();

    if( iDcfClient )

        {

        delete iDcfClient;

        }

    if( iContents )

        {

        delete iContents;

        }

    if( iParents )

        {

        delete iParents;

        }

    if( iNoContents )

        {

        delete iNoContents;

    };

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

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

void CDRMObsoleteFinder::ExecuteFinderLD()

    {

    TRequestStatus* status = 0;

        {

        }

        {

        }

    iOperationStatus = KRequestPending;

    status = &iStatus;

    };

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

    {

// CDRMObsoleteFinder::ConstructL

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

void CDRMObsoleteFinder::ConstructL( const TBool aPerformScan )

    {

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

    if( aPerformScan )

        {

        }

    else

        {

    // connect to dcf repository

    iDcfClient = CDcfRep::NewL();

    // Create a new list

    // Create a new list

    // Create a new list

// CDRMObsoleteFinder::RunError

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

TInt CDRMObsoleteFinder::RunError(TInt aError)

    {

    TRequestStatus* status = 0;

    if( aError != KErrNone )

        {

        status = &iOperationStatus;

        }

    return KErrNone;

    };

// CDRMObsoleteFinder::RunL

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

void CDRMObsoleteFinder::RunL()

    {

    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;

            break;

        case KScanContents:

            if( iIndex == -1 )

                {

                // Get the contents

                iRightsDb->GetContentIDListL( *iContents );

                // Reset the index

                }

                {

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

                {

                iState = KRemoveUsedParents;

                }

                {

                // Check if there is content

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

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

                if( error != KErrNotFound )

                    {

                    // Get all the parents

                        {

                    }

                else

                    {

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

                    iNoContents->AppendL( buffer );

                }

            SetActive();

            status = &iStatus;

            break;

        case KRemoveUsedParents:

            if( iIndex == -1 )

                {

                }

                {

                }

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

                {

                iState = KWriteTempFile;

                }

            else

                {

                // Find the parent

                                       TLinearOrder<HBufC8>(CompareHBufC8));

                if( error != KErrNotFound )

                    {

                    buffer = (*iNoContents)[error];

                    iNoContents->Remove( error );

                    delete buffer;

                }

            SetActive();

            status = &iStatus;

            break;

        case KWriteTempFile:

            ObsoleteToStreamL();

            // we are complete:

            status = &iOperationStatus;

        default:

            // illegal status, return error and delete object

            status = &iOperationStatus;

            User::RequestComplete( status, KErrGeneral );

        }

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

// CDRMObsoleteFinder::GetParentsL

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

//

void CDRMObsoleteFinder::GetParentsL( const TDesC8& aContentId,

                                      RPointerArray<HBufC8>& aParents )

    {

    HBufC8* parentId = NULL;

    TInt error = KErrNone;

      CDRMPointerArray<CDRMPermission>::NewLC();

    permissions->SetAutoCleanup( ETrue );

    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

        }

        {

        }

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

        {

        // Check if the permission has a parent

            {

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

                                          TLinearOrder<HBufC8>(CompareHBufC8));

            if( error == KErrNotFound )

                {

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

                                    TLinearOrder<HBufC8>(CompareHBufC8)) );

                }

            }

        }

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

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

                                                EDriveC ) )

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

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

                                                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;

        }

    iStream.CommitL();

    }

// CDRMObsoleteFinder::DoCancel

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

void CDRMObsoleteFinder::DoCancel()

// CDRMObsoleteFinder::DoCleanup

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

void CDRMObsoleteFinder::DoCleanup()

    {

    if( iCancel <= 0 )

        {

        iCancel = 1;

        status = &iStatus;

        User::RequestComplete(status, KErrCancel);