/*
* Copyright (c) 2007-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:
*
*/
/**
@file
@internalComponent
*/
#include "fdfsession.h"
#include "fdfserver.h"
#include <usb/usblogger.h>
#include "utils.h"
#include <ecom/ecom.h>
#include "fdfapi.h"
#include "fdf.h"
#include "event.h"
#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, "fdf ");
#endif
#ifdef _DEBUG
PANICCATEGORY("fdfsession");
#endif
CFdfSession::CFdfSession(CFdf& aFdf, CFdfServer& aServer)
: iFdf(aFdf),
iServer(aServer)
{
LOG_FUNC
}
CFdfSession::~CFdfSession()
{
LOG_LINE
LOG_FUNC;
iServer.SessionClosed();
}
void CFdfSession::ServiceL(const RMessage2& aMessage)
{
LOG_LINE
LOG_FUNC;
LOGTEXT2(_L8("\taMessage.Function() = %d"), aMessage.Function());
// Switch on the IPC number and call a 'message handler'. Message handlers
// complete aMessage (either with Complete or Panic), or make a note of
// the message for later asynchronous completion.
// Message handlers should not leave- the server does not have an Error
// function.
switch ( aMessage.Function() )
{
case EUsbFdfSrvEnableDriverLoading:
EnableDriverLoading(aMessage);
// This is a sync API- check that the message has been completed.
// (NB We don't check the converse for async APIs because the message
// may have been panicked synchronously.)
ASSERT_DEBUG(aMessage.Handle() == 0);
break;
case EUsbFdfSrvDisableDriverLoading:
DisableDriverLoading(aMessage);
ASSERT_DEBUG(aMessage.Handle() == 0);
break;
case EUsbFdfSrvNotifyDeviceEvent:
NotifyDeviceEvent(aMessage);
break;
case EUsbFdfSrvNotifyDeviceEventCancel:
NotifyDeviceEventCancel(aMessage);
ASSERT_DEBUG(aMessage.Handle() == 0);
break;
case EUsbFdfSrvNotifyDevmonEvent:
NotifyDevmonEvent(aMessage);
break;
case EUsbFdfSrvNotifyDevmonEventCancel:
NotifyDevmonEventCancel(aMessage);
ASSERT_DEBUG(aMessage.Handle() == 0);
break;
case EUsbFdfSrvGetSingleSupportedLanguageOrNumberOfSupportedLanguages:
GetSingleSupportedLanguageOrNumberOfSupportedLanguages(aMessage);
ASSERT_DEBUG(aMessage.Handle() == 0);
break;
case EUsbFdfSrvGetSupportedLanguages:
GetSupportedLanguages(aMessage);
ASSERT_DEBUG(aMessage.Handle() == 0);
break;
case EUsbFdfSrvGetManufacturerStringDescriptor:
GetManufacturerStringDescriptor(aMessage);
ASSERT_DEBUG(aMessage.Handle() == 0);
break;
case EUsbFdfSrvGetProductStringDescriptor:
GetProductStringDescriptor(aMessage);
ASSERT_DEBUG(aMessage.Handle() == 0);
break;
case EUsbFdfSrvGetOtgDescriptor:
GetOtgDeviceDescriptor(aMessage);
ASSERT_DEBUG(aMessage.Handle() == 0);
break;
// Heap failure testing APIs.
case EUsbFdfSrvDbgFailNext:
#ifdef _DEBUG
{
LOGTEXT2(_L8("\tfail next (simulating failure after %d allocation(s))"), aMessage.Int0());
if ( aMessage.Int0() == 0 )
{
__UHEAP_RESET;
}
else
{
__UHEAP_FAILNEXT(aMessage.Int0());
}
}
#endif // _DEBUG
CompleteClient(aMessage, KErrNone);
break;
case EUsbFdfSrvDbgAlloc:
{
TInt err = KErrNone;
#ifdef _DEBUG
LOGTEXT(_L8("\tallocate on the heap"));
TInt* x = NULL;
TRAP(err, x = new(ELeave) TInt);
delete x;
#endif // _DEBUG
CompleteClient(aMessage, err);
}
break;
default:
PANIC_MSG(aMessage, KUsbFdfServerName, EBadIpc);
break;
}
}
void CFdfSession::CompleteClient(const RMessage2& aMessage, TInt aError)
{
LOGTEXT2(_L8("\tcompleting client message with %d"), aError);
aMessage.Complete(aError);
}
void CFdfSession::EnableDriverLoading(const RMessage2& aMessage)
{
LOG_FUNC
iFdf.EnableDriverLoading();
CompleteClient(aMessage, KErrNone);
}
void CFdfSession::DisableDriverLoading(const RMessage2& aMessage)
{
LOG_FUNC
iFdf.DisableDriverLoading();
CompleteClient(aMessage, KErrNone);
}
TBool CFdfSession::NotifyDeviceEventOutstanding() const
{
const TBool ret = ( iNotifyDeviceEventMsg.Handle() != 0 );
LOGTEXT2(_L("CFdfSession::NotifyDeviceEventOutstanding returning %d"), ret);
return ret;
}
void CFdfSession::NotifyDeviceEvent(const RMessage2& aMessage)
{
LOG_FUNC
if ( iNotifyDeviceEventMsg.Handle() )
{
PANIC_MSG(iNotifyDeviceEventMsg, KUsbFdfServerName, ENotifyDeviceEventAlreadyOutstanding);
}
else
{
iNotifyDeviceEventMsg = aMessage;
TDeviceEvent event;
if ( iFdf.GetDeviceEvent(event) )
{
CompleteDeviceEventNotification(event);
}
}
}
void CFdfSession::NotifyDeviceEventCancel(const RMessage2& aMessage)
{
LOG_FUNC
if ( iNotifyDeviceEventMsg.Handle() )
{
CompleteClient(iNotifyDeviceEventMsg, KErrCancel);
}
CompleteClient(aMessage, KErrNone);
}
void CFdfSession::DeviceEvent(const TDeviceEvent& aEvent)
{
LOG_FUNC
// This function should only be called if there is a request outstanding.
ASSERT_DEBUG(iNotifyDeviceEventMsg.Handle());
CompleteDeviceEventNotification(aEvent);
}
void CFdfSession::CompleteDeviceEventNotification(const TDeviceEvent& aEvent)
{
LOG_FUNC
TRAPD(err, CompleteDeviceEventNotificationL(aEvent));
if ( err )
{
PANIC_MSG(iNotifyDeviceEventMsg, KUsbFdfServerName, EBadNotifyDeviceEventData);
}
}
void CFdfSession::CompleteDeviceEventNotificationL(const TDeviceEvent& aEvent)
{
LOG_FUNC
// iNotifyDeviceEventMsg has one IPC arg: a TDeviceEventInformation
ASSERT_DEBUG(iNotifyDeviceEventMsg.Handle());
TPckg<TDeviceEventInformation> info(aEvent.iInfo);
iNotifyDeviceEventMsg.WriteL(0, info);
CompleteClient(iNotifyDeviceEventMsg, KErrNone);
}
TBool CFdfSession::NotifyDevmonEventOutstanding() const
{
const TBool ret = ( iNotifyDevmonEventMsg.Handle() != 0 );
LOGTEXT2(_L("CFdfSession::NotifyDevmonEventOutstanding returning %d"), ret);
return ret;
}
void CFdfSession::NotifyDevmonEvent(const RMessage2& aMessage)
{
LOG_FUNC
if ( iNotifyDevmonEventMsg.Handle() )
{
PANIC_MSG(iNotifyDevmonEventMsg, KUsbFdfServerName, ENotifyDevmonEventAlreadyOutstanding);
}
else
{
iNotifyDevmonEventMsg = aMessage;
TInt event;
if ( iFdf.GetDevmonEvent(event) )
{
CompleteDevmonEventNotification(event);
}
}
}
void CFdfSession::NotifyDevmonEventCancel(const RMessage2& aMessage)
{
LOG_FUNC
if ( iNotifyDevmonEventMsg.Handle() )
{
CompleteClient(iNotifyDevmonEventMsg, KErrCancel);
}
CompleteClient(aMessage, KErrNone);
}
void CFdfSession::DevmonEvent(TInt aError)
{
LOG_FUNC
// This function should only be called if there is a request outstanding.
ASSERT_DEBUG(iNotifyDevmonEventMsg.Handle());
CompleteDevmonEventNotification(aError);
}
void CFdfSession::CompleteDevmonEventNotification(TInt aError)
{
LOG_FUNC
TRAPD(err, CompleteDevmonEventNotificationL(aError));
if ( err )
{
PANIC_MSG(iNotifyDevmonEventMsg, KUsbFdfServerName, EBadNotifyDevmonEventData);
}
}
void CFdfSession::CompleteDevmonEventNotificationL(TInt aEvent)
{
LOG_FUNC
// iNotifyDevmonEventMsg has the following IPC args:
// 0- TInt& aError
ASSERT_DEBUG(iNotifyDevmonEventMsg.Handle());
TPckg<TInt> event(aEvent);
iNotifyDevmonEventMsg.WriteL(0, event);
CompleteClient(iNotifyDevmonEventMsg, KErrNone);
}
void CFdfSession::GetSingleSupportedLanguageOrNumberOfSupportedLanguages(const RMessage2& aMessage)
{
LOG_FUNC
// To save IPC operations between client and server, we make use of the
// fact that the majority of devices only support a single language.
// The client is expected to have a buffer big enough to hold a single
// TUint.
// If the device supports 0 languages, the buffer is left empty and the
// request is completed with KErrNotFound.
// If the device supports 1 language, the language ID is put in the buffer
// and the request is completed with KErrNone.
// If the device supports more than 1 language, the number of languages is
// put in the buffer, and the request is completed with
// KErrTooBig. The client then allocates a buffer big enough to hold the
// supported languages and uses EUsbFdfSrvGetSupportedLanguages to get
// them all.
TRAPD(err, GetSingleSupportedLanguageOrNumberOfSupportedLanguagesL(aMessage));
CompleteClient(aMessage, err);
}
void CFdfSession::GetSingleSupportedLanguageOrNumberOfSupportedLanguagesL(const RMessage2& aMessage)
{
LOG_FUNC
const TUint deviceId = aMessage.Int0();
LOGTEXT2(_L8("\tdeviceId = %d"), deviceId);
const RArray<TUint>& langIds = iFdf.GetSupportedLanguagesL(deviceId);
const TUint count = langIds.Count();
LOGTEXT2(_L8("\tcount = %d"), count);
switch ( count )
{
case 0:
// Nothing to write to the client's address space, complete with
LEAVEL(KErrNotFound);
break;
case 1:
{
// Write the single supported language to the client, complete with
// KErrNone (or error of course, if their buffer isn't big enough).
TPckg<TUint> buf(langIds[0]);
LEAVEIFERRORL(aMessage.Write(1, buf));
}
break;
default:
{
// Write the number of supported languages to the client, complete
// with KErrTooBig (or error if their buffer wasn't big enough). NB
// This is the point at which this mechanism depends on
// RMessagePtr2::WriteL itself not leaving with KErrTooBig!
TPckg<TUint> buf(count);
LEAVEIFERRORL(aMessage.Write(1, buf));
LEAVEL(KErrTooBig);
}
break;
}
}
void CFdfSession::GetSupportedLanguages(const RMessage2& aMessage)
{
LOG_FUNC
TRAPD(err, GetSupportedLanguagesL(aMessage));
CompleteClient(aMessage, err);
}
void CFdfSession::GetSupportedLanguagesL(const RMessage2& aMessage)
{
LOG_FUNC
const TUint deviceId = aMessage.Int0();
LOGTEXT2(_L8("\tdeviceId = %d"), deviceId);
const RArray<TUint>& langIds = iFdf.GetSupportedLanguagesL(deviceId);
const TUint count = langIds.Count();
LOGTEXT2(_L8("\tcount = %d"), count);
RBuf8 buf;
buf.CreateL(count * sizeof(TUint));
CleanupClosePushL(buf);
for ( TUint ii = 0 ; ii < count ; ++ii )
{
buf.Append((TUint8*)&(langIds[ii]), sizeof(TUint));
}
// Write back to the client.
LEAVEIFERRORL(aMessage.Write(1, buf));
CleanupStack::PopAndDestroy(&buf);
}
void CFdfSession::GetManufacturerStringDescriptor(const RMessage2& aMessage)
{
LOG_FUNC
GetStringDescriptor(aMessage, EManufacturer);
}
void CFdfSession::GetProductStringDescriptor(const RMessage2& aMessage)
{
LOG_FUNC
GetStringDescriptor(aMessage, EProduct);
}
void CFdfSession::GetStringDescriptor(const RMessage2& aMessage, TStringType aStringType)
{
LOG_FUNC
TRAPD(err, GetStringDescriptorL(aMessage, aStringType));
CompleteClient(aMessage, err);
}
void CFdfSession::GetStringDescriptorL(const RMessage2& aMessage, TStringType aStringType)
{
LOG_FUNC
ASSERT_DEBUG(aStringType == EManufacturer || aStringType == EProduct);
TName string;
const TUint deviceId = aMessage.Int0();
const TUint langId = aMessage.Int1();
if ( aStringType == EManufacturer )
{
iFdf.GetManufacturerStringDescriptorL(deviceId, langId, string);
}
else
{
iFdf.GetProductStringDescriptorL(deviceId, langId, string);
}
LOGTEXT2(_L("\tstring = \"%S\""), &string);
LEAVEIFERRORL(aMessage.Write(2, string));
}
void CFdfSession::GetOtgDeviceDescriptor(const RMessage2& aMessage)
{
LOG_FUNC
TOtgDescriptor otgDesc;
const TUint deviceId = aMessage.Int0();
TRAPD(err, iFdf.GetOtgDeviceDescriptorL(deviceId, otgDesc));
if (KErrNone == err)
{
TPckg<TOtgDescriptor> buf(otgDesc);
err = aMessage.Write(1, buf);
}
CompleteClient(aMessage, err);
}