/*

 * Copyright (c) 2005 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:   Fota server update and download functionality 

 *

 */

// INCLUDE FILES

#include <apgtask.h>

#include <apgwgnam.h>

#include <schtime.h>

#include <csch_cli.h>

#include <e32property.h>

#include <ApUtils.h> 

#include <commdb.h>

#include <DevManInternalCRKeys.h>

#include <nsmlconstants.h>

#include <centralrepository.h>

#include <sysversioninfo.h>

#include <hbstackedlayout.h>

#include <hbmainwindow.h>

#include <hbview.h>

#include <featmgr.h>

#include <DevEncProtectedPSKey.h>

#include <hbapplication.h>

#include <xqconversions.h>

#include <hbtransparentwindow.h>

#include <es_sock.h>

#include <es_enum_internal.h>

#include <es_sock_partner.h>

#include <e32property.h>

#include <xqserviceutil.h>

#include "FotaServer.h"

#include "FotaSrvDebug.h"

#include "FotasrvSession.h"

#include "fotaConst.h"

#include "nsmldmtreedbclient.h"

#include "fotaserverPrivatePSKeys.h"

#include "FotaNetworkRegStatus.h"

#include "FotaDlMgrClient.h"

#include "fotadevicedialogobserver.h"

#include "fotanotifiers.h"

#include "fotaserverPrivatePSKeys.h"

#define __LEAVE_IF_ERROR(x) if(KErrNone!=x) {FLOG(_L("LEAVE in %s: %d"), __FILE__, __LINE__); User::Leave(x); }

TInt CFotaServer::iSessionCount = 0;

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

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

// GetPredefinedNodeL

// function to get preconfigured node for FUMO

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

void GetPredefinedNodeL(TDes8& aNode)

    {

    FLOG(_L("GetPredefinedNodeL() Begin"));

    CRepository* centrep(NULL);

    aNode.Zero();

    centrep = CRepository::NewLC(TUid::Uid(0x101F9A0A));

    if (centrep)

        {

        FLOG(_L("centralrepository found End"));

        TFullName temp;

        if (centrep->Get(KDevManFUMOPredefinedNodes, temp) == KErrNone

                && temp.Length())

            {

            temp.Trim();

            aNode.Copy(temp);

            }

        CleanupStack::PopAndDestroy(centrep);

        }

    FLOG(_L("GetPredefinedNodeL() End"));

    }

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

// DeleteFUMOTreeL

// function to get preconfigured node for FUMO

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

void DeleteFUMOTreeL()

    {

    FLOG(_L("DeleteFUMOTreeL() Begin"));

    const TUint32 KNSmlFotaAdapterUid = 0x101F9A09;

    _LIT8( KNSmlFumoPath, "FUMO" );

    _LIT8( KNSmlFumoSeparator, "/" );

    const TInt KGranularity = 10;

    TBuf8<KMaxFullName> temp;

    GetPredefinedNodeL(temp);

    RNSmlDMCallbackSession session;

    __LEAVE_IF_ERROR(session.Connect());

    CleanupClosePushL(session);

    CBufBase *emptyList = CBufFlat::NewL(0);

    CleanupStack::PushL(emptyList);

    CArrayFixFlat<TSmlDmMappingInfo>* UriSegList;

    UriSegList = new (ELeave) CArrayFixFlat<TSmlDmMappingInfo> (KGranularity);

    CleanupStack::PushL(UriSegList);

    session.GetUriSegListL(KNSmlFotaAdapterUid, KNSmlFumoPath, *UriSegList);

    for (TUint16 i = 0; i < UriSegList->Count(); i++)

        {

        if (temp.Length() && UriSegList->At(i).iURISeg.Find(temp)

                != KErrNotFound)

            {

            FLOG(_L("DeleteFUMOTreeL predefined match =%S"), &temp);

            continue;

            }

        TBuf8<KMaxFullName> tempFumo;

        tempFumo.Append(KNSmlFumoPath);

        tempFumo.Append(KNSmlFumoSeparator);

        tempFumo.Append(UriSegList->At(i).iURISeg);

        FLOG(_L("DeleteFUMOTreeL() call update mapping info for node %S"), &tempFumo);

        session.UpdateMappingInfoL(KNSmlFotaAdapterUid, tempFumo, *emptyList);

        }

    // session.UpdateMappingInfoL(KNSmlFotaAdapterUid,KNSmlFumoPath,*emptyList);

    CleanupStack::PopAndDestroy(UriSegList);

    CleanupStack::PopAndDestroy(emptyList);

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

    FLOG(_L("DeleteFUMOTreeL() End"));

    }

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

// CFotaServer::NewInstance

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

