/*

* Copyright (c) 2002 - 2007 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:  Handling end time based automated content

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    <e32std.h>

#include    <s32file.h>

#include    "DRMHelperServer.h"

#include    "EndTimeFactory.h"

#include    "EndTimeBased.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

LOCAL_C const TInt KInformingDelay( 1 );

// Maximum amount of times the expired item is handled before 

// unregistering without client's call.

// (In order to avoid stale registrations)

LOCAL_C const TInt KMaxHandlingCount( 50 );

// MACROS

// LOCAL CONSTANTS AND MACROS

#ifdef _DRM_TESTING

LOCAL_C void WriteFileL( const TDesC8& text , RFs &aFs , const TDesC& aName )

    {

    RFile file;

    TInt size;

    User::LeaveIfError( file.Open( aFs, aName , EFileWrite ) );

    CleanupClosePushL( file );

    User::LeaveIfError( file.Size( size ) );

    User::LeaveIfError( file.Write( size, text ) );

    CleanupStack::PopAndDestroy(&file); //file

    }

LOCAL_C void WriteLogL( const TDesC8& text , RFs &aFs )

    {

    _LIT( KLogFile , "c:\\ETFLog.txt" );

    WriteFileL( text , aFs , KLogFile );

    }

LOCAL_C void CreateLogL()

    {

    RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    RFile file;

    User::LeaveIfError( file.Replace( fs , _L("c:\\ETFLog.txt") , EFileWrite ) );

    file.Close();

    CleanupStack::PopAndDestroy(&fs); //fs

    }

LOCAL_C void WriteL( const TDesC& aText )

    {

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL(fs);

    HBufC8* text = HBufC8::NewLC(1000);

    TPtr8 textptr(text->Des() );

    textptr.Append( aText );

    textptr.Append(_L( "\r\n" ));

    WriteLogL(textptr , fs);

    CleanupStack::PopAndDestroy(text);

    CleanupStack::PopAndDestroy(&fs); //fs

    }

LOCAL_C void WriteL( const TDesC8& aText )

    {

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL(fs);

    HBufC8* text = HBufC8::NewLC(1000);

    TPtr8 textptr(text->Des() );

    textptr.Append( aText );

    textptr.Append(_L8( "\r\n" ));

    WriteLogL(textptr , fs);

    CleanupStack::PopAndDestroy(text);

    CleanupStack::PopAndDestroy(&fs); //fs

    }

LOCAL_C void WriteTimeL( TTime aTime )

    {

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL(fs);

    HBufC8* text = HBufC8::NewLC(100);

    TPtr8 textptr(text->Des() );

    // Date and Time display

    TBuf<256> dateString;

    _LIT(KDate,"%*E%*D%X%*N%*Y %1 %2 '%3");

    aTime.FormatL(dateString,KDate);

    textptr.Append(_L( "\r\n\t\t\t\tData:\t" ) );

    textptr.Append( dateString );

    _LIT(KTime,"%-B%:0%J%:1%T%:2%S%:3%+B");

    aTime.FormatL(dateString,KTime);

    textptr.Append(_L( "\r\n\t\t\t\tTime:\t" ) );

    textptr.Append( dateString );

    textptr.Append(_L( "\r\n" ) );

    textptr.Append(_L( "\r\n" ) );

    WriteLogL(textptr , fs);

    CleanupStack::PopAndDestroy(text);

    CleanupStack::PopAndDestroy(&fs); //fs

    }

LOCAL_C void WriteCurrentTimeL()

    {

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL(fs);

    HBufC8* text = HBufC8::NewLC(100);

    TPtr8 textptr(text->Des() );

    // Date and Time display

    TTime time;

    time.HomeTime();

    TBuf<256> dateString;

    _LIT(KDate,"%*E%*D%X%*N%*Y %1 %2 '%3");

    time.FormatL(dateString,KDate);

    textptr.Append(_L( "\r\n\t\tData:\t" ) );

    textptr.Append( dateString );

    _LIT(KTime,"%-B%:0%J%:1%T%:2%S%:3%+B");

    time.FormatL(dateString,KTime);

    textptr.Append(_L( "\r\n\t\tTime:\t" ) );

    textptr.Append( dateString );

    textptr.Append(_L( "\r\n" ) );

    textptr.Append(_L( "\r\n" ) );

    WriteLogL(textptr , fs);

    CleanupStack::PopAndDestroy(text);

    CleanupStack::PopAndDestroy(&fs); //fs

    }

#endif

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CEndTimeFactory::CEndTimeFactory

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CEndTimeFactory::CEndTimeFactory( CDRMHelperServer& aServer ):

    CTimer(CActive::EPriorityStandard),

    iServer( aServer ),

    iOverflowedAlarm( Time::MaxTTime() )

    {

    iAlarm.HomeTime();

    }

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

// CEndTimeFactory::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CEndTimeFactory::ConstructL()

    {

#ifdef _DRM_TESTING

    CreateLogL(); //test

#endif

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

    }

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

// CEndTimeFactory::NewL

// Two-phased constructor.

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

//

CEndTimeFactory* CEndTimeFactory::NewL(CDRMHelperServer& aServer)

    {

    CEndTimeFactory* self = new( ELeave ) CEndTimeFactory(aServer);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CEndTimeFactory::~CEndTimeFactory()

    {

#ifdef _DRM_TESTING

    TRAPD( err , WriteL(_L("CEndTimeFactory-Destruct")) );

    TRAP( err , WriteCurrentTimeL() );

#endif

    iList.ResetAndDestroy();

    iList.Close();

    Cancel();

    }

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

// CEndTimeFactory::AddL

// add a specific content uri into factory

// (other items were commented in a header).

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

//

void CEndTimeFactory::AddL(

        const TDesC8& aUri ,

        TTime aEndTime ,

        const TUint8& aPermType ,

        const TUint8& aRegType ,

        const TUint8& aAutoType )

    {

#ifdef _DRM_TESTING

    WriteL(_L("Add"));

    WriteL(aUri);

    WriteCurrentTimeL();

#endif

    CEndTimeBased* newItem = NULL;

    TTime home;

    TInt index = 0;

    // check if uri is already in the list

    index = Find( aUri , aPermType , aRegType , aAutoType );

    if ( index >= 0 )

        {

        // if it is in the list then just update the end time.

        iList[index]->IncreaseRegTimes();

        UpdateEndTimeL( iList[index] , aEndTime );

        return;

        }

    // if not in the list then create one

    newItem = CEndTimeBased::NewL( aUri , aPermType , aRegType , aAutoType );

    CleanupStack::PushL(newItem);

    // set end time

    newItem->SetEndTime(aEndTime);

    // set expiration

    home.HomeTime();

    if ( home >= aEndTime )

        {

        newItem->SetIsExpired(ETrue);

        }

    // add the item into list

    User::LeaveIfError( iList.Append( newItem ) );

    CleanupStack::Pop(newItem);

    // change alarm time if necessary

    if ( home >= iAlarm && !newItem->IsExpired() )

        {

#ifdef _DRM_TESTING

        //test code start

        WriteL(_L("Add->Change iAlarm-><home"));

        WriteL(aUri);

        WriteCurrentTimeL();

        WriteL(_L("Change Time"));

        WriteTimeL(aEndTime);

        //test code end

#endif

        iAlarm = aEndTime;

        }

    if ( !newItem->IsExpired() && iAlarm >= aEndTime && iAlarm != Time::MaxTTime() )

        {

        iAlarm = aEndTime;

        Cancel();

#ifdef _DRM_TESTING

        //test code start

        WriteL(_L("Add->Change iAlarm->>Change Time"));

        WriteL(aUri);

        WriteCurrentTimeL();

        WriteL(_L("Change Time"));

        WriteTimeL(iAlarm);

        WriteL(_L("Add->Trigger iAlarm"));

        WriteL(aUri);

        WriteL(_L("Trigger Time"));

        WriteTimeL(iAlarm);

        //test code end

#endif

        CTimer::At(iAlarm+TTimeIntervalSeconds(KInformingDelay));

        }

    }

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

// CEndTimeFactory::UpdateL

// update a specific content uri in the list

// (other items were commented in a header).

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

//

void CEndTimeFactory::UpdateL()

    {

#ifdef _DRM_TESTING

    WriteL(_L("UpdateL(all)"));

    WriteCurrentTimeL();

#endif

    for( TInt i( 0 ); i < iList.Count(); i++ )

        {

        const CEndTimeBased* e( iList[i] );

        iServer.UpdateL(

                *e->Uri(), e->PermType(), e->RegType(), e->AutoType() );

        if ( e->Count() > KMaxHandlingCount )

            {

            // Client must have forgotten to unregister item properly.

            // So let's unregister now.

            Remove( *e->Uri(), e->PermType(), e->RegType(), e->AutoType() );

            }

        }

    }

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

// CEndTimeFactory::UpdateEndTimeL

// update the end time of a specific content uri in the list

// (other items were commented in a header).

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

//

void CEndTimeFactory::UpdateEndTimeL(

        const TDesC8& aUri ,

        const TTime& aEndTime ,

        const TUint8& aPermType ,

        const TUint8& aRegType

        )

    {

#ifdef _DRM_TESTING

    WriteL(_L("UpdateEndTimeL(uri,endtime,perm,reg)"));

    WriteL(aUri);

    WriteCurrentTimeL();

#endif

    TInt index = 0;

    index = FindNext(aUri,aPermType,aRegType,index);

    while ( index >= 0 )

        {

        UpdateEndTimeL( iList[index] , aEndTime );

        index++;

        index = FindNext(aUri,aPermType,aRegType,index);

        }

    }

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

// CEndTimeFactory::UpdateEndTimeL

// update the end time of a specific content uri in the list

// (other items were commented in a header).

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

//

void CEndTimeFactory::UpdateEndTimeL(

        const TDesC8& aUri ,

        const TTime& aEndTime ,

        const TUint8& aPermType ,

        const TUint8& aRegType ,

        const TUint8& aAutoType

        )

    {

#ifdef _DRM_TESTING

    WriteL(_L("UpdateEndTimeL(uri,endtime,perm,reg,autotype)"));

    WriteL(aUri);

    WriteCurrentTimeL();

#endif

    TInt index = 0;

    index = Find(aUri,aPermType,aRegType,aAutoType);

    if ( index >= 0 )

        {

        UpdateEndTimeL( iList[index] , aEndTime );

        }

    }

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

// CEndTimeFactory::UpdateEndTimeL

// update the end time of a specific content uri in the list

// (other items were commented in a header).

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

//

void CEndTimeFactory::UpdateEndTimeL( CEndTimeBased*& aItem , const TTime& aEndTime )

    {

#ifdef _DRM_TESTING

    WriteL(_L("UpdateEndTimeL(item,endtime)"));

    WriteL(aItem->Uri()->Des());

    WriteCurrentTimeL();

#endif

    aItem->SetEndTime(aEndTime);

    ResetAlarm();

    }

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

// CEndTimeFactory::IsRegisteredL

// check if content uri is registered into list or not

// (other items were commented in a header).

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

//

TBool CEndTimeFactory::IsRegistered(

        const TDesC8& aUri ,

        const TUint8& aPermType ,

        const TUint8& aRegType ,

        const TUint8& aAutoType )

    {

#ifdef _DRM_TESTING

    TRAPD( err , WriteL(_L("IsRegisteredL(aUri,aPermType,aRegType,aAutoType)")) );

    TRAP( err , WriteL(aUri) );

    TRAP( err , WriteCurrentTimeL() );

#endif

    // check if it is in the list

    if ( Find( aUri , aPermType , aRegType , aAutoType ) >= 0 )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CEndTimeFactory::IsRegisteredL

// check if content uri is registered into list or not

// (other items were commented in a header).

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

//

TBool CEndTimeFactory::IsRegistered(

        const TDesC8& aUri ,

        const TUint8& aPermType ,

        const TUint8& aRegType )

    {

#ifdef _DRM_TESTING

    TRAPD( err , WriteL(_L("IsRegisteredL(aUri,aPermType,aRegType)")) );

    TRAP( err , WriteL(aUri) );

    TRAP( err , WriteCurrentTimeL() );

#endif

    // check if it is in the list

    TInt index = 0;

    if ( FindNext( aUri , aPermType , aRegType , index ) >= 0 )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CEndTimeFactory::IsRegisteredL

// check if content uri is registered into list or not

// (other items were commented in a header).

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

//

TBool CEndTimeFactory::IsRegistered2(

        const TDesC8& aUri ,

        const TUint8& aRegType,

        const TUint8& aAutoType )

    {

#ifdef _DRM_TESTING

    TRAPD( err , WriteL(_L("IsRegisteredL(aUri,aRegType)")) );

    TRAP( err , WriteL(aUri) );

    TRAP( err , WriteCurrentTimeL() );

#endif

    // check if it is in the list

    if ( Exists( aUri, aRegType, aAutoType) >= 0 )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CEndTimeFactory::IsRegisteredL

// check if content uri is registered into list or not

// (other items were commented in a header).

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

//

TBool CEndTimeFactory::IsRegistered( const TDesC8& aUri )

    {

#ifdef _DRM_TESTING

    TRAPD( err , WriteL(_L("IsRegisteredL(aUri)")) );

    TRAP( err , WriteL(aUri) );

    TRAP( err , WriteCurrentTimeL() );

#endif

    // check if it is in the list

    TInt index = 0;

    if ( FindNext( aUri , index ) >= 0 )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CEndTimeFactory::Remove

// Remove a specific content uri from factory

// (other items were commented in a header).

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

//

void CEndTimeFactory::Remove(

        const TDesC8& aUri ,

        const TUint8& aPermType ,

        const TUint8& aRegType ,

        const TUint8& aAutoType )

    {

#ifdef _DRM_TESTING

    TRAPD( err , WriteL(_L("Remove")) );

    TRAP( err , WriteL(aUri) );

    TRAP( err , WriteCurrentTimeL() );

#endif