/*

 * Copyright (c) 2005-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:   starts update sequence

 *

 */

// INCLUDE FILES

#include <StringLoader.h>

#include <fotaserver.rsg>

#include <centralrepository.h>

#include <AknUtils.h>

#include <AknBidiTextUtils.h> 

#include <biditext.h>

#include <gdi.h>

#include <fotaengine.h>

#include <apgtask.h>

#include <SyncMLNotifierParams.h>

#include <aknradiobuttonsettingpage.h> 

#include <akntitle.h>

#include <schtime.h>

#include <csch_cli.h>

#include "fotaupdate.h"

#include "fmsclient.h"

#include "FotaReminderDlg.h"

#include "FotasrvSession.h"

#include "fotaserverPrivateCRKeys.h"

#include "fotaserverPrivatePSKeys.h"

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

TInt WriteUpdateBitmapL( const TDesC& aText, const TDesC& aFile)

    {

    FLOG(_L("WriteUpdateBitmapL writing %S to %S w/ txtdir"),&aText,&aFile);

    TSize   screensize = CCoeEnv::Static()->ScreenDevice()->SizeInPixels();

    TInt                width  = screensize.iWidth - KBmpMargin*2;

    TInt                height =  screensize.iHeight;

    CArrayFixSeg<TPtrC>*   lines = new CArrayFixSeg<TPtrC>(5);

    CleanupStack::PushL(lines);

    CFbsBitmap*         bitmap = new ( ELeave ) CFbsBitmap;

    CleanupStack::PushL( bitmap );

    bitmap->Create(  TSize(width,height), EColor64K );

    CFbsBitmapDevice*   device = CFbsBitmapDevice::NewL( bitmap );

    CleanupStack::PushL( device );

    const CFont* font = AknLayoutUtils::FontFromId(EAknLogicalFontPrimaryFont);

    CFbsBitGc*          context;

    User::LeaveIfError( device->CreateContext( context ) );

    CleanupStack::PushL( context );

    TInt                ascent = font->AscentInPixels();

    TInt                descent = font->DescentInPixels();

    context->UseFont ( font );

    context->Clear(); // bg color

    // Visually ordered text

    HBufC* wrappedstring = AknBidiTextUtils::ConvertToVisualAndWrapToArrayL(

            aText, width,*font, *lines);

    CleanupStack::PushL ( wrappedstring );

    TBool dirfound (ETrue);

    // direction of text, affects alignemnt

    TBidiText::TDirectionality direction = TBidiText::TextDirectionality(

            *wrappedstring, &dirfound );

    // Print visual text to bitmap

    for ( TInt i=0; i<lines->Count(); ++i ) 

        {

        TPtrC l = (*lines)[i];

        TInt top = (ascent+descent)*(i);

        TInt bot = (ascent+descent)*(i+1);

        TRect rect (0, top ,width, bot );

        CGraphicsContext::TTextAlign alignment = 

        direction==TBidiText::ELeftToRight ? CGraphicsContext::ELeft 

            : CGraphicsContext::ERight;

        context->DrawText(l, rect, ascent, alignment);

        }

    height = (ascent+descent)*lines->Count() + descent;

    bitmap->Resize( TSize(width,height));

    bitmap->Save( aFile );

    context->DiscardFont();

    CleanupStack::PopAndDestroy( wrappedstring );

    CleanupStack::PopAndDestroy( context );

    CleanupStack::PopAndDestroy( device );

    CleanupStack::PopAndDestroy( bitmap );

    CleanupStack::PopAndDestroy( lines );

    return 1;

    }

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

// PackageFileName  Creates pgk filename ,like 5.swupd

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

void PackageFileName( TInt aPkgid, TDes8& aFileName )

    {

    aFileName.AppendNum(aPkgid);

    aFileName.Append( KSwupdFileExt8 );

    }

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

// PackageFilePath  Creates pk file path, like c:\\private\\102072C4\\5.swupd

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

void PackageFilePath( TInt aPkgid, TDes8& aPath )

    {

    TBuf8<20> fn;

    PackageFileName ( aPkgid,fn);

    aPath.Append(KSwupdPath8);

    aPath.Append(fn);

    }

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

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

// CFotaUpdate::CFotaUpdate()

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

//

CFotaUpdate::CFotaUpdate() : CActive(EPriorityNormal) 

