/*

* Copyright (c) 2004-2009 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 Helper Server functionality

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <s32file.h>

#include <DRMNotifier.h>

#include <DRMEventAddRemove.h>

#include <DRMTypes.h>

#include <bacntf.h> //CEnvironmentChangeNotifier

#include <centralrepository.h> // link against centralrepository.lib

#ifdef RD_MULTIPLE_DRIVE

#endif

#include "DRMEventModify.h"

#include "DRMHelperServerInternalCRKeys.h"

#include "DRMHelperCommon.h"

#include "DRMHelperServer.h"

#include "DRMHelperSession.h"

#include "EndTimeFactory.h"

#include "EndTimeBased.h"

#include "IdleObserver.h"

// LOCAL CONSTANTS AND MACROS

_LIT8(KExpiredMark , "E");

#ifdef RD_MULTIPLE_DRIVE

_LIT( KHelperServerDataStorage , "%c:DRMHS.dat" );

#else

_LIT( KHelperServerDataStorage , "c:DRMHS.dat" );

#endif

// #define _MEM_HEAP_USAGE

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

#ifdef _DRM_TESTING

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

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

LOCAL_C void CreateLogL();

LOCAL_C void WriteL( const TDesC8& aText );

LOCAL_C void WriteTimeL( TTime aTime );

LOCAL_C void WriteCurrentTimeL();

LOCAL_C void WriteL( const TDesC8& aText , TInt aErr );

#ifdef _MEM_HEAP_USAGE

LOCAL_C void WriteHeapAllocL();

#endif //_MEM_HEAP_USAGE

#endif

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

// Testing stuff

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

//

#ifdef _DRM_TESTING

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

    {

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

    WriteFileL( text , aFs , KLogFile );

    }

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 CreateLogL()

    {

    RFs fs;

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

    CleanupClosePushL(fs);

    RFile file;

    TInt err = file.Open( fs , _L("c:\\HSLog.txt") , EFileWrite );

    if (err)

        {

        err = file.Replace( fs , _L("c:\\HSLog.txt") , EFileWrite );

        }

    file.Close();

    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

    WriteCurrentTimeL();

#ifdef _MEM_HEAP_USAGE

    WriteHeapAllocL();

#endif //_MEM_HEAP_USAGE

    }

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

    }

LOCAL_C void WriteL( const TDesC8& aText , TInt aErr )

    {

    _LIT8(KErr,": %d");

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

    TBuf8<20> num;

    TPtr8 textptr(text->Des());

    textptr.Append(aText);

    num.Format(KErr(),aErr);

    textptr.Append(num);

    WriteL(textptr);

    CleanupStack::PopAndDestroy(text);

#ifdef _MEM_HEAP_USAGE

    WriteHeapAllocL();

#endif //_MEM_HEAP_USAGE

    }

#ifdef _MEM_HEAP_USAGE

LOCAL_C void WriteHeapAllocL()

    {

    _LIT8(KHeapUsage,"\r\n***** Heap cells allocated: %d *****\r\n");

    TBuf8<256> string;

    TInt size = 0;

    RFs fs;

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

    CleanupClosePushL(fs);

    User::Heap().AllocSize(size);

    string.Format(KHeapUsage(),size);

    WriteLogL(string , fs);

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

    }

#endif //_MEM_HEAP_USAGE

#endif //_DRM_TESTING

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

// DataFileL

// return data filename as a TParse

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

//

LOCAL_C TParse DataFileL(RFs& aFs)

    {

    TBuf<256> path;

    TParse p;

    User::LeaveIfError(aFs.PrivatePath(path));

#ifndef RD_MULTIPLE_DRIVE

    p.Set(KHelperServerDataStorage,&path,NULL);

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

    TChar driveLetter;

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

    aFs.DriveToChar( driveNumber, driveLetter );

    TFileName helperServerDataStorage;

    helperServerDataStorage.Format(

                    KHelperServerDataStorage, (TUint)driveLetter );

    p.Set( helperServerDataStorage, &path, NULL );

#endif

    return p;

    }

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

// CreatePrivatePathL

// Create private path

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

//

LOCAL_C void CreatePrivatePathL(RFs& aFs)

    {

#ifdef _DRM_TESTING

    TRAPD( r , WriteL(_L8("CreatePrivatePathL")) );

#endif

#ifndef RD_MULTIPLE_DRIVE

    TInt err = aFs.CreatePrivatePath(EDriveC);

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

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

    TInt err = aFs.CreatePrivatePath(driveNumber);

#endif

    if (err == KErrAlreadyExists)

        {

        err = KErrNone;

        }

    User::LeaveIfError(err);

#ifdef _DRM_TESTING

    TRAP( r , WriteL(_L8("CreatePrivatePathL->End")) );

#endif

    return;

    }

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

// CreateCRKeyL

// Create CenRep Key

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

//

LOCAL_C void CreateCRKeyL()

    {

#ifdef _DRM_TESTING

    TRAPD( r , WriteL(_L8("CreateCRKeyL")) );

#endif

  CRepository* repository = CRepository::NewL(KCRUidDRMHelperServer);

    CleanupStack::PushL( repository );

    TInt err = repository->Create(KDRMHelperServerNotification, KNullDesC8);

    if (err == KErrAlreadyExists)

        {

        err = KErrNone;

        }

#ifdef _DRM_TESTING

    TRAP( r , WriteL(_L8("CreateCRKeyL->Create1"),err) );

#endif

    User::LeaveIfError(err);

    err = repository->Create(KDRMHelperServerNotificationPassive, KNullDesC8);

    if (err == KErrAlreadyExists)

        {

        err = KErrNone;

        }

#ifdef _DRM_TESTING

    TRAP( r , WriteL(_L8("CreateCRKeyL->Create2"),err) );

#endif

    User::LeaveIfError(err);

    CleanupStack::PopAndDestroy(repository); // repository

#ifdef _DRM_TESTING

    TRAP( r , WriteL(_L8("CreateCRKeyL->End")) );

#endif

    }

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

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

// CDRMHelperServer::CDRMHelperServer

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

// might leave.

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

//

CDRMHelperServer::CDRMHelperServer() :

    CServer2( EPriorityStandard ) ,

                    iEndTimeFactory(NULL) ,

                    iNotifier(NULL),

                    iIdleObserver(NULL) ,

                    iUiTimeNotifier(NULL)

    {

    // Nothing

    }

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

// CDRMHelperServer::NewLC

// Two-phased constructor.

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

//

CDRMHelperServer* CDRMHelperServer::NewLC()

    {

#ifdef _DRM_TESTING

    CreateLogL();

    TRAPD( err , WriteL(_L8("NewLC")) );

#endif

    CDRMHelperServer* self = new(ELeave) CDRMHelperServer;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    };

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

// CDRMHelperServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDRMHelperServer::ConstructL()

    {

    TInt err = 0;

#ifdef _DRM_TESTING

    TRAPD( r , WriteL(_L8("ConstructL")) );

#endif

    TUint8 waitCount = 0;

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

    User::LeaveIfError(iDrm.StartServer());

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

    StartL(KDRMHelperServerName);

    //ignore errors

    err = User::RenameProcess( KDRMHSServerFileName );

    err = User::RenameThread(KDRMHSServerFileName);

    CreatePrivatePathL(iFs); // create path for internal data file

    iEndTimeFactory = CEndTimeFactory::NewL( *this );

    err = KErrNotFound;

    while( err!=0 && waitCount < 30 ) // wait maximum of 6s

        {

        TRAP( err , iNotifier = CDRMNotifier::NewL() );

        if ( err ) // wait only if the server isn't running

            {

            User::After(200000); // 0.2s

            waitCount++;

            }

        if (iNotifier)

            {

            iNotifier->RegisterEventObserverL( *this , KEventTimeChange );

            }

        }

#ifdef _DRM_TESTING

    TRAP( r , WriteL(_L8("ConstructL->Notifier")) );

#endif

    User::LeaveIfError( err ); // None can do, throw an exception.

    iUiTimeNotifier = CEnvironmentChangeNotifier::NewL(

        EPriorityHigh,

        TCallBack(UiTimeChanged,this)

        );

    iUiTimeNotifier->Start();

    iIdleObserver = CIdleObserver::NewL( *this );

    iIdleObserver->StartL();

#ifdef _DRM_TESTING

    TRAP( r , WriteL(_L8("ConstructL->IdleObserver")) );

#endif

    CreateCRKeyL();

    RestoreL();

    iEndTimeFactory->HandleExpiredL();

#ifdef _DRM_TESTING

    TRAP( r , WriteL(_L8("ConstructL->End")) );

#endif

    }

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

// CDRMHelperServer::~CDRMHelperServer

// Destructor.

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

//

CDRMHelperServer::~CDRMHelperServer()

    {

#ifdef _DRM_TESTING

    TRAPD( err , WriteL(_L8("destructor")) );

#endif

    if ( iEndTimeFactory )

        {

        TRAPD( error , StoreL() );

        TRAP( error , RemoveAllL() );

        }

    delete iEndTimeFactory;

    if (iNotifier)

        {

        TRAP_IGNORE( iNotifier->UnRegisterEventObserverL( *this , KEventTimeChange ) );

        }

    delete iNotifier;

    if(iUiTimeNotifier)

        {

        iUiTimeNotifier->Cancel();

        delete iUiTimeNotifier;

        }

    delete iIdleObserver;

    iFs.Close();

    iDrm.Close();

    }

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

// CDRMHelperServer::NewSessionL

// Called when a client requires a new instance.

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

CSession2* CDRMHelperServer::NewSessionL(const TVersion &aVersion,

                                         const RMessage2& /*aMessage*/ ) const

    {

    // check we're the right version

    if (!User::QueryVersionSupported(TVersion(KDRMHSMajorVersionNumber,

                                              KDRMHSMinorVersionNumber,

                                              KDRMHSBuildVersionNumber),

                                     aVersion))

        {

        User::Leave(KErrNotSupported);

        }

    // make new session

    return CDRMHelperSession::NewL();

    }

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

// CDRMHelperServer::StartupL().

// This function starts the actual DRM Helper server after initializing

// the cleanup stack and active scheduler.

// Returns: TInt: Symbian OS error code.

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

//

void CDRMHelperServer::StartupL()

    {

    // Construct active scheduler

    CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;

    CleanupStack::PushL(activeScheduler) ;

    // Install active scheduler

    // We don't need to check whether an active scheduler is already installed

    // as this is a new thread, so there won't be one

    CActiveScheduler::Install(activeScheduler);

    // Construct our server

    CDRMHelperServer::NewLC();

    RSemaphore semaphore;

    User::LeaveIfError(semaphore.OpenGlobal(KDRMHelperServerSemaphoreName));

    // Semaphore opened ok

    semaphore.Signal();

    semaphore.Close();

    // Start handling requests

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy(2, activeScheduler);    //  anonymous CDRMHelperServer

    }

void CDRMHelperServer::PanicServer(TDRMHelperServPanic aPanic)

    {

    User::Panic(KDRMHSServer, aPanic);

    }

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

// CDRMHelperServer::Startup().

// This function starts the actual DRM Rights server after initializing