--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/obex/obexprotocol/obextransport/src/ObexReaderBase.cpp Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,243 @@
+// 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:
+//
+
+#include <obex/transport/obexreaderbase.h>
+#include <obex/internal/obexpacket.h>
+#include <obex/transport/mobextransportnotify.h>
+#include "logger.h"
+
+#ifdef __FLOG_ACTIVE
+_LIT8(KLogComponent, "OBEXCT");
+#endif
+
+/**
+*Constructor
+*/
+EXPORT_C CObexReaderBase::CObexReaderBase(TPriority aPriority,
+ MObexTransportNotify& aOwner,
+ TObexConnectionInfo& aInfo)
+ : CObexActiveRW (aPriority, aOwner, aInfo)
+ {
+ LOG_LINE
+ LOG_FUNC
+ }
+
+/**
+* Destructor
+*/
+EXPORT_C CObexReaderBase::~CObexReaderBase()
+ {
+ LOG_LINE
+ LOG_FUNC
+
+ Cancel();
+ }
+
+/**
+This function is a place holder for future use. If the iFuture1 variable is
+used it will need this function for any allocation required.
+
+To prevent binary compatiblity breaks if the iFuture1 variable is used, this
+function must be called from the
+NewL of derived classes.
+*/
+EXPORT_C void CObexReaderBase::BaseConstructL()
+ {
+ LOG_LINE
+ LOG_FUNC
+ }
+
+/**
+Start transfer. Calls into CObexActiveRW, which eventually queues a read
+
+@param aPacket The Obex packet to read into.
+*/
+EXPORT_C void CObexReaderBase::StartTransfer (CObexPacket& aPacket)
+ {
+ LOG_LINE
+ LOG_FUNC
+
+ // Ensure that we don't try to queue two reads at once (this should probably
+ // never happen anyway).
+ if (IsActive())
+ {
+ FLOG(_L("\treturning because already active..."));
+ return;
+ }
+ iGotHeader = EFalse;
+ // Initial packet size indicates how much data we should ask for on the
+ // first read
+ // Packet & stream based transports do the same thing here due to ESOCK
+ // flexibility.
+ // See Remaining() and CompleteTransfer() for a clearer picture
+ iPacketSize = 0;
+ aPacket.Init(0);
+ NewRequest (aPacket);
+ }
+
+/**
+Check if the packet read is complete
+@return ETrue if the read is complete. EFalse otherwise.
+*/
+EXPORT_C TBool CObexReaderBase::CompleteTransfer ()
+ {
+ LOG_LINE
+ LOG_FUNC
+
+ iTransferError = KErrNone;
+
+ // Can't check anything until we have at least the OBEX packet header
+ if (iCount >= KObexPacketHeaderSize)
+ {// iCount is the number of bytes read thus far
+ if (!iGotHeader)
+ {
+ iPacketSize = iPacket->PacketSize ();
+
+ // Check packet's claimed size is at least as big as the header just sent
+ if ( iPacketSize < KObexPacketHeaderSize )
+ {
+ iTransferError = KErrCommsFrame;
+ return ETrue;
+ }
+ TInt maxPacketSize = GetMaxPacketSize();
+ LOG1(_L8("\taMaxPacketSize = %d"), maxPacketSize);
+ if (iPacketSize > maxPacketSize)
+ {// The peer is sending us a packet thats too large for us
+ iTransferError = KErrCommsFrame;
+ return (ETrue);
+ }
+ iGotHeader = ETrue;
+ OnReadActivity();
+ }
+
+
+ if (iCount >= iPacketSize)
+ {// We've got the whole packet.
+ return (ETrue);
+ }
+ }
+ return (EFalse);
+
+ }
+
+/**
+ Called when read activity is detected.
+ This method will certainly be called when read activity is
+ first detected on an Obex operation, and it may be called
+ from time to time thereafter until that Obex operation is
+ completed.
+*/
+EXPORT_C void CObexReaderBase::OnReadActivity()
+ {
+ iOwner.SignalPacketProcessEvent(EObexReadActivityDetected);
+ }
+
+/** Performs any actions necessary on completion of a read.
+*/
+EXPORT_C void CObexReaderBase::OnCompleteTransfer()
+ {
+ if(iTransferError)
+ {
+ iOwner.Error(iTransferError);
+ }
+ else
+ {
+ iOwner.Process(*iPacket);
+ }
+ }
+
+/*
+Returns the number of bytes remaining to be read based on the default packet
+size if the packet size is unknown, otherwise based on the packet size
+
+@return TInt the number of bytes remaining to be read
+*/
+EXPORT_C TInt CObexReaderBase::Remaining()
+ {
+ LOG_LINE
+ LOG_FUNC
+
+
+ TInt remaining;
+
+ if (iPacketSize == 0)
+ {
+ // If we don't know the size of the packet yet, ask for as much as
+ // an initial or default size (-iCount) specifies
+ TInt defaultPacketSize = GetInitialPacketSize();
+ LOG1(_L8("\taRemainingLimit = %d"), defaultPacketSize);
+ remaining = defaultPacketSize - iCount;
+ }
+ else
+ {
+ remaining = iPacketSize - iCount;
+ }
+
+ if (remaining < 0)
+ {
+ remaining = 0;
+ }
+
+ return remaining;
+ }
+
+/**
+This function returns the buffer size of the read packet.
+
+@return TInt the size of the buffer held by the iPacket member variable
+*/
+EXPORT_C TInt CObexReaderBase::GetObexPacketBufferSize()
+ {
+ return iPacket->BufferSize();
+ }
+
+/**
+This function returns the size of the obex packet's header
+
+@return TInt the size of the obex header
+*/
+EXPORT_C TInt CObexReaderBase::GetObexPacketHeaderSize()
+ {
+ return KObexPacketHeaderSize;
+ }
+
+/**
+This function return the maximum limit the received data can be
+
+@return TInt the data limit of the obex packet
+*/
+EXPORT_C TInt CObexReaderBase::GetObexPacketDataLimit()
+ {
+ return iPacket->DataLimit();
+ }
+
+/**
+This function is part of the extension pattern and is implemented by all
+derived instantiable classes that need to extend it's interface.
+
+By default this returns null. Any derived class that is required to extend its
+interface and that of this base class returns its new interface in the form of
+an M class, that it extends, if and only if the corresponding TUid, aUid, is
+received. Otherwise the function calls the base class implementation,
+returning NULL.
+
+@return TAny* The M Class representing the extension to the interface
+otherwise NULL
+@param aUid The uid associated with the M Class that is being implemented
+*/
+EXPORT_C TAny* CObexReaderBase::GetInterface(TUid /*aUid*/)
+ {
+ return NULL;
+ }