--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/services/csc/src/capinfo.cpp Wed Sep 01 12:20:56 2010 +0100
@@ -0,0 +1,1031 @@
+/*
+* 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: CCapInfo implementation
+*
+*/
+
+
+// INCLUDE FILES
+
+#include <utf.h>
+#include <driveinfo.h>
+#include <pathinfo.h> // for PathInfo::SoundsPath
+#include <seconsdkcrkeys.h>
+#include "sconsyncservice.h"
+#include "capinfo.h"
+#include "caplist.h"
+#include "capparser.h"
+#include "caputils.h"
+#include "stringlist.h"
+#include "sconversioninfo.h"
+#include "debug.h"
+
+
+_LIT8( KLineFeed, "\r\n" );
+
+const TInt KDefaultArrayGranularity = 5;
+
+
+// ============================= MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CCapInfo::NewL()
+// Two-phase constructor
+// -----------------------------------------------------------------------------
+//
+CCapInfo* CCapInfo::NewL()
+ {
+ TRACE_FUNC_ENTRY;
+ CCapInfo* self = new (ELeave) CCapInfo();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ TRACE_FUNC_EXIT;
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::~CCapInfo()
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CCapInfo::~CCapInfo()
+ {
+ TRACE_FUNC_ENTRY;
+ iFsSession.Close();
+ delete iHeapBuf;
+ delete iCapList;
+ delete iSconInfo;
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::CapabilityDocumentL(CBufFlat* aBuf)
+// Creates capability xml document end places it in aBuf
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::CapabilityDocumentL(CBufFlat* aBuf)
+ {
+ TRACE_FUNC_ENTRY;
+ TInt err( KErrNone );
+
+ // set buffer where capability document is written
+ SetCapabilityBuf( aBuf );
+
+ WriteL( KXmlVersion );
+ WriteL( KComment1 );
+ WriteL( KDocType );
+ WriteL( KRootBegin );
+
+
+ //
+ // general
+ //
+ TRAP( err, GeneralInfoL() );
+ if ( err != KErrNone )
+ {
+ LOGGER_WRITE_1( "GeneralInfoL failed : %d", err );
+ User::Leave( err );
+ }
+
+
+ //
+ // services
+ //
+ // Search service files first from C-drive, and then from Z
+ // Do not add same files twice.
+
+ RArray<TFileName> excludeList( KDefaultArrayGranularity );
+ CleanupClosePushL( excludeList );
+ RArray<TFileName> filesAdded( KDefaultArrayGranularity );
+ CleanupClosePushL( filesAdded );
+
+ //read service files from C Import folder
+ TRAP( err, ServiceInfoL( KCapabilityDirCImport, excludeList, filesAdded ) );
+ LOGGER_WRITE_1( "ServiceInfoL(KCapabilityDirCImport) returned : %d", err );
+ for ( TInt i=0; i<filesAdded.Count(); i++ )
+ {
+ excludeList.Append( filesAdded[i] );
+ }
+ filesAdded.Reset();
+
+ // read service files from C Capability folder
+ TRAP( err, ServiceInfoL( KCapabilityDirC, excludeList, filesAdded ) );
+ LOGGER_WRITE_1( "ServiceInfoL(KCapabilityDirC) returned : %d", err );
+ for ( TInt i=0; i<filesAdded.Count(); i++ )
+ {
+ excludeList.Append( filesAdded[i] );
+ }
+ filesAdded.Reset();
+
+ // read service files from Z Capability folder
+ TRAP( err, ServiceInfoL( KCapabilityDirZ, excludeList, filesAdded ) );
+ LOGGER_WRITE_1( "ServiceInfoL(KCapabilityDirZ) returned : %d", err );
+
+ CleanupStack::PopAndDestroy( &filesAdded );
+ CleanupStack::PopAndDestroy( &excludeList );
+
+
+ // this service does not come from file
+ TRAP( err, FolderServiceL() );
+ LOGGER_WRITE_1( "FolderServiceL() returned : %d", err );
+
+ TRAP( err, SyncSolutionsServiceL() );
+ LOGGER_WRITE_1( "SyncSolutionsServiceL() returned: %d", err );
+
+ WriteL( KRootEnd );
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::ConstructL()
+// Initializes member data
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::ConstructL()
+ {
+ TRACE_FUNC_ENTRY;
+ User::LeaveIfError( iFsSession.Connect() );
+
+ iHeapBuf = HBufC8::NewL( KMaxSize*2 );
+ iCapList = CCapList::NewL();
+ iIdStack.Reset();
+
+ iSconInfo = CSconVersionInfo::NewL();
+ TInt err(KErrNone);
+ TRAP(err, iSconInfo->FetchInfoL( iFsSession ));
+ LOGGER_WRITE_1("sconInfo->FetchInfoL() Leaved: %d", err);
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::CCapInfo()
+// Constuctor
+// -----------------------------------------------------------------------------
+//
+CCapInfo::CCapInfo()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::CapList()
+// Returns caplist
+// -----------------------------------------------------------------------------
+//
+CCapList* CCapInfo::CapList()
+ {
+ TRACE_FUNC;
+ __ASSERT_DEBUG(iCapList, CapUtil::Panic(KErrGeneral));
+ return iCapList;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::SetCapabilityBuf( CBufFlat* aBuf )
+// Set capability buffer
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::SetCapabilityBuf( CBufFlat* aBuf )
+ {
+ TRACE_FUNC;
+ iCapabilityBuf=aBuf;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::GeneralInfoL()
+// Write general device capability information.
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::GeneralInfoL()
+ {
+ TRACE_FUNC_ENTRY;
+ TInt err( KErrNone );
+ TBuf<KBufSize> buf;
+ TBuf<KBufSize> longName;
+ TBuf<KBufSize> coutryCode;
+ TBuf<KBufSize> networkID;
+
+ WriteTagL(EGeneral, TXmlParser::EElementBegin);
+
+ if ( !iSconInfo->IsReady() )
+ {
+ LOGGER_WRITE("iSconInfo wasn't ready, call iSconInfo->FetchInfoL");
+ iSconInfo->FetchInfoL( iFsSession );
+ }
+
+ if ( iSconInfo->iManufacturer )
+ {
+ WriteValueL( EManufacturer, *iSconInfo->iManufacturer );
+ }
+
+ if ( iSconInfo->iProduct )
+ {
+ WriteValueL( EModel, *iSconInfo->iProduct );
+ }
+
+ // serial number
+ if ( iSconInfo->iSerialNumber )
+ {
+ WriteValueL( ESN, *iSconInfo->iSerialNumber );
+ }
+
+ // software version
+ if ( iSconInfo->iSWVersion )
+ {
+ WriteAttributeL( ESW, *iSconInfo->iSWVersion, iSconInfo->iDate );
+ }
+
+ // language
+ WriteValueL( ELanguage, iSconInfo->iLanguage );
+
+ // this must succeed - do not trap
+ MemoryInfoL();
+
+ // Operator
+ TRAP( err, CapUtil::GetOperatorNameL( longName, coutryCode, networkID ) );
+ LOGGER_WRITE_1( "CapUtil::GGetOperatorNameL returned : %d", err );
+ if( err == KErrNone )
+ {
+ LOGGER_WRITE_3( "CSConFsHandler::GetOperatorNameL longName = %S coutryCode = %S networkID = %S", &longName, &coutryCode, &networkID );
+ _LIT( KNetworkInfo, "NetworkInfo" );
+ _LIT( KCurrentNetwork, "CurrentNetwork=" );
+ _LIT( KCountryCode, "CountryCode=" );
+ _LIT( KNetworkID, "NetworkID=" );
+
+ WriteTagL( EExt, TXmlParser::EElementBegin );
+ WriteValueL( EXNam, KNetworkInfo );
+
+ // write CurrentNetwork
+ buf.Copy( KCurrentNetwork );
+ buf.Append( longName );
+ WriteValueL( EXVal, buf );
+
+ // write CountryCode
+ buf.Copy( KCountryCode );
+ buf.Append( coutryCode );
+ WriteValueL( EXVal, buf );
+
+ // write NetworkID
+ buf.Copy( KNetworkID );
+ buf.Append( networkID );
+ WriteValueL( EXVal, buf );
+
+ WriteTagL( EExt, TXmlParser::EElementEnd );
+ }
+
+ if ( iSconInfo->iModel )
+ {
+ // print modelname (phone model sales name. For example "N01".)
+ WriteTagL( EExt, TXmlParser::EElementBegin );
+ _LIT(KModelName, "ModelName");
+ WriteValueL( EXNam, KModelName );
+ WriteValueL( EXVal, *iSconInfo->iModel );
+ WriteTagL( EExt, TXmlParser::EElementEnd );
+ }
+
+ if ( iSconInfo->iProductCode )
+ {
+ // print productcode
+ WriteTagL( EExt, TXmlParser::EElementBegin );
+ _LIT( KProductCode, "ProductCode" );
+ WriteValueL( EXNam, KProductCode );
+ WriteValueL( EXVal, *iSconInfo->iProductCode );
+ WriteTagL( EExt, TXmlParser::EElementEnd );
+ }
+
+
+ // print advanced info
+ WriteTagL( EExt, TXmlParser::EElementBegin );
+ _LIT(KAdvancedDeviceInfo, "AdvancedDeviceInfo");
+ WriteValueL( EXNam, KAdvancedDeviceInfo );
+
+ TBuf<KSysVersionInfoTextLength> temp;
+
+ if ( iSconInfo->iRevision )
+ {
+ // product revision. For example "01"
+ _LIT( KRevision, "Revision=" );
+ temp.Copy( KRevision );
+ temp.Append( *iSconInfo->iRevision );
+ LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );
+ WriteValueL( EXVal, temp );
+ }
+
+
+ if ( iSconInfo->iSysVersionInfo )
+ {
+ _LIT( KFWVersion, "FWVersion=" );
+ temp.Copy( KFWVersion );
+ temp.Append( *iSconInfo->iSysVersionInfo );
+ LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );
+ WriteValueL( EXVal, temp );
+ }
+
+ SysVersionInfo::TSymbianOSVersion osVersion;
+ err = iSconInfo->GetSymbianVersion( osVersion );
+ LOGGER_WRITE_1("TSymbianOSVersion info error: %d", err)
+ if ( !err )
+ {
+ // Now osVersion contains the Symbian OS version information
+ _LIT( KSymbianOSVersion, "SymbianOSVersion=%d.%d" );
+ temp.Format( KSymbianOSVersion,
+ osVersion.iMajorVersion,
+ osVersion.iMinorVersion );
+ LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );
+
+ WriteValueL( EXVal, temp );
+ }
+
+ VersionInfo::TPlatformVersion platformVersion;
+ err = iSconInfo->GetS60Version( platformVersion );
+ if ( !err )
+ {
+ _LIT( KS60Version, "S60PlatformVersion=%d.%d" );
+ temp.Format( KS60Version,
+ platformVersion.iMajorVersion,
+ platformVersion.iMinorVersion );
+ LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );
+ WriteValueL( EXVal, temp );
+ }
+
+
+ if ( iSconInfo->iLangVersion )
+ {
+ _LIT( KLangVersion, "LangVersion=" );
+ temp.Copy( KLangVersion );
+ temp.Append( *iSconInfo->iLangVersion );
+ LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );
+ WriteValueL( EXVal, temp );
+ }
+
+ if ( iSconInfo->iLangSWVersion )
+ {
+ _LIT( KLangSWVersion, "LangSWVersion=" );
+ temp.Copy( KLangSWVersion );
+ temp.Append( *iSconInfo->iLangSWVersion );
+ LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );
+ WriteValueL( EXVal, temp );
+ }
+
+ if ( iSconInfo->iOPVersion )
+ {
+ // CustomerVersion
+ _LIT( KOPVersion, "OPVersion=" );
+ temp.Copy( KOPVersion );
+ temp.Append( *iSconInfo->iOPVersion );
+ LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );
+ WriteValueL( EXVal, temp );
+ }
+
+ // screen size
+ LOGGER_WRITE_2("Size, width: %d, height: %d",
+ iSconInfo->iScreenSize.iWidth,
+ iSconInfo->iScreenSize.iHeight );
+ _LIT( KWidth, "ScreenWidth=%d" );
+ _LIT( KHeight, "ScreenHeight=%d" );
+
+ temp.Format( KWidth, iSconInfo->iScreenSize.iWidth );
+ WriteValueL( EXVal, temp );
+
+ temp.Format( KHeight, iSconInfo->iScreenSize.iHeight );
+ WriteValueL( EXVal, temp );
+
+ WriteTagL( EExt, TXmlParser::EElementEnd );
+ // end of advanced info
+
+ WriteTagL(EGeneral, TXmlParser::EElementEnd);
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::MemoryInfoL()
+// Create memory info for all drives (RAM excluded).
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::MemoryInfoL()
+ {
+ TRACE_FUNC_ENTRY;
+
+ TMemoryInfo info;
+ TInt devDriveCount = 0;
+ TInt mmcDriveCount = 0;
+
+ //Write all drivers to folderlisting object
+ TDriveList driveList;
+ // Get all drives that are visible to the user.
+ TInt driveCount;
+ User::LeaveIfError( DriveInfo::GetUserVisibleDrives( iFsSession, driveList, driveCount ) );
+
+ for( TInt i = EDriveA; i < KMaxDrives; i++ )
+ {
+ if( driveList[i] )
+ {
+ TUint driveStatus;
+ TInt err = DriveInfo::GetDriveStatus( iFsSession, i, driveStatus );
+ if( err )
+ {
+ LOGGER_WRITE_1( "CCapInfo::MemoryInfoL() : DriveInfo::GetDriveStatus: %d", i);
+ continue;
+ }
+
+ if( !(driveStatus & DriveInfo::EDrivePresent )
+ || driveStatus & DriveInfo::EDriveCorrupt
+ || (driveStatus & DriveInfo::EDriveRemote) )
+ {
+ LOGGER_WRITE_1( "skip drive %d", i);
+ continue;
+ }
+
+ TRAP( err, CapUtil::GetMemoryInfoL( iFsSession, i, info ));
+ if ( err )
+ {
+ LOGGER_WRITE_1( "CapUtil::GetMemoryInfoL() : Leaved with: %d", err);
+ continue;
+ }
+
+ info.iDriveStatus = driveStatus;
+ if( driveStatus & DriveInfo::EDriveInternal )
+ {
+ // if internal (DEV) drive, save drive number
+ devDriveCount++;
+ info.iMemNr = devDriveCount;
+ }
+ else if ( driveStatus & DriveInfo::EDriveRemovable )
+ {
+ // if removable (MMC) drive, save drive number
+ mmcDriveCount++;
+ info.iMemNr = mmcDriveCount;
+ }
+ else
+ {
+ // was not internal or removable, skip.
+ LOGGER_WRITE( "CCapInfo::MemoryInfoL() : not internal or removable, skip." );
+ continue;
+ }
+
+ WriteMemoryInfoL(info);
+
+ }
+ }
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::MemoryInfoL(TMemoryInfo& aInfo)
+// Create memory info for all drives (RAM excluded).
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteMemoryInfoL(TMemoryInfo& aInfo)
+ {
+ TRACE_FUNC_ENTRY;
+ TBuf<KBufSize> buf;
+
+ WriteTagL(EMemory, TXmlParser::EElementBegin);
+
+ if( aInfo.iDriveStatus & DriveInfo::EDriveInternal )
+ {
+ buf = KMediaFlash;
+ }
+ else
+ {
+ buf = KMediaMMC; // memory card (MMC)
+ }
+
+ if( aInfo.iMemNr > 1 )
+ {
+ // append memory number DEV2, MMC2..
+ buf.AppendNum( aInfo.iMemNr );
+ }
+
+ WriteValueL(EMemType, buf);
+ WriteValueL(ELocation, aInfo.iLocation);
+ WriteValueL(EFree, aInfo.iFree);
+ WriteValueL(EUsed, aInfo.iUsed);
+
+ WriteValueL(EFileNLen, aInfo.iFileNameSize);
+
+ WriteTagL(EMemory, TXmlParser::EElementEnd);
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::ServiceInfoL(const TDesC& aDir)
+// Reads service xml-files from directory and writes them into capability
+// document.
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::ServiceInfoL(const TDesC& aDir, const RArray<TFileName>& aExcludeList,
+ RArray<TFileName>& aFilesAdded)
+ {
+ TRACE_FUNC_ENTRY;
+ CCapList* capList=CapList();
+
+ RArray<TFileName> array( KDefaultArrayGranularity );
+ CleanupClosePushL(array);
+
+ CStringList* stringList=CStringList::NewLC();
+
+ CapUtil::GetFileListL(iFsSession, aDir, array);
+
+ _LIT(KFormat, "%S%S");
+ TFileName name;
+ TInt count=array.Count();
+ for (TInt i=0; i<count; i++)
+ {
+ TBool exludeFromList(EFalse);
+
+ // Check if file is already added to list
+ for ( TInt j=0; j<aExcludeList.Count() && !exludeFromList; j++ )
+ {
+ if ( array[i].CompareF(aExcludeList[j]) == 0 )
+ {
+ LOGGER_WRITE_1( "match found at pos %d", j);
+ exludeFromList = ETrue;
+ }
+ }
+
+ if ( !exludeFromList )
+ {
+ name.Format(KFormat, &aDir, &array[i]);
+ if (!CapUtil::CheckFileType(name, KXmlExtension))
+ {
+ continue; // only accept .xml files
+ }
+
+ capList->List()->Reset();
+ capList->List()->ReadFromFileL( iFsSession, name );
+ if (capList->FindServiceL(stringList))
+ {
+ WriteNewLineL();
+ WriteFromListL(stringList);
+
+ User::LeaveIfError( aFilesAdded.Append(array[i]) );
+ LOGGER_WRITE_1( "File '%S' added to list", &array[i] );
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(stringList);
+ CleanupStack::PopAndDestroy(&array);
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::FolderServiceL()
+// Writes folder service. Notice that this service is created in code because
+// pathinfo component is used to get folder names.
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::FolderServiceL()
+ {
+ TRACE_FUNC_ENTRY;
+ TBuf<KBufSize> rootPath;
+ TBuf<KBufSize> memoryType(KNullDesC);
+ TFileName folderName;
+ _LIT( KFormat, "%S%S" );
+
+ WriteNewLineL();
+ WriteTagL(EService, TXmlParser::EElementBegin);
+
+ WriteValueL(EName, KFolderServiceName);
+ WriteValueL(EUUID, KFolderServiceUid);
+ WriteValueL(EVersion, KFolderServiceVersion);
+
+ WriteTagL(EObject, TXmlParser::EElementBegin);
+ WriteValueL(EType, KFolderServiceType);
+ WriteTagL(EObject, TXmlParser::EElementEnd);
+ TInt drive;
+ TInt err;
+
+ CapUtil::GetDefaultRootPathL( iFsSession, rootPath );
+ if( rootPath.Length() > 0 )
+ {
+ err = iFsSession.CharToDrive( rootPath[0], drive );
+ if( err == KErrNone )
+ {
+ CapUtil::GetMemoryType( iFsSession, memoryType, drive );
+ }
+ }
+
+ // EFolderImages
+ folderName.Format( KFormat, &rootPath, &PathInfo::ImagesPath() );
+ WriteFolderL( KFolderImages, folderName, memoryType );
+
+ // EFolderGraphics
+ folderName.Format( KFormat, &rootPath, &PathInfo::ImagesPath() );
+ WriteFolderL(KFolderGraphics, folderName, memoryType);
+
+ // EFolderTones
+ folderName.Format( KFormat, &rootPath, &PathInfo::DigitalSoundsPath() );
+ WriteFolderL(KFolderTones, folderName, memoryType);
+
+ // EFolderMusic
+ folderName.Format( KFormat, &rootPath, &PathInfo::SoundsPath() );
+ WriteFolderL(KFolderMusic, folderName, memoryType);
+
+ // EFolderVideos
+ folderName.Format( KFormat, &rootPath, &PathInfo::VideosPath() );
+ WriteFolderL(KFolderVideos, folderName, memoryType);
+
+ // EFolderInstalls
+ folderName.Format( KFormat, &rootPath, &PathInfo::InstallsPath() );
+ WriteFolderL(KFolderInstalls, folderName, memoryType);
+
+
+ WriteTagL(EService, TXmlParser::EElementEnd);
+ WriteNewLineL();
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::SyncSolutionsServiceL()
+// Reads last used syncSolutions from cenrep and writes to capability object
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::SyncSolutionsServiceL()
+ {
+ TRACE_FUNC_ENTRY;
+ TSConSolutionInfo calendar;
+ TSConSolutionInfo contact;
+ TSConSolutionInfo sms;
+ TSConSolutionInfo bookmark;
+
+ CSConSyncService *syncService = CSConSyncService::NewLC();
+ syncService->GetSolutionL( KSeconCalendarUid, calendar );
+ syncService->GetSolutionL( KSeconContactsUid, contact );
+ syncService->GetSolutionL( KSeconSmsUid, sms );
+ syncService->GetSolutionL( KSeconBookmarkUid, bookmark );
+ CleanupStack::PopAndDestroy( syncService );
+
+ WriteSyncSolutionsServiceL( calendar, contact, sms, bookmark );
+
+ TRACE_FUNC_EXIT;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteSyncSolutionsServiceL()
+// Writes SyncSolutionsService data to capability object.
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteSyncSolutionsServiceL( const TSConSolutionInfo& aCalendar,
+ const TSConSolutionInfo& aContact,
+ const TSConSolutionInfo& aSms,
+ const TSConSolutionInfo& aBookmark)
+ {
+ TRACE_FUNC_ENTRY;
+
+ WriteTagL( EService, TXmlParser::EElementBegin );
+
+ WriteValueL( EName, KSyncSolutionsServiceName );
+ WriteValueL( EVersion, KSyncSolutionsServiceVersion );
+
+ if ( aCalendar.iUid != 0 )
+ {
+ WriteSolutionTagL( KSyncCalendar, aCalendar );
+ }
+
+ if ( aContact.iUid != 0 )
+ {
+ WriteSolutionTagL( KSyncContacts, aContact );
+ }
+
+ if ( aSms.iUid != 0 )
+ {
+ WriteSolutionTagL( KSyncSms, aSms );
+ }
+
+ if ( aBookmark.iUid != 0 )
+ {
+ WriteSolutionTagL( KSyncBookmark, aBookmark );
+ }
+
+ /*
+ * <Ext>
+ * <XNam>DesktopSync</XNam>
+ * <XVal></XVal>
+ * </Ext>
+ *
+ */
+ if ( !iSconInfo->iDesktopSyncError )
+ {
+ WriteTagL( EExt, TXmlParser::EElementBegin );
+ WriteValueL( EXNam, KDesktopSync );
+
+ TBuf<KBufSize> buffer;
+ buffer.AppendNum( iSconInfo->iDesktopSync );
+
+ WriteValueL( EXVal, buffer );
+ WriteTagL( EExt, TXmlParser::EElementEnd );
+ }
+
+
+
+ WriteTagL( EService, TXmlParser::EElementEnd );
+ TRACE_FUNC_EXIT;
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteSolutionTagL()
+// Writes SyncSolutionsService solution data to capability object.
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteSolutionTagL( const TDesC& aContentName,
+ const TSConSolutionInfo& aSolution )
+ {
+ TRACE_FUNC_ENTRY;
+ _LIT( KFormatUID, "UID=0x%08x" );
+ _LIT( KFormatName, "Name=%S" );
+ _LIT( KFormatDate, "Timestamp=%04d%02d%02dT%02d%02d%02dZ" );
+
+ WriteTagL( EExt, TXmlParser::EElementBegin );
+ WriteValueL( EXNam, aContentName );
+
+ TFileName temp;
+ temp.Format( KFormatUID, aSolution.iUid );
+ WriteValueL( EXVal, temp );
+
+ temp.Format( KFormatName, &aSolution.iSolutionName );
+ WriteValueL( EXVal, temp );
+
+ if ( aSolution.iTime.Int64() != 0 )
+ {
+ // write time
+ TDateTime time = aSolution.iTime.DateTime();
+ temp.Format( KFormatDate, time.Year(), time.Month() + 1,
+ time.Day() + 1, time.Hour(), time.Minute(), time.Second() );
+ WriteValueL( EXVal, temp );
+
+ }
+
+
+ WriteTagL( EExt, TXmlParser::EElementEnd );
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteFolderL(const TDesC& aType, const TDesC& aFullName,
+// const TDesC& aMemory)
+// Writes one folder name element.
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteFolderL(const TDesC& aType, const TDesC& aFullName,
+ const TDesC& aMemory)
+ {
+ TRACE_FUNC_ENTRY;
+ _LIT(KFormat, "%S=%S");
+
+ TBuf<KBufSize> buf;
+ const TInt KReservedSize = 10;
+ if ( aFullName.Length() + KReservedSize > KBufSize )
+ {
+ return;
+ }
+ buf.Format(KFormat, &KFolderNameTag, &aFullName);
+
+
+ WriteTagL(EExt, TXmlParser::EElementBegin);
+
+ WriteValueL(EXNam, aType);
+ WriteValueL(EXVal, buf);
+
+ buf.Format(KFormat, &KFolderMemoryTypeTag, &aMemory);
+ WriteValueL(EXVal, buf);
+
+
+ WriteTagL(EExt, TXmlParser::EElementEnd);
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteL(const TDesC& aText)
+// Writes one element to capability buffer.
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteL(const TDesC& aText)
+ {
+ if (aText.Length() > iBuf.MaxLength())
+ {
+ User::Leave(KErrTooBig);
+ }
+
+
+ iBuf=aText;
+ iBuf.Trim();
+ FormatElement(iBuf);
+ TPtr8 ptr = iHeapBuf->Des();
+
+ if ( iBuf.Length()+2 > ptr.MaxLength() )
+ {
+ User::Leave(KErrTooBig);
+ }
+
+ //unicode conversion
+ HBufC8* convBuf = HBufC8::NewLC( iBuf.Size() );
+ TPtr8 convPtr = convBuf->Des();
+
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(convPtr, iBuf);
+
+ ptr.Copy(convPtr);
+ ptr.Append( KLineFeed ); // linefeed
+
+ CleanupStack::PopAndDestroy( convBuf );
+
+ TInt pos=iCapabilityBuf->Size();
+ iCapabilityBuf->InsertL(pos, ptr);
+
+ iBuf=KNullDesC;
+ }
+
+void CCapInfo::WriteNewLineL()
+ {
+ TInt pos=iCapabilityBuf->Size();
+ iCapabilityBuf->InsertL(pos, KLineFeed );
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteValueL(TInt aId, const TDesC& aValue)
+// Constructs element with value (eg <Language>en</Language>)
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteValueL(TInt aId, const TDesC& aValue)
+ {
+ // empty values not written to capability object
+ if (aValue.Length()<1)
+ {
+ LOGGER_WRITE( "WriteValueL: value is empty" );
+ return;
+ }
+
+ TBuf<KBufSize> buf;
+
+ TRAPD(err, CapParser::MakeElementL(buf, aId, aValue));
+ if (err==KErrNone)
+ {
+ WriteL(buf);
+ }
+ else if (err==KErrTooBig)
+ {
+ WriteBigValueL(aId, aValue);
+ }
+ else
+ {
+ User::Leave(err);
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteBigValueL(TInt aId, const TDesC& aValue)
+// Constructs element with value
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteBigValueL(TInt aId, const TDesC& aValue)
+ {
+ HBufC* hBuf=HBufC::NewL(aValue.Length()+KBufSize);
+ CleanupStack::PushL(hBuf);
+
+ TPtr pBuf(hBuf->Des());
+ CapParser::MakeElementL(pBuf, aId, aValue);
+ WriteL(*hBuf);
+
+ CleanupStack::PopAndDestroy(hBuf);
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteValueL(TInt aId, TInt64 aValue)
+// Constructs element with integer value
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteValueL(TInt aId, TInt64 aValue)
+ {
+ TBuf<KBufSize> buf;
+ TBuf<KTagSize> value;
+ CapUtil::IntToStr(value, aValue);
+ CapParser::MakeElementL(buf, aId, value);
+ WriteL(buf);
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteTagL(TInt aId, TInt aType)
+// Constructs element without value (eg <Memory>)
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteTagL(TInt aId, TInt aType)
+ {
+ TBuf<KBufSize> buf;
+ CapParser::MakeElementL(buf, aId, aType);
+ WriteL(buf);
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteAttributeL(TInt aId, const TDesC& aVersion, const TDesC& aDate)
+// Constructs element with attributes "Version" and "Date"
+// (eg <HW Version="1.5"/>)
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteAttributeL(TInt aId, const TDesC& aVersion,
+ const TDesC& aDate)
+ {
+ // empty values not written to capability object
+ if (aVersion.Length()<1 && aDate.Length()<1)
+ {
+ LOGGER_WRITE( "WriteAttributeL: attributes are empty" );
+ return;
+ }
+
+ TBuf<KBufSize> buf;
+ CapParser::MakeElementL(buf, aId, aVersion, aDate);
+ WriteL(buf);
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::WriteFromListL(CStringList* aList)
+// Writes elements from list to capability buffer.
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::WriteFromListL(CStringList* aList)
+ {
+ TInt count=aList->Count();
+
+ for (TInt i=0; i<count; i++)
+ {
+ WriteL(aList->ReadPtr(i));
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::FormatElement(TDes& aText)
+// Function adds indentation spaces to capability elements to improve
+// readability.
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::FormatElement(TDes& aText)
+ {
+ TXmlParser parser;
+
+ parser.Set(aText);
+ TInt type=parser.Type();
+ TBuf<KTagSize> tag;
+ parser.GetTag(tag);
+
+ if (type==TXmlParser::EElementEnd)
+ {
+ TInt id1=CapParser::ElementId(tag);
+ TInt id2=iIdStack.Pop();
+
+ __ASSERT_DEBUG(id1==id2, CapUtil::Panic(KErrGeneral));
+ id1=0;
+ id2=0;
+ }
+
+ AddFormatText(aText, iIdStack.Size());
+
+ if (type==TXmlParser::EElementBegin)
+ {
+ TInt id1=CapParser::ElementId(tag);
+ iIdStack.Push(id1);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CCapInfo::AddFormatText( TDes& aText, TInt aNum ) const
+// Adds format text
+// -----------------------------------------------------------------------------
+//
+void CCapInfo::AddFormatText( TDes& aText, TInt aNum ) const
+ {
+ TBuf<KBufSize> buf;
+ buf = KNullDesC;
+
+ if ( aNum > KNestingLimit )
+ {
+ aNum = KNestingLimit;
+ }
+
+ for ( TInt i=0; i<aNum; i++ )
+ {
+ buf.Append( KFormatText );
+ }
+ if ( aText.MaxLength()-aText.Length()>buf.Length() )
+ {
+ aText.Insert( 0, buf );
+ }
+ }
+
+// End of file
+
+