fotaapplication/FotaEngine/SRC/fotaengine.cpp
author hgs
Tue, 13 Jul 2010 09:51:41 +0530
changeset 51 2e64dc50f295
permissions -rw-r--r--
201025_02

/*
* 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:   Client for fotaserver
*
*/


// INCLUDES
#include <bldvariant.hrh>
#include <fotaengine.h>
#include "FotaIPCTypes.h"
#include "fotaConst.h"
#include "fotaenginedebug.h"
#include <apgcli.h>

       

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


// ---------------------------------------------------------------------------
// StartServerL()  
//  Starts Fota Downlaod Interrupt Monitory server
// ---------------------------------------------------------------------------
TInt StartServerL()
    {
    FLOG(_L("StartServerLt Started"));
    TInt res = KErrNone;
    
    RProcess server;
    RSemaphore sem;
    res = sem.CreateGlobal(KFotaServerScem, EOwnerProcess);

    res=server.Create(KFotaServerName,KNullDesC);
    FLOG(_L("StartServerL-- create server error as %d"),res);
    if (res!=KErrNone)
        {       
        return res;
        }

    server.Resume();    // logon OK - start the server
    
    sem.Wait();
    sem.Close();
    server.Close();
    
    FLOG(_L("StartServerL-- server.ExitType() returns %d"),res);

    return res;
    }

/**
 * Connects to the  server using 4 message slots.
 */
TBool RFotaEngineSession::connectToHbServer()
{
    FLOG(_L("RFotaEngineSession::connectToHbServer >>"));

    TInt error = CreateSession(KFotaServerName,TVersion(1,0,0),2);

    if (KErrNone != error) {
        FLOG(_L("RFotaEngineSession::Error: %d"), error);
    }
    FLOG(_L("RFotaEngineSession::connectToHbServer <<"));
    return (KErrNone == error); 
}

// ---------------------------------------------------------------------------
// RFotaEngineSession::OpenL( )
// Opens session to fotaserver. 
// ---------------------------------------------------------------------------
EXPORT_C void RFotaEngineSession::OpenL( )
{
    RProcess pr; TFullName fn = pr.FullName(); 

    TInt res = KErrNone;
    FLOG(_L("[RFotaEngineSession] OpenL\tcalled by '%S' >>"),&fn );
    
    res = connectToHbServer();
    if(!res)
        {
    FLOG(_L("Creation of session failed with error: %d; starting the server now..."), res);
        res = StartServerL();
        
        FLOG(_L("Starting of the server, error = %d"), res);
        User::LeaveIfError( res );

        res = CreateSession( KFotaServerName,TVersion(1,0,0),2 );
        FLOG(_L("Creation of session,  error: %d; "), res);
        User::LeaveIfError (res);
    
        }
    
    FLOG(_L("[RFotaEngineSession]\tconnected <<") );
}


// ---------------------------------------------------------------------------
// RFotaEngineSession::Close( )
// Closes session to fotaserver
// ---------------------------------------------------------------------------
EXPORT_C void RFotaEngineSession::Close( )
{
    RProcess pr; TFullName fn = pr.FullName(); 
    FLOG(_L("[RFotaEngineSession] RFotaEngineSession::Close() >> called by '%S'"),&fn );
        
    // Tell server that generic alert is sent for this pkg, so state is 
    // cleaned up     
    FLOG(_L("iGenericAlertSentPkgID = %d"), iGenericAlertSentPkgID);
    if ( iGenericAlertSentPkgID != -1 )
        {
        TInt err = SendReceive( EGenericAlertSentForPackage
                                    , TIpcArgs(iGenericAlertSentPkgID) );
        }

    RSessionBase::Close();
    FLOG(_L("[RFotaEngineSession] RFotaEngineSession::Close() <<") );
}


// ---------------------------------------------------------------------------
// RFotaEngineSession::Download
// Starts download of upd package.
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::Download(const TInt aPkgId
    , const TDesC8& aPkgURL, const TSmlProfileId aProfileId
    , const TDesC8& aPkgName, const TDesC8& aPkgVersion, TBool aSilent)
{
    TInt err;
    TDownloadIPCParams          ipcparam;
    ipcparam.iPkgId             = aPkgId;
    ipcparam.iProfileId         = aProfileId;
    ipcparam.iPkgName.Copy      (aPkgName);
    ipcparam.iPkgVersion.Copy   (aPkgVersion);
    TPckg<TDownloadIPCParams>   pkg(ipcparam);
    err = SendReceive ( EFotaDownload ,  TIpcArgs(&pkg, &aPkgURL, aSilent));
    return err;
}

