/*

 * 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 download manager client

 *

 */

//System includes

#include <sysutil.h> 

#include <bautils.h>

#include <cmmanager.h>

#include <cmconnectionmethod.h>

#include <devicedialogconsts.h>

#include <centralrepository.h>

#include <XQConversions>

#include <uri8.h> //For parsing uri

//User includes

#include "FotaDlMgrClient.h"

#include "FotaDlClient.h"

#include "FotaServer.h"

#include "fotanotifiers.h"

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

//  Two phase construction

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

DownloadManagerClient* DownloadManagerClient::NewL(CFotaServer* aServer)

    {

    DownloadManagerClient* self = new (ELeave) DownloadManagerClient(aServer);

    self->ConstructL();

    return self;

    }

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

//  The constructor

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

DownloadManagerClient::DownloadManagerClient(CFotaServer* aServer) :

    iDownloadManager(NULL), iDownloadClient(NULL), iFotaServer(aServer),

            iInitialized(EFalse), iDownloadSubmitted(EFalse), iReservedSize(

                    5242880), iNotifParams(NULL), iNotifier (NULL)

    {

    }

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

//  The destructor

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

DownloadManagerClient::~DownloadManagerClient()

    {

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

    if (iDownloadClient)

        {

        delete iDownloadClient;

        iDownloadClient = NULL;

        }

    UninitDownloadMgr(); //Closes the RFs session and iDownloadManager.

    iFs.Close();

    	/*

    if (iNotifParams)

        {

        FLOG(_L("DownloadManagerClient::~DownloadManagerClient, iNotifParams >>"));

        delete iNotifParams;

        iNotifParams = NULL;

        FLOG(_L("DownloadManagerClient::~DownloadManagerClient, iNotifParams <<"));

        }

    if (iNotifier)

        {

        FLOG(_L("DownloadManagerClient::~DownloadManagerClient, iNotifier >>"));

        delete iNotifier;

        iNotifier = NULL;

        FLOG(_L("DownloadManagerClient::~DownloadManagerClient, iNotifier <<"));

        }*/

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

    }

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

//  Two phase construction

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

void DownloadManagerClient::ConstructL()

    {

    FLOG(_L("DownloadManagerClient::ConstructL >>"));

    TInt err;

    CRepository* centrep(NULL);

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

    if (centrep)

        {

        err = centrep->Get(KFotaDiskSpaceReservationKey, iReservedSize);

        }

    delete centrep;

    centrep = NULL;

    __LEAVE_IF_ERROR(iFs.Connect());

    iProgress = EFalse;

    FLOG(_L("DownloadManagerClient::ConstructL, reservation needed is %d <<"),iReservedSize);

    }

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

//  Initializes the download manager for fota requirements

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

int DownloadManagerClient::InitDownloadMgr()

    {

    FLOG(_L("DownloadManagerClient::InitDownloadMgr >>"));

    int ret = EOk;

    if (!iInitialized)

        {

        iDownloadManager = new DownloadManager("FotaServer"); //Step 0

        connect(iDownloadManager,

                SIGNAL(downloadManagerEvent(DownloadManagerEvent *)), this,

                SLOT(DownloadMgrEventRecieved(DownloadManagerEvent *))); //step 1

        //Scope as false signifies that the download should happen on fota process

        bool scope = false;

        ret = iDownloadManager->initialize(scope); //Step 2

#if defined(__WINS__)

        iDownloadManager->setProxy("bswebproxy01.americas.nokia.com", 8080); //Step 3/

#endif

        //Set the progress mode of download to be non quite

        ret = iDownloadManager->setAttribute(ProgressMode, NonQuiet);

        //Set the persistent mode of download to be active.

        ret = iDownloadManager->setAttribute(PersistantMode, Active);

        //Set the default destination path for all the downloads

        ret = iDownloadManager->setAttribute(DefaultDestinationPath, DefaultPath);

        if (iFotaServer->iPackageState.iIapId > 0)

            {

            QString name;

            TRAPD(err, name = GetIapNameWithIdL(iFotaServer->iPackageState.iIapId));

            HBufC* temp = XQConversions::qStringToS60Desc(name);

            FLOG(_L("IAP name for ID %d is %S, err = %d"), iFotaServer->iPackageState.iIapId, temp, err);

            delete temp;

#if defined(__WINS__)

#else

            if (err == KErrNone)

                {

                FLOG(_L("Setting IAP =int for the single download"), iFotaServer->iPackageState.iIapId);

                ret = iDownloadManager->setAttribute(AccessPoint, name);

                }

#endif  

            }

        iInitialized = ETrue;

        }

    FLOG(_L("DownloadManagerClient::InitDownloadMgr, ret = %d <<"), ret);

    return ret;

    }

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

