/*
* Copyright (c) 2006 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:  Wraps task scheduler functionality
*
*/



// INCLUDE FILES
#include <apacmdln.h>
#include <FileManagerSchDefinitions.h>
#include <FileManagerDebug.h>
#include <CFileManagerEngine.h>
#include <CFileManagerBackupSettings.h>
#include <FileManagerPrivateCRKeys.h>
#include "CFileManagerTaskScheduler.h"


// CONSTANTS
const TInt KSchedulerPriority = 32;
const TInt KSchedulerGranularity = 1;
const TInt KSchedulerRepeat = -1; // Repeat until deleted
const TInt KSchedulerTaskId = 0;
const TInt KDayNumStringLen = 4;
const TInt KTaskInterval = 1;
const TInt KTaskValidity = 1;
_LIT( KDayNumStr, "%d" );


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

// ----------------------------------------------------------------------------
// CFileManagerTaskScheduler::CFileManagerTaskScheduler
// ----------------------------------------------------------------------------
//
CFileManagerTaskScheduler::CFileManagerTaskScheduler(
        CFileManagerEngine& aEngine ) :
    iEngine( aEngine ),
    iScheduleHandle( KErrNotFound )
    {
    }

// ----------------------------------------------------------------------------
// CFileManagerTaskScheduler::NewL
// ----------------------------------------------------------------------------
//
CFileManagerTaskScheduler* CFileManagerTaskScheduler::NewL(
        CFileManagerEngine& aEngine )
    {
    CFileManagerTaskScheduler* self =
        new( ELeave ) CFileManagerTaskScheduler( aEngine );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CFileManagerTaskScheduler::ConstructL
// ----------------------------------------------------------------------------
// 
void CFileManagerTaskScheduler::ConstructL()
    {
    FUNC_LOG

    User::LeaveIfError( iScheduler.Connect() );
    TFileName name( KSchBackupStarterExe );
    User::LeaveIfError( iScheduler.Register( name, KSchedulerPriority ) );

    // Try to get schedule handle of previously made schedule
    CArrayFixFlat< TSchedulerItemRef >* array = 
        new( ELeave ) CArrayFixFlat< TSchedulerItemRef >(
            KSchedulerGranularity );
    CleanupStack::PushL( array );
    if ( iScheduler.GetScheduleRefsL( *array, EAllSchedules ) == KErrNone )
        {
        if ( array->Count() )
            {
            iScheduleHandle = array->At( 0 ).iHandle;
            }
        }
    CleanupStack::PopAndDestroy( array );
    }

// ----------------------------------------------------------------------------
// CFileManagerTaskScheduler::~CFileManagerTaskScheduler
// ----------------------------------------------------------------------------
// 
CFileManagerTaskScheduler::~CFileManagerTaskScheduler()
    {
    FUNC_LOG
    
    iScheduler.Close();
    }

// ----------------------------------------------------------------------------
// CFileManagerTaskScheduler::CreateScheduleL
// ----------------------------------------------------------------------------
// 
void CFileManagerTaskScheduler::CreateScheduleL()
    {
    FUNC_LOG

    CFileManagerBackupSettings& settings( iEngine.BackupSettingsL() );

    // Create schedule entry and store schedule handle for later use
    CArrayFixFlat< TScheduleEntryInfo2 >* array =
        new ( ELeave ) CArrayFixFlat<
            TScheduleEntryInfo2 >( KSchedulerGranularity );
    CleanupStack::PushL( array );

    TTsTime tsTime( settings.Time(), EFalse );
    TScheduleEntryInfo2 entry(
        tsTime, EDaily, KTaskInterval, KTaskValidity );
    array->AppendL( entry );

    TSchedulerItemRef ref;
    User::LeaveIfError( iScheduler.CreatePersistentSchedule( ref, *array ) );
    CleanupStack::PopAndDestroy( array );
    iScheduleHandle = ref.iHandle;

    // Add weekday to task data if weekly backup
    HBufC* data = HBufC::NewLC( KDayNumStringLen );
    if ( settings.Scheduling() == EFileManagerBackupScheduleWeekly )
        {
        TPtr ptr( data->Des() );
        ptr.Format( KDayNumStr, settings.Day() );
        }

    // Create scheduled task entry and enable it
    TTaskInfo taskInfo;
    taskInfo.iName = KSchBackupTaskName;
    taskInfo.iPriority = KSchedulerPriority;
    taskInfo.iTaskId = KSchedulerTaskId;
    taskInfo.iRepeat = KSchedulerRepeat;
    User::LeaveIfError( iScheduler.ScheduleTask(
        taskInfo, *data, iScheduleHandle ) );
    CleanupStack::PopAndDestroy( data );
    User::LeaveIfError( iScheduler.EnableSchedule( iScheduleHandle ) );
    }

// ----------------------------------------------------------------------------
// CFileManagerTaskScheduler::DeleteScheduleL
// ----------------------------------------------------------------------------
// 
void CFileManagerTaskScheduler::DeleteScheduleL()
    {
    if ( iScheduleHandle != KErrNotFound )
        {
        INFO_LOG( "CFileManagerTaskScheduler::DeleteScheduleL-Delete" )
        iScheduler.DisableSchedule( iScheduleHandle );
        iScheduler.DeleteTask( KSchedulerTaskId );
        iScheduler.DeleteSchedule( iScheduleHandle );
        iScheduleHandle = KErrNotFound;
        }
    }

// ----------------------------------------------------------------------------
// CFileManagerTaskScheduler::EnableBackupScheduleL
// ----------------------------------------------------------------------------
// 
void CFileManagerTaskScheduler::EnableBackupScheduleL( const TBool aEnable )
    {
    // Delete old schedule first
    DeleteScheduleL();

    if ( aEnable )
        {
        CreateScheduleL();
        }
    }

//  End of File