/*

* Copyright (c) 2006-2008 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:  Handles file manager scheduled backup task start

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <schtask.h>

#include <w32std.h>

#include <apgtask.h>

#include <apgcli.h>

#include <apgwgnam.h>

#include <apacmdln.h>

#include <centralrepository.h>

#include <ctsydomainpskeys.h>

#include <UsbWatcherInternalPSKeys.h>

#include <usbpersonalityids.h>

#include <DataSyncInternalPSKeys.h>

#include <connect/sbdefs.h>

#include "filemanagerschbackuptask.h"

#include "filemanagerschsubscriber.h"

#include "FileManagerUID.h"

#include "FileManagerDebug.h"

#include "FileManagerSchDefinitions.h"

#include "FileManagerPrivateCRKeys.h"

using namespace conn;

// CONSTANTS

const TUid KUidFileManager = { KFileManagerUID3 };

_LIT_SECURE_ID( KFileManagerSID, KFileManagerUID3 );

const TInt KStartStateChangeTimeoutSecs = 30;

const TInt KPhoneStateChangeTimeoutSecs = 120;

const TInt KNumAttempts = -1; // Try forever

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

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

// FindStandaloneAppL

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

//

static TBool FindStandaloneAppL(

        RWsSession& aWs, const TUid& aUid, TInt& aWgId )

    {

    FUNC_LOG

    aWgId = 0; // Used window group id is always greater than zero

    RArray< RWsSession::TWindowGroupChainInfo > windowChain;

    User::LeaveIfError( aWs.WindowGroupList( &windowChain ) );

    CleanupClosePushL( windowChain );

    TInt count( windowChain.Count() );

    for( TInt i( 0 ); i < count; ++i )

        {

        const RWsSession::TWindowGroupChainInfo& entry( windowChain[ i ] );

        CApaWindowGroupName* app = CApaWindowGroupName::NewLC(

            aWs, entry.iId );

        TUid appUid( app->AppUid() );

        CleanupStack::PopAndDestroy( app );

        // Match the app's UID and the embedded status.

        // The app is standalone when there is no parent window group.

        if ( appUid == aUid && entry.iParentId <= 0 )

            {

            // Standalone application found

            aWgId = entry.iId;

            break;

            }

        }

    CleanupStack::PopAndDestroy( &windowChain );

    return aWgId > 0;

    }

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

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

// CFileManagerSchBackupTask::CFileManagerSchBackupTask

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

//

CFileManagerSchBackupTask::CFileManagerSchBackupTask() :

        CActive( EPriorityStandard ),

        iDay( KErrNotFound ),

        iAttemptsLeft( KNumAttempts )

    {

    FUNC_LOG

    }

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

// CFileManagerSchBackupTask::NewL

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

//

CFileManagerSchBackupTask* CFileManagerSchBackupTask::NewL(

        const CScheduledTask& aTask )

    {

    FUNC_LOG

    CFileManagerSchBackupTask* self =

        new ( ELeave ) CFileManagerSchBackupTask();

    CleanupStack::PushL( self );

    self->ConstructL( aTask );

    CleanupStack::Pop( self );

    return self;

    }

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

// CFileManagerSchBackupTask::~CFileManagerSchBackupTask

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

//

CFileManagerSchBackupTask::~CFileManagerSchBackupTask()

    {

    FUNC_LOG

    delete iSubscriber;

    delete iCenRep;

    Cancel();

    }

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

// CFileManagerSchBackupTask::RunL

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

//

void CFileManagerSchBackupTask::RunL()

    {

    StartL();

    }

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

// CFileManagerSchBackupTask::DoCancel

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

//

void CFileManagerSchBackupTask::DoCancel()

    {

    delete iSubscriber;

    iSubscriber = NULL;

    }

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

// CFileManagerSchBackupTask::RunError()

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

//

TInt CFileManagerSchBackupTask::RunError(

#ifdef FILE_MANAGER_ERROR_LOG_ENABLED

    TInt aError

#else // FILE_MANAGER_ERROR_LOG_ENABLED

    TInt /*aError*/

#endif // FILE_MANAGER_ERROR_LOG_ENABLED

     )

    {    

    ERROR_LOG1( "CFileManagerSchBackupTask::RunError()-Error=%d", aError )

    // Try again

    Retry();

    return KErrNone;

    }

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

// CFileManagerSchBackupTask::ConstructL

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

