diff -r 7fdc9a71d314 -r 8ad140f3dd41 hti/HtiServicePlugins/HtiIpProxyServicePlugin/src/HtiIpProxyServicePlugin.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hti/HtiServicePlugins/HtiIpProxyServicePlugin/src/HtiIpProxyServicePlugin.cpp	Wed Oct 13 16:17:58 2010 +0300
@@ -0,0 +1,363 @@
+/*
+* 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:  HtiIpProxyServicePlugin implementation
+*
+*/
+
+
+// INCLUDE FILES
+#include "HtiIpProxyServicePlugin.h"
+#include <HtiDispatcherInterface.h>
+#include <HtiLogging.h>
+#include <badesca.h>
+#include <in_sock.h>
+#include "MSocketObserver.h"
+#include "Mhostconnectionobserver.h"
+#include "CIPProxyEngine.h"
+
+// CONSTANTS
+const static TUid KIpProxyServiceUid = { 0x10210CD3 };
+
+// MACROS
+
+// LOCAL CONSTANTS AND MACROS
+
+// MODULE DATA STRUCTURES
+
+// LOCAL FUNCTION PROTOTYPES
+
+// FORWARD DECLARATIONS
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// Create instance of concrete ECOM interface implementation
+CHtiIpProxyServicePlugin* CHtiIpProxyServicePlugin::NewL()
+    {
+    CHtiIpProxyServicePlugin* self = new( ELeave ) CHtiIpProxyServicePlugin;
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop();
+    return self;
+    }
+
+// Constructor
+CHtiIpProxyServicePlugin::CHtiIpProxyServicePlugin() :
+    iSocketObserver( NULL ),
+    iHostObserver( NULL ),
+    iProxyEngine( NULL ),
+    iOutgoingArray( NULL ),
+    iBusy( EFalse ),
+    iConnected( EFalse )
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin" );
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin" );
+    }
+
+CHtiIpProxyServicePlugin::~CHtiIpProxyServicePlugin()
+    {
+    HTI_LOG_FUNC_IN( "~CHtiIpProxyServicePlugin" );
+
+    if ( iProxyEngine )
+        {
+        iProxyEngine->StopListening();
+        }
+    delete iProxyEngine;
+    delete iOutgoingArray;
+
+    HTI_LOG_FUNC_OUT( "~CHtiIpProxyServicePlugin" );
+    }
+
+// Second phase construction.
+void CHtiIpProxyServicePlugin::ConstructL()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::ConstructL" );
+
+    iOutgoingArray = new( ELeave ) CDesC8ArraySeg( 10 );
+    iProxyEngine = CIPProxyEngine::NewL( this );
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::ConstructL" );
+    }
+
+
+void CHtiIpProxyServicePlugin::InitL()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::InitL" );
+
+    if ( iProxyEngine )
+        {
+        iProxyEngine->StartListening();
+        }
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::InitL" );
+    }
+
+TBool CHtiIpProxyServicePlugin::IsBusy()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::IsBusy" );
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::IsBusy" );
+    return iBusy;
+    }
+
+void CHtiIpProxyServicePlugin::ProcessMessageL( const TDesC8& aMessage,
+                                                THtiMessagePriority /* aPriority */ )
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::ProcessMessageL" );
+
+    iBusy = ETrue;
+
+    __ASSERT_ALWAYS( iSocketObserver, User::Panic( _L ( "IP-Proxy ECom-plugin" ), KErrBadHandle ) );
+    iSocketObserver->DataReceivedL( this, aMessage );
+
+    iBusy = EFalse;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::ProcessMessageL" );
+    }
+
+void CHtiIpProxyServicePlugin::NotifyMemoryChange( TInt aAvailableMemory )
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::NotifyMemoryChange" );
+
+    iBusy = ETrue;
+
+    TInt count = iOutgoingArray->Count();
+    if ( !count )
+        {
+        // No outgoing data
+        return;
+        }
+
+    // Calculate needed outgoing buffer size
+    TInt i = 0;
+    TInt neededSize = 0;
+    for ( ; i < count; ++i )
+        {
+        TInt size = ( *iOutgoingArray )[i].Size();
+        if ( neededSize + size <= aAvailableMemory )
+            {
+            neededSize += size;
+            }
+        }
+
+    if ( !neededSize )
+       {
+       // Not enough memory
+       return;
+       }
+
+    // Create an outgoing buffer and join as many buffers as possible
+    HBufC8* message = HBufC8::New( neededSize );
+    if ( !message )
+        {
+        // Not enough memory
+        return;
+        }
+
+    TPtr8 messagePtr( message->Des() );
+    for ( TInt j = 0; j < i; ++j )
+        {
+        messagePtr.Append( ( *iOutgoingArray )[j] );
+        }
+
+    // Dispatch message to HTI-Framework which takes the ownership of message
+    TInt err = iDispatcher->DispatchOutgoingMessage( message, KIpProxyServiceUid );
+    if ( err == KErrNone )
+        {
+        message = NULL;
+        iOutgoingArray->Delete( 0, i );
+        iDispatcher->RemoveMemoryObserver( this );
+        }
+    else if ( err != KErrNoMemory )
+        {
+        delete message;
+        iDispatcher->RemoveMemoryObserver( this );
+
+        __ASSERT_ALWAYS( iHostObserver, User::Panic( _L ( "IP-Proxy ECom-plugin" ), KErrBadHandle ) );
+        TRAP( err, iHostObserver->HostConnectionErrorL( err ) );
+        }
+
+    iBusy = EFalse;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::NotifyMemoryChange" );
+    }
+
+MSocket* CHtiIpProxyServicePlugin::GetSocket()
+    {
+    return this;
+    }
+
+MHostConnection* CHtiIpProxyServicePlugin::GetHostConnection()
+    {
+    return this;
+    }
+
+RSocket* CHtiIpProxyServicePlugin::GetRSocket()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::GetRSocket" );
+
+    RSocket* KSocket = NULL;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::GetRSocket" );
+    return KSocket;
+    }
+
+TUint CHtiIpProxyServicePlugin::LocalPort() const
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::LocalPort" );
+
+    const TUint KLocalPort = 0;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::LocalPort" );
+    return KLocalPort;
+    }
+
+TUint CHtiIpProxyServicePlugin::RemotePort() const
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::RemotePort" );
+
+    const TUint KRemotePort = 0;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::RemotePort" );
+    return KRemotePort;
+    }
+
+void CHtiIpProxyServicePlugin::SetObserver( MSocketObserver* aObserver )
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::SetObserver" );
+
+    iSocketObserver = aObserver;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::SetObserver" );
+    }
+
+void CHtiIpProxyServicePlugin::SetSocketOwnershipMode( TBool /* aHasOwnership */ )
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::SetSocketOwnershipMode" );
+
+    /* Empty implementation */
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::SetSocketOwnershipMode" );
+    }
+
+void CHtiIpProxyServicePlugin::IssueRead()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::IssueRead" );
+
+    /* Empty implementation */
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::IssueRead" );
+    }
+
+void CHtiIpProxyServicePlugin::Cancel()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::Cancel" );
+
+    /* Empty implementation */
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::Cancel" );
+    }
+
+void CHtiIpProxyServicePlugin::SocketInfo( TProtocolDesc& aDesc ) const
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::SocketInfo" );
+
+    aDesc.iProtocol = KProtocolInetTcp;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::SocketInfo" );
+    }
+
+TBool CHtiIpProxyServicePlugin::IsUDP() const
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::IsUDP" );
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::IsUDP" );
+    return EFalse;
+    }
+
+void CHtiIpProxyServicePlugin::WriteL( const TDesC8& aData )
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::WriteL" );
+
+    iBusy = ETrue;
+
+    // Dispatcher takes ownership of the message if no error has occured
+    HBufC8* message = aData.AllocL();
+    TInt err = iDispatcher->DispatchOutgoingMessage( message, KIpProxyServiceUid );
+    if ( err != KErrNone && err != KErrNoMemory )
+        {
+        // Some error occured while dispatching the message
+        delete message;
+        __ASSERT_ALWAYS( iHostObserver, User::Panic( _L ( "IP-Proxy ECom-plugin" ), KErrBadHandle ) );
+        iHostObserver->HostConnectionErrorL( err );
+        }
+    else if ( err == KErrNoMemory )
+        {
+        // No memory was available so add message to queue
+        delete message;
+        iOutgoingArray->AppendL( aData.Mid( 0 ) );
+        iDispatcher->AddMemoryObserver( this );
+        }
+
+    iBusy = EFalse;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::WriteL" );
+    }
+
+void CHtiIpProxyServicePlugin::IssueConnectL()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::IssueConnectL" );
+
+    iConnected = ETrue;
+
+    __ASSERT_ALWAYS( iHostObserver, User::Panic( _L ( "IP-Proxy ECom-plugin" ), KErrBadHandle ) );
+    iHostObserver->ConnectionEstablishedL();
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::IssueConnectL" );
+    }
+
+void CHtiIpProxyServicePlugin::IssueDisconnect()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::IssueDisconnect" );
+
+    __ASSERT_ALWAYS( iSocketObserver, User::Panic( _L ( "IP-Proxy ECom-plugin" ), KErrBadHandle ) );
+    TRAP_IGNORE( iSocketObserver->DisconnectedL( this ) );
+
+    iConnected = EFalse;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::IssueDisconnect" );
+    }
+
+void CHtiIpProxyServicePlugin::SetObserver( MHostConnectionObserver* aObserver )
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::SetObserver 2" );
+
+    iHostObserver = aObserver;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::SetObserver 2" );
+    }
+
+TBool CHtiIpProxyServicePlugin::IsConnected()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::IsConnected" );
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::IsConnected" );
+    return iConnected;
+    }
+
+RSocket* CHtiIpProxyServicePlugin::Socket()
+    {
+    HTI_LOG_FUNC_IN( "CHtiIpProxyServicePlugin::Socket" );
+
+    RSocket* KSocket = NULL;
+
+    HTI_LOG_FUNC_OUT( "CHtiIpProxyServicePlugin::Socket" );
+    return KSocket;
+    }