Mark symbol as ABSENT, to complete the GCCE bringup of pppmain.dll - added to Bug 2629
// Copyright (c) 2005-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
*/
#if !defined(__SHIMNIFMANSCONN_H__)
#define __SHIMNIFMANSCONN_H__
#include <comms-infras/ss_log.h>
#include "shimdatatransfer.h"
#include "shimclient.h"
#include "shimcpr.h" //access to the CConnectionProviderShim::Provider() fn
//const TInt KSubConnectionProviderShimImplementationUid = 0x10207106;
#define KShimScprTag KESockSubConnectionTag
_LIT8(KShimScprSubTag, "shimscpr");
_LIT8(KShimScprDataTag, "shimscprData");
_LIT8(KShimScprClientTag, "shimscprClient");
//Former CInterface CSubConnection related up-calls so that CConnectionProviderShim
//doesn't have to link against the sub-connection shim
class CConnection;
class MSubInterfaceShim : public MConnDataTransferNotify
{
public:
virtual TInt ProgressNotification(TInt aStage, TInt aError, const TDesC8& aInfo) = 0;
virtual TSubConnectionUniqueId Id() = 0;
virtual void SetSubConnectionUniqueId( TSubConnectionUniqueId aSubConnectionUniqueId ) = 0;
virtual void ConnectionJoiningL(const CConnection& aConnection) = 0;
virtual void ConnectionLeaving(const CConnection& aConnection) = 0;
};
//class CSubConnectionProviderFactoryShim;
class CSubConnectionLinkShimClient;
NONSHARABLE_CLASS(CNifManSubConnectionShim) : public CBase, public MConnectionDataClient, public MSubInterfaceShim
/**
@internalComponent
*/
{
public:
CNifManSubConnectionShim(CConnectionProviderShim& aProviderShim);
~CNifManSubConnectionShim();
// MSubInterfaceShim impl
virtual TInt ProgressNotification(TInt aStage, TInt aError, const TDesC8& aInfo);
virtual TInt NotifyDataTransferred(TUint aUplinkVolume, TUint aDownlinkVolume);
virtual TInt NotifyDataSent(TUint aUplinkVolume, TUint aCurrentGranularity);
virtual TInt NotifyDataReceived(TUint aDownlinkVolume, TUint aCurrentGranularity);
virtual TSubConnectionUniqueId Id();
virtual void SetSubConnectionUniqueId( TSubConnectionUniqueId aSubConnectionUniqueId );
virtual void ConnectionJoiningL(const CConnection& aConnection);
virtual void ConnectionLeaving(const CConnection& aConnection);
CConnectionProvdBase& Provider()
{
return static_cast<CConnectionProviderShim*>(iConnectionProvider)->Provider();
}
CConnDataTransferShim* DataTransferShim()
{
return iConnDataTransferShim;
}
CSubConnectionLinkShimClient* ShimClient( TInt aIndex )
{
return aIndex < iShimClients.Count() ? iShimClients[aIndex] : NULL;
}
void DeleteAsync();
protected:
//MConnectionDataClient
virtual void ConnectionGoingDown(CConnectionProviderBase& aConnProvider);
virtual void ConnectionError(TInt aStage, TInt aError);
virtual void Notify(TNotify aNotifyType, CConnectionProviderBase* aConnProvider, TInt aError, const CConNotificationEvent* aConNotificationEvent);
virtual void AttachToNext(CSubConnectionProviderBase* aSubConnProvider);
TInt FindClient(const CConnection& aConnection);
CConnDataTransfer& CreateDataTransferL();
protected:
RPointerArray<CSubConnectionLinkShimClient> iShimClients;
TSubConnectionUniqueId iSubConnectionsUniqueId;
CConnDataTransferShim* iConnDataTransferShim;
CConnectionProviderBase* iConnectionProvider;
CAsyncCallBack iAsyncDestructor;
private:
static TInt AsyncDestructorCb(TAny* aInstance);
};
NONSHARABLE_CLASS(CSubConnectionLinkShimClient) : public CBase, public MConnDataTransferNotify, public MShimControlClient
/**
Handle subconnection-related asynchronous client requests that may not complete immediately, it effectively
represents the old CSubConnection
@internalComponent
*/
{
public:
CSubConnectionLinkShimClient(const CConnection& aConnection, CNifManSubConnectionShim& aSubConnectionShim);
~CSubConnectionLinkShimClient();
//MConnDataTransferNotify interface towards CConnDataTransfer
virtual TInt NotifyDataTransferred(const TUint aUplinkVolume, const TUint aDownlinkVolume);
virtual TInt NotifyDataSent(TUint aUplinkVolume, TUint aCurrentGranularity);
virtual TInt NotifyDataReceived(TUint aDownlinkVolume, TUint aCurrentGranularity);
void ProgressNotification(TInt aStage, TInt aError, const TDesC8& aInfo);
//MShimControlClient interface towards ESOCK
//former CConnection::StopSubConnectionL(const RMessage2& aMessage);
virtual TBool StopL(const RMessage2& aMessage);
// Former calls from CConnection::GetSubConnectionInfo
virtual TInt GetSubConnectionInfo(const RMessage2& aMessage);
// Former Calls from RConnection via CSubConnection
virtual TInt GetCurrentProgress(TNifProgress& aProgress);
virtual TBool DataTransferredL(const RMessage2& aMessage);
virtual TBool DataTransferredCancel(const RMessage2& aMessage);
virtual TBool RequestSubConnectionProgressNotificationL(const RMessage2& aMessage);
virtual TBool CancelSubConnectionProgressNotification(const RMessage2& aMessage);
virtual TBool DataSentNotificationRequestL(const RMessage2& aMessage);
virtual TBool DataSentNotificationCancel(const RMessage2& aMessage);
virtual TBool DataReceivedNotificationRequestL(const RMessage2& aMessage);
virtual TBool DataReceivedNotificationCancel(const RMessage2& aMessage);
virtual TBool IsSubConnectionActiveRequestL(const RMessage2& aMessage);
virtual TBool IsSubConnectionActiveCancel(const RMessage2& aMessage);
TBool Match(const CConnection& aConnection) const;
TSubConnectionUniqueId Id();
virtual TInt ReturnCode() const;
void SetReturnCode(TInt aErr)
{
iReturnCode = aErr;
}
/**
Callback from activity timer
*/
void CheckSubConnectionActivity();
NONSHARABLE_CLASS(CActivityTimer) : public CTimer
/**
@internalComponent
*/
{
public:
static CActivityTimer* NewL(CSubConnectionLinkShimClient* aOwner, TInt aPriority);
virtual inline ~CActivityTimer() {};
void RunL();
private:
inline CActivityTimer(CSubConnectionLinkShimClient* aOwner, TInt aPriority);
private:
CSubConnectionLinkShimClient* iOwner;
};
private:
const CConnection& iConnection;
CNifManSubConnectionShim& iSubConnectionShim;
TUint iUplinkDataVolume;
TUint iDownlinkDataVolume;
TUint iUplinkDataNotificationVolume;
TUint iDownlinkDataNotificationVolume;
TInt iRemainingUplinkGranularity;
TInt iRemainingDownlinkGranularity;
TBool iDataSentNotificationsInAbsoluteMode;
TBool iDataReceivedNotificationsInAbsoluteMode;
TNifProgress iCurrentProgress;
TInt iLastProgressToClient;
TInt iClientRequestedProgress;
CActivityTimer* iActivityTimer;
TInt iRequestedClientTimerPeriod;
TBool iClientBelievesSubConnectionActive;
TUint iPreviousUplinkDataVolume;
TUint iPreviousDownlinkDataVolume;
TBool iOutstandingProgressNotification:1;
TBool iOutstandingDataSentNotification:1;
TBool iOutstandingDataReceivedNotification:1;
TBool iOutstandingSubConnectionActivity:1;
RMessage2 iOutstandingProgressNotificationMessage;
RMessage2 iOutstandingDataSentNotificationMessage;
RMessage2 iOutstandingDataReceivedNotificationMessage;
RMessage2 iOutstandingSubConnectionActivityMessage;
TInt iReturnCode;
};
inline CSubConnectionLinkShimClient::CActivityTimer::CActivityTimer(CSubConnectionLinkShimClient* aOwner, TInt aPriority)
: CTimer(aPriority), iOwner(aOwner)
/**
Set up the activity timer for subconnection activity
@param aOwner, The owing subconnection
@param aPriority, The priority of the active object
*/
{ CActiveScheduler::Add(this); };
#endif
// __SHIMNIFMANSCONN_H__