//  Uninitializes the download manager

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

void DownloadManagerClient::UninitDownloadMgr()

    {

    FLOG(_L("DownloadManagerClient::UninitDownloadMgr >>"));

    if (iDownloadManager)

        {

        disconnect(iDownloadManager,

                SIGNAL(downloadManagerEvent(DownloadManagerEvent *)), this,

                SLOT(DownloadMgrEventRecieved(DownloadManagerEvent *)));

        iDownloadManager->deleteLater();

        iDownloadManager = NULL;

        }

    iInitialized = EFalse;

    FLOG(_L("DownloadManagerClient::UninitDownloadMgr <<"));

    }

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

//  Gets the access point name for a given access point id.

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

QString DownloadManagerClient::GetIapNameWithIdL(TInt aIapId)

    {

    FLOG(_L("DownloadManagerClient::GetIapNameWithIdL, iapid = %d"), aIapId);

    QString name(NULL);

    RCmManager cmManager;

    cmManager.OpenL();

    RCmConnectionMethod conn;

    conn = cmManager.ConnectionMethodL(aIapId);

    HBufC* temp = conn.GetStringAttributeL(CMManager::ECmName);

    name = QString::fromUtf16(temp->Ptr(), temp->Length());

    delete temp;

    temp = NULL;

    conn.Close();

    cmManager.Close();

    FLOG(_L("DownloadManagerClient::GetIapNameWithIdL <<"));

    return name;

    }

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

//  Starts the download using a given url

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

void DownloadManagerClient::DownloadL(const TDesC8& url)

    {

    FLOG(_L("DownloadManagerClient::Download >>"));

    iDownloadSubmitted = EFalse;

    iProgress = EFalse;

    //Validate url...

    TUriParser8 parser;

    if (parser.Parse(url) && !parser.IsSchemeValid())

        {

        FLOG(_L("URL is malformed.. finalizing download"));

        iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadFailed;

        iFotaServer->iPackageState.iResult= RFotaEngineSession::EResMalformedOrBadURL;

        iFotaServer->iDatabase->OpenDBL();

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

        iFotaServer->iDatabase->CloseAndCommitDB();

        iFotaServer->FinalizeDownloadL();

        TRAP_IGNORE(ShowDialogL(EFwDLNonResumableFailure));

        return;

        }

    FLOG(_L("DownloadManagerClient::DownloadL, State 2 - init download manager"));

    InitDownloadMgr();

    //Remove any existing download for this client

    iDownloadManager->removeAll();

    DeleteUpdatePackageL();

    DownloadType type = Parallel;

    if (!iDownloadClient)

        {

        iDownloadClient = new DownloadClient(this);

        }

    FLOG(_L("DownloadManagerClient::DownloadL, State 3 - creating download"));

    QString temp = QString::fromUtf8(

            reinterpret_cast<const char*> (url.Ptr()), url.Length());

    int err (0);

    if ((err = iDownloadClient->CreateDownload(temp, type)) != 0)

        {

        FLOG(_L("Error in creating download"), err);

        }

    else if ((err = iDownloadClient->SetDownloadAttributes()) != 0)

        {

        FLOG(_L("Error in setting attributes for download: %d"), err);

        }

    else 

        {

        iFotaServer->iPackageState.iState  = RFotaEngineSession::EStartingDownload;

        iFotaServer->iPackageState.iResult = KErrNotFound;

        iFotaServer->iDatabase->OpenDBL();

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

        iFotaServer->iDatabase->CloseAndCommitDB();

        iDownloadSubmitted = ETrue;

        iFotaServer->SetStartupReason(EFotaDownloadInterrupted);

        iDownloadClient->Start();

        FLOG(_L("Download is submitted successfully"));

        }

    if (err == ENotOk)

        {

        iFotaServer->iDatabase->OpenDBL();

        iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadFailed;

        iFotaServer->iPackageState.iResult = RFotaEngineSession::EResUndefinedError;

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

        iFotaServer->iDatabase->CloseAndCommitDB();

        iFotaServer->FinalizeDownloadL();

        TRAP_IGNORE(ShowDialogL(EFwDLNonResumableFailure));

        }

    FLOG(_L("DownloadManagerClient::Download <<"));

    }

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

