// ----------------------------------------------------------------------------
// The thread ID of the client thread
// ----------------------------------------------------------------------------
//
TThreadId CMPXPlaybackSession::ClientIdL(const RMessage2& aMessage)
{
RThread t;
aMessage.ClientL(t);
TThreadId tid=t.Id();
t.Close();
return tid;
}
// ---------------------------------------------------------------------------
// CFotaSrvSession::ServiceL
// Handle client request
// ---------------------------------------------------------------------------
//
void CFotaSrvSession::ServiceL(const RMessage2& aMessage)
{
TInt err(KErrNone);
TInt pkgid = 0;
TPackageState state;
RThread clt;
aMessage.ClientL(clt);
TFullName cltnm = clt.FullName();
FLOG(_L( "CFotaSrvSession::ServiceL %d serving for %S?" ),
aMessage.Function(), &cltnm);
TFotaClient client = CheckClientSecureIdL(aMessage);
if (client == EUnknown)
{
FLOG(_L("Permission denied to use fota services!"));
User::Leave(KErrPermissionDenied);
}
TInt cmd = aMessage.Function();
if ((cmd != EGetState) && (cmd != EGetResult) && (cmd != EGetCurrFwDetails) && (cmd != EGetUpdateTimestamp))
{
TInt fotaValue(1);
CRepository* centrep(NULL);
TUid uidValue =
{
0x101F9A08
}; // KCRFotaAdapterEnabled
centrep = CRepository::NewL(uidValue);
if (centrep)
{
FLOG(_L("centralrepository found "));
centrep->Get(1, fotaValue); // KCRFotaAdapterEnabled
delete centrep;
}
if (!fotaValue)
{
FLOG(_L("Fota is disabled or not supported!"));
User::Leave(KErrNotSupported);
}
}
switch (aMessage.Function())
{
case EFotaDownload:
{
FLOG(_L( "CFotaSrvSession::ServiceL DOWNLOAD"));
TDownloadIPCParams ipc;
TPckg<TDownloadIPCParams> pkg(ipc);
aMessage.Read(0, pkg);
TInt deslen = aMessage.GetDesLengthL(1);
HBufC8* urlbuf = HBufC8::NewLC(deslen);
TPtr8 urlptr = urlbuf->Des();
aMessage.Read(1, urlptr);
TInt silent = aMessage.Int2();
FotaServer()->DownloadL(ipc, urlptr, client, silent, EFalse);
CleanupStack::PopAndDestroy(urlbuf); // urlbuf
aMessage.Complete(KErrNone);
break;
}
case EFotaUpdate:
{
FLOG(_L( "CFotaSrvSession::ServiceL UPDATE" ));
TDownloadIPCParams ipc;
TPckg<TDownloadIPCParams> pkg(ipc);
aMessage.Read(0, pkg);
// If update started from omadmappui, no alert should be sent if
// update is cancelled
if (client == EOMADMAppUi)
{
ipc.iSendAlert = EFalse;
}
FotaServer()->TryUpdateL(client);
aMessage.Complete(KErrNone);
break;
}
case EFotaDownloadAndUpdate:
{
FLOG(_L( "CFotaSrvSession::ServiceL DOWNLOADANDUPDATE" ));
TDownloadIPCParams ipc;
TPckg<TDownloadIPCParams> pkg(ipc);
aMessage.Read(0, pkg);
TInt deslen = aMessage.GetDesLengthL(1);
HBufC8* urlbuf = HBufC8::NewLC(deslen);
TPtr8 urlptr = urlbuf->Des();
aMessage.Read(1, urlptr);
TFotaClient requester = CheckClientSecureIdL(aMessage);
TInt silent = aMessage.Int2();
FotaServer()->DownloadL(ipc, urlptr, requester, silent, ETrue);
CleanupStack::PopAndDestroy(urlbuf);
aMessage.Complete(KErrNone);
}
break;
case EFotaTryResumeDownload:
{
FLOG(_L( "CFotaSrvSession::ServiceL TRYRESUMEDOWNLOAD" ));
if (client == EOMADMAppUi || client == EFMSServer || client
== EFotaTestApp)
{
TInt silent = aMessage.Int0();
FotaServer()->TryResumeDownloadL(client, silent); // silent
aMessage.Complete(KErrNone);
}
else
{
aMessage.Complete(KErrAccessDenied);
}
}
break;
case EDeletePackage:
{
FLOG(_L( "CFotaSrvSession::ServiceL DELETEPACKAGE"));
pkgid = aMessage.Int0();
FotaServer()->DeletePackageL(pkgid);
aMessage.Complete(KErrNone);
}
break;
case EGetState:
{
FLOG(_L( "CFotaSrvSession::ServiceL GETSTATE" ));
pkgid = aMessage.Int0();
state = FotaServer()->GetStateL(pkgid);
FLOG(_L( "CFotaSrvSession::ServiceL GETSTATE << %d" ), state.iState);
TPckg<RFotaEngineSession::TState> pkg2(state.iState);
aMessage.Write(1, pkg2);
aMessage.Complete(KErrNone);
}
break;
case EGetResult:
{
FLOG(_L( "CFotaSrvSession::ServiceL GETRESULT >>" ));
pkgid = aMessage.Int0();
state = FotaServer()->GetStateL(pkgid);
TPckg<TInt> pkg2(state.iResult);
FLOG(_L( "CFotaSrvSession::ServiceL GETRESULT << %d" ),
state.iResult);
aMessage.Write(1, pkg2);
aMessage.Complete(err);
break;
}
case EGetUpdatePackageIds:
{
FLOG(_L( "CFotaSrvSession::ServiceL EGETUPDATEPACKAGEIDS" ));
TPkgIdList pkgids;
FotaServer()->GetUpdatePackageIdsL(pkgids);
TPckg<TPkgIdList> pkgids_pkg(pkgids);
aMessage.Write(0, pkgids_pkg);
aMessage.Complete(KErrNone);
}
break;
case EGetUpdateTimestamp:
{
FLOG(_L( "CFotaSrvSession::ServiceL EGETUPDATETIMESTAMP" ));
TBuf16<15> timestamp;
FotaServer()->GetUpdateTimeStampL(timestamp);
aMessage.Write(0, timestamp);
aMessage.Complete(KErrNone);
}
break;
case EGenericAlertSentForPackage:
{
FLOG(_L( "CFotaSrvSession::ServiceL EGENERICALERTSENT FOR PKGID" ));
TInt pkgid = aMessage.Int0();
FotaServer()->ResetFotaStateL(pkgid);
aMessage.Complete(err);
}
break;
case EScheduledUpdate:
{
FLOG(_L( "CFotaSrvSession::ServiceL ESCHEDULEDUPDATE" ));
TFotaScheduledUpdate sched(-1, -1);
TPckg<TFotaScheduledUpdate> p(sched);
aMessage.Read(0, p);
FLOG(_L(" pkgid: %d scheduleid:%d"), sched.iPkgId,
sched.iScheduleId);
FotaServer()->ScheduledUpdateL(sched, client);
aMessage.Complete(KErrNone);
}
break;
case EPauseDownload:
{
FLOG(_L( "CFotaSrvSession::ServiceL EPAUSEDOWNLOAD" ));
FotaServer()->PauseDownloadL();
aMessage.Complete(KErrNone);
}
break;
case EGetCurrFwDetails:
{
FLOG(_L( "CFotaSrvSession::ServiceL EGETCURRFWDETAILS" ));
TBuf8<KFotaMaxPkgNameLength> name;
TBuf8<KFotaMaxPkgVersionLength> version;
TInt size(0);
FotaServer()->GetCurrentFwDetailsL(name, version, size);
/*
aMessage.Write(1, name);
aMessage.Write(2, version);
TPckg<TInt> psize(size);
aMessage.Write(3, psize);
aMessage.Complete(KErrNone);*/
aMessage.Write(0, name);
aMessage.Write(1, version);
TPckg<TInt> psize(size);
aMessage.Write(2, psize);
aMessage.Complete(KErrNone);
}
break;
default:
{
FLOG(_L( "CFotaSrvSession::ServiceL In default case" ));
}
break;
}
}
/*!
Handle an IPC request.
\param aMessage Message object.
*/
void CServiceSymbianSession::handleRequestL(const RMessage2& aMessage)
{
XQSERVICE_DEBUG_PRINT("CServiceSymbianSession::handleRequestL");
// Store the message
iMessage = aMessage;
// Convert from Symbian to QT
HBufC* request = ReadDesLC(aMessage, 0);
HBufC8* data = ReadDes8LC(aMessage, 1);
XQSharableFile *file = 0;
if (aMessage.Function() == KIPCOperationWithSharableFile)
{
// Only one file support now !
file = new XQSharableFile();
AdoptSharableFile(aMessage, file);
}
// Shallow copy only, we want a deep copy
QString d = QString::fromUtf16(request->Ptr(), request->Length());
QString operation;
operation += d;
XQSERVICE_DEBUG_PRINT("operation: %s", qPrintable(operation));
//QByteArray convertData;
TPtr8 ptr8(data->Des());
const char* ptrz = reinterpret_cast<const char*> (ptr8.PtrZ());
//convertData.append(ptrz);
QByteArray convertData(ptrz,data->Length());
XQSERVICE_DEBUG_PRINT("convertData: %s", convertData.constData());
// New request
if (iCurRequest) {
iObserver->handleDeleteRequest(iCurRequest);
delete iCurRequest;
}
iCurRequest = NULL;
iCurRequest = new ServiceIPCRequest(this, 0, operation);
iData.clear();
// Get client info
ClientInfo *client = new ClientInfo();
client->setProcessId(aMessage.SecureId().iId);
client->setVendorId(aMessage.VendorId().iId);
RThread clientThread;
aMessage.ClientL(clientThread);
CleanupClosePushL(clientThread);
RProcess clientProc;
CleanupClosePushL(clientProc);
clientThread.Process(clientProc);
client->setName(QString::fromUtf16(clientProc.Name().Ptr(),
clientProc.Name().Length()));
client->setCapabilities(ClientCapabilities(aMessage));
CleanupStack::PopAndDestroy(2, &clientThread);
// Set the picked sharable file if any
if (file != 0)
{
// Support only one sharable file
iCurRequest->addSharableFile(file, 0);
}
// Add data and callback to the observer
//
iCurRequest->addRequestdata(convertData);
iCurRequest->setClientInfo(client); // ownership passed
iObserver->handleRequest(iCurRequest);
CleanupStack::PopAndDestroy(2, request);
}