// ---------------------------------------------------------------------------
// RFotaEngineSession::DownloadAndUpdate
// Starts download and update of update pakcage
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::DownloadAndUpdate(const TInt aPkgId
        ,const TDesC8& aPkgURL, const TSmlProfileId aProfileId
        ,const TDesC8& aPkgName, const TDesC8& aPkgVersion, TBool aSilent)
{
    TInt err;
    TDownloadIPCParams          ipcparam;
    ipcparam.iPkgId             = aPkgId;
    ipcparam.iProfileId         = aProfileId;
    ipcparam.iPkgName.Copy      (aPkgName);
    ipcparam.iPkgVersion.Copy   (aPkgVersion);
    TPckg<TDownloadIPCParams>   pkg(ipcparam);
    err = SendReceive( EFotaDownloadAndUpdate,  TIpcArgs(&pkg, &aPkgURL, aSilent));
    return err;
}

// ---------------------------------------------------------------------------
// RFotaEngineSession::Update
// Starts update of update package
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::Update(const TInt aPkgId
        ,const TSmlProfileId aProfileId, const TDesC8& aPkgName
        ,const TDesC8& aPkgVersion)
{
    TInt err;
    TDownloadIPCParams          ipcparam;
    ipcparam.iPkgId             = aPkgId;
    ipcparam.iProfileId         = aProfileId;
    ipcparam.iPkgName.Copy      (aPkgName);
    ipcparam.iPkgVersion.Copy   (aPkgVersion);
    TPckg<TDownloadIPCParams>   pkg(ipcparam);
    err = SendReceive ( EFotaUpdate ,  TIpcArgs(&pkg));
    return err;
}

// --------------------------------------------------------------------------
// RFotaEngineSession::PauseDownload
// To pause the download
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::PauseDownload ( )
    {
    TInt err(KErrNotSupported);

    err = SendReceive( EPauseDownload );

    return err;
    }

// ---------------------------------------------------------------------------
// RFotaEngineSession::TryResumeDownload
// Requests to resume the suspended download of the update package. 
// Implementation is not ready and will be provided later.
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::TryResumeDownload(TBool aSilent)
	{
	FLOG(_L("RFotaEngineSession::TryResumeDownload >>"));

	TInt err = KErrNone;
	
	err = SendReceive( EFotaTryResumeDownload, TIpcArgs( aSilent) );
	
	FLOG(_L("RFotaEngineSession::TryResumeDownload << err = %d" ),err);
	return err;
	}


// ---------------------------------------------------------------------------
// RFotaEngineSession::GetState
// ---------------------------------------------------------------------------
EXPORT_C RFotaEngineSession::TState RFotaEngineSession::GetState(
                                                         const TInt aPkgId)
    {
    FLOG(_L("RFotaEngineSession::GetState >>"));

    RFotaEngineSession::TState          state;
    TPckg<RFotaEngineSession::TState>   pkgstate(state);
    SendReceive ( EGetState , TIpcArgs(aPkgId, &pkgstate));
    FLOG(_L("RFotaEngineSession::GetState <<"));

    return state;
    }

// ---------------------------------------------------------------------------
// RFotaEngineSession::GetResult    
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::GetResult(const TInt aPkgId)
    {
    FLOG(_L("RFotaEngineSession::GetResult"));
    TInt            result;
    TPckg<TInt>     pkgresult(result);
    SendReceive ( EGetResult , TIpcArgs(aPkgId, &pkgresult));
    return result;
    }


// ---------------------------------------------------------------------------
// RFotaEngineSession::DeleteUpdatePackage
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::DeleteUpdatePackage(const TInt aPkgId)
{
    TInt err = SendReceive(EDeletePackage, TIpcArgs(aPkgId) );
    return err;
}


// ---------------------------------------------------------------------------
// RFotaEngineSession::LastUpdate
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::LastUpdate(TTime& aUpdates)
    {
    TInt err;
    FLOG(_L("RFotaEngineSession::LastUpdate >>"));
    TBuf<15>                    timestamp;
    err = SendReceive ( EGetUpdateTimestamp, TIpcArgs(&timestamp) );

    if ( timestamp.Length() > 0 )
        {
        TInt year   = timestamp[0];
        TInt month  = timestamp[1];
        TInt day    = timestamp[2];
        TInt hour   = timestamp[3];
        TInt minute = timestamp[4];
        aUpdates = TDateTime (year,(TMonth)month,day,hour,minute,0,0 );
        }
    else
        {
        aUpdates.Set( _L( "19900327:101010.000000" ) ); 
        err = KErrUnknown;
        }
    FLOG(_L("RFotaEngineSession::LastUpdate <<"));
    return err;
    }


// ---------------------------------------------------------------------------
// RFotaEngineSession::CurrentVersion
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::CurrentVersion(TDes& aSWVersion)
    {
    aSWVersion.Copy(_L("1.0"));  
    return KErrNone;
    }