//  Pauses an ongoing download.

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

void DownloadManagerClient::PauseDownloadL()

    {

    FLOG(_L("DownloadManagerClient::PauseDownloadL >>"));

    TInt ret(ENotOk);

    if (iDownloadClient)

        {

        ret = iDownloadClient->Pause(UserCancelled);

        __LEAVE_IF_ERROR(ret);

        }

    FLOG(_L("DownloadManagerClient::PauseDownloadL <<"));

    }

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

//  Tries to resume a suspended download

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

void DownloadManagerClient::TryResumeDownloadL()

    {

    FLOG(_L("DownloadManagerClient::TryResumeDownloadL >>"));

    TInt ret(ENotOk);

    FLOG(_L("DownloadManagerClient::TryResumeDownloadL, State 1 - init download manager"));

    __LEAVE_IF_ERROR(InitDownloadMgr());

    iDownloadSubmitted = ETrue;

    iProgress = EFalse;

    if (!iDownloadClient)

        {

        iDownloadClient = new DownloadClient(this);

        }

    iFotaServer->SetStartupReason(EFotaDownloadInterrupted);

    ret = iDownloadClient->Resume();

    if (ret == ENotOk )

        {

        if (iFotaServer->DecrementDownloadRestartCount())

            {

            FLOG(_L("There is no paused download! Hence restarting download..."));

            DownloadL(iFotaServer->iLastFwUrl);

            }

        else

            {

            FLOG(_L("There is no paused download! Restart exhausted and hence finalizing download..."));

            iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadFailed;

            if (iFotaServer->iPackageState.iResult == -1 )

                iFotaServer->iPackageState.iResult = RFotaEngineSession::EResUndefinedError;

            iDownloadSubmitted = EFalse;

            iFotaServer->FinalizeDownloadL();

            TRAP_IGNORE(ShowDialogL(EFwDLNonResumableFailure));

            }

        }

    FLOG(_L("DownloadManagerClient::TryResumeDownloadL, ret = %d <<"), ret);

    }

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

//  The slot which gets all the download manager events.

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

bool DownloadManagerClient::DownloadMgrEventRecieved(

        DownloadManagerEvent *event)

    {

    FLOG(_L("DownloadManagerClient::event >>"));

    DownloadManagerEvent::Event type = (DownloadManagerEvent::Event) event->type();

    TBool ret(EFalse);

    FLOG(_L("Download Manager Event Type: %d"), type);

    switch (type)

        {

        case DownloadManagerEvent::Created:

            {

            FLOG(_L("Download is created..."));

            ret = ETrue;

            break;

            }

        case DownloadManagerEvent::Removed:

            {

            FLOG(_L("Download is cleared..."));

            ret = ETrue;

            break;

            }

        }

    FLOG(_L("DownloadManagerClient::event, ret = %d <<"), ret);

    return ret;

    }

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

//  Called by the download client when the single download begins.

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

