rgcp.h

《SymbianOSC手机应用开发》源码

// rgcp.h
//
// Copyright (c) 2000 Symbian Ltd.  All rights reserved
//

#ifndef __RGCP_H
#define __RGCP_H

#include "gsdp.h"

#include <s32std.h>
#include <s32mem.h>

const TUid KUidRgcp = { 0x10005409 };

class MRgcpHandler
	{
public:
	virtual void RgcpHandleResponse(TInt aOpcode, const TDesC8& aData)=0;
	virtual void RgcpHandleRequest(TInt aOpcode, const TDesC8& aData)=0;
	virtual void RgcpHandleTerminated(TBool aClientInitiated)=0;
	virtual void RgcpHandleBound()=0;
	virtual void RgcpStartRequesting()=0;
	};

class CRgcpSession : public CBase, public MGsdpPacketHandler
	{
public:
	enum TState {
		EBlank, EListening, EInitiating, EResponding, ERequesting, EWaiting, 
		};
	enum TOpcode {
		EReserved=0,
		EInitiate=0xff,
		ETerminate=0xfe
		};
public:
	// construct/destruct
	IMPORT_C CRgcpSession();
	IMPORT_C void ConstructL(TUint32 aGameProtocol);
	IMPORT_C ~CRgcpSession();
	IMPORT_C void SetHandler(MRgcpHandler* aHandler);
	// initialization
	IMPORT_C void SetGdpProtocolL(TUid aGdpProtocol);
	// state
	inline TState State() const;
	inline TBool IsBlank() const;
	inline TBool IsInitiating() const;
	inline TBool IsListening() const;
	inline TBool IsResponding() const;
	inline TBool IsRequesting() const;
	inline TBool IsWaiting() const;
	inline TBool IsBound() const;
	// state transitioning functions
	IMPORT_C void Initiate(const TDesC8& aOtherAddress);
	IMPORT_C void Listen();
	IMPORT_C void Terminate();
	IMPORT_C void SendResponse(TInt aOpcode, const TDesC8& aData);
	IMPORT_C void SendResponse(TInt aOpcode);
	IMPORT_C void SendResponse();
	IMPORT_C void SendRequest(TInt aOpcode, const TDesC8& aData);
	IMPORT_C void SendRequest(TInt aOpcode);
	IMPORT_C void Resend();
	// persistence
	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
	IMPORT_C void InternalizeL(RReadStream& aStream);
	IMPORT_C TStreamId StoreL(CStreamStore& aStore) const;
	IMPORT_C void RestoreL(const CStreamStore& aStore, TStreamId aStreamId);
	// access to GSDP stuff
	inline const RGsdpSession& Gsdp() const;
private:
	// help with sending
	void DoSendRequest(TInt aOpcode, const TDesC8& aData);
	void DoSendResponse(TInt aOpcode, const TDesC8& aData);
	void DoTerminate(TBool aClientInitiated);
	// handle incoming datagrams
	void GsdpHandleL(const TDesC8& aData);
	void CrackPacketL(const TDesC8& aData, TInt& aSeqNo, TInt& aResponseOpcode, TInt& aRequestOpcode);
	void HandlePacket(TInt aSeqNo, TInt aResponseOpcode, TInt aRequestOpcode);
	void HandleTerminateRequest();
	void HandleInitiateRequest();
private:
	TState iState;
	RGsdpSession iGsdp;
	MRgcpHandler* iHandler;
	// send apparatus
	TInt iNextSendSequenceNo;
	RDesWriteStream iSendWriter;
	TBuf8<KMaxGsdpData> iSendBuffer;
	// receive apparatus
	TInt iLastReceivedSequenceNo;
	TBuf8<KMaxGsdpData> iReceiveBuffer;
	TBuf8<126> iResponse; // rather wasteful
	TBuf8<126> iRequest; // rather wasteful
	};

// inlines

CRgcpSession::TState CRgcpSession::State() const { return iState; }

TBool CRgcpSession::IsBlank() const { return iState==EBlank; }
TBool CRgcpSession::IsInitiating() const { return iState==EInitiating; }
TBool CRgcpSession::IsListening() const { return iState==EListening; }
TBool CRgcpSession::IsResponding() const { return iState==EResponding; }
TBool CRgcpSession::IsRequesting() const { return iState==ERequesting; }
TBool CRgcpSession::IsWaiting() const { return iState==EWaiting; }

TBool CRgcpSession::IsBound() const { return IsResponding() || IsRequesting() || IsWaiting(); }

const RGsdpSession& CRgcpSession::Gsdp() const { return iGsdp; }

#endif