,iScheduledUpdate(NULL),iHandleUpdateAcceptLater(EFalse)

                {

                CActiveScheduler::Add( this ); 

                iNotifParams.iNoteType  = ESyncMLFwUpdUnknown;  

                iNotifParams.iIntParam  = 0;

                iChargeToMonitor = 0;

                iFinalizeLater = EFalse;

                }

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

// CFotaUpdate::~CFotaUpdate()

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

//

CFotaUpdate::~CFotaUpdate()

    {

    if(iScheduledUpdate)

        {

        delete iScheduledUpdate;

        iScheduledUpdate = NULL;	

        }

    iIntervalType.Close();  

    iInterval.Close();  

    }

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

// CFotaUpdate::NewL 

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

//

CFotaUpdate* CFotaUpdate::NewL (CFotaServer* aServer)

    {

    CFotaUpdate* ao = new (ELeave) CFotaUpdate();

    ao->iFotaServer = aServer;

    return ao;

    }

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

// CFotaUpdate::CheckUpdateResults

// Checks if there is update result file available (meaning that update just

// took place)

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

//

TBool CFotaUpdate::CheckUpdateResults( RFs& aRfs )

    {

    RFile   f;

    TInt    err;

    err = f.Open ( aRfs, KUpdateResultFile, EFileShareAny );

    f.Close();

    if ( err!=KErrNone )

        {

        return EFalse;

        }

    FLOG(_L(" CFotaUpdate::CheckUpdateResults  update result file Found! "));

    return ETrue;

    }

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

// CFotaUpdate::ExecuteUpdateResultFileL

// Read result code from update result file and update state accordingly. 

// Show notifier "Update succesful". Do some cleanup.

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

//

