/*

 * 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 <centralrepository.h>

#include <AknUtils.h>

#include <AknBidiTextUtils.h> 

#include <biditext.h>

#include <gdi.h>

#include <fotaengine.h>

#include <apgtask.h>

#include <aknradiobuttonsettingpage.h> 

#include <akntitle.h>

#include <schtime.h>

#include <csch_cli.h>

#include <fotaengine.h>

#include <XQConversions>

#include "fotaupdate.h"

#include "fmsclient.h"

#include "FotasrvSession.h"

#include "fotaserverPrivateCRKeys.h"

#include "fotaserverPrivatePSKeys.h"

#include "fotanotifiers.h"

#include <usbman.h>

#include <usbstates.h>

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

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

// CFotaUpdate::CFotaUpdate()

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

//

CFotaUpdate::CFotaUpdate() :

    CActive(EPriorityNormal)

    {

    CActiveScheduler::Add(this);

    }

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

// CFotaUpdate::~CFotaUpdate()

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

//

CFotaUpdate::~CFotaUpdate()

    {

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

    iFotaServer = NULL;

    CancelMonitor();

    if (iProperty.Handle())

        iProperty.Close();

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

    }

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

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

    {

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

    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(iFotaServer->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();

    msglen = rstr.ReadUint32L();

    if (msglen != 0)

        {

        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;

    FLOG(_L("   3"));

    switch (result)

        {

        case UPD_OK:

            {

            fstate = RFotaEngineSession::EUpdateSuccessfulNoData;

            fresult = RFotaEngineSession::EResSuccessful;

            deleteData = ETrue;

            ShowDialogL(EFwUpdSuccess);

            }

            break;

        case UPD_INSTALL_REQUEST_IS_INVALID:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResUpdateFailed;

            deleteData = ETrue;

            ShowDialogL(EFwUpdNotCompatible);

            }

            break;

        case UPD_UPDATE_PACKAGE_IS_ABSENT:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResUpdateFailed;

            ShowDialogL(EFwUpdNotCompatible);

            }

            break;

        case UPD_UPDATE_PACKAGE_IS_CORRUPTED:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResCorruptedFWUPD;

            deleteData = ETrue;

            ShowDialogL(EFwUpdNotCompatible);

            }

            break;

        case UPD_UPDATE_PACKAGE_CONTENTS_IS_INVALID:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResCorruptedFWUPD;

            deleteData = ETrue;

            ShowDialogL(EFwUpdNotCompatible);

            }

            break;

        case UPD_UPDATE_PACKAGE_IS_NOT_COMPATIBLE_WITH_CURRENT_MOBILE_DEVICE:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResPackageMismatch;

            deleteData = ETrue;

            ShowDialogL(EFwUpdNotCompatible);

            }

            break;

        case UPD_FATAL_ERROR:

            {

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResUpdateFailed;

            deleteData = ETrue;

            ShowDialogL(EFwUpdNotCompatible);

            }

            break;

        default:

            {

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

            fstate = RFotaEngineSession::EUpdateFailedNoData;

            fresult = RFotaEngineSession::EResUpdateFailed;

            deleteData = ETrue;

            ShowDialogL(EFwUpdNotCompatible);

            }

            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;

        TBuf8<KMaxFileName> tmpurl;

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

        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(iFotaServer->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(iFotaServer->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->DeletePackageL(state.iPkgId);

        DeleteUpdateResultFileL();

        }

    // Report state back to syncml server

    if (state.iPkgId >= 0)

        {

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

                state.iProfileId);

        iFotaServer->ReportFwUpdateStatusL(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()

    {

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

    // Delete result file

    RFs fs;

    __LEAVE_IF_ERROR(fs.Connect());

    BaflUtils::DeleteFile(fs, KUpdateResultFile);

    BaflUtils::DeleteFile(fs, KUpdateRequestFile);

    BaflUtils::DeleteFile(fs, KUpdateBitmap);

    BaflUtils::DeleteFile(fs, KRestartingBitmap);

    fs.Close();

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

    }

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

// CFotaUpdate::UpdateL

// Updates the fw: Creates input files for update agent and boots device to 

// update mode.

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

void CFotaUpdate::UpdateL()

    {

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

    // Set state ........................................

    iFotaServer->iPackageState.iState

            = RFotaEngineSession::EUpdateProgressing;

    iFotaServer->iDatabase->OpenDBL();

    iFotaServer->iDatabase->SetStateL(iFotaServer->iPackageState, KNullDesC8,

            EFDBState);

    iFotaServer->iDatabase->CloseAndCommitDB();

    // Write update request for update agent..............

    FLOG(_L("CFotaUpdate::UpdateL  1 writing update.req "));

    TBuf16<KMaxFileName> dp2filepath;

    HBufC16* dp2;

    RFileWriteStream wstr;

    CleanupClosePushL(wstr);

    FLOG(_L("CFotaUpdate::UpdateL  2 getting pkg location"));

    iFotaServer->DownloaderL()->GetUpdatePackageLocation(dp2filepath);

    FLOG(_L("CFotaUpdate::UpdateL  3 craeting update.req"));

    User::LeaveIfError(wstr.Replace(iFotaServer->iFs, KUpdateRequestFile,

            EFileWrite));

    wstr.WriteInt16L(1); // version number is  1

    wstr.WriteInt32L(1); // count   of cmds is 1

    wstr.WriteInt16L(0); // requestid is 0

    dp2 = HBufC16::NewLC(dp2filepath.Length());

    dp2->Des().Copy(dp2filepath);

    wstr.WriteInt32L(dp2->Des().Length() + 1); // length of filename + null

    wstr.WriteL(dp2->Des());

    wstr.WriteInt16L(0); // null character

    CleanupStack::PopAndDestroy(dp2);

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

    FLOG(_L("CFotaUpdate::UpdateL  4 craeting update.bmp"));

    // Write update graphic for update agent ...............

    HBufC* updatetxt;

    HBufC* restarttxt;

    QString installstr = hbTrId("txt_device_update_info_installing");

    QString rebootstr = hbTrId("txt_device_update_info_rebooting");

    updatetxt = XQConversions::qStringToS60Desc(installstr);

    restarttxt = XQConversions::qStringToS60Desc(rebootstr);

    WriteUpdateBitmapL( updatetxt->Des(), KUpdateBitmap );

    WriteUpdateBitmapL( restarttxt->Des(), KRestartingBitmap );

    delete updatetxt;

    delete restarttxt;

    // Simulate update agent by writing result file.

    CRepository* centrep(NULL);

    TInt err = KErrNone;

    TRAP(err, centrep = CRepository::NewL( KCRUidFotaServer ) );

    TInt simulate(KErrNotFound);

    if (centrep)

        {

        err = centrep->Get(KSimulateUpdateAgent, simulate);

        }

    delete centrep;

    if (simulate > 0)

        {

        FLOG(_L("CFotaUpdate::UpdateL  5  - writing update.resp"));

        RFileWriteStream respstr;

        CleanupClosePushL(respstr);

        User::LeaveIfError(respstr.Replace(iFotaServer->iFs,

                KUpdateResultFile, EFileWrite));

        respstr.WriteUint32L(UPD_OK);

        respstr.WriteUint32L(15);

        respstr.WriteL(_L("UPDATE DONE!"));

        CleanupStack::PopAndDestroy(&respstr);

        }

    iFotaServer->SetStartupReason(EFotaDefault);

    RStarterSession starter;

    FLOG(_L("           starter->Connect"));

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

    starter.Reset(RStarterSession::EFirmwareUpdate);

    starter.Close();

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

    }

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

// CFotaUpdate::CheckBatteryL()

// Cheks if there's enough battery power to update

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

//

TBool CFotaUpdate::CheckBatteryL()

    {

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

    TInt chargingstatus(EChargingStatusError);

    TInt batterylevel(EBatteryLevelUnknown);

    TBool enoughPower(EFalse);

    // Read battery level

    RProperty pw;

    User::LeaveIfError(pw.Attach(KPSUidHWRMPowerState, KHWRMBatteryLevel));

    User::LeaveIfError(pw.Get(batterylevel));

    if (batterylevel >= BatteryLevelAccepted)

        {

        FLOG(_L("Battery charge is above acceptable level!"));

        enoughPower = ETrue;

        }

    else

        {

        //Read charger status

        User::LeaveIfError(pw.Attach(KPSUidHWRMPowerState,

                KHWRMChargingStatus));

        User::LeaveIfError(pw.Get(chargingstatus));

        pw.Close();

        // But charger is connected, power sufficient

        if (chargingstatus == EChargingStatusCharging || chargingstatus

                == EChargingStatusAlmostComplete || chargingstatus

                == EChargingStatusChargingComplete || chargingstatus

                == EChargingStatusChargingContinued)

            {

            FLOG(

                    _L("Battery charge is below acceptable level, but charger is connected!"));

            enoughPower = ETrue;

            }

        }

    FLOG(_L("CFotaUpdate::CheckBattery, current charge = %d, ret = %d <<"),

            batterylevel, enoughPower);

    return enoughPower;

    }

void CFotaUpdate::MonitorBatteryChargeLevel()

    {

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

    CancelMonitor();

    iProperty.Attach(KPSUidHWRMPowerState, KHWRMBatteryLevel);

    TInt value = 0;

    iProperty.Get(KPSUidHWRMPowerState, KHWRMBatteryLevel, value);

    FLOG(_L("Battery level at this time is %d, err = %d"), value);

    iStatus = KRequestPending;

    iProperty.Subscribe(iStatus);

    iMonitorType = BatteryLevel;

    SetActive();

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

    }

void CFotaUpdate::MonitorBatteryChargingStatus()

    {

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

    CancelMonitor();

    iProperty.Attach(KPSUidHWRMPowerState, KHWRMChargingStatus);

    TInt value = 0;

    iProperty.Get(KPSUidHWRMPowerState, KHWRMChargingStatus, value);

    FLOG(_L("Charging status at this time is %d, err = %d"), value);

    iStatus = KRequestPending;

    iProperty.Subscribe(iStatus);

    iMonitorType = ChargingStatus;

    SetActive();

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

    }

void CFotaUpdate::CancelMonitor()

    {

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

    if (IsActive())

        {

        FLOG(_L("Cancelling...."));

        Cancel();

        }

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

    }

TBool CFotaUpdate::IsUSBConnected()

    {

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

    TBool ret (EFalse);