--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/locationcentre/lcutils/src/lcipcparams.cpp Tue Feb 02 00:16:03 2010 +0200
@@ -0,0 +1,581 @@
+/*
+* Copyright (c) 2007 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: Parameters for the IPC message handling between the
+* Location Centre API and Location Centre Server.
+*
+*/
+
+
+// SYSTEM INCLUDES
+#include <e32std.h>
+
+// USER INCLUDES
+#include "lcipcparams.h"
+
+// CONSTANT DEFINITIONS
+const TInt KSizeofTUint32 = sizeof( TUint32 );
+
+// ----- Member funtions for RLcIpcAppIdArray --------------------------------
+
+// ---------------------------------------------------------------------------
+// void RLcIpcAppIdArray::ExternalizeL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void RLcIpcAppIdArray::ExternalizeL( RWriteStream& aWriteStream )
+ {
+ // The format for packing the buffer would be as follows
+ // Count | Length1 | ID1 | Length2 | ID2 | ...
+ // where
+ // Count - The number of strings which would be packed
+ // Length1 - The Length of the first Identifier string
+ // ID1 - First Identifier
+ // Length2 - The Length of the second Identifier string
+ // ID2 - Second Identifier.
+ // ...
+
+ const TInt count = Count();
+ // First pack the number of elements in the array. Even if there is no
+ // elements pack a 0
+
+ aWriteStream.WriteUint32L( Count());
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ // Obtain the element at position i
+ HBufC* element = ( *this )[i];
+
+ // As per the grammar first pack the length and then pack the string
+ TInt length = element->Des().Length();
+ aWriteStream.WriteUint32L( length );
+
+ // Now pack the identifier
+ aWriteStream.WriteL( element->Des(), length );
+ }
+
+ aWriteStream.CommitL();
+ }
+
+// ---------------------------------------------------------------------------
+// void RLcIpcAppIdArray::InternalizeL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void RLcIpcAppIdArray::InternalizeL( RReadStream& aReadStream )
+ {
+ // Clean up all the elements in the array so that the previous internalized
+ // structure would be removed.
+ ResetAndDestroy();
+
+ // The first element in the array is the Count variable which indicates
+ // the number of elements in this array.
+ const TUint32 count = aReadStream.ReadUint32L();
+
+ // Even a string containing no elements is acceptable.
+ for ( TInt i = 0; i < count; i++ )
+ {
+ // First read the length of the Identifer
+ TUint32 length = aReadStream.ReadUint32L();
+ if ( length >= KMaxTInt/2 )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ // Now create a buffer to read the actual identifier name. The length
+ // of the buffer would be defined by the length value. Use this buffer
+ // read the identifier.
+ HBufC* buffer = HBufC::NewLC( length );
+ TPtr bufferPtr( buffer->Des());
+
+ aReadStream.ReadL( bufferPtr, length );
+
+ // Transfer the ownership of the buffer to this array.
+ User::LeaveIfError( Append( buffer ));
+ CleanupStack::Pop( buffer );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// void RLcIpcAppIdArray::BufferLength
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt RLcIpcAppIdArray::BufferLength()
+ {
+ TInt length = 0;
+
+ // Pack the Length for including the length of Count buffer
+ length += KSizeofTUint32;
+
+ // Even a string containing no elements is acceptable.
+ for ( TInt i = 0; i < Count(); i++ )
+ {
+ // First 4 bytes for the Length of the string
+ length += KSizeofTUint32;
+
+ // Now pack the length for the buffer
+ length += ( *this )[i]->Des().Size();
+ }
+ return length;
+ }
+
+// ---------------------------------------------------------------------------
+// void RLcIpcAppIdArray::ResetAndDestroyIdArray
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void RLcIpcAppIdArray::ResetAndDestroyIdArray( TAny* aIdArray )
+ {
+ RLcIpcAppIdArray* array = reinterpret_cast< RLcIpcAppIdArray* >( aIdArray );
+ if ( array )
+ {
+ array->ResetAndDestroy();
+ }
+
+ }
+
+
+// ----- Member funtions for RLcIpcAppIdArray --------------------------------
+
+// ---------------------------------------------------------------------------
+// void RLcIpcAppInfoArray::ExternalizeL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void RLcIpcAppInfoArray::ExternalizeL( RWriteStream& aWriteStream )
+ {
+ // The format for packing the buffer would be as follows
+ // Count | IDLength | ID | NameLength | Name | Launch mode | Sys Characteristics |
+ // Application Characteristics
+ // where
+ // Count - The number of structures which would be packed
+ // IDLength - The Length of the Identifier string
+ // ID - Application Identifier
+ // NameLength - The Length of the name string
+ // Name - Application Name.
+ // IconFile Length - Length of the Icon file name.
+ // Icon File - Full path of the icon file with file name
+ // IconFile Type - The Icon file type
+ // Frame No - The Frame no of the icon if the icon file is a MIF
+ // file
+ // Launch Mode - Launching mode of the application
+ // Sys Char - System characteristics
+ // App Char - Application characteristics
+ // These elements are repeated for all Application information structures.
+
+ const TInt count = Count();
+ // First pack the number of elements in the array. Even if there is no
+ // elements pack a 0
+
+ aWriteStream.WriteUint32L( Count());
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ // Obtain the element at position i
+ CLcAppInfo* element = ( *this )[i];
+
+ // Externalize the parent class first and then externalize the child
+ element->ExternalizeL( aWriteStream );
+ }
+
+ aWriteStream.CommitL();
+ }
+
+// ---------------------------------------------------------------------------
+// void RLcIpcAppIdArray::InternalizeL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void RLcIpcAppInfoArray::InternalizeL( RReadStream& aReadStream )
+ {
+ // Clean up all the elements in the array so that the previous internalized
+ // structure would be removed.
+ ResetAndDestroy();
+
+ // The first element in the array is the Count variable which indicates
+ // the number of elements in this array.
+ const TUint32 count = aReadStream.ReadUint32L();
+
+ // Even a string containing no elements is acceptable.
+ for ( TInt i = 0; i < count; i++ )
+ {
+
+ // Create a new CLcAppInfo element
+ CLcAppInfo* element = CLcAppInfo::NewLC();
+
+ // Internalize the Parent class first and then proceed to the child
+ element->InternalizeL( aReadStream );
+
+ // Transfer the ownership of the buffer to this array.
+ User::LeaveIfError( Append( element ));
+ CleanupStack::Pop( element );
+
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// TInt RLcIpcAppInfoArray::BufferLength
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt RLcIpcAppInfoArray::BufferLength()
+ {
+ TInt length = 0;
+
+ // Pack the length for the Count field.
+ length += KSizeofTUint32;
+
+ // Pack the length required for the individual app structures
+
+ TInt count = Count();
+ for ( TInt i = 0; i < count; i++ )
+ {
+ // Obtain the element at position i
+ CLcAppInfo* element = ( *this )[i];
+
+ // Pack the length required for this element
+ length += element->BufferLength();
+ }
+
+ return length;
+ }
+
+// ---------------------------------------------------------------------------
+// void RLcIpcAppIdArray::ResetAndDestroyIdArray
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void RLcIpcAppInfoArray::ResetAndDestroyAppArray( TAny* aIdArray )
+ {
+ RLcIpcAppInfoArray* array = reinterpret_cast< RLcIpcAppInfoArray* >( aIdArray );
+ if ( array )
+ {
+ array->ResetAndDestroy();
+ }
+ }
+
+// ----- Member funtions for CLcBasicAppInfo ---------------------------------
+
+// ---------------------------------------------------------------------------
+// void CLcBasicAppInfo::ExternalizeL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CLcBasicAppInfo::ExternalizeL( RWriteStream& aWriteStream )
+ {
+ // The format for packing the buffer would be as follows
+ // Application Type | DataLength | Data | CmdLength | Cmd
+ // where
+ // Application Type - The type of the Application which is stored in the
+ // structure.
+ // DataLength - The Length of the Application data string
+ // Data - Application Data
+ // CmdLength - The Length of the command line arguments
+ // Cmd - Command line arguments
+
+ // First pack the Application type
+
+ aWriteStream.WriteUint32L( iAppType );
+
+ // Pack the Launching mode of the application
+ aWriteStream.WriteUint32L( iLaunchMode );
+
+ // Pack the length of the Application Data. If there is no application
+ // data then pack zero.
+ TUint length = 0;
+ if ( iAppData )
+ {
+ length = iAppData->Length();
+ }
+ aWriteStream.WriteUint32L( length );
+
+ // If there is a valid data field pack it onto the buffer.
+ if ( length )
+ {
+ aWriteStream.WriteL( iAppData->Des(), length );
+ }
+
+ // Pack the command line arguments. If there is no command line
+ // parameters then pack a length of 0
+ length = 0;
+ if ( iCmdLineParams )
+ {
+ length = iCmdLineParams->Length();
+ }
+ aWriteStream.WriteUint32L( length );
+
+ // If there is a valid command line parameters field pack it onto the buffer.
+ if ( length )
+ {
+ aWriteStream.WriteL( iCmdLineParams->Des(), length );
+ }
+
+ aWriteStream.CommitL();
+ }
+
+// ---------------------------------------------------------------------------
+// void CLcBasicAppInfo::InternalizeL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CLcBasicAppInfo::InternalizeL( RReadStream& aReadStream )
+ {
+ // Clear the application data
+ delete iAppData;
+ iAppData = NULL;
+
+ // Clear the command line params
+ delete iCmdLineParams;
+ iCmdLineParams = NULL;
+
+ // The first element in the array if the Application type variable.
+ iAppType = aReadStream.ReadUint32L();
+
+ // The second element is the Application Launch mode
+ iLaunchMode = aReadStream.ReadUint32L();
+
+ // Now get the length of the data field.
+ TUint32 length = aReadStream.ReadUint32L();
+ if ( length >= KMaxTInt/2 )
+ {
+ User::Leave( KErrArgument );
+ }
+ // Set the application data only if the length is a +ve value.
+ if ( length )
+ {
+ iAppData = HBufC::NewL( length );
+ TPtr appData( iAppData->Des());
+ aReadStream.ReadL( appData, length );
+ }
+
+ // Now read the length of the command line parameters
+ length = aReadStream.ReadUint32L();
+ if ( length >= KMaxTInt/2 )
+ {
+ User::Leave( KErrArgument );
+ }
+ // Set the command line params only if the length is a +ve value.
+ if ( length )
+ {
+ iCmdLineParams = HBufC::NewL( length );
+ TPtr cmdParam( iCmdLineParams->Des());
+ aReadStream.ReadL( cmdParam, length );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// TInt CLcBasicAppInfo::BufferLength
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt CLcBasicAppInfo::BufferLength()
+ {
+ TInt length = 0;
+
+ // Include length for Application type
+ length += KSizeofTUint32;
+
+ // Add the length for Launch mode
+ length += KSizeofTUint32;
+
+ // Add the length of the Application Data and the length for Application
+ // data if it exists
+ length += KSizeofTUint32;
+
+ if ( iAppData )
+ {
+ length += iAppData->Des().MaxSize();
+ }
+
+ // Add the length of the Command line args and the length for Cmd line
+ // args if it exists
+ length += KSizeofTUint32;
+
+ if ( iCmdLineParams )
+ {
+ length += iCmdLineParams->Des().MaxSize();
+ }
+ return length;
+ }
+
+
+// ----- Member funtions for CLcBasicAppInfo ---------------------------------
+
+// ---------------------------------------------------------------------------
+// void CLcBasicAppInfo::ExternalizeL
+// ---------------------------------------------------------------------------
+//
+void CLcAppInfo::ExternalizeL( RWriteStream& aWriteStream )
+ {
+ CLcBasicAppInfo::ExternalizeL( aWriteStream );
+
+ // As per the grammar first pack the length and then pack the string
+ TInt length = Id().Length();
+ aWriteStream.WriteUint32L( length );
+
+ // Pack the Identifier. No need to check for the Length since
+ // this is a mandatory field and the Application would not have been
+ // accepted if it were not +ve
+ aWriteStream.WriteL( Id(), length );
+
+ // Pack the name. If there is no name then pack a length of 0 for the
+ // name field.
+ length = Name().Length();
+ aWriteStream.WriteUint32L( length );
+
+ // Pack the name field only if the length is +ve
+ if ( length )
+ {
+ aWriteStream.WriteL( Name(), length );
+ }
+
+ // Pack the Icon file and Icon file type for the file
+ length = IconFile().Length();
+ aWriteStream.WriteUint32L( length );
+
+ if ( length )
+ {
+ aWriteStream.WriteL( IconFile(), length );
+ aWriteStream.WriteUint32L( iIconFileType);
+
+ // If the Icon file type is a MIF, pack the Frame no
+ if ( EMifFile == iIconFileType )
+ {
+ aWriteStream.WriteUint32L( iFrameNo );
+ }
+ }
+
+ // Pack the System characteristics
+ aWriteStream.WriteUint32L( iSystemCharacteristics );
+
+ // Pack the application characteristics
+ aWriteStream.WriteUint32L( iAppCharacteristics );
+
+ aWriteStream.CommitL();
+ }
+
+// ---------------------------------------------------------------------------
+// void CLcBasicAppInfo::InternalizeL
+// ---------------------------------------------------------------------------
+//
+void CLcAppInfo::InternalizeL( RReadStream& aReadStream )
+ {
+ CLcBasicAppInfo::InternalizeL( aReadStream );
+
+ // First read the length of the Identifer
+ TUint32 length = aReadStream.ReadUint32L();
+ if ( length >= KMaxTInt/2 )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ // No need to check for the length for this is a mandatory field.
+ // Now create a buffer to read the actual identifier. The length
+ // of the buffer would be defined by the length value. Use this buffer
+ // read the identifier.
+ iId = HBufC::NewL( length );
+ TPtr bufferPtr( iId->Des());
+ aReadStream.ReadL( bufferPtr, length );
+
+ // Read the length of the name buffer
+ length = aReadStream.ReadUint32L();
+ if ( length >= KMaxTInt/2 )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ if ( length )
+ {
+ iApplicationName = HBufC::NewL( length );
+ bufferPtr.Set( iApplicationName->Des());
+
+ // Read the name field
+ aReadStream.ReadL( bufferPtr, length );
+ }
+
+ // Read the Icon file if its exists
+ length = aReadStream.ReadUint32L();
+ if ( length >= KMaxTInt/2 )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ if ( length )
+ {
+ iIconFile = HBufC::NewL( length );
+ bufferPtr.Set( iIconFile->Des());
+
+ // Read the Icon file field
+ aReadStream.ReadL( bufferPtr, length );
+
+ // Set the Icon file type
+ iIconFileType =
+ static_cast< CLcAppInfo::TLcIconFileType >( aReadStream.ReadUint32L());
+
+ // If the Icon file type is a MIF file then set the Frame no
+ if ( EMifFile == iIconFileType )
+ {
+ iFrameNo = aReadStream.ReadUint32L();
+ }
+ }
+
+ // Set the System characteristics
+ iSystemCharacteristics = aReadStream.ReadUint32L();
+
+ // Set the Application characteristics
+ iAppCharacteristics = aReadStream.ReadUint32L();
+ }
+
+// ---------------------------------------------------------------------------
+// TInt CLcAppInfo::BufferLength
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt CLcAppInfo::BufferLength()
+ {
+ TInt length = 0;
+
+ // First pack the length for the Basic App Info structure
+ length += CLcBasicAppInfo::BufferLength();
+
+ // Include length for Application Identifier
+ length += KSizeofTUint32;
+ length += iId->Des().MaxSize();
+
+ // Pack the name field and the Length of the name field if it exists
+ // Add the length of the Command line args and the length for Cmd line
+ // args if it exists
+ length += KSizeofTUint32;
+
+ if ( iApplicationName )
+ {
+ length += iApplicationName->Des().MaxSize();
+ }
+
+ // Pack the Icon file field and the name of icon file if it exists
+ // Read the Icon file if its exists
+ length += KSizeofTUint32;
+ if ( iIconFile )
+ {
+ // Pack the Icon file name length
+ length += iIconFile->Des().MaxSize();
+
+ // Pack the Icon file type
+ length += KSizeofTUint32;
+
+ // If the Icon file type is a MIF file then add length for the
+ // frame number
+ if ( EMifFile == iIconFileType )
+ {
+ length += KSizeofTUint32;
+ }
+ }
+
+ // Add the length for System characteristics
+ length += KSizeofTUint32;
+
+ // Add the length for Application characteristics
+ length += KSizeofTUint32;
+
+ return length;
+ }
+// End of File