Bug 3539. Update localisation mappings.
/*
* Copyright (c) 2006 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: Access handler of the network session
*
*/
// INCLUDE FILES
#include "CImpsPluginAccessHandler.h"
#include "CImpsPluginPureDataHandler.h"
#include "ImpsPluginPanics.h"
#include "CImpsPluginSendDataOperation.h"
#include <flogger.h>
#include <F32File.h>
#include <APPARC.h>
// CONSTANTS
const TInt KOpIdInitvalue = 1000;
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::CImpsPluginPureDataHandler
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CImpsPluginPureDataHandler::CImpsPluginPureDataHandler(
MImpsPluginAccessHandler& aAccessHandler,
RImpsEng& aSessClient )
:
iAccessHandler( aAccessHandler ),
iSessClient( aSessClient ),
iOpidIterator( KOpIdInitvalue )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CImpsPluginPureDataHandler Start-End" ) );
}
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CImpsPluginPureDataHandler::ConstructL(
RImpsEng& aSessClient )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ConstructL Start" ) );
iPureClient.RegisterL( aSessClient, // main client
this, // Observer
EImpsServicePresence, // Type of service
ETrue, // Incoming data interest
ETrue ); // Any content type
iPureClient.RegisterErrorObserverL( *this );
TInt bufferSize ( iPureClient.MaxTransactionContentLengthL() );
// if size is zero, leave cause WV Engine is not ready
if ( bufferSize == 0 )
{
User::Leave( KErrNotReady );
}
iTrasferBuffer = HBufC8::NewL( bufferSize );
User::LeaveIfError( iFs.Connect() );
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ConstructL End %d " ), bufferSize );
#ifdef IMPS_ENABLE_DEBUG_PRINT
// init logs connection Id
//iConnectionLogsId = PEngPacketLogger::GetConnectionId();
#endif
}
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::NewLC()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CImpsPluginPureDataHandler* CImpsPluginPureDataHandler::NewL(
RImpsEng& aSessClient,
MImpsPluginAccessHandler& aAccessHandler )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::NewL Start" ) );
CImpsPluginPureDataHandler* self = new ( ELeave ) CImpsPluginPureDataHandler(
aAccessHandler,
aSessClient );
CleanupStack::PushL( self );
self->ConstructL( aSessClient );
CleanupStack::Pop( self );
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::NewL End" ) );
return self;
}
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::NewLC()
// Destructor
// -----------------------------------------------------------------------------
//
CImpsPluginPureDataHandler::~CImpsPluginPureDataHandler()
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::~CImpsPluginPureDataHandler Start" ) );
delete iTrasferBuffer;
iIncomingData.ResetAndDestroy();
if ( iIncReqStatus )
{
User::RequestComplete( iIncReqStatus, KErrCancel );
iIncReqStatus = NULL;
}
iPureClient.Unregister();
iOperations.ResetAndDestroy();
iAccessHandler.UnregisterSessionObserver( *this );
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::~CImpsPluginPureDataHandler End" ) );
}
// =============================================================================
// =============== New Functions of the MImpsPureDataHandler ===================
// =============================================================================
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::TransferBufferL()
// -----------------------------------------------------------------------------
//
TPtr8 CImpsPluginPureDataHandler::TransferBufferL()
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::TransferBufferL Start" ) );
TPtr8 buf = iTrasferBuffer->Des();
buf.Zero();
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::TransferBufferL End" ) );
return buf;
}
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::SendDataL()
// -----------------------------------------------------------------------------
//
TInt CImpsPluginPureDataHandler::SendDataL(
TRequestStatus& aStatus )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::SendDataL: Start" ) );
if ( iTrasferBuffer->Length() == 0 )
{
// buffer is empty, nothing to send, leave
User::Leave( KErrArgument );
}
// allocate slot in array by adding NULL pointer and removing it
iOperations.AppendL( NULL );
iOperations.Remove( iOperations.Count() - 1 );
CImpsPluginSendDataOperation* operation =
CImpsPluginSendDataOperation::NewLC();
TInt opId( iPureClient.SendPureDataL( *iTrasferBuffer ) );
// code for xmlfile
IMPS_DP( D_IMPS_LIT( "*****************************************" ) );
TFileName fileName = _L( "c:\\logs\\presadap12\\send.xml" );
User::LeaveIfError( CApaApplication::GenerateFileName( iFs, fileName ) );
RFile f;
if ( f.Create( iFs, fileName, EFileWrite ) == KErrNone )
{
f.Write( 0, *iTrasferBuffer );
f.Close();
}
IMPS_DP( D_IMPS_LIT( "-------------------------------------------" ) );
operation->SetIds( opId, iOpidIterator++ );
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::SendDataL opId %d" ), opId );
iOperations.Append( operation );
CleanupStack::Pop( operation ); // operation
// now it is safe to set request status
operation->SetRequestStatus( aStatus );
aStatus = KRequestPending;
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::SendDataL: End" ) );
return opId;
}
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::ResponseLC()
// -----------------------------------------------------------------------------
//
HBufC8* CImpsPluginPureDataHandler::ResponseL(
TInt aTransId )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ResponseL Start- id: %d" ), aTransId );
// is it incoming data request
if ( aTransId == 0 )
{
IMPS_DP( D_IMPS_LIT( "=======================================================" ) );
if ( iIncomingData.Count() == 0 )
{
User::Leave( KErrNotFound );
}
// take first one from the array
HBufC8* buff = iIncomingData[ 0 ];
iIncomingData.Remove( 0 );
TFileName fileName = _L( "c:\\logs\\presadap12\\notification.xml" );
User::LeaveIfError( CApaApplication::GenerateFileName( iFs, fileName ) );
RFile f;
if ( f.Create( iFs, fileName, EFileWrite ) == KErrNone )
{
f.Write( 0, *buff );
f.Close();
}
return buff;
}
// try to find operation
TInt x( FindOperationL( aTransId, CImpsPluginSendDataOperation::OperationId ) );
// is operation completed?
TRequestStatus* status = iOperations[ x ]->Status();
if ( status && ( *status == KRequestPending ) )
{
User::Leave( KErrNotReady );
}
// send buffer and remove operation
HBufC8* buff = iOperations[ x ]->Response();
delete iOperations[ x ];
iOperations.Remove( x );
// code for xmlfile
TFileName fileName = _L( "c:\\logs\\presadap12\\receive.xml" );
User::LeaveIfError( CApaApplication::GenerateFileName( iFs, fileName ) );
RFile f;
if ( f.Create( iFs, fileName, EFileWrite ) == KErrNone )
{
f.Write( 0, *buff );
f.Close();
}
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ResponseL: End" ) );
return buff;
}
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::CancelSending()
// -----------------------------------------------------------------------------
//
void CImpsPluginPureDataHandler::CancelSending(
TInt aTransId )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CancelSending Start - id: %d" ),
aTransId );
// try to find operation
TInt x( FindOperation( aTransId, CImpsPluginSendDataOperation::OperationId ) );
if ( x == KErrNotFound )
{
// nothing to cancel
return;
}
TRequestStatus* status = iOperations[ x ]->Status();
if ( status && ( *status == KRequestPending ) )
{
// operation pending, cancel it
iPureClient.CancelTransaction( aTransId );
iOperations[ x ]->CompletedOperation( KErrCancel );
}
delete iOperations[ x ];
iOperations.Remove( x );
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CancelSending End " ) );
}
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::ListenIncomingData()
// -----------------------------------------------------------------------------
//
TInt CImpsPluginPureDataHandler::ListenIncomingData(
TRequestStatus& aStatus )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ListenIncomingData Start" ) );
__ASSERT_DEBUG( !iIncReqStatus,
User::Panic( KImpsPluginPanic,
EListenerAlreadyActive )
);
if ( !iIncReqStatus )
{
iIncReqStatus = &aStatus;
aStatus = KRequestPending;
}
else
{
User::Leave( KErrNotReady );
}
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ListenIncomingData End Count is %d" ), iIncomingData.Count() );
return iIncomingData.Count();
}
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::CancelListening()
// -----------------------------------------------------------------------------
//
void CImpsPluginPureDataHandler::CancelListening()
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CancelListening Start" ) );
if ( iIncReqStatus )
{
User::RequestComplete( iIncReqStatus, KErrCancel );
iIncReqStatus = NULL;
}
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CancelListening End" ) );
}
// =============================================================================
// =============== New Functions of the MImpsPureHandler =======================
// =============================================================================
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::HandlePureDataL()
// -----------------------------------------------------------------------------
//
void CImpsPluginPureDataHandler::HandlePureDataL(
TInt aOpId,
const TDesC8& aBuffer,
TImpsCspIdentifier& /* aCspId*/ )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::HandlePureDataL - id: %d" ),
aOpId );
// is it incoming data handler
if ( aOpId == 0 )
{
IMPS_DP( D_IMPS_LIT( "=======================================================" ) );
HBufC8* buff = aBuffer.AllocLC();
iIncomingData.AppendL( buff );
CleanupStack::Pop( buff ); // buff
if ( iIncReqStatus )
{
User::RequestComplete( iIncReqStatus, KErrNone );
iIncReqStatus = NULL;
}
return;
}
// get buffer and store it in the correct Operation if it is our operation
TInt x( FindOperationL( aOpId, CImpsPluginSendDataOperation::OperationId ) );
if ( x != KErrNotFound )
{
iOperations[ x ]->SetResponse( aBuffer.AllocL() );
iOperations[ x ]->CompletedOperation( KErrNone );
}
}
// =============================================================================
// =============== New Functions of the MImpsErrorHandler ======================
// =============================================================================
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::HandleErrorL()
// -----------------------------------------------------------------------------
//
void CImpsPluginPureDataHandler::HandleErrorL(
TInt aStatus,
TInt aOpId,
const TDesC* /*aDescription*/,
const CImpsDetailed* /* aDetailedRes*/,
TImpsCspIdentifier& /*aCspId*/ )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::HandleErrorL - id: %d, %d" ),
aStatus,
aOpId );
IMPS_DP( D_IMPS_LIT( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++" ) );
// get buffer and store it in the correct Operation
TInt x( FindOperationL( aOpId, CImpsPluginSendDataOperation::OperationId ) );
iOperations[ x ]->CompletedOperation( aStatus );
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::HandleErrorL End" ) );
}
// =============================================================================
// ============== New Functions of the MPEngSessionStatusObserver ==============
// =============================================================================
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::HandleErrorL()
// -----------------------------------------------------------------------------
//
void CImpsPluginPureDataHandler::StatusChangedL(
TPEngNWSessionSlotState aNewState,
TPEngNWSessionSlotEvent /*aNewEvent*/ )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::StatusChangedL Start" ) );
if ( aNewState == EPEngNWPresenceSessionClosed )
{
// cancel all operations
iOperations.ResetAndDestroy();
//iPluginHost.HandleConnectionTerminated(
}
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::StatusChangedL End" ) );
}
// =============================================================================
// =============== New Functions of main class =================================
// =============================================================================
// =============================================================================
// =============== New private Functions of the base class =====================
// =============================================================================
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::FindOperation()
// Find operation in array
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CImpsPluginPureDataHandler::FindOperation(
TInt aOpId,
TInt ( CImpsPluginSendDataOperation:: *aIdFunc )() const ) const
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation Start" ) );
TInt count ( iOperations.Count() );
for ( TInt x( 0 ) ; x < count ; ++x )
{
if ( aOpId == ( ( *iOperations[ x ] ).*aIdFunc )() )
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation Returns %d" ), x );
return x;
}
}
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation End" ) );
return KErrNotFound;
}
// -----------------------------------------------------------------------------
// CImpsPluginPureDataHandler::FindOperationL()
// Find operation in array, leave if not found
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CImpsPluginPureDataHandler::FindOperationL(
TInt aOpId,
TInt ( CImpsPluginSendDataOperation:: *aIdFunc )() const ) const
{
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation Start" ) );
TInt x ( FindOperation( aOpId, aIdFunc ) );
if ( x == KErrNotFound )
{
User::Leave( KErrNotFound );
}
IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation End Returns %d" ), x );
return x;
}
// End of File