/*
* Copyright (c) 2009 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: Implementation of fotaserver component
* This is part of fotaapplication.
*
*/
#include <f32file.h>
#include <fotaConst.h>
#include <fotaengine.h>
#include "fmsclientserver.h"
#include "fmsclient.h"
#include "fmsclientdebug.h"
#include "fotaserverPrivateCRKeys.h"
#include <centralrepository.h>
// ---------------------------------------------------------------------------
// IsSecureClient()
// Checks who is trying to launch FMS
// ---------------------------------------------------------------------------
TBool IsSecureClient(TBool& aFotaStartUp)
{
FLOG(_L("IsSecureClient Started"));
RThread thread;
TUid fotaserver,fotastartup;
fotaserver.iUid = KFotaServerUid;
fotastartup.iUid = KStarterUid;
if ( thread.SecureId() == fotaserver.iUid )
{
FLOG(_L("fmsclient fotaserver is using the service"));
return ETrue;
}
else if ( thread.SecureId() == fotastartup.iUid )
{
FLOG(_L("fmsclient fotastartupplugin is using the service"));
aFotaStartUp = ETrue;
return ETrue;
}
else if (thread.SecureId() == 0x01D278B9 ) //test app
{
FLOG(_L("fmsclient test app is using the service"));
return ETrue;
}
FLOG(_L("fmsclient not launched"));
return EFalse;
}
// ---------------------------------------------------------------------------
// StartServerL()
// Starts Fota Downlaod Interrupt Monitory server
// ---------------------------------------------------------------------------
TInt StartServerL()
{
FLOG(_L("StartServerLt Started"));
TInt res = KErrNone;
RProcess server;
res=server.Create(KFMSServerName,KNullDesC);
FLOG(_L("StartServerL-- create server error as %d"),res);
if (res!=KErrNone)
{
return res;
}
TRequestStatus stat;
server.Rendezvous(stat);
if (stat!=KRequestPending)
server.Kill(0); // abort startup
else
server.Resume(); // logon OK - start the server
User::WaitForRequest(stat); // wait for start or death
res=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();
FLOG(_L("StartServerL-- server.ExitType() returns %d"),res);
server.Close();
return res;
}
// ---------------------------------------------------------------------------
// RFMSClient::OpenL()
// ---------------------------------------------------------------------------
EXPORT_C TInt RFMSClient::OpenL()
{
FLOG(_L("RFMSClient::OpenL()- Begin"));
TInt res = KErrNone;
TBool FotaStartUp = EFalse;
if( IsSecureClient(FotaStartUp))
{
FLOG(_L("RFMSClient::OpenL()- Secured client"));
res = CreateSession( KFMSServerName,TVersion(1,0,0),2 );
if ( res != KErrNone )
{
FLOG(_L("RFMSClient::OpenL()- session not created"));
res = StartServerL();
User::LeaveIfError( res );
res = CreateSession( KFMSServerName,TVersion(1,0,0),2 );
}
User::LeaveIfError( res );
FLOG(_L("RFMSClient::OpenL()- session created"));
CRepository* centrep2 = NULL;
TRAPD( err, centrep2 = CRepository::NewL( KCRUidFotaServer ) )
TInt val = KErrNone;
if (err==KErrNone )
{
centrep2->Get( KFotaUpdateState, val );
delete centrep2;
}
centrep2 = NULL;
if( FotaStartUp && val == EFotaDownloadInterrupted )
{
FLOG(_L("RFMSClient::OpenL()- fotastartup using FMS session"));
SendInterruptParamsL();
}
}
else //not a secured client
{
FLOG(_L("fmsclient not launched--insecured client"));
res = KErrNotFound;
}
FLOG(_L("RFMSClient::OpenL()- End %d"),res);
return res;
}
// ---------------------------------------------------------------------------
// RFMSClient::Close()
// ---------------------------------------------------------------------------
EXPORT_C void RFMSClient::Close()
{
FLOG(_L(" RFMSClient::Close"));
RSessionBase::Close(); //basecall
}
// ----------------------------------------------------------------------------
// RFMSClient::NotifyForResumeL()
// ----------------------------------------------------------------------------
EXPORT_C void RFMSClient::NotifyForResumeL(const TOmaDLInterruptReason& aReason,
const TInt& aBearer, const TDriveNumber& aDrive, const TInt& aSize)
{
FLOG(_L(" RFMSClient::NotifyForResumeL--Begin"));
TInt Size(aSize),Drive((TInt)aDrive),Bearer(aBearer);
TInt err = SendReceive( (TInt)aReason, TIpcArgs(Bearer,Drive,Size));
FLOG(_L(" RFMSClient::NotifyForResumeL--End error as %d"),err);
}
// ---------------------------------------------------------------------------
// RFMSClient::SendInterruptParamsL() called only when fotastartup launched
// ---------------------------------------------------------------------------
void RFMSClient::SendInterruptParamsL()
{
FLOG(_L(" RFMSClient::SendInterruptParamsL--Begin"));
TInt err = Send( EFotaStartUpPlugin );
FLOG(_L(" RFMSClient::SendInterruptParamsL--End as %d"),err);
}
// ---------------------------------------------------------------------------
// RFMSClient::CancelNotifyForResume()
// ---------------------------------------------------------------------------
EXPORT_C void RFMSClient::CancelNotifyForResume()
{
FLOG(_L(" RFMSClient::CancelNotifyForResume--Begin"));
TInt err = Send( ECancelOutstandingRequest );
FLOG(_L(" RFMSClient::CancelNotifyForResume--End as %d"),err);
}
// ---------------------------------------------------------------------------
// RFMSClient::MonitorForBatteryL()
// ---------------------------------------------------------------------------
EXPORT_C void RFMSClient::MonitorForBatteryL(TUint aLevel)
{
FLOG(_L(" RFMSClient::MonitorForBatteryL--Begin, level = %d"), aLevel);
TInt err = SendReceive( EMonitorbattery, TIpcArgs (aLevel));
FLOG(_L(" RFMSClient::MonitorForBatterL--End as %d"),err);
User::LeaveIfError(err);
}
// ---------------------------------------------------------------------------
// RFMSClient::Cancel()
// ---------------------------------------------------------------------------
EXPORT_C void RFMSClient::Cancel()
{
FLOG(_L(" RFMSClient::Cancel--Begin"));
TInt err = SendReceive( ECancelOutstandingRequest );
FLOG(_L(" RFMSClient::Cancel--End as %d"),err);
}
// ---------------------------------------------------------------------------
// RFMSClient::ActivePhoneCallSync()
// ---------------------------------------------------------------------------
EXPORT_C TInt RFMSClient::IsPhoneCallActive(TInt& aCallActive)
{
FLOG(_L(" RFMSClient::IsPhoneCallActive--Begin"));
TPckgBuf<TInt> result(aCallActive);
TInt err = SendReceive( EPhoneCallActive,TIpcArgs(&result));
aCallActive=result();
FLOG(_L(" RFMSClient::IsPhoneCallActive--End as %d,%d"),err,aCallActive);
return err;
}
// ---------------------------------------------------------------------------
// RFMSClient::MonitorActivePhoneCallEnd()
// ---------------------------------------------------------------------------
EXPORT_C TInt RFMSClient::MonitorActivePhoneCallEnd(TInt aPkgId,TInt aProfileId)
{
FLOG(_L(" RFMSClient::MonitorActivePhoneCallEnd--Begin, pkgid:%d, \
/ profileid:%d"),aPkgId,aProfileId);
TInt err = SendReceive( EMonitorPhoneCallEnd, TIpcArgs(aPkgId,aProfileId));
FLOG(_L(" RFMSClient::MonitorActivePhoneCallEnd--End as %d"),err);
return err;
}
//End of file