//

void CFileManagerSchBackupTask::ConstructL( const CScheduledTask& aTask )

    {

    FUNC_LOG

    INFO_LOG1( "CFileManagerTaskScheduler::ConstructL()-Repeat=%d",

        aTask.Info().iRepeat )

    CActiveScheduler::Add( this );

    // Check task creator

    if( aTask.SecurityInfo().iSecureId.iId != KFileManagerSID )

        {

        User::Leave( KErrPermissionDenied );

        }

    // Get pointer to file manager settings

    iCenRep = CRepository::NewL( KCRUidFileManagerSettings );

    // Get backup weekday if given from originator

    const HBufC& data( aTask.Data() );

    if ( data.Length() )

        {

        TLex parse;

        parse.Assign( data );

        User::LeaveIfError( parse.Val( iDay ) );

        }

    Retry();

    }

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

// CFileManagerSchBackupTask::CheckBackupRequired

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

//

TBool CFileManagerSchBackupTask::CheckBackupRequired()

    {

    TBool ret( ETrue );

    // Check schedule type

    TInt scheduling( 0 );

    iCenRep->Get( KFileManagerBackupScheduling, scheduling );

    if ( scheduling == EFileManagerBackupScheduleNone )

        {

        // Backup is not required

        ret = EFalse;

        }

    // Check weekday

    if ( ret && iDay != KErrNotFound )

        {

        TTime time;

        time.HomeTime();

        if ( time.DayNoInWeek() != iDay )

            {

            // Backup is not required today

            ret = EFalse;

            }

        }

    if ( !ret )

        {

        INFO_LOG( "CFileManagerSchBackupTask::CheckBackupRequired()-No" )

        Exit();

        }

    return ret;

    }

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

// CFileManagerSchBackupTask::CheckPhoneStateL

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

//

TBool CFileManagerSchBackupTask::CheckPhoneStateL()

    {

    // Check call state

    TInt callState( 0 );

    RProperty::Get(

        KPSUidCtsyCallInformation, KCTsyCallState, callState ); 

    if ( callState != EPSCTsyCallStateNone )

        {

        INFO_LOG1( "CFileManagerSchBackupTask::CheckPhoneStateL()-callState=%d",

            callState )

        // Set subscriber to wait call to finish

        iSubscriber = CFileManagerSchSubscriber::NewL(

            *this,

            KPSUidCtsyCallInformation,

            KCTsyCallState,

            CFileManagerSchSubscriber::ESubscribePS,

            KPhoneStateChangeTimeoutSecs );

        return EFalse;

        }

    // Check usb transfer state

    TInt usbState( 0 );

    RProperty::Get(

        KPSUidUsbWatcher, KUsbWatcherSelectedPersonality, usbState );

    if ( usbState == KUsbPersonalityIdMS )

        {

        INFO_LOG( "CFileManagerSchBackupTask::CheckPhoneStateL()-Usb transfer on" )

        // Set subscriber to wait usb transfer to finish

        iSubscriber = CFileManagerSchSubscriber::NewL(

            *this,

            KPSUidUsbWatcher,

            KUsbWatcherSelectedPersonality,

            CFileManagerSchSubscriber::ESubscribePS,

            KPhoneStateChangeTimeoutSecs );

        return EFalse;

        }

    // Check synchronization state

    TInt syncState( 0 );

    RProperty::Get(

        KPSUidDataSynchronizationInternalKeys, KDataSyncStatus, syncState );

    if ( syncState > 0 )

        {

        INFO_LOG( "CFileManagerSchBackupTask::CheckPhoneStateL()-Synchronization on" )

        // Set subscriber to wait usb transfer to finish

        iSubscriber = CFileManagerSchSubscriber::NewL(

            *this,

            KPSUidDataSynchronizationInternalKeys,

            KDataSyncStatus,

            CFileManagerSchSubscriber::ESubscribePS,

            KPhoneStateChangeTimeoutSecs );

        return EFalse;

        }

    // Check backup/restore (e.g. PC Suite initiated) state

    TInt burState( 0 );

    RProperty::Get(

        KUidSystemCategory, KUidBackupRestoreKey, burState );

    const TBURPartType partType = static_cast< TBURPartType >

        ( burState & KBURPartTypeMask );

    if ( partType != EBURUnset && partType != EBURNormal )

        {

        INFO_LOG( "CFileManagerSchBackupTask::CheckPhoneStateL()-Backup/restore on" )

        // Set subscriber to wait backup or restore to finish

        iSubscriber = CFileManagerSchSubscriber::NewL(

            *this,

            KUidSystemCategory,

            KUidBackupRestoreKey,

            CFileManagerSchSubscriber::ESubscribePS,

            KPhoneStateChangeTimeoutSecs );

        return EFalse;

        }

    return ETrue;

    }

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