// ---------------------------------------------------------------------------
// RFotaEngineSession::RFotaEngineSession
// ---------------------------------------------------------------------------
EXPORT_C RFotaEngineSession::RFotaEngineSession() : iGenericAlertSentPkgID(-1)
    {
    FLOG(_L("RFotaEngineSession::RFotaEngineSession() >>"));
    FLOG(_L("RFotaEngineSession::RFotaEngineSession() <<"));
    }


// ---------------------------------------------------------------------------
// RFotaEngineSession::GetUpdatePackageIds
// Gets ids of the update packages present in the system.
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::GetUpdatePackageIds(TDes16& aPackageIdList)
    {
    TInt err;
    FLOG(_L("RFotaEngineSession::GetUpdatePackageIds >>"));
    TBuf<10> b; b.Copy(_L("dkkd"));
    TPkgIdList                  pkgids;
    TPckg<TPkgIdList>           pkgids_pkg(pkgids);
    TIpcArgs                    args ( &pkgids_pkg);
    err = SendReceive ( EGetUpdatePackageIds, args);
    aPackageIdList.Copy(pkgids);
    FLOG(_L("RFotaEngineSession::GetUpdatePackageIds <<"));
    return err;
    }


EXPORT_C TVersion RFotaEngineSession::Version() const
    {
    TVersion version (1,0,0);
      
    return version;
    }

// ---------------------------------------------------------------------------
// RFotaEngineSession::GenericAlertSentL
// marks genereic alert being sent
// ---------------------------------------------------------------------------
EXPORT_C void RFotaEngineSession::GenericAlertSentL ( const TInt aPackageID )
    {
    FLOG(_L("RFotaEngineSession::GenericAlertSentL, aPackageID = %d >>"),aPackageID);
    iGenericAlertSentPkgID = aPackageID;
    FLOG(_L("RFotaEngineSession::GenericAlertSentL, iGenericAlertSentPkgID = %d <<"), iGenericAlertSentPkgID);
    }

// ---------------------------------------------------------------------------
// RFotaEngineSession::ScheduledUpdateL
// Update fw
// ---------------------------------------------------------------------------
EXPORT_C TInt RFotaEngineSession::ScheduledUpdateL ( const TFotaScheduledUpdate aSchedule )
    {
  	TInt err(KErrNotSupported);

    TPckg<TFotaScheduledUpdate> p(aSchedule);
    err = SendReceive( EScheduledUpdate, TIpcArgs(&p) );

    return err;
    }

EXPORT_C void RFotaEngineSession::GetCurrentFirmwareDetailsL(TDes8& aName, TDes8& aVersion, TInt& aSize)
    {
    FLOG(_L("RFotaEngineSession::GetCurrentFirmwareDetailsL >>"));
    
    TPckg<TInt>     pkgsize(aSize);
    
    __ASSERT_ALWAYS(aName.MaxLength() >= KFotaMaxPkgNameLength, User::Leave(KErrArgument) );
    __ASSERT_ALWAYS(aName.MaxLength() >= KFotaMaxPkgVersionLength, User::Leave(KErrArgument) );
    
    TInt err = SendReceive(EGetCurrFwDetails, TIpcArgs(&aName, &aVersion, &pkgsize));
    
    FLOG(_L("RFotaEngineSession::GetCurrentFirmwareDetailsL, err = %d <<"), err);
    User::LeaveIfError(err);
    }

// ---------------------------------------------------------------------------
// RFotaEngineSession::ServiceUid
// Apparc asks which session class to create in server side
// ---------------------------------------------------------------------------
TUid RFotaEngineSession::ServiceUid() const
	{
    RProcess pr; TFullName fn = pr.FullName(); 
    FLOG(_L( "RFotaEngineSession::ServiceUid() >> called by: %S" ), &fn );
    FLOG(_L( "RFotaEngineSession::ServiceUid() << ret: 0x%X" ),
                                            KFotaServiceUid );
	return TUid::Uid( KFotaServiceUid );
	}
	
/*
 * The following exported functions are not supported in SF4
 * They would be removed once stakeholder remove dependency with them.
 * Polonium CR: 530
 */ 
	
EXPORT_C TBool RFotaEngineSession::IsPackageStoreSizeAvailable(
        const TInt aSize)
    {
    return EFalse;
    }

EXPORT_C TInt RFotaEngineSession::OpenUpdatePackageStore(const TInt aPkgId,
        RWriteStream*& aPkgStore)
    {
    return KErrNotSupported;
    }

EXPORT_C TInt RFotaEngineSession::GetDownloadUpdatePackageSize(
        const TInt aPkgId, TInt& aDownloadedSize, TInt& aTotalSize)
    {
    return KErrNotSupported;
    }

EXPORT_C void RFotaEngineSession::UpdatePackageDownloadComplete(
        const TInt aPkgId)
    {
    
    }