CFotaServer* CFotaServer::NewInstance(HbMainWindow& mainwindow)

    {

    FLOG(_L("CFotaServer::NewInstance >>"));

    CFotaServer* self = new CFotaServer(mainwindow);

    if (self)

        {

        TRAPD( err, self->ConstructL());

        if (err != KErrNone)

            {

            delete self; self = NULL;

            }

        }

    FLOG(_L("CFotaServer::NewInstance >>"));

    return self;

    }

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

// CFotaSrvSession::NewSessionL() 

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

CSession2* CFotaServer::NewSessionL(const TVersion&, const RMessage2&) const

    {

    iSessionCount++;

    FLOG(_L("Number of active sessions = %d"), iSessionCount);

    return new (ELeave) CFotaSrvSession();

    }

void CFotaServer::ReportFwUpdateStatusL(TPackageState& aState)

    {

    FLOG(_L("CFotaServer::ReportFwUpdateStatusL >>"));

    TFotaClient requester = GetUpdateRequester();

    if (requester == EDMHostServer)

        {

        FLOG(_L("Reporting status back to hostserver..."));

        ServerCanShut(EFalse);

        CreateDeviceManagementSessionL(aState);

        }

    else

        {

        //iServerCanShut = EFalse; Don't do here. Should be set in downloadmgrcli based on error type.

        //ResetFotaStateL(aState.iPkgId);

        SetStartupReason(EFotaDefault);

        StopServerWhenPossible();

        FLOG(_L("Not reporting status as requester is unknown!"));

        }

    FLOG(_L("CFotaServer::ReportFwUpdateStatusL >>"));

    }

void CFotaServer::StartDownloadDialog(const QString &aName,

        const QString &aVersion, const TInt &aSize)

    {

    FLOG(_L("CFotaServer::StartDownloadDialog >>"));

    //The dialog should not timeout here.

    if (!iFullScreenDialog)

        {

        //ConstructApplicationUI(ETrue);

        iFullScreenDialog = new FotaFullscreenDialog(this);

        }

    iFullScreenDialog->SetSoftwareDetails(aSize, aVersion, aName);

    iFullScreenDialog->SetWarningDetails(EHbFotaDownload);

    TBool postpone = IsUserPostponeAllowed();

    if (!postpone)

        {

        FLOG(_L("Disabling option to resume later!"));

        iFullScreenDialog->DisableRSK(ETrue);

        }

    FLOG(_L("CFotaServer::StartDownloadDialog <<"));

    }

void CFotaServer::UpdateDownloadDialog(TInt aProgress)

    {

    FLOG(_L("CFotaServer::UpdateDownloadDialog >>"));

    if (!iFullScreenDialog)

        {

        QString name = XQConversions::s60Desc8ToQString(

                iPackageState.iPkgName);

        QString version = XQConversions::s60Desc8ToQString(

                iPackageState.iPkgVersion);

        StartDownloadDialog(name, version, iPackageState.iPkgSize);

        ConstructApplicationUI(ETrue);

        }

    iFullScreenDialog->UpdateProgressBar(aProgress);

    FLOG(_L("CFotaServer::UpdateDownloadDialog <<"));

    }