void CFotaUpdate::ExecuteUpdateResultFileL( RFs& aRfs )

    {

    FLOG(_L("CFotaUpdate::ExecuteUpdateResultFileL >>"));

    iFs = &aRfs;

    TInt                err;

    RFileReadStream     rstr;

    TInt                result;

    TInt                msglen;

    HBufC8*             message=NULL;

    HBufC16*            message16=NULL;

    TBool               deleteData ( EFalse );

    // Open update result file

    FLOG(_L("opening rstr 1/2  "));

    err = rstr.Open(*iFs,KUpdateResultFile ,EFileRead|EFileStream);

    FLOG(_L("opened  rstr 2/2  "));

    if(err) FLOG(_L("   update result file open err %d"), err);

    User::LeaveIfError (err );

    FLOG(_L("       0.1"));

    CleanupClosePushL( rstr );

    FLOG(_L("       0.2"));

    // Read resultcode 

    result = rstr.ReadUint32L();        FLOG(_L("       0.3"));

    msglen = rstr.ReadUint32L();        FLOG(_L("       0.4  result: %d  \

    msglen:%d "),  result, msglen);

    if(msglen != 0)

        {

        FLOG(_L("       0.5  reading msg"));

        message         = HBufC8::NewLC(msglen+1);

        TPtr8  ptrdesc  = message->Des();

        TRAPD ( err2, rstr.ReadL(ptrdesc) );

        if ( err2 != KErrNone && err2 != KErrEof)

            {

            FLOG(_L("  file read err %d"),err2); User::Leave( err2 ); 

            }

        message16 = HBufC16::NewLC (message->Des().Length());

        message16->Des().Copy( *message );

        FLOG(_L("   1 update result: %d"),  result) ;

        FLOG(_L("   2 dbg msg: %S"),message16);

        CleanupStack::PopAndDestroy( message16 );

        CleanupStack::PopAndDestroy( message );

        }

    FLOG(_L("       0.6 "));

    CleanupStack::PopAndDestroy( &rstr ); 

    // Map resultcode to FUMO result code

    RFotaEngineSession::TState  fstate  

    = RFotaEngineSession::EUpdateFailed;

    RFotaEngineSession::TResult fresult 

    = RFotaEngineSession::EResUpdateFailed;

    TDriveNumber drive;

    TBool toencrypt =   iFotaServer->NeedToEncryptL(drive);

    FLOG(_L("   3"));

    switch ( result )

        {

        case UPD_OK:

            {

            fstate = RFotaEngineSession::EUpdateSuccessfulNoData;

            fresult = RFotaEngineSession::EResSuccessful;

            deleteData = ETrue;

            LaunchNotifierL ( ESyncMLFwUpdResultNote, KErrNone, toencrypt );

            }

            break;

        case UPD_INSTALL_REQUEST_IS_INVALID:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResUpdateFailed;

            deleteData = ETrue;

            LaunchNotifierL ( ESyncMLFwUpdResultNote, KErrNotFound, toencrypt );

            }

            break;

        case UPD_UPDATE_PACKAGE_IS_ABSENT:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResUpdateFailed;

            }

            break;

        case UPD_UPDATE_PACKAGE_IS_CORRUPTED:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResCorruptedFWUPD;

            deleteData = ETrue;

            LaunchNotifierL ( ESyncMLFwUpdResultNote, KErrNotSupported, toencrypt );

            }

            break;

        case UPD_UPDATE_PACKAGE_CONTENTS_IS_INVALID:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResCorruptedFWUPD;

            deleteData = ETrue;

            LaunchNotifierL ( ESyncMLFwUpdResultNote, KErrNotSupported, toencrypt );

            }

            break;

        case UPD_UPDATE_PACKAGE_IS_NOT_COMPATIBLE_WITH_CURRENT_MOBILE_DEVICE:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResPackageMismatch;

            deleteData = ETrue;

            LaunchNotifierL ( ESyncMLFwUpdResultNote, KErrNotSupported, toencrypt );

            }

            break;

        case UPD_FATAL_ERROR:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResUpdateFailed;

            deleteData = ETrue;

            LaunchNotifierL ( ESyncMLFwUpdResultNote, KErrNotFound, toencrypt );

            }

            break;

        default:

            {

            FLOG(_L("   3.1 invalid result: %d"), result);

            LaunchNotifierL ( ESyncMLFwUpdResultNote, KErrNotFound, toencrypt );

            }

            break;      

        }

    // Find the state 60 (update  progressing) -> 100 (etc)

    RArray<TInt>    states;

    TPackageState   state;

    CleanupClosePushL (states);

    iFotaServer->iDatabase->OpenDBL();

    iFotaServer->iDatabase->GetAllL(states);

    FLOG(_L("   4.1 found %d states "),states.Count() );

    for(TInt i=0;i<states.Count(); ++i ) 

        {

        TPackageState   tmp;

        tmp = iFotaServer->iDatabase->GetStateL(  states[i]  );

        FLOG(_L("   5 got state "));

        if ( tmp.iState == RFotaEngineSession::EUpdateProgressing )

            {

            state = tmp;

            state.iState    = fstate;

            state.iResult   = fresult;

            FLOG(_L("   6 Updating state id %d  to %d ,result %d  ")

                    ,state.iPkgId, state.iState,state.iResult );

            iFotaServer->iDatabase->SetStateL(state,KNullDesC8

                    ,EFDBState|EFDBResult ) ;

            }

        }

    iFotaServer->iDatabase->CloseAndCommitDB();

    CleanupStack::PopAndDestroy(&states);

    // Delete request file

    err = BaflUtils::DeleteFile ( *iFs, KUpdateRequestFile );

    if ( err != KErrNone && err != KErrNotFound ) 

        {

        FLOG(_L("   6.1  req file deleted, err %d"), err);

        User::Leave(err); 

        } 

    // Write timestamp (shown to user in device management ui)

    if( fresult == RFotaEngineSession::EResSuccessful )

        {

        RFileWriteStream    wstr;

        TTime               time;

        User::LeaveIfError( wstr.Replace( *iFs, KUpdateTimeStampFileName

                ,EFileWrite ) );

        CleanupClosePushL ( wstr );

        time.HomeTime();

        TInt                year   = time.DateTime().Year();

        TInt                month  = time.DateTime().Month();    

        TInt                day    = time.DateTime().Day();    

        TInt                hour   = time.DateTime().Hour();    

        TInt                minute = time.DateTime().Minute();    

        wstr.WriteInt32L(year) ;

        wstr.WriteInt32L(month) ;

        wstr.WriteInt32L(day) ;

        wstr.WriteInt32L(hour) ;

        wstr.WriteInt32L(minute) ;   

        CleanupStack::PopAndDestroy (1); // wstr

        }

    // Delete package content

    if ( deleteData  && state.iPkgId > KErrNotFound )

        {

        iFotaServer->StoragePluginL()->DeleteUpdatePackageL( state.iPkgId ) ;

        }

    // Report state back to syncml server

    if ( state.iPkgId >= 0 )

        {

        FLOG(_L("   6.1 creating device mgmt session for profile %d")

                ,state.iProfileId);

        iFotaServer->CreateDeviceManagementSessionL( state );

        }

    else 

        {

        FLOG(_L(" No state found in 'update progress' mode! cannot report\

        status to DM server "));

        }

    FLOG(_L("CFotaUpdate::ExecuteUpdateResultFileL <<"));

    }

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

// CFotaUpdate::DeleteUpdateResultsL

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

//

void CFotaUpdate::DeleteUpdateResultFileL( RFs& aRfs )

    {

    FLOG(_L("CFotaUpdate::DeleteUpdateResultsL "));

    // Delete result file

    BaflUtils::DeleteFile( aRfs, KUpdateResultFile );

    BaflUtils::DeleteFile( aRfs, KUpdateRequestFile );

    BaflUtils::DeleteFile( aRfs, KUpdateBitmap );

    BaflUtils::DeleteFile( aRfs, KRestartingBitmap );

    }

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

// CFotaUpdate::RunL

//  Handles user selection (button press: accept/ cancel update)

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

//

void CFotaUpdate::RunL()

    {

    FLOG(_L( "[FotaServer] CFotaUpdate::RunL() >> %d"  ),iStatus.Int() );

    TBool       handled( EFalse );

    User::LeaveIfError(iNotifier.CancelNotifier(KSyncMLFwUpdNotifierUid));

    iNotifier.Close();

    if (iStatus.Int() == KErrNotFound )

        {

        FLOG(_L("Exiting...."));

        TApaTaskList taskList(iFotaServer->GetEikEnv()->WsSession());

        TApaTask task=taskList.FindApp(TUid::Uid(KOmaDMAppUid));

        if(task.Exists())

            {

            task.EndTask();

            }

        return;

        }

    // Handle update start query

    if ( iNotifParams.iNoteType == ESyncMLFwUpdStartQuery )

        {

        FLOG(_L("   update start query"));

        // User pressed accept

        if ( iStatus.Int() == KErrNone )

            {

            handled = ETrue;

            HandleUpdateAcceptStartL();

            }

        // User pressed later

        else if ( iStatus.Int() == KErrCancel )

            {

            FLOG(_L("USER PRESSED LATER"));

            handled = ETrue;

            HandleUpdateAcceptLaterL();

            }

        }

    if ( iNotifParams.iNoteType == ESyncMLFwUpdStartQueryEnc )

        {

        FLOG(_L("   update start query"));

        if ( iStatus.Int() == KErrNone )

            {

            FLOG(_L(" user accepted query to decrypt memory"));

            handled = ETrue;

            TRAPD(err, iFotaServer->DoStartDecryptionL());

            if (err == KErrNotReady)

                {

                HandleUpdateErrorL(err);

                }

            }

        else if (iStatus.Int() == KErrCancel )

            {

            FLOG(_L("User pressed cancel. Don't decrypt. Stop."));

            handled = ETrue;

            LaunchNotifierL( ESyncMLFwUpdNoReminder , KErrNone );

            }

        }

    // Handle battery error

    if ( iNotifParams.iNoteType == ESyncMLFwUpdErrorNote )

        {

        if (iNotifParams.iIntParam == KErrBadPower || iNotifParams.iIntParam == KErrBadUsbPower)

            {

            FLOG(_L("       battery note"));

            if ( iStatus.Int() == KErrNone )

                {

                handled = ETrue;

                // Still check batt. (user might have connected charger)

                HandleErrorBasedonChargingTypeL();

                }

            else if (iNotifParams.iIntParam == KErrDeviceMemoryBusy)

                {

                FLOG(_L("Do nothing. Stop the update."));

                iFotaServer->FinalizeUpdateL();

                }

            else if (iNotifParams.iIntParam == KErrBadPowerForEnc)

                {

                if (iFinalizeLater)

                    {

                    FLOG(_L("Finalizing update now..."));

                    iFinalizeLater = EFalse;

                    iFotaServer->FinalizeUpdateL();

                    }

                }

            }

        }

    //  Handle update complete notification

    if ( iNotifParams.iNoteType == ESyncMLFwUpdResultNote )

        {

        handled = ETrue;

        DeleteUpdateResultFileL( iFotaServer->iFs );

        if (!iNotifParams.iEncryptReq)

            {

            FLOG(_L("Going to finalize update..."));

            iFotaServer->FinalizeUpdateL();

            }