--- a/backupandrestore/backupengine/src/sbecompressionandencryption.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/backupandrestore/backupengine/src/sbecompressionandencryption.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -709,7 +709,7 @@
iEncryptionHeader.iEncrypted, iEncryptionHeader.iBufferSize, iEncryptionHeader.iTotalSize);
// Check we have a sensible encryption header
- if ((iEncryptionHeader.iBufferSize < 0) ||
+ if ((iEncryptionHeader.iBufferSize < 0) || (iEncryptionHeader.iBufferSize >= KMaxTInt/2) ||
(iEncryptionHeader.iTotalSize < 0))
{
__LOG("CSBEDecompressAndEncrypt::CreateCipherL() - Corrupt data");
--- a/backupandrestore/backuptest/ABTester/group/bld.inf Thu Jul 15 19:35:12 2010 +0300
+++ b/backupandrestore/backuptest/ABTester/group/bld.inf Thu Aug 19 10:44:03 2010 +0300
@@ -33,10 +33,10 @@
./abtester.oby /epoc32/rom/include/abtester.oby
./abtester.iby /epoc32/rom/include/abtester.iby
- ../data/incremental_active_backup_registration.xml z:/private/0AB7E57C/backup_registration.xml
- ../data/proxy_active_backup_registration.xml z:/private/0AB7E57D/backup_registration.xml
- ../data/base_active_backup_registration.xml z:/private/0AB7E57E/backup_registration.xml
- ../data/base_active_backup_registration2.xml z:/private/0AB7E58A/backup_registration.xml
- ../data/base_active_backup_registration3.xml z:/private/0AB7E58B/backup_registration.xml
- ../data/passive_backup_registration.xml z:/private/0AB7E58C/backup_registration.xml
- ../data/backup_public_files_registration.xml z:/private/0FA00001/backup_registration.xml
+ ../data/incremental_active_backup_registration.xml z:/private/0ab7e57c/backup_registration.xml
+ ../data/proxy_active_backup_registration.xml z:/private/0ab7e57d/backup_registration.xml
+ ../data/base_active_backup_registration.xml z:/private/0ab7e57e/backup_registration.xml
+ ../data/base_active_backup_registration2.xml z:/private/0ab7e58a/backup_registration.xml
+ ../data/base_active_backup_registration3.xml z:/private/0ab7e58b/backup_registration.xml
+ ../data/passive_backup_registration.xml z:/private/0ab7e58c/backup_registration.xml
+ ../data/backup_public_files_registration.xml z:/private/0fa00001/backup_registration.xml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/clients/syncclient/bwins/sconsyncclientu.def Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,43 @@
+EXPORTS
+ ??0RSconSyncSession@@QAE@XZ @ 1 NONAME ; RSconSyncSession::RSconSyncSession(void)
+ ??1CSconDataproviderInfo@@UAE@XZ @ 2 NONAME ; CSconDataproviderInfo::~CSconDataproviderInfo(void)
+ ??1RSconSyncSession@@QAE@XZ @ 3 NONAME ; RSconSyncSession::~RSconSyncSession(void)
+ ?AddedItemsL@RSconSyncSession@@QBEXAAV?$RArray@H@@@Z @ 4 NONAME ; void RSconSyncSession::AddedItemsL(class RArray<int> &) const
+ ?CancelRequest@RSconSyncSession@@QAEXXZ @ 5 NONAME ; void RSconSyncSession::CancelRequest(void)
+ ?Close@RSconSyncSession@@QAEXXZ @ 6 NONAME ; void RSconSyncSession::Close(void)
+ ?CloseDataStore@RSconSyncSession@@QBEXXZ @ 7 NONAME ; void RSconSyncSession::CloseDataStore(void) const
+ ?CommitChangeInfoL@RSconSyncSession@@QAEXABV?$RArray@H@@@Z @ 8 NONAME ; void RSconSyncSession::CommitChangeInfoL(class RArray<int> const &)
+ ?Connect@RSconSyncSession@@QAEHXZ @ 9 NONAME ; int RSconSyncSession::Connect(void)
+ ?CreateItemL@RSconSyncSession@@QAEXAAHHABVTDesC8@@11@Z @ 10 NONAME ; void RSconSyncSession::CreateItemL(int &, int, class TDesC8 const &, class TDesC8 const &, class TDesC8 const &)
+ ?CreateItemL@RSconSyncSession@@QAEXAAV?$TPckg@H@@HABVTDesC8@@11AAVTRequestStatus@@@Z @ 11 NONAME ; void RSconSyncSession::CreateItemL(class TPckg<int> &, int, class TDesC8 const &, class TDesC8 const &, class TDesC8 const &, class TRequestStatus &)
+ ?DefaultStoreL@CSconDataproviderInfo@@QAEAAVTDesC16@@XZ @ 12 NONAME ; class TDesC16 & CSconDataproviderInfo::DefaultStoreL(void)
+ ?DeleteAllItems@RSconSyncSession@@QAEXAAVTRequestStatus@@@Z @ 13 NONAME ; void RSconSyncSession::DeleteAllItems(class TRequestStatus &)
+ ?DeleteItemL@RSconSyncSession@@QAEXH@Z @ 14 NONAME ; void RSconSyncSession::DeleteItemL(int)
+ ?DeletedItemsL@RSconSyncSession@@QBEXAAV?$RArray@H@@@Z @ 15 NONAME ; void RSconSyncSession::DeletedItemsL(class RArray<int> &) const
+ ?DisplayNameL@CSconDataproviderInfo@@QAEAAVTDesC16@@XZ @ 16 NONAME ; class TDesC16 & CSconDataproviderInfo::DisplayNameL(void)
+ ?ExternalizeL@CSconDataproviderInfo@@QBEXAAVRWriteStream@@@Z @ 17 NONAME ; void CSconDataproviderInfo::ExternalizeL(class RWriteStream &) const
+ ?GetParent@RSconSyncSession@@QAEHHAAH@Z @ 18 NONAME ; int RSconSyncSession::GetParent(int, int &)
+ ?GetSyncTimeStampL@RSconSyncSession@@QBEXHHAAVTDateTime@@@Z @ 19 NONAME ; void RSconSyncSession::GetSyncTimeStampL(int, int, class TDateTime &) const
+ ?HasSyncHistoryL@RSconSyncSession@@QBEHXZ @ 20 NONAME ; int RSconSyncSession::HasSyncHistoryL(void) const
+ ?ImplementationUid@CSconDataproviderInfo@@QBE?AVTUid@@XZ @ 21 NONAME ; class TUid CSconDataproviderInfo::ImplementationUid(void) const
+ ?InternalizeL@CSconDataproviderInfo@@QAEXAAVRReadStream@@@Z @ 22 NONAME ; void CSconDataproviderInfo::InternalizeL(class RReadStream &)
+ ?ListAllImplementationsL@RSconSyncSession@@QAEXAAV?$RPointerArray@VCSconDataproviderInfo@@@@@Z @ 23 NONAME ; void RSconSyncSession::ListAllImplementationsL(class RPointerArray<class CSconDataproviderInfo> &)
+ ?ListStoresL@CSconDataproviderInfo@@QBEPAVCDesC16Array@@XZ @ 24 NONAME ; class CDesC16Array * CSconDataproviderInfo::ListStoresL(void) const
+ ?ModifiedItemsL@RSconSyncSession@@QBEXAAV?$RArray@H@@@Z @ 25 NONAME ; void RSconSyncSession::ModifiedItemsL(class RArray<int> &) const
+ ?MoveItemL@RSconSyncSession@@QAEXHH@Z @ 26 NONAME ; void RSconSyncSession::MoveItemL(int, int)
+ ?MovedItemsL@RSconSyncSession@@QBEXAAV?$RArray@H@@@Z @ 27 NONAME ; void RSconSyncSession::MovedItemsL(class RArray<int> &) const
+ ?NewL@CSconDataproviderInfo@@SAPAV1@XZ @ 28 NONAME ; class CSconDataproviderInfo * CSconDataproviderInfo::NewL(void)
+ ?OpenDataStoreL@RSconSyncSession@@QAEXHABVTDesC16@@H@Z @ 29 NONAME ; void RSconSyncSession::OpenDataStoreL(int, class TDesC16 const &, int)
+ ?OpenItemL@RSconSyncSession@@QAEXHAAH0AAVTDes8@@1AAVCBufFlat@@@Z @ 30 NONAME ; void RSconSyncSession::OpenItemL(int, int &, int &, class TDes8 &, class TDes8 &, class CBufFlat &)
+ ?ReplaceItemL@RSconSyncSession@@QAEXHHHABVTDesC8@@@Z @ 31 NONAME ; void RSconSyncSession::ReplaceItemL(int, int, int, class TDesC8 const &)
+ ?ReplaceItemL@RSconSyncSession@@QAEXHHHABVTDesC8@@AAVTRequestStatus@@@Z @ 32 NONAME ; void RSconSyncSession::ReplaceItemL(int, int, int, class TDesC8 const &, class TRequestStatus &)
+ ?ResetChangeInfoL@RSconSyncSession@@QAEXXZ @ 33 NONAME ; void RSconSyncSession::ResetChangeInfoL(void)
+ ?SetDefaultStoreL@CSconDataproviderInfo@@QAEXABVTDesC16@@@Z @ 34 NONAME ; void CSconDataproviderInfo::SetDefaultStoreL(class TDesC16 const &)
+ ?SetDisplayNameL@CSconDataproviderInfo@@QAEXABVTDesC16@@@Z @ 35 NONAME ; void CSconDataproviderInfo::SetDisplayNameL(class TDesC16 const &)
+ ?SetImplementationUid@CSconDataproviderInfo@@QAEXVTUid@@@Z @ 36 NONAME ; void CSconDataproviderInfo::SetImplementationUid(class TUid)
+ ?SetRemoteStoreFormatL@RSconSyncSession@@QAEXABVCSmlDataStoreFormat@@@Z @ 37 NONAME ; void RSconSyncSession::SetRemoteStoreFormatL(class CSmlDataStoreFormat const &)
+ ?SetStoresL@CSconDataproviderInfo@@QAEXABVCDesC16Array@@@Z @ 38 NONAME ; void CSconDataproviderInfo::SetStoresL(class CDesC16Array const &)
+ ?SoftDeleteItemL@RSconSyncSession@@QAEXH@Z @ 39 NONAME ; void RSconSyncSession::SoftDeleteItemL(int)
+ ?SoftDeletedItemsL@RSconSyncSession@@QBEXAAV?$RArray@H@@@Z @ 40 NONAME ; void RSconSyncSession::SoftDeletedItemsL(class RArray<int> &) const
+ ?StoreFormatL@RSconSyncSession@@QAEPAVCSmlDataStoreFormat@@ABVRStringPool@@@Z @ 41 NONAME ; class CSmlDataStoreFormat * RSconSyncSession::StoreFormatL(class RStringPool const &)
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/clients/syncclient/eabi/sconsyncclientu.def Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,49 @@
+EXPORTS
+ _ZN16RSconSyncSession11CreateItemLER5TPckgIiEiRK6TDesC8S5_S5_R14TRequestStatus @ 1 NONAME
+ _ZN16RSconSyncSession11CreateItemLERiiRK6TDesC8S3_S3_ @ 2 NONAME
+ _ZN16RSconSyncSession11DeleteItemLEi @ 3 NONAME
+ _ZN16RSconSyncSession12ReplaceItemLEiiiRK6TDesC8 @ 4 NONAME
+ _ZN16RSconSyncSession12ReplaceItemLEiiiRK6TDesC8R14TRequestStatus @ 5 NONAME
+ _ZN16RSconSyncSession12StoreFormatLERK11RStringPool @ 6 NONAME
+ _ZN16RSconSyncSession13CancelRequestEv @ 7 NONAME
+ _ZN16RSconSyncSession14DeleteAllItemsER14TRequestStatus @ 8 NONAME
+ _ZN16RSconSyncSession14OpenDataStoreLEiRK7TDesC16i @ 9 NONAME
+ _ZN16RSconSyncSession15SoftDeleteItemLEi @ 10 NONAME
+ _ZN16RSconSyncSession16ResetChangeInfoLEv @ 11 NONAME
+ _ZN16RSconSyncSession17CommitChangeInfoLERK6RArrayIiE @ 12 NONAME
+ _ZN16RSconSyncSession21SetRemoteStoreFormatLERK19CSmlDataStoreFormat @ 13 NONAME
+ _ZN16RSconSyncSession23ListAllImplementationsLER13RPointerArrayI21CSconDataproviderInfoE @ 14 NONAME
+ _ZN16RSconSyncSession5CloseEv @ 15 NONAME
+ _ZN16RSconSyncSession7ConnectEv @ 16 NONAME
+ _ZN16RSconSyncSession9GetParentEiRi @ 17 NONAME
+ _ZN16RSconSyncSession9MoveItemLEii @ 18 NONAME
+ _ZN16RSconSyncSession9OpenItemLEiRiS0_R5TDes8S2_R8CBufFlat @ 19 NONAME
+ _ZN16RSconSyncSessionC1Ev @ 20 NONAME
+ _ZN16RSconSyncSessionC2Ev @ 21 NONAME
+ _ZN16RSconSyncSessionD1Ev @ 22 NONAME
+ _ZN16RSconSyncSessionD2Ev @ 23 NONAME
+ _ZN21CSconDataproviderInfo10SetStoresLERK12CDesC16Array @ 24 NONAME
+ _ZN21CSconDataproviderInfo12DisplayNameLEv @ 25 NONAME
+ _ZN21CSconDataproviderInfo12InternalizeLER11RReadStream @ 26 NONAME
+ _ZN21CSconDataproviderInfo13DefaultStoreLEv @ 27 NONAME
+ _ZN21CSconDataproviderInfo15SetDisplayNameLERK7TDesC16 @ 28 NONAME
+ _ZN21CSconDataproviderInfo16SetDefaultStoreLERK7TDesC16 @ 29 NONAME
+ _ZN21CSconDataproviderInfo20SetImplementationUidE4TUid @ 30 NONAME
+ _ZN21CSconDataproviderInfo4NewLEv @ 31 NONAME
+ _ZN21CSconDataproviderInfoD0Ev @ 32 NONAME
+ _ZN21CSconDataproviderInfoD1Ev @ 33 NONAME
+ _ZN21CSconDataproviderInfoD2Ev @ 34 NONAME
+ _ZNK16RSconSyncSession11AddedItemsLER6RArrayIiE @ 35 NONAME
+ _ZNK16RSconSyncSession11MovedItemsLER6RArrayIiE @ 36 NONAME
+ _ZNK16RSconSyncSession13DeletedItemsLER6RArrayIiE @ 37 NONAME
+ _ZNK16RSconSyncSession14CloseDataStoreEv @ 38 NONAME
+ _ZNK16RSconSyncSession14ModifiedItemsLER6RArrayIiE @ 39 NONAME
+ _ZNK16RSconSyncSession15HasSyncHistoryLEv @ 40 NONAME
+ _ZNK16RSconSyncSession17GetSyncTimeStampLEiiR9TDateTime @ 41 NONAME
+ _ZNK16RSconSyncSession17SoftDeletedItemsLER6RArrayIiE @ 42 NONAME
+ _ZNK21CSconDataproviderInfo11ListStoresLEv @ 43 NONAME
+ _ZNK21CSconDataproviderInfo12ExternalizeLER12RWriteStream @ 44 NONAME
+ _ZNK21CSconDataproviderInfo17ImplementationUidEv @ 45 NONAME
+ _ZTI21CSconDataproviderInfo @ 46 NONAME ; #<TI>#
+ _ZTV21CSconDataproviderInfo @ 47 NONAME ; #<VT>#
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/clients/syncclient/group/bld.inf Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,28 @@
+/*
+* Copyright (c) 2009-2010 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: Build information file for project SyncClient
+*
+*/
+
+
+PRJ_EXPORTS
+../rom/sconsyncclient.iby CORE_APP_LAYER_IBY_EXPORT_PATH(sconsyncclient.iby)
+
+PRJ_PLATFORMS
+DEFAULT
+
+PRJ_MMPFILES
+sconsyncclient.mmp
+
+PRJ_TESTMMPFILES
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/clients/syncclient/group/sconsyncclient.mmp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,50 @@
+/*
+* Copyright (c) 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: Client side of sconsyncserver
+*
+*/
+
+
+// To get the MW_LAYER_SYSTEMINCLUDE-definition
+#include <platform_paths.hrh>
+#include <data_caging_paths.hrh>
+
+TARGET sconsyncclient.dll
+TARGETTYPE dll
+
+CAPABILITY CAP_CLIENT_DLL
+
+UID 0x1000008d 0x2001A963
+VENDORID VID_DEFAULT
+
+SOURCEPATH ../src
+SOURCE sconsyncclient.cpp
+SOURCE scondataproviderinfo.cpp
+
+USERINCLUDE ../inc
+USERINCLUDE ../../../inc
+
+// Server
+USERINCLUDE ../../../servers/syncserver/inc
+
+
+// Default system include paths for middleware layer modules.
+MW_LAYER_SYSTEMINCLUDE
+
+LIBRARY euser.lib
+LIBRARY estor.lib
+LIBRARY bafl.lib
+LIBRARY charconv.lib
+LIBRARY smlstoreformat.lib
+DEBUGLIBRARY flogger.lib
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/clients/syncclient/inc/scondataproviderinfo.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,61 @@
+/*
+* Copyright (c) 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: CSconDataproviderInfo header
+*
+*/
+
+
+#ifndef SCONDATAPROVIDERINFO_H_
+#define SCONDATAPROVIDERINFO_H_
+
+#include <e32base.h>
+#include <badesca.h>
+
+class RWriteStream;
+class RReadStream;
+
+/**
+ * Contains information about DataSync dataprovider.
+ */
+class CSconDataproviderInfo : public CBase
+{
+public:
+ IMPORT_C static CSconDataproviderInfo* NewL();
+ IMPORT_C ~CSconDataproviderInfo();
+
+ IMPORT_C void ExternalizeL( RWriteStream& aStream ) const;
+ IMPORT_C void InternalizeL( RReadStream& aStream );
+
+ IMPORT_C TUid ImplementationUid() const;
+ IMPORT_C void SetImplementationUid( const TUid aUid );
+ IMPORT_C TDesC& DisplayNameL();
+ IMPORT_C void SetDisplayNameL( const TDesC& aName );
+ IMPORT_C TDesC& DefaultStoreL();
+ IMPORT_C void SetDefaultStoreL( const TDesC& aStore );
+ IMPORT_C CDesCArray* ListStoresL() const;
+ IMPORT_C void SetStoresL( const CDesCArray& aStores );
+private:
+ CSconDataproviderInfo();
+ void ConstructL();
+
+private:
+ TInt iUid;
+ HBufC* iName;
+ HBufC* iDefaultStore;
+ CDesCArrayFlat* iStores;
+};
+
+typedef RPointerArray<CSconDataproviderInfo> RSconDataProviderInfoArray;
+
+#endif /*SCONDATAPROVIDERINFO_H_*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/clients/syncclient/inc/sconsyncclient.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,99 @@
+/*
+* Copyright (c) 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: RSconSyncSession header
+*
+*/
+
+
+#ifndef _SCONSYNCCLIENT_H_
+#define _SCONSYNCCLIENT_H_
+
+#include <e32base.h>
+#include <e32std.h>
+#include <ecom/ImplementationInformation.h>
+#include <SmlDataProvider.h>
+
+#include "scondataproviderinfo.h"
+
+
+
+class CNSmlDataItemUidSet;
+
+class RSconSyncSession : public RSessionBase
+{
+public:
+ IMPORT_C RSconSyncSession();
+ IMPORT_C ~RSconSyncSession();
+
+ IMPORT_C TInt Connect();
+ IMPORT_C void Close();
+
+ IMPORT_C void ListAllImplementationsL( RSconDataProviderInfoArray& aInfoArray );
+
+ IMPORT_C void OpenDataStoreL( const TSmlDataProviderId aProviderId, const TDesC& aStoreName, const TInt aContextId );
+
+ IMPORT_C void OpenItemL(TSmlDbItemUid aUid, TBool& aFieldChange,
+ TSmlDbItemUid& aParent, TDes8& aMimeType, TDes8& aMimeVer,
+ CBufFlat& aItemData );
+
+ IMPORT_C void CreateItemL(TSmlDbItemUid& aUid, TSmlDbItemUid aParent,
+ const TDesC8& aMimeType, const TDesC8& aMimeVer, const TDesC8& aData);
+ IMPORT_C void CreateItemL(TPckg<TSmlDbItemUid>& aUidPckg, TSmlDbItemUid aParent,
+ const TDesC8& aMimeType, const TDesC8& aMimeVer, const TDesC8& aData,
+ TRequestStatus& aStatus );
+
+ IMPORT_C void ReplaceItemL(TSmlDbItemUid aUid, TSmlDbItemUid aParent,
+ TBool aFieldChange, const TDesC8& aData);
+ IMPORT_C void ReplaceItemL(TSmlDbItemUid aUid, TSmlDbItemUid aParent,
+ TBool aFieldChange, const TDesC8& aData,
+ TRequestStatus& aStatus );
+
+ IMPORT_C void MoveItemL(TSmlDbItemUid aUid, TSmlDbItemUid aNewParent);
+ IMPORT_C void DeleteItemL(TSmlDbItemUid aUid);
+ IMPORT_C void SoftDeleteItemL(TSmlDbItemUid aUid);
+ IMPORT_C void DeleteAllItems( TRequestStatus& aStatus );
+
+ IMPORT_C TBool HasSyncHistoryL() const;
+ IMPORT_C void AddedItemsL( RArray<TSmlDbItemUid>& aItems ) const;
+ IMPORT_C void DeletedItemsL( RArray<TSmlDbItemUid>& aItems ) const;
+ IMPORT_C void SoftDeletedItemsL( RArray<TSmlDbItemUid>& aItems ) const;
+ IMPORT_C void ModifiedItemsL( RArray<TSmlDbItemUid>& aItems ) const;
+ IMPORT_C void MovedItemsL( RArray<TSmlDbItemUid>& aItems ) const;
+
+ IMPORT_C void CloseDataStore() const;
+
+ IMPORT_C void ResetChangeInfoL();
+ IMPORT_C void CommitChangeInfoL(const RArray<TSmlDbItemUid>& aItems );
+
+ IMPORT_C void GetSyncTimeStampL( const TSmlDataProviderId aProviderId, const TInt aContextId, TDateTime& aTimeStamp ) const;
+
+ IMPORT_C CSmlDataStoreFormat* StoreFormatL( const RStringPool& aStringPool );
+ IMPORT_C void SetRemoteStoreFormatL( const CSmlDataStoreFormat& aServerDataStoreFormat );
+
+
+ IMPORT_C void CancelRequest();
+
+ IMPORT_C TInt GetParent( TSmlDbItemUid aUid, TSmlDbItemUid& aParent );
+private:
+ TInt StartServer();
+ TInt CreateAndSendChunkHandle();
+private:
+ RChunk iChunk;
+ TIpcArgs iArgs;
+
+};
+
+#endif // _SCONSYNCCLIENT_H_
+
+// End of File
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/clients/syncclient/rom/sconsyncclient.iby Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,25 @@
+/*
+* Copyright (c) 2010 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: IBY file for SconSyncClient
+*
+*/
+
+#ifndef _SCONSYNCCLIENT_IBY_
+#define _SCONSYNCCLIENT_IBY_
+
+#include <data_caging_paths_for_iby.hrh>
+
+file=ABI_DIR\BUILD_DIR\sconsyncclient.dll SHARED_LIB_DIR\sconsyncclient.dll
+
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/clients/syncclient/src/scondataproviderinfo.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,220 @@
+/*
+* Copyright (c) 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: CSconDataproviderInfo implementation
+*
+*/
+
+
+#include "scondataproviderinfo.h"
+#include <s32strm.h>
+#include <badesca.h>
+#include <utf.h> // for CnvUtfConverter
+#include "debug.h"
+
+CSconDataproviderInfo::CSconDataproviderInfo()
+ {
+ }
+
+EXPORT_C CSconDataproviderInfo::~CSconDataproviderInfo()
+ {
+ delete iName;
+ delete iDefaultStore;
+ delete iStores;
+ }
+
+EXPORT_C CSconDataproviderInfo* CSconDataproviderInfo::NewL()
+ {
+ return new (ELeave) CSconDataproviderInfo();
+ }
+
+EXPORT_C void CSconDataproviderInfo::ExternalizeL( RWriteStream& aStream ) const
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("iUid: 0x%x", iUid);
+ aStream.WriteInt32L( iUid );
+ if ( iName )
+ {
+ HBufC8* temp = CnvUtfConverter::ConvertFromUnicodeToUtf8L( iName->Des() );
+ CleanupStack::PushL( temp );
+ TPtrC8 tempPtr = temp->Des();
+ aStream.WriteUint16L( tempPtr.Length() );
+ aStream.WriteL( tempPtr );
+ CleanupStack::PopAndDestroy( temp );
+ }
+ else
+ {
+ aStream.WriteUint16L( 0 );
+ }
+
+ if ( iDefaultStore )
+ {
+ HBufC8* temp = CnvUtfConverter::ConvertFromUnicodeToUtf8L( iDefaultStore->Des() );
+ CleanupStack::PushL( temp );
+ TPtrC8 tempPtr = temp->Des();
+ aStream.WriteUint16L( tempPtr.Length() );
+ aStream.WriteL( tempPtr );
+ CleanupStack::PopAndDestroy( temp );
+ }
+ else
+ {
+ aStream.WriteUint16L( 0 );
+ }
+ if ( iStores )
+ {
+ aStream.WriteUint16L( iStores->Count() );
+ for ( TInt i=0; i<iStores->Count(); i++ )
+ {
+ TPtrC storePtr = (*iStores)[i];
+ HBufC8* temp = CnvUtfConverter::ConvertFromUnicodeToUtf8L( storePtr );
+ CleanupStack::PushL( temp );
+ TPtrC8 tempPtr = temp->Des();
+ aStream.WriteUint16L( tempPtr.Length() );
+ if ( tempPtr.Length() > 0 )
+ {
+ aStream.WriteL( tempPtr );
+ }
+ CleanupStack::PopAndDestroy( temp );
+ }
+ }
+ else
+ {
+ aStream.WriteUint16L( 0 );
+ }
+ aStream.CommitL();
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void CSconDataproviderInfo::InternalizeL( RReadStream& aStream )
+ {
+ TRACE_FUNC_ENTRY;
+ delete iName;
+ iName = NULL;
+ delete iDefaultStore;
+ iDefaultStore = NULL;
+ delete iStores;
+ iStores = NULL;
+ iStores = new ( ELeave ) CDesCArrayFlat( 1 );
+ iUid = aStream.ReadInt32L();
+ TInt len = aStream.ReadUint16L();
+ if ( len > 0 )
+ {
+ HBufC8* tempBuf = HBufC8::NewLC( len );
+ TPtr8 tempPtr = tempBuf->Des();
+ aStream.ReadL( tempPtr, len );
+
+ iName = CnvUtfConverter::ConvertToUnicodeFromUtf8L( tempPtr );
+ CleanupStack::PopAndDestroy( tempBuf );
+ }
+
+ len = aStream.ReadUint16L();
+ if ( len > 0 )
+ {
+ HBufC8* tempBuf = HBufC8::NewLC( len );
+ TPtr8 tempPtr = tempBuf->Des();
+ aStream.ReadL( tempPtr, len );
+
+ iDefaultStore = CnvUtfConverter::ConvertToUnicodeFromUtf8L( tempPtr );
+ CleanupStack::PopAndDestroy( tempBuf );
+ }
+
+ TInt storeCount = aStream.ReadUint16L();
+ for (TInt i=0; i<storeCount; i++ )
+ {
+ len = aStream.ReadUint16L();
+ if ( len > 0 )
+ {
+ HBufC8* tempBuf8 = HBufC8::NewLC( len );
+ TPtr8 tempPtr8 = tempBuf8->Des();
+ aStream.ReadL( tempPtr8, len );
+
+ HBufC* temp = CnvUtfConverter::ConvertToUnicodeFromUtf8L( tempPtr8 );
+ CleanupStack::PushL( temp );
+ TPtr tempPtr = temp->Des();
+ iStores->AppendL( tempPtr );
+ CleanupStack::PopAndDestroy( temp );
+ CleanupStack::PopAndDestroy( tempBuf8 );
+ }
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C TUid CSconDataproviderInfo::ImplementationUid() const
+ {
+ return TUid::Uid( iUid );
+ }
+
+EXPORT_C void CSconDataproviderInfo::SetImplementationUid( const TUid aUid )
+ {
+ iUid = aUid.iUid;
+ }
+
+EXPORT_C TDesC& CSconDataproviderInfo::DisplayNameL()
+ {
+ if ( iName )
+ {
+ return *iName;
+ }
+ else
+ {
+ iName = KNullDesC().AllocL();
+ return *iName;
+ }
+ }
+
+EXPORT_C void CSconDataproviderInfo::SetDisplayNameL( const TDesC& aName )
+ {
+ delete iName;
+ iName = NULL;
+ iName = aName.AllocL();
+ }
+
+EXPORT_C TDesC& CSconDataproviderInfo::DefaultStoreL()
+ {
+ if ( iDefaultStore )
+ {
+ return *iDefaultStore;
+ }
+ else
+ {
+ iDefaultStore = KNullDesC().AllocL();
+ return *iDefaultStore;
+ }
+ }
+
+EXPORT_C void CSconDataproviderInfo::SetDefaultStoreL( const TDesC& aStore )
+ {
+ delete iDefaultStore;
+ iDefaultStore = NULL;
+ iDefaultStore = aStore.AllocL();
+ }
+
+EXPORT_C CDesCArray* CSconDataproviderInfo::ListStoresL() const
+ {
+ if ( !iStores )
+ {
+ User::Leave( KErrNotFound );
+ }
+ return iStores;
+ }
+
+EXPORT_C void CSconDataproviderInfo::SetStoresL( const CDesCArray& aStores )
+ {
+ delete iStores;
+ iStores = NULL;
+ iStores = new ( ELeave ) CDesCArrayFlat( 1 );
+ for ( TInt i=0; i<aStores.Count(); i++ )
+ {
+ iStores->AppendL( aStores[i] );
+ }
+ }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/clients/syncclient/src/sconsyncclient.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,668 @@
+/*
+* Copyright (c) 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: RSconSyncSession implementation
+*
+*/
+
+
+#include "sconsyncclient.h"
+
+#include <SmlDataProvider.h>
+#include <s32mem.h>
+
+#include "sconsyncclientserver.h"
+#include "debug.h"
+
+const TInt KSConSyncChunkSize = 0xFFFF; // 65535 bytes;
+const TInt KSConSyncChunkMaxSize = 0x400000; // 4194304 bytes
+
+EXPORT_C RSconSyncSession::RSconSyncSession()
+ {
+ TRACE_FUNC;
+ }
+
+EXPORT_C RSconSyncSession::~RSconSyncSession()
+ {
+ TRACE_FUNC;
+ }
+
+EXPORT_C TInt RSconSyncSession::Connect()
+ {
+ TRACE_FUNC_ENTRY;
+ TInt retryCount = 2;
+ TInt error = KErrNone;
+ while(retryCount)
+ {
+ error = CreateSession(KSconSyncServerName, TVersion(1,0,0));
+ if ( error != KErrNotFound && error != KErrServerTerminated )
+ {
+ break;
+ }
+ error = StartServer();
+ if( error != KErrNone && error != KErrAlreadyExists )
+ {
+ break;
+ }
+ --retryCount;
+ }
+
+ if ( error == KErrNone )
+ {
+ error = CreateAndSendChunkHandle();
+ if ( error != KErrNone )
+ {
+ LOGGER_WRITE("CreateAndSendChunkHandle failed, close session");
+ Close();
+ }
+ }
+ TRACE_FUNC_EXIT;
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// RSconSyncSession::Close()
+// Closes the server connection
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void RSconSyncSession::Close()
+ {
+ TRACE_FUNC_ENTRY;
+ iChunk.Close();
+ RSessionBase::Close();
+ TRACE_FUNC_EXIT
+ }
+
+EXPORT_C void RSconSyncSession::ListAllImplementationsL( RSconDataProviderInfoArray& aInfoArray )
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ TInt ret = SendReceive ( EListImplementations, args );
+
+ if ( ret != KErrNone)
+ {
+ LOGGER_WRITE_1( "RSconSyncSession::ListAllImplementationsL() :\
+ Send Receive failed with code %d", ret );
+ User::Leave( ret );
+ };
+
+ // copy data from the chunk
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ TInt count( readStream.ReadUint16L() );
+ LOGGER_WRITE_1("count: %d", count);
+ for ( TInt i=0; i<count; i++ )
+ {
+ LOGGER_WRITE_1("Import[%d]", i);
+ CSconDataproviderInfo *dpInfo = CSconDataproviderInfo::NewL();
+ CleanupStack::PushL( dpInfo );
+
+ dpInfo->InternalizeL( readStream );
+ aInfoArray.AppendL( dpInfo );
+ CleanupStack::Pop( dpInfo );
+ }
+
+ CleanupStack::PopAndDestroy( &readStream );
+
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::OpenDataStoreL( const TSmlDataProviderId aProviderId, const TDesC& aStoreName, TInt aContextId )
+ {
+ TRACE_FUNC_ENTRY;
+ User::LeaveIfError( iChunk.Adjust(
+ sizeof(TInt32)
+ + sizeof(TInt32)
+ + aStoreName.Size()
+ + sizeof(TInt) ));
+
+ RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() );
+ writeBuf.WriteInt32L( aProviderId );
+
+ writeBuf.WriteInt32L( aStoreName.Length() );
+ writeBuf.WriteL( aStoreName );
+
+ writeBuf.WriteInt32L( aContextId );
+
+ writeBuf.CommitL();
+ writeBuf.Close();
+
+ TIpcArgs args;
+ TInt ret = SendReceive ( EOpenStore, args );
+
+ if ( ret != KErrNone)
+ {
+ LOGGER_WRITE_1( "RSconSyncSession::OpenDataStoreL() :\
+ Send Receive failed with code %d", ret );
+ User::Leave( ret );
+ };
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::OpenItemL( TSmlDbItemUid aUid, TBool& aFieldChange,
+ TSmlDbItemUid& aParent, TDes8& aMimeType, TDes8& aMimeVer, CBufFlat& aItemData )
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args( aUid );
+ TInt ret = SendReceive ( EOpenItem, args );
+ if ( ret != KErrNone)
+ {
+ LOGGER_WRITE_1( "RSconSyncSession::OpenItemL() :\
+ Send Receive failed with code %d", ret );
+ User::Leave( ret );
+ };
+
+ // copy data from the chunk
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+ TInt32 length ( 0 );
+
+ aItemData.Reset();
+ length = readStream.ReadInt32L();
+
+ HBufC8* data = HBufC8::NewLC( length );
+ TPtr8 dataPtr = data->Des();
+
+ readStream.ReadL( dataPtr, length );
+ aItemData.ExpandL( 0, length );
+ aItemData.Write ( 0, dataPtr );
+
+ CleanupStack::PopAndDestroy( data );
+
+ aFieldChange = readStream.ReadInt8L();
+
+ aParent = readStream.ReadInt32L();
+ length = readStream.ReadInt32L();
+ readStream.ReadL( aMimeType, length );
+
+ length = readStream.ReadInt32L();
+ readStream.ReadL( aMimeVer, length );
+
+ CleanupStack::PopAndDestroy( &readStream );
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::CreateItemL(TSmlDbItemUid& aUid/*, TInt aSize*/,
+ TSmlDbItemUid aParent, const TDesC8& aMimeType, const TDesC8& aMimeVer,
+ const TDesC8& aData)
+ {
+ TRACE_FUNC_ENTRY;
+ User::LeaveIfError( iChunk.Adjust(
+ sizeof(TInt32)
+ + sizeof(TInt32)
+ + aMimeType.Length()
+ + sizeof(TInt32)
+ + aMimeVer.Length()
+ + sizeof(TInt32)
+ + aData.Length() ));
+ RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( writeBuf );
+ writeBuf.WriteInt32L( aParent );
+ writeBuf.WriteInt32L( aMimeType.Length() );
+ writeBuf.WriteL( aMimeType );
+ writeBuf.WriteInt32L( aMimeVer.Length() );
+ writeBuf.WriteL( aMimeVer );
+ writeBuf.WriteInt32L( aData.Length() );
+ writeBuf.WriteL( aData );
+
+ writeBuf.CommitL();
+ CleanupStack::PopAndDestroy( &writeBuf );
+
+
+
+ TPckg<TSmlDbItemUid> pckg(aUid);
+ iArgs = TIpcArgs( &pckg );
+
+ TInt ret = SendReceive ( ECreateItem, iArgs );
+ if ( ret != KErrNone)
+ {
+ LOGGER_WRITE_1( "RSconSyncSession::CreateItemL() :\
+ Send Receive failed with code %d", ret );
+ User::Leave( ret );
+ };
+ LOGGER_WRITE_1("aUid: %d", aUid);
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::CreateItemL(TPckg<TSmlDbItemUid>& aUidPckg,
+ TSmlDbItemUid aParent, const TDesC8& aMimeType, const TDesC8& aMimeVer,
+ const TDesC8& aData, TRequestStatus& aStatus)
+ {
+ TRACE_FUNC_ENTRY;
+ User::LeaveIfError( iChunk.Adjust(
+ sizeof(TInt32)
+ + sizeof(TInt32)
+ + aMimeType.Length()
+ + sizeof(TInt32)
+ + aMimeVer.Length()
+ + sizeof(TInt32)
+ + aData.Length() ));
+ RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( writeBuf );
+ writeBuf.WriteInt32L( aParent );
+ writeBuf.WriteInt32L( aMimeType.Length() );
+ writeBuf.WriteL( aMimeType );
+ writeBuf.WriteInt32L( aMimeVer.Length() );
+ writeBuf.WriteL( aMimeVer );
+ writeBuf.WriteInt32L( aData.Length() );
+ writeBuf.WriteL( aData );
+
+ writeBuf.CommitL();
+ CleanupStack::PopAndDestroy( &writeBuf );
+
+ iArgs = TIpcArgs( &aUidPckg );
+ SendReceive( ECreateItem, iArgs, aStatus );
+
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::ReplaceItemL(TSmlDbItemUid aUid,
+ TSmlDbItemUid aParent, TBool aFieldChange, const TDesC8& aData)
+ {
+ TRACE_FUNC_ENTRY;
+ User::LeaveIfError( iChunk.Adjust(
+ sizeof(TInt32)
+ + sizeof(TInt32)
+ + sizeof(TInt8)
+ + sizeof(TInt32)
+ + aData.Length() ));
+ RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( writeBuf );
+ writeBuf.WriteInt32L( aUid );
+ writeBuf.WriteInt32L( aParent );
+ writeBuf.WriteInt8L( aFieldChange );
+ writeBuf.WriteInt32L( aData.Length() );
+ writeBuf.WriteL( aData );
+ writeBuf.CommitL();
+ CleanupStack::PopAndDestroy( &writeBuf );
+
+ TIpcArgs args;
+ TInt ret = SendReceive( EReplaceItem, args );
+ if ( ret != KErrNone)
+ {
+ LOGGER_WRITE_1( "RSconSyncSession::ReplaceItemL() :\
+ Send Receive failed with code %d", ret );
+ User::Leave( ret );
+ };
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::ReplaceItemL(TSmlDbItemUid aUid,
+ TSmlDbItemUid aParent, TBool aFieldChange, const TDesC8& aData,
+ TRequestStatus& aStatus)
+ {
+ TRACE_FUNC_ENTRY;
+ User::LeaveIfError( iChunk.Adjust(
+ sizeof(TInt32)
+ + sizeof(TInt32)
+ + sizeof(TInt8)
+ + sizeof(TInt32)
+ + aData.Length() ));
+ RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( writeBuf );
+ writeBuf.WriteInt32L( aUid );
+ writeBuf.WriteInt32L( aParent );
+ writeBuf.WriteInt8L( aFieldChange );
+ writeBuf.WriteInt32L( aData.Length() );
+ writeBuf.WriteL( aData );
+ writeBuf.CommitL();
+ CleanupStack::PopAndDestroy( &writeBuf );
+
+ TIpcArgs args;
+ SendReceive( EReplaceItem, args, aStatus );
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::MoveItemL( TSmlDbItemUid aUid, TSmlDbItemUid aNewParent )
+ {
+ TRACE_FUNC_ENTRY;
+
+ TIpcArgs args(aUid, aNewParent);
+ TInt ret = SendReceive ( EMoveItem, args );
+ if ( ret != KErrNone)
+ {
+ LOGGER_WRITE_1( "RSconSyncSession::MoveItemL() :\
+ Send Receive failed with code %d", ret );
+ User::Leave( ret );
+ };
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::DeleteItemL( TSmlDbItemUid aUid )
+ {
+ TRACE_FUNC_ENTRY;
+
+ TIpcArgs args( aUid );
+ TInt ret = SendReceive ( EDeleteItem, args );
+ if ( ret != KErrNone)
+ {
+ LOGGER_WRITE_1( "RSconSyncSession::DeleteItemL() :\
+ Send Receive failed with code %d", ret );
+ User::Leave( ret );
+ };
+ TRACE_FUNC_EXIT;
+ }
+
+
+EXPORT_C void RSconSyncSession::SoftDeleteItemL( TSmlDbItemUid aUid )
+ {
+ TRACE_FUNC_ENTRY;
+
+ TIpcArgs args( aUid );
+ TInt ret = SendReceive ( ESoftDeleteItem, args );
+ if ( ret != KErrNone)
+ {
+ LOGGER_WRITE_1( "RSconSyncSession::SoftDeleteItemL() :\
+ Send Receive failed with code %d", ret );
+ User::Leave( ret );
+ };
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::DeleteAllItems( TRequestStatus& aStatus )
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ SendReceive( EDeleteAllItems, args, aStatus );
+ TRACE_FUNC_EXIT;
+ }
+
+
+EXPORT_C TBool RSconSyncSession::HasSyncHistoryL() const
+ {
+ TRACE_FUNC;
+ TBool history(EFalse);
+ TPckg<TBool> pck(history);
+ TIpcArgs args(&pck);
+ TInt ret = SendReceive ( EHasHistory, args );
+ User::LeaveIfError( ret );
+ TRACE_FUNC_EXIT;
+ return history;
+ }
+
+EXPORT_C void RSconSyncSession::AddedItemsL( RArray<TSmlDbItemUid>& aItems) const
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ TInt ret = SendReceive ( EAddedItems, args );
+ User::LeaveIfError( ret );
+
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ aItems.Reset();
+ TInt itemCount = readStream.ReadInt32L();
+ for (TInt i=0; i<itemCount; i++)
+ {
+ aItems.AppendL( readStream.ReadInt32L() );
+ }
+
+ CleanupStack::PopAndDestroy( &readStream );
+
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::DeletedItemsL( RArray<TSmlDbItemUid>& aItems) const
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ TInt ret = SendReceive ( EDeletedItems, args );
+ User::LeaveIfError( ret );
+
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ aItems.Reset();
+ TInt itemCount = readStream.ReadInt32L();
+ for (TInt i=0; i<itemCount; i++)
+ {
+ aItems.AppendL( readStream.ReadInt32L() );
+ }
+
+ CleanupStack::PopAndDestroy( &readStream );
+
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::SoftDeletedItemsL( RArray<TSmlDbItemUid>& aItems) const
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ TInt ret = SendReceive ( ESoftDeletedItems, args );
+ User::LeaveIfError( ret );
+
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ aItems.Reset();
+ TInt itemCount = readStream.ReadInt32L();
+ for (TInt i=0; i<itemCount; i++)
+ {
+ aItems.AppendL( readStream.ReadInt32L() );
+ }
+
+ CleanupStack::PopAndDestroy( &readStream );
+
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::ModifiedItemsL( RArray<TSmlDbItemUid>& aItems) const
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ TInt ret = SendReceive ( EModifiedItems, args );
+ User::LeaveIfError( ret );
+
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ aItems.Reset();
+ TInt itemCount = readStream.ReadInt32L();
+ for (TInt i=0; i<itemCount; i++)
+ {
+ aItems.AppendL( readStream.ReadInt32L() );
+ }
+
+ CleanupStack::PopAndDestroy( &readStream );
+
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::MovedItemsL( RArray<TSmlDbItemUid>& aItems) const
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ TInt ret = SendReceive ( EMovedItems, args );
+ User::LeaveIfError( ret );
+
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ aItems.Reset();
+ TInt itemCount = readStream.ReadInt32L();
+ for (TInt i=0; i<itemCount; i++)
+ {
+ aItems.AppendL( readStream.ReadInt32L() );
+ }
+
+ CleanupStack::PopAndDestroy( &readStream );
+
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::CloseDataStore() const
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ SendReceive ( ECloseStore, args );
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::ResetChangeInfoL()
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ TInt ret = SendReceive ( EResetChangeInfo, args );
+ User::LeaveIfError( ret );
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::CommitChangeInfoL(const RArray<TSmlDbItemUid>& aItems )
+ {
+ TRACE_FUNC_ENTRY;
+ RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( stream );
+ LOGGER_WRITE_1("items count: %d", aItems.Count());
+ stream.WriteInt32L( aItems.Count() );
+ for (TInt i=0; i < aItems.Count(); i++ )
+ {
+ LOGGER_WRITE("Write item");
+ stream.WriteInt32L( aItems[i] );
+ }
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+
+ TIpcArgs args;
+ TInt ret = SendReceive ( ECommitChangeInfo, args );
+ User::LeaveIfError( ret );
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::GetSyncTimeStampL( const TSmlDataProviderId aProviderId, const TInt aContextId, TDateTime& aTimeStamp ) const
+ {
+ TRACE_FUNC_ENTRY;
+
+ TPckg<TDateTime> timeBuf( aTimeStamp );
+ TIpcArgs args( aProviderId, aContextId, &timeBuf );
+ TInt ret = SendReceive ( EGetSyncTimeStamp, args );
+ User::LeaveIfError( ret );
+
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C CSmlDataStoreFormat* RSconSyncSession::StoreFormatL( const RStringPool& aStringPool )
+ {
+ TRACE_FUNC_ENTRY;
+ TIpcArgs args;
+ TInt ret = SendReceive ( EExportStoreFormat, args );
+ User::LeaveIfError( ret );
+
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+ TInt len = readStream.ReadInt32L();
+ LOGGER_WRITE_1("data size from server: %d", len);
+ LOGGER_WRITE("CSmlDataStoreFormat::NewLC");
+ CSmlDataStoreFormat* tempStoreFormat = CSmlDataStoreFormat::NewLC( aStringPool, readStream );
+ LOGGER_WRITE("CSmlDataStoreFormat::NewLC -ok");
+ CleanupStack::Pop( tempStoreFormat );
+
+ LOGGER_WRITE("PopAndDestroy( &readStream )");
+ CleanupStack::PopAndDestroy( &readStream );
+ LOGGER_WRITE("return");
+ TRACE_FUNC_EXIT;
+ return tempStoreFormat;
+ }
+
+EXPORT_C void RSconSyncSession::SetRemoteStoreFormatL( const CSmlDataStoreFormat& aServerDataStoreFormat )
+ {
+ TRACE_FUNC_ENTRY;
+ const TInt KMaximumDataStoreFormatSize = 100000; // 100kb should be enought
+ User::LeaveIfError( iChunk.Adjust( KMaximumDataStoreFormatSize ));
+
+ RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( stream );
+
+ aServerDataStoreFormat.ExternalizeL( stream );
+
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+
+ TIpcArgs args;
+ TInt ret = SendReceive ( ESetRemoteStoreFormat, args );
+ User::LeaveIfError( ret );
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void RSconSyncSession::CancelRequest()
+ {
+ TRACE_FUNC_ENTRY;
+ SendReceive( ECancelRequest, TIpcArgs() );
+ TRACE_FUNC_EXIT;
+ }
+
+EXPORT_C TInt RSconSyncSession::GetParent( TSmlDbItemUid aUid, TSmlDbItemUid& aParent )
+ {
+ TRACE_FUNC_ENTRY;
+ TPckg<TSmlDbItemUid> pckg(aParent);
+ TIpcArgs args( aUid, &pckg );
+ TInt ret = SendReceive( EReadParent, args );
+ TRACE_FUNC_EXIT;
+ return ret;
+ }
+
+TInt RSconSyncSession::StartServer()
+ {
+ TRACE_FUNC_ENTRY;
+
+ RProcess server;
+ TInt error = server.Create(KSconSyncServerExe, KNullDesC);
+ if ( error != KErrNone )
+ {
+ return error;
+ }
+ // start server and wait for signal before proceeding
+ TRequestStatus status;
+ server.Rendezvous(status);
+ if ( status.Int() != KRequestPending )
+ {
+ server.Kill(0);
+ }
+ else
+ {
+ server.Resume();
+ }
+
+ User::WaitForRequest( status );
+ error = server.ExitType() == EExitPanic ? KErrGeneral : status.Int();
+ server.Close();
+ TRACE_FUNC_EXIT;
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// RSconSyncSession::CreateAndSendChunkHandle()
+// Creates a chunk and sends a handle to server
+// -----------------------------------------------------------------------------
+//
+TInt RSconSyncSession::CreateAndSendChunkHandle()
+ {
+ TRACE_FUNC_ENTRY;
+
+ TInt err = iChunk.CreateGlobal( KNullDesC,
+ KSConSyncChunkSize,
+ KSConSyncChunkMaxSize );
+ if ( err != KErrNone )
+ {
+ LOGGER_WRITE_1("iChunk.CreateGlobal failed, err: %d", err);
+ return err;
+ }
+ TIpcArgs args;
+ args.Set( 0, iChunk );
+ err = SendReceive( ESendChunkHandle, args );
+
+ LOGGER_WRITE_1("RSconSyncSession::CreateAndSendChunkHandle : returned: %d", err);
+ return err;
+ }
+
+// End of File
--- a/connectivitymodules/SeCon/common/conmltask/inc/sconconmltask.h Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/common/conmltask/inc/sconconmltask.h Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2010 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"
@@ -212,7 +212,7 @@
{
public:
CSConInstApp() {};
- ~CSConInstApp() {};
+ ~CSConInstApp();
CSConInstApp* CopyL();
TFileName iName;
@@ -222,6 +222,7 @@
TInt64 iSize;
TSConAppType iType;
TUid iUid;
+ HBufC* iWidgetBundleId; // Widget bundle identifier like "com.nokia.widget.HelloWorld"
};
//============================================================
--- a/connectivitymodules/SeCon/common/conmltask/src/sconconmltask.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/common/conmltask/src/sconconmltask.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2010 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"
@@ -161,6 +161,10 @@
return copy;
}
+CSConInstApp::~CSConInstApp()
+ {
+ delete iWidgetBundleId;
+ }
// -----------------------------------------------------------------------------
// CSConInstApp::Copy()
//
@@ -177,6 +181,14 @@
copy->iSize = iSize;
copy->iType = iType;
copy->iUid = iUid;
+ if ( iWidgetBundleId )
+ {
+ copy->iWidgetBundleId = iWidgetBundleId->AllocL();
+ }
+ else
+ {
+ copy->iWidgetBundleId = NULL;
+ }
return copy;
}
--- a/connectivitymodules/SeCon/group/bld.inf Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/group/bld.inf Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2002-2010 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"
@@ -22,9 +22,14 @@
#include "../services/csc/bld/bld.inf"
#include "../services/ftp/bld/bld.inf"
#include "../services/pcd/bld/bld.inf"
+
#include "../wbxml/conmlhandler/bld/bld.inf"
#include "../servers/pcconn/bld/bld.inf"
+#include "../servers/syncserver/group/bld.inf"
+
#include "../clients/pcconn/bld/bld.inf"
+#include "../clients/syncclient/group/bld.inf"
+
#include "../plugins/pcconn/bld/bld.inf"
#include "../plugins/ftp/bld/bld.inf"
#include "../plugins/hapticsconnplugin/group/bld.inf"
Binary file connectivitymodules/SeCon/group/stubs/secon_stub.SIS has changed
--- a/connectivitymodules/SeCon/group/stubs/secon_stub.pkg Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/group/stubs/secon_stub.pkg Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
;
-; Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+; Copyright (c) 2010 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"
@@ -17,7 +17,7 @@
&EN
; Header
-#{"Service Controllers"},(0x101F99F6),1,0,0, TYPE=SA
+#{"Service Controllers"},(0x101F99F6),1,72,0, TYPE=SA
; Localised Vendor name
%{"Nokia"}
--- a/connectivitymodules/SeCon/servers/pcconn/bld/sconpcconnserver.mmp Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/servers/pcconn/bld/sconpcconnserver.mmp Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2010 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"
@@ -27,14 +27,17 @@
TARGET sconpcconnserver.exe
TARGETTYPE exe
-EPOCSTACKSIZE 49152
-EPOCHEAPSIZE 0x10000 0x800000
+EPOCSTACKSIZE 0x10000
+EPOCHEAPSIZE 0x10000 0x1000000 // heap memory 16MB
UID 0 0x101F99F6
// Server
SOURCEPATH ../src
SOURCE sconpcconnserver.cpp
+SOURCE sconimsireader.cpp
+SOURCE sconfolderlister.cpp
+SOURCE sconbtengine.cpp
// ConML
SOURCEPATH ../../../wbxml/conmlhandler/src
@@ -49,6 +52,7 @@
USERINCLUDE ../../../common/conmltask/inc
USERINCLUDE ../../../services/pcd/inc
USERINCLUDE ../../../services/csc/inc
+USERINCLUDE ../../../services/oviaccounthandler/inc
USERINCLUDE ../../../wbxml/conmlhandler/inc
// Default system include paths for middleware layer modules.
@@ -58,4 +62,16 @@
LIBRARY estor.lib // RMemWriteStream, RMemReadStream
LIBRARY efsrv.lib // Rfs, RFile
LIBRARY charconv.lib // For Unicode conversion
+LIBRARY etel3rdparty.lib
+LIBRARY platformenv.lib // For pathinfo
+LIBRARY directorylocalizer.lib // For localizing directories
+LIBRARY centralrepository.lib
+LIBRARY commonengine.lib // For resource reader
+LIBRARY bafl.lib // Basic Application Framework Library
+LIBRARY btengdevman.lib
+LIBRARY btmanclient.lib
+LIBRARY btdevice.lib
+LIBRARY bluetooth.lib
+LIBRARY btengsettings.lib
DEBUGLIBRARY flogger.lib
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/pcconn/inc/sconbtengine.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,82 @@
+/*
+* Copyright (c) 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: CSconBtEngine declaration
+*
+*/
+
+
+
+#ifndef SCONBTENGINE_H_
+#define SCONBTENGINE_H_
+
+#include <e32std.h>
+#include <e32base.h>
+#include <s32mem.h>
+#include <BTEngDevMan.h>
+#include <btengsettings.h>
+
+const TInt KCenRepAddrBufSize = 2 * KBTDevAddrSize;
+
+class CSconBtEngine : public CBase,
+ public MBTEngDevManObserver,
+ public MBTEngSettingsObserver
+ {
+public:
+ static CSconBtEngine* NewL();
+ ~CSconBtEngine();
+
+ void ReadBTInfoL( RBufWriteStream& aStream );
+
+ void SetBtAuthorizedL( const TDesC& aBtDevAddress, TBool aAuthorized );
+
+ TInt SetBtPowerState( TBool aPower );
+
+ TInt SetBtName( const TDesC& aBtName );
+
+protected:
+ // From MBTEngDevManObserver
+ void HandleDevManComplete( TInt aErr );
+ void HandleGetDevicesComplete( TInt aErr,
+ CBTDeviceArray* aDeviceArray );
+
+ // From MBTEngSettingsObserver
+ void PowerStateChanged( TBTPowerStateValue aState );
+ void VisibilityModeChanged( TBTVisibilityMode aState );
+
+private:
+ CSconBtEngine();
+ void ConstructL();
+
+ void PrintDevicesL();
+
+private:
+ enum TState
+ {
+ EIdle,
+ ERequestBtInfo,
+ EChangeBtState,
+ EChangeAuthorized
+ };
+ TState iState;
+ TInt iOperationError;
+ CActiveSchedulerWait iWait;
+ RBufWriteStream* iStream;
+ CBTEngDevMan* iBtEng;
+ CBTDeviceArray* iBtDevArray;
+ CBTEngSettings* iBtSettings;
+ TBool iAuthorizedValue;
+ TBuf<KCenRepAddrBufSize> iBtAddress;
+ };
+
+#endif /* SCONBTENGINE_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/pcconn/inc/sconfolderlister.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,136 @@
+/*
+* Copyright (c) 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: CSconFolderLister declaration
+*
+*/
+
+
+#ifndef CSCONFOLDERLISTER_H
+#define CSCONFOLDERLISTER_H
+
+// INCLUDES
+#include <e32std.h>
+#include <e32base.h>
+#include <s32mem.h> // For RMemReadStream
+#include <f32file.h>
+// CLASS DECLARATION
+
+class TSconDriveInfoEntry
+ {
+public:
+ TUint8 iDriveType;
+ TUint8 iDriveTypeCount;
+ TInt64 iSize;
+ TInt64 iFree;
+ };
+
+class TSconDriveInfo : public TSconDriveInfoEntry
+ {
+public:
+ TUint iDriveStatus;
+ TBuf16<2> iDriveLetter;
+ TUint iDriveAttr;
+ TBufC<KMaxFileName> iVolumeName;
+ };
+
+
+class CSconFolderEntry : public CBase
+ {
+public:
+ static CSconFolderEntry* NewLC();
+ static CSconFolderEntry* NewLC( const TEntry& aEntry );
+ ~CSconFolderEntry();
+private:
+ CSconFolderEntry();
+ void ConstructL( const TEntry& aEntry );
+
+public:
+ TUint iAtt;
+ TTime iModified;
+ HBufC *iName;
+ HBufC *iLabel;
+ TBool iDriveInfoEntryExists;
+ TSconDriveInfoEntry iDriveInfoEntry;
+ };
+
+
+class CDirectoryLocalizer;
+
+/**
+ * CSconFolderLister
+ *
+ */
+class CSconFolderLister : public CBase
+ {
+public:
+ // Constructors and destructor
+
+ /**
+ * Destructor.
+ */
+ ~CSconFolderLister();
+
+ /**
+ * Two-phased constructor.
+ */
+ static CSconFolderLister* NewL( RFs& aFs );
+
+ /**
+ *
+ * @param aStream
+ * @param aStartPath
+ * @param aLevelsToSearch -1 = Search all levels, 0 = Search only current level, 1..N Search N levels
+ */
+ void GenerateFolderListL( RBufWriteStream& aStream, const TDesC& aStartPath, const TInt aLevelsToSearch );
+
+private:
+
+ void ListAllDrivesL( RBufWriteStream& aStream, const TInt aLevelsToSearch );
+ void ListDriveAndPathL( RBufWriteStream& aStream, TInt aDrive, const TDesC& aStartPath, const TInt aLevelsToSearch );
+
+ void ExportDriveL( RBufWriteStream& aStream, const TSconDriveInfo& aDriveInfo,
+ const TDesC& aPathName, const TInt aLevelsToSearch );
+
+ /**
+ *
+ * @param aStream
+ * @param aPathName
+ */
+ void ExportPathL( RBufWriteStream& aStream, const TDesC& aPathName,
+ const CSconFolderEntry& aEntry, const TBool aLocalize, const TInt aLevelsToSearch );
+
+ void GetDriveTypeNumberL( TInt aDrive , TUint driveStatus, TInt& aTypeNumber);
+
+ /**
+ * Constructor for performing 1st stage construction
+ */
+ CSconFolderLister( RFs& aFs );
+
+ /**
+ * EPOC default constructor for performing 2nd stage construction
+ */
+ void ConstructL();
+
+ TBool IsDirectoryPrintable( const TDesC& aParentPath, const TEntry& aFolderEntry );
+
+ void GetLocalizedVolumeNameL( CSconFolderEntry& aDriveEntry );
+private:
+ RFs& iFs;
+ TInt iFolders;
+ TInt iFiles;
+ TInt iCriticalLevel;
+ CDirectoryLocalizer* iLocalizer;
+ };
+
+#endif // CSCONFOLDERLISTER_H
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/pcconn/inc/sconimsireader.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,65 @@
+/*
+* Copyright (c) 2009-2010 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: Imsi reader
+*
+*/
+
+
+#ifndef __SCONIMSIREADER_H__
+#define __SCONIMSIREADER_H__
+
+#include <e32base.h>
+#include <Etel3rdParty.h>
+
+enum TImsiReaderStatus
+ {
+ EIdle,
+ ERequestingImsi,
+ ERequestingNetworkStatus
+ };
+
+class CSconImsiReader : public CActive
+ {
+ public:
+
+ static TInt GetImsiL( TDes& aImsi );
+
+ static TInt GetNetworkStatusL( CTelephony::TRegistrationStatus& aRegistrationStatus );
+
+ private:
+ CSconImsiReader( TDes& aImsi, CTelephony::TRegistrationStatus& aRegistrationStatus );
+ void ConstructL();
+ ~CSconImsiReader();
+
+ void RequestImsi();
+ void RequestNetworkStatus();
+
+ private: // From CActive
+
+ void RunL();
+ void DoCancel();
+
+ private: // data
+ TDes& iImsi;
+ CTelephony::TRegistrationStatus& iNetworkStatus;
+ CTelephony* iTelephony;
+ CTelephony::TSubscriberIdV1 iSubscriberIdV1;
+ CTelephony::TSubscriberIdV1Pckg iSubscriberIdV1Pckg;
+
+ CTelephony::TNetworkRegistrationV1 iNetworkRegistrationV1;
+ CTelephony::TNetworkRegistrationV1Pckg iNetworkRegistrationV1Pckg;
+ TImsiReaderStatus iImsiReaderStatus;
+ };
+
+#endif // __SCONIMSIREADER_H__
--- a/connectivitymodules/SeCon/servers/pcconn/inc/sconpcconnserver.h Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/servers/pcconn/inc/sconpcconnserver.h Thu Aug 19 10:44:03 2010 +0300
@@ -127,6 +127,10 @@
};
+
+class CSconFolderLister;
+class CSconBtEngine;
+
//**********************************
//CSConPCConnSession - Server session class, handles the requested operations
//**********************************
@@ -216,7 +220,9 @@
TDesC8& HashToDesLC( const TDesC& aBuf );
TPtr DesToHashLC( const TDesC8& aDes );
TBool IsJavaHash( const TDesC8& aDes );
-
+
+ TInt ReadOviAccountInfoL( RWriteStream& aAccountInfoStream );
+
// data
private:
CSConPCConnServer& iServer;
@@ -232,6 +238,10 @@
RChunk iChunk;
CBufFlat* iBuffer;
TInt iResult;
+
+ CSconFolderLister* iFolderLister;
+ RFs iFs;
+ CSconBtEngine* iBtEngine;
};
#endif // __SCONPCCONNSERVER_H__
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/pcconn/src/sconbtengine.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,415 @@
+/*
+* Copyright (c) 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: CSconBtEngine implementation
+*
+*/
+
+
+
+#include <centralrepository.h>
+#include <btengdomaincrkeys.h>
+
+#include <e32property.h>
+#include <bttypes.h>
+#include <bt_subscribe.h>
+
+#include "sconbtengine.h"
+#include "debug.h"
+
+CSconBtEngine* CSconBtEngine::NewL()
+ {
+ TRACE_FUNC;
+ CSconBtEngine* self = new (ELeave) CSconBtEngine();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+CSconBtEngine::~CSconBtEngine()
+ {
+ TRACE_FUNC;
+ if ( iBtEng )
+ {
+ iBtEng->Cancel();
+ delete iBtEng;
+ }
+
+ delete iBtSettings;
+ }
+
+CSconBtEngine::CSconBtEngine()
+ {
+ }
+
+void CSconBtEngine::ConstructL()
+ {
+ iBtEng = CBTEngDevMan::NewL( this );
+ iBtSettings = CBTEngSettings::NewL( this );
+ iState = EIdle;
+ }
+
+void CSconBtEngine::ReadBTInfoL( RBufWriteStream& aStream )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( iState != EIdle )
+ {
+ User::Leave( KErrInUse );
+ }
+ iStream = &aStream;
+ iOperationError = KErrNone;
+
+ // Write local name (8 bit name length + unicode name)
+ TBuf<100> localName;
+ TInt err = iBtSettings->GetLocalName( localName );
+ User::LeaveIfError( err );
+ LOGGER_WRITE_1("localName: %S", &localName);
+ iStream->WriteUint8L( localName.Length() );
+ iStream->WriteL( localName, localName.Length() );
+
+ if ( iBtAddress.Length() == 0 )
+ {
+ LOGGER_WRITE("Try to read bt address");
+
+ CRepository* cenRep = NULL;
+ // Use TRAP to catch a leave if the CenRep key does not exist.
+ TRAP( err, cenRep = CRepository::NewL( KCRUidBluetoothLocalDeviceAddress ) );
+ CleanupStack::PushL( cenRep );
+ if( !err )
+ {
+ err = cenRep->Get( KBTLocalDeviceAddress, iBtAddress );
+ LOGGER_WRITE_1("cenRep->Get err: %d", err);
+ }
+ CleanupStack::PopAndDestroy( cenRep );
+
+ if ( err )
+ {
+ iBtAddress.Zero();
+ }
+ }
+
+ // Write bt address (8 bit addr length + unicode address)
+ if ( iBtAddress.Length() > 0 )
+ {
+ LOGGER_WRITE_1("btAddr: %S", &iBtAddress);
+ iStream->WriteUint8L( iBtAddress.Length() );
+ iStream->WriteL( iBtAddress, iBtAddress.Length() );
+ }
+ else
+ {
+ iStream->WriteUint8L( 0 );
+ }
+
+ // Write BT Power State (8-bit, 0=Off, 1=On)
+ TBTPowerStateValue state;
+ err = iBtSettings->GetPowerState( state );
+ User::LeaveIfError( err );
+ LOGGER_WRITE_1("PowerState: %d", state);
+ iStream->WriteUint8L( state );
+
+ // Get device info
+ TBTRegistrySearch crit;
+ crit.FindAll();
+ if ( !iBtDevArray )
+ {
+ LOGGER_WRITE("create arr");
+ iBtDevArray = new (ELeave) CBTDeviceArray(5);
+ LOGGER_WRITE("create arr -ok");
+ }
+ else
+ {
+ iBtDevArray->ResetAndDestroy();
+ }
+ err = iBtEng->GetDevices( crit, iBtDevArray );
+ LOGGER_WRITE_1("GetDevices err: %d", err);
+ User::LeaveIfError( err );
+ iState = ERequestBtInfo;
+
+ // Wait until completed
+ iWait.Start();
+ iState = EIdle;
+ if ( iOperationError )
+ {
+ LOGGER_WRITE_1("Operation failed, leave %d", iOperationError);
+ User::Leave( iOperationError );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconBtEngine::SetBtAuthorizedL( const TDesC& aBtDevAddress, TBool aAuthorized )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( iState != EIdle )
+ {
+ User::Leave( KErrInUse );
+ }
+
+ TBTRegistrySearch crit;
+ TBTDevAddr addr;
+ addr.SetReadable( aBtDevAddress );
+ crit.FindAddress( addr );
+
+ if ( !iBtDevArray )
+ {
+ LOGGER_WRITE("create arr");
+ iBtDevArray = new (ELeave) CBTDeviceArray(5);
+ LOGGER_WRITE("create arr -ok");
+ }
+ else
+ {
+ iBtDevArray->ResetAndDestroy();
+ }
+ TInt err = iBtEng->GetDevices( crit, iBtDevArray );
+ LOGGER_WRITE_1("GetDevices err: %d", err);
+ User::LeaveIfError( err );
+ iState = EChangeAuthorized;
+ iOperationError = KErrNone;
+ iAuthorizedValue = aAuthorized;
+
+ // Wait until completed
+ iWait.Start();
+ iState = EIdle;
+ if ( iOperationError )
+ {
+ LOGGER_WRITE_1("Operation failed, leave %d", iOperationError);
+ User::Leave( iOperationError );
+
+ }
+
+ TRACE_FUNC_EXIT;
+ }
+
+TInt CSconBtEngine::SetBtPowerState( TBool aPower )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( iState != EIdle )
+ {
+ return KErrInUse;
+ }
+
+ TBTPowerStateValue state;
+ iOperationError = iBtSettings->GetPowerState( state );
+ if ( iOperationError )
+ {
+ return iOperationError;
+ }
+ else if ( ( aPower && state == EBTPowerOn )
+ || ( !aPower && state == EBTPowerOff ) )
+ {
+ // No need to change state
+ return KErrNone;
+ }
+
+ state = EBTPowerOff;
+ if ( aPower )
+ {
+ state = EBTPowerOn;
+ }
+ iOperationError = iBtSettings->SetPowerState( state );
+ if ( iOperationError )
+ {
+ return iOperationError;
+ }
+ iState = EChangeBtState;
+
+ // Wait until completed
+ iWait.Start();
+
+ iState = EIdle;
+ TRACE_FUNC_RET( iOperationError );
+ return iOperationError;
+ }
+
+TInt CSconBtEngine::SetBtName( const TDesC& aBtName )
+ {
+ LOGGER_WRITE_1("SetBtName aBtName: %S", &aBtName);
+ TInt err = iBtSettings->SetLocalName( static_cast<const TDes&>( aBtName ) );
+ TRACE_FUNC_RET( err );
+ return err;
+ }
+
+// From MBTEngDevManObserver
+void CSconBtEngine::HandleDevManComplete( TInt aErr )
+ {
+ TRACE_FUNC;
+ LOGGER_WRITE_1("aErr: %d", aErr );
+ if ( iState == EChangeAuthorized )
+ {
+ if ( iWait.IsStarted() )
+ {
+ iOperationError = aErr;
+ iWait.AsyncStop();
+ }
+ }
+
+ }
+
+void CSconBtEngine::HandleGetDevicesComplete( TInt aErr,
+ CBTDeviceArray* aDeviceArray )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aErr: %d", aErr);
+ //iBtReqOngoing = EFalse;
+ if ( iState == ERequestBtInfo )
+ {
+ // Continue to write devices info
+ TRAP( iOperationError, PrintDevicesL() );
+ LOGGER_WRITE_1("PrintDevicesL err: %d", iOperationError);
+
+ if ( iWait.IsStarted() )
+ {
+ iWait.AsyncStop();
+ }
+ }
+ else if ( iState == EChangeAuthorized )
+ {
+ iOperationError = aErr;
+ if ( !aErr && aDeviceArray->Count() == 1 )
+ {
+ CBTDevice* btRef = aDeviceArray->At(0);
+ TBTDeviceSecurity devSec = btRef->GlobalSecurity();
+ if ( btRef->IsPaired() && !devSec.Banned() )
+ {
+ LOGGER_WRITE8_1("btAdrr: %S", &btRef->BDAddr().Des() );
+ CBTDevice* btDevice = CBTDevice::NewLC( btRef->BDAddr() );
+
+ btDevice->SetPaired( ETrue );
+
+ btDevice->SetDeviceNameL( btRef->DeviceName() );
+ btDevice->SetFriendlyNameL( btRef->FriendlyName() );
+ LOGGER_WRITE8_1("name: %S", &btRef->DeviceName());
+ LOGGER_WRITE8_1("FriendlyName: %S", &btRef->FriendlyName());
+
+ LOGGER_WRITE_1("iAuthorizedValue: %d", iAuthorizedValue);
+ // Set as authorized and store the device
+ TBTDeviceSecurity security;
+ security.SetNoAuthenticate( EFalse );
+ security.SetNoAuthorise( iAuthorizedValue );
+ security.SetBanned( EFalse );
+
+ btDevice->SetGlobalSecurity (security );
+
+ //iOperationError = iBtEng->ModifyDevice(*aDeviceArray->At(0));
+ iOperationError = iBtEng->ModifyDevice( *btDevice );
+ LOGGER_WRITE_1( "ModifyDevice err: %d", iOperationError );
+ CleanupStack::PopAndDestroy( btDevice );
+ }
+ else
+ {
+ LOGGER_WRITE("Device was not paired or it's banned")
+ iOperationError = KErrAccessDenied;
+ }
+ }
+
+ // If error occured stop waiting, otherwise continue waiting until
+ // HandleDevManComplete has been called
+ if ( iOperationError && iWait.IsStarted() )
+ {
+ iWait.AsyncStop();
+ }
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconBtEngine::PrintDevicesL()
+ {
+ TRACE_FUNC_ENTRY;
+ // calculate devices count
+ TInt devCount(0);
+
+ for ( TInt i=0 ; i<iBtDevArray->Count(); i++ )
+ {
+ CBTDevice* device = iBtDevArray->At(i);
+ // show only paired and banned devices
+ if ( device->IsPaired() || device->GlobalSecurity().Banned() )
+ {
+ devCount++;
+ }
+ }
+
+ // Print info
+ iStream->WriteUint8L( devCount );
+
+ for ( TInt i=0 ; i<iBtDevArray->Count(); i++ )
+ {
+ CBTDevice* device = iBtDevArray->At(i);
+
+ const TBTDeviceSecurity btSec = device->GlobalSecurity();
+
+ // show only paired and banned devices
+ if ( device->IsPaired() || btSec.Banned() )
+ {
+ LOGGER_WRITE_1("IsValidDeviceName: %d", device->IsValidDeviceName());
+ const TDesC8& deviceName = device->DeviceName();
+ LOGGER_WRITE8_1("DeviceName: %S", &deviceName );
+ iStream->WriteUint8L( deviceName.Length() );
+ iStream->WriteL( deviceName, deviceName.Length() );
+
+ LOGGER_WRITE_1("IsValidFriendlyName: %d", device->IsValidFriendlyName());
+ LOGGER_WRITE_1("FriendlyName: %S", &device->FriendlyName() );
+
+ const TBTDevAddr& addr = device->BDAddr();
+
+ TBuf<100> readable;
+ addr.GetReadable( readable );
+ LOGGER_WRITE_1("readable addr: %S", &readable);
+ iStream->WriteUint8L( readable.Length() );
+ iStream->WriteL( readable, readable.Length() );
+
+ LOGGER_WRITE_1("paired: %d", device->IsPaired() );
+ LOGGER_WRITE_1("IsValidPaired: %d", device->IsValidPaired() );
+ TUint8 paired(0);
+ if ( device->IsPaired() && device->IsValidPaired() )
+ {
+ paired = 1;
+ }
+ iStream->WriteUint8L( paired );
+
+ TUint8 noAuthorise(0);
+ if ( btSec.NoAuthorise() )
+ {
+ noAuthorise = 1;
+ }
+ iStream->WriteUint8L( noAuthorise );
+
+ TUint8 banned(0);
+ if ( btSec.Banned() )
+ {
+ banned = 1;
+ }
+ iStream->WriteUint8L( banned );
+
+ LOGGER_WRITE("");
+ }
+ }
+ iStream->CommitL();
+ iStream = NULL; //delete reference only
+ TRACE_FUNC_EXIT;
+ }
+
+// From MBTEngSettingsObserver
+void CSconBtEngine::PowerStateChanged( TBTPowerStateValue /*aState*/ )
+ {
+ TRACE_FUNC;
+ if ( iState == EChangeBtState && iWait.IsStarted() )
+ {
+ iWait.AsyncStop();
+ }
+
+ }
+
+void CSconBtEngine::VisibilityModeChanged( TBTVisibilityMode /*aState*/ )
+ {
+ TRACE_FUNC;
+ }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/pcconn/src/sconfolderlister.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,717 @@
+/*
+* Copyright (c) 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: CSconFolderLister implementation
+*
+*/
+
+
+#include "sconfolderlister.h"
+
+#include <driveinfo.h>
+#include <centralrepository.h>
+#include <sysutildomaincrkeys.h>
+#include <CDirectoryLocalizer.h>
+#include <stringresourcereader.h>
+#include <sconftp.rsg>
+#include <bautils.h>
+
+#include "debug.h"
+
+const TUint16 KFormatVersion( 1 );
+
+// Obex package size
+const TInt KPackageSize = 65536;
+
+const TInt KMaxLevelsToSearch = 80;
+
+_LIT( KSConResourceName, "z:\\Resource\\sconftp.rsc" );
+
+CSconFolderEntry* CSconFolderEntry::NewLC()
+ {
+ CSconFolderEntry* self = new (ELeave) CSconFolderEntry();
+ CleanupStack::PushL( self );
+ return self;
+ }
+CSconFolderEntry* CSconFolderEntry::NewLC( const TEntry& aEntry )
+ {
+ CSconFolderEntry* self = new (ELeave) CSconFolderEntry();
+ CleanupStack::PushL( self );
+ self->ConstructL( aEntry );
+ return self;
+ }
+CSconFolderEntry::CSconFolderEntry()
+ {
+ }
+CSconFolderEntry::~CSconFolderEntry()
+ {
+ delete iName;
+ delete iLabel;
+ }
+
+
+void CSconFolderEntry::ConstructL( const TEntry& aEntry )
+ {
+ iAtt = aEntry.iAtt;
+ iModified = aEntry.iModified.Int64();
+ iName = aEntry.iName.AllocL();
+ }
+
+CSconFolderLister::CSconFolderLister( RFs& aFs ) : iFs(aFs)
+ {
+ // No implementation required
+ }
+
+CSconFolderLister::~CSconFolderLister()
+ {
+ TRACE_FUNC;
+ delete iLocalizer;
+ }
+
+CSconFolderLister* CSconFolderLister::NewL( RFs& aFs )
+ {
+ TRACE_FUNC_ENTRY;
+ CSconFolderLister* self = new (ELeave) CSconFolderLister( aFs );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ TRACE_FUNC_EXIT;
+ return self;
+ }
+
+void CSconFolderLister::ConstructL()
+ {
+ TRACE_FUNC_ENTRY;
+
+ iLocalizer = CDirectoryLocalizer::NewL();
+
+ // set free memory up to critical level for all drives
+ CRepository* repository = CRepository::NewLC( KCRUidDiskLevel );
+ TInt iCriticalLevel(0);
+ User::LeaveIfError( repository->Get( KDiskCriticalThreshold, iCriticalLevel ) );
+ CleanupStack::PopAndDestroy( repository );
+ iCriticalLevel += KPackageSize; // add obex package size to critical level
+ TRACE_FUNC_EXIT;
+ }
+
+
+void CSconFolderLister::GenerateFolderListL( RBufWriteStream& aStream, const TDesC& aStartPath,
+ const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aStartPath: %S", &aStartPath );
+ LOGGER_WRITE_1("aLevelsToSearch: %d", aLevelsToSearch );
+ TInt levelsToSearch = aLevelsToSearch;
+ if ( levelsToSearch > KMaxLevelsToSearch || levelsToSearch == KErrNotFound )
+ levelsToSearch = KMaxLevelsToSearch;
+ iFolders = 0;
+ iFiles = 0;
+ const TInt KDriveNameLength( 3 );
+
+ if ( aStartPath.CompareF( _L("\\") ) == 0 )
+ {
+ LOGGER_WRITE("List all drives");
+ aStream.WriteUint16L( KFormatVersion );
+ ListAllDrivesL( aStream, levelsToSearch );
+ }
+ else if ( aStartPath.Length() >= KDriveNameLength )
+ {
+ if ( aStartPath.Length() > KDriveNameLength )
+ {
+ // check root path permissions, is listing allowed
+ TPtrC path = aStartPath.Mid(KDriveNameLength);
+ LOGGER_WRITE_1("pathFromRoot: %S", &path);
+ TInt pathEndMark = path.Locate(TChar('\\'));
+ if ( pathEndMark == KErrNotFound )
+ {
+ User::Leave( KErrArgument );
+ }
+ //"private\" locate = 7"
+ TPtrC pathName = aStartPath.Left( KDriveNameLength+pathEndMark );
+ LOGGER_WRITE_1("pathName: %S", &path);
+ TEntry pathEntry;
+ User::LeaveIfError( iFs.Entry(pathName, pathEntry) );
+
+ TBool printable = IsDirectoryPrintable( aStartPath.Left(3), pathEntry );
+ if ( !printable )
+ {
+ // access denied
+ LOGGER_WRITE("Access denied!");
+ User::Leave( KErrAccessDenied );
+ }
+ User::LeaveIfError( iFs.Entry(aStartPath, pathEntry) );
+ if ( pathEntry.IsSystem() )
+ {
+ // access denied
+ LOGGER_WRITE("System folder, Access denied!");
+ User::Leave( KErrAccessDenied );
+ }
+ }
+
+
+ aStream.WriteUint16L( KFormatVersion );
+
+ TInt drive;
+ User::LeaveIfError( iFs.CharToDrive( aStartPath[0], drive) );
+ ListDriveAndPathL( aStream, drive, aStartPath, levelsToSearch);
+
+ }
+ else
+ {
+ LOGGER_WRITE("aStartPath KErrArgument");
+ User::Leave( KErrArgument );
+ }
+
+
+ LOGGER_WRITE_1("iFolders: %d", iFolders);
+ LOGGER_WRITE_1("iFiles: %d", iFiles);
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconFolderLister::ListAllDrivesL( RBufWriteStream& aStream, const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ TInt devDriveCount = 0;
+ TInt mmcDriveCount = 0;
+ TChar driveLetter;
+ TBuf8<1> driveBuf;
+ RArray<TSconDriveInfo> sconDriveInfo(5);
+
+ // Write all drives to folderlisting object
+ TDriveList driveList;
+ // Get all drives that are visible to the user.
+ TInt driveCount;
+ User::LeaveIfError( DriveInfo::GetUserVisibleDrives( iFs, driveList, driveCount ) );
+
+ for( TInt i = EDriveA; i < KMaxDrives; i++ )
+ {
+ if( driveList[i] )
+ {
+ TUint driveStatus;
+ User::LeaveIfError( DriveInfo::GetDriveStatus( iFs, i, driveStatus ) );
+ //LOGGER_WRITE_1( "DriveInfo for drive: %d", i);
+
+ if( !(driveStatus & DriveInfo::EDrivePresent )
+ || driveStatus & DriveInfo::EDriveCorrupt
+ || (driveStatus & DriveInfo::EDriveRemote) )
+ {
+ //LOGGER_WRITE_1( "skip drive %d", i);
+ continue;
+ }
+
+ User::LeaveIfError( iFs.DriveToChar( i, driveLetter ) );
+ //Letter to uppercase form.
+ driveLetter.UpperCase();
+
+ TSconDriveInfo info;
+ info.iDriveStatus = driveStatus;
+ info.iDriveLetter.Zero();
+ info.iDriveLetter.Append( driveLetter );
+ info.iDriveLetter.Append( _L(":") );
+
+
+ info.iDriveAttr = KEntryAttNormal; // ReadWrite
+
+ if( driveStatus & DriveInfo::EDriveInternal && devDriveCount==0 )
+ {
+ //permission always R for first internal drive
+ info.iDriveAttr = KEntryAttReadOnly;
+ }
+
+ //memory type
+ if( driveStatus & DriveInfo::EDriveInternal )
+ {
+ LOGGER_WRITE( "DriveInfo::EDriveInternal" );
+ devDriveCount++;
+ info.iDriveType = DriveInfo::EDriveInternal; // =1
+ info.iDriveTypeCount = devDriveCount;
+
+ }
+ else if( driveStatus & DriveInfo::EDriveRemovable )
+ {
+ LOGGER_WRITE( "DriveInfo::EDriveRemovable" );
+ mmcDriveCount++;
+ info.iDriveType = DriveInfo::EDriveRemovable;; // =2
+ info.iDriveTypeCount = mmcDriveCount;
+ }
+
+ TVolumeInfo volumeInfo;
+ User::LeaveIfError( iFs.Volume( volumeInfo, i) );
+
+ info.iVolumeName = volumeInfo.iName;
+ if ( volumeInfo.iFree > iCriticalLevel )
+ {
+ volumeInfo.iFree = volumeInfo.iFree - iCriticalLevel;
+ }
+ else
+ {
+ volumeInfo.iFree = 0;
+ }
+
+ info.iFree = volumeInfo.iFree;
+ info.iSize = volumeInfo.iSize;
+
+
+ sconDriveInfo.AppendL( info );
+
+ }
+ }
+
+ LOGGER_WRITE_1("Drives: %d", sconDriveInfo.Count());
+ aStream.WriteUint8L( sconDriveInfo.Count() );
+ for ( TInt i=0; i < sconDriveInfo.Count(); i++ )
+ {
+
+ TBuf<3> path(KNullDesC);
+ path.Copy(sconDriveInfo[i].iDriveLetter);
+ path.Append(_L("\\"));
+
+ ExportDriveL( aStream, sconDriveInfo[i], path, aLevelsToSearch);
+ }
+ sconDriveInfo.Close();
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconFolderLister::ListDriveAndPathL( RBufWriteStream& aStream, TInt aDrive, const TDesC& aStartPath, const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ TVolumeInfo volumeInfo;
+ User::LeaveIfError( iFs.Volume(volumeInfo, aDrive) );
+ TInt driveCount(0);
+ TUint driveStatus;
+ User::LeaveIfError( DriveInfo::GetDriveStatus( iFs, aDrive, driveStatus ) );
+ GetDriveTypeNumberL( aDrive, driveStatus, driveCount );
+
+
+ TSconDriveInfo info;
+ info.iDriveLetter.Copy( aStartPath.Left(2) );
+ info.iVolumeName = volumeInfo.iName;
+
+ info.iDriveAttr = KEntryAttNormal; // ReadWrite
+ if( driveStatus & DriveInfo::EDriveInternal && driveCount==0 )
+ {
+ //permission always R for first internal drive
+ info.iDriveAttr = KEntryAttReadOnly;
+ }
+ info.iDriveType = 0;
+ if( driveStatus & DriveInfo::EDriveInternal )
+ {
+ info.iDriveType = DriveInfo::EDriveInternal; // =1
+ }
+ else if( driveStatus & DriveInfo::EDriveRemovable )
+ {
+ info.iDriveType = DriveInfo::EDriveRemovable;; // =2
+ }
+
+ if ( volumeInfo.iFree > iCriticalLevel )
+ {
+ volumeInfo.iFree = volumeInfo.iFree - iCriticalLevel;
+ }
+ else
+ {
+ volumeInfo.iFree = 0;
+ }
+
+ info.iFree = volumeInfo.iFree;
+ info.iSize = volumeInfo.iSize;
+
+ aStream.WriteUint8L( 1 );
+ ExportDriveL( aStream, info, aStartPath, aLevelsToSearch);
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconFolderLister::ExportDriveL( RBufWriteStream& aStream, const TSconDriveInfo& aDriveInfo,
+ const TDesC& aPathName, const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("Drive: %S", &aDriveInfo.iDriveLetter);
+ LOGGER_WRITE_1("aLevelsToSearch: %d", aLevelsToSearch );
+
+ CSconFolderEntry* driveEntry = CSconFolderEntry::NewLC();
+ driveEntry->iName = aDriveInfo.iDriveLetter.AllocL();
+
+ if ( driveEntry->iLabel )
+ {
+ LOGGER_WRITE_1("Label: %S", &driveEntry->iLabel->Des());
+ }
+ driveEntry->iAtt = aDriveInfo.iDriveAttr;
+
+ driveEntry->iDriveInfoEntryExists = ETrue;
+ driveEntry->iDriveInfoEntry.iDriveType = aDriveInfo.iDriveType;
+ driveEntry->iDriveInfoEntry.iDriveTypeCount = aDriveInfo.iDriveTypeCount;
+
+ driveEntry->iDriveInfoEntry.iFree = aDriveInfo.iFree;
+ driveEntry->iDriveInfoEntry.iSize = aDriveInfo.iSize;
+
+ driveEntry->iLabel = aDriveInfo.iVolumeName.AllocL();
+ GetLocalizedVolumeNameL( *driveEntry );
+
+ ExportPathL( aStream, aPathName, *driveEntry, ETrue, aLevelsToSearch );
+ CleanupStack::PopAndDestroy( driveEntry );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconFolderLister::GetLocalizedVolumeNameL( CSconFolderEntry& aDriveEntry )
+ {
+ TRACE_FUNC_ENTRY;
+ // Get localized names
+ if ( aDriveEntry.iDriveInfoEntry.iDriveType == DriveInfo::EDriveInternal
+ && aDriveEntry.iDriveInfoEntry.iDriveTypeCount > 1 )
+ {
+ LOGGER_WRITE("Internal mass memory");
+ // internal second memory (Mass memory)
+ TFileName file( KSConResourceName );
+ BaflUtils::NearestLanguageFile( iFs, file );
+
+ CStringResourceReader* reader = CStringResourceReader::NewL( file );
+ if ( aDriveEntry.iLabel )
+ {
+ delete aDriveEntry.iLabel;
+ aDriveEntry.iLabel = NULL;
+ }
+ aDriveEntry.iLabel = reader->ReadResourceString( R_SECON_VALUE_MASS_STORAGE ).AllocL();
+ delete reader;
+ }
+ else if ( aDriveEntry.iLabel && aDriveEntry.iLabel->Length()>0 )
+ {
+ LOGGER_WRITE("Use normal volume label");
+
+ }
+ else
+ {
+ TFileName file( KSConResourceName );
+ BaflUtils::NearestLanguageFile( iFs, file );
+ CStringResourceReader* reader = CStringResourceReader::NewL( file );
+ if (aDriveEntry.iLabel)
+ {
+ delete aDriveEntry.iLabel;
+ aDriveEntry.iLabel = NULL;
+ }
+ if ( aDriveEntry.iDriveInfoEntry.iDriveType == DriveInfo::EDriveRemovable )
+ {
+ LOGGER_WRITE("EDriveRemovable");
+ // read default MMC name
+ aDriveEntry.iLabel = reader->ReadResourceString( R_SECON_VALUE_MMC ).AllocL();
+ }
+ else
+ {
+ LOGGER_WRITE("EDriveInternal");
+ // read default DEV name
+ aDriveEntry.iLabel = reader->ReadResourceString( R_SECON_VALUE_DEVICE ).AllocL();
+ }
+ delete reader;
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSconFolderLister::GetDriveTypeNumberL()
+//
+// -----------------------------------------------------------------------------
+//
+void CSconFolderLister::GetDriveTypeNumberL( TInt aDrive, TUint aDriveStatus , TInt& aTypeNumber)
+ {
+ TRACE_FUNC_ENTRY;
+ aTypeNumber = 0;
+
+ //TUint driveStatus;
+ //
+ // if true, search internal drives, else search removable drives
+ TBool searchInternalDrives = (aDriveStatus & DriveInfo::EDriveInternal);
+
+ TInt driveCount;
+ TDriveList driveList;
+
+ User::LeaveIfError( DriveInfo::GetUserVisibleDrives( iFs, driveList, driveCount ) );
+
+ for( TInt i = EDriveA; i <= aDrive; i++ )
+ {
+ if( driveList[i] )
+ {
+ TUint driveStatus;
+ User::LeaveIfError( DriveInfo::GetDriveStatus( iFs, i, driveStatus ) );
+
+ if( !(driveStatus & DriveInfo::EDrivePresent )
+ || driveStatus & DriveInfo::EDriveCorrupt )
+ {
+ LOGGER_WRITE( "not present or corrupted" );
+ continue;
+ }
+
+ if( driveStatus & DriveInfo::EDriveInternal )
+ {
+ if( searchInternalDrives )
+ {
+ aTypeNumber++;
+ }
+ }
+ else if( driveStatus & DriveInfo::EDriveRemovable )
+ {
+ if( !searchInternalDrives )
+ {
+ aTypeNumber++;
+ }
+ }
+ }
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+
+void CSconFolderLister::ExportPathL( RBufWriteStream& aStream, const TDesC& aPathName,
+ const CSconFolderEntry& aEntry, const TBool aLocalize, const TInt aLevelsToSearch )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aPathName: %S", &aPathName );
+ LOGGER_WRITE_1("aLevelsToSearch: %d", aLevelsToSearch );
+
+ LOGGER_WRITE_1("aEntry.iName: %S", &aEntry.iName->Des() );
+
+ TBool localized(EFalse);
+
+ // foldername length + name
+ aStream.WriteUint8L( aEntry.iName->Length() );
+ aStream.WriteL( aEntry.iName->Des() );
+
+ TUint att = aEntry.iAtt;
+
+ if ( aEntry.iLabel && aEntry.iLabel->Length() > 0 )
+ {
+ aStream.WriteUint8L( aEntry.iLabel->Length() );
+ aStream.WriteL( aEntry.iLabel->Des() );
+ }
+ else
+ {
+ if ( aLocalize )
+ {
+ // initialize Localizer
+ iLocalizer->SetFullPath( aPathName );
+ localized = iLocalizer->IsLocalized();
+ }
+
+ if( localized )
+ {
+ const TDesC& localizedName = iLocalizer->LocalizedName();
+ aStream.WriteUint8L( localizedName.Length() );
+ aStream.WriteL( localizedName );
+ LOGGER_WRITE_1("LocalizedName: %S", &localizedName );
+ }
+ else if ( aPathName.CompareF(_L("C:\\Data\\")) == 0 )
+ {
+ TFileName file( KSConResourceName );
+
+ BaflUtils::NearestLanguageFile( iFs, file );
+
+ CStringResourceReader* reader = CStringResourceReader::NewL( file );
+ CleanupStack::PushL( reader );
+
+ const TDesC& localizedName = reader->ReadResourceString( R_SECON_DATA_FOLDER );
+ aStream.WriteUint8L( localizedName.Length() );
+ aStream.WriteL( localizedName );
+ LOGGER_WRITE_1("LocalizedName: %S", &localizedName );
+
+ CleanupStack::PopAndDestroy( reader );
+ localized = ETrue;
+ }
+ else
+ {
+ aStream.WriteUint8L( 0 );
+ }
+ // attributes
+ if ( localized )
+ {
+ // localized folder, set readonly flag
+ att = att | KEntryAttReadOnly;
+ }
+ }
+
+ if ( aPathName.Length() == 3 && aLocalize )
+ {
+ // enable subfolder localization, even when root cannot be localized
+ localized = ETrue;
+ }
+
+ // DriveInfoEntry
+ if ( aEntry.iDriveInfoEntryExists )
+ {
+ aStream.WriteUint8L( 1 );
+ aStream.WriteUint8L( aEntry.iDriveInfoEntry.iDriveType );
+ aStream.WriteUint8L( aEntry.iDriveInfoEntry.iDriveTypeCount );
+ aStream << aEntry.iDriveInfoEntry.iFree;
+ aStream << aEntry.iDriveInfoEntry.iSize;
+ }
+ else
+ {
+ aStream.WriteUint8L( 0 );
+ }
+
+
+ // modified time
+ TDateTime time = aEntry.iModified.DateTime();
+ aStream.WriteInt16L( time.Year() );
+ aStream.WriteInt8L( time.Month()+1 ); // range 1...12
+ aStream.WriteInt8L( time.Day()+1 );
+ aStream.WriteInt8L( time.Hour() );
+ aStream.WriteInt8L( time.Minute() );
+ aStream.WriteInt8L( time.Second() );
+
+ // write attribute
+ aStream.WriteUint32L( att );
+
+
+ if ( aLevelsToSearch == 0 )
+ {
+ // don't list directory content
+ LOGGER_WRITE("Not listing directory content");
+ aStream.WriteInt16L( 0 ); // files count
+ aStream.WriteInt16L( 0 ); // directory count
+ return;
+ }
+
+ CDir *fileList = 0;
+ CDir *dirList = 0;
+
+ // show normal and hidden files and folders
+ TUint entryAttMask = KEntryAttNormal | KEntryAttHidden;
+
+ // get folders and files
+ TInt err = iFs.GetDir( aPathName, entryAttMask, ESortByName,
+ fileList, dirList );
+
+ if ( err )
+ {
+ LOGGER_WRITE_1( "ParseFolderListL GetDir returned: %d", err );
+ User::Leave( err );
+ }
+
+ CleanupStack::PushL( dirList );
+ CleanupStack::PushL( fileList );
+
+
+ LOGGER_WRITE_1("files: %d", fileList->Count());
+ aStream.WriteUint16L( fileList->Count() );
+
+ // Print files to folder listing object
+ for( TInt i = 0; i < fileList->Count(); i++ )
+ {
+ const TEntry& fileEntry = ( *fileList )[i];
+ iFiles++;
+ LOGGER_WRITE_1("fileEntry.iName: %S", &fileEntry.iName);
+ // filename length + name
+ aStream.WriteUint8L( fileEntry.iName.Length() );
+ aStream.WriteL( fileEntry.iName );
+
+ // modified time
+ TDateTime time = fileEntry.iModified.DateTime();
+ aStream.WriteInt16L( time.Year() );
+ aStream.WriteInt8L( time.Month()+1 ); // range 1...12
+ aStream.WriteInt8L( time.Day()+1 );
+ aStream.WriteInt8L( time.Hour() );
+ aStream.WriteInt8L( time.Minute() );
+ aStream.WriteInt8L( time.Second() );
+
+ // attributes
+ aStream.WriteUint32L( fileEntry.iAtt );
+
+ // file size
+ aStream.WriteUint32L( fileEntry.iSize );
+ }
+ CleanupStack::PopAndDestroy( fileList );
+
+
+ // calculate ow many directories we are going to list
+ TInt directoryCount(0);
+ for( TInt i = 0; i < dirList->Count(); i++ )
+ {
+ if ( IsDirectoryPrintable(aPathName, ( *dirList )[i] ) )
+ {
+ directoryCount++;
+ }
+ }
+ LOGGER_WRITE_1("directories: %d", directoryCount);
+ aStream.WriteUint16L( directoryCount );
+
+ HBufC* fullpath = HBufC::NewL( KMaxPath );
+ TPtr fullpathPtr = fullpath->Des();
+ CleanupStack::PushL( fullpath );
+
+ // Print folders to folder listing object
+ for( TInt i = 0; i < dirList->Count(); i++ )
+ {
+ const TEntry& folderEntry = ( *dirList )[i];
+ if ( !IsDirectoryPrintable(aPathName, folderEntry) )
+ {
+ continue;
+ }
+ iFolders++;
+
+ fullpathPtr.Copy( aPathName );
+ fullpathPtr.Append( folderEntry.iName );
+ fullpathPtr.Append( _L("\\") );
+ CSconFolderEntry* subFolderEntry = CSconFolderEntry::NewLC( folderEntry );
+ if ( aLevelsToSearch == KErrNotFound )
+ {
+ ExportPathL( aStream, fullpathPtr, *subFolderEntry, localized, aLevelsToSearch);
+ }
+ else
+ {
+ ExportPathL( aStream, fullpathPtr, *subFolderEntry, localized, aLevelsToSearch-1);
+ }
+ CleanupStack::PopAndDestroy( subFolderEntry );
+ }
+ CleanupStack::PopAndDestroy( fullpath );
+ CleanupStack::PopAndDestroy( dirList );
+
+ TRACE_FUNC_EXIT;
+ }
+TBool CSconFolderLister::IsDirectoryPrintable( const TDesC& aParentPath, const TEntry& aFolderEntry )
+ {
+ if ( aFolderEntry.IsSystem() )
+ {
+ LOGGER_WRITE_1("folder '%S' was system folder", &aFolderEntry.iName);
+ return EFalse;
+ }
+ if ( aParentPath.Length() == 3 )
+ {
+ if ( aParentPath.FindF(_L("C:\\")) == 0 && aFolderEntry.iName.CompareF(_L("data")) != 0 )
+ {
+ // C root not visible, exept Data folder
+ LOGGER_WRITE_1("folder '%S' not visible to user in c-root", &aFolderEntry.iName);
+ return EFalse;
+ }
+
+ if ( aFolderEntry.iName.CompareF(_L("private")) == 0 )
+ {
+ LOGGER_WRITE_1("folder '%S' not visible to user", &aFolderEntry.iName);
+ return EFalse;
+ }
+ else if ( aFolderEntry.iName.CompareF(_L("sys")) == 0 )
+ {
+ LOGGER_WRITE_1("folder '%S' not visible to user", &aFolderEntry.iName);
+ return EFalse;
+ }
+ else if ( aFolderEntry.iName.CompareF(_L("system")) == 0 )
+ {
+ LOGGER_WRITE_1("folder '%S' not visible to user", &aFolderEntry.iName);
+ return EFalse;
+ }
+ else if ( aFolderEntry.iName.CompareF(_L("resource")) == 0 )
+ {
+ LOGGER_WRITE_1("folder '%S' not visible to user", &aFolderEntry.iName);
+ return EFalse;
+ }
+ }
+ return ETrue;
+ }
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/pcconn/src/sconimsireader.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,123 @@
+/*
+* Copyright (c) 2009-2010 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: CSconImsiReader implementation
+*
+*/
+
+
+#include "sconimsireader.h"
+#include "debug.h"
+
+TInt CSconImsiReader::GetImsiL( TDes& aImsi )
+ {
+ TRACE_FUNC_ENTRY;
+ CTelephony::TRegistrationStatus temp;
+ CSconImsiReader* self = new (ELeave) CSconImsiReader(aImsi, temp);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+
+ self->RequestImsi();
+
+ TInt err = self->iStatus.Int();
+ CleanupStack::PopAndDestroy(self);
+ TRACE_FUNC_RET(err);
+ return err;
+ }
+
+TInt CSconImsiReader::GetNetworkStatusL( CTelephony::TRegistrationStatus& aRegistrationStatus )
+ {
+ TRACE_FUNC_ENTRY;
+ TBuf<CTelephony::KIMSISize> temp;
+ CSconImsiReader* self = new (ELeave) CSconImsiReader(temp, aRegistrationStatus);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+
+ self->RequestNetworkStatus();
+
+ TInt err = self->iStatus.Int();
+ CleanupStack::PopAndDestroy(self);
+ TRACE_FUNC_RET(err);
+ return err;
+ }
+
+void CSconImsiReader::ConstructL()
+ {
+ TRACE_FUNC_ENTRY;
+ iTelephony = CTelephony::NewL();
+ CActiveScheduler::Add(this);
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconImsiReader::RequestImsi()
+ {
+ iImsiReaderStatus = ERequestingImsi;
+ iTelephony->GetSubscriberId(iStatus,iSubscriberIdV1Pckg);
+ SetActive();
+ CActiveScheduler::Start();
+ }
+
+void CSconImsiReader::RequestNetworkStatus()
+ {
+ iImsiReaderStatus = ERequestingNetworkStatus;
+ iTelephony->GetNetworkRegistrationStatus(iStatus, iNetworkRegistrationV1Pckg);
+ SetActive();
+ CActiveScheduler::Start();
+ }
+
+CSconImsiReader::~CSconImsiReader()
+ {
+ TRACE_FUNC_ENTRY;
+ delete iTelephony;
+ TRACE_FUNC_EXIT;
+ }
+
+CSconImsiReader::CSconImsiReader(TDes& aImsi, CTelephony::TRegistrationStatus& aRegistrationStatus): CActive(EPriorityStandard),
+ iImsi(aImsi), iNetworkStatus(aRegistrationStatus), iSubscriberIdV1Pckg(iSubscriberIdV1), iNetworkRegistrationV1Pckg(iNetworkRegistrationV1)
+ {
+ }
+
+void CSconImsiReader::RunL()
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("iStatus: %d", iStatus.Int() );
+ if ( iStatus == KErrNone )
+ {
+ if ( iImsiReaderStatus == ERequestingImsi )
+ {
+ iImsi = iSubscriberIdV1.iSubscriberId;
+ LOGGER_WRITE_1("iImsi: %S", &iImsi);
+ }
+ else if ( iImsiReaderStatus == ERequestingNetworkStatus )
+ {
+ iNetworkStatus = iNetworkRegistrationV1.iRegStatus;
+ LOGGER_WRITE_1( "iNetworkStatus: %d", (TInt)iNetworkStatus);
+ }
+ }
+ CActiveScheduler::Stop();
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconImsiReader::DoCancel()
+ {
+ TRACE_FUNC_ENTRY;
+ if ( iImsiReaderStatus == ERequestingImsi )
+ {
+ iTelephony->CancelAsync( CTelephony::EGetSubscriberIdCancel );
+ }
+ else if ( iImsiReaderStatus == ERequestingNetworkStatus )
+ {
+ iTelephony->CancelAsync( CTelephony::EGetNetworkRegistrationStatusCancel );
+ }
+ TRACE_FUNC_EXIT;
+ }
--- a/connectivitymodules/SeCon/servers/pcconn/src/sconpcconnserver.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/servers/pcconn/src/sconpcconnserver.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2010 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"
@@ -18,12 +18,18 @@
#include <s32mem.h> // For RMemReadStream
#include <utf.h>
+#include <Etel3rdParty.h>
+#include <f32file.h>
#include "sconpcconnclientserver.h"
#include "sconpcconnserver.h"
#include "sconpcd.h"
#include "sconcsc.h"
#include "sconconmlhandler.h"
+#include "sconimsireader.h"
+#include "sconoviaccounthandler.h"
+#include "sconfolderlister.h"
+#include "sconbtengine.h"
#include "debug.h"
#ifdef DEBUG_XML
@@ -33,6 +39,15 @@
#endif
_LIT( KSCONGetMetadataRequest, "METADATA:" );
+_LIT8( KSCONSyncRequest, "SYNC:" );
+_LIT( KSCONReadImsi, "READIMSI");
+_LIT( KSCONReadNetworkInfo, "READNETWORKINFO");
+_LIT( KSCONReadOviAccount, "READOVIACCOUNT");
+_LIT( KSCONListPath, "LISTP:");
+_LIT( KSCONReadBtInfo, "READBTINFO" );
+_LIT( KSCONSetBtPower, "SETBTPOWER:" );
+_LIT( KSCONSetBtName, "SETBTNAME:" );
+_LIT( KSCONSetBtAuthorized, "SETBTAUTHORIZED:" );
//------------------------------------------------------------
// Global functions
@@ -129,7 +144,13 @@
if ( clientId != KSConPCConnClientSecureId )
{
LOGGER_WRITE( "CSConPCConnServer::NewSessionL() : Secure ID does not match" );
+#ifndef __WINS__
+ LOGGER_WRITE( "Leave KErrAccessDenied");
User::Leave( KErrAccessDenied );
+#else
+ // does not leave on WINS environment. Easier to run module tests.
+ LOGGER_WRITE( "Not leaving on WINS environment" );
+#endif
}
TRACE_FUNC_EXIT;
@@ -272,7 +293,12 @@
}
iChunk.Close();
-
+ delete iFolderLister;
+
+ iFs.Close();
+
+ delete iBtEngine;
+
TRACE_FUNC_EXIT;
}
@@ -304,21 +330,18 @@
TInt ret ( KErrNone );
iResult = KErrNone;
+ User::LeaveIfError( iFs.Connect() );
+
#ifdef DEBUG_XML
// create log file
- RFs fs;
- User::LeaveIfError( fs.Connect () );
- CleanupClosePushL( fs );
RFile file;
- TInt err = file.Create ( fs, KSConConMLDebugFile, EFileWrite );
+ TInt err = file.Create ( iFs, KSConConMLDebugFile, EFileWrite );
if( err == KErrNone )
{
// file created, close it
file.Close();
- }
-
- CleanupStack::PopAndDestroy( &fs );
+ }
#endif
// initialize buffer
@@ -355,7 +378,9 @@
User::Leave ( ret );
}
}
-
+
+ iFolderLister = CSconFolderLister::NewL( iFs );
+
TRACE_FUNC_EXIT;
}
@@ -457,9 +482,14 @@
iBuffer->Reset();
length = buf.ReadInt32L();
- HBufC8* name = HBufC8::NewLC( length );
- TPtr8 namePtr = name->Des();
- buf.ReadL( namePtr, length);
+ HBufC8* name8 = HBufC8::NewLC( length );
+ TPtr8 namePtr8 = name8->Des();
+ buf.ReadL( namePtr8, length);
+
+ const TUint8* ptr8 = namePtr8.Ptr();
+ const TUint16* ptr16 = reinterpret_cast<const TUint16*>( ptr8 );
+ TPtrC namePtr;
+ namePtr.Set( ptr16, length/2 );
length = buf.ReadInt32L();
HBufC8* type = HBufC8::NewLC( length );
@@ -478,12 +508,9 @@
buf.Close();
#ifdef DEBUG_XML
- RFs fs;
- User::LeaveIfError( fs.Connect() );
- CleanupClosePushL( fs );
RFile file;
- if ( file.Open( fs, KSConConMLDebugFile, EFileWrite ) == KErrNone )
+ if ( file.Open( iFs, KSConConMLDebugFile, EFileWrite ) == KErrNone )
{
RFileWriteStream fws;
TInt fileSize;
@@ -507,11 +534,25 @@
CleanupStack::PopAndDestroy( &fws );
}
- file.Close();
- CleanupStack::PopAndDestroy( &fs );
+ file.Close();
#endif
-
- if ( ( typePtr.Compare( KSConPCDWBXMLObjectType ) == KErrNone) ||
+ if ( ( ( typePtr.CompareC( KSConPCDWBXMLObjectType)== KErrNone ) ||
+ ( typePtr.CompareC( KSConPCDWBXMLObjectType2 )== KErrNone ) )
+ && namePtr8.Find(KSCONSyncRequest) == 0 )
+ {
+ LOGGER_WRITE_1("Sync request: %S", &namePtr);
+ RBufReadStream stream( *iBuffer );
+
+ CleanupClosePushL( stream );
+ TRAP( ret, iPCDHandler->HandlePutSyncRequestL( namePtr8, stream ));
+ if ( ret )
+ {
+ LOGGER_WRITE_1("HandlePutSyncRequestL() Leaved with %d", ret);
+ }
+
+ CleanupStack::PopAndDestroy( &stream );
+ }
+ else if ( ( typePtr.Compare( KSConPCDWBXMLObjectType ) == KErrNone) ||
( typePtr.Compare( KSConPCDWBXMLObjectType2 )== KErrNone) )
{
LOGGER_WRITE( "CSConPCConnSession::HandlePutMessageL() : Object type PCD " );
@@ -533,7 +574,7 @@
}
CleanupStack::PopAndDestroy( data );
CleanupStack::PopAndDestroy( type );
- CleanupStack::PopAndDestroy( name );
+ CleanupStack::PopAndDestroy( name8 );
LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() end : Heap count : %d", User::Heap().Count() );
LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() : returned %d", ret );
return ret;
@@ -587,12 +628,9 @@
ret = iCSCHandler->CapabilityObject( *iBuffer );
#ifdef DEBUG_XML
- RFs fs;
- User::LeaveIfError(fs.Connect());
- CleanupClosePushL(fs);
-
+
RFile file;
- if ( file.Open(fs, KSConConMLDebugFile, EFileWrite ) == KErrNone )
+ if ( file.Open(iFs, KSConConMLDebugFile, EFileWrite ) == KErrNone )
{
RFileWriteStream fws;
TInt fileSize;
@@ -616,13 +654,218 @@
CleanupStack::PopAndDestroy( &fws );
}
file.Close();
- CleanupStack::PopAndDestroy( &fs );
#endif
}
else if ( typePtr.CompareC( KSConPCDWBXMLObjectType) == KErrNone )
{
- ret = HandleWBXMLGetRequestL( namePtr );
+ if ( namePtr8.Find(KSCONSyncRequest) == 0 ) // 8-bit search
+ {
+ LOGGER_WRITE("Sync request");
+
+ RBufWriteStream stream( *iBuffer );
+
+ CleanupClosePushL( stream );
+
+ TRAP( ret, iPCDHandler->HandleGetSyncRequestL( namePtr8, stream, iChunk.MaxSize() - sizeof(TInt32) ));
+ if ( ret )
+ {
+ LOGGER_WRITE_1("HandleGetSyncRequestL() Leaved with %d", ret);
+ }
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+
+ LOGGER_WRITE_1("iBuffer size: %d", iBuffer->Size());
+
+ }
+ else if ( namePtr.Find(KSCONReadImsi) == 0 ) // 16-bit search
+ {
+ LOGGER_WRITE("Read IMSI");
+ TBuf<CTelephony::KIMSISize> imsi;
+ ret = CSconImsiReader::GetImsiL( imsi );
+
+ if ( ret == KErrNone )
+ {
+ TBuf8<CTelephony::KIMSISize> imsi8;
+ User::LeaveIfError( CnvUtfConverter::ConvertFromUnicodeToUtf8(imsi8,imsi) );
+
+ iBuffer->ResizeL( imsi8.Length() );
+ iBuffer->Write( 0, imsi8 );
+ }
+ else
+ {
+ // Change error code more generic
+ ret = KErrNotFound;
+ }
+ }
+ else if ( namePtr.Find(KSCONReadNetworkInfo) == 0 ) // 16-bit search
+ {
+ LOGGER_WRITE("Read NetworkInfo");
+ CTelephony::TRegistrationStatus regStatus;
+ ret = CSconImsiReader::GetNetworkStatusL( regStatus );
+
+ if ( ret == KErrNone )
+ {
+ RBufWriteStream stream( *iBuffer );
+ CleanupClosePushL( stream );
+ stream.WriteInt8L( regStatus );
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ }
+ else
+ {
+ // Change error code more generic
+ ret = KErrNotFound;
+ }
+ }
+ else if ( namePtr.Find(KSCONReadOviAccount) == 0 )
+ {
+ LOGGER_WRITE("Read Ovi account");
+ RBufWriteStream stream( *iBuffer );
+ CleanupClosePushL( stream );
+
+ ret = ReadOviAccountInfoL( stream );
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+
+ }
+ else if ( namePtr.Find(KSCONListPath) == 0 )
+ {
+ LOGGER_WRITE("List path");
+ // LISTP:0:pathname
+ if ( namePtr.Length() > KSCONListPath().Length()+2)
+ {
+ TPtrC pathname = namePtr.Mid( KSCONListPath().Length()+2 );
+
+ const TUint16 levelsChar = namePtr[ KSCONListPath().Length() ];
+ TInt level(KErrNotFound);
+ if ( levelsChar >= TChar('0') )
+ {
+ level = levelsChar - TChar('0');
+ }
+
+ RBufWriteStream stream( *iBuffer );
+ CleanupClosePushL( stream );
+ TRAP( ret, iFolderLister->GenerateFolderListL( stream, pathname, level ));
+ LOGGER_WRITE_1("GenerateFolderListL leaved with err: %d", ret);
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ }
+ else
+ {
+ ret = KErrArgument;
+ }
+
+ }
+ else if ( namePtr.Find(KSCONReadBtInfo) == 0 )
+ {
+ LOGGER_WRITE( "Read BT info");
+ if ( !iBtEngine )
+ {
+ iBtEngine = CSconBtEngine::NewL();
+ }
+ RBufWriteStream stream( *iBuffer );
+ CleanupClosePushL( stream );
+ TRAP( ret, iBtEngine->ReadBTInfoL( stream ) );
+ LOGGER_WRITE_1("ReadBTInfoL leaved with err: %d", ret);
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ }
+ else if ( namePtr.Find(KSCONSetBtPower) == 0 )
+ {
+ LOGGER_WRITE( "Change BT Power state");
+ if ( namePtr.Length() == KSCONSetBtPower().Length()+1 )
+ {
+ const TUint16 lastChar = namePtr[ KSCONSetBtPower().Length() ];
+ TBool changeBtOn;
+ if ( lastChar == TChar('0') )
+ {
+ changeBtOn = EFalse;
+ }
+ else if ( lastChar == TChar('1') )
+ {
+ changeBtOn = ETrue;
+ }
+ else
+ {
+ ret = KErrArgument;
+ }
+
+ if ( !ret )
+ {
+ if ( !iBtEngine )
+ {
+ iBtEngine = CSconBtEngine::NewL();
+ }
+ TInt err = iBtEngine->SetBtPowerState( changeBtOn );
+
+ RBufWriteStream stream( *iBuffer );
+ CleanupClosePushL( stream );
+ stream.WriteInt32L( err );
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ }
+ }
+ else
+ {
+ ret = KErrArgument;
+ }
+ }
+ else if ( namePtr.Find(KSCONSetBtName) == 0 )
+ {
+ LOGGER_WRITE( "Set BT Name");
+ TPtrC btName = namePtr.Mid( KSCONSetBtName().Length() );
+ TInt err = iBtEngine->SetBtName( btName );
+
+ RBufWriteStream stream( *iBuffer );
+ CleanupClosePushL( stream );
+ stream.WriteInt32L( err );
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ }
+ else if ( namePtr.Find(KSCONSetBtAuthorized) == 0 )
+ {
+ LOGGER_WRITE( "Set BT Authorized");
+ ret = KErrArgument;
+ // SETBTAUTHORIZED:0:00245f8d6a26
+ // 1. param = auth. state ("0"=off, "1"=true)
+ // 2. param = bt address (hex string)
+
+ if ( namePtr.Length() > KSCONSetBtAuthorized().Length()+2)
+ {
+ TPtrC btAddr = namePtr.Mid( KSCONSetBtAuthorized().Length()+2 );
+
+ const TUint16 authStateChar = namePtr[ KSCONSetBtAuthorized().Length() ];
+ TBool authorize(EFalse);
+ if ( authStateChar == TChar('0') )
+ {
+ authorize = EFalse;
+ ret = KErrNone;
+ }
+ else if ( authStateChar == TChar('1') )
+ {
+ authorize = ETrue;
+ ret = KErrNone;
+ }
+
+ if ( !iBtEngine )
+ {
+ iBtEngine = CSconBtEngine::NewL();
+ }
+ TRAPD(err, iBtEngine->SetBtAuthorizedL( btAddr, authorize ) );
+
+ RBufWriteStream stream( *iBuffer );
+ CleanupClosePushL( stream );
+ stream.WriteInt32L( err );
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ }
+
+ }
+ else
+ {
+ ret = HandleWBXMLGetRequestL( namePtr );
+ }
}
else
{
@@ -760,6 +1003,59 @@
return ret;
}
+
+// -----------------------------------------------------------------------------
+// CSConPCConnSession::ReadOviAccountInfoL()
+// Reads ovi account information to stream
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCConnSession::ReadOviAccountInfoL( RWriteStream& aAccountInfoStream )
+ {
+ TRACE_FUNC_ENTRY;
+ RLibrary oviaccounthandlerLib;
+ CleanupClosePushL( oviaccounthandlerLib );
+ // Dynamically load DLL
+ TInt err = oviaccounthandlerLib.Load( KSconOviAccountHandlerDllName );
+ if ( err )
+ {
+ LOGGER_WRITE_1("oviaccounthandlerLib.Load err: %d", err);
+ err = KErrNotSupported;
+ }
+ else if( oviaccounthandlerLib.Type()[1] != KSconOviAccountHandlerDllUid )
+ {
+ LOGGER_WRITE_1( "KSconOviAccountHandlerDllUid incorrect... (0x%08X)",oviaccounthandlerLib.Type()[1].iUid );
+ err = KErrNotSupported;
+ }
+
+ if ( err == KErrNone )
+ {
+ TSConCreateCSconOviAccountHandlerFunc CreateCSconOviAccountHandlerL =
+ (TSConCreateCSconOviAccountHandlerFunc)oviaccounthandlerLib.Lookup(1);
+
+ CSconOviAccountHandler* oviAccountHandler = (CSconOviAccountHandler*)CreateCSconOviAccountHandlerL();
+
+ TRAP(err, oviAccountHandler->GetOviAccountDetailsL( aAccountInfoStream ) );
+ LOGGER_WRITE_1("GetOviAccountDetailsL err: %d", err);
+
+ delete oviAccountHandler;
+ oviAccountHandler = NULL;
+
+ if ( err )
+ {
+ // change error code
+ err = KErrNotFound;
+ }
+ }
+ else
+ {
+ err = KErrNotSupported;
+ }
+
+ CleanupStack::PopAndDestroy( &oviaccounthandlerLib );
+ TRACE_FUNC_EXIT;
+ return err;
+ }
+
// -----------------------------------------------------------------------------
// CSConPCConnSession::HandleResetMessage()
// Resets the PCCS service
@@ -878,12 +1174,8 @@
#ifdef DEBUG_XML
iConMLHandler->GenerateDocument( aContent );
- RFs fs;
- User::LeaveIfError(fs.Connect());
- CleanupClosePushL(fs);
RFile file;
-
- if ( file.Open(fs, KSConConMLDebugFile, EFileWrite) == KErrNone )
+ if ( file.Open(iFs, KSConConMLDebugFile, EFileWrite) == KErrNone )
{
RFileWriteStream fws;
TInt fileSize;
@@ -910,7 +1202,6 @@
CleanupStack::PopAndDestroy( &fws );
}
file.Close();
- CleanupStack::PopAndDestroy( &fs );
#endif
@@ -1357,6 +1648,7 @@
p && p->data; p=p->next )
{
CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();
+ CleanupStack::PushL( dataOwner );
if ( p->data->type )
{
dataOwner->iType = TSConDOType (DesToInt(
@@ -1385,7 +1677,8 @@
TInt intValue = DesToInt( p->data->transferDataType->Data() );
dataOwner->iTransDataType = static_cast<TSConTransferDataType> (intValue);
}
- task->iGetDataSizeParams->iDataOwners.Append( dataOwner );
+ task->iGetDataSizeParams->iDataOwners.AppendL( dataOwner );
+ CleanupStack::Pop( dataOwner );
}
}
ret = iPCDHandler->PutTaskL( task );
@@ -1540,7 +1833,7 @@
for ( ConML_SIDListPtr_t p = aContent->sid; p && p->data; p = p->next )
{
CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();
-
+ CleanupStack::PushL( dataOwner );
if ( p->data->type )
{
dataOwner->iType = TSConDOType ( DesToInt(
@@ -1571,7 +1864,8 @@
dataOwner->iPackageName,
p->data->packageInfo->name->Data());
}
- task->iPubFilesParams->iDataOwners.Append( dataOwner );
+ task->iPubFilesParams->iDataOwners.AppendL( dataOwner );
+ CleanupStack::Pop( dataOwner );
}
}
ret = iPCDHandler->PutTaskL( task );
@@ -1667,6 +1961,7 @@
p && p->data; p=p->next )
{
CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();
+ CleanupStack::PushL( dataOwner );
if ( p->data->type )
{
dataOwner->iType = TSConDOType (DesToInt(
@@ -1686,7 +1981,8 @@
CleanupStack::PopAndDestroy(); //DesToHashLC()
}
}
- task->iGetDataOwnerParams->iDataOwners.Append( dataOwner );
+ task->iGetDataOwnerParams->iDataOwners.AppendL( dataOwner );
+ CleanupStack::Pop( dataOwner );
}
}
ret = iPCDHandler->PutTaskL( task );
@@ -2020,9 +2316,9 @@
if ( aResult->iApps.Count() > 0 )
{
- // 5 * KMaxFileName should be enought
- // ( 4 items of TFileName and uid + type + size + 6* "#" )
- HBufC8* buf = HBufC8::NewLC( 5 * KMaxFileName );
+ // 6 * KMaxFileName should be enought
+ // ( 5 items of TFileName and uid + type + size + 7* "#" )
+ HBufC8* buf = HBufC8::NewLC( 6 * KMaxFileName );
TPtr8 ptrBuf = buf->Des();
aContent->applications = new ( ELeave ) ConML_Applications_t();
@@ -2040,7 +2336,7 @@
aResult->iApps[i]->iName));
CleanupStack::PopAndDestroy(); // BufToDesLC
- // create uid: UID # Type # Size # Version # Vendor # Parent app. name #
+ // create uid: UID # Type # Size # Version # Vendor # Parent app. name # WidgetBundleId #
LOGGER_WRITE( "CSConPCConnSession::AppendListInstalledAppsResultsL() : Create Uid" );
ptrBuf.Copy( UidToDesLC( aResult->iApps[i]->iUid ) );
@@ -2068,6 +2364,13 @@
CleanupStack::PopAndDestroy(); // BufToDesLC
ptrBuf.Append( KSConAppInfoSeparator );
+ if (aResult->iApps[i]->iWidgetBundleId)
+ {
+ ptrBuf.Append( BufToDesLC( *aResult->iApps[i]->iWidgetBundleId ) );
+ CleanupStack::PopAndDestroy(); // BufToDesLC
+ }
+
+ ptrBuf.Append( KSConAppInfoSeparator );
LOGGER_WRITE( "CSConPCConnSession::AppendListInstalledAppsResultsL() : set data" );
app->data->uid = new ( ELeave ) pcdata_t();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/group/bld.inf Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,27 @@
+/*
+* Copyright (c) 2009-2010 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: Build information file for project SyncServer
+*
+*/
+
+
+PRJ_EXPORTS
+../rom/sconsyncserver.iby CORE_APP_LAYER_IBY_EXPORT_PATH(sconsyncserver.iby)
+
+PRJ_PLATFORMS
+DEFAULT
+
+PRJ_MMPFILES
+sconsyncserver.mmp
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/group/sconsyncserver.mmp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,61 @@
+/*
+* Copyright (c) 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: sconsyncserver mmp file
+*
+*/
+
+
+#include <platform_paths.hrh>
+#include <data_caging_paths.hrh>
+
+
+TARGET sconsyncserver.exe
+TARGETTYPE exe
+
+// Same capabilities than in DS Ui application
+CAPABILITY LocalServices ReadUserData WriteUserData ReadDeviceData WriteDeviceData NetworkServices UserEnvironment ProtServ SwEvent NetworkControl Location
+
+UID 0x0 0x2001A964
+VENDORID VID_DEFAULT
+
+EPOCSTACKSIZE 0x2000
+EPOCHEAPSIZE 0x500 0x800000 // minimum and maximum heap sizes
+
+SOURCEPATH ../src
+SOURCE sconsyncserver.cpp
+SOURCE sconsyncsession.cpp
+SOURCE sconsyncrelationship.cpp
+SOURCE sconasynchandler.cpp
+SOURCE cscontimeout.cpp
+
+// common components (dataproviderinfo)
+SOURCEPATH ../../../clients/syncclient/src
+USERINCLUDE ../../../clients/syncclient/inc
+SOURCE scondataproviderinfo.cpp
+
+USERINCLUDE ..\inc
+
+// Default system include paths for middleware layer modules.
+MW_LAYER_SYSTEMINCLUDE
+
+DEBUGLIBRARY flogger.lib
+LIBRARY euser.lib
+LIBRARY efsrv.lib
+LIBRARY bafl.lib
+LIBRARY ecom.lib
+LIBRARY estor.lib // CDictionaryFileStore
+LIBRARY smldataprovider.lib
+LIBRARY nsmlchangefinder.lib
+LIBRARY smlstoreformat.lib
+LIBRARY charconv.lib
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/inc/cscontimeout.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,79 @@
+/*
+* Copyright (c) 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: CCSconTimeOut header file
+*
+*/
+
+
+#ifndef CSCONTIMEOUT_H
+#define CSCONTIMEOUT_H
+
+#include <e32base.h> // For CActive, link against: euser.lib
+#include <e32std.h> // For RTimer, link against: euser.lib
+
+class MTimeOutObserver
+ {
+public:
+ virtual void TimeOut() = 0;
+ };
+
+class CCSconTimeOut : public CActive
+ {
+public:
+ // Cancel and destroy
+ ~CCSconTimeOut();
+
+ // Two-phased constructor.
+ static CCSconTimeOut* NewL( MTimeOutObserver& aTimeOutObserver );
+
+public:
+ // New functions
+ // Function for making the timeout request
+ void Start(TTimeIntervalMicroSeconds32 aDelay);
+
+private:
+ // C++ constructor
+ CCSconTimeOut( MTimeOutObserver& aTimeOutObserver );
+
+ // Second-phase constructor
+ void ConstructL();
+
+private:
+ // From CActive
+ // Handle completion
+ void RunL();
+
+ // How to cancel me
+ void DoCancel();
+
+ // Override to handle leaves from RunL(). Default implementation causes
+ // the active scheduler to panic.
+ TInt RunError(TInt aError);
+
+private:
+ enum TCSconTimeOutState
+ {
+ EUninitialized, // Uninitialized
+ EInitialized, // Initalized
+ EError
+ // Error condition
+ };
+
+private:
+ TInt iState; // State of the active object
+ RTimer iTimer; // Provides async timing service
+ MTimeOutObserver& iTimeOutObserver;
+ };
+
+#endif // CSCONTIMEOUT_H
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/inc/debug.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,130 @@
+/*
+* Copyright (c) 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: Debug utility for SyncServer
+*
+*/
+
+
+#ifndef _SECON_DEBUG_H
+#define _SECON_DEBUG_H
+
+#ifdef _DEBUG
+
+ // File logging
+ #define __FLOGGING__
+
+ #include <e32svr.h>
+ #ifdef __FLOGGING__
+ #include <f32file.h>
+ #include <flogger.h>
+ #endif
+
+ NONSHARABLE_CLASS(TOverflowTruncate16) : public TDes16Overflow
+ {
+ public:
+ void Overflow(TDes16& /*aDes*/) {}
+ };
+
+ NONSHARABLE_CLASS(TOverflowTruncate8) : public TDes8Overflow
+ {
+ public:
+ void Overflow(TDes8& /*aDes*/) {}
+ };
+
+ _LIT( KLogDir, "SECON" );
+ _LIT( KLogFile, "SeconDebug.txt" );
+
+ _LIT(KTracePrefix16, "[SeConSync] ");
+ _LIT8(KTracePrefix8, "[SeConSync] ");
+ _LIT8(KFuncEntryFormat8, "%S : Begin");
+ _LIT8(KFuncExitFormat8, "%S : End");
+ _LIT8(KFuncFormat8, "><%S");
+
+ const TInt KMaxLogLineLength = 512;
+
+ // old function loggin macros
+ #define FLOG(a) {FPrint(a);}
+ #define FLOG_1(a,b) {FPrint(a,b);}
+ #define FLOG_2(a,b,c) {FPrint(a,b,c);}
+ #define FTRACE(a) {a;}
+ #define LOGGER_ENTERFN( name ) {TRACE_FUNC_ENTRY;}
+ #define LOGGER_LEAVEFN( name ) {TRACE_FUNC_EXIT;}
+
+ #define LOGGER_WRITE( text ) {_LIT( KTemp, text ); FPrint( KTemp );}
+ #define LOGGER_WRITE_1( text,par1 ) {_LIT( KTemp, text ); FPrint( KTemp, par1 );}
+ #define LOGGER_WRITE8_1( text,par1 ) {_LIT8( KTemp, text ); FPrint( KTemp, par1 );}
+ #define LOGGER_WRITE_2( text,par1,par2 ) {_LIT( KTemp, text ); FPrint( KTemp, par1, par2 );}
+ #define LOGGER_WRITE_3( text,par1,par2,par3 ) {_LIT( KTemp, text ); FPrint( KTemp, par1, par2, par3 );}
+
+ // New function logging macros
+ #define TRACE_FUNC_ENTRY {TPtrC8 ptr8((TUint8*)__PRETTY_FUNCTION__); FPrint(KFuncEntryFormat8, &ptr8);}
+ #define TRACE_FUNC_EXIT {TPtrC8 ptr8((TUint8*)__PRETTY_FUNCTION__); FPrint(KFuncExitFormat8, &ptr8);}
+ #define TRACE_FUNC {TPtrC8 ptr8((TUint8*)__PRETTY_FUNCTION__); FPrint(KFuncFormat8, &ptr8);}
+
+ // Declare the FPrint function
+ inline void FPrint( TRefByValue<const TDesC16> aFmt, ...)
+ {
+ VA_LIST list;
+ VA_START(list,aFmt);
+ #ifdef __FLOGGING__
+ RFileLogger::WriteFormat( KLogDir, KLogFile, EFileLoggingModeAppend, aFmt, list );
+ #endif
+ TBuf16<KMaxLogLineLength> theFinalString;
+ theFinalString.Append(KTracePrefix16);
+ TOverflowTruncate16 overflow;
+ theFinalString.AppendFormatList(aFmt,list,&overflow);
+ RDebug::Print(theFinalString);
+ }
+
+ // Declare the FPrint function
+ inline void FPrint(TRefByValue<const TDesC8> aFmt, ...)
+ {
+ VA_LIST list;
+ VA_START(list, aFmt);
+ #ifdef __FLOGGING__
+ RFileLogger::WriteFormat(KLogDir, KLogFile, EFileLoggingModeAppend, aFmt, list);
+ #endif
+ TOverflowTruncate8 overflow;
+ TBuf8<KMaxLogLineLength> buf8;
+ buf8.Append(KTracePrefix8);
+ buf8.AppendFormatList(aFmt, list, &overflow);
+ TBuf16<KMaxLogLineLength> buf16(buf8.Length());
+ buf16.Copy(buf8);
+ TRefByValue<const TDesC> tmpFmt(_L("%S"));
+ RDebug::Print(tmpFmt, &buf16);
+ }
+#else
+
+ // No loggings --> reduced code size
+ #define FLOG(a)
+ #define FLOG_1(a,b)
+ #define FLOG_2(a,b,c)
+ #define FTRACE(a)
+ #define LOGGER_ENTERFN( name )
+ #define LOGGER_LEAVEFN( name )
+ #define LOGGER_WRITE( text )
+ #define LOGGER_WRITE_1( text, par1 )
+ #define LOGGER_WRITE8_1( text, par1 )
+ #define LOGGER_WRITE_2( text, par1, par2 )
+ #define LOGGER_WRITE_3( text, par1, par2, par3 )
+ #define TRACE_FUNC_ENTRY
+ #define TRACE_FUNC_EXIT
+ #define TRACE_FUNC
+
+#endif //_DEBUG
+
+#endif // SECON_DEBUG_H
+
+// End of file
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/inc/logdatastoreformat.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,98 @@
+/*
+* Copyright (c) 2010 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: Simple class for tracing datastore format
+*
+*/
+
+#ifndef LOGDATASTOREFORMAT_H_
+#define LOGDATASTOREFORMAT_H_
+
+//
+#include "debug.h"
+
+NONSHARABLE_CLASS(TLogDataStoreFormat)
+ {
+ public:
+#ifndef _DEBUG
+// does nothing on release version
+static void TLogDataStoreFormat::LogDataStoreFormatL( const TDesC& /*aLogInfo*/, const CSmlDataStoreFormat& /*aDataStoreFormat*/ )
+ {
+ }
+#else
+static void TLogDataStoreFormat::LogDataStoreFormatL( const TDesC& aLogInfo, const CSmlDataStoreFormat& aDataStoreFormat )
+ {
+ LOGGER_WRITE_1("LogDataStoreFormatL, aLogInfo: %S", &aLogInfo);
+ LOGGER_WRITE_1("DisplayName: %S", &aDataStoreFormat.DisplayName());
+ TBool hasMaxSize = aDataStoreFormat.IsSupported( CSmlDataStoreFormat::EOptionHasMaxSize );
+ TBool hasMaxItems = aDataStoreFormat.IsSupported( CSmlDataStoreFormat::EOptionHasMaxItems );
+ TBool hierarcial = aDataStoreFormat.IsSupported( CSmlDataStoreFormat::EOptionHierarchial );
+ LOGGER_WRITE_1("hasMaxSize: %d", (TInt)hasMaxSize);
+ LOGGER_WRITE_1("hasMaxItems: %d", (TInt)hasMaxItems);
+ LOGGER_WRITE_1("hierarcial: %d", (TInt)hierarcial);
+ LOGGER_WRITE_1("MimeFormatCount: %d", aDataStoreFormat.MimeFormatCount());
+ for ( TInt i = 0; i < aDataStoreFormat.MimeFormatCount(); i++)
+ {
+ LOGGER_WRITE_1(" MimeFormat(%d)",i);
+ const CSmlMimeFormat& mimeformat = aDataStoreFormat.MimeFormat(i);
+ LOGGER_WRITE8_1(" MimeType: %S", &mimeformat.MimeType().DesC());
+ LOGGER_WRITE8_1(" MimeVersion: %S", &mimeformat.MimeVersion().DesC());
+ LOGGER_WRITE_1( " FieldLevel, bool: %d", (TInt) mimeformat.FieldLevel());
+ LOGGER_WRITE_1( " PropertyCount: %d", mimeformat.PropertyCount());
+ for ( TInt j=0; j<mimeformat.PropertyCount(); j++ )
+ {
+ LOGGER_WRITE_1(" MimeFormat property(%d)",j);
+ const CSmlDataProperty& dataProp = mimeformat.Property(j);
+ const CSmlDataField& dataField = dataProp.Field();
+ LOGGER_WRITE8_1(" dataField: %S", &dataField.Name().DesC());
+ LOGGER_WRITE_1( " DisplayName: %S", &dataField.DisplayName());
+ LOGGER_WRITE_1( " HasMaxSize: %d", (TInt)dataProp.HasMaxSize());
+ LOGGER_WRITE_1( " MaxSize: %d", dataProp.MaxSize());
+ LOGGER_WRITE_1( " HasMaxOccur: %d", (TInt)dataProp.HasMaxOccur());
+ LOGGER_WRITE_1( " MaxOccur: %d", dataProp.MaxOccur());
+ TBool OptionNoTruncate = dataProp.IsSupported(CSmlDataProperty::EOptionNoTruncate);
+ LOGGER_WRITE_1( " EOptionNoTruncate: %d", (TInt)OptionNoTruncate);
+ LOGGER_WRITE8_1(" DataType(): %S", &dataField.DataType().DesC());
+ LOGGER_WRITE_1( " EnumValueCount(): %d", dataField.EnumValueCount());
+ for ( TInt k=0; k<dataField.EnumValueCount(); k++)
+ {
+ LOGGER_WRITE8_1(" EnumValue(): %S", &dataField.EnumValue(k).DesC());
+ }
+ LOGGER_WRITE_1(" ParamCount: %d", dataProp.ParamCount());
+ for ( TInt k=0; k<dataProp.ParamCount(); k++)
+ {
+ LOGGER_WRITE_1( " dataParamField(%d)", k);
+ const CSmlDataPropertyParam& param = dataProp.Param(k);
+ const CSmlDataField& field = param.Field();
+ LOGGER_WRITE8_1(" dataParamField: %S", &field.Name().DesC());
+ LOGGER_WRITE_1( " dataParamDisplayName: %S", &field.DisplayName());
+ LOGGER_WRITE8_1(" dataParamDataType(): %S", &field.DataType().DesC());
+ LOGGER_WRITE_1( " dataParamEnumValueCount(): %d", field.EnumValueCount());
+ for ( TInt l=0; l<field.EnumValueCount(); l++)
+ {
+ LOGGER_WRITE8_1(" dataParamEnumValue(): %S", &field.EnumValue(l).DesC());
+ }
+
+ LOGGER_WRITE(" ---------------");
+ }
+ LOGGER_WRITE( " -----------------");
+ }
+
+ LOGGER_WRITE( " -----------------");
+ }
+ }
+#endif
+ };
+
+
+#endif /* LOGDATASTOREFORMAT_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/inc/sconasynchandler.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,127 @@
+/*
+* Copyright (c) 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: CSconAsyncHandler header
+*
+*/
+
+
+#ifndef SCONASYNCHANDLER_H_
+#define SCONASYNCHANDLER_H_
+
+#include <e32base.h>
+#include <f32file.h>
+
+#include <syncml/SmlDataSyncDefs.h>
+#include <stringpool.h>
+
+#include "cscontimeout.h"
+
+class CSmlDataStore;
+class CSconSyncRelationship;
+class CSmlDataProvider;
+class CNSmlDataItemUidSet;
+class CSmlDataStoreFormat;
+
+NONSHARABLE_CLASS ( CSconAsyncHandler ): public CActive, MTimeOutObserver
+{
+public:
+ static CSconAsyncHandler* NewL();
+ ~CSconAsyncHandler();
+ void HandleServiceL( const RMessage2& aMessage );
+
+private: // From CActive
+ void RunL();
+ TInt RunError(TInt aError);
+ void DoCancel();
+
+private: // From MTimeOutObserver
+ void TimeOut();
+
+private:
+
+ CSconAsyncHandler();
+ void ConstructL();
+
+ void HandleChunkMessage();
+ void ListAllImplementationsL();
+ void OpenStoreL();
+
+ void OpenItemL();
+ void OpenItemCompletedL( TInt aError );
+
+ void CreateItemL();
+ void CreateItemCompletedL( TInt aError );
+ void ReplaceItemL();
+ void ReplaceItemCompletedL( TInt aError );
+ void MoveItemL();
+ void DeleteItemL();
+ void SoftDeleteItemL();
+ void DeleteAllItemsL();
+ void ReadParentL();
+ void ReadParentCompletedL( TInt aError );
+
+ void HasHistoryL();
+ void AddedItemsL();
+ void DeletedItemsL();
+ void SoftDeletedItemsL();
+ void ModifiedItemsL();
+ void MovedItemsL();
+ //void ListChangesL();
+ void ResetChangeInfoL();
+ void CommitChangeInfoL();
+ void CloseStore();
+
+ void SetSyncTimeStampL();
+ void GetSyncTimeStampL();
+
+ void ExportStoreFormatL();
+ void SetRemoteStoreFormatL();
+
+ void LeaveIfNoInstanceL();
+
+ void DoCloseStore();
+
+ void CleanOldStoresL();
+ void CompleteRequest( TInt aError );
+private:
+ RChunk iChunk;
+
+ RStringPool iStringPool;
+ CSmlDataStoreFormat* iStoreFormat;
+ CSmlDataProvider* iDataProvider;
+ CSmlDataStore* iDataStore;
+ CSconSyncRelationship* iContext;
+ RFs iFs;
+ RMessage2 iMessage;
+
+ // for committing changes
+ CNSmlDataItemUidSet* iItems;
+
+ // for opening item
+ TBool iFieldChange;
+ TInt iSize;
+ TInt iParent;
+ TBuf8<64> iMimeType;
+ TBuf8<64> iMimeVer;
+
+ // for creating item
+ TSmlDbItemUid iNewItem;
+ HBufC8* iWriteData;
+ TBool iCommitInProgress;
+
+ CCSconTimeOut* iTimeOut;
+ TBool iForceCancel;
+};
+
+#endif /*SCONASYNCHANDLER_H_*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/inc/sconsyncclientserver.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,64 @@
+/*
+* Copyright (c) 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: Sync Client-Server header
+*
+*/
+
+
+#ifndef SCONSYNCCLIENTSERVER_H
+#define SCONSYNCCLIENTSERVER_H
+
+#include <e32base.h>
+
+_LIT(KSconSyncServerName, "sconsyncserver");
+_LIT(KSconSyncServerExe, "sconsyncserver.exe");
+
+
+enum TService
+{
+ ESendChunkHandle,
+ ECancelRequest,
+ EListImplementations,
+
+ EOpenStore,
+ EOpenItem,
+ ECreateItem,
+ EReplaceItem,
+ EMoveItem,
+ EDeleteItem,
+ ESoftDeleteItem,
+ EDeleteAllItems,
+ EReadParent,
+
+ EHasHistory,
+ EAddedItems,
+ EDeletedItems,
+ ESoftDeletedItems,
+ EModifiedItems,
+ EMovedItems,
+
+ //EListChanges,
+ EResetChangeInfo,
+ ECommitChangeInfo,
+
+ ECloseStore,
+ ESetSyncTimeStamp,
+ EGetSyncTimeStamp,
+ EExportStoreFormat,
+ ESetRemoteStoreFormat,
+
+ EMaxService // Not an actual service
+};
+
+#endif // SCONSYNCCLIENTSERVER_H
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/inc/sconsyncrelationship.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,90 @@
+/*
+* Copyright (c) 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: CSconSyncRelationship header
+*
+*/
+
+
+#ifndef SCONSYNCRELATIONSHIP_H_
+#define SCONSYNCRELATIONSHIP_H_
+
+#include <e32base.h>
+#include <f32file.h>
+#include <s32file.h>
+#include <syncml/smldatasyncdefs.h>
+#include <syncmldef.h>
+
+class CDictionaryFileStore;
+
+NONSHARABLE_CLASS ( CSconSyncRelationship ) : public CBase, public MSmlSyncRelationship
+ {
+public:
+ /**
+ * Creates CSconSyncRelationship object.
+ * @param aFs reference to open RFs connection
+ * @param aRelationUid uniqueID for each server-client pair
+ * @return new CSconSyncRelationship object
+ */
+ static CSconSyncRelationship* NewL( RFs& aFs, TUid aRelationUid, TSmlDataProviderId aProviderId );
+ ~CSconSyncRelationship();
+
+ static void SetTimeStampL( RFs& aFs, TUid aRelationUid, TSmlDataProviderId aId );
+ static void GetTimeStampL( RFs& aFs, TUid aRelationUid, TSmlDataProviderId aId, TDateTime& aTimeStamp );
+
+public: // From MSmlSyncRelationship
+
+ /**
+ * Returns the unique identifier for the synchronisation relationship.
+ *
+ * @return A unique identifier for the sync relationship.
+ */
+ TSmlSyncTaskKey SyncTaskKey() const;
+
+ /**
+ * Opens a specified stream for reading, and places an item on the cleanup stack to close it.
+ *
+ * @param aReadStream On return, an open read stream
+ * @param aStreamUid The UID of the stream to open for reading.
+ */
+ void OpenReadStreamLC(RReadStream& aReadStream, TUid aStreamUid);
+
+ /**
+ * Opens the specified stream, or creates a new one if it does not exist, and places an item on the cleanup stack to close it.
+ *
+ * @param aWriteStream On return, an open write stream
+ * @param aStreamUid The UID of the stream to open or create
+ */
+ void OpenWriteStreamLC(RWriteStream& aWriteStream, TUid aStreamUid);
+
+ /**
+ * Tests if the specified stream identified exists in the store.
+ *
+ * @param aStreamUid The stream UID
+ * @return Non-zero if the stream exists, otherwise EFalse.
+ */
+ TBool IsStreamPresentL(TUid aStreamUid) const;
+
+private:
+ CSconSyncRelationship( RFs& aFs, TUid aRelationUid, TSmlDataProviderId aProviderId );
+ void ConstructL();
+
+private:
+
+ CDictionaryFileStore* iDictionaryStore;
+ RFs& iFs;
+ TUid iID;
+ TSmlDataProviderId iProviderId;
+ };
+
+#endif /*SCONSYNCRELATIONSHIP_H_*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/inc/sconsyncserver.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,46 @@
+/*
+* Copyright (c) 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: CSconSyncServer header
+*
+*/
+
+
+#ifndef __SCONSYNCSERVER_H__
+#define __SCONSYNCSERVER_H__
+
+#include <e32base.h>
+
+class CSconSyncServer : public CPolicyServer
+{
+public:
+ static CSconSyncServer* NewL();
+ static CSconSyncServer* NewLC();
+ virtual ~CSconSyncServer();
+
+ void AddSession();
+ void RemoveSession();
+
+private:
+ CSconSyncServer();
+ void ConstructL();
+
+ CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;
+ TInt RunError(TInt aError);
+
+private:
+ TInt iSessionCount;
+
+};
+
+#endif // __SCONSYNCSERVER_H__
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/inc/sconsyncsession.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,47 @@
+/*
+* Copyright (c) 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: CSconSyncSession header
+*
+*/
+
+
+#ifndef __SCONSYNCSESSION_H__
+#define __SCONSYNCSESSION_H__
+
+#include <e32base.h>
+
+
+class CSconSyncServer;
+class CSconAsyncHandler;
+
+class CSconSyncSession : public CSession2
+ {
+public:
+ static CSconSyncSession* NewL();
+
+ void CreateL();
+
+private:
+ CSconSyncSession();
+ ~CSconSyncSession();
+ void ConstructL();
+
+ CSconSyncServer& Server();
+ void ServiceL(const RMessage2& aMessage);
+
+private:
+ CSconAsyncHandler* iAsyncHandler;
+ };
+
+#endif // __SCONSYNCSESSION_H__
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/rom/sconsyncserver.iby Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,26 @@
+/*
+* Copyright (c) 2010 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: IBY file for SconSyncServer
+*
+*/
+
+#ifndef _SCONSYNCSERVER_IBY_
+#define _SCONSYNCSERVER_IBY_
+
+#include <data_caging_paths_for_iby.hrh>
+
+//file content
+file=ABI_DIR\BUILD_DIR\sconsyncserver.exe PROGRAMS_DIR\sconsyncserver.exe
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/src/cscontimeout.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,85 @@
+/*
+* Copyright (c) 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: CCSconTimeOut implementation
+*
+*/
+
+#include "cscontimeout.h"
+
+CCSconTimeOut::CCSconTimeOut( MTimeOutObserver& aTimeOutObserver ) :
+ CActive(EPriorityStandard), // Standard priority
+ iTimeOutObserver(aTimeOutObserver)
+ {
+ }
+
+
+CCSconTimeOut* CCSconTimeOut::NewL( MTimeOutObserver& aTimeOutObserver )
+ {
+ CCSconTimeOut* self = new (ELeave) CCSconTimeOut( aTimeOutObserver );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+void CCSconTimeOut::ConstructL()
+ {
+ User::LeaveIfError(iTimer.CreateLocal()); // Initialize timer
+ CActiveScheduler::Add(this); // Add to scheduler
+ }
+
+CCSconTimeOut::~CCSconTimeOut()
+ {
+ Cancel(); // Cancel any request, if outstanding
+ iTimer.Close(); // Destroy the RTimer object
+ // Delete instance variables if any
+ }
+
+void CCSconTimeOut::DoCancel()
+ {
+ iTimer.Cancel();
+ }
+
+void CCSconTimeOut::Start(TTimeIntervalMicroSeconds32 aDelay)
+ {
+ Cancel(); // Cancel any request, just to be sure
+ iState = EUninitialized;
+ iTimer.After(iStatus, aDelay); // Set for later
+ SetActive(); // Tell scheduler a request is active
+ }
+
+void CCSconTimeOut::RunL()
+ {
+ /*if (iState == EUninitialized)
+ {
+ // Do something the first time RunL() is called
+ iState = EInitialized;
+ }
+ else if (iState != EError)
+ {
+ // Do something
+ }
+ iTimer.After(iStatus, 1000000); // Set for 1 sec later
+ SetActive(); // Tell scheduler a request is active*/
+ if ( iState == KErrNone )
+ {
+ iTimeOutObserver.TimeOut();
+ }
+
+ }
+
+TInt CCSconTimeOut::RunError(TInt aError)
+ {
+ return aError;
+ }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/src/sconasynchandler.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,1179 @@
+/*
+* Copyright (c) 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: CSconAsyncHandler implementation
+*
+*/
+
+
+#include "sconasynchandler.h"
+
+#include <ecom/ecom.h>
+#include <SmlDataProvider.h>
+#include <s32mem.h>
+#include <nsmlchangefinder.h>
+#include <e32cmn.h>
+#include <ecom/ImplementationInformation.h>
+#include <mmf/common/mmfcontrollerpluginresolver.h>
+
+#include "sconsyncclientserver.h"
+#include "sconsyncrelationship.h"
+#include "scondataproviderinfo.h"
+#include "debug.h"
+#include "logdatastoreformat.h"
+
+// Data Store interface implementation Uid.
+// Load all plugins with this uid.
+const TUid KDSEcomIFUid = {0x101F4D3A};
+
+const TInt KDefaultExpandSize = 1024;
+
+// one store per computer, max store count.
+const TInt KMaxStoresCount = 10;
+
+const TInt KDefaultTimeOutInMicroSeconds = 30 * 1000000; // 30 seconds
+const TInt KDeleteAllTimeOutInMicroSeconds = 300 * 1000000; // 5 minutes
+const TInt KOpenStoreTimeOutInMicroSeconds = 180 * 1000000; // 180 seconds
+
+CSconAsyncHandler::~CSconAsyncHandler()
+ {
+ TRACE_FUNC_ENTRY;
+ Cancel();
+ DoCloseStore();
+ delete iItems;
+ delete iWriteData;
+ delete iDataStore;
+ delete iDataProvider;
+ delete iContext;
+ delete iStoreFormat;
+ iStringPool.Close();
+ iFs.Close();
+ REComSession::FinalClose();
+ iChunk.Close();
+ delete iTimeOut;
+ TRACE_FUNC_EXIT;
+ }
+
+CSconAsyncHandler::CSconAsyncHandler(): CActive( EPriorityStandard )
+ {
+ TRACE_FUNC;
+ CActiveScheduler::Add( this );
+ }
+
+CSconAsyncHandler* CSconAsyncHandler::NewL()
+ {
+ TRACE_FUNC;
+ CSconAsyncHandler* self = new(ELeave) CSconAsyncHandler();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+void CSconAsyncHandler::ConstructL()
+ {
+ TRACE_FUNC;
+ User::LeaveIfError( iFs.Connect() );
+ TInt err = iFs.CreatePrivatePath( EDriveC );
+ LOGGER_WRITE_1("CreatePrivatePath err: %d", err);
+ iStringPool.OpenL();
+ iTimeOut = CCSconTimeOut::NewL( *this );
+ }
+
+// -----------------------------------------------------------------------------
+// CSconAsyncHandler::HandleServiceL()
+// Handles the client request
+// -----------------------------------------------------------------------------
+//
+void CSconAsyncHandler::HandleServiceL( const RMessage2& aMessage )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( aMessage.Function() == ECancelRequest )
+ {
+ LOGGER_WRITE("ECancelRequest");
+ if ( IsActive() )
+ {
+ Cancel();
+ LOGGER_WRITE("iMessage.Complete( KErrCancel )");
+ CompleteRequest( KErrCancel );
+ }
+
+ LOGGER_WRITE("aMessage.Complete( KErrNone )");
+ aMessage.Complete( KErrNone );
+ TRACE_FUNC_EXIT;
+ return;
+ }
+
+ iTimeOut->Start( KDefaultTimeOutInMicroSeconds );
+
+ iMessage = aMessage;
+ switch ( aMessage.Function() )
+ {
+ case ESendChunkHandle:
+ LOGGER_WRITE( "CSconSyncSession::ServiceL() : ESendChunkHandle" );
+ HandleChunkMessage();
+ break;
+
+ case EListImplementations:
+ LOGGER_WRITE( "CSconSyncSession::ServiceL() : EListImplementations" );
+ ListAllImplementationsL();
+ break;
+
+ case EOpenStore:
+ LOGGER_WRITE( "CSconSyncSession::ServiceL() : EOpenStore" );
+ iTimeOut->Start( KOpenStoreTimeOutInMicroSeconds );
+ OpenStoreL();
+ break;
+
+ case EOpenItem:
+ OpenItemL();
+ break;
+ case ECreateItem:
+ CreateItemL();
+ break;
+ case EReplaceItem:
+ ReplaceItemL();
+ break;
+ case EMoveItem:
+ MoveItemL();
+ break;
+ case EDeleteItem:
+ DeleteItemL();
+ break;
+ case ESoftDeleteItem:
+ SoftDeleteItemL();
+ break;
+ case EDeleteAllItems:
+ iTimeOut->Start( KDeleteAllTimeOutInMicroSeconds );
+ DeleteAllItemsL();
+ break;
+ case EReadParent:
+ ReadParentL();
+ break;
+
+ case EHasHistory:
+ HasHistoryL();
+ break;
+ case EAddedItems:
+ AddedItemsL();
+ break;
+ case EDeletedItems:
+ DeletedItemsL();
+ break;
+ case ESoftDeletedItems:
+ SoftDeletedItemsL();
+ break;
+ case EModifiedItems:
+ ModifiedItemsL();
+ break;
+ case EMovedItems:
+ MovedItemsL();
+ break;
+ case EResetChangeInfo:
+ ResetChangeInfoL();
+ break;
+ case ECommitChangeInfo:
+ CommitChangeInfoL();
+ break;
+ case ECloseStore:
+ CloseStore();
+ break;
+ case ESetSyncTimeStamp:
+ SetSyncTimeStampL();
+ break;
+ case EGetSyncTimeStamp:
+ GetSyncTimeStampL();
+ break;
+ case EExportStoreFormat:
+ ExportStoreFormatL();
+ break;
+ case ESetRemoteStoreFormat:
+ SetRemoteStoreFormatL();
+ break;
+
+ default:
+ aMessage.Complete(KErrNotSupported);
+ break;
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+
+void CSconAsyncHandler::RunL()
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("iStatus.Int(): %d", iStatus.Int());
+ switch ( iMessage.Function() )
+ {
+ case EOpenStore:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : EOpenStore" );
+ CompleteRequest( iStatus.Int() );
+ break;
+
+ case EOpenItem:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : EOpenItem" );
+ OpenItemCompletedL( iStatus.Int() );
+ break;
+
+ case ECreateItem:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : ECreateItem" );
+ if (!iCommitInProgress)
+ {
+ // Write data to item
+ CreateItemCompletedL( iStatus.Int() );
+ }
+ else
+ {
+ // commit is done, all ready
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : ECreateItem, commit done" );
+ TPckg<TSmlDbItemUid> pckg(iNewItem);
+ iMessage.WriteL( 0, pckg, 0);
+ CompleteRequest( iStatus.Int() );
+ }
+ break;
+
+ case EReplaceItem:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : EReplaceItem" );
+ if (!iCommitInProgress)
+ {
+ // Write data to item
+ ReplaceItemCompletedL( iStatus.Int() );
+ }
+ else
+ {
+ // commit is done, all ready
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : EReplaceItem, commit done" );
+ CompleteRequest( iStatus.Int() );
+ }
+ break;
+
+ case EMoveItem:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : EMoveItem" );
+ CompleteRequest( iStatus.Int() );
+ break;
+
+ case EDeleteItem:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : EDeleteItem" );
+ CompleteRequest( iStatus.Int() );
+ break;
+
+ case ESoftDeleteItem:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : ESoftDeleteItem" );
+ CompleteRequest( iStatus.Int() );
+ break;
+
+ case EDeleteAllItems:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : EDeleteAllItems" );
+ CompleteRequest( iStatus.Int() );
+ break;
+
+ case EReadParent:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : EReadParent" );
+ ReadParentCompletedL( iStatus.Int() );
+ break;
+
+ case EResetChangeInfo:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : EResetChangeInfo" );
+ CompleteRequest( iStatus.Int() );
+ break;
+
+ case ECommitChangeInfo:
+ LOGGER_WRITE( "CSconAsyncHandler::RunL() : ECommitChangeInfo" );
+ delete iItems;
+ iItems = NULL;
+ CompleteRequest( iStatus.Int() );
+ break;
+
+ default:
+ LOGGER_WRITE("Not asynchronous function")
+ CompleteRequest( KErrNotSupported );
+ break;
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+TInt CSconAsyncHandler::RunError(TInt aError)
+ {
+ LOGGER_WRITE_1("CSconAsyncHandler::RunError() aError: %d", aError);
+ delete iItems;
+ iItems = NULL;
+ delete iWriteData;
+ iWriteData = NULL;
+
+ if ( IsActive() )
+ {
+ LOGGER_WRITE("IsActive");
+ //iDataStore->CancelRequest();
+ Cancel();
+ }
+
+ if ( iDataStore && iMessage.Function() == EOpenItem )
+ {
+ LOGGER_WRITE( "CSconAsyncHandler::RunError() : EOpenItem" );
+ iDataStore->CloseItem();
+ }
+
+ CompleteRequest( aError );
+ aError = KErrNone;
+ LOGGER_WRITE_1("CSconAsyncHandler::RunError() : Return %d", aError);
+ return aError;
+ //return KErrNone;//aError;
+ }
+
+void CSconAsyncHandler::DoCancel()
+ {
+ TRACE_FUNC_ENTRY;
+ iDataStore->CancelRequest();
+ iTimeOut->Cancel();
+
+ if ( iStatus == KRequestPending )
+ {
+ LOGGER_WRITE( "iStatus == KRequestPending" );
+ }
+
+ if ( iDataStore && iMessage.Function() == EOpenItem )
+ {
+ LOGGER_WRITE( "CSconAsyncHandler::RunError() : EOpenItem" );
+ iDataStore->CloseItem();
+ }
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::TimeOut()
+ {
+ TRACE_FUNC_ENTRY;
+ if ( IsActive() )
+ {
+ Cancel();
+ CompleteRequest( KErrCancel );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+
+void CSconAsyncHandler::HandleChunkMessage()
+ {
+ TRACE_FUNC_ENTRY;
+ TInt ret ( KErrNone );
+
+ ret = iChunk.Open( iMessage, 0, EFalse );
+
+ LOGGER_WRITE_1( "CSconAsyncHandler::HandleChunkMessageL() : ret %d", ret );
+ CompleteRequest( ret );
+ }
+
+
+
+void CSconAsyncHandler::ListAllImplementationsL()
+ {
+ TRACE_FUNC_ENTRY;
+
+ RImplInfoPtrArray implInfoArray;
+ CleanupResetAndDestroyPushL( implInfoArray );
+ REComSession::ListImplementationsL( KDSEcomIFUid, implInfoArray );
+
+ const TInt KDataproviderInfoSize = 250; // 250 bytes should be enought
+ TInt requiredSize = implInfoArray.Count() * KDataproviderInfoSize;
+ if ( iChunk.Size() < requiredSize )
+ {
+ User::LeaveIfError( iChunk.Adjust( requiredSize ) );
+ }
+
+ RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( stream );
+
+ RSconDataProviderInfoArray dpInfoArray;
+ CleanupResetAndDestroyPushL( dpInfoArray );
+
+ // Collect information from dataproviders
+ for ( TInt i=0; i < implInfoArray.Count(); i++ )
+ {
+ LOGGER_WRITE_1("implInfoArray: %d",i);
+ CImplementationInformation& implInfo = *implInfoArray[i];
+
+ CSmlDataProvider* dp(NULL);
+ TRAPD( err, dp = CSmlDataProvider::NewL( implInfo.ImplementationUid().iUid ) );
+ LOGGER_WRITE_2("CSmlDataProvider::NewL, uid(0x%08x) err: %d",implInfo.ImplementationUid().iUid, err );
+ if ( !err )
+ {
+ CleanupStack::PushL( dp );
+
+ CSconDataproviderInfo *dpInfo = CSconDataproviderInfo::NewL();
+ CleanupStack::PushL( dpInfo );
+
+ dpInfo->SetImplementationUid( implInfo.ImplementationUid() );
+ LOGGER_WRITE_1("ImplementationUid: 0x%08x", implInfo.ImplementationUid().iUid );
+ dpInfo->SetDisplayNameL( implInfo.DisplayName() );
+ LOGGER_WRITE_1("DisplayName: %S", &implInfo.DisplayName() );
+
+ dpInfo->SetDefaultStoreL( dp->DefaultStoreL() );
+ LOGGER_WRITE_1("DefaultStoreL: %S", &dp->DefaultStoreL() );
+ CDesCArray* stores = dp->ListStoresLC();
+ dpInfo->SetStoresL( *stores );
+ CleanupStack::PopAndDestroy( stores );
+
+ dpInfoArray.AppendL( dpInfo );
+ CleanupStack::Pop( dpInfo );
+
+ CleanupStack::PopAndDestroy( dp );
+ }
+ }
+
+ // Wrtie to stream
+ stream.WriteUint16L( dpInfoArray.Count() );
+ for ( TInt i = 0; i < dpInfoArray.Count(); i++ )
+ {
+ CSconDataproviderInfo& dpInfo = *dpInfoArray[i];
+ dpInfo.ExternalizeL( stream );
+ }
+
+ stream.CommitL();
+
+ CleanupStack::PopAndDestroy( &dpInfoArray );
+ CleanupStack::PopAndDestroy( &stream );
+ CleanupStack::PopAndDestroy( &implInfoArray );
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::OpenStoreL()
+ {
+ TRACE_FUNC_ENTRY;
+ if ( iDataStore )
+ {
+ LOGGER_WRITE("Warning: Previous DataStore was not closed properly.");
+ DoCloseStore();
+ }
+
+ // copy data from the chunk
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ TSmlDataProviderId providerId = readStream.ReadUint32L();
+ LOGGER_WRITE_1("providerId: 0x%08x", providerId);
+
+ TInt len = readStream.ReadUint32L();
+ HBufC* storeName = HBufC::NewLC(len);
+ TPtr storeNamePtr = storeName->Des();
+ readStream.ReadL(storeNamePtr, len);
+ LOGGER_WRITE_1("storeName: %S", &storeNamePtr);
+
+ TInt contextUid = readStream.ReadUint32L();
+
+ LOGGER_WRITE_1("contextIdentifier: 0x%08x", contextUid);
+
+ LOGGER_WRITE("Open provider");
+ delete iDataProvider;
+ iDataProvider = NULL;
+ iDataProvider = CSmlDataProvider::NewL( providerId );
+
+ delete iContext;
+ iContext = NULL;
+
+ delete iStoreFormat;
+ iStoreFormat = NULL;
+
+ LOGGER_WRITE("Create context");
+ iContext = CSconSyncRelationship::NewL( iFs, TUid::Uid(contextUid), providerId );
+
+
+ LOGGER_WRITE("Create NewStoreInstanceLC");
+ iDataStore = iDataProvider->NewStoreInstanceLC();
+ CleanupStack::Pop( iDataStore );
+
+ SetActive();
+ iStatus = KRequestPending;
+ LOGGER_WRITE("OpenL");
+ TRAPD(err, iDataStore->OpenL(storeNamePtr,*iContext, iStatus));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->OpenL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+
+ CleanupStack::PopAndDestroy( storeName );
+ CleanupStack::PopAndDestroy( &readStream );
+
+ TRACE_FUNC_EXIT;
+ }
+
+
+void CSconAsyncHandler::OpenItemL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ if ( IsActive() )
+ {
+ LOGGER_WRITE("Was still in Active");
+ Cancel();
+ }
+
+ TSmlDbItemUid itemUid = iMessage.Int0();
+ LOGGER_WRITE_1("Open item: %d", itemUid);
+
+ // set default values
+ iFieldChange = EFalse;
+ iSize = 0;
+ iParent = 0;
+ iMimeType.Copy(KNullDesC);
+ iMimeVer.Copy(KNullDesC);
+
+ SetActive();
+ LOGGER_WRITE("iDataStore->OpenItemL");
+ iStatus = KRequestPending;
+ TRAPD( err, iDataStore->OpenItemL(itemUid,iFieldChange,iSize,iParent,iMimeType,iMimeVer,iStatus));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->OpenItemL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::OpenItemCompletedL( TInt aError )
+ {
+ TRACE_FUNC_ENTRY;
+ // item opened, now read it
+ if ( aError )
+ {
+ CompleteRequest( aError );
+ return;
+ }
+ LeaveIfNoInstanceL();
+
+ LOGGER_WRITE_1("item size: %d", iSize);
+
+ TInt totalObjectSize( 0 );
+ totalObjectSize+= sizeof(TInt32); // data length
+ totalObjectSize+= iSize; // data
+ totalObjectSize+= sizeof(TInt8); // iFieldChange
+ totalObjectSize+= sizeof(TInt32); // iParent
+ totalObjectSize+= sizeof(TInt32); // iMimeType
+ totalObjectSize+= iMimeType.Length(); // iMimeType
+ totalObjectSize+= sizeof(TInt32); // iMimeVer
+ totalObjectSize+= iMimeVer.Length(); // iMimeType
+
+ LOGGER_WRITE_1("iChunk.Size(): %d", iChunk.Size());
+ LOGGER_WRITE_1("iChunk.MaxSize(): %d", iChunk.MaxSize());
+ LOGGER_WRITE_1("totalObjectSize: %d", totalObjectSize);
+
+ if ( iChunk.Size() < totalObjectSize )
+ {
+ LOGGER_WRITE("adjust chunk");
+ TInt err = iChunk.Adjust( totalObjectSize );
+ LOGGER_WRITE_1("Chunk.Adjust err: %d", err);
+ User::LeaveIfError( err );
+ }
+ LOGGER_WRITE_1("new Chunk size: %d", iChunk.Size());
+ LOGGER_WRITE_1("new ChunkMaxSize(): %d", iChunk.MaxSize());
+ RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( stream );
+
+ LOGGER_WRITE("ReadItemL");
+ HBufC8* tempBuf = HBufC8::NewLC(iSize);
+ TPtr8 tempPtr = tempBuf->Des();
+
+ TUint8* ptr = (TUint8*) tempPtr.Ptr();
+
+ TPtr8 tempPtr2( ptr, 0, iSize );
+ LOGGER_WRITE_1( "tempPtr2.Size(): %d", tempPtr2.Size());
+ iDataStore->ReadItemL( tempPtr2 );
+ LOGGER_WRITE("ReadItemL -ok");
+
+ LOGGER_WRITE_1("readed Length: %d", tempPtr2.Length() );
+ LOGGER_WRITE_1("readed Size: %d", tempPtr2.Size() );
+
+ LOGGER_WRITE8_1("iMimeType: %S", &iMimeType );
+ LOGGER_WRITE_1("iMimeType.Length(): %d", iMimeType.Length() );
+ LOGGER_WRITE_1("iMimeType Size: %d", iMimeType.Size() );
+
+ LOGGER_WRITE8_1("iMimeVer: %S", &iMimeVer );
+ LOGGER_WRITE_1("iMimeVer.Length(): %d", iMimeVer.Length() );
+ LOGGER_WRITE_1("iMimeVer Size: %d", iMimeVer.Size() );
+
+ iDataStore->CloseItem();
+ LOGGER_WRITE("Write to chunk");
+ stream.WriteInt32L( tempPtr2.Length() );
+ stream.WriteL( tempPtr2 );
+ CleanupStack::PopAndDestroy( tempBuf );
+
+ stream.WriteInt8L( (TInt)iFieldChange );
+ stream.WriteInt32L( iParent );
+ stream.WriteInt32L( iMimeType.Length() );
+ stream.WriteL( iMimeType );
+ stream.WriteInt32L( iMimeVer.Length() );
+ stream.WriteL( iMimeVer );
+
+ stream.CommitL();
+ LOGGER_WRITE("Writed ok");
+ CleanupStack::PopAndDestroy( &stream );
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::CreateItemL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ iCommitInProgress = EFalse;
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ TSmlDbItemUid parent = readStream.ReadUint32L();
+ TInt len = readStream.ReadUint32L();
+ readStream.ReadL(iMimeType, len);
+ len = readStream.ReadUint32L();
+ readStream.ReadL(iMimeVer, len);
+ len = readStream.ReadUint32L();
+ delete iWriteData;
+ iWriteData = NULL;
+ iWriteData = HBufC8::New(len);
+ TPtr8 dataPtr = iWriteData->Des();
+ readStream.ReadL(dataPtr, len);
+ CleanupStack::PopAndDestroy( &readStream );
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err, iDataStore->CreateItemL( iNewItem, dataPtr.Size(), parent, iMimeType, iMimeVer, iStatus ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->CreateItemL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::CreateItemCompletedL( TInt aError )
+ {
+ TRACE_FUNC_ENTRY;
+ User::LeaveIfError( aError );
+ LeaveIfNoInstanceL();
+ // CreateItem completed, now we must write the data to the created item and commit it.
+
+ iDataStore->WriteItemL( iWriteData->Des() );
+ delete iWriteData;
+ iWriteData = NULL;
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err, iDataStore->CommitItemL( iStatus ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->CommitItemL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ iCommitInProgress = ETrue;
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::ReplaceItemL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+
+ iCommitInProgress = EFalse;
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ TSmlDbItemUid uid = readStream.ReadUint32L();
+ TSmlDbItemUid parent = readStream.ReadUint32L();
+ TBool fieldChange = readStream.ReadUint8L();
+ TInt len = readStream.ReadUint32L();
+ delete iWriteData;
+ iWriteData = NULL;
+ iWriteData = HBufC8::New(len);
+ TPtr8 dataPtr = iWriteData->Des();
+ readStream.ReadL(dataPtr, len);
+
+ CleanupStack::PopAndDestroy( &readStream );
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err,iDataStore->ReplaceItemL( uid,dataPtr.Size(),parent,fieldChange, iStatus ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->CommitItemL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::ReplaceItemCompletedL( TInt aError )
+ {
+ TRACE_FUNC_ENTRY;
+ User::LeaveIfError( aError );
+ LeaveIfNoInstanceL();
+ // CreateItem completed, now we must write the data to the created item and commit it.
+
+ iDataStore->WriteItemL( iWriteData->Des() );
+ delete iWriteData;
+ iWriteData = NULL;
+
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err, iDataStore->CommitItemL( iStatus ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->CommitItemL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ iCommitInProgress = ETrue;
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::MoveItemL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ TSmlDbItemUid uid = iMessage.Int0();
+ TSmlDbItemUid newParent = iMessage.Int1();
+ LOGGER_WRITE_1( "uid: %d", uid );
+ LOGGER_WRITE_1( "newParent: %d", newParent );
+
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err, iDataStore->MoveItemL( uid, newParent, iStatus ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->MoveItemL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::DeleteItemL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+
+ TSmlDbItemUid uid = iMessage.Int0();
+ LOGGER_WRITE_1( "uid: %d", uid );
+
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err, iDataStore->DeleteItemL( uid, iStatus ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->DeleteItemL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::SoftDeleteItemL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+
+ TSmlDbItemUid uid = iMessage.Int0();
+ LOGGER_WRITE_1( "uid: %d", uid );
+
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err, iDataStore->SoftDeleteItemL( uid, iStatus ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->SoftDeleteItemL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::DeleteAllItemsL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err, iDataStore->DeleteAllItemsL( iStatus ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->DeleteAllItemsL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::ReadParentL()
+ {
+ TRACE_FUNC_ENTRY;
+ OpenItemL();
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::ReadParentCompletedL( TInt aError )
+ {
+ TRACE_FUNC_ENTRY;
+ // item opened, now read it
+ if ( aError )
+ {
+ CompleteRequest( aError );
+ return;
+ }
+ LeaveIfNoInstanceL();
+
+ iDataStore->CloseItem();
+
+ TPckg<TSmlDbItemUid> pckg(iParent);
+ iMessage.WriteL( 1, pckg, 0);
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::HasHistoryL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ TBool hasHistory = iDataStore->HasSyncHistory();
+
+ TPckgC<TBool> pckg(hasHistory);
+ iMessage.WriteL( 0, pckg, 0);
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::AddedItemsL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ const MSmlDataItemUidSet& items = iDataStore->AddedItems();
+
+ RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( stream );
+ items.ExternalizeL( stream );
+ CleanupStack::PopAndDestroy( &stream );
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::DeletedItemsL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ const MSmlDataItemUidSet& items = iDataStore->DeletedItems();
+
+ RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( stream );
+ items.ExternalizeL( stream );
+ CleanupStack::PopAndDestroy( &stream );
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::SoftDeletedItemsL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ const MSmlDataItemUidSet& items = iDataStore->SoftDeletedItems();
+
+ RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( stream );
+ items.ExternalizeL( stream );
+ CleanupStack::PopAndDestroy( &stream );
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::ModifiedItemsL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ const MSmlDataItemUidSet& items = iDataStore->ModifiedItems();
+
+ RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( stream );
+ items.ExternalizeL( stream );
+ CleanupStack::PopAndDestroy( &stream );
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::MovedItemsL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ const MSmlDataItemUidSet& items = iDataStore->MovedItems();
+
+ RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( stream );
+ items.ExternalizeL( stream );
+ CleanupStack::PopAndDestroy( &stream );
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::ResetChangeInfoL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err, iDataStore->ResetChangeInfoL( iStatus ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->ResetChangeInfoL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::CommitChangeInfoL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ if ( iItems )
+ {
+ delete iItems;
+ iItems = NULL;
+ }
+ iItems = new (ELeave) CNSmlDataItemUidSet();
+ iItems->InternalizeL( readStream );
+
+ CleanupStack::PopAndDestroy( &readStream );
+
+ SetActive();
+ iStatus = KRequestPending;
+ TRAPD(err, iDataStore->CommitChangeInfoL( iStatus, *iItems ));
+ if ( err )
+ {
+ // we are on active state, call request completed (RunL)
+ LOGGER_WRITE_1("iDataStore->CommitChangeInfoL leaved with err: %d", err);
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, err );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::CloseStore()
+ {
+ TRACE_FUNC_ENTRY;
+ DoCloseStore();
+ REComSession::FinalClose();
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::SetSyncTimeStampL()
+ {
+ TRACE_FUNC_ENTRY;
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+ TInt relationId = readStream.ReadInt32L();
+ TInt providerId = readStream.ReadInt32L();
+ CleanupStack::PopAndDestroy( &readStream );
+
+ CSconSyncRelationship::SetTimeStampL( iFs, TUid::Uid(relationId), providerId);
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::GetSyncTimeStampL()
+ {
+ TRACE_FUNC_ENTRY;
+ TInt providerId = iMessage.Int0();
+ TInt relationId = iMessage.Int1();
+
+ TDateTime time;
+ CSconSyncRelationship::GetTimeStampL( iFs, TUid::Uid(relationId), providerId, time);
+
+ // write timestamp
+ TPckgC<TDateTime> timeBuf(time);
+ iMessage.WriteL( 2, timeBuf, 0);
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::ExportStoreFormatL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+ if ( !iDataProvider )
+ {
+ User::Leave( KErrNotReady );
+ }
+ CBufFlat* buffer = CBufFlat::NewL( KDefaultExpandSize );
+ CleanupStack::PushL( buffer );
+ RBufWriteStream stream( *buffer );
+ CleanupClosePushL( stream );
+
+ const CSmlDataStoreFormat& storeFormat = iDataProvider->StoreFormatL();
+ TRAP_IGNORE( TLogDataStoreFormat::LogDataStoreFormatL( _L("iDataProvider->StoreFormatL()"), storeFormat ));
+
+ storeFormat.ExternalizeL( stream );
+
+ stream.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ buffer->Compress();
+
+ RMemWriteStream chunkStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( chunkStream );
+
+ chunkStream.WriteInt32L( buffer->Size() );
+ chunkStream.WriteL( buffer->Ptr(0), buffer->Size());
+ chunkStream.CommitL();
+ CleanupStack::PopAndDestroy( &chunkStream );
+
+ CleanupStack::PopAndDestroy( buffer );
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::SetRemoteStoreFormatL()
+ {
+ TRACE_FUNC_ENTRY;
+ LeaveIfNoInstanceL();
+
+ RMemReadStream readStream( iChunk.Base(), iChunk.Size() );
+ CleanupClosePushL( readStream );
+
+ if ( iStoreFormat )
+ {
+ delete iStoreFormat;
+ iStoreFormat = NULL;
+ }
+ iStoreFormat = CSmlDataStoreFormat::NewLC( iStringPool, readStream);
+ CleanupStack::Pop( iStoreFormat );
+ TRAP_IGNORE( TLogDataStoreFormat::LogDataStoreFormatL( _L("iDataProvider->SetRemoteStoreFormatL()"), *iStoreFormat ));
+ iDataStore->SetRemoteStoreFormatL( *iStoreFormat );
+
+ CleanupStack::PopAndDestroy( &readStream );
+
+ CompleteRequest( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::LeaveIfNoInstanceL()
+ {
+ if ( !iDataStore )
+ {
+ LOGGER_WRITE("DataStore instance was not ready, leaving KErrNotReady");
+ User::Leave( KErrNotReady );
+ }
+ }
+
+void CSconAsyncHandler::DoCloseStore()
+ {
+ TRACE_FUNC_ENTRY;
+ delete iItems;
+ iItems = NULL;
+ delete iWriteData;
+ iWriteData = NULL;
+ if ( iDataProvider && iContext )
+ {
+ TInt providerId = iDataProvider->Identifier();
+ TInt contextId = iContext->SyncTaskKey();
+ TRAP_IGNORE( CSconSyncRelationship::SetTimeStampL( iFs, TUid::Uid(contextId), providerId) );
+ }
+ delete iDataStore;
+ iDataStore = NULL;
+ delete iDataProvider;
+ iDataProvider = NULL;
+ delete iContext;
+ iContext = NULL;
+ delete iStoreFormat;
+ iStoreFormat = NULL;
+
+ CleanOldStoresL();
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::CleanOldStoresL()
+ {
+ TRACE_FUNC_ENTRY;
+ TFileName path;
+ User::LeaveIfError( iFs.PrivatePath( path ) );
+ CDir* dir;
+ iFs.GetDir( path, KEntryAttNormal, ESortByDate, dir );
+ CleanupStack::PushL( dir );
+ TInt storesCount(0);
+ LOGGER_WRITE_1("count: %d", dir->Count() );
+ for ( TInt i=dir->Count()-1; i >= 0; i-- )
+ {
+ LOGGER_WRITE_1("dir[%d]", i);
+ TEntry entry = (*dir)[i];
+ LOGGER_WRITE_1("file: %S", &entry.iName);
+ _LIT(KContextStoreName, "contextstore");
+ _LIT(KTimeStoreName, "timestore");
+ if ( entry.iName.Find(KContextStoreName) == 0 )
+ {
+ storesCount++;
+ LOGGER_WRITE_1("storeNro: %d", storesCount);
+#ifdef _DEBUG
+ TTime time = entry.iModified;
+ TDateTime dt = time.DateTime();
+ _LIT(KFormat, "%d.%d %02d:%02d");
+ TFileName mod;
+ mod.Format(KFormat, dt.Day()+1, dt.Month()+1, dt.Hour()+1,dt.Minute() );
+ LOGGER_WRITE_1("time: %S", &mod);
+#endif
+ if ( storesCount > KMaxStoresCount )
+ {
+ LOGGER_WRITE_1("delete contextstore: '%S'", &entry.iName );
+ iFs.Delete( entry.iName );
+ TFileName timeStoreFile;
+ timeStoreFile = entry.iName.Right(15);
+ timeStoreFile.Insert(0, KTimeStoreName);
+ LOGGER_WRITE_1("delete timeStoreFile: %S", &timeStoreFile);
+ iFs.Delete( timeStoreFile );
+ }
+ }
+
+ }
+ CleanupStack::PopAndDestroy( dir );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconAsyncHandler::CompleteRequest( TInt aError )
+ {
+ TRACE_FUNC;
+ iTimeOut->Cancel();
+ LOGGER_WRITE_1("iMessage.Complete( %d )", aError);
+ iMessage.Complete( aError );
+ }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/src/sconsyncrelationship.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,181 @@
+/*
+* Copyright (c) 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: CSconSyncRelationship implementation
+*
+*/
+
+
+#include "sconsyncrelationship.h"
+#include <s32file.h>
+#include <nsmlchangefinder.h>
+
+#include "debug.h"
+
+_LIT(KContextStore, "contextstore_0x%08x.dat");
+_LIT(KTimeStore, "timestore_0x%08x.dat");
+
+CSconSyncRelationship::~CSconSyncRelationship()
+ {
+ TRACE_FUNC_ENTRY;
+ if ( iDictionaryStore )
+ {
+ iDictionaryStore->Commit();
+ delete iDictionaryStore;
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+CSconSyncRelationship::CSconSyncRelationship( RFs& aFs, TUid aRelationUid, TSmlDataProviderId aProviderId )
+ : iFs(aFs), iID(aRelationUid), iProviderId(aProviderId)
+ {
+ TRACE_FUNC;
+
+ }
+
+CSconSyncRelationship* CSconSyncRelationship::NewL( RFs& aFs, TUid aRelationUid, TSmlDataProviderId aProviderId )
+ {
+ TRACE_FUNC_ENTRY;
+ CSconSyncRelationship* self = new (ELeave) CSconSyncRelationship( aFs, aRelationUid, aProviderId );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ TRACE_FUNC_EXIT;
+ return self;
+ }
+
+void CSconSyncRelationship::SetTimeStampL( RFs& aFs, TUid aRelationUid, TSmlDataProviderId aId )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aRelationUid: 0x%08x", aRelationUid.iUid );
+ LOGGER_WRITE_1("aId: 0x%08x", aId );
+ aFs.SetSessionToPrivate( EDriveC );
+ TFileName file;
+ file.Format(KTimeStore, aRelationUid.iUid);
+ CDictionaryFileStore* dictionaryStore = CDictionaryFileStore::OpenLC(aFs, file, TUid::Uid(0x0001));
+
+ RDictionaryWriteStream stream;
+ stream.AssignLC( *dictionaryStore, TUid::Uid(aId) );
+
+ TTime time;
+ time.UniversalTime();
+
+ TDateTime dateTime = time.DateTime();
+ TPckgBuf<TDateTime> timeBuf(dateTime);
+
+ stream.WriteL( timeBuf );
+ stream.CommitL();
+
+ CleanupStack::PopAndDestroy( &stream ); //AssingLC
+ dictionaryStore->Commit();
+ CleanupStack::PopAndDestroy( dictionaryStore );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncRelationship::GetTimeStampL( RFs& aFs, TUid aRelationUid, TSmlDataProviderId aId, TDateTime& aTimeStamp )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aRelationUid: 0x%08x", aRelationUid.iUid );
+ LOGGER_WRITE_1("aId: 0x%08x", aId );
+ User::LeaveIfError( aFs.SetSessionToPrivate( EDriveC ) );
+ TFileName file;
+ file.Format(KTimeStore, aRelationUid.iUid);
+ CDictionaryFileStore* dictionaryStore = CDictionaryFileStore::OpenLC(aFs, file, TUid::Uid(0x0001));
+ TBool present = dictionaryStore->IsPresentL( TUid::Uid(aId) );
+ if ( !present )
+ {
+ LOGGER_WRITE("Stream was not present");
+ User::Leave(KErrNotFound);
+ }
+ RDictionaryReadStream stream;
+ stream.OpenLC( *dictionaryStore, TUid::Uid(aId) );
+ TPckgBuf<TDateTime> timeBuf;
+ stream.ReadL( timeBuf );
+ aTimeStamp = timeBuf();
+ CleanupStack::PopAndDestroy(); //OpenLC
+ CleanupStack::PopAndDestroy( dictionaryStore );
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncRelationship::ConstructL()
+ {
+ TRACE_FUNC_ENTRY;
+ iFs.SetSessionToPrivate( EDriveC );
+ TFileName file;
+ file.Format(KContextStore, iID.iUid);
+ iDictionaryStore = CDictionaryFileStore::OpenL(
+ iFs, file, TUid::Uid(0x0001));
+
+ TRACE_FUNC_EXIT;
+ }
+
+
+TSmlSyncTaskKey CSconSyncRelationship::SyncTaskKey() const
+ {
+ TRACE_FUNC;
+ return static_cast<TSmlSyncTaskKey>(iID.iUid);
+ }
+
+void CSconSyncRelationship::OpenReadStreamLC(RReadStream& aReadStream, TUid aStreamUid)
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aStreamUid: 0x%08x", aStreamUid);
+ TUid streamUid(aStreamUid);
+ if ( aStreamUid.iUid == KNSmlDefaultSnapshotStreamUID )
+ {
+ LOGGER_WRITE_1(" Default stream uid was used, use provider uid (0x%08x) as stream uid", iProviderId);
+ streamUid.iUid = iProviderId;
+ }
+ if ( !IsStreamPresentL( streamUid ) )
+ {
+ LOGGER_WRITE("Stream was not present");
+ User::Leave(KErrNotFound);
+ }
+
+
+ static_cast<RDictionaryReadStream&>(aReadStream).OpenLC(
+ *iDictionaryStore, streamUid );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncRelationship::OpenWriteStreamLC(RWriteStream& aWriteStream, TUid aStreamUid)
+ {
+ TRACE_FUNC_ENTRY;
+
+ LOGGER_WRITE_1("aStreamUid: 0x%08x", aStreamUid);
+ TUid streamUid(aStreamUid);
+ if ( aStreamUid.iUid == KNSmlDefaultSnapshotStreamUID )
+ {
+ LOGGER_WRITE_1(" Default stream uid was used, use provider uid (0x%08x) as stream uid", iProviderId);
+ streamUid.iUid = iProviderId;
+ }
+ static_cast<RDictionaryWriteStream&>(aWriteStream).AssignLC(
+ *iDictionaryStore, streamUid );
+ TRACE_FUNC_EXIT;
+ }
+
+TBool CSconSyncRelationship::IsStreamPresentL(TUid aStreamUid) const
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aStreamUid: 0x%08x", aStreamUid.iUid );
+ TUid streamUid(aStreamUid);
+ if ( aStreamUid.iUid == KNSmlDefaultSnapshotStreamUID )
+ {
+ LOGGER_WRITE_1(" Default stream uid was used, use provider uid (0x%08x) as stream uid", iProviderId);
+ streamUid.iUid = iProviderId;
+ }
+ TBool present = iDictionaryStore->IsPresentL( streamUid );
+ LOGGER_WRITE_1("CSconSyncRelationship::IsStreamPresentL() return: %d",(TInt)present);
+ return present;
+ }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/src/sconsyncserver.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,177 @@
+/*
+* Copyright (c) 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: CSconSyncServer implementation
+*
+*/
+
+
+#include "sconsyncserver.h"
+#include "sconsyncclientserver.h"
+
+#include "sconsyncsession.h"
+#include "debug.h"
+
+const TInt KSConPCConnServerUid = 0x101F99F6;
+
+// Security policy
+const TUint KServerPolicyRangeCount = 2;
+
+const TInt KServerPolicyRanges[KServerPolicyRangeCount] =
+ {
+ 0, // range is 0 inclusive
+ EMaxService // range is 1-KMaxTInt inclusive
+ };
+
+const TUint8 KServerPolicyElementsIndex[KServerPolicyRangeCount] =
+ {
+ 0, // applies to 0th range
+ CPolicyServer::ENotSupported // applies to 1st range
+ };
+
+const CPolicyServer::TPolicyElement KServerPolicyElements[] =
+ {
+ { _INIT_SECURITY_POLICY_S0(KSConPCConnServerUid) /*_INIT_SECURITY_POLICY_C1(ECapabilityReadDeviceData)*/, CPolicyServer::EFailClient }
+ };
+
+const CPolicyServer::TPolicy KServerPolicy =
+ {
+ 0 /*CPolicyServer::EAlwaysPass*/, // specifies all connect attempts should pass
+ KServerPolicyRangeCount,
+ KServerPolicyRanges,
+ KServerPolicyElementsIndex,
+ KServerPolicyElements
+ };
+
+
+CSconSyncServer* CSconSyncServer::NewL()
+ {
+ CSconSyncServer* self = NewLC();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CSconSyncServer* CSconSyncServer::NewLC()
+ {
+ CSconSyncServer* self = new(ELeave) CSconSyncServer();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+CSconSyncServer::CSconSyncServer() :
+ CPolicyServer(EPriorityStandard, KServerPolicy, ESharableSessions)
+ {
+ }
+
+void CSconSyncServer::ConstructL()
+ {
+ TRACE_FUNC_ENTRY;
+ TInt error = Start(KSconSyncServerName);
+
+ if (error != KErrNone)
+ {
+ User::Panic(KSconSyncServerName, error);
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+CSconSyncServer::~CSconSyncServer()
+ {
+ TRACE_FUNC;
+ }
+
+CSession2* CSconSyncServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const
+ {
+ TRACE_FUNC;
+ TVersion v(1,0,0);
+ if ( !User::QueryVersionSupported(v,aVersion) )
+ {
+ TVersionName vname = aVersion.Name();
+ LOGGER_WRITE_1("Client has wrong version: %S", &vname);
+ User::Leave( KErrNotSupported );
+ }
+
+ return CSconSyncSession::NewL();
+ }
+
+TInt CSconSyncServer::RunError(TInt aError)
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aError: %d", aError);
+ // Bad descriptor implies bad client
+ if (aError == KErrBadDescriptor)
+ {
+ Message().Panic(KSconSyncServerName, aError);
+ }
+ else
+ {
+ Message().Complete(aError);
+ }
+
+ // Continue handling requests
+ ReStart();
+ TRACE_FUNC_EXIT;
+ return KErrNone;
+ }
+
+void CSconSyncServer::AddSession()
+ {
+ ++iSessionCount;
+ LOGGER_WRITE_1("CSconSyncServer::AddSession(), iSessionCount: %d", iSessionCount);
+ }
+
+void CSconSyncServer::RemoveSession()
+ {
+ --iSessionCount;
+ LOGGER_WRITE_1("CSconSyncServer::RemoveSession(), iSessionCount: %d", iSessionCount);
+ if (iSessionCount == 0)
+ {
+ CActiveScheduler::Stop();
+ }
+ }
+
+LOCAL_C void ExeMainL()
+ {
+ TRACE_FUNC_ENTRY;
+ // Install active scheduler
+ CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
+ CleanupStack::PushL(scheduler);
+ CActiveScheduler::Install(scheduler);
+
+ CSconSyncServer::NewLC();
+
+ User::LeaveIfError(User::RenameThread(KSconSyncServerName));
+ RProcess::Rendezvous(KErrNone);
+
+ CActiveScheduler::Start();
+
+ CleanupStack::PopAndDestroy(); // CSconSyncServer
+ CleanupStack::PopAndDestroy(); // CActiveScheduler
+ TRACE_FUNC_EXIT;
+ }
+
+GLDEF_C TInt E32Main()
+ {
+ TRACE_FUNC_ENTRY;
+ __UHEAP_MARK;
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+
+ TRAPD(error, ExeMainL());
+ __ASSERT_ALWAYS(!error, User::Panic(KSconSyncServerName, error));
+
+ delete cleanup;
+ __UHEAP_MARKEND;
+ TRACE_FUNC_EXIT;
+ return 0;
+ }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/servers/syncserver/src/sconsyncsession.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,96 @@
+/*
+* Copyright (c) 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: CSconSyncSession implementation
+*
+*/
+
+
+#include "sconsyncsession.h"
+
+#include "sconsyncserver.h"
+#include "sconsyncclientserver.h"
+#include "sconasynchandler.h"
+#include "debug.h"
+
+
+CSconSyncSession::CSconSyncSession()
+ {
+ TRACE_FUNC;
+ }
+
+CSconSyncSession* CSconSyncSession::NewL()
+ {
+ TRACE_FUNC;
+ CSconSyncSession* self = new(ELeave) CSconSyncSession();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+void CSconSyncSession::ConstructL()
+ {
+ TRACE_FUNC_ENTRY;
+ iAsyncHandler = CSconAsyncHandler::NewL();
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncSession::CreateL()
+ {
+ TRACE_FUNC;
+ Server().AddSession();
+ }
+
+CSconSyncSession::~CSconSyncSession()
+ {
+ TRACE_FUNC_ENTRY;
+ delete iAsyncHandler;
+
+ Server().RemoveSession();
+
+ TRACE_FUNC_EXIT;
+ }
+
+CSconSyncServer& CSconSyncSession::Server()
+ {
+ return *static_cast<CSconSyncServer*>(const_cast<CServer2*>(CSession2::Server()));
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSconSyncSession::ServiceL()
+// Handles the client request
+// -----------------------------------------------------------------------------
+//
+void CSconSyncSession::ServiceL(const RMessage2& aMessage)
+ {
+ TRACE_FUNC_ENTRY;
+
+ TRAPD( err, iAsyncHandler->HandleServiceL( aMessage ));
+ if ( err )
+ {
+ LOGGER_WRITE_1("iAsyncHandler->HandleServiceL leaved: %d", err);
+ if ( iAsyncHandler->IsActive() )
+ {
+ LOGGER_WRITE(" and it was active -> Cancel it");
+ iAsyncHandler->Cancel();
+ }
+ // do server error processing
+ User::Leave( err );
+ }
+
+ TRACE_FUNC_EXIT;
+ }
+
+
Binary file connectivitymodules/SeCon/services/csc/bld/101F99F6.xml has changed
--- a/connectivitymodules/SeCon/services/csc/bld/bld.inf Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/csc/bld/bld.inf Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2010 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"
@@ -22,17 +22,9 @@
DEFAULT
PRJ_EXPORTS
-./101F9698.xml /epoc32/data/Z/private/101F99F6/capability/101F9698.xml
-./fwdcomp.xml /epoc32/data/Z/private/101F99F6/capability/fwdcomp.xml
-./101F99F6.xml /epoc32/data/Z/private/101F99F6/capability/101F99F6.xml
-
-./101F9698.xml /epoc32/RELEASE/winscw/udeb/Z/private/101F99F6/capability/101F9698.xml
-./fwdcomp.xml /epoc32/RELEASE/winscw/udeb/Z/private/101F99F6/capability/fwdcomp.xml
-./101F99F6.xml /epoc32/RELEASE/winscw/udeb/Z/private/101F99F6/capability/101F99F6.xml
-
+./101F9698.xml Z:/private/101F99F6/capability/101F9698.xml
+./fwdcomp.xml Z:/private/101F99F6/capability/fwdcomp.xml
+./101F99F6.xml Z:/private/101F99F6/capability/101F99F6.xml
PRJ_MMPFILES
-
sconcsc.mmp
-
-
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/services/oviaccounthandler/inc/sconoviaccounthandler.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,58 @@
+/*
+* Copyright (c) 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: CSconOviAccountHandler header file
+*
+*/
+
+
+#ifndef _SCONOVIACCOUNTHANDLER_H_
+#define _SCONOVIACCOUNTHANDLER_H_
+
+#include <e32base.h>
+#include <s32strm.h>
+
+_LIT(KSconOviAccountHandlerDllName, "sconoviaccounthandler.dll");
+const TUid KSconOviAccountHandlerDllUid={0x10009D8D};
+
+class CWSOviAccountManager;
+
+/**
+ * CSconOviAccountHandler provides Ovi account information.
+ * Dynamically loadable dll.
+ */
+class CSconOviAccountHandler : public CBase
+{
+ public:
+ static CSconOviAccountHandler* NewL();
+ ~CSconOviAccountHandler();
+
+ /**
+ * Reads account information from device
+ * @param aAccountInfoStream stream where to export account details.
+ * @leave KErrNotFound if account information does not exist.
+ */
+ virtual void GetOviAccountDetailsL( RWriteStream& aAccountInfoStream );
+
+ private:
+ void ConstructL();
+
+ private: // Data
+ CWSOviAccountManager* iOviAccountManager;
+
+};
+
+IMPORT_C CSconOviAccountHandler* CreateCSconOviAccountHandlerL();
+typedef CSconOviAccountHandler* (*TSConCreateCSconOviAccountHandlerFunc) ();
+
+#endif // _SCONOVIACCOUNTHANDLER_H_
--- a/connectivitymodules/SeCon/services/pcd/bld/bld.inf Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/bld/bld.inf Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2002-2010 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"
@@ -23,7 +23,7 @@
DEFAULT
PRJ_EXPORTS
-./sbeconfig.xml /epoc32/data/Z/private/10202D56/sbeconfig.xml
+./sbeconfig.xml Z:/private/10202D56/sbeconfig.xml
PRJ_MMPFILES
sconpcd.mmp
--- a/connectivitymodules/SeCon/services/pcd/bld/sconpcd.mmp Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/bld/sconpcd.mmp Thu Aug 19 10:44:03 2010 +0300
@@ -51,6 +51,7 @@
SOURCE sconpcdutility.cpp
SOURCE sconmetadata.cpp
SOURCE sconvideoparser.cpp
+SOURCE sconsynchandler.cpp
SOURCE cscontimeout.cpp
SOURCEPATH ../../../common/conmltask/src
@@ -59,6 +60,7 @@
USERINCLUDE ../inc
USERINCLUDE ../../../inc
USERINCLUDE ../../../common/conmltask/inc
+USERINCLUDE ../../../clients/syncclient/inc
// Default system include paths
APP_LAYER_SYSTEMINCLUDE
@@ -84,5 +86,10 @@
LIBRARY ImageConversion.lib // for CImageEncoder
LIBRARY MMFControllerFramework.lib // for CMMFMetaDataEntry
LIBRARY bafl.lib // for BaflUtils
+LIBRARY ecom.lib
+LIBRARY estor.lib // CDictionaryFileStore
+LIBRARY sconsyncclient.lib
+LIBRARY smlstoreformat.lib
+LIBRARY centralrepository.lib
DEBUGLIBRARY flogger.lib
// End of file
--- a/connectivitymodules/SeCon/services/pcd/inc/sconmetadatafielddefs.h Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/inc/sconmetadatafielddefs.h Thu Aug 19 10:44:03 2010 +0300
@@ -46,6 +46,8 @@
const TUint8 KSconAudioUniqueFileIdentifier( 0x11 );
const TUint8 KSconAudioDuration ( 0x12 );
const TUint8 KSconAudioDate ( 0x13 );
+const TUint8 KSconAudioUnsyncLyrics ( 0x14 );
+const TUint8 KSconAudioProtected ( 0x15 );
// fields for exif
const TUint8 KSconExifThumbnail ( 0x01 );
--- a/connectivitymodules/SeCon/services/pcd/inc/sconpcd.h Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/inc/sconpcd.h Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies).
+* 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"
@@ -23,11 +23,13 @@
#include <e32base.h>
#include <e32cons.h>
+#include <s32strm.h>
#include "sconconmltask.h"
class CSConInstallerQueue;
class CSConBackupRestoreQueue;
+class CSconSyncHandler;
enum TSConLastConMLOperation
{
@@ -68,6 +70,9 @@
* @return none
*/
virtual void ResetPCD();
+
+ virtual void HandleGetSyncRequestL( const TDesC8& aRequest, RWriteStream& aResult, TInt aMaxObjectSize );
+ virtual void HandlePutSyncRequestL( const TDesC8& aRequest, RReadStream& aResult );
private:
/**
@@ -153,6 +158,7 @@
TInt iMaxObjectSize;
TSConLastConMLOperation iLastOperation;
RFs iFs;
+ CSconSyncHandler* iSyncHandler;
};
IMPORT_C CSConPCD* CreateCSConPCDL();
--- a/connectivitymodules/SeCon/services/pcd/inc/sconsbeclient.h Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/inc/sconsbeclient.h Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2010 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"
@@ -138,7 +138,12 @@
* @return KErrNone if no erros. Else system wide error codes.
*/
TInt ProcessRequestDataL();
- /**
+ /**
+ * Request data to iDataBuffer
+ * @return none
+ */
+ void RequestDataL( CSBGenericTransferType& aGenericTransferType );
+ /**
* Executes GetDataOwnerStatus task
* @return none
*/
@@ -209,25 +214,20 @@
* @param TDriveList drives to include
* @return dataowner data size in specified drives
*/
- TUint JavaDataSizeL( const TDesC& aJavaHash, const TDriveList& aDriveList ) const;
-
- private:
- CSBEClient* iSBEClient;
- TRequestStatus* iCallerStatus;
- TBool iProcessComplete;
- TInt iProcessIndex;
- TInt iMaxObjectSize;
-
- CSConTask* iCurrentTask;
- TInt iDataPos;
- TBool iDataLeft;
- TPtrC8 iDataPtr;
- TBool iLastChunk;
- TBool iBURModeNormal;
- TBool iRestoreMode;
- RFs& iFs;
- TBool iAllSnapshotsSuppliedCalled;
- };
+ TUint JavaDataSizeL( const TDesC& aJavaHash, const TDriveList& aDriveList ) const;
+
+ private:
+ CSBEClient* iSBEClient;
+ TRequestStatus* iCallerStatus;
+ CSConTask* iCurrentTask;
+ TBool iBURModeNormal;
+ TBool iRestoreMode;
+ RFs& iFs;
+ TBool iAllSnapshotsSuppliedCalled;
+ TBool iLastChunk;
+ CBufFlat* iDataBuffer;
+ TInt iDataBufferSize;
+ };
#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/services/pcd/inc/sconsynchandler.h Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,138 @@
+/*
+* Copyright (c) 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: CSconSyncHandler header
+*
+*/
+
+
+#ifndef SCONSYNCHANDLER_H_
+#define SCONSYNCHANDLER_H_
+
+#include <e32base.h>
+#include <s32file.h>
+#include "sconsyncclient.h"
+
+class RFs;
+class RWriteStream;
+class RReadStream;
+class RFileReadStream;
+
+NONSHARABLE_CLASS( TCreatedItem )
+ {
+public:
+ TInt iTemporaryId;
+ TInt iErrorCode;
+ TSmlDbItemUid iNewUid;
+ };
+
+NONSHARABLE_CLASS( TReplacedItem )
+ {
+public:
+ TSmlDbItemUid iItemUid;
+ TInt iErrorCode;
+ };
+
+NONSHARABLE_CLASS( CSconSyncHandler ) : public CActive
+{
+public:
+ static CSconSyncHandler* NewL( RFs& aFs );
+ ~CSconSyncHandler();
+
+ void HandleGetSyncRequestL( const TDesC8& aRequest, RWriteStream& aResult, TInt aMaxObjectSize );
+ void HandlePutSyncRequestL( const TDesC8& aRequest, RReadStream& aData );
+private:
+ CSconSyncHandler( RFs& aFs );
+ void ConstructL();
+
+ void ListStoresL( RWriteStream& aResult );
+ void OpenStoreL( const TDesC8& aParams, RWriteStream& aResult );
+ void CloseStoreL( RWriteStream& aResult );
+
+ void ListChangesL( RWriteStream& aResult );
+ void ResetChangeInfoL( RWriteStream& aResult );
+ void CommitChangesL( const TDesC8& aParams, RWriteStream& aResult );
+ void ReadItemsL( const TDesC8& aParams, RWriteStream& aResult );
+ void GetParentsL( const TDesC8& aParams, RWriteStream& aResult );
+ void CreateItemsL( RReadStream& aData );
+ void GetCreateItemsResponseL( const TDesC8& aParams, RWriteStream& aResult );
+ void ReplaceItemsL( RReadStream& aData );
+ void GetReplaceItemsResponseL( const TDesC8& aParams, RWriteStream& aResult );
+ void MoveItemsL( const TDesC8& aParams, RWriteStream& aResult );
+ void DeleteItemsL( const TDesC8& aParams, RWriteStream& aResult );
+ void SoftDeleteItemsL( const TDesC8& aParams, RWriteStream& aResult );
+ void DeleteAllItemsL( RWriteStream& aResult );
+ void GetDeleteAllItemsStatusL( RWriteStream& aResult );
+ void GetStoreFormatL( RWriteStream& aResult );
+ void SetRemoteStoreFormatL( RReadStream& aData );
+
+ void CreateNextItemOnStreamL();
+ void ReplaceNextItemOnStreamL();
+
+ void ReadNextDataBlockL( RWriteStream& aResult );
+ void ReadItemL( TSmlDbItemUid aUid, CBufFlat& aItemData );
+
+ void LoadRemoteStoreFormatL( TInt aContextId, TInt aProviderId );
+ void SaveRemoteStoreFormatL( CSmlDataStoreFormat& aStoreFormat, TInt aContextId, TInt aProviderId );
+
+ void CancelOperationsL( RWriteStream& aResult );
+
+ void Reset();
+
+ void SetCalendarCenrepL( TInt aProfileId, const TDesC& aServerId );
+ void ClearCalendarCenrepL();
+
+private: // from CActive
+ void DoCancel();
+ void RunL();
+ TInt RunError( TInt aError );
+
+private:
+ RFs& iFs; // Not owned
+ RSconSyncSession iSyncSession;
+ TBool iConnected;
+
+ TInt iCurrentDataProviderUid;
+ TInt iCurrentContextUid;
+
+ CBufFlat* iResponseData;
+
+ enum TSyncStatus
+ {
+ EReady,
+ ECreatingItemsFromFile,
+ EItemsCreated,
+ EReplacingItemsFromFile,
+ EItemsReplaced,
+ EDeletingAllItems
+ };
+ TSyncStatus iSyncStatus;
+
+ TInt iMaxObjectSize;
+ TInt iBytesWrited;
+ TBool iHasFileStream;
+ RFileReadStream iFileStream;
+ TSmlDbItemUid iCreatedItemUid;
+ TPckg<TSmlDbItemUid> iCreatedItemUidPckg;
+ TSmlDbItemUid iTemporaryItemUid;
+ TInt iItemsLeftInStream;
+ TInt iItemInProgress; // =1 if item is in progress
+ RArray<TCreatedItem> iCreatedItems;
+ RArray<TReplacedItem> iReplacedItems;
+ RArray<TSmlDbItemUid> iItemsToRead;
+ TReplacedItem iReplacedItem;
+ TFileName iFileInProgress;
+ TBool iCalendarCenrepUsed;
+};
+
+#endif /*SCONSYNCHANDLER_H_*/
--- a/connectivitymodules/SeCon/services/pcd/src/sconbackuprestore.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/src/sconbackuprestore.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -38,12 +38,10 @@
CSConBackupRestore* CSConBackupRestore::NewL( CSConBackupRestoreQueue* aQueue,
const TInt aMaxObjectSize, RFs& aFs )
{
- TRACE_FUNC_ENTRY;
CSConBackupRestore* self = new (ELeave) CSConBackupRestore( aQueue, aFs );
CleanupStack::PushL( self );
self->ConstructL( aMaxObjectSize );
CleanupStack::Pop( self );
- TRACE_FUNC_EXIT;
return self;
}
@@ -76,18 +74,12 @@
//
CSConBackupRestore::~CSConBackupRestore()
{
- TRACE_FUNC_ENTRY;
if( iSBEClient )
{
- if( iSBEClient->IsActive() )
- {
- iSBEClient->Cancel();
- }
-
+ iSBEClient->Cancel();
delete iSBEClient;
iSBEClient = NULL;
}
- TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
@@ -166,11 +158,7 @@
TRACE_FUNC_ENTRY;
if( iSBEClient )
{
- if( iSBEClient->IsActive() )
- {
- iSBEClient->Cancel();
- }
-
+ iSBEClient->Cancel();
delete iSBEClient;
iSBEClient = NULL;
}
@@ -212,11 +200,9 @@
//
void CSConBackupRestore::RunL()
{
- TRACE_FUNC_ENTRY;
-
+ TRACE_FUNC;
iQueue->CompleteTask( iCurrentTask, iStatus.Int() );
iBackupRestoreActive = EFalse;
- TRACE_FUNC_EXIT;
}
// End of file
--- a/connectivitymodules/SeCon/services/pcd/src/sconmetadata.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/src/sconmetadata.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -210,8 +210,8 @@
// get field id
fields.FieldIdAt( i , fieldId );
LOGGER_WRITE_2( "AudioFieldId( %d ): 0x%02x", i, fieldId );
-
- if ( fieldId == EMetaDataJpeg )
+ TUint8 sconFieldId = AudioFieldId( fieldId );
+ if ( sconFieldId == KSconAudioJpeg )
{
TPtrC8 field8( fields.Field8( fieldId ) );
AppendByteDataFieldL(
@@ -219,13 +219,16 @@
field8,
AudioFieldId( fieldId ) );
}
- else
+ else if ( sconFieldId > 0 )
{
// get field data and add UTF-8 formatted text to buffer
fieldData.Set( fields.At( i , fieldId ) );
- AppendUtf8DataFieldL( buffer, fieldData, AudioFieldId( fieldId ) );
+ AppendUtf8DataFieldL( buffer, fieldData, sconFieldId );
}
-
+ else
+ {
+ LOGGER_WRITE("Unknown field skipped");
+ }
}
if ( buffer->Size() > 0 )
@@ -426,6 +429,12 @@
case EMetaDataDate :
ret = KSconAudioDate;
break;
+ case EMetaDataUnsyncLyrics:
+ ret = KSconAudioUnsyncLyrics;
+ break;
+ case EMetaDataProtected:
+ ret = KSconAudioProtected;
+ break;
default :
LOGGER_WRITE( "SConMetadata::AudioFieldId : ERR field not defined!" );
break;
--- a/connectivitymodules/SeCon/services/pcd/src/sconpcd.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/src/sconpcd.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -23,6 +23,7 @@
#include "sconinstqueue.h"
#include "sconbrqueue.h"
#include "sconmetadata.h"
+#include "sconsynchandler.h"
#include "debug.h"
// ============================= MEMBER FUNCTIONS ===============================
@@ -88,6 +89,7 @@
}
CActiveScheduler::Add( iInstallerQueue );
CActiveScheduler::Add( iBackupRestoreQueue );
+ iSyncHandler = CSconSyncHandler::NewL( iFs );
TRACE_FUNC_EXIT;
}
@@ -119,6 +121,12 @@
iLatestReply = NULL;
}
+ if ( iSyncHandler )
+ {
+ iSyncHandler->Cancel();
+ delete iSyncHandler;
+ iSyncHandler = NULL;
+ }
iFs.Close();
TRACE_FUNC_EXIT;
}
@@ -260,6 +268,32 @@
}
// -----------------------------------------------------------------------------
+// CSConPCD::HandleGetSyncRequestL()
+//
+// -----------------------------------------------------------------------------
+//
+void CSConPCD::HandleGetSyncRequestL( const TDesC8& aRequest, RWriteStream& aResult, TInt aMaxObjectSize )
+ {
+ TRACE_FUNC_ENTRY;
+ iSyncHandler->HandleGetSyncRequestL( aRequest, aResult, aMaxObjectSize );
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::HandlePutSyncRequestL()
+//
+// -----------------------------------------------------------------------------
+//
+void CSConPCD::HandlePutSyncRequestL( const TDesC8& aRequest, RReadStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ iSyncHandler->HandlePutSyncRequestL( aRequest, aResult );
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
// CSConPCD::SupportedInstTaskL( CSConTask* aTask )
// Fills a reply with predefined supported task -information
// -----------------------------------------------------------------------------
@@ -421,16 +455,22 @@
for ( TInt i = 0; i < installerReply->iTasks.Count(); i++ )
{
- mergeReply->iTasks.Append( installerReply->iTasks[i]->CopyAndFreeL() );
+ CSConTaskReply* temp = installerReply->iTasks[i]->CopyAndFreeL();
+ CleanupStack::PushL( temp );
+ mergeReply->iTasks.AppendL( temp );
+ CleanupStack::Pop( temp );
}
// installer replys are copied to mergereply, delete installerReply
CleanupStack::PopAndDestroy( installerReply );
// do same for br reply
- for ( TInt j = 0; j < brReply->iTasks.Count(); j++ )
+ for ( TInt i = 0; i < brReply->iTasks.Count(); i++ )
{
- mergeReply->iTasks.Append( brReply->iTasks[j]->CopyAndFreeL() );
+ CSConTaskReply* temp = brReply->iTasks[i]->CopyAndFreeL();
+ CleanupStack::PushL( temp );
+ mergeReply->iTasks.AppendL( temp );
+ CleanupStack::Pop( temp );
}
CleanupStack::PopAndDestroy( brReply );
--- a/connectivitymodules/SeCon/services/pcd/src/sconpcdutility.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/src/sconpcdutility.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2006-2010 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"
@@ -217,7 +217,7 @@
CJavaRegistry* javaRegistry = CJavaRegistry::NewLC( );
RArray<TUid> packageUids;
CleanupClosePushL( packageUids );
- javaRegistry->GetRegistryEntryUidsL( /*EGeneralPackage,*/ packageUids );
+ javaRegistry->GetRegistryEntryUidsL( packageUids );
LOGGER_WRITE_1("packageUids.Count(): %d", packageUids.Count());
for (TInt i=0; i<packageUids.Count(); i++ )
{
@@ -317,7 +317,7 @@
RWidgetInfoArray widgetInfoArr;
CleanupClosePushL( widgetInfoArr );
widgetSession.InstalledWidgetsL( widgetInfoArr );
-
+ TFileName bundleId;
for ( TInt i = 0; i < widgetInfoArr.Count(); i++ )
{
CWidgetInfo *item = widgetInfoArr[i];
@@ -359,6 +359,9 @@
}
delete propValue;
propValue = NULL;
+ bundleId.Zero();
+ widgetSession.GetWidgetBundleId( item->iUid, bundleId );
+ app->iWidgetBundleId = bundleId.AllocL();
User::LeaveIfError( aListInstApps.iApps.Append( app ) );
CleanupStack::Pop( app ); // ownership transferred, do not delete
--- a/connectivitymodules/SeCon/services/pcd/src/sconsbeclient.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/connectivitymodules/SeCon/services/pcd/src/sconsbeclient.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2010 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"
@@ -24,7 +24,8 @@
#include "sconsbeclient.h"
#include "debug.h"
-
+const TInt KDataBufExpandSize( 1024 );
+const TInt KMaxObjectSize( 1048576 - 1024 ); // Max chunk size is 1MB, but give some space for ConML wbxml
_LIT( KSConNoDrive, "\x0" );
_LIT( KSConDriveExists, "\x1" );
// ============================= MEMBER FUNCTIONS ==============================
@@ -46,13 +47,10 @@
// Constructor
// -----------------------------------------------------------------------------
//
-CSConSBEClient::CSConSBEClient( const TInt aMaxObjectSize, RFs& aFs ) :
- CActive( EPriorityStandard ), iSBEClient(NULL),
- iProcessComplete(EFalse), iProcessIndex( 0 ), iDataPos( 0 ),
- iDataLeft( EFalse ), iBURModeNormal( ETrue ),
- iRestoreMode( EFalse ), iFs( aFs )
+CSConSBEClient::CSConSBEClient( const TInt /*aMaxObjectSize*/, RFs& aFs ) :
+ CActive( EPriorityStandard ), iBURModeNormal( ETrue ), iFs( aFs )
{
- iMaxObjectSize = aMaxObjectSize;
+
}
// -----------------------------------------------------------------------------
@@ -89,6 +87,8 @@
delete iSBEClient;
iSBEClient = NULL;
}
+
+ delete iDataBuffer;
TRACE_FUNC_EXIT;
}
@@ -263,67 +263,52 @@
LOGGER_WRITE( "CSConSBEClient::RunL() : ESetBURMode" );
TRAP( err, ProcessSetBURModeL() );
LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessSetBURModeL() : returned %d", err );
- HandleSBEErrorL( err );
- User::RequestComplete( iCallerStatus, err );
break;
case EListPublicFiles :
LOGGER_WRITE( "CSConSBEClient::RunL() : EListPublicFiles" );
TRAP( err, ProcessListPublicFilesL() );
LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListPublicFilesL() : returned %d", err );
- HandleSBEErrorL( err );
- User::RequestComplete( iCallerStatus, err );
break;
case EListDataOwners :
LOGGER_WRITE( "CSConSBEClient::RunL() : EListDataOwners" );
TRAP( err, ProcessListDataOwnersL() );
LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListDataOwnersL() : returned %d", err );
- HandleSBEErrorL( err );
- User::RequestComplete( iCallerStatus, err );
break;
case EGetDataSize :
LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataSize" );
TRAP( err, ProcessGetDataSizeL() );
LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataSizeL() : returned %d", err );
- HandleSBEErrorL( err );
- User::RequestComplete( iCallerStatus, err );
break;
case ERequestData :
LOGGER_WRITE( "CSConSBEClient::RunL() : ERequestData" );
TRAP( err, ret = ProcessRequestDataL() );
LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessRequestDataL() : returned %d", err );
- HandleSBEErrorL( err );
-
- if( err == KErrNone )
- {
- err = ret;
- }
-
- User::RequestComplete( iCallerStatus, err );
break;
case EGetDataOwnerStatus :
LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataOwnerStatus" );
TRAP( err, ProcessGetDataOwnerStatusL() );
LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataOwnerStatusL() : returned %d", err );
- HandleSBEErrorL( err );
- User::RequestComplete( iCallerStatus, err );
break;
case ESupplyData :
LOGGER_WRITE( "CSConSBEClient::RunL() : ESupplyData" );
TRAP( err, ret = ProcessSupplyDataL() );
LOGGER_WRITE_1( "CSConSBEClient::RunL() : SupplyDataL() : returned %d", err );
- HandleSBEErrorL( err );
-
- if( err == KErrNone )
- {
- err = ret;
- }
-
- User::RequestComplete( iCallerStatus, err );
break;
default :
+ err = KErrNotSupported;
LOGGER_WRITE( "CSConSBEClient::RunL() : ERROR! Unknown!" );
break;
}
+
+ if ( err )
+ {
+ HandleSBEErrorL( err );
+ }
+ else
+ {
+ err = ret;
+ }
+ User::RequestComplete( iCallerStatus, err );
TRACE_FUNC_EXIT;
}
@@ -338,6 +323,7 @@
TRACE_FUNC_ENTRY;
iAllSnapshotsSuppliedCalled = EFalse;
+ iLastChunk = EFalse;
TDriveList driveList = iCurrentTask->iBURModeParams->iDriveList;
@@ -368,6 +354,21 @@
break;
}
+ if ( partialType == EBURBackupFull || partialType == ESConBurBackupPartial )
+ {
+ // initialize buffer
+ if ( !iDataBuffer )
+ iDataBuffer = CBufFlat::NewL( KDataBufExpandSize );
+ else
+ iDataBuffer->Reset();
+ iDataBufferSize=0;
+ }
+ else
+ {
+ delete iDataBuffer;
+ iDataBuffer = 0;
+ }
+
TBackupIncType incType = ENoBackup;
switch( iCurrentTask->iBURModeParams->iIncType )
@@ -521,6 +522,7 @@
{
LOGGER_WRITE_2("handling do: %d, count: %d", i, dataOwners.Count());
CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();
+ CleanupStack::PushL( dataOwner );
// default values
TSecureId sid( 0 );
includeToList = ETrue;
@@ -704,24 +706,27 @@
if( includeToList )
{
LOGGER_WRITE_1( "Appending to list, uid: 0x%08x", dataOwner->iUid.iUid );
- iCurrentTask->iListDataOwnersParams->iDataOwners.Append( dataOwner );
+ iCurrentTask->iListDataOwnersParams->iDataOwners.AppendL( dataOwner );
+ CleanupStack::Pop( dataOwner );
}
if( sid )
{
LOGGER_WRITE_1( "Appending package sid to list, sid: 0x%08x", sid.iId );
CSConDataOwner* packageDataOwner = dataOwner->CopyL();
+ CleanupStack::PushL( packageDataOwner );
//Clear package name
packageDataOwner->iPackageName = KNullDesC();
//Add sid
packageDataOwner->iUid.iUid = sid.iId;
- iCurrentTask->iListDataOwnersParams->iDataOwners.Append( packageDataOwner );
+ iCurrentTask->iListDataOwnersParams->iDataOwners.AppendL( packageDataOwner );
+ CleanupStack::Pop( packageDataOwner );
}
if( !includeToList )
{
//Not included to list => delete memory allocation
- delete dataOwner;
+ CleanupStack::PopAndDestroy( dataOwner );
}
}
@@ -838,11 +843,6 @@
{
TRACE_FUNC_ENTRY;
TInt ret( KErrNone );
-
- if( iMaxObjectSize <= 1 )
- {
- User::Leave( KErrGeneral );
- }
TBool packageData = EFalse;
TTransferDataType transferDataType( ERegistrationData );
@@ -917,95 +917,42 @@
sid = iCurrentTask->iRequestDataParams->iDataOwner->iUid;
LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() sid: 0x%08x", sid.iId);
}
-
- CSBPackageTransferType* ptt( NULL );
- CSBSIDTransferType* stt( NULL );
- CSBJavaTransferType* jtt( NULL );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
- Begin - Data left: %d", iDataLeft );
+
LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
Begin - Package data: %d", packageData );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
- Begin - iDataPos: %d", iDataPos );
+
+ LOGGER_WRITE_1("iLastChunk: %d", (TInt) iLastChunk );
+ LOGGER_WRITE_1("iDataBufferSize: %d", iDataBufferSize );
- //Are there old data left to be transfered?
- if( !iDataLeft )
+ // if was't last chunk and there are free space left on our packet
+ if( !iLastChunk && iDataBufferSize < KMaxObjectSize )
{
//No data left, request more from the server
if( packageData && !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
{
- ptt = CSBPackageTransferType::NewL( uid, driveNumber,
- packageDataType );
+ CSBPackageTransferType* ptt = CSBPackageTransferType::NewL(
+ uid, driveNumber, packageDataType );
CleanupStack::PushL( ptt );
- LOGGER_WRITE( "iSBEClient->RequestDataL( ptt ) : start" );
- TRequestStatus status;
- iSBEClient->RequestDataL( *ptt, status );
- User::WaitForRequest( status );
- LOGGER_WRITE( "iSBEClint->RequestDataL( ptt ) : stop" );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : status.Int() %d", status.Int() );
- User::LeaveIfError( status.Int() );
-
- //Get the data and store the handle
- CSBGenericTransferType* gtt = NULL;
- LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : start" );
- iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iLastChunk ) );
- LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : stop" );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Received data size %d", iDataPtr.Length() );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Received from DO 0x%08x", uid );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Is last chunk %d", iLastChunk );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Transfertype %d", iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType );
-
- if( gtt )
- {
- delete gtt;
- }
-
+ RequestDataL( *ptt );
+
CleanupStack::PopAndDestroy( ptt );
}
else if( !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
{
- stt = CSBSIDTransferType::NewL( sid, driveNumber, transferDataType );
+ CSBSIDTransferType* stt = CSBSIDTransferType::NewL(
+ sid, driveNumber, transferDataType );
CleanupStack::PushL( stt );
- LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : start" );
- TRequestStatus status;
- iSBEClient->RequestDataL( *stt, status );
- User::WaitForRequest( status );
- LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : stop" );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- status.Int() %d", status.Int() );
- User::LeaveIfError( status.Int() );
-
- //Get the data and store the handle
- CSBGenericTransferType* gtt = NULL;
- LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : start" );
- iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iLastChunk ) );
- LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : stop" );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Received data size %d", iDataPtr.Length() );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Is last chunk %d", iLastChunk );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Transfertype %d",
- iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType );
-
- if( gtt )
- {
- delete gtt;
- }
-
+ RequestDataL( *stt );
+
CleanupStack::PopAndDestroy( stt );
}
else
{
TPtr javaHashPtr = iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash->Des();
-
+ CSBJavaTransferType* jtt( NULL );
//When ESystemData is requested, request EJavaMIDlet
if( packageDataType == ESystemData )
{
@@ -1020,52 +967,25 @@
if( packageDataType == ESystemData || transferDataType == EPassiveBaseData )
{
CleanupStack::PushL( jtt );
- LOGGER_WRITE( "iSBEClient->RequestDataL( jtt ) : start" );
- TRequestStatus status;
- iSBEClient->RequestDataL( *jtt, status );
- User::WaitForRequest( status );
- LOGGER_WRITE( "iSBEClient->RequestDataL( jtt ) : stop" );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- status.Int() %d", status.Int() );
- User::LeaveIfError( status.Int() );
-
- //Get the data and store the handle
- CSBGenericTransferType* gtt = NULL;
- LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : start" );
- iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iLastChunk ) );
- LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ): stop" );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Received data size %d", iDataPtr.Length() );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Is last chunk %d", iLastChunk );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
- Transfertype %d",
- iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType );
-
- if( gtt )
- {
- delete gtt;
- }
-
+ RequestDataL( *jtt );
+
CleanupStack::PopAndDestroy( jtt );
}
else
{
//No data
- iDataPtr.Set( KNullDesC8 );
+ iDataBuffer->Reset();
+ iDataBufferSize = 0;
iLastChunk = ETrue;
}
}
- }
+ }
+
+ LOGGER_WRITE_1("readed iLastChunk: %d", (TInt) iLastChunk );
+ LOGGER_WRITE_1("readed iDataBufferSize: %d", iDataBufferSize );
- TInt dataBufLength = iDataPtr.Length();
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
- Data received: %d", dataBufLength );
- TInt maxLength = iMaxObjectSize - 1024;
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
- Max length: %d", maxLength );
if( iCurrentTask->iRequestDataParams->iBackupData )
{
@@ -1073,57 +993,71 @@
iCurrentTask->iRequestDataParams->iBackupData = NULL;
}
+ TInt dataToRead = KMaxObjectSize;
+ if ( dataToRead > iDataBufferSize )
+ dataToRead = iDataBufferSize;
+
//Initialize the task data buffer
- iCurrentTask->iRequestDataParams->iBackupData = HBufC8::NewL( maxLength );
+ iCurrentTask->iRequestDataParams->iBackupData = HBufC8::NewL( dataToRead );
//Get descriptor task's buffer
TPtr8 backupDataPtr = iCurrentTask->iRequestDataParams->iBackupData->Des();
- TInt copyPos = 0;
- //Copy data to task buffer
- for( ; iDataPos < dataBufLength && copyPos < maxLength;
- iDataPos++ )
+ iDataBuffer->Read(0, backupDataPtr, dataToRead );
+ iDataBuffer->Delete(0, dataToRead);
+ iDataBufferSize -= dataToRead;
+
+ if ( !iLastChunk || iDataBufferSize>0 )
{
- backupDataPtr.Append( iDataPtr[iDataPos] );
- copyPos++;
- }
-
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
- End - copyPos: %d", copyPos );
- LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
- End - iDataPos: %d", iDataPos );
-
- //Are there more data left in the buffer
- if( iDataPos < dataBufLength )
- {
- LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : There is more data in buffer" );
- iDataLeft = ETrue;
+ LOGGER_WRITE( "CSConSBEClient::ProcessRequestDataL() : There are more data available" );
iCurrentTask->iRequestDataParams->iMoreData = ETrue;
//Another task is needed to transfer the data to the client
ret = KErrCompletion;
}
else
{
- //Check if the backup server has more data from the dataowner
- if( !iLastChunk )
- {
- iCurrentTask->iRequestDataParams->iMoreData = ETrue;
- //Another task is needed to transfer the data to the client
- ret = KErrCompletion;
- LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : There are more data available from SBE" );
- }
- else
- {
- iCurrentTask->iRequestDataParams->iMoreData = EFalse;
- }
-
- iDataPos = 0;
- iDataLeft = EFalse;
+ LOGGER_WRITE( "CSConSBEClient::ProcessRequestDataL() : All data readed" );
+ iDataBuffer->Reset();
+ iDataBufferSize = 0;
+ // task will be completed, initialize iLastChunk value for next operation
+ iLastChunk = EFalse;
}
+
LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : returned %d", ret );
return ret;
}
+
+void CSConSBEClient::RequestDataL( CSBGenericTransferType& aGenericTransferType )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( !iDataBuffer )
+ User::Leave( KErrArgument );
+
+ do
+ {
+ LOGGER_WRITE( "iSBEClient->RequestDataL() : start" );
+ TRequestStatus status;
+ iSBEClient->RequestDataL( aGenericTransferType, status );
+ User::WaitForRequest( status );
+ LOGGER_WRITE_1( "iSBEClient->RequestDataL() : status.Int() %d", status.Int() );
+ User::LeaveIfError( status.Int() );
+
+ //Get the data and store the handle
+ CSBGenericTransferType* gtt = NULL;
+ const TPtrC8& dataPtr = iSBEClient->TransferDataInfoL( gtt, iLastChunk );
+ LOGGER_WRITE_1("data size: %d", dataPtr.Length());
+ delete gtt;
+ iDataBuffer->ExpandL( iDataBufferSize, dataPtr.Length() );
+ iDataBuffer->Write(iDataBufferSize, dataPtr);
+ iDataBufferSize += dataPtr.Length();
+ LOGGER_WRITE_1("total buffer size: %d", iDataBufferSize);
+ }
+ // Continue if there are more data, and our packet is not full
+ while ( !iLastChunk && iDataBufferSize < KMaxObjectSize );
+
+ TRACE_FUNC_EXIT;
+ }
// -----------------------------------------------------------------------------
// CSConSBEClient::ProcessGetDataOwnerStatusL()
@@ -1556,6 +1490,15 @@
iSBEClient = NULL;
iSBEClient = CSBEClient::NewL();
}
+ else if ( aErr ) // error
+ {
+ if ( iDataBuffer )
+ {
+ iDataBuffer->Reset();
+ iDataBufferSize = 0;
+ }
+ iLastChunk = EFalse;
+ }
TRACE_FUNC_EXIT;
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/services/pcd/src/sconsynchandler.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -0,0 +1,1460 @@
+/*
+* Copyright (c) 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: CSconSyncHandler implementation
+*
+*/
+
+
+#include "sconsynchandler.h"
+#include <f32file.h>
+#include <S32MEM.H>
+#include <UTF.H>
+#include <mmf/common/mmfcontrollerpluginresolver.h>
+#include <bautils.h>
+#include <nsmlconstants.h>
+#include <centralrepository.h>
+
+#include "debug.h"
+
+// versions up to 5 must be backward compatible
+const TUint16 KFormatVersionNumber ( 1 );
+
+_LIT8(KCommandListStores, "SYNC: ListStores");
+_LIT8(KCommandOpenStore, "SYNC: OpenStore: ");
+_LIT8(KCommandCloseStore, "SYNC: CloseStore");
+_LIT8(KCommandListChanges, "SYNC: ListChanges");
+_LIT8(KCommandResetChangeInfo, "SYNC: ResetChangeInfo");
+_LIT8(KCommandCommitChanges, "SYNC: CommitChanges: ");
+_LIT8(KCommandReadItems, "SYNC: ReadItems: ");
+_LIT8(KCommandGetParents, "SYNC: GetParents: ");
+_LIT8(KCommandCreateItems, "SYNC: CreateItems");
+_LIT8(KCommandGetCreateItemsResponse, "SYNC: GetCreateItemsResponse");
+_LIT8(KCommandGetCreateItems, "SYNC: GetCreateItems: ");
+_LIT8(KCommandReplaceItems, "SYNC: ReplaceItems");
+_LIT8(KCommandGetReplaceItemsResponse, "SYNC: GetReplaceItemsResponse");
+_LIT8(KCommandGetReplaceItems, "SYNC: GetReplaceItems: ");
+_LIT8(KCommandMoveItems, "SYNC: MoveItems");
+_LIT8(KCommandDeleteItems, "SYNC: DeleteItems: ");
+_LIT8(KCommandSoftDeleteItems, "SYNC: SoftDeleteItems: ");
+_LIT8(KCommandDeleteAllItems, "SYNC: DeleteAllItems");
+_LIT8(KCommandDeleteAllItemsStatus, "SYNC: GetDeleteAllItemsStatus");
+_LIT8(KCommandGetStoreFormat, "SYNC: GetStoreFormat");
+_LIT8(KCommandSetRemoteStoreFormat, "SYNC: SetRemoteStoreFormat");
+_LIT8(KCommandGetRestOfData, "SYNC: GetRestOfData");
+_LIT8(KCommandCancel, "SYNC: Cancel");
+
+
+_LIT(KRemoteFormatStore, "remoteformatstore_0x%08x.dat");
+_LIT(KDataFileExtension, ".tmp");
+
+const TInt KTimeStampLength = 16;
+_LIT8(KTimeStampFormat, "%02d%02d%04dT%02d%02d%02dZ");
+
+const TInt KDefaultExpandSize = 1024;
+
+// Calendar sync specific constants
+const TInt KCalendarDsUid = 0x101F6DDE;
+
+CSconSyncHandler::~CSconSyncHandler()
+ {
+ TRACE_FUNC_ENTRY;
+ Cancel();
+ iSyncSession.Close();
+ delete iResponseData;
+ iFileStream.Close();
+ iCreatedItems.Close();
+ iReplacedItems.Close();
+ iItemsToRead.Close();
+ iFs.Delete( iFileInProgress );
+ ClearCalendarCenrepL();
+ TRACE_FUNC_EXIT;
+ }
+
+CSconSyncHandler::CSconSyncHandler( RFs& aFs )
+ : CActive( EPriorityStandard ), iFs(aFs), iCreatedItemUidPckg(iCreatedItemUid)
+ {
+ CActiveScheduler::Add( this );
+ }
+
+CSconSyncHandler* CSconSyncHandler::NewL( RFs& aFs)
+ {
+ TRACE_FUNC_ENTRY;
+ CSconSyncHandler* self = new (ELeave) CSconSyncHandler(aFs);
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ TRACE_FUNC_EXIT;
+ return self;
+ }
+
+void CSconSyncHandler::ConstructL()
+ {
+ TInt err = iFs.CreatePrivatePath( EDriveC );
+ LOGGER_WRITE_1("CreatePrivatePath err: %d", err);
+ iFs.SetSessionToPrivate( EDriveC );
+ }
+
+void CSconSyncHandler::HandleGetSyncRequestL( const TDesC8& aRequest, RWriteStream& aResult, TInt aMaxObjectSize )
+ {
+ TRACE_FUNC_ENTRY;
+ iMaxObjectSize = aMaxObjectSize;
+ iBytesWrited = 0;
+ LOGGER_WRITE_1("iMaxObjectSize: %d", iMaxObjectSize);
+ if ( !iConnected )
+ {
+ LOGGER_WRITE("Try to connect")
+ User::LeaveIfError( iSyncSession.Connect() );
+ iConnected = ETrue;
+ }
+
+ if ( aRequest.Compare( KCommandListStores ) == KErrNone )
+ {
+ ListStoresL( aResult );
+ }
+ else if ( aRequest.Find( KCommandOpenStore ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandOpenStore().Length() );
+ OpenStoreL( params, aResult );
+ }
+ else if ( aRequest.Find( KCommandCloseStore ) == 0 )
+ {
+ CloseStoreL( aResult );
+ }
+ else if ( aRequest.Find( KCommandListChanges ) == 0 )
+ {
+ ListChangesL( aResult );
+ }
+ else if ( aRequest.Find( KCommandResetChangeInfo ) == 0 )
+ {
+ ResetChangeInfoL( aResult );
+ }
+ else if ( aRequest.Find( KCommandCommitChanges ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandCommitChanges().Length() );
+ CommitChangesL( params, aResult );
+ }
+ else if ( aRequest.Find( KCommandReadItems ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandReadItems().Length() );
+ ReadItemsL( params, aResult );
+ }
+ else if ( aRequest.Find( KCommandGetParents ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandGetParents().Length() );
+ GetParentsL( params, aResult );
+ }
+ else if ( aRequest.Find( KCommandGetRestOfData ) == 0 )
+ {
+ // Get rest of data
+ ReadNextDataBlockL( aResult );
+ }
+ else if ( aRequest.Find( KCommandGetCreateItemsResponse ) == 0 )
+ {
+ GetCreateItemsResponseL( KNullDesC8(), aResult );
+ }
+ else if ( aRequest.Find( KCommandGetCreateItems ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandGetCreateItems().Length() );
+ GetCreateItemsResponseL( params, aResult );
+ }
+ else if ( aRequest.Find( KCommandGetReplaceItemsResponse ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandGetReplaceItemsResponse().Length() );
+ GetReplaceItemsResponseL( KNullDesC8(), aResult );
+ }
+ else if ( aRequest.Find( KCommandGetReplaceItems ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandGetReplaceItems().Length() );
+ GetReplaceItemsResponseL( params, aResult );
+ }
+ else if ( aRequest.Find( KCommandMoveItems ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandMoveItems().Length() );
+ MoveItemsL( params, aResult );
+ }
+ else if ( aRequest.Find( KCommandDeleteItems ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandDeleteItems().Length() );
+ DeleteItemsL( params, aResult );
+ }
+ else if ( aRequest.Find( KCommandSoftDeleteItems ) == 0 )
+ {
+ TPtrC8 params = aRequest.Mid( KCommandSoftDeleteItems().Length() );
+ SoftDeleteItemsL( params, aResult );
+ }
+ else if ( aRequest.Find( KCommandDeleteAllItems ) == 0 )
+ {
+ DeleteAllItemsL( aResult );
+ }
+ else if ( aRequest.Find( KCommandDeleteAllItemsStatus ) == 0 )
+ {
+ GetDeleteAllItemsStatusL( aResult );
+ }
+ else if ( aRequest.Find( KCommandGetStoreFormat ) == 0 )
+ {
+ GetStoreFormatL( aResult );
+ }
+ else if ( aRequest.Find( KCommandCancel ) == 0 )
+ {
+ CancelOperationsL( aResult );
+ }
+ else
+ {
+ LOGGER_WRITE("Unknown command");
+ User::Leave( KErrNotSupported );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+
+void CSconSyncHandler::HandlePutSyncRequestL( const TDesC8& aRequest, RReadStream& aData )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( !iConnected )
+ {
+ LOGGER_WRITE("Try to connect")
+ User::LeaveIfError( iSyncSession.Connect() );
+ iConnected = ETrue;
+ }
+ if ( aRequest.Find( KCommandCreateItems ) == KErrNone )
+ {
+ CreateItemsL( aData );
+ }
+ else if ( aRequest.Find( KCommandReplaceItems ) == 0 )
+ {
+ ReplaceItemsL( aData );
+ }
+ else if ( aRequest.Find( KCommandSetRemoteStoreFormat ) == 0 )
+ {
+ SetRemoteStoreFormatL( aData );
+ }
+ else
+ {
+ LOGGER_WRITE("Unknown command");
+ User::Leave( KErrNotSupported );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::ListStoresL( RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ RSconDataProviderInfoArray infoArray(5);
+ CleanupResetAndDestroyPushL( infoArray );
+ iSyncSession.ListAllImplementationsL( infoArray );
+ LOGGER_WRITE_1("infoArray.Count(): %d", infoArray.Count());
+ aResult.WriteInt32L( infoArray.Count() );
+ for (TInt i=0; i<infoArray.Count(); i++ )
+ {
+ CSconDataproviderInfo& info = (*infoArray[i]);
+ info.ExternalizeL( aResult );
+ }
+ CleanupStack::PopAndDestroy( &infoArray );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::OpenStoreL( const TDesC8& aParams, RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE8_1("Params:'%S'", &aParams);
+
+ const TUint8* ptr = aParams.Ptr();
+ LOGGER_WRITE_1("Params size: %d", aParams.Size())
+ RMemReadStream stream( ptr , aParams.Size() );
+ CleanupClosePushL( stream );
+
+ TInt providerId = stream.ReadInt32L();
+ LOGGER_WRITE_1("Provider Id: 0x%08x", providerId);
+ TInt contextId = stream.ReadInt32L();
+ LOGGER_WRITE_1("Context Id: 0x%08x", contextId);
+
+ // read utf8 formatted text
+ TInt len = stream.ReadUint16L();
+
+ LOGGER_WRITE_1("storeName length: %d", len);
+ HBufC8* buf8 = HBufC8::NewLC( len );
+ TPtr8 bufPtr8 = buf8->Des();
+ stream.ReadL( bufPtr8, len );
+
+ LOGGER_WRITE8_1("storeName8: %S", &bufPtr8);
+
+ // and convert it to unicode
+ HBufC* storeName = CnvUtfConverter::ConvertToUnicodeFromUtf8L( bufPtr8 );
+ CleanupStack::PopAndDestroy( buf8 );
+ CleanupStack::PushL( storeName );
+
+ TPtr storeNamePtr = storeName->Des();
+ LOGGER_WRITE_1("storeName: %S", &storeNamePtr);
+
+ if ( providerId == KCalendarDsUid && aParams.Size() >
+ sizeof(TInt32) // providerId
+ + sizeof(TInt32) // contextId
+ + sizeof(TUint16)// storeName len
+ + len ) // storeName
+ {
+ TInt profileId = stream.ReadInt32L();
+ len = stream.ReadUint16L();
+ HBufC8* buffer = HBufC8::NewLC( len );
+ TPtr8 bufferPtr8 = buffer->Des();
+ stream.ReadL( bufferPtr8, len );
+ HBufC* serverId = CnvUtfConverter::ConvertToUnicodeFromUtf8L( bufferPtr8 );
+ CleanupStack::PopAndDestroy( buffer );
+ CleanupStack::PushL( serverId );
+ SetCalendarCenrepL( profileId, serverId->Des() );
+ CleanupStack::PopAndDestroy(serverId);
+ }
+
+ aResult.WriteUint16L( KFormatVersionNumber );
+ TRAPD( err, iSyncSession.OpenDataStoreL( providerId, storeName->Des(), contextId));
+ if ( err == KErrServerTerminated )
+ {
+ // server terminated, try to reconnect
+ iConnected = EFalse;
+ LOGGER_WRITE("Try to re-connect");
+ err = iSyncSession.Connect();
+ LOGGER_WRITE_1("iSyncSession.Connect() err: %d", err);
+ if ( !err )
+ {
+ iConnected = ETrue;
+ TRAP( err, iSyncSession.OpenDataStoreL( providerId, storeName->Des(), contextId));
+ }
+ }
+
+ CleanupStack::PopAndDestroy( storeName );
+ CleanupStack::PopAndDestroy( &stream );
+
+ aResult.WriteInt32L( err );
+
+ if ( err )
+ {
+ LOGGER_WRITE_1("Error: %d", err);
+ LOGGER_WRITE("iSyncSession.CloseDataStore()");
+ iSyncSession.CloseDataStore();
+ ClearCalendarCenrepL();
+ return;
+ }
+ iCurrentDataProviderUid = providerId;
+ iCurrentContextUid = contextId;
+
+
+ // Now the store is opened
+ TRAP(err, LoadRemoteStoreFormatL( contextId, providerId ));
+ if ( err )
+ {
+ aResult.WriteUint8L( 1 ); // Remote store format needed
+ }
+ else
+ {
+ aResult.WriteUint8L( 0 ); // Remote store format not needed
+ }
+
+ // return last sync timestamp, if has synced before.
+ TBool hasHistory = iSyncSession.HasSyncHistoryL();
+ TUint8 historyFlag(0);
+ if ( hasHistory )
+ {
+ historyFlag = 1;
+ }
+ aResult.WriteUint8L( historyFlag );
+
+ if ( hasHistory )
+ {
+ TDateTime timeStamp;
+ TInt err(KErrNone);
+ TRAP(err, iSyncSession.GetSyncTimeStampL( providerId, contextId, timeStamp));
+ LOGGER_WRITE_1("GetSyncTimeStampL err: %d", err);
+
+ TBuf8<KTimeStampLength> timeStampBuf;
+
+ timeStampBuf.Format( KTimeStampFormat,
+ timeStamp.Day()+1,timeStamp.Month()+1, timeStamp.Year(),
+ timeStamp.Hour(), timeStamp.Minute(), timeStamp.Second() );
+ LOGGER_WRITE8_1("timeStamp: %S", &timeStampBuf);
+ aResult.WriteL( timeStampBuf );
+ }
+
+
+ // for testin purposes only
+ /*
+ if (!remoteStoreSetted)
+ {
+ RStringPool pool;
+ pool.OpenL();
+ CleanupClosePushL( pool );
+ CSmlDataStoreFormat* storeFormat(NULL);
+ TRAPD( err, storeFormat = iSyncSession.StoreFormatL( pool ) );
+ CleanupStack::PushL( storeFormat );
+
+ iSyncSession.SetRemoteStoreFormatL( *storeFormat );
+ SaveRemoteStoreFormatL( *storeFormat, contextId, providerId );
+
+ CleanupStack::PopAndDestroy( storeFormat );
+ CleanupStack::PopAndDestroy( &pool );
+ }
+ */
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::LoadRemoteStoreFormatL( TInt aContextId, TInt aProviderId )
+ {
+ TRACE_FUNC_ENTRY;
+ TFileName remoteFormatStore;
+ iFs.SetSessionToPrivate( EDriveC );
+ remoteFormatStore.Format( KRemoteFormatStore, aContextId );
+
+ CDictionaryFileStore* dictionaryStore =
+ CDictionaryFileStore::OpenLC(iFs, remoteFormatStore, TUid::Uid(0x0001));
+ TBool present = dictionaryStore->IsPresentL( TUid::Uid(aProviderId) );
+ if ( !present )
+ {
+ LOGGER_WRITE("Remote store was not saved");
+ User::Leave( KErrNotFound );
+ }
+ else
+ {
+ RDictionaryReadStream stream;
+ stream.OpenLC( *dictionaryStore, TUid::Uid(aProviderId) );
+ RStringPool stringPool;
+ stringPool.OpenL();
+ CleanupClosePushL( stringPool );
+ CSmlDataStoreFormat* storeFormat = CSmlDataStoreFormat::NewLC(stringPool, stream);
+ iSyncSession.SetRemoteStoreFormatL( *storeFormat );
+ CleanupStack::PopAndDestroy( storeFormat );
+ CleanupStack::PopAndDestroy( &stringPool );
+ CleanupStack::PopAndDestroy(); //OpenLC
+ }
+ CleanupStack::PopAndDestroy( dictionaryStore );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::SaveRemoteStoreFormatL( CSmlDataStoreFormat& aStoreFormat, TInt aContextId, TInt aProviderId)
+ {
+ TRACE_FUNC_ENTRY;
+ iFs.SetSessionToPrivate( EDriveC );
+ TFileName remoteFormatStore;
+ remoteFormatStore.Format( KRemoteFormatStore, aContextId );
+ CDictionaryFileStore* dictionaryStore =
+ CDictionaryFileStore::OpenLC(iFs, remoteFormatStore, TUid::Uid(0x0001));
+
+ RDictionaryWriteStream stream;
+ stream.AssignLC( *dictionaryStore, TUid::Uid(aProviderId) );
+
+ aStoreFormat.ExternalizeL( stream );
+ stream.CommitL();
+ CleanupStack::PopAndDestroy(); //AssignLC
+ dictionaryStore->CommitL();
+
+ CleanupStack::PopAndDestroy( dictionaryStore );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::CloseStoreL( RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ iSyncSession.CloseDataStore();
+ ClearCalendarCenrepL();
+
+ // Get last used timestamp if provider was open
+ if ( iCurrentDataProviderUid != 0 )
+ {
+ TDateTime timeStamp;
+ iSyncSession.GetSyncTimeStampL(iCurrentDataProviderUid, iCurrentContextUid, timeStamp );
+
+ iCurrentDataProviderUid = 0;
+ iCurrentContextUid = 0;
+
+ const TInt KTimeStampLength = 16;
+ TBuf8<KTimeStampLength> timeStampBuf;
+
+
+ timeStampBuf.Format( KTimeStampFormat,
+ timeStamp.Day()+1,timeStamp.Month()+1, timeStamp.Year(),
+ timeStamp.Hour(), timeStamp.Minute(), timeStamp.Second() );
+ aResult.WriteL( timeStampBuf );
+ }
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::ListChangesL( RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ RArray<TSmlDbItemUid> items;
+ CleanupClosePushL( items );
+
+ iSyncSession.AddedItemsL( items );
+ LOGGER_WRITE_1("Added items count: %d", items.Count());
+ aResult.WriteInt32L( items.Count() );
+ for (TInt i=0; i<items.Count(); i++ )
+ {
+ aResult.WriteInt32L( items[i] );
+ }
+
+ items.Reset();
+ iSyncSession.ModifiedItemsL( items );
+ LOGGER_WRITE_1("Modified items count: %d", items.Count());
+ aResult.WriteInt32L( items.Count() );
+ for (TInt i=0; i<items.Count(); i++ )
+ {
+ aResult.WriteInt32L( items[i] );
+ }
+
+ items.Reset();
+ iSyncSession.MovedItemsL( items );
+ LOGGER_WRITE_1("Moved items count: %d", items.Count());
+ aResult.WriteInt32L( items.Count() );
+ for (TInt i=0; i<items.Count(); i++ )
+ {
+ aResult.WriteInt32L( items[i] );
+ }
+
+ items.Reset();
+ iSyncSession.DeletedItemsL( items );
+ LOGGER_WRITE_1("Deleted items count: %d", items.Count());
+ aResult.WriteInt32L( items.Count() );
+ for (TInt i=0; i<items.Count(); i++ )
+ {
+ aResult.WriteInt32L( items[i] );
+ }
+
+ items.Reset();
+ iSyncSession.SoftDeletedItemsL( items );
+ LOGGER_WRITE_1("SoftDeleted items count: %d", items.Count());
+ aResult.WriteInt32L( items.Count() );
+ for (TInt i=0; i<items.Count(); i++ )
+ {
+ aResult.WriteInt32L( items[i] );
+ }
+ CleanupStack::PopAndDestroy( &items );
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::ResetChangeInfoL( RWriteStream& /*aResult*/ )
+ {
+ TRACE_FUNC_ENTRY;
+ iSyncSession.ResetChangeInfoL();
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::CommitChangesL( const TDesC8& aParams, RWriteStream& /*aResult*/ )
+ {
+ TRACE_FUNC_ENTRY;
+ const TUint8* ptr = aParams.Ptr();
+ RMemReadStream stream( ptr , aParams.Size() );
+ CleanupClosePushL( stream );
+
+ TInt itemCount = stream.ReadInt32L();
+ RArray<TSmlDbItemUid> items;
+ CleanupClosePushL( items );
+ for ( TInt i=0; i<itemCount; i++ )
+ {
+ items.AppendL( stream.ReadInt32L() );
+ }
+
+ if ( items.Count() > 0 )
+ {
+ iSyncSession.CommitChangeInfoL( items );
+ }
+
+ CleanupStack::PopAndDestroy( &items );
+ CleanupStack::PopAndDestroy( &stream );
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::ReadItemsL( const TDesC8& aParams, RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ iItemsToRead.Reset();
+ LOGGER_WRITE_1("aParams length: %d", aParams.Length());
+
+ const TUint8* ptr = aParams.Ptr();
+ RMemReadStream stream( ptr , aParams.Size() );
+ CleanupClosePushL( stream );
+
+ // Read item uids from parameter
+ TInt itemCount = stream.ReadInt32L();
+ LOGGER_WRITE_1("Item count: %d", itemCount);
+ for ( TInt i=0; i<itemCount; i++ )
+ {
+ iItemsToRead.AppendL( stream.ReadInt32L() );
+ LOGGER_WRITE_2("Item[%d] = %d", i, iItemsToRead[i] );
+ }
+ CleanupStack::PopAndDestroy( &stream );
+ LOGGER_WRITE( "Items readed ok" );
+
+ aResult.WriteInt32L( iItemsToRead.Count() );
+ iBytesWrited += sizeof(TInt32);
+
+ ReadNextDataBlockL( aResult );
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::GetParentsL( const TDesC8& aParams, RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ const TUint8* ptr = aParams.Ptr();
+ RMemReadStream stream( ptr , aParams.Size() );
+ CleanupClosePushL( stream );
+
+ // Read item uids from parameter
+ TInt itemCount = stream.ReadInt32L();
+ aResult.WriteInt32L( itemCount );
+ LOGGER_WRITE_1("Item count: %d", itemCount);
+ for ( TInt i=0; i<itemCount; i++ )
+ {
+ TSmlDbItemUid itemUid = stream.ReadInt32L();
+ TSmlDbItemUid parent(KErrNotFound);
+ aResult.WriteInt32L( itemUid );
+ TInt err = iSyncSession.GetParent( itemUid, parent);
+ LOGGER_WRITE_1("itemUid: %d", itemUid);
+ LOGGER_WRITE_1("err: %d", err);
+ aResult.WriteInt32L( err );
+ if ( err == KErrNone )
+ {
+ LOGGER_WRITE_1("parent: %d", parent);
+ aResult.WriteInt32L( parent );
+ }
+ }
+ CleanupStack::PopAndDestroy( &stream );
+ aResult.CommitL();
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::ReadNextDataBlockL( RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( (!iResponseData || iResponseData->Size() == 0 ) && iItemsToRead.Count() == 0 )
+ {
+ // no data
+ LOGGER_WRITE("no more data or items");
+ User::Leave(KErrEof);
+ }
+
+ if ( iResponseData )
+ {
+ // write data from tempbuffer to response buffer
+ TInt writeLength = iResponseData->Size();
+ if ( writeLength > iMaxObjectSize-iBytesWrited )
+ {
+ writeLength = iMaxObjectSize-iBytesWrited;
+ }
+ aResult.WriteL( iResponseData->Ptr(0), writeLength );
+ iBytesWrited += writeLength;
+
+ if ( iResponseData->Size() > writeLength )
+ {
+ iResponseData->Delete(0, writeLength);
+ }
+ else
+ {
+ iResponseData->Reset();
+ }
+ }
+ if ( iBytesWrited == iMaxObjectSize )
+ {
+ // responce buffer is full, return it.
+ LOGGER_WRITE("Stream is full, return it");
+ return;
+ }
+
+ TBool streamIsFull( EFalse );
+ // Read items from server
+ CBufFlat* dataBuffer = CBufFlat::NewL(KDefaultExpandSize);
+ CleanupStack::PushL( dataBuffer );
+ while ( iItemsToRead.Count() > 0 && !streamIsFull )
+ {
+ if ( iMaxObjectSize-iBytesWrited < sizeof(TUint32) )
+ {
+ streamIsFull = ETrue;
+ LOGGER_WRITE("Stream is full, don't read next item");
+ continue;
+ }
+ ReadItemL( iItemsToRead[0], *dataBuffer );
+ aResult.WriteUint32L( dataBuffer->Size() );
+ iBytesWrited += sizeof( TUint32 );
+
+ TInt writeLength = dataBuffer->Size();
+ if ( writeLength > iMaxObjectSize-iBytesWrited )
+ {
+ writeLength = iMaxObjectSize-iBytesWrited;
+ LOGGER_WRITE_1("Write only %d bytes", writeLength);
+ }
+ aResult.WriteL( dataBuffer->Ptr(0), writeLength );
+ iBytesWrited += writeLength;
+
+ if ( dataBuffer->Size() > writeLength )
+ {
+ // write rest to next data block
+ if ( !iResponseData )
+ {
+ iResponseData = CBufFlat::NewL(KDefaultExpandSize);
+ }
+ iResponseData->Reset();
+ LOGGER_WRITE_1("Save %d bytes for next request", dataBuffer->Size() - writeLength);
+ iResponseData->ResizeL( dataBuffer->Size() - writeLength );
+ iResponseData->Write(0, dataBuffer->Ptr( writeLength ));
+ streamIsFull = ETrue;
+ }
+
+ iItemsToRead.Remove(0);
+
+ if ( iBytesWrited == iMaxObjectSize )
+ {
+ // writestream is full
+ LOGGER_WRITE("Stream is full");
+ streamIsFull = ETrue;
+ }
+
+ }
+ aResult.CommitL();
+
+ CleanupStack::PopAndDestroy( dataBuffer );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::ReadItemL( TSmlDbItemUid aUid, CBufFlat& aItemData )
+ {
+ TRACE_FUNC_ENTRY;
+ aItemData.Reset();
+ CBufFlat* dataBuffer = CBufFlat::NewL(KDefaultExpandSize);
+ CleanupStack::PushL( dataBuffer );
+ TSmlDbItemUid parent(-1);
+ TBool fieldChange(EFalse);
+
+ TBuf8<256> mimeType;
+ TBuf8<100> mimeVer;
+ TRAPD( err, iSyncSession.OpenItemL( aUid, fieldChange,
+ parent, mimeType, mimeVer, *dataBuffer ));
+ if ( err )
+ {
+ LOGGER_WRITE_1("Could not read item %d", aUid);
+ // only item uid and errorcode will be writed
+ aItemData.ResizeL(
+ sizeof(TInt32) +
+ sizeof(TInt32));
+
+ }
+ else
+ {
+ // reserve memory for all fields
+ aItemData.ResizeL(
+ sizeof(TInt32) +
+ sizeof(TInt32) +
+ sizeof(TUint8) +
+ sizeof(TInt32) +
+ sizeof(TUint16) +
+ mimeType.Length() +
+ sizeof(TUint16) +
+ mimeVer.Length() +
+ sizeof(TInt32) +
+ dataBuffer->Size()
+ );
+ }
+
+ RBufWriteStream tempStream( aItemData );
+ CleanupClosePushL( tempStream );
+ tempStream.WriteInt32L( aUid );
+ tempStream.WriteInt32L( err );
+ if ( !err )
+ {
+ tempStream.WriteUint8L( fieldChange );
+ tempStream.WriteInt32L( parent );
+ tempStream.WriteUint16L( mimeType.Length() );
+ tempStream.WriteL( mimeType );
+ tempStream.WriteUint16L( mimeVer.Length() );
+ tempStream.WriteL( mimeVer );
+ tempStream.WriteInt32L( dataBuffer->Size() );
+ tempStream.WriteL( dataBuffer->Ptr(0), dataBuffer->Size() );
+ }
+ tempStream.CommitL();
+ CleanupStack::PopAndDestroy( &tempStream );
+ CleanupStack::PopAndDestroy( dataBuffer );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::CreateItemsL( RReadStream& aData )
+ {
+ TRACE_FUNC_ENTRY;
+ delete iResponseData;
+ iResponseData = NULL;
+ iResponseData = CBufFlat::NewL(KDefaultExpandSize);
+ RBufWriteStream responseStream( *iResponseData );
+ CleanupClosePushL( responseStream );
+ // Read item uids from parameter
+ TInt itemCount = aData.ReadInt32L();
+ LOGGER_WRITE_1("itemCount: %d", itemCount);
+ responseStream.WriteInt32L( itemCount );
+ for ( TInt i=0; i<itemCount; i++ )
+ {
+ LOGGER_WRITE("read from aData stream");
+ TInt tempUid = aData.ReadInt32L();
+
+ TSmlDbItemUid parent = aData.ReadInt32L();
+
+ TInt len = aData.ReadUint16L();
+ HBufC8* mimeTypeBuf = HBufC8::NewLC( len );
+ TPtr8 mimeTypePtr = mimeTypeBuf->Des();
+ aData.ReadL(mimeTypePtr, len);
+
+ len = aData.ReadUint16L();
+ HBufC8* mimeVerBuf = HBufC8::NewLC( len );
+ TPtr8 mimeVerPtr = mimeVerBuf->Des();
+ aData.ReadL(mimeVerPtr, len);
+
+ len = aData.ReadInt32L();
+ HBufC8* dataBuf = HBufC8::NewLC( len );
+ TPtr8 dataPtr = dataBuf->Des();
+ aData.ReadL( dataPtr, len );
+
+ TSmlDbItemUid newUid(-1);
+ LOGGER_WRITE("read from aData stream -readed ok");
+ TRAPD( err, iSyncSession.CreateItemL(newUid,
+ parent, mimeTypePtr,
+ mimeVerPtr, dataPtr));
+
+ CleanupStack::PopAndDestroy( dataBuf );
+ CleanupStack::PopAndDestroy( mimeVerBuf );
+ CleanupStack::PopAndDestroy( mimeTypeBuf );
+ LOGGER_WRITE("Write to responseStream");
+ responseStream.WriteInt32L( tempUid );
+ responseStream.WriteInt32L( err );
+ if ( !err )
+ {
+ responseStream.WriteInt32L( newUid );
+ }
+ LOGGER_WRITE("Write to responseStream -writed ok");
+ }
+
+ responseStream.CommitL();
+ CleanupStack::PopAndDestroy( &responseStream );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::GetCreateItemsResponseL( const TDesC8& aParams, RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( aParams.Length() > 0 )
+ {
+ LOGGER_WRITE_1("params length: %d", aParams.Length());
+
+ //LOGGER_WRITE8_1("aParams: %S", &aParams);
+ if ( iSyncStatus == EReady )
+ {
+ LOGGER_WRITE("Start creating items from file");
+ iCreatedItems.Reset();
+ const TUint8* ptr = aParams.Ptr();
+ RMemReadStream stream( ptr , aParams.Size() );
+ CleanupClosePushL( stream );
+ TInt filenameLength = stream.ReadInt32L();
+ LOGGER_WRITE_1("filename length: %d", filenameLength );
+ HBufC8* filenameBuf8 = HBufC8::NewLC( /*stream,*/ filenameLength ); // filename
+ TPtr8 filenamePtr = filenameBuf8->Des();
+ stream.ReadL( filenamePtr, filenameLength);
+ LOGGER_WRITE("filename ok");
+ TInt err = CnvUtfConverter::ConvertToUnicodeFromUtf8(iFileInProgress, filenamePtr );
+ LOGGER_WRITE_1("ConvertToUnicodeFromUtf8 err: %d", err);
+ User::LeaveIfError( err );
+ LOGGER_WRITE_1("iFileInProgress: %S", &iFileInProgress);
+
+ if ( iFileInProgress.RightTPtr(KDataFileExtension().Length()).CompareF(KDataFileExtension) != 0 )
+ {
+ iFileInProgress = KNullDesC();
+ LOGGER_WRITE("File extendion was not correct");
+ User::Leave( KErrAccessDenied );
+ }
+
+ CleanupStack::PopAndDestroy( filenameBuf8 );
+
+ LOGGER_WRITE("open file");
+ err = iFileStream.Open(iFs,iFileInProgress, EFileShareReadersOnly);
+ LOGGER_WRITE_1("iFileStream.Open err: %d", err);
+ User::LeaveIfError( err );
+
+ CleanupStack::PopAndDestroy( &stream );
+
+ iSyncStatus = ECreatingItemsFromFile;
+ iItemsLeftInStream = iFileStream.ReadInt32L();
+ LOGGER_WRITE_1("iItemsLeftInStream: %d", iItemsLeftInStream);
+ aResult.WriteInt32L( iItemsLeftInStream );
+ aResult.WriteInt32L( 0 ); // completed items since last sync
+ CreateNextItemOnStreamL();
+ iItemsLeftInStream--;
+ }
+ else if ( iSyncStatus == ECreatingItemsFromFile || iSyncStatus == EItemsCreated )
+ {
+ LOGGER_WRITE("Read status");
+ TInt temp = 0;
+ if ( iSyncStatus == ECreatingItemsFromFile )
+ {
+ // one item is on progress, add it to to "left" items.
+ temp = 1;
+ }
+ LOGGER_WRITE_1("left items: %d", iItemsLeftInStream + temp);
+ LOGGER_WRITE_1("completed items: %d", iCreatedItems.Count());
+ aResult.WriteInt32L( iItemsLeftInStream + temp ); // items in progress
+ aResult.WriteInt32L( iCreatedItems.Count() ); // completed items since last get
+
+ while ( iCreatedItems.Count() > 0 )
+ {
+ aResult.WriteInt32L( iCreatedItems[0].iTemporaryId );
+ aResult.WriteInt32L( iCreatedItems[0].iErrorCode );
+ if ( !iCreatedItems[0].iErrorCode )
+ {
+ aResult.WriteInt32L( iCreatedItems[0].iNewUid );
+ }
+ iCreatedItems.Remove(0);
+ }
+ if ( iSyncStatus == EItemsCreated )
+ {
+ // all done
+ iSyncStatus = EReady;
+ LOGGER_WRITE("iSyncStatus = EReady");
+ }
+ }
+ else
+ {
+ LOGGER_WRITE_1("Wrong sync status: %d", iSyncStatus);
+ User::Leave( KErrInUse );
+ }
+ }
+ else
+ {
+ LOGGER_WRITE("Read response");
+ if ( !iResponseData )
+ {
+ User::Leave( KErrNotReady );
+ }
+ aResult.WriteL( iResponseData->Ptr(0), iResponseData->Size() );
+ delete iResponseData;
+ iResponseData = NULL;
+ }
+ aResult.CommitL();
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::ReplaceItemsL( RReadStream& aData )
+ {
+ TRACE_FUNC_ENTRY;
+ delete iResponseData;
+ iResponseData = NULL;
+ iResponseData = CBufFlat::NewL(KDefaultExpandSize);
+ RBufWriteStream responseStream( *iResponseData );
+ CleanupClosePushL( responseStream );
+ // Read item uids from parameter
+ TInt itemCount = aData.ReadInt32L();
+
+ responseStream.WriteInt32L( itemCount );
+ for ( TInt i=0; i<itemCount; i++ )
+ {
+ TSmlDbItemUid uid = aData.ReadInt32L();
+ TSmlDbItemUid parent = aData.ReadInt32L();
+ TBool fieldChange = aData.ReadUint8L();
+ TInt len = aData.ReadInt32L();
+ HBufC8* dataBuf = HBufC8::NewLC( len );
+ TPtr8 dataPtr = dataBuf->Des();
+ aData.ReadL( dataPtr, len );
+
+ TRAPD( err, iSyncSession.ReplaceItemL(uid,
+ parent,
+ fieldChange, dataPtr));
+ CleanupStack::PopAndDestroy( dataBuf );
+
+ responseStream.WriteInt32L( uid );
+ responseStream.WriteInt32L( err );
+ }
+ responseStream.CommitL();
+ CleanupStack::PopAndDestroy( &responseStream );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::GetReplaceItemsResponseL( const TDesC8& aParams, RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( aParams.Length() > 0 )
+ {
+ LOGGER_WRITE8_1("aParams: %S", &aParams);
+ if ( iSyncStatus == EReady )
+ {
+ LOGGER_WRITE("Start replacing items from file");
+ iReplacedItems.Reset();
+
+ // create parameter stream reader
+ const TUint8* ptr = aParams.Ptr();
+ RMemReadStream stream( ptr , aParams.Size() );
+ CleanupClosePushL( stream );
+
+ // read filename
+ TInt filenameLength = stream.ReadInt32L();
+ LOGGER_WRITE_1("filename length: %d", filenameLength );
+ HBufC8* filenameBuf8 = HBufC8::NewLC( filenameLength ); // filename
+ TPtr8 filenamePtr = filenameBuf8->Des();
+ stream.ReadL( filenamePtr, filenameLength);
+ LOGGER_WRITE("filename ok");
+
+ TInt err = CnvUtfConverter::ConvertToUnicodeFromUtf8(iFileInProgress, filenameBuf8->Des() );
+ LOGGER_WRITE_1("ConvertToUnicodeFromUtf8 err: %d", err);
+ User::LeaveIfError( err );
+ if ( iFileInProgress.RightTPtr(KDataFileExtension().Length()).CompareF(KDataFileExtension) != 0 )
+ {
+ iFileInProgress = KNullDesC();
+ LOGGER_WRITE("File extendion was not correct");
+ User::Leave( KErrAccessDenied );
+ }
+
+ // open file
+ err = iFileStream.Open(iFs, iFileInProgress, EFileShareReadersOnly);
+ LOGGER_WRITE_1("iFileStream.Open err: %d", err);
+ User::LeaveIfError( err );
+
+ CleanupStack::PopAndDestroy( filenameBuf8 );
+ CleanupStack::PopAndDestroy( &stream );
+
+ iSyncStatus = EReplacingItemsFromFile;
+ iItemsLeftInStream = iFileStream.ReadInt32L();
+ LOGGER_WRITE_1("iItemsLeftInStream: %d", iItemsLeftInStream);
+ // write results to return stream
+ aResult.WriteInt32L( iItemsLeftInStream );
+ aResult.WriteInt32L( 0 ); // completed items since last sync
+ ReplaceNextItemOnStreamL();
+ iItemsLeftInStream--;
+ }
+ else if ( iSyncStatus == EReplacingItemsFromFile || iSyncStatus == EItemsReplaced )
+ {
+ LOGGER_WRITE("Read status");
+ TInt temp = 0;
+ if ( iSyncStatus == EReplacingItemsFromFile )
+ {
+ // one item is on progress, add it to to "left" items.
+ temp = 1;
+ }
+ LOGGER_WRITE_1("left items: %d", iItemsLeftInStream + temp);
+ LOGGER_WRITE_1("completed items: %d", iReplacedItems.Count());
+ aResult.WriteInt32L( iItemsLeftInStream + temp ); // items in progress
+ aResult.WriteInt32L( iReplacedItems.Count() ); // completed items since last get
+ //for (TInt i=0; i<iCreatedItems.Count(); i++)
+ while ( iReplacedItems.Count() > 0 )
+ {
+ aResult.WriteInt32L( iReplacedItems[0].iItemUid );
+ aResult.WriteInt32L( iReplacedItems[0].iErrorCode );
+ iReplacedItems.Remove(0);
+ }
+ if ( iSyncStatus == EItemsReplaced )
+ {
+ // all done
+ iSyncStatus = EReady;
+ LOGGER_WRITE("iSyncStatus = EReady");
+ }
+ }
+ }
+ else
+ {
+ if ( !iResponseData )
+ {
+ LOGGER_WRITE("No response data, leave KErrNotReady");
+ User::Leave( KErrNotReady );
+ }
+ aResult.WriteL( iResponseData->Ptr(0), iResponseData->Size() );
+ aResult.CommitL();
+ delete iResponseData;
+ iResponseData = NULL;
+ }
+ aResult.CommitL();
+
+
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::MoveItemsL( const TDesC8& aParams, RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ const TUint8* ptr = aParams.Ptr();
+ RMemReadStream stream( ptr , aParams.Size() );
+ CleanupClosePushL( stream );
+
+ // Read item uids from parameter
+ TInt itemCount = stream.ReadInt32L();
+ aResult.WriteInt32L( itemCount );
+ for ( TInt i=0; i<itemCount; i++ )
+ {
+ TSmlDbItemUid uid = stream.ReadInt32L();
+ TSmlDbItemUid newParent = stream.ReadInt32L();
+ TRAPD( err, iSyncSession.MoveItemL( uid,newParent ));
+
+ aResult.WriteInt32L( uid );
+ aResult.WriteInt32L( err );
+ }
+ aResult.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::DeleteItemsL( const TDesC8& aParams, RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ const TUint8* ptr = aParams.Ptr();
+ RMemReadStream stream( ptr , aParams.Size() );
+ CleanupClosePushL( stream );
+
+ // Read item uids from parameter
+ TInt itemCount = stream.ReadInt32L();
+ aResult.WriteInt32L( itemCount );
+ for ( TInt i=0; i<itemCount; i++ )
+ {
+ TSmlDbItemUid uid = stream.ReadInt32L();
+
+ TRAPD( err, iSyncSession.DeleteItemL( uid ));
+
+ aResult.WriteInt32L( uid );
+ aResult.WriteInt32L( err );
+ }
+ aResult.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::SoftDeleteItemsL( const TDesC8& aParams, RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ const TUint8* ptr = aParams.Ptr();
+ RMemReadStream stream( ptr , aParams.Size() );
+ CleanupClosePushL( stream );
+
+ // Read item uids from parameter
+ TInt itemCount = stream.ReadInt32L();
+ aResult.WriteInt32L( itemCount );
+ for ( TInt i=0; i<itemCount; i++ )
+ {
+ TSmlDbItemUid uid = stream.ReadInt32L();
+
+ TRAPD( err, iSyncSession.SoftDeleteItemL( uid ));
+
+ aResult.WriteInt32L( uid );
+ aResult.WriteInt32L( err );
+ }
+ aResult.CommitL();
+ CleanupStack::PopAndDestroy( &stream );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::DeleteAllItemsL( RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( IsActive() )
+ {
+ LOGGER_WRITE("Warning: Was on active state!");
+ Cancel();
+ }
+ SetActive();
+ iStatus = KRequestPending;
+ iSyncStatus = EDeletingAllItems;
+ iSyncSession.DeleteAllItems( iStatus );
+ aResult.WriteInt32L( KErrNone );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::GetDeleteAllItemsStatusL( RWriteStream& aResult )
+ {
+ if ( iSyncStatus == EDeletingAllItems )
+ {
+ LOGGER_WRITE("CSconSyncHandler::GetDeleteAllItemsStatusL - In progress");
+ aResult.WriteInt8L( 1 ); // 1 = in progress
+ }
+ else
+ {
+ LOGGER_WRITE("CSconSyncHandler::GetDeleteAllItemsStatusL - Ready");
+ aResult.WriteInt8L( 0 ); // 0 = ready
+ aResult.WriteInt32L( iStatus.Int() );
+ }
+ }
+
+void CSconSyncHandler::GetStoreFormatL( RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ RStringPool pool;
+ pool.OpenL();
+ CleanupClosePushL( pool );
+ CSmlDataStoreFormat* storeFormat(NULL);
+ TRAPD( err, storeFormat = iSyncSession.StoreFormatL( pool ) );
+ CleanupStack::PushL( storeFormat );
+ aResult.WriteInt32L( err );
+ if ( !err )
+ {
+ storeFormat->ExternalizeL( aResult );
+ }
+ CleanupStack::PopAndDestroy( storeFormat );
+ CleanupStack::PopAndDestroy( &pool );
+ TRACE_FUNC_EXIT;
+ }
+
+
+void CSconSyncHandler::SetRemoteStoreFormatL( RReadStream& aData )
+ {
+ TRACE_FUNC_ENTRY;
+ RStringPool pool;
+ pool.OpenL();
+ CleanupClosePushL( pool );
+ CSmlDataStoreFormat* serverDataStoreFormat = CSmlDataStoreFormat::NewLC( pool, aData );
+ iSyncSession.SetRemoteStoreFormatL( *serverDataStoreFormat );
+ // Save format for later use
+ TRAPD(err, SaveRemoteStoreFormatL( *serverDataStoreFormat, iCurrentContextUid, iCurrentDataProviderUid ));
+ if ( err )
+ {
+ LOGGER_WRITE_1("SaveRemoteStoreFormatL err: %d", err);
+ }
+ CleanupStack::PopAndDestroy( serverDataStoreFormat );
+ CleanupStack::PopAndDestroy( &pool );
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::CreateNextItemOnStreamL()
+ {
+ TRACE_FUNC_ENTRY;
+ if ( IsActive() )
+ {
+ LOGGER_WRITE("Warning: Was on active state!");
+ Cancel();
+ }
+ iTemporaryItemUid = iFileStream.ReadInt32L();
+ TSmlDbItemUid parent = iFileStream.ReadInt32L();
+
+ TInt len = iFileStream.ReadUint16L();
+ HBufC8* mimeTypeBuf = HBufC8::NewLC( len );
+ TPtr8 mimeTypePtr = mimeTypeBuf->Des();
+ iFileStream.ReadL(mimeTypePtr, len);
+
+ len = iFileStream.ReadUint16L();
+ HBufC8* mimeVerBuf = HBufC8::NewLC( len );
+ TPtr8 mimeVerPtr = mimeVerBuf->Des();
+ iFileStream.ReadL(mimeVerPtr, len);
+
+ len = iFileStream.ReadInt32L();
+ HBufC8* dataBuf = HBufC8::NewLC( len );
+ TPtr8 dataPtr = dataBuf->Des();
+ iFileStream.ReadL( dataPtr, len );
+
+ SetActive();
+ iStatus = KRequestPending;
+ iSyncSession.CreateItemL(iCreatedItemUidPckg,
+ parent, mimeTypePtr,
+ mimeVerPtr, dataPtr, iStatus);
+
+ CleanupStack::PopAndDestroy( dataBuf );
+ CleanupStack::PopAndDestroy( mimeVerBuf );
+ CleanupStack::PopAndDestroy( mimeTypeBuf );
+
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::ReplaceNextItemOnStreamL()
+ {
+ TRACE_FUNC_ENTRY;
+ if ( IsActive() )
+ {
+ LOGGER_WRITE("Warning: Was on active state!");
+ Cancel();
+ }
+ TSmlDbItemUid uid = iFileStream.ReadInt32L();
+ TSmlDbItemUid parent = iFileStream.ReadInt32L();
+ TBool fieldChange = iFileStream.ReadUint8L();
+ TInt len = iFileStream.ReadInt32L();
+ HBufC8* dataBuf = HBufC8::NewLC( len );
+ TPtr8 dataPtr = dataBuf->Des();
+ iFileStream.ReadL( dataPtr, len );
+
+ iReplacedItem.iItemUid = uid;
+
+ SetActive();
+ iStatus = KRequestPending;
+
+ iSyncSession.ReplaceItemL(uid,
+ parent,
+ fieldChange, dataPtr, iStatus);
+
+ CleanupStack::PopAndDestroy( dataBuf );
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::CancelOperationsL( RWriteStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ Cancel();
+ // all done
+ iFileStream.Close();
+ iTemporaryItemUid = -1;
+ iCreatedItemUid = -1;
+ iSyncStatus = EItemsCreated;
+ iFs.Delete( iFileInProgress );
+ iFileInProgress = KNullDesC();
+ iItemsLeftInStream = 0;
+ _LIT8(KDummyParam, "Cancel");
+ if ( iSyncStatus == EItemsCreated )
+ {
+ GetCreateItemsResponseL( KDummyParam, aResult );
+ }
+ else if ( iSyncStatus == EItemsReplaced )
+ {
+ GetReplaceItemsResponseL( KDummyParam, aResult );
+ }
+
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::DoCancel()
+ {
+ TRACE_FUNC_ENTRY;
+ iSyncSession.CancelRequest();
+ Reset();
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::RunL()
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("iSyncStatus: %d", iSyncStatus);
+ LOGGER_WRITE_1("iStatus: %d", iStatus.Int());
+ if ( iSyncStatus == ECreatingItemsFromFile )
+ {
+ LOGGER_WRITE_1("iTemporaryItemUid: %d", iTemporaryItemUid);
+ LOGGER_WRITE_1("iCreatedItemUid: %d", iCreatedItemUid);
+ TCreatedItem item;
+ item.iTemporaryId = iTemporaryItemUid;
+ item.iErrorCode = iStatus.Int();
+ item.iNewUid = iCreatedItemUid;
+ iCreatedItems.Append( item );
+ if ( iItemsLeftInStream > 0 )
+ {
+ CreateNextItemOnStreamL();
+ iItemsLeftInStream--;
+ LOGGER_WRITE_1("iItemsLeftInStream: %d", iItemsLeftInStream);
+ }
+ else
+ {
+ // all done
+ LOGGER_WRITE("All items added.");
+ iFileStream.Close();
+ iTemporaryItemUid = -1;
+ iCreatedItemUid = -1;
+ iSyncStatus = EItemsCreated;
+ TInt err = iFs.Delete( iFileInProgress );
+ LOGGER_WRITE_2("iFs.Delete( '%S' ) ret: %d", &iFileInProgress, err);
+ iFileInProgress = KNullDesC();
+ }
+ }
+ else if ( iSyncStatus == EReplacingItemsFromFile )
+ {
+ iReplacedItem.iErrorCode = iStatus.Int();
+ iReplacedItems.Append( iReplacedItem );
+ if ( iItemsLeftInStream > 0 )
+ {
+ ReplaceNextItemOnStreamL();
+ iItemsLeftInStream--;
+ LOGGER_WRITE_1("iItemsLeftInStream: %d", iItemsLeftInStream);
+ }
+ else
+ {
+ // all done
+ LOGGER_WRITE("All items replaced.");
+ iFileStream.Close();
+ iSyncStatus = EItemsReplaced;
+ TInt err = iFs.Delete( iFileInProgress );
+ LOGGER_WRITE_2("iFs.Delete( '%S' ) ret: %d", &iFileInProgress, err);
+ iFileInProgress = KNullDesC();
+ }
+ }
+ else if ( iSyncStatus == EDeletingAllItems )
+ {
+ iSyncStatus = EReady;
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+TInt CSconSyncHandler::RunError( TInt aError )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1("aError: %d", aError);
+ LOGGER_WRITE_1("iSyncStatus: %d", iSyncStatus);
+ TInt err( aError );
+ if ( iSyncStatus == ECreatingItemsFromFile )
+ {
+ iSyncStatus = EItemsCreated;
+ iItemsLeftInStream = 0;
+ iFileStream.Close();
+ err = iFs.Delete( iFileInProgress );
+ LOGGER_WRITE_2("iFs.Delete( '%S' ) ret: %d", &iFileInProgress, err);
+ iFileInProgress = KNullDesC();
+ err = KErrNone;
+ }
+ else if ( iSyncStatus == EReplacingItemsFromFile )
+ {
+ iSyncStatus = EItemsReplaced;
+ iItemsLeftInStream = 0;
+ iFileStream.Close();
+ err = iFs.Delete( iFileInProgress );
+ LOGGER_WRITE_2("iFs.Delete( '%S' ) ret: %d", &iFileInProgress, err);
+ iFileInProgress = KNullDesC();
+ err = KErrNone;
+ }
+ else if ( iSyncStatus == EDeletingAllItems )
+ {
+ iSyncStatus = EReady;
+ }
+
+ TRACE_FUNC_EXIT;
+ return err;
+ }
+
+void CSconSyncHandler::Reset()
+ {
+ TRACE_FUNC_ENTRY;
+ iFileStream.Close();
+ TInt err = iFs.Delete( iFileInProgress );
+ LOGGER_WRITE_2("iFs.Delete( '%S' ) ret: %d", &iFileInProgress, err);
+ iFileInProgress = KNullDesC();
+ iSyncStatus = EReady;
+ TRACE_FUNC_EXIT;
+ }
+
+void CSconSyncHandler::SetCalendarCenrepL( TInt aProfileId, const TDesC& aServerId )
+ {
+ LOGGER_WRITE(" Write cenrep values");
+ CRepository* rep = CRepository::NewLC(KNsmlDsSessionInfoKey);
+ User::LeaveIfError( rep->Set(EDSSessionProfileId, aProfileId) );
+ User::LeaveIfError( rep->Set(EDSSessionProfileName, KNullDesC) );
+ User::LeaveIfError( rep->Set(EDSSessionServerId, aServerId) );
+ CleanupStack::PopAndDestroy(rep);
+ iCalendarCenrepUsed = ETrue;
+ }
+
+void CSconSyncHandler::ClearCalendarCenrepL()
+ {
+ if ( iCalendarCenrepUsed )
+ {
+ LOGGER_WRITE("Calendar sync, clear cenrep values");
+
+ CRepository* rep = CRepository::NewLC(KNsmlDsSessionInfoKey);
+ rep->Set(EDSSessionProfileId, KErrNotFound);
+ rep->Set(EDSSessionProfileName, KNullDesC);
+ rep->Set(EDSSessionServerId, KNullDesC);
+ CleanupStack::PopAndDestroy(rep);
+ iCalendarCenrepUsed = EFalse;
+ }
+ }
+
--- a/mtpdataproviders/mtpimagedp/inc/cmtpimagedp.h Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpdataproviders/mtpimagedp/inc/cmtpimagedp.h Thu Aug 19 10:44:03 2010 +0300
@@ -67,6 +67,7 @@
void HandleDeleteObjectsArray();
void IncreaseNewPictures(TInt aCount);
void DecreaseNewPictures(TInt aCount);
+ void ResetNewPictures();
void HandleMdeSessionCompleteL(TInt aError);
public: // From CMTPDataProviderPlugin
@@ -129,6 +130,7 @@
TBool iEnumerationNotified;
RPointerArray<HBufC> iDeleteObjectsArray;
+ RArray<TUint> iNewPicHandles;
};
#endif // CMTPIMAGEDP_H
--- a/mtpdataproviders/mtpimagedp/inc/cmtpimagedpgetobject.h Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpdataproviders/mtpimagedp/inc/cmtpimagedpgetobject.h Thu Aug 19 10:44:03 2010 +0300
@@ -42,6 +42,7 @@
void ServiceL();
TBool DoHandleCompletingPhaseL();
+ TMTPResponseCode CheckRequestL();
private:
--- a/mtpdataproviders/mtpimagedp/src/cmtpimagedp.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpdataproviders/mtpimagedp/src/cmtpimagedp.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -120,8 +120,10 @@
}
//Define RProperty of new pictures for status data provider
+ RProcess process;
+ TUid tSid = process.SecureId();
_LIT_SECURITY_POLICY_PASS(KAllowReadAll);
- TInt error = RProperty::Define(TUid::Uid(KMTPServerUID), KMTPNewPicKey, RProperty::EInt, KAllowReadAll, KAllowReadAll);
+ TInt error = RProperty::Define(tSid, KMTPNewPicKey, RProperty::EInt, KAllowReadAll, KAllowReadAll);
if (error != KErrNone && error != KErrAlreadyExists)
{
__FLOG_1(_L8("CMTPImageDataProvider::ConstructL - RProperty define error:%d"), error);
@@ -165,6 +167,7 @@
//Try to delete objects in array
HandleDeleteObjectsArray();
iDeleteObjectsArray.ResetAndDestroy();
+ iNewPicHandles.Reset();
__FLOG(_L8("<< ~CMTPImageDataProvider"));
__FLOG_CLOSE;
@@ -610,8 +613,7 @@
/**
* Get image object count from framework and calculate the new pictures
*/
- TUint newPictures = QueryImageObjectCountL();
- RProperty::Set(TUid::Uid(KMTPServerUID), KMTPNewPicKey, newPictures);
+ TUint newPictures = QueryImageObjectCountL();
iNewPicNotifier->SetNewPictures(newPictures);
__FLOG_1(_L16("CMTPImageDpEnumerator::CompleteEnumeration - New Pics: %d"), newPictures);
iEnumerated = EFalse;
@@ -693,6 +695,8 @@
CleanupClosePushL(context);
CleanupClosePushL(handles);
+ iNewPicHandles.Reset();
+
do
{
/*
@@ -712,6 +716,7 @@
if (MTPImageDpUtilits::IsNewPicture(*objMetadata))
{
++newPictures;
+ iNewPicHandles.Append(handles[i]);
}
}
@@ -765,6 +770,32 @@
__FLOG(_L8("<< DecreaseNewPictures "));
}
+void CMTPImageDataProvider::ResetNewPictures()
+ {
+ __FLOG(_L8(">> ResetNewPictures "));
+
+ iNewPicNotifier->SetNewPictures(0);
+
+ TInt count = iNewPicHandles.Count();
+ if (!count)
+ {
+ return;
+ }
+
+ CMTPObjectMetaData* objMetadata = CMTPObjectMetaData::NewLC();
+
+ for (TInt i(0); i<count; ++i)
+ {
+ Framework().ObjectMgr().ObjectL(iNewPicHandles[i], *objMetadata);
+ MTPImageDpUtilits::UpdateObjectStatusToOldL(Framework(), *objMetadata);
+ }
+
+ iNewPicHandles.Reset();
+ CleanupStack::PopAndDestroy(objMetadata);
+
+ __FLOG(_L8("<< ResetNewPictures "));
+ }
+
void CMTPImageDataProvider::HandleMdeSessionCompleteL(TInt aError)
{
__FLOG(_L8(">> HandleMdeSessionComplete"));
--- a/mtpdataproviders/mtpimagedp/src/cmtpimagedpgetobject.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpdataproviders/mtpimagedp/src/cmtpimagedpgetobject.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -93,7 +93,22 @@
__FLOG(_L8(">> CMTPImageDpGetObject::ConstructL"));
__FLOG(_L8("<< CMTPImageDpGetObject::ConstructL"));
}
-
+TMTPResponseCode CMTPImageDpGetObject::CheckRequestL()
+ {
+ __FLOG(_L8(">> CMTPImageDpGetObject::CheckRequestL"));
+ TMTPResponseCode responseCode = CMTPRequestProcessor::CheckRequestL();
+
+ TUint32 handle(Request().Uint32(TMTPTypeRequest::ERequestParameter1));
+ if ( handle != KMTPHandleAll )
+ {
+ CMTPObjectMetaData* ObjectMeta = CMTPObjectMetaData::NewL();
+ responseCode = MTPImageDpUtilits::VerifyObjectHandleL(
+ iFramework, handle, *ObjectMeta);
+ delete ObjectMeta;
+ }
+ __FLOG(_L8("<< CMTPImageDpGetObject::CheckRequestL"));
+ return responseCode;
+ }
/**
GetObject request handler
*/
@@ -140,7 +155,7 @@
{
//update new picture status
MTPImageDpUtilits::UpdateObjectStatusToOldL(iFramework, *objectInfo);
- iDataProvider.DecreaseNewPictures(1);
+ iDataProvider.ResetNewPictures();
}
}
--- a/mtpdataproviders/mtpimagedp/src/cmtpimagedpnewpicturesnotifier.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpdataproviders/mtpimagedp/src/cmtpimagedpnewpicturesnotifier.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -44,6 +44,7 @@
void CMTPImageDpNewPicturesNotifier::SetNewPictures(TInt aValue)
{
iNewPictures = aValue;
+ RProperty::Set(TUid::Uid(KMTPServerUID), KMTPNewPicKey, iNewPictures);
}
void CMTPImageDpNewPicturesNotifier::IncreaseCount(TInt aValue)
--- a/mtpdataproviders/mtpimagedp/src/cmtpimagedpobjectpropertymgr.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpdataproviders/mtpimagedp/src/cmtpimagedpobjectpropertymgr.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -68,7 +68,9 @@
CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache* CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::NewL()
{
CMTPImagePropertiesCache* self = new(ELeave) CMTPImagePropertiesCache(KElements, ENumProperties);
+ CleanupStack::PushL(self);
self->ConstructL();
+ CleanupStack::Pop(self);
return self;
}
--- a/mtpdataproviders/mtppictbridgedp/src/cmtppictbridgedpsendobjectinfo.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpdataproviders/mtppictbridgedp/src/cmtppictbridgedpsendobjectinfo.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -659,7 +659,16 @@
//with folder creation.
- iFramework.ObjectMgr().CommitReservedObjectHandleL(*iReceivedObjectP);
+ TRAPD(err, iFramework.ObjectMgr().CommitReservedObjectHandleL(*iReceivedObjectP));
+ __FLOG_VA((_L8(" Entry error %d"),err));
+ if( KErrAlreadyExists == err )
+ {
+ iReceivedObjectP->SetUint(CMTPObjectMetaData::EHandle, iFramework.ObjectMgr().HandleL(iFullPath));
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
SendResponseL(EMTPRespCodeOK);
}
__FLOG(_L8("<< CMTPPictGetObjectPropDesc::DoHandleSendObjectCompleteL"));
--- a/mtpdataproviders/mtppictbridgedp/src/cmtppictbridgeusbconnection.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpdataproviders/mtppictbridgedp/src/cmtppictbridgeusbconnection.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -78,13 +78,19 @@
//
void CMTPPictBridgeUsbConnection::Listen()
{
- iProperty.Subscribe(iStatus);
- SetActive();
- if(ConnectionClosed()) // we listen to the disconnection only if connected to the printer
+ __FLOG(_L8(">> CMTPPictBridgeUsbConnection::Listen"));
+ if(!IsActive())
{
- iPrinter.ConnectionClosed();
- Cancel();
+ __FLOG(_L8(" CMTPPictBridgeUsbConnection AO is NOT active and run AO"));
+ iProperty.Subscribe(iStatus);
+ SetActive();
+ if(ConnectionClosed()) // we listen to the disconnection only if connected to the printer
+ {
+ iPrinter.ConnectionClosed();
+ Cancel();
+ }
}
+ __FLOG(_L8("<< CMTPPictBridgeUsbConnection::Listen"));
}
// --------------------------------------------------------------------------
@@ -97,12 +103,14 @@
TInt ret = RProperty::Get(KPSUidUsbWatcher, KUsbWatcherSelectedPersonality, personality);
__FLOG_VA((_L8("CMTPPictBridgeUsbConnection::ConnectionClosed() current personality = %d, previous personality = %d"), personality, iPreviousPersonality));
- if ((ret == KErrNone &&
- (personality == KUsbPersonalityIdMS || personality == KUsbPersonalityIdPTP))
+ if ((ret == KErrNone && personality == KUsbPersonalityIdMS)
|| (iPreviousPersonality != KNotAssigned && personality != iPreviousPersonality))
- {
- __FLOG_VA((_L8("****WARNING!!! PTP server detects the USB connection closed!")));
- return ETrue;
+ {
+ if((personality != KUsbPersonalityIdPCSuiteMTP)&&(personality != KUsbPersonalityIdMTP))
+ {
+ __FLOG_VA((_L8("****WARNING!!! PTP server detects the USB connection closed!")));
+ return ETrue;
+ }
}
iPreviousPersonality = personality;
--- a/mtpfws/mtpfw/dataproviders/devdp/inc/cmtpgetnumobjects.h Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/dataproviders/devdp/inc/cmtpgetnumobjects.h Thu Aug 19 10:44:03 2010 +0300
@@ -49,10 +49,12 @@
CMTPGetNumObjects(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection);
void ConstructL();
+ void HandleObjectHandlesUnderMacL(CMTPTypeArray &aObjectHandles);
private:
TBool IsSupportedFormatL(TUint32 aFormatCode);
+ void GetObjectHandlesByFormatCodeL(TUint32 aFormatCode, CMTPTypeArray &aObjectHandles);
protected:
/**
--- a/mtpfws/mtpfw/dataproviders/devdp/src/cmtpdevicedp.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/dataproviders/devdp/src/cmtpdevicedp.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -388,7 +388,9 @@
if(extnpluginMap )
{
+ CleanupStack::PushL(extnpluginMap);
iExtnPluginMapArray.AppendL(extnpluginMap);
+ CleanupStack::Pop(extnpluginMap);
}
}
--- a/mtpfws/mtpfw/dataproviders/devdp/src/cmtpgetnumobjects.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/dataproviders/devdp/src/cmtpgetnumobjects.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -13,6 +13,7 @@
// Description:
//
+
#include <mtp/tmtptyperequest.h>
#include <mtp/mmtpdataproviderframework.h>
#include <mtp/mmtpobjectmgr.h>
@@ -153,18 +154,11 @@
if(iDevDpSingletons.DeviceDataStore().IsConnectMac()
&&(KMTPFormatsAll == Request().Uint32(TMTPTypeRequest::ERequestParameter2)))
{
- //get folder count
- TMTPObjectMgrQueryParams paramsFolder(Request().Uint32(TMTPTypeRequest::ERequestParameter1), EMTPFormatCodeAssociation, Request().Uint32(TMTPTypeRequest::ERequestParameter3));
- TUint32 count = iFramework.ObjectMgr().CountL(paramsFolder);
- __FLOG_VA((_L8("ConnectMac and Fetch all, folder count = %d"), count));
-
- //get script count
- TMTPObjectMgrQueryParams paramsScript(Request().Uint32(TMTPTypeRequest::ERequestParameter1), EMTPFormatCodeScript, Request().Uint32(TMTPTypeRequest::ERequestParameter3));
- count += iFramework.ObjectMgr().CountL(paramsScript);
-
- //get Image file count
- TMTPObjectMgrQueryParams paramsImage(Request().Uint32(TMTPTypeRequest::ERequestParameter1), EMTPFormatCodeEXIFJPEG, Request().Uint32(TMTPTypeRequest::ERequestParameter3));
- count += iFramework.ObjectMgr().CountL(paramsImage);
+ TUint32 count(0);
+ CMTPTypeArray *handles = CMTPTypeArray::NewLC(EMTPTypeAUINT32);
+ HandleObjectHandlesUnderMacL(*handles);
+ count = handles->NumElements();
+ CleanupStack::PopAndDestroy(handles);
__FLOG_VA((_L8("ConnectMac and Fetch all, total count = %d"), count));
SendResponseL(EMTPRespCodeOK, 1, &count);
}
@@ -201,26 +195,106 @@
}
-
-
-
-
-
-
-
-
-
-
+/**
+Handle special case under Mac.
+Only expose the Folder, Image File and Viedo, Script under Drive:\Images, Drive\Viedos
+*/
+void CMTPGetNumObjects::HandleObjectHandlesUnderMacL(CMTPTypeArray &aObjectHandles)
+ {
+ __FLOG(_L8("HandleObjectHandlesUnderMacL - Entry"));
+
+ CMTPTypeArray* totalHandles = CMTPTypeArray::NewLC(EMTPTypeAUINT32);
+
+ //get folder object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCodeAssociation,*totalHandles);
+
+ //get image/jpeg object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCodeEXIFJPEG,*totalHandles);
+ //get image/bmp object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCodeBMP,*totalHandles);
+ //get image/jif object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCodeGIF,*totalHandles);
+ //get image/jpeg object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCodePNG,*totalHandles);
+
+ //get video/mp4 object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCodeMP4Container,*totalHandles);
+ //get video/3gp object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCode3GPContainer,*totalHandles);
+ //get video/wmv object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCodeWMV,*totalHandles);
+ //get video/asf object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCodeASF,*totalHandles);
+
+ //Filer the folder list, ?:\\Images\\* and ?:\\Videos\\*
+ _LIT(KImagesFolderPre, "?:\\Images\\*");
+ _LIT(KViedosFolderPre, "?:\\Videos\\*");
+
+ const TUint KCount(totalHandles->NumElements());
+
+ for (TUint i(0); (i < KCount); i++)//handles loop
+ {
+ CMTPObjectMetaData* object(CMTPObjectMetaData::NewLC());
+ iFramework.ObjectMgr().ObjectL(totalHandles->ElementUint(i),*object);
+ const TDesC& suid(object->DesC(CMTPObjectMetaData::ESuid));
+
+#ifdef __FLOG_ACTIVE
+ TBuf8<KMaxFileName> tmp;
+ tmp.Copy(suid);
+ __FLOG_VA((_L8("HandleObjectHandlesUnderMacL - suid: %S"), &tmp));
+#endif // __FLOG_ACTIVE
+ if((KErrNotFound != suid.MatchF(KImagesFolderPre)) ||
+ (KErrNotFound != suid.MatchF(KViedosFolderPre)))
+ {
+ _LIT(KComma,",");
+ _LIT(KLineation,"-");
+ _LIT(KUnderline,"_");
+ _LIT(Ksemicolon ,";");
+ if((KErrNotFound != suid.Find(KComma))||
+ (KErrNotFound != suid.Find(KLineation))||
+ (KErrNotFound != suid.Find(KUnderline))||
+ (KErrNotFound != suid.Find(Ksemicolon)))
+ {
+ __FLOG(_L8("HandleObjectHandlesUnderMacL - Skip handle"));
+ }
+ else
+ {
+ __FLOG_VA((_L8("HandleObjectHandlesUnderMacL - Add handle: %x"), totalHandles->ElementUint(i)));
+ RArray<TUint> tmphandles;
+ CleanupClosePushL(tmphandles);
+ tmphandles.AppendL(totalHandles->ElementUint(i));
+ aObjectHandles.AppendL(tmphandles);
+ CleanupStack::PopAndDestroy(&tmphandles);
+ }
+ }
+ CleanupStack::PopAndDestroy(object);
+ }
+
+ CleanupStack::PopAndDestroy(totalHandles);
+ //get script object handles
+ GetObjectHandlesByFormatCodeL(EMTPFormatCodeScript,aObjectHandles);
+
+ __FLOG(_L8("HandleObjectHandlesUnderMacL - Exit"));
+ }
+/**
+Get Object Handles by format code
+*/
+void CMTPGetNumObjects::GetObjectHandlesByFormatCodeL(TUint32 aFormatCode, CMTPTypeArray &aObjectHandles)
+ {
+ __FLOG_VA((_L8("GetObjectHandlesByFormatCodeL - Entry FormatCode: %x"), aFormatCode));
+ RMTPObjectMgrQueryContext context;
+ RArray<TUint> handles;
+ CleanupClosePushL(context);
+ CleanupClosePushL(handles);
+ TMTPObjectMgrQueryParams paramsFolder(Request().Uint32(TMTPTypeRequest::ERequestParameter1), aFormatCode, Request().Uint32(TMTPTypeRequest::ERequestParameter3));
+ do
+ {
+ iFramework.ObjectMgr().GetObjectHandlesL(paramsFolder, context, handles);
+ aObjectHandles.AppendL(handles);
+ }
+ while (!context.QueryComplete());
+ CleanupStack::PopAndDestroy(&context);
+ CleanupStack::PopAndDestroy(&handles);
+ __FLOG(_L8("GetObjectHandlesByFormatCode - Exit"));
+ }
-
-
-
-
-
-
-
-
-
-
-
-
--- a/mtpfws/mtpfw/dataproviders/devdp/src/cmtpgetobjecthandles.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/dataproviders/devdp/src/cmtpgetobjecthandles.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -107,10 +107,6 @@
iTimeoutCount = 0;
- RMTPObjectMgrQueryContext context;
- RArray<TUint> handles;
- CleanupClosePushL(context);
- CleanupClosePushL(handles);
delete iHandles;
iHandles = CMTPTypeArray::NewL(EMTPTypeAUINT32);
@@ -119,47 +115,14 @@
&&(KMTPFormatsAll == Request().Uint32(TMTPTypeRequest::ERequestParameter2)))
{
__FLOG(_L8("ConnectMac and Fetch all."));
- //get folder object handles
- TMTPObjectMgrQueryParams paramsFolder(Request().Uint32(TMTPTypeRequest::ERequestParameter1), EMTPFormatCodeAssociation, Request().Uint32(TMTPTypeRequest::ERequestParameter3));
- do
- {
- iFramework.ObjectMgr().GetObjectHandlesL(paramsFolder, context, handles);
- iHandles->AppendL(handles);
- }
- while (!context.QueryComplete());
-
- //get script object handles
- RMTPObjectMgrQueryContext contextScript;
- RArray<TUint> handlesScript;
- CleanupClosePushL(contextScript);
- CleanupClosePushL(handlesScript);
- TMTPObjectMgrQueryParams paramsScript(Request().Uint32(TMTPTypeRequest::ERequestParameter1), EMTPFormatCodeScript, Request().Uint32(TMTPTypeRequest::ERequestParameter3));
- do
- {
- iFramework.ObjectMgr().GetObjectHandlesL(paramsScript, contextScript, handlesScript);
- iHandles->AppendL(handlesScript);
- }
- while (!contextScript.QueryComplete());
- CleanupStack::PopAndDestroy(&contextScript);
- CleanupStack::PopAndDestroy(&handlesScript);
-
- //get image object handles
- RMTPObjectMgrQueryContext contextImage;
- RArray<TUint> handlesImage;
- CleanupClosePushL(contextImage);
- CleanupClosePushL(handlesImage);
- TMTPObjectMgrQueryParams paramsImage(Request().Uint32(TMTPTypeRequest::ERequestParameter1), EMTPFormatCodeEXIFJPEG, Request().Uint32(TMTPTypeRequest::ERequestParameter3));
- do
- {
- iFramework.ObjectMgr().GetObjectHandlesL(paramsImage, contextImage, handlesImage);
- iHandles->AppendL(handlesImage);
- }
- while (!contextImage.QueryComplete());
- CleanupStack::PopAndDestroy(&contextImage);
- CleanupStack::PopAndDestroy(&handlesImage);
+ HandleObjectHandlesUnderMacL(*iHandles);
}
else
{
+ RMTPObjectMgrQueryContext context;
+ RArray<TUint> handles;
+ CleanupClosePushL(context);
+ CleanupClosePushL(handles);
TMTPObjectMgrQueryParams params(Request().Uint32(TMTPTypeRequest::ERequestParameter1), Request().Uint32(TMTPTypeRequest::ERequestParameter2), Request().Uint32(TMTPTypeRequest::ERequestParameter3));
do
{
@@ -194,13 +157,11 @@
}
iHandles->AppendL(handles);
}
- while (!context.QueryComplete());
+ while (!context.QueryComplete());
+ CleanupStack::PopAndDestroy(&handles);
+ CleanupStack::PopAndDestroy(&context);
}
-
-
-
- CleanupStack::PopAndDestroy(&handles);
- CleanupStack::PopAndDestroy(&context);
+
SendDataL(*iHandles);
__FLOG(_L8("ServiceL - Exit"));
}
--- a/mtpfws/mtpfw/dataproviders/devdp/src/cmtpgetstorageinfo.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/dataproviders/devdp/src/cmtpgetstorageinfo.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -196,7 +196,7 @@
{
//E: is set as logically removable after eMMC image updated
//So here we need to deal with this case to set it as FixedRam
- if(iDriveInfo.iDriveAtt & KDriveAttInternal)
+ if(iDriveInfo.iDriveAtt & KDriveAttLogicallyRemovable)
{
__FLOG(_L8("removable but internal drive, set as Fixed RAM"));
storageType = EMTPStorageFixedRAM;
--- a/mtpfws/mtpfw/dataproviders/devdp/src/cmtptypedeviceinfo.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/dataproviders/devdp/src/cmtptypedeviceinfo.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -130,7 +130,9 @@
}
__ASSERT_DEBUG(chunk, User::Invariant());
+ CleanupStack::PushL(chunk);
ChunkAppendL(*chunk);
+ CleanupStack::Pop(chunk);
}
}
}
--- a/mtpfws/mtpfw/dataproviders/dputility/src/cmtpfsenumerator.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/dataproviders/dputility/src/cmtpfsenumerator.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -396,18 +396,27 @@
TInt CMTPFSEnumerator::RunError(TInt aError)
{
__FLOG_VA((_L8("RunError - entry with error %d"), aError));
- if(!iFramework.StorageMgr().ValidStorageId(iStorages[iScanPos]))
- {
- __FLOG_VA((_L8("Invalid StorageID = %d"),iStorages[iScanPos] ));
- if (iStorages.Count()>1)
- {
- //Not necessary to process any entry on the storage, since the storage removed.
- //Then need to start from root dir of next storage if there is.
- //So, the dir stack is popped to bottom.
- iDirStack.Reset();
- }
- iSkipCurrentStorage = ETrue;
- }
+
+ // avoid to access overflow of iStorages
+ if (iScanPos < iStorages.Count())
+ {
+ if(!iFramework.StorageMgr().ValidStorageId(iStorages[iScanPos]))
+ {
+ __FLOG_VA((_L8("Invalid StorageID = %d"),iStorages[iScanPos] ));
+ if (iStorages.Count()>1)
+ {
+ //Not necessary to process any entry on the storage, since the storage removed.
+ //Then need to start from root dir of next storage if there is.
+ //So, the dir stack is popped to bottom.
+ iDirStack.Reset();
+ }
+ iSkipCurrentStorage = ETrue;
+ }
+ }
+ else
+ {
+ iSkipCurrentStorage = ETrue;
+ }
// Reschedule ourselves
TRequestStatus* status = &iStatus;
@@ -548,10 +557,16 @@
__FLOG_VA((_L("mime %S"), mime));
DpId = iDpSingletons.MTPUtility().GetDpIdL(parse.Ext().Mid(1),*mime);
__FLOG_VA((_L("DpId find %d"), DpId));
+
+ format = iDpSingletons.MTPUtility().GetFormatCodeByMimeTypeL(parse.Ext().Mid(1),*mime);
+ AddFileEntryForOtherDpL(iCurrentPath, handle, format, DpId, entry, iStorages[iScanPos],
+ iParentHandle, iDpSingletons.MTPUtility().GetSubFormatCodeL(parse.Ext().Mid(1),*mime));
}
- format = iDpSingletons.MTPUtility().GetFormatCodeByMimeTypeL(parse.Ext().Mid(1),*mime);
- AddFileEntryForOtherDpL(iCurrentPath, handle, format, DpId, entry, iStorages[iScanPos],
- iParentHandle, iDpSingletons.MTPUtility().GetSubFormatCodeL(parse.Ext().Mid(1),*mime));
+ else
+ {
+ AddEntryL(iCurrentPath, handle, EMTPFormatCodeUndefined, iDpID, entry, iStorages[iScanPos], iParentHandle);
+ }
+
CleanupStack::PopAndDestroy(mime);
}
else
--- a/mtpfws/mtpfw/dataproviders/dputility/src/cmtpgetformatcapabilities.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/dataproviders/dputility/src/cmtpgetformatcapabilities.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -95,44 +95,71 @@
CMTPTypeFormatCapability* frmCap = CMTPTypeFormatCapability::NewLC( EMTPFormatCodeAssociation ,interDesc );
//EMTPObjectPropCodeStorageID
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeStorageID) );
+ CMTPTypeObjectPropDesc* storageId = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeStorageID);
+ frmCap->AppendL(storageId);
+ CleanupStack::Pop(storageId);
//EMTPObjectPropCodeObjectFormat
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeObjectFormat) );
+ CMTPTypeObjectPropDesc* objFormat = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeObjectFormat);
+ frmCap->AppendL(objFormat);
+ CleanupStack::Pop(objFormat);
//EMTPObjectPropCodeProtectionStatus
- frmCap->AppendL( ServiceProtectionStatusL() );
+ CMTPTypeObjectPropDesc* protectionStatus = ServiceProtectionStatusL();
+ CleanupStack::PushL(protectionStatus);
+ frmCap->AppendL(protectionStatus);
+ CleanupStack::Pop(protectionStatus);
//EMTPObjectPropCodeAssociationType
- frmCap->AppendL( ServiceAssociationTypeL() );
+ CMTPTypeObjectPropDesc* associationType = ServiceAssociationTypeL();
+ CleanupStack::PushL(associationType);
+ frmCap->AppendL(associationType);
+ CleanupStack::Pop(associationType);
//EMTPObjectPropCodeAssociationDesc
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeAssociationDesc) );
+ CMTPTypeObjectPropDesc* associationDesc = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeAssociationDesc);
+ frmCap->AppendL(associationDesc);
+ CleanupStack::Pop(associationDesc);
//EMTPObjectPropCodeObjectSize
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeObjectSize) );
+ CMTPTypeObjectPropDesc* objSize = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeObjectSize);
+ frmCap->AppendL(objSize);
+ CleanupStack::Pop(objSize);
//EMTPObjectPropCodeObjectFileName
_LIT(KMtpObjDescObjFileName, "[a-zA-Z!#\\$%&'\\(\\)\\-0-9@\\^_\\`\\{\\}\\~][a-zA-Z!#\\$%&'\\(\\)\\-0-9@\\^_\\`\\{\\}\\~ ]{0, 7}\\.[[a-zA-Z!#\\$%&'\\(\\)\\-0-9@\\^_\\`\\{\\}\\~][a-zA-Z!#\\$%&'\\(\\)\\-0-9@\\^_\\`\\{\\}\\~ ]{0, 2}]?");
- CMTPTypeString* form = CMTPTypeString::NewLC( KMtpObjDescObjFileName );
- frmCap->AppendL(CMTPTypeObjectPropDesc::NewL( EMTPObjectPropCodeObjectFileName,
- CMTPTypeObjectPropDesc::ERegularExpressionForm, form));
+ CMTPTypeString* form = CMTPTypeString::NewLC( KMtpObjDescObjFileName );
+ CMTPTypeObjectPropDesc* objFileName = CMTPTypeObjectPropDesc::NewLC( EMTPObjectPropCodeObjectFileName,
+ CMTPTypeObjectPropDesc::ERegularExpressionForm, form);
+ frmCap->AppendL(objFileName);
+ CleanupStack::Pop(objFileName);
CleanupStack::PopAndDestroy(form );
//EMTPObjectPropCodeDateModified
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeDateModified) );
+ CMTPTypeObjectPropDesc* dateModified = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeDateModified);
+ frmCap->AppendL(dateModified);
+ CleanupStack::Pop(dateModified);
//EMTPObjectPropCodeParentObject
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeParentObject) );
+ CMTPTypeObjectPropDesc* parentobj = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeParentObject);
+ frmCap->AppendL(parentobj);
+ CleanupStack::Pop(parentobj);
//EMTPObjectPropCodePersistentUniqueObjectIdentifier
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodePersistentUniqueObjectIdentifier) );
+ CMTPTypeObjectPropDesc* objectIdentifier = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodePersistentUniqueObjectIdentifier);
+ frmCap->AppendL(objectIdentifier);
+ CleanupStack::Pop(objectIdentifier);
//EMTPObjectPropCodeName
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeName));
+ CMTPTypeObjectPropDesc* name = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeName);
+ frmCap->AppendL(name);
+ CleanupStack::Pop(name);
//EMTPObjectPropCodeNonConsumable
- frmCap->AppendL(ServiceNonConsumableL() );
+ CMTPTypeObjectPropDesc* nonConsumable = ServiceNonConsumableL();
+ CleanupStack::PushL(nonConsumable);
+ frmCap->AppendL(nonConsumable);
+ CleanupStack::Pop(nonConsumable);
iCapabilityList->AppendL(frmCap);
CleanupStack::Pop(frmCap);
@@ -146,38 +173,60 @@
CMTPTypeFormatCapability* frmCap = CMTPTypeFormatCapability::NewLC( aFormatCode ,interDesc );
//EMTPObjectPropCodeStorageID
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeStorageID) );
+ CMTPTypeObjectPropDesc* storageID = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeStorageID);
+ frmCap->AppendL(storageID);
+ CleanupStack::Pop(storageID);
//EMTPObjectPropCodeObjectFormat
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeObjectFormat) );
+ CMTPTypeObjectPropDesc* objectFormat = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeObjectFormat);
+ frmCap->AppendL(objectFormat);
+ CleanupStack::Pop(objectFormat);
//EMTPObjectPropCodeProtectionStatus
- frmCap->AppendL( ServiceProtectionStatusL() );
+ CMTPTypeObjectPropDesc* protectionStatus = ServiceProtectionStatusL();
+ CleanupStack::PushL(protectionStatus);
+ frmCap->AppendL(protectionStatus);
+ CleanupStack::Pop(protectionStatus);
//EMTPObjectPropCodeObjectSize
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeObjectSize) );
+ CMTPTypeObjectPropDesc* objSize = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeObjectSize);
+ frmCap->AppendL(objSize);
+ CleanupStack::Pop(objSize);
//EMTPObjectPropCodeObjectFileName
_LIT(KMtpObjDescObjFileName, "[a-zA-Z!#\\$%&'\\(\\)\\-0-9@\\^_\\`\\{\\}\\~][a-zA-Z!#\\$%&'\\(\\)\\-0-9@\\^_\\`\\{\\}\\~ ]{0, 7}\\.[[a-zA-Z!#\\$%&'\\(\\)\\-0-9@\\^_\\`\\{\\}\\~][a-zA-Z!#\\$%&'\\(\\)\\-0-9@\\^_\\`\\{\\}\\~ ]{0, 2}]?");
- CMTPTypeString* form = CMTPTypeString::NewLC( KMtpObjDescObjFileName );
- frmCap->AppendL(CMTPTypeObjectPropDesc::NewL( EMTPObjectPropCodeObjectFileName,
- CMTPTypeObjectPropDesc::ERegularExpressionForm, form));
+ CMTPTypeString* form = CMTPTypeString::NewLC( KMtpObjDescObjFileName );
+ CMTPTypeObjectPropDesc* objFileName = CMTPTypeObjectPropDesc::NewLC( EMTPObjectPropCodeObjectFileName,
+ CMTPTypeObjectPropDesc::ERegularExpressionForm, form);
+ frmCap->AppendL(objFileName);
+ CleanupStack::Pop(objFileName);
CleanupStack::PopAndDestroy(form );
//EMTPObjectPropCodeDateModified
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeDateModified) );
+ CMTPTypeObjectPropDesc* dateModified = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeDateModified);
+ frmCap->AppendL(dateModified);
+ CleanupStack::Pop(dateModified);
//EMTPObjectPropCodeParentObject
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeParentObject) );
+ CMTPTypeObjectPropDesc* parentObject = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeParentObject);
+ frmCap->AppendL(parentObject);
+ CleanupStack::Pop(parentObject);
//EMTPObjectPropCodePersistentUniqueObjectIdentifier
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodePersistentUniqueObjectIdentifier) );
+ CMTPTypeObjectPropDesc* objectIdentifier = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodePersistentUniqueObjectIdentifier);
+ frmCap->AppendL(objectIdentifier);
+ CleanupStack::Pop(objectIdentifier);
//EMTPObjectPropCodeName
- frmCap->AppendL( CMTPTypeObjectPropDesc::NewL(EMTPObjectPropCodeName));
+ CMTPTypeObjectPropDesc* name = CMTPTypeObjectPropDesc::NewLC(EMTPObjectPropCodeName);
+ frmCap->AppendL(name);
+ CleanupStack::Pop(name);
//EMTPObjectPropCodeNonConsumable
- frmCap->AppendL(ServiceNonConsumableL() );
+ CMTPTypeObjectPropDesc* nonConsumable = ServiceNonConsumableL();
+ CleanupStack::PushL(nonConsumable);
+ frmCap->AppendL(nonConsumable);
+ CleanupStack::Pop(nonConsumable);
iCapabilityList->AppendL(frmCap);
CleanupStack::Pop(frmCap);
--- a/mtpfws/mtpfw/datatypes/interface/mtpprotocolconstants.h Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/datatypes/interface/mtpprotocolconstants.h Thu Aug 19 10:44:03 2010 +0300
@@ -368,7 +368,7 @@
EMTPRespCodeCaptureAlreadyTerminated = 0x2018,
EMTPRespCodeDeviceBusy = 0x2019,
EMTPRespCodeInvalidParentObject = 0x201A,
- EMTPRespCodeInvalidDeviEMTPRespCodecePropFormat = 0x201B,
+ EMTPRespCodeInvalidDevicePropFormat = 0x201B,
EMTPRespCodeInvalidDevicePropValue = 0x201C,
EMTPRespCodeInvalidParameter = 0x201D,
EMTPRespCodeSessionAlreadyOpen = 0x201E,
--- a/mtpfws/mtpfw/datatypes/src/cmtptypeobjectinfo.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/datatypes/src/cmtptypeobjectinfo.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -128,7 +128,9 @@
}
__ASSERT_DEBUG(chunk, User::Invariant());
+ CleanupStack::PushL(chunk);
ChunkAppendL(*chunk);
+ CleanupStack::Pop(chunk);
}
}
}
--- a/mtpfws/mtpfw/datatypes/src/cmtptypestorageinfo.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/datatypes/src/cmtptypestorageinfo.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -115,7 +115,9 @@
break;
}
__ASSERT_DEBUG(chunk, User::Invariant());
+ CleanupStack::PushL(chunk);
ChunkAppendL(*chunk);
+ CleanupStack::Pop(chunk);
}
}
}
--- a/mtpfws/mtpfw/src/cmtpconnection.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/src/cmtpconnection.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -94,6 +94,12 @@
}
iSessions.ResetAndDestroy();
+
+ if (iTransportConnection != NULL)
+ {
+ iTransportConnection->Unbind(*this);
+ }
+
//close the property
iProperty.Close();
// delete the ‘name?property
@@ -357,7 +363,7 @@
CompleteCloseConnection();
ret = ETrue;
}
-
+
SetState(EStateShutdown);
PublishConnState(EDisconnectedFromHost);
}
@@ -372,10 +378,6 @@
CloseAllSessions();
iSessions.Reset();
- if (iTransportConnection != NULL)
- {
- iTransportConnection->Unbind(*this);
- }
//notify ConnectionMgr and corresponding transports of completion of connection close
iSingletons.ConnectionMgr().ConnectionCloseComplete(iConnectionId);
@@ -405,8 +407,12 @@
*/
SessionOpenedL(KMTPSessionNone);
+ if (iTransportConnection != NULL)
+ {
+ iTransportConnection->Unbind(*this);
+ }
iTransportConnection = &aTransportConnection;
- iTransportConnection->BindL(*this);
+ iTransportConnection->BindL(*this);
SetState(EStateOpen);
}
@@ -707,7 +713,7 @@
iEventQ(_FOFF(CMTPEventLink, iLink)),
iTransportConnection(&aTransportConnection)
{
-
+ iTransportConnection->BindL(*this);
}
/**
--- a/mtpfws/mtpfw/src/cmtpconnectionmgr.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/src/cmtpconnectionmgr.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -13,8 +13,6 @@
// Description:
//
-#include <usbman.h>
-#include <usbstates.h>
#include "cmtpconnectionmgr.h"
#include "cmtpconnection.h"
@@ -115,33 +113,6 @@
EXPORT_C void CMTPConnectionMgr::StartTransportL(TUid aTransport)
{
__FLOG(_L8("StartTransportL - Entry"));
-
- RUsb usb;
- User::LeaveIfError(usb.Connect());
- __FLOG(_L8("after connect, and before call get currentpersonalityid"));
- TInt usbMode;
- TUsbServiceState usbStat;
- TInt err = usb.GetCurrentPersonalityId(usbMode);
- __FLOG_1(_L8("The return value of GetCurrentPersonalityId is %d"), err);
-
- err = usb.GetServiceState(usbStat);
- __FLOG_1(_L8("The return value of GetServiceState is %d"), err);
-
- usb.Close();
-
- __FLOG_1(_L8("The current usb mode is %d"), usbMode);
- __FLOG_1(_L8("The current usb service state is %d"), usbStat);
-
- TInt massStorageMode = 0x02;
-
- if(usbMode == massStorageMode && usbStat != EUsbServiceIdle)
- {
- __FLOG(_L8("StartTransportL without parameter!"));
- StartTransportL( aTransport, NULL );
- return;
- }
-
-
//When USB plug out, BT will start Master mode to reconnect remote device. Else BT will start slave mode to listen connection.
if(aTransport.iUid == KMTPBTTransportUid && iRemoteDevice.iDeviceAddr != 0 && aTransport != iTransportUid)
--- a/mtpfws/mtpfw/src/cmtpdataprovidercontroller.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/src/cmtpdataprovidercontroller.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -484,7 +484,7 @@
Cancel();
//clean the root level snapshot
- iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL(ETrue);
+ TRAP_IGNORE(iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL(ETrue));
//Schedule again to scan subdir
iEnumerationState = EEnumeratingSubDirFiles;
@@ -500,9 +500,7 @@
{
Cancel();
iEnumerationState = EEnumeratingCleanDBSnapshot;
- iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL(EFalse);
-
-
+ TRAP_IGNORE(iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL(EFalse));
}
else
{
--- a/mtpfws/mtpfw/src/cmtpframeworkconfig.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtpfws/mtpfw/src/cmtpframeworkconfig.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -174,9 +174,9 @@
const TInt KStartupInitValue = 1;
iAbnormalDownValue = 0;
TInt err(iRepository->Get(EAbnormalDown, iAbnormalDownValue));
- if ((KErrNone != err ) && (KErrNotFound != err))
+ if ( KErrNone != err )
{
- User::Leave(err);
+ iAbnormalDownValue = 0;
}
//Save the AbnormalDown state to ETrue
--- a/mtptransports/mtpcontroller/src/cmtpbearermonitor.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtptransports/mtpcontroller/src/cmtpbearermonitor.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -80,7 +80,9 @@
__FLOG( _L8("+ConstructL") );
CMTPBluetoothController* btController = CMTPBluetoothController::NewL( *this );
+ CleanupStack::PushL(btController);
iMTPControllers.AppendL( btController );
+ CleanupStack::Pop(btController);
__FLOG( _L8("-ConstructL") );
}
--- a/mtptransports/mtpcontroller/src/cmtpcontrollertimer.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtptransports/mtpcontroller/src/cmtpcontrollertimer.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -89,7 +89,7 @@
{
__FLOG( _L8("Start transport to launch mtp server") );
- iMTPClient.Connect();
+ User::LeaveIfError(iMTPClient.Connect());
iMTPClient.StartTransport(KMTPBtTransportUid);
iStopTransport = EFalse;
iMTPOperator->SubscribeConnState();
--- a/mtptransports/mtpusbtransport/usbsic_imp/inc/cmtpusbepbase.h Thu Jul 15 19:35:12 2010 +0300
+++ b/mtptransports/mtpusbtransport/usbsic_imp/inc/cmtpusbepbase.h Thu Aug 19 10:44:03 2010 +0300
@@ -55,6 +55,7 @@
void FlushRxDataL();
void FlushBufferedRxDataL();
+ void FlushOnePacketL();
protected:
--- a/mtptransports/mtpusbtransport/usbsic_imp/src/cmtpusbconnection.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtptransports/mtpusbtransport/usbsic_imp/src/cmtpusbconnection.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -131,7 +131,7 @@
__FLOG(_L8("CloseConnection - Exit"));
}
-void CMTPUsbConnection::ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& aRequest)
+void CMTPUsbConnection::ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& /*aRequest*/)
{
__FLOG(_L8("ReceiveDataL - Entry"));
@@ -636,7 +636,11 @@
{
__FLOG(_L8("SendInterruptDataCompleteL - Entry"));
iEventPending = EFalse;
+
+ if ( NULL != iProtocolLayer)
+ {
BoundProtocolLayer().SendEventCompleteL(aError, iMTPEvent);
+ }
__FLOG(_L8("SendInterruptDataCompleteL - Exit"));
}
@@ -1254,7 +1258,7 @@
@param aRequest The USB SIC class specific request setup data.
@leave One of the system wide error codes, if a processing failure occurs.
*/
-void CMTPUsbConnection::ProcessControlRequestDeviceStatusL(const TMTPUsbControlRequestSetup& aRequest)
+void CMTPUsbConnection::ProcessControlRequestDeviceStatusL(const TMTPUsbControlRequestSetup& /*aRequest*/)
{
__FLOG(_L8("ProcessControlRequestDeviceStatusL - Entry"));
iUsbControlRequestDeviceStatus.Reset();
@@ -1358,7 +1362,17 @@
{
// Invalid bulk transaction state, close the connection.
__FLOG_VA((_L8("Expected bulk transaction state = %d"), aExpectedTransactionState));
+
+ //if transaction is in request phase, while the container type of data we received is other transaction phase,
+ //just ignore the data and initiate another request receiving.
+ if (ERequestPhase == iBulkTransactionState)
+ {
+ InitiateBulkRequestSequenceL();
+ }
+ else
+ {
CloseConnection();
+ }
}
__FLOG(_L8("BulkRequestTransactionStateValid - Exit"));
return valid;
@@ -1503,6 +1517,7 @@
__FLOG(_L8("BulkEndpointsStallL - Entry"));
EndpointStallL(EMTPUsbEpBulkIn);
EndpointStallL(EMTPUsbEpBulkOut);
+ SetDeviceStatus(EMTPUsbDeviceStatusTransactionCancelled);
__FLOG(_L8("BulkEndpointsStallL - Exit"));
}
@@ -1669,6 +1684,7 @@
SetBulkTransactionState(EUndefined);
SetConnectionState(EIdle);
SetSuspendState(ENotSuspended);
+ iMTPSessionId = KMTPSessionNone;
}
__FLOG(_L8("StopConnection - Exit"));
--- a/mtptransports/mtpusbtransport/usbsic_imp/src/cmtpusbepbase.cpp Thu Jul 15 19:35:12 2010 +0300
+++ b/mtptransports/mtpusbtransport/usbsic_imp/src/cmtpusbepbase.cpp Thu Aug 19 10:44:03 2010 +0300
@@ -596,19 +596,11 @@
// USB Header validation
if (!ValidateUSBHeaderL())
{
- //trash data, continue to flush.
- TRequestStatus status;
- RBuf8 readBuf;
- readBuf.CreateL(KMaxPacketTypeBulkHS);
- Connection().Ldd().ReadPacket(status, EndpointNumber(), readBuf, KMaxPacketTypeBulkHS);
- User::WaitForRequest(status);
- RDebug::Print(_L("CMTPUsbEpBase::ProcessFirstReceivedChunkL(), trash data length = %d"), readBuf.Length());
- readBuf.Close();
+ //trash data, continue to flush by one packet.
+ FlushOnePacketL();
InitiateFirstChunkReceiveL();
return;
-
-
}
if ((iDataLength - KUSBHeaderSize) == 0)
@@ -617,7 +609,14 @@
SetStreamState(EReceiveComplete);
}
}
- else if (iReceiveChunkData.MaxLength() == iReceiveChunkData.Length())
+ else if (iReceiveChunkData.MaxLength() == KUSBHeaderSize
+ && iReceiveChunkData.Length() < KUSBHeaderSize)
+ {
+ //trash data received, just diacard it and initiate next receiving
+ InitiateFirstChunkReceiveL();
+ return;
+ }
+ else if (iReceiveChunkData.MaxLength() == iReceiveChunkData.Length())
{
// USB Control request setup or data packet is received from Control EP.
// All the desired data should be received.
@@ -692,7 +691,7 @@
// 1. MTP file receiving: MTP type file never returns KMTPChunkSequenceCompletion,It can be received
// one part after another. Also it can be commited mutiple times.
// 2. Other MTP datatype receiving during the middle of data stream
- __FLOG(_L8("Commiting write data chunk"));
+ __FLOG(_L8("Commiting write data chunk - 1"));
needCommit = iReceiveDataSink->CommitChunkL(iReceiveChunkData);
lastChunkCommited = ETrue;
}
@@ -702,7 +701,7 @@
{
// It should be the end of MTP type file receiving since it never returns KMTPChunkSequenceCompletion.
// it can be commited mutiple times.
- __FLOG(_L8("Commiting write data chunk"));
+ __FLOG(_L8("Commiting write data chunk - 2"));
needCommit = iReceiveDataSink->CommitChunkL(iReceiveChunkData);
}
else if ((iChunkStatus == KMTPChunkSequenceCompletion)
@@ -711,9 +710,22 @@
{
// The last chunk data which type is any other MTP data type than MTP file type.
// It will not be commited until all the chunk data is received.
- __FLOG(_L8("Commiting write data chunk"));
+ __FLOG(_L8("Commiting write data chunk - 3"));
needCommit = iReceiveDataSink->CommitChunkL(iReceiveChunkData);
- }
+ }
+ else if ((iChunkStatus == KMTPChunkSequenceCompletion)
+ && !endStream
+ && (iReceiveChunkData.Length() == iReceiveChunkData.MaxLength()))
+ {
+ // The last chunk data is received and chunk has been filled up:
+ // just flush one packet and set endStream true and commit received data.
+ // This condition tries to make MTP more robust if DP forgets to handle data-out phase.
+ __FLOG(_L8("Commiting write data chunk - 4"));
+
+ FlushOnePacketL();
+ endStream = ETrue;
+ needCommit = iReceiveDataSink->CommitChunkL(iReceiveChunkData);
+ }
}
// Fetch the next read data chunk.
@@ -1110,3 +1122,15 @@
readBuf.Close();
}
}
+
+void CMTPUsbEpBase::FlushOnePacketL()
+ {
+ //trash data, continue to flush.
+ TRequestStatus status;
+ RBuf8 readBuf;
+ readBuf.CreateL(KMaxPacketTypeBulkHS);
+ Connection().Ldd().ReadPacket(status, EndpointNumber(), readBuf, KMaxPacketTypeBulkHS);
+ User::WaitForRequest(status);
+ RDebug::Print(_L("CMTPUsbEpBase::ProcessFirstReceivedChunkL(), trash data length = %d"), readBuf.Length());
+ readBuf.Close();
+ }