/*
* Copyright (c) 2002-2005 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: Header declaration
*
*/
#ifndef SEN_CHUNK_H
#define SEN_CHUNK_H
// INCLUDES
#include <e32base.h>
#include <flogger.h>
#include <f32file.h>
#include <MSenMessage.h>
#include <MSenProperties.h>
// Min size for new RChunk allocations:
const TInt KSenMinRChunkSize = 0x2750; // 10064 bytes
// Max size for new RChunk allocations:
const TInt KSenMaxRChunkSize = 0x400000; // 4194304 bytes
// FORWARD DECLARE
class CSenChunk;
// CLASS DECLARATION
class TChunkHeader
/**
* This class is set in the beginning of the RChunk. Class is used
* to store header information.
*
* Note: All data in here must be 4-byte aligned (using dummy values
* if needed)
*/
{
public:
/**
* Getter for message class enumeration
* @return message type enumeration
* @see MSenMessage.h
*/
inline MSenMessage::TClass MessageType() const
{
return (MSenMessage::TClass)iMessageType;
}
/**
* Setter for message class enumeration
* @param aValue defines the message class type enumeration.
* @see MSenMessage.h
*/
inline void SetMessageType(MSenMessage::TClass aType)
{
iMessageType = (TInt)aType;
}
/**
* Getter for message direction enumeration
* @return message type enumeration
* @see MSenMessage.h
*/
inline MSenMessage::TDirection MessageDirection() const
{
return (MSenMessage::TDirection)iMessageDirection;
}
/**
* Setter for message direction enumeration
* @param aValue defines the message class type enumeration.
* @see MSenMessage.h
*/
inline void SetMessageDirection(MSenMessage::TDirection aDirection)
{
iMessageDirection = (TInt)aDirection;
}
/**
* Getter to determine should init be done before sending the message.
* @return ETrue if yes, otherwise EFalse.
*/
inline TBool DoInitBeforeSending() const
{
if ( iDoInitBeforeSending )
{
return ETrue;
}
else
{
return EFalse;
}
}
/**
* Sets the flag indicating that init should be done
* before sending the message
* @param aValue if ETrue, init will be done before sending
* if EFalse, init will not be done before sending
*/
inline void SetDoInitBeforeSending(TBool aValue)
{
if ( aValue )
{
iDoInitBeforeSending = 1;
}
else
{
iDoInitBeforeSending = 0;
}
// iDoInitBeforeSending = aValue;
}
/**
* Getter for (transport) properties type.
* @return transport properties type
* enumeration. Note:
* ENotInUse means that transport
* properties are not in use.
* @see MSenProperties
*/
inline MSenProperties::TSenPropertiesClassType PropertiesType() const
{
return (MSenProperties::TSenPropertiesClassType)iPropertiesType;
}
/**
* Sets the (transport) properties type enumeration
* @param aType where ENotInUse indicates that
* there are no associated properties, and all
* the others point to a concrete properties
* class.
* @see MSenProperties
*/
inline void SetPropertiesType(MSenProperties::TSenPropertiesClassType aType)
{
iPropertiesType = (TInt)aType;
}
/**
* Getter for descriptor count.
* @return the descriptor count
*/
inline TInt DescriptorCount() const
{
return iDescriptorCount;
}
/**
* Setter for descriptor count.
* @param aCount is the descriptor count
*/
inline void SetDescriptorCount(TInt aCount)
{
iDescriptorCount = aCount;
}
/**
* Getter for transaction id.
* @return the transaction id
*/
inline TInt TransactionId() const
{
return iTransactionId;
}
/**
* Setter for transaction id.
* @param aID is the transaction id
*/
inline void SetTransactionId(TInt aId)
{
iTransactionId = aId;
}
/**
* Getter for ctx id.
* @return the ctx id
*/
inline TInt ContextId() const
{
return iContextId;
}
/**
* Setter for ctx id.
* @param aID is the ctx id
*/
inline void SetContextId(TInt aId)
{
iContextId = aId;
}
/**
* Getter for pending transaction id.
* @return the pending transaction id
*/
inline TInt PendingTransactionId() const
{
return iPendingTransactionId;
}
/**
* Setter for pending transaction id.
* @param aCount is the pending transaction id
*/
inline void SetPendingTransactionId(TInt aId)
{
iPendingTransactionId = aId;
}
private:
/*MSenMessage::TClass*/ TInt iMessageType;
/*MSenMessage::TDirection*/ TInt iMessageDirection;
/*TBool*/ TInt iDoInitBeforeSending;
/*MSenProperties::TSenPropertiesClassType*/ TInt iPropertiesType;
TInt iDescriptorCount;
TInt iTransactionId;
TInt iPendingTransactionId;
TInt iContextId;
};
/**
* Offset to the beginning of header
*/
const TInt KHeaderOffset = 0;
/**
* Offset to the beginning of data
*/
const TInt KDataOffset = KHeaderOffset + sizeof(TChunkHeader);
// CLASS DECLARATION
class CSenChunk : public CBase
{
/**
* Helper class for storing RChunks
*/
public:
/**
* Two-phased constructor.
* @since Series60 4.0
* @param aChunkName is the chunk name.
* @return a new CSenChunk
*/
IMPORT_C static CSenChunk* NewL(const TDesC& aChunkName);
/**
* Two-phased constructor.
* @since Series60 4.0
* @param aChunkName is the chunk name.
* @return a new CSenChunk
*/
IMPORT_C static CSenChunk* NewLC(const TDesC& aChunkName);
/**
* Destructor.
*/
IMPORT_C ~CSenChunk();
/**
* @since Series60 4.0
* @return a reference to internal chunk
*/
IMPORT_C RChunk& Chunk();
/**
* @since Series60 4.0
* @return a pointer to ChunkName
*/
IMPORT_C TPtrC ChunkName() const;
/**
* Creates global protected RChunk inside CSenChunk
* @since Series60 4.0
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt CreateChunk();
/**
* Opens global protected RChunk inside CSenChunk
* @since Series60 4.0
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt OpenChunk();
/**
* Closes RChunk inside CSenChunk
* @since Series60 4.0
*/
IMPORT_C void CloseChunk();
/**
* Changes the number of bytes committed to the internal chunk.
* This value is always rounded up to the next nearest processor
* page boundary.
* This value is rounded up to KSenMinRChunkSize if value is
* less than KSenMinRChunkSize.
* @since Series60 4.0
* @param aNewSize The number of bytes to be committed to this chunk.
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt AdjustChunk(TInt aNewSize);
/**
* @since Series60 4.0
* @return a header of the internal chunk
*/
IMPORT_C TChunkHeader& ChunkHeader();
/**
* Stores given descriptor into internal chunk.
* Internal chunk is tried to adjust so that given descriptor
* fits into chunk.
* @since Series60 4.0
* @param aDesc is the descriptor to store
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt DescToChunk(const TDesC8& aDesc);
/**
* Stores given descriptor into internal chunk.
* Internal chunk is tried to adjust so that given descriptor
* fits into chunk.
* @since Series60 4.0
* @param aDesc is the descriptor to store
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt DescToChunk(const TDesC8& aDesc, TInt aIndex);
/**
* Changes the number of bytes committed to the internal chunk
* and places a pointer to chunk to apAllocated.
* Size is always rounded up to the next nearest processor
* page boundary.
* Size is rounded up to KSenMinRChunkSize if given size is
* less than KSenMinRChunkSize.
* @since Series60 4.0
* @param aSize The number of bytes to be committed to this chunk.
* @param apAllocated
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt AllocDescToChunk(TInt aSize, TPtr8*& apAllocated);
/**
* Stores given descriptors into internal chunk.
* Internal chunk is tried to adjust so that both of the
* given descriptors fit into chunk.
* @since Series60 4.0
* @param aDesc is the first descriptor to store
* @param aDesc2 is the second descriptor to store
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt DescsToChunk(const TDesC8& aDesc,
const TDesC8& aDesc2);
/**
* Gets stored descriptor in given index from internal chunk.
* @since Series60 4.0
* @param aDesc will hold the pointer to descriptor in internal chunk
* @param aIndex is the index of descriptor to get
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt DescFromChunk(TPtrC8& aDesc, TInt aIndex = 0);
/**
* Gets stored descriptors from internal chunk.
* @since Series60 4.0
* @param aDesc1 will hold the pointer to the first descriptor in internal chunk
* @param aDesc2 will hold the pointer to the second descriptor in internal chunk
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt DescsFromChunk(TPtrC8& aDesc1, TPtrC8& aDesc2);
/**
* Sets an internal chunk into TIpcArgs into given po.
* @since Series60 4.0
* @param aArgs The IPC message arguments
* @param aIndex An index value that identifies the slot in the array
* of arguments into which the chunk is to be
* placed. This must be a value in the range 0 to 3.
*/
IMPORT_C void ChunkToArgs(TIpcArgs& aArgs, TInt aIndex);
/**
* Opens internal chunk using a handle number sent by a client to a server.
* This function is called by the server.
* @since Series60 4.0
* @param aMessage Represents the contents of the client message
* @param aIndex An index specifying which of the four message arguments
* contains the handle number.
* @return KErrNone or some system-wide Symbian error codes.
*/
IMPORT_C TInt OpenChunkFromRMsgL(const RMessage2& aMessage, TInt aIndex);
/**
* Opens internal chunk using a handle number returned by a server to a client.
* This function is called by the client.
* @since Series60 4.0
* @param aHandleOrError A handle-number, if zero or positive;
* an error value, if negative.
* @return KErrNone, if aHandle is a handle-number;
* the value of aHandleOrError, otherwise..
*/
IMPORT_C TInt OpenChunkFromHandleNumberL(TInt aHandleOrError);
/**
* Tests whether two CSenChunks are equal.
* @since Series60 4.0
* @param aChunk The SenChunk to be compared with this SenChunk
* @return True if the two SenChunks are equal. False if not.
*/
IMPORT_C TBool operator==(const CSenChunk& aChunk);
/**
* Sets the file logger used for debug messages.
* @since Series60 4.0
* @param aLog is the file logger
*/
IMPORT_C void SetLogger(RFileLogger* aLog);
/**
* Gets the Rfile Pointer to CHUNK to send content by HTTP:POST
* @since Series60
*/
IMPORT_C RFile& RequestFileHandle();
/**
* Sets the Rfile Pointer to CHUNK to send content by HTTP:POST
* @since Series60
*/
IMPORT_C void RequestFileHandle(RFile& aFile);
protected: // Helper functions
/**
* @since Series60 4.0
* @return Pointer to the file logger
*/
IMPORT_C RFileLogger* Log() const;
/**
* Constructor.
*/
IMPORT_C CSenChunk();
private:
/**
* This private helper ensures that cast address is dividable by four (MANDATORY in ARMv5 environment, for example)
*/
TUint8* RoundToNextDividableByFourAddress(TUint8* aValue);
/**
* Basic ConstructL function
* @since Series60 4.0
* @param aChunkName is the chunk name.
*/
void ConstructL(const TDesC& aChunkName);
protected: // Data
HBufC* ipChunkName;
private: // Data
RChunk iChunk;
RFileLogger* iLog;
RFile iFile;
};
#endif //R_SEN_SERVICE_CONNECTION_H