diff -r 000000000000 -r 522cd55cc3d7 locationcentre/lcutils/src/lcipcparams.cpp --- /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 + +// 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