diff -r 000000000000 -r b16258d2340f applayerpluginsandutils/bookmarksupport/src/bkmrkdb.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/applayerpluginsandutils/bookmarksupport/src/bkmrkdb.cpp Tue Feb 02 01:09:52 2010 +0200 @@ -0,0 +1,1011 @@ +// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Internal class for opening and manipulating the bookmark database. +// @internalComponent +// +// + +#include + +#include "bkmrk.h" +#include "bkmrkfolder.h" +#include "bkmrkdb.h" +#include "repository.h" + +_LIT8(KEmptyIconData, ""); + +const TInt KVersionMajor = 1; +const TInt KVersionMinor = 0; +const TInt KVersionBuild = 1; + +const TInt KFirstIndex = 1; + +CBookmarkDb* CBookmarkDb::NewL(Bookmark::TVisibility aVisibility, MBookmarkObserver* aObserver) + { + CBookmarkDb* self = new (ELeave) CBookmarkDb(aObserver); + CleanupStack::PushL(self); + self->ConstructL(aVisibility); + CleanupStack::Pop(self); + return self; + } + +CBookmarkDb::~CBookmarkDb() + { + delete iHomeText; + delete iSearchUri; + delete iDatabaseWatcher; + delete iDatabaseRepository; + delete iFolderWatcher; + delete iFolderRepository; + delete iBookmarkWatcher; + delete iBookmarkRepository; + delete iIconWatcher; + delete iIconRepository; + Reset(); + delete iCustomProperties; + delete iPropertyRegister; + + delete iUnloadedFolderList; + } + +CBookmarkDb::CBookmarkDb(MBookmarkObserver* aObserver) + : iObserver(aObserver) + { + } + +void CBookmarkDb::ConstructL(Bookmark::TVisibility aVisibility) + { + RThread thread; + TSecurityInfo secInfo(thread); + TBool hasWriteUserData = secInfo.iCaps.HasCapability(ECapabilityWriteUserData); + if (aVisibility == Bookmark::EVisibilityManager && !hasWriteUserData) + { + User::Leave(KErrPermissionDenied); + } + + iVisibility = (aVisibility == Bookmark::EVisibilityDefault) ? Bookmark::EVisibilityAll : aVisibility; + + iDatabaseRepository = CRepository::NewL(KUidBookmarkDatabaseRepository); + SetRepository(*iDatabaseRepository); + iFolderRepository = CRepository::NewL(KUidFolderRepository); + iBookmarkRepository = CRepository::NewL(KUidBookmarkRepository); + iIconRepository = CRepository::NewL(KUidIconRepository); + + iPropertyRegister = CPropertyReg::NewL(); + iCustomProperties = CPropertyList::NewL(*iDatabaseRepository, *iPropertyRegister, CPropertyReg::EGroupDatabase, KDbCusPropertyStart); + + // Create the repositories if they don't exist + TPckgBuf pckg; + TInt err = iDatabaseRepository->Get(KVersionIndex, pckg); + if (err == KErrNone) + { + TransactionL(ETransLoad); + iBkmrkDbInitialized = ETrue; + } + else if (err == KErrNotFound) + { + // Set all as default empty values + iHomeId = Bookmark::KNullItemID; + iHomeText = KNullDesC().AllocL(); + iSearchUri = KNullDesC8().AllocL(); + iDefaultProxy = 0; + iDefaultNap = 0; + } + else + { + User::Leave(err); + } + + if (iObserver) + { + iDatabaseWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherDatabase, *this, *iDatabaseRepository); + iDatabaseWatcher->WatchL(); + iFolderWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherFolder, *this, *iFolderRepository); + iFolderWatcher->WatchL(); + iBookmarkWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherBookmark, *this, *iBookmarkRepository); + iBookmarkWatcher->WatchL(); + iIconWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherIcon, *this, *iIconRepository); + iIconWatcher->WatchL(); + } + + iTreeSync = EFalse; + iConfigSync = EFalse; + iIconSync = EFalse; + + iUnloadedFolderList = new (ELeave) CDesCArrayFlat(10); + SetClean(); + } + +void CBookmarkDb::Reset() + { + ResetTree(); + ResetIcons(); + if (iCustomProperties) + { + iCustomProperties->Reset(); + } + } + +void CBookmarkDb::ResetTree() + { + if (iRoot) + { + iRoot->Reset(); + delete iRoot; + iRoot = NULL; + iTreeConstructed = EFalse; + } + + if (iUnloadedFolderList) + { + iUnloadedFolderList->Reset(); + } + + iFolderList.Reset(); + iBookmarkList.Reset(); + + for (TInt index = iDeletedList.Count() - 1; index >= 0; --index) + { + delete iDeletedList[index]; + } + iDeletedList.Reset(); + } + +void CBookmarkDb::ResetIcons() + { + for (TInt index = iIconList.Count() - 1; index >= 0; --index) + { + delete iIconList[index]; + } + iIconList.Reset(); + + iIconSync = EFalse; + } + +void CBookmarkDb::RefreshL() + { + // If no repository files( no bookmark data ) exists, it is not required to + // refresh the bookmark view. Check whether the repository has data or not + // + if ( HasDataInRepositoryL () ) + { + TransactionL(ETransLoad); + ResetTree(); + ConstructTreeL(); + ResetIcons(); + LoadIconsL(); + } + } + +void CBookmarkDb::InitialiseRepL(CRepository& aRepository) + { + TPckgBuf pckg; + TInt err = aRepository.Get(KVersionIndex, pckg); + if (err == KErrNotFound) + { + TInt result = KErrLocked; + do + { + aRepository.StartTransaction(CRepository::EConcurrentReadWriteTransaction); + + // create entries in the repository + TVersion version(KVersionMajor, KVersionMinor, KVersionBuild); + TPckgBuf pckg(version); + aRepository.Create(KVersionIndex, pckg); + aRepository.Create(KRepNextIndex, KFirstIndex); + + // commit the transaction + TUint32 failedIndex; + result = aRepository.CommitTransaction(failedIndex); + } while (result == KErrLocked); + User::LeaveIfError(result); + } + else if (err != KErrNone) + { + User::Leave(err); + } + } + + +void CBookmarkDb::CommitL() + { + CreateDefaultRepositoriesL (); + + CRepositoryAccessor::CommitL(); + + iPropertyRegister->CommitL(); + iCustomProperties->CommitL(); + + TInt index = iFolderList.Count() - 1; + for (;index >= 0; --index) + { + iFolderList[index]->CommitL(); + } + + index = iBookmarkList.Count() - 1; + for (;index >= 0; --index) + { + iBookmarkList[index]->CommitL(); + } + + index = iIconList.Count() - 1; + for (;index >= 0; --index) + { + iIconList[index]->CommitL(); + } + + index = iDeletedList.Count() - 1; + for (;index >= 0; --index) + { + iDeletedList[index]->CommitL(); + delete iDeletedList[index]; + iDeletedList[index] = NULL; + } + iDeletedList.Reset(); + } + +CBookmarkFolder& CBookmarkDb::RootL() + { + ConstructTreeL(); + return *iRoot; + } + +CBookmarkFolder* CBookmarkDb::FindFolder(const TDesC& aFolderName) + { + TInt index = iFolderList.Count() - 1; + for (;index >=0; --index) + { + if (iFolderList[index] != NULL && + aFolderName.Compare(iFolderList[index]->Title()) == 0) + { + return static_cast(iFolderList[index]); + } + } + + return NULL; + } + +CBookmark& CBookmarkDb::CreateBookmarkL(CBookmarkFolder& aParent) + { + CreateDefaultRepositoriesL (); + ConstructTreeL(); + CBookmarkFolder* parent = &aParent; + CBookmark* bookmark = CBookmark::NewL(*parent, *this); + CleanupStack::PushL(bookmark); + bookmark->AssignIdL(); + bookmark->SetTitleL(KNullDesC); + iBookmarkList.AppendL(bookmark); + CleanupStack::Pop(bookmark); + + return *bookmark; + } + +CBookmarkFolder& CBookmarkDb::CreateFolderL(const TDesC& aFolderName, CBookmarkFolder& aParent) + { + CreateDefaultRepositoriesL (); + if (FindFolder(aFolderName) || FindUnloadedFolder(aFolderName)) + { + User::Leave(Bookmark::KErrTitleAlreadyUsed); + } + + ConstructTreeL(); + CBookmarkFolder* parent = &aParent; + CBookmarkFolder* folder = CBookmarkFolder::NewL(parent, *this); + CleanupStack::PushL(folder); + folder->AssignIdL(); + folder->SetTitleL(aFolderName); + iFolderList.AppendL(folder); + CleanupStack::Pop(folder); + + return *folder; + } + +void CBookmarkDb::DeleteItemL(Bookmark::TItemId aItem, TBool aRecursive) + { + if (aItem == Bookmark::KRootItemID) + { + User::Leave(Bookmark::KErrOperationDenied); + } + + CBookmarkBase* item = FindItem(aItem); + if (!item) + { + User::Leave(KErrNotFound); + } + + if (item->Type() == Bookmark::ETypeFolder && !aRecursive) + { + CBookmarkFolder* folder = static_cast(item); + folder->SendChildrenToFolderL(*iRoot); + } + + // Bookmark items are not deleted until the database is commited + // Deleted items are removed from the folder tree and go into a + // 'deleted' list. On a commit the deleted list is deleted from memory + // and from the repository. + item->DeleteL(); + } + +void CBookmarkDb::RemoveBookmarkL(CBookmark* aBookmark) + { + TInt index = iBookmarkList.Find(aBookmark); + if (index != KErrNotFound) + { + if (Home() == aBookmark) + { + SetHome(NULL); + } + iBookmarkList.Remove(index); + iDeletedList.AppendL(aBookmark); + } + } + +void CBookmarkDb::RemoveFolderL(CBookmarkFolder* aFolder) + { + TInt index = iFolderList.Find(aFolder); + if (index != KErrNotFound) + { + iFolderList.Remove(index); + iDeletedList.AppendL(aFolder); + } + } + +const TDesC8& CBookmarkDb::IconL(Bookmark::TAttachmentId aIconId) + { + LoadIconsL(); + TInt index = FindIcon(aIconId); + if (index == KErrNotFound) + { + User::Leave(KErrNotFound); + } + return iIconList[index]->Data(); + } + +Bookmark::TAttachmentId CBookmarkDb::CreateIconL(const TDesC8& aData) + { + CreateDefaultRepositoriesL (); + + LoadIconsL(); + CBkmrkAttachment* icon = CBkmrkAttachment::NewL(*iIconRepository, aData); + CleanupStack::PushL(icon); + icon->SetIdL(); + iIconList.AppendL(icon); + CleanupStack::Pop(icon); + return icon->Id(); + } + +TInt CBookmarkDb::DeleteIconL(Bookmark::TAttachmentId aIconId) + { + LoadIconsL(); + TInt index = FindIcon(aIconId); + if (index == KErrNotFound) + { + return KErrNotFound; + } + + iDeletedList.AppendL(iIconList[index]); + iIconList[index]->DeleteL(); + iIconList.Remove(index); + + return KErrNone; + } + +TVersion CBookmarkDb::Version() + { + TVersion version(KVersionMajor, KVersionMinor, KVersionBuild); + return version; + } + +Bookmark::TVisibility CBookmarkDb::Visibility() + { + return iVisibility; + } + +void CBookmarkDb::SetHome(CBookmark* aHome) + { + iHome = aHome; + if (iHome) + { + iHomeId = iHome->Id(); + } + else + { + iHomeId = Bookmark::KNullItemID; + } + SetDirty(); + } + +CBookmark* CBookmarkDb::Home() + { + return iHome; + } + +const TDesC& CBookmarkDb::HomePageText() const + { + return *iHomeText; + } + +void CBookmarkDb::SetHomePageTextL(const TDesC& aHomePageText) + { + // The aHomePageText must be smaller that the maximim descriptor storage size + __ASSERT_ALWAYS(aHomePageText.Length() <= Bookmark::KMaxDescriptorLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument)); + + delete iHomeText; + iHomeText = NULL; + iHomeText = aHomePageText.AllocL(); + SetDirty(); + } + +const TDesC8& CBookmarkDb::SearchUri() const + { + return *iSearchUri; + } + +void CBookmarkDb::SetSearchUriL(const TDesC8& aUri) + { + // The aUri must be smaller that the maximim uri storage size + __ASSERT_ALWAYS(aUri.Length() <= Bookmark::KMaxUriLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument)); + + delete iSearchUri; + iSearchUri = NULL; + iSearchUri = aUri.AllocL(); + SetDirty(); + } + +TUint32 CBookmarkDb::DefaultProxy() const + { + return iDefaultProxy; + } + +void CBookmarkDb::SetDefaultProxy(TUint32 aServiceId) + { + iDefaultProxy = aServiceId; + SetDirty(); + } + +TUint32 CBookmarkDb::DefaultNap() const + { + return iDefaultNap; + } + +void CBookmarkDb::SetDefaultNap(TUint32 aNetworkId) + { + iDefaultNap = aNetworkId; + SetDirty(); + } + +TBool CBookmarkDb::IsTreeConstructed() + { + return (iRoot != NULL && iTreeConstructed); + } + +void CBookmarkDb::ConstructTreeL() + { + if (!iRoot) + { + iRoot = CBookmarkFolder::NewL(NULL, *this); + iRoot->SetTitleL(Bookmark::KTxtRootTitle); + iRoot->SetId(Bookmark::KRootItemID); + } + if ( !IsTreeConstructed() && HasDataInRepositoryL () ) + { + // Load the tree only if the bookmark db is initialized + // and the tree is not already constructed. + LoadTreeL (); + } + } + +CBookmarkBase* CBookmarkDb::FindItem(Bookmark::TItemId aItemId) + { + if (aItemId == Bookmark::KRootItemID) + { + return iRoot; + } + + CBookmarkBase* item = NULL; + + TInt index = 0; + TInt count = 0; + // the top bit of the id indicates whether the id is a folder or bookmark + TInt topBitSet = aItemId & KFolderIdMaskID; + if (topBitSet == 0) + { + // item is a bookmark + count = iBookmarkList.Count(); + for (index = 0; index < count; ++index) + { + if (iBookmarkList[index]->Id() == aItemId) + { + // bookmark item found + item = iBookmarkList[index]; + break; + } + } + } + else + { + // item is a folder + Bookmark::TItemId folderId; + count = iFolderList.Count(); + for (index = 0; index < count; ++index) + { + folderId = iFolderList[index]->Id(); + if (folderId == aItemId) + { + // folder item found + item = iFolderList[index]; + break; + } + } + } + + return item; + } + +CRepository& CBookmarkDb::FolderRepository() + { + return *iFolderRepository; + } + +CRepository& CBookmarkDb::BookmarkRepository() + { + return *iBookmarkRepository; + } + +CPropertyList& CBookmarkDb::CustomProperties() + { + return *iCustomProperties; + } + +CPropertyReg& CBookmarkDb::PropertyRegister() + { + return *iPropertyRegister; + } + +void CBookmarkDb::BWONotify(TBkmrkWatcherType aType) + { + switch(aType) + { + case EBkmrkWatcherFolder: + case EBkmrkWatcherBookmark: + iObserver->MBONotify(MBookmarkObserver::EEventUpdatedBookmarkTree); + iTreeSync = EFalse; + break; + case EBkmrkWatcherDatabase: + iObserver->MBONotify(MBookmarkObserver::EEventUpdatedConfig); + iConfigSync = EFalse; + break; + case EBkmrkWatcherIcon: + iObserver->MBONotify(MBookmarkObserver::EEventUpdatedIcons); + iIconSync = EFalse; + break; + default: + break; + } + } + +void CBookmarkDb::LoadBookmarkListL(CRepository& aRepository, TBkmrkList& aList, Bookmark::TType aType, TBool aLoadAll) + { + RArray entryList; + CleanupClosePushL(entryList); + aRepository.FindL(KRepIndexFind, KRepIndexMask, entryList); + CBookmarkBase* newItem; + TInt count = entryList.Count(); + for (TInt index = 0;index < count; ++index) + { + if (aType == Bookmark::ETypeFolder) + { + newItem = CBookmarkFolder::NewL(NULL, *this); + } + else + { + newItem = CBookmark::NewL(*iRoot, *this); + } + CleanupStack::PushL(newItem); + newItem->SetIdFromIndexBase(entryList[index]); + newItem->TransactionL(ETransLoad); + if (aLoadAll || CheckAccessL(*newItem)) + { + aList.AppendL(newItem); + CleanupStack::Pop(newItem); + } + else + { + if (aType == Bookmark::ETypeFolder) + { + iUnloadedFolderList->AppendL(newItem->Title()); + } + CleanupStack::PopAndDestroy(newItem); + } + } + CleanupStack::PopAndDestroy(&entryList); + } + +void CBookmarkDb::AddItemsToFolderTreeL(TBkmrkList& aList) + { + TInt rank = 0; + CBookmarkFolder* parent; + CBookmarkBase* item; + TInt count = aList.Count(); + for (TInt index = 0; index < count; ++index) + { + item = aList[index]; + parent = static_cast(FindItem(item->ParentId())); + if (!parent) + { + item->SetOrphaned(ETrue); + iRoot->AppendL(*item); + } + else + { + rank = item->Rank(); + if (rank < parent->Count()) + { + parent->InsertL(*item, rank); + } + else + { + parent->AppendL(*item); + } + } + item->SetClean(); + } + } + +TBool CBookmarkDb::RemoveFolderIfPublicL(CBookmarkFolder& aFolder) + { + // This method removes public folders in private-only mode. + // If not in this mode this method should not be called + __ASSERT_DEBUG(iVisibility == Bookmark::EVisibilityPrivate, User::Invariant()); + + TBool containsPrivate = EFalse; + for (TInt index = aFolder.Count() - 1; index >= 0; --index) + { + if (aFolder.At(index).Type() == Bookmark::ETypeFolder) + { + if (RemoveFolderIfPublicL(static_cast(aFolder.At(index)))) + { + containsPrivate = ETrue; + } + } + else + { + // child is a bookmark which will only exist if it is private + containsPrivate = ETrue; + } + } + + if (&aFolder != iRoot && !containsPrivate && !CheckAccessL(aFolder)) + { + // The folder is not the root, does not contain any private items and is not private itself + // we can remove the folder + TInt index = iFolderList.Find(&aFolder); + iFolderList.Remove(index); + iUnloadedFolderList->AppendL(aFolder.Title()); + delete &aFolder; + } + + return containsPrivate; + } + +void CBookmarkDb::LoadTreeL() + { + if (HasOpenHandles()) + { + User::Leave(Bookmark::KErrOpenHandle); + } + + iLoading = ETrue; + + // If we are in private-only mode then we need to open all the folders initially. + // We need to include public folders that contain private bookmarks + TBool privateMode = (Visibility() == Bookmark::EVisibilityPrivate); + + // The pointers inside the folder list will not get deleted if LoadBookmarkListL or + // AddItemsToFolderTreeL functions leave. Attach the folder list into TCleanupItem + CleanupStack::PushL ( TCleanupItem ( CBookmarkDb::ResetAndDestroyBkmrkList, &iFolderList ) ); + // Load folders into folder list + LoadBookmarkListL(*iFolderRepository, iFolderList, Bookmark::ETypeFolder, privateMode); + AddItemsToFolderTreeL(iFolderList); + CleanupStack::Pop (); // Pop the cleanup item object + + // Load bookmarks into bookmark list + CleanupStack::PushL ( TCleanupItem ( CBookmarkDb::ResetAndDestroyBkmrkList, &iBookmarkList ) ); + LoadBookmarkListL(*iBookmarkRepository, iBookmarkList, Bookmark::ETypeBookmark, EFalse); + AddItemsToFolderTreeL(iBookmarkList); + CleanupStack::Pop (); // Pop the cleanup item object + if (privateMode) + { + // remove folders that are not private and contain no private items. + RemoveFolderIfPublicL(*iRoot); + } + + SetHome(static_cast(FindItem(iHomeId))); + + iLoading = EFalse; + iTreeSync = ETrue; + iTreeConstructed = ETrue; + } + +TBool CBookmarkDb::IsLoading() + { + return iLoading; + } + +void CBookmarkDb::LoadIconsL() + { + if (!iIconSync) + { + RArray entryList; + CleanupClosePushL ( entryList ); + iIconRepository->FindL(KRepIndexFind, KRepIconIndexMask, entryList); + CBkmrkAttachment* newIcon; + TInt index = 0; + TInt count = entryList.Count(); + for (;index < count; ++index) + { + newIcon = CBkmrkAttachment::NewL(*iIconRepository, KEmptyIconData); + CleanupStack::PushL(newIcon); + newIcon->SetIdFromIndexBase(entryList[index]); + newIcon->TransactionL(ETransLoad); + iIconList.AppendL(newIcon); + CleanupStack::Pop(newIcon); + newIcon->SetClean(); + } + CleanupStack::PopAndDestroy ( &entryList ); + + iIconSync = ETrue; + } + + } + +TBool CBookmarkDb::HasOpenHandles() + { + if (!iRoot) + { + return EFalse; + } + + TInt index = iFolderList.Count() -1; + for (; index >= 0; --index) + { + if (iFolderList[index]->RefCount() != 0) + { + return ETrue; + } + } + + index = iBookmarkList.Count() -1; + for (; index >= 0; --index) + { + if (iBookmarkList[index]->RefCount() != 0) + { + return ETrue; + } + } + + return EFalse; + } + +TInt CBookmarkDb::FindIcon(Bookmark::TAttachmentId aIconId) + { + TInt index = iIconList.Count() - 1; + for (;index >= 0; --index) + { + if (iIconList[index]->Id() == aIconId) + { + break; + } + } + return index; + } + +TBool CBookmarkDb::FindUnloadedFolder(const TDesC& aFolderName) + { + TInt index = iUnloadedFolderList->Count() - 1; + for (;index >=0; --index) + { + if (aFolderName.Compare((*iUnloadedFolderList)[index]) == 0) + { + return ETrue; + } + } + + return EFalse; + } + +TBool CBookmarkDb::CheckAccessL(CBookmarkBase& aItem) + { + TBool accessible = EFalse; + + // Always accessible if the item is the home page + if (aItem.Type() == Bookmark::ETypeBookmark && aItem.Id() == iHomeId) + { + return ETrue; + } + + TBool owned = EFalse; + if (!aItem.IsPublic()) + { + RThread thread; + TSecurityInfo secInfo(thread); + TSecureId id; + aItem.GetOwnerL(id); + if (id == secInfo.iSecureId) + { + owned = ETrue; + } + } + + switch(iVisibility) + { + case Bookmark::EVisibilityPublic: + accessible = aItem.IsPublic(); + break; + case Bookmark::EVisibilityPrivate: + accessible = owned; + break; + case Bookmark::EVisibilityAll: + accessible = (owned || aItem.IsPublic()); + break; + case Bookmark::EVisibilityManager: + accessible = ETrue; + break; + case Bookmark::EVisibilityDefault: + default: + // should have been assigned to one of the values above + // during construction so shouldn't get here + User::Invariant(); + break; + } + + return accessible; + } + + +void CBookmarkDb::TransNewL() + { + TInt customPropertyCount = 0; + // create entries in the repository + TVersion version(KVersionMajor, KVersionMinor, KVersionBuild); + TPckgBuf pckg(version); + iRepository->Create(KVersionIndex, pckg); + iRepository->Create(KDbHomeIdIndex, iHomeId); + iRepository->Create(KDbHomeTextIndex, *iHomeText); + iRepository->Create(KDbSearchUriIndex, *iSearchUri); + iRepository->Create(KDbDefaultProxyIndex, iDefaultProxy); + iRepository->Create(KDbDefaultNapIndex, iDefaultNap); + iRepository->Create(KRepBkmrkPropertyStart, customPropertyCount); + iRepository->Create(KRepFldrPropertyStart, customPropertyCount); + iRepository->Create(KRepDbPropertyStart, customPropertyCount); + } + +void CBookmarkDb::TransSaveL() + { + // create entries in the repository + TVersion version(KVersionMajor, KVersionMinor, KVersionBuild); + TPckgBuf pckg(version); + iRepository->Set(KVersionIndex, pckg); + iRepository->Set(KDbHomeIdIndex, iHomeId); + iRepository->Set(KDbHomeTextIndex, *iHomeText); + iRepository->Set(KDbSearchUriIndex, *iSearchUri); + iRepository->Set(KDbDefaultProxyIndex, iDefaultProxy); + iRepository->Set(KDbDefaultNapIndex, iDefaultNap); + } + +void CBookmarkDb::TransLoadL() + { + TPckgBuf pckg; + User::LeaveIfError(iRepository->Get(KVersionIndex, pckg)); + TVersion version = pckg(); + if (version.iMajor != KVersionMajor || + version.iMinor != KVersionMinor ) + { + User::Leave(Bookmark::KErrBadVersion); + } + + User::LeaveIfError(iRepository->Get(KDbHomeIdIndex, iHomeId)); + HBufC* homeText = HBufC::NewLC(Bookmark::KMaxDescriptorLength); + TPtr16 ptr = homeText->Des(); + User::LeaveIfError(iRepository->Get(KDbHomeTextIndex, ptr)); + SetHomePageTextL(*homeText); + CleanupStack::PopAndDestroy(homeText); + + + HBufC8* searchUri = HBufC8::NewLC(Bookmark::KMaxDataLength); + TPtr8 ptr8 = searchUri->Des(); + User::LeaveIfError(iRepository->Get(KDbSearchUriIndex, ptr8)); + SetSearchUriL(*searchUri); + CleanupStack::PopAndDestroy(searchUri); + + User::LeaveIfError(iRepository->Get(KDbDefaultProxyIndex, iDefaultProxy)); + User::LeaveIfError(iRepository->Get(KDbDefaultNapIndex, iDefaultNap)); + + iCustomProperties->TransLoadL(); + SetClean(); + iTreeSync = ETrue; + } + +void CBookmarkDb::TransRemoveL() + { + iDatabaseRepository->Delete(KVersionIndex); + iDatabaseRepository->Delete(KDbHomeIdIndex); + iDatabaseRepository->Delete(KDbHomeTextIndex); + iDatabaseRepository->Delete(KDbSearchUriIndex); + iDatabaseRepository->Delete(KDbDefaultProxyIndex); + iDatabaseRepository->Delete(KDbDefaultNapIndex); + iDatabaseRepository->Delete(KRepBkmrkPropertyStart); + iDatabaseRepository->Delete(KRepFldrPropertyStart); + iDatabaseRepository->Delete(KRepDbPropertyStart); + } + +TUint32 CBookmarkDb::IndexBase() + { + return KIndexBaseZero; + } + +void CBookmarkDb::SetIdFromIndexBase(TUint32 /*aIndexBase*/) + { + // the id and index base is always 0 so do nothing + } + +void CBookmarkDb::ResetAndDestroyBkmrkList ( TAny* aPtr ) + { + TBkmrkList& bkList = *( TBkmrkList* )aPtr; + + // Delete all items added. Otherwise these items will not get deleted and there will + // be a memory leak. + for ( TInt index = bkList.Count() - 1; index >= 0; --index ) + { + delete bkList[ index ]; + } + bkList.Reset (); + } + +void CBookmarkDb::CreateDefaultRepositoriesL () + { + if ( !iBkmrkDbInitialized ) + { + TransactionL ( ETransNew ); + InitialiseRepL ( *iFolderRepository ); + InitialiseRepL ( *iBookmarkRepository ); + InitialiseRepL ( *iIconRepository ); + iBkmrkDbInitialized = ETrue; + } + } + +TBool CBookmarkDb::HasDataInRepositoryL () + { + if ( !iBkmrkDbInitialized ) + { + const TUint32 KNullKey = 0x00000000; + RArray foundKeys; + CleanupClosePushL ( foundKeys ); + iDatabaseRepository->FindL ( KNullKey, KNullKey, foundKeys ); + if ( foundKeys.Count () > 0 ) + { + // Repository has data. + iBkmrkDbInitialized = ETrue; + } + CleanupStack::PopAndDestroy (); // foundKeys + } + return iBkmrkDbInitialized; + } + +#ifndef EKA2 +GLDEF_C TInt E32Dll(TDllReason /*aReason*/) + { + return(KErrNone); + } +#endif // EKA2