void CFotaServer::ShowDialogL(TFwUpdNoteTypes adialogid)

    {

    FLOG(_L("CFotaServer::ShowDialogL  adialogid = %d<<"), adialogid);

    if (iNotifier)

        {

        FLOG(_L("Deleting the open device dialog!!"));

        iNotifier->Cancel();

        }

    ServerCanShut(EFalse);

    iDialogId = (TInt) adialogid;

    iNotifParams = CHbSymbianVariantMap::NewL();

    HBufC* keyDialog = HBufC::NewL(10);

    CleanupStack::PushL(keyDialog);

    *keyDialog = KKeyDialog;

    HBufC* keyParam1 = HBufC::NewL(10);

    CleanupStack::PushL(keyParam1);

    *keyParam1 = KKeyParam1;

    HBufC* keyParam2 = HBufC::NewL(10);

    CleanupStack::PushL(keyParam2);

    *keyParam2 = KKeyParam2;

    HBufC* keyParam3 = HBufC::NewL(10);

    CleanupStack::PushL(keyParam3);

    *keyParam3 = KKeyParam3;

    HBufC* keyParam4 = HBufC::NewL(10);

    CleanupStack::PushL(keyParam4);

    *keyParam4 = KKeyParam4;

    CHbSymbianVariant* dialogId = CHbSymbianVariant::NewL(&adialogid,

            CHbSymbianVariant::EInt);

    CleanupStack::PushL(dialogId);

    iNotifParams->Add(*keyDialog, dialogId);

    if (!iNotifier)

        iNotifier = CFotaDownloadNotifHandler::NewL(this);

    switch (adialogid)

        {

        case EFwUpdNotEnoughBattery:

        case EFwUpdDeviceBusy:

            {

            FLOG(_L("CFotaServer::EFwUpdNotEnoughBattery/EFwUpdDeviceBusy"));

            iNotifier->LaunchNotifierL(iNotifParams, adialogid);

            }

            break;

        case EFwUpdResumeUpdate:

        case EFwUpdResumeDownload:

            {

            FLOG(_L("CFotaServer::EFwUpdResumeUpdate / EFwUpdResumeDownload"));

            CHbSymbianVariant* param1Val = CHbSymbianVariant::NewL(

                    &iPackageState.iPkgSize, CHbSymbianVariant::EInt);

            CleanupStack::PushL(param1Val);

            iNotifParams->Add(*keyParam1, param1Val);

            TBuf16<KFotaMaxPkgNameLength>    temp1;

            temp1.Copy(iPackageState.iPkgVersion);

            CHbSymbianVariant* param2Val = CHbSymbianVariant::NewL(

                    //&iPackageState.iPkgVersion, CHbSymbianVariant::EDes);

                    &temp1, CHbSymbianVariant::EDes);

            CleanupStack::PushL(param2Val);

            iNotifParams->Add(*keyParam2, param2Val);

            TBuf16<KFotaMaxPkgNameLength>    temp2;

            temp2.Copy(iPackageState.iPkgName);

            CHbSymbianVariant* param3Val = CHbSymbianVariant::NewL(

                    &temp2, CHbSymbianVariant::EDes);

            CleanupStack::PushL(param3Val);

            iNotifParams->Add(*keyParam3, param3Val);

            TBool postpone = IsUserPostponeAllowed();

            CHbSymbianVariant* param4Val = CHbSymbianVariant::NewL(&postpone,

                    CHbSymbianVariant::EInt);

            CleanupStack::PushL(param4Val);

            iNotifParams->Add(*keyParam4, param4Val);

            iNotifier->LaunchNotifierL(iNotifParams, adialogid);

            CleanupStack::PopAndDestroy(4);

            }

            break;

        default:

            {

            FLOG(_L("CFotaServer::default"));

            //Do nothing

            }

            break;

        }

    CleanupStack::PopAndDestroy(6);

    FLOG(_L("CFotaServer::ShowDialogL >>"));

    }

void CFotaServer::HandleDialogResponse(int response, TInt aDialogId)

    {

    FLOG( _L("CFotaServer::HandleDialogResponse, response = %d dialog = %d >>"), response, aDialogId);

    switch (aDialogId)

        {

        case EFwUpdNotEnoughBattery:

        case EFwUpdDeviceBusy:

            {

            SetServerActive(EFalse);

            StopServerWhenPossible();

            }

            break;

        case EFwUpdResumeDownload:

            {

            if (response == EHbLSK) //Continue

                {

                FLOG(_L("User accepted to resume the download"));

                TRAP_IGNORE(CancelFmsL());

                TRAP_IGNORE(DownloaderL()->TryResumeDownloadL());

                }

            else //Resume Later

                {

                FLOG(_L("User denied resuming the download"));

                DecrementUserPostponeCount();

                SetServerActive(EFalse);

                SetStartupReason(EFotaDownloadInterrupted);

                TRAP_IGNORE(InvokeFmsL());

                StopServerWhenPossible();

                }

            }

            break;

        case EFwUpdResumeUpdate:

            {

            if (response == EHbLSK) //Continue

                {

                FLOG(_L("User accepted to resume the update"));

                iPackageState.iResult = KErrNotFound;

                TRAPD(err,

                        iDatabase->OpenDBL();

                        iDatabase->SetStateL( iPackageState ,KNullDesC8,EFDBResult );

                );

                FLOG(_L("Updating the fota database... err = %d"), err);

                iDatabase->CloseAndCommitDB();

                TRAP(err, iUpdater->StartUpdateL( iPackageState ));

                FLOG(_L("Starting update, err = %d"), err);

                }

            else //Update Later

                {

                FLOG(_L("User denied resuming the update"));

                iPackageState.iState = RFotaEngineSession::EStartingUpdate;

                iPackageState.iResult = RFotaEngineSession::EResUserCancelled;

                TRAPD(err,

                        iDatabase->OpenDBL();

                        iDatabase->SetStateL( iPackageState ,KNullDesC8,EFDBState|EFDBResult );

                        iDatabase->CloseAndCommitDB();

                );

                FLOG(_L("Updating the fota database... err = %d"), err);

                DecrementUserPostponeCount();

                SetServerActive(EFalse);

                SetStartupReason(EFotaUpdateInterrupted);

                TRAP(err, InvokeFmsL());

                FLOG(_L("Invoking fms, err = %d"), err);

                StopServerWhenPossible();

                }

            }

            break;

        default:

            {

            //Do nothing

            }

            break;

        }

    /*

     if(iNotifParams)

     {

     delete iNotifParams; iNotifParams = NULL;

     }

     if(iNotifier)

     {

     delete iNotifier; iNotifier = NULL;

     }*/

    iDialogId = 0;

    FLOG(_L("CFotaServer::HandleDialogResponse<<"));

    }