void DownloadManagerClient::StartDownloadProgress(QString name,

        QString version, int size)

    {

    HBufC8* temp1 = XQConversions::qStringToS60Desc8(name);

    HBufC8* temp2 = XQConversions::qStringToS60Desc8(version);

    iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadProgressing;

    iFotaServer->iPackageState.iPkgSize = size;

    if (temp1->Length() <= iFotaServer->iPackageState.iPkgName.MaxLength())

        iFotaServer->iPackageState.iPkgName.Copy(temp1->Des());

    if (temp2->Length() <= iFotaServer->iPackageState.iPkgVersion.MaxLength())

        iFotaServer->iPackageState.iPkgVersion.Copy(temp2->Des());

    delete temp1;

    delete temp2;

    TRAP_IGNORE(

            iFotaServer->iDatabase->OpenDBL();

            iFotaServer->iDatabase->SetStateL( iFotaServer->iPackageState, KNullDesC8, EFDBPkgName|EFDBVersion|EFDBPkgSize|EFDBState);

            iFotaServer->iDatabase->CloseAndCommitDB();

            );

    if (!iFotaServer->iPackageState.iSessionType)

        {

        iFotaServer->StartDownloadDialog(name, version, size);

        iFotaServer->ConstructApplicationUI(ETrue);

        }

    }

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

//  Called by the download client to update the progress of download.

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

void DownloadManagerClient::UpdateDownloadProgress(int progress)

    {

    FLOG(_L("DownloadManagerClient::UpdateDownloadProgress, progress = %d >>"),

            progress );

    iProgress = ETrue;

    if (!iFotaServer->iPackageState.iSessionType)

        {

        iFotaServer->UpdateDownloadDialog(progress);

        }

    FLOG(_L("DownloadManagerClient::UpdateDownloadProgress <<"));

    }

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

//  Called by the download client when the download is complete, either successfully or unsuccessfully.

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

void DownloadManagerClient::HandleDownloadEvent(Download::State dlstate,

        int err0)

    {

    FLOG(_L("DownloadManagerClient::HandleDownloadEvent, status = %d >>"),  dlstate);

    iDownloadSubmitted = EFalse;

    iProgress = EFalse;

    TInt notetype(-1);

    if (iDownloadClient)

        {

        delete iDownloadClient;

        iDownloadClient = NULL;

        }

    if (dlstate == Download::Completed)

        {

        iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadComplete;

        iFotaServer->iPackageState.iResult = -1;

        }

    else if (dlstate == Download::Paused)

        {

        iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadProgressing;

        MapDownloadErrors(err0);

        }

    else if (dlstate == Download::Failed)

        {

        iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadFailed;

        MapDownloadErrors(err0);

        if(iFotaServer->iPackageState.iResult == RFotaEngineSession::EResDLFailDueToDeviceOOM

           || iFotaServer->iPackageState.iResult == RFotaEngineSession::EResDLFailDueToNWIssues)

            {

            iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadProgressing;

            }

        }

    else if (dlstate == Download::Cancelled)

        {

        iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadProgressing;

        MapDownloadErrors(err0);

        }

    else if (dlstate == Download::Paused)

        {

        iFotaServer->iPackageState.iState = RFotaEngineSession::EDownloadProgressing;

        MapDownloadErrors(err0);

        }

    else

        {

        FLOG(_L(" I DO NOT KNOW THIS DLSTATE!!"));

        }

    TRAPD(err,

            iFotaServer->iDatabase->OpenDBL();

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

            iFotaServer->iDatabase->CloseAndCommitDB();

    );

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

    UninitDownloadMgr();

    if (iFotaServer->iPackageState.iState == RFotaEngineSession::EDownloadComplete

            && iFotaServer->iPackageState.iUpdateLtr)

        {

        iFotaServer->SetStartupReason(EFotaUpdateInterrupted);

        }

    if (iFotaServer->iPackageState.iResult

            == RFotaEngineSession::EResDLFailDueToNWIssues)

        {

        notetype = EFwDLConnectionFailure;

        }

    else if (iFotaServer->iPackageState.iState == RFotaEngineSession::EDownloadProgressing &&

            iFotaServer->iPackageState.iResult == RFotaEngineSession::EResUndefinedError)