/*
* 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(×tamp) );
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)
{
}