void CFotaServer::SetServerActive(TBool aValue)

    {

    FLOG(_L("CFotaServer::SetServerActive, aValue = %d"), aValue);

    TInt err = RProperty::Set(TUid::Uid(KOmaDMAppUid), KFotaServerActive,

            aValue);

    FLOG(_L("RProperty SetServerActive Set %d, err = %d"), aValue, err);

    if (err == KErrNotFound)

        {

        err = RProperty::Define(TUid::Uid(KOmaDMAppUid), KFotaServerActive,

                RProperty::EInt, KReadPolicy, KWritePolicy);

        err = RProperty::Set(TUid::Uid(KOmaDMAppUid), KFotaServerActive,

                aValue);

        FLOG(_L("RProperty SetServerActive Set %d, err = %d"), aValue,

                err);

        }

    FLOG(_L("CFotaServer::SetServerActive <<"));

    }

void CFotaServer::ShowFullScreenDialog(TInt aType)

    {

    FLOG(_L("CFotaServer::ShowFullScreenDialog, type = %d >>"), aType);

    if (!iFullScreenDialog)

        {

        const QString  ver =   QString::fromUtf8( reinterpret_cast<const char*> (iPackageState.iPkgVersion.Ptr()), iPackageState.iPkgVersion.Length());

        const QString name =   QString::fromUtf8( reinterpret_cast<const char*> (iPackageState.iPkgName.Ptr()), iPackageState.iPkgName.Length());

        iFullScreenDialog = new FotaFullscreenDialog(this);

        iFullScreenDialog->SetSoftwareDetails(iPackageState.iPkgSize, ver, name);

        iFullScreenDialog->SetWarningDetails(EHbFotaDownload);

        ConstructApplicationUI(ETrue);

        }

    if (aType == EHbFotaUpdate)

        {

        iFullScreenDialog->UpdateProgressBar(100);

        TBool postpone = IsUserPostponeAllowed();

        if (!postpone)

            {

            FLOG(_L("Disabling option to resume later!"));

            iFullScreenDialog->DisableRSK(ETrue);

            }

        iFullScreenDialog->ShowUpdateDialog();

        }

    else if (aType == EHbFotaLowBattery)

        {

        iFullScreenDialog->UpdateProgressBar(100);

        iFullScreenDialog->DisableRSK(EFalse);

        iFullScreenDialog->SetWarningDetails(EHbFotaLowBattery);

        }

    FLOG(_L("CFotaServer::ShowFullScreenDialog <<"));

    }

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

// CreateDeviceManagementSessionL       

// Creates DM session 

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

void CFotaServer::CreateDeviceManagementSessionL(TPackageState& aState)

    {

    FLOG(

            _L("[cfotasever]   CreateDeviceManagementSessionL dms >> profid %d\

    %d counts left ,sml handle %d, iNetworkAvailable=%d"),

            aState.iProfileId, aState.iSmlTryCount, iSyncMLSession.Handle(),

            iNetworkAvailable);

    SetStartupReason(EFotaPendingGenAlert);

    if (!iNetworkAvailable)

        {

        iRetryingGASend = ETrue;

        iPackageState = aState;

        StartNetworkMonitorL();

        }

    else

        {

        TBool dbAlreadyOpen = iDatabase->IsOpen();

        TBool triesLeft(EFalse);

        iNetworkAvailable = EFalse; // to check network again when GA is sent next time

        if (iSyncMLSession.Handle())

            {

            __LEAVE_IF_ERROR( KErrAlreadyExists );

            }

        if (!dbAlreadyOpen)

            iDatabase->OpenDBL();

        // There is still tries left

        if (aState.iSmlTryCount > 0)

            {

            triesLeft = ETrue;

            FLOG(_L(" decrementing the retry count"));

            aState.iSmlTryCount = aState.iSmlTryCount - 1;

            iDatabase->SetStateL(aState, KNullDesC8, EFDBSmlTryCount);

            }

        // out of tries, set state to idle