// CFileManagerSchBackupTask::StartL

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

//

void CFileManagerSchBackupTask::StartL()

    {

    FUNC_LOG

    delete iSubscriber;

    iSubscriber = NULL;

    if ( !CheckBackupRequired() )

        {

        return;

        }

    if ( !CheckPhoneStateL() )

        {

        return;

        }

    // Set backup starting state

    iCenRep->Set(

        KFileManagerLastSchBackupStatus,

        EFileManagerSchBackupStatusStarting );

    // Set subscriber to watch backup start success

    iSubscriber = CFileManagerSchSubscriber::NewL(

        *this,

        KCRUidFileManagerSettings,

        KFileManagerLastSchBackupStatus,

        CFileManagerSchSubscriber::ESubscribeCR,

        KStartStateChangeTimeoutSecs );

    // Start file manager for backup and ensure that it starts properly

    StartFileManagerL();

    }

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

// CFileManagerSchBackupTask::Exit

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

//

void CFileManagerSchBackupTask::Exit()

    {

    FUNC_LOG

    Cancel();

    CActiveScheduler::Stop();

    }

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

// CFileManagerSchBackupTask::Retry

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

//

void CFileManagerSchBackupTask::Retry()

    {

    if ( iAttemptsLeft != 0 )

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        if ( iAttemptsLeft > 0 )

            {

            --iAttemptsLeft;

            }

        }

    else

        {

        Exit();

        }

    }

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

// CFileManagerSchBackupTask::StartFileManagerL

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

//

void CFileManagerSchBackupTask::StartFileManagerL()

    {

    FUNC_LOG

    RWsSession wsSession;

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

    CleanupClosePushL( wsSession );

    // Backup cannot be done from embedded file manager.

    // Backup operation closes the app where file manager is started and 

    // the backup operation stops because file manager gets closed as well.

    TInt wgId( 0 );

    if ( FindStandaloneAppL( wsSession, KUidFileManager, wgId ) )

        {

        // Notify running standalone file manager to start backup

        HBufC8* param8 = HBufC8::NewLC( KSchBackupTaskName().Length() );

        TPtr8 paramPtr( param8->Des() );

        paramPtr.Copy( KSchBackupTaskName );

        wsSession.SendMessageToWindowGroup(

            wgId,

            TUid::Uid( KUidApaMessageSwitchOpenFileValue ),

            *param8 );

        CleanupStack::PopAndDestroy( param8 );

        }

    else

        {

        // Start standalone file manager for backup

        TApaAppInfo appInfo;

        RApaLsSession apaLsSession;

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

        CleanupClosePushL( apaLsSession );

        User::LeaveIfError( apaLsSession.GetAppInfo(

            appInfo, KUidFileManager ) );

        CApaCommandLine* apaCmdLine = CApaCommandLine::NewLC();

        apaCmdLine->SetExecutableNameL( appInfo.iFullName );

        apaCmdLine->SetCommandL( EApaCommandBackground );

        TThreadId fmThreadId;

        User::LeaveIfError( apaLsSession.StartApp(

            *apaCmdLine, fmThreadId ) );

        CleanupStack::PopAndDestroy( apaCmdLine );

        CleanupStack::PopAndDestroy( &apaLsSession );

        }

    CleanupStack::PopAndDestroy( &wsSession );

    }

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

// CFileManagerSchBackupTask::NotifyKeyChangeOrTimeoutL

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

//

void CFileManagerSchBackupTask::NotifyKeyChangeOrTimeoutL(

        const TUid& aCategory,

        const TUint aKey,

        const TBool aTimeout )

    {

    FUNC_LOG

    if ( aCategory == KCRUidFileManagerSettings &&

        aKey == KFileManagerLastSchBackupStatus &&

        !aTimeout )

        {

        // Backup was started, the task starter can be finished

        Exit();

        }

    else

        {

        // Backup was not started, try starting it again

        Retry();

        }

    }

// End of file