"//components/samsung/account_provider",
"//components/samsung/samsung_pass",
"//components/samsung/data_sync_service",
+ "//components/samsung/bpbookmark_model",
+ "//components/samsung/bpbookmark_image_model",
]
configs += [
"samsung/high_contrast_controller.h",
"samsung/data_sync_controller.cc",
"samsung/data_sync_controller.h",
+ "samsung/bookmark_button_controller.h",
+ "samsung/bookmark_button_controller.cc",
]
}
}
#include "components/lens/lens_features.h"
#endif
+#if defined(SAMSUNG_NEXT_BROWSER)
+#include "chrome/browser/ui/samsung/samsung_browser_core.h"
+#endif
+
namespace {
const char kOsOverrideForTabletSite[] = "Linux; Android 9; Chrome tablet";
}
void BookmarkCurrentTab(Browser* browser) {
+// Add Bookmark to Cloud
+#if defined(SAMSUNG_NEXT_BROWSER)
+ std::string action = "Add";
+ LOG(INFO) << "SRPH on BookmarkCurrentTab";
+ auto tab_strip_model = browser->tab_strip_model();
+ auto controller = samsung_browser_main::SamsungBrowserCore::instance()
+ ->BookmarkButtonController();
+ auto model =
+ tab_strip_model->GetTabHandleAt(tab_strip_model->active_index()).Get();
+ // For Verification
+ LOG(INFO) << "SRPH Showing All Bookmarks before add";
+ controller->GetAllBookmarks();
+
+ controller->OnBookmarkClicked(model, action);
+
+ // For Verification
+ LOG(INFO) << "SRPH Showing All Bookmarks after add";
+ controller->GetAllBookmarks();
+
+ // //Remove Bookmark from Cloud
+ // #if defined (SAMSUNG_NEXT_BROWSER)
+ // LOG(INFO) << "SRPH on BookmarkCurrentTab deletion";
+ // auto tab_strip_model = browser -> tab_strip_model();
+ // auto controller = samsung_browser_main::SamsungBrowserCore::instance() ->
+ // BookmarkButtonController(); auto model = tab_strip_model ->
+ // GetTabHandleAt(tab_strip_model -> active_index()).Get(); controller ->
+ // OnBookmarkClicked(model); #endif
+#else
base::RecordAction(base::UserMetricsAction("Star"));
BookmarkModel* model =
BookmarkModelFactory::GetForBrowserContext(browser->profile());
if (!was_bookmarked_by_user && is_bookmarked_by_user) {
RecordBookmarksAdded(browser->profile());
}
+#endif
}
void BookmarkCurrentTabInFolder(Browser* browser, int64_t folder_id) {
--- /dev/null
+#include <codecvt>
+
+#include "bookmark_button_controller.h"
+#include "chrome/browser/ui/samsung/samsung_browser_core.h"
+
+namespace samsung_browser_controller {
+
+BookmarkButtonController::BookmarkButtonController() {}
+
+void BookmarkButtonController::Init() {
+ LOG(INFO) << "SRPH BookmarkButtonController::Init()";
+ LOG(INFO) << "SRPH BookmarkButtonController initialized";
+}
+
+void BookmarkButtonController::GetAllBookmarks() {
+ LOG(INFO) << "SRPH inside GetAllBookmarks";
+
+ // Get instance of Storage Manager
+ auto sm =
+ samsung_browser_main::SamsungBrowserCore::instance()->StorageManager();
+
+ // Get instance of Bookmark Model
+ auto bm = sm->bookmarkModel(sm->BookmarkCloud);
+
+ // Create the parameters for Get Bookmarks
+ auto bookmark_order =
+ samsung_browser_fw_core::IBookmarkModel::BookmarkItemOrder::CreationTime;
+ int limit = 50;
+ int offset = 0;
+ auto bookmark_type = samsung_browser_fw_core::BookmarkType::AllBookmarks;
+ auto parent_id = samsung_browser_fw_core::BookmarkID::NONE;
+
+ // Get Bookmarks
+ auto bookmarks =
+ bm->getBookmarks(bookmark_order, limit, offset, bookmark_type, parent_id);
+
+ // Log all the Bookmarks
+ for (int i = 0; i < bookmarks.size(); i++) {
+ LOG(INFO) << "SRPH Log of Bookmark Items ID " << i << " "
+ << bookmarks[i].getID().toString();
+ LOG(INFO) << "SRPH Log of Bookmark Items URL " << i << " "
+ << bookmarks[i].getURL();
+ }
+}
+
+void BookmarkButtonController::SetAccount() {
+ // Get Browser Core Instance
+ auto core = samsung_browser_main::SamsungBrowserCore::instance();
+ if (!core) {
+ LOG(ERROR) << "SRPH BookmarkButtonController::Init() BrowserCore is null";
+ return;
+ }
+
+ // Get Account Manager Instance
+ auto account_manager = core->SamsungAccountManager();
+ if (!account_manager) {
+ LOG(ERROR) << "SRPH SamsungAccountManager is null";
+ return;
+ }
+
+ // Get Samsung Login Info
+ auto samsung_login_info = account_manager->GetLoginInfoFromSSO();
+
+ // Extract the account name from Samsung Login Info
+ auto account_name = samsung_login_info.GetID();
+
+ // Get A Storage Manager Instance
+ auto sm =
+ samsung_browser_main::SamsungBrowserCore::instance()->StorageManager();
+
+ // Get a Bookmark Model
+ auto bm = sm->bookmarkModel(sm->BookmarkCloud);
+
+ // Set Account Name
+ bm->setAccountName(account_name);
+}
+
+void BookmarkButtonController::OnBookmarkClicked(const TabModel* model,
+ std::string action) {
+ SetAccount();
+ LOG(INFO) << "SRPH inside onBookmarkClicked";
+ bool m_isLogged = true; // for testing
+
+ // Get instance of Storage Manager
+ auto sm =
+ samsung_browser_main::SamsungBrowserCore::instance()->StorageManager();
+
+ // Check if user is logged in
+ if (m_isLogged) {
+ std::string parentID = "";
+ // Check state of BookmarkItem
+ // If already bookmarked, click of bookmark should be for delete
+ // RemoveBookmark(sm->bookmarkModel(sm->BookmarkCloud), model);
+
+ // If not yet bookmarked, click of bookmark should be for add
+ if (action == "Add") {
+ AddBookmark(sm->bookmarkModel(sm->BookmarkCloud), parentID, model);
+ }
+ }
+}
+
+void BookmarkButtonController::AddBookmark(
+ std::shared_ptr<samsung_browser_storage::BPBookmarkModel> bookmarkModel,
+ const std::string& parentID,
+ const TabModel* model) {
+ LOG(INFO) << "SRPH inside AddBookmark";
+
+ // Get URL from WebContent
+ auto url = model->contents()->GetVisibleURL();
+ LOG(INFO) << "SRPH value of URL:" << url;
+
+ // Get Title from WebContent
+ std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> conv;
+ auto title = conv.to_bytes(model->contents()->GetTitle());
+ LOG(INFO) << "SRPH value of title: " << title;
+
+ // Get Favicon from WebContent
+
+ // Create Bookmark Item
+ samsung_browser_fw_core::BookmarkItem item(
+ url.spec(), title, bookmarkModel->getSourceName(),
+ samsung_browser_fw_core::BookmarkType::UserBookmark,
+ samsung_browser_fw_core::BookmarkItemType::Bookmark, parentID);
+
+ // Check if bookmark that will be added is already in model
+ auto check_item = bookmarkModel->getBookmark(url.spec()).getURL();
+
+ // Add Bookmark Item on Bookmarks
+ if (check_item != url.spec()) {
+ LOG(INFO) << "SRPH URL is not present in model. Proceed to add";
+ if (!bookmarkModel->add(item)) {
+ LOG(INFO) << "Failed to add Bookmark";
+ return;
+ }
+ } else {
+ LOG(INFO) << "SRPH URL is already present in model. Do not add";
+ return;
+ }
+
+ // Set Image
+ // if (favicon && favicon->dataSize)
+ // {
+ // imageModel->setImage(favicon, url, item.getSourceName());
+ // }
+
+ // olny for TVLocalBookmarks we check maxBookmarks
+
+ // if ( bookmarkModel ==
+ // BrowserMain::BrowserCore::instance()->storageManager()->defaultBookmarkModel()
+ // &&
+ // m_maxBookmarks <=
+ // bookmarkModel->count(BrowserFWCore::BookmarkType::AllBookmarks))
+ // {
+ // BROWSER_LOGD("Max bookmarks reached");
+ // browserInstance->commonUI()->showToast("TV_SID_UNABLE_TO_ADD_MORE_BOOKMARKS");
+ // return;
+ // }
+ LOG(INFO) << "SRPH Successfully added a Bookmark";
+}
+
+void BookmarkButtonController::RemoveBookmark(
+ std::shared_ptr<samsung_browser_storage::BPBookmarkModel> bm,
+ const TabModel* model) {
+ // Check value of samsung_browser_fw_core::BookmarkItem::INVALID
+ // samsung_browser_fw_core::BookmarkItem bmitem =
+ // samsung_browser_fw_core::BookmarkItem::INVALID; LOG(INFO) << "SRPH value
+ // of BookmarkItem invalid on RemoveBookmark " << bmitem.getID().toString();
+
+ // Get URL from WebContent
+ auto url = model->contents()->GetVisibleURL();
+ LOG(INFO) << "SRPH value of URL:" << url;
+
+ // Get Bookmark Item
+ samsung_browser_fw_core::BookmarkItem bookmark_item =
+ bm->getBookmark(url.spec());
+
+ LOG(INFO) << "SRPH bookmark_item id: " << bookmark_item.getID().toString();
+
+ // check if bookmark_item is invalid
+ if (bookmark_item != samsung_browser_fw_core::BookmarkItem::INVALID) {
+ // remove the bookmark item from bookmark model
+ if (bm->removeURL(bookmark_item)) {
+ LOG(INFO) << "SRPH Removal of bookmark successful";
+ return;
+ }
+ LOG(INFO) << "Removal of Bookmark unsuccessful";
+ return;
+ } else {
+ LOG(INFO) << "SRPH Bookmark Item is invalid";
+ }
+}
+} // namespace samsung_browser_controller
--- /dev/null
+#ifndef CHROME_BROWSER_UI_SAMSUNG_BOOKMARK_BUTTON_CONTROLLER_H_
+#define CHROME_BROWSER_UI_SAMSUNG_BOOKMARK_BUTTON_CONTROLLER_H_
+
+#include "chrome/browser/ui/samsung/storage_manager.h"
+#include "chrome/browser/ui/tabs/tab_model.h"
+#include "components/samsung/bpbookmark_model/samsung_bookmark_item.h"
+
+namespace samsung_browser_controller {
+class BookmarkButtonController {
+ public:
+ BookmarkButtonController();
+ void Init();
+ void GetAllBookmarks();
+ void OnBookmarkClicked(const TabModel* model, std::string action);
+ void AddBookmark(std::shared_ptr<samsung_browser_storage::BPBookmarkModel> bm,
+ const std::string& parentID,
+ const TabModel* model);
+ void RemoveBookmark(
+ std::shared_ptr<samsung_browser_storage::BPBookmarkModel> bm,
+ const TabModel* model);
+
+ private:
+ void SetAccount();
+};
+} // namespace samsung_browser_controller
+#endif
#include "chrome/browser/ui/browser_window.h"
SamsungAbstractID SamsungAbstractID::NONE;
+
namespace samsung_browser_fw_core {
samsung_browser_fw_core::OpenedTabID samsung_browser_fw_core::OpenedTabID::NONE;
+samsung_browser_fw_core::BookmarkID samsung_browser_fw_core::BookmarkID::NONE;
+samsung_browser_fw_core::BookmarkItem
+ samsung_browser_fw_core::BookmarkItem::INVALID =
+ samsung_browser_fw_core::BookmarkItem(
+ samsung_browser_fw_core::BookmarkID::NONE);
}
namespace samsung_browser_main {
m_data_sync_controller->Init();
m_opened_tabs_controller =
std::make_unique<samsung_browser_controller::OpenedTabsController>();
+ m_bookmark_button_controller =
+ std::make_unique<samsung_browser_controller::BookmarkButtonController>();
+ m_bookmark_button_controller->Init();
m_initialized = true;
return true;
}
#include "base/observer_list.h"
#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/samsung/bookmark_button_controller.h"
#include "chrome/browser/ui/samsung/cursor_controller.h"
#include "chrome/browser/ui/samsung/data_sync_controller.h"
#include "chrome/browser/ui/samsung/high_contrast_controller.h"
return m_samsung_web_server_downloader.get();
}
+ samsung_browser_controller::BookmarkButtonController*
+ BookmarkButtonController() {
+ return m_bookmark_button_controller.get();
+ }
+
SamsungPass* GetSamsungPass() { return m_samsung_pass.get(); }
aura::WindowTreeHost* GetWindowInstance();
m_data_sync_controller;
std::unique_ptr<samsung_browser_controller::OpenedTabsController>
m_opened_tabs_controller;
+ std::unique_ptr<samsung_browser_controller::BookmarkButtonController>
+ m_bookmark_button_controller;
raw_ptr<samsung_account_manager::SamsungAccountManager>
m_samsung_account_manager;
std::unique_ptr<SamsungPass> m_samsung_pass;
namespace samsung_browser_fw_core {
ModelInfo StorageManager::ImageFeatured;
+ModelInfo StorageManager::BookmarkCloud;
+ModelInfo StorageManager::ImageBookmarkCloud;
StorageManager::StorageManager() : m_initialized(false) {}
LOG(INFO) << "Opened Tab Image Model Initialize Fail";
}
+ m_bookmarkModel =
+ std::make_unique<samsung_browser_storage::BPBookmarkModel>();
+ if (m_bookmarkModel) {
+ m_bookmarkModel->init();
+ LOG(INFO) << "Bookmark Model Initialized";
+ } else {
+ LOG(INFO) << "Bookmark Model Initialization Failed!!";
+ }
+
m_initialized = true;
return true;
}
return m_tabImageModel;
}
+std::shared_ptr<samsung_browser_storage::BPBookmarkModel>&
+StorageManager::bookmarkModel(samsung_browser_fw_core::ModelInfo mi) {
+ if (!m_bookmarkModel) {
+ m_bookmarkModel =
+ std::make_unique<samsung_browser_storage::BPBookmarkModel>();
+ m_bookmarkModel->init();
+ }
+ return m_bookmarkModel;
+}
+
+// std::unique_ptr<samsung_browser_storage::BPBookmarkImageModel>&
+// StorageManager::imageModel(samsung_browser_fw_core::ModelInfo mi) const
+// {
+// if(!m_imageModel){
+// m_imageModel =
+// std::make_unique<samsung_browser_storage::BPBookmarkImageModel>();
+// //m_imageModel -> init();
+// }
+// return m_imageModel;
+// }
+
} // namespace samsung_browser_fw_core
\ No newline at end of file
#ifndef CHROME_BROWSER_UI_SAMSUNG_STORAGE_MANAGER_H
#define CHROME_BROWSER_UI_SAMSUNG_STORAGE_MANAGER_H
+#include "components/samsung/bpbookmark_model/samsung_bpbookmark_model.h"
#include "components/samsung/opened_tabs/samsung_bpopened_tab_model.h"
#include "components/samsung/opened_tabs/samsung_bptab_image_model.h"
#include "components/samsung/public/samsung_enums.h"
std::unique_ptr<samsung_browser_storage::BPTabImageModel>& tabImageModel();
+ std::shared_ptr<samsung_browser_storage::BPBookmarkModel>& bookmarkModel(
+ samsung_browser_fw_core::ModelInfo mi);
+
+ // std::unique_ptr<samsung_browser_storage::BPBookmarkImageModel>&
+ // imageModel();
+
std::unique_ptr<samsung_browser_storage::BPOpenedTabModel> m_openedTabModel;
std::unique_ptr<samsung_browser_storage::BPTabImageModel> m_tabImageModel;
+ std::shared_ptr<samsung_browser_storage::BPBookmarkModel> m_bookmarkModel;
+
+ // std::unique_ptr<samsung_browser_storage::BPBookmarkImageModel>
+ // m_imageModel;
+
static ModelInfo ImageFeatured;
+ static ModelInfo BookmarkCloud;
+ static ModelInfo ImageBookmarkCloud;
bool m_initialized;
};
--- /dev/null
+source_set("bpbookmark_image_model") {
+ sources = [
+ "samsung_bpbookmark_image_model.cc",
+ "samsung_bpbookmark_image_model.h",
+ ]
+
+ deps = [
+ "//skia",
+ ]
+
+ public_deps = [ "//base", ]
+
+ configs += [
+ "//tizen_src/build:capi-cloud-bookmark",
+ "//tizen_src/build:libcapi-cloud-bookmark",
+ "//tizen_src/build:capi-media-image-util",
+ "//tizen_src/build:libcapi-media-image-util",
+ ]
+}
--- /dev/null
+#include "samsung_bpbookmark_image_model.h"
+#include "base/logging.h"
+#include "cloud_bookmark.h"
+
+namespace samsung_browser_storage {
+
+std::string BPBookmarkImageModel::sourceName = "BPBookmarkImageModel";
+
+namespace {
+
+struct CloudStruct {
+ CloudStruct(const samsung_browser_fw_core::BookmarkType type =
+ samsung_browser_fw_core::BookmarkType::AllBookmarks,
+ int parent_id = -1 /*main folder*/,
+ int limit = -1 /*no limits*/) {
+ memset(&properties, 0x00, sizeof(bp_bookmark_property_cond_fmt));
+ memset(&conds, 0x00, sizeof(bp_bookmark_rows_cond_fmt));
+ properties.parent = parent_id;
+ properties.type = 0;
+ switch (type) {
+ case samsung_browser_fw_core::BookmarkType::UserBookmark:
+ properties.is_operator = 0;
+ break;
+ case samsung_browser_fw_core::BookmarkType::DefaultBookmark:
+ properties.is_operator = 1;
+ break;
+ case samsung_browser_fw_core::BookmarkType::AllBookmarks:
+ properties.is_operator = -1;
+ break;
+ default:
+ break;
+ }
+ properties.is_editable = -1;
+ conds.limit = limit;
+ conds.offset = 0;
+ conds.ordering = 0;
+ }
+
+ bp_bookmark_property_cond_fmt properties;
+ bp_bookmark_rows_cond_fmt conds;
+};
+} // namespace
+
+BPBookmarkImageModel::BPBookmarkImageModel() : m_initialized(false) {
+ LOG(INFO) << "BPBookmarkImageModel Constructor called";
+}
+
+BPBookmarkImageModel::~BPBookmarkImageModel() {
+ LOG(INFO) << "BPBookmarkImageModel Destructor called";
+ if (m_initialized) {
+ deinit();
+ }
+}
+
+bool BPBookmarkImageModel::init() {
+ LOG(INFO) << "BPBookmarkImageModel init called";
+ m_initialized = true;
+ return true;
+}
+
+void BPBookmarkImageModel::deinit() {
+ m_initialized = false;
+}
+
+std::shared_ptr<samsung_browser_fw_core::Image> BPBookmarkImageModel::getImage(
+ const std::string& url,
+ samsung_browser_fw_core::Image::ImageType type,
+ const std::string& source) const {
+ LOG(INFO) << "BPBookmarImageModel::getImage";
+ std::shared_ptr<samsung_browser_fw_core::Image> image =
+ std::make_shared<samsung_browser_fw_core::Image>();
+
+ CloudStruct c_item;
+
+ int* ids = NULL;
+ int ids_count = -1;
+ int id = 0;
+ int length = 0;
+ unsigned char* value = NULL;
+ bookmark_cond_h cond = NULL;
+ if (bookmark_adaptor_cond_create(
+ &cond, c_item.properties.parent, c_item.properties.type,
+ c_item.properties.is_operator, c_item.properties.is_editable,
+ BOOKMARK_PROPERTY_URL, c_item.conds.ordering) != 0) {
+ LOG(WARNING) << "bookmark_adaptor_cond_create returned error";
+ return image;
+ }
+ if (bookmark_adaptor_get_id_list_by_cond_and_keyword(
+ &ids, &ids_count, -1, 0, cond, BOOKMARK_PROPERTY_URL, url.c_str(),
+ 0) != 0) {
+ LOG(WARNING) << "Cannot get cond ids";
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return image;
+ }
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(WARNING) << "bookmark_adaptor_cond_destroy returned error";
+ free(ids);
+ return image;
+ }
+ LOG(INFO) << "id count: " << ids_count;
+ if (ids_count <= 0 || !ids) {
+ LOG(WARNING) << "Didn't find id with this url";
+ return image;
+ }
+
+ id = ids[0];
+
+ if (type == samsung_browser_fw_core::Image::ImageType::Thumb) {
+ int width = 0;
+ int height = 0;
+ if (bookmark_adaptor_get_snapshot(id, &width, &height, &value, &length) !=
+ 0) {
+ LOG(WARNING) << "Cannot get snapshot";
+ free(ids);
+ return image;
+ }
+ } else if (type == samsung_browser_fw_core::Image::ImageType::Favicon) {
+ if (bookmark_adaptor_get_icon_png(id, &value, &length) != 0) {
+ LOG(WARNING) << "Cannot get icon";
+ free(ids);
+ return image;
+ }
+ }
+ if (value == NULL) {
+ free(ids);
+ return image;
+ }
+ image->data = malloc(length);
+ if (image->data)
+ memcpy(image->data, value, length);
+ else {
+ free(ids);
+ free(value);
+ return image;
+ }
+ image->dataSize = length;
+ image->type = type;
+ LOG(INFO) << "Freeing the image value";
+ free(value);
+ free(ids);
+ LOG(INFO) << "length " << length;
+ return image;
+}
+
+bool BPBookmarkImageModel::setImage(
+ const std::shared_ptr<samsung_browser_fw_core::Image> image,
+ const std::string& url,
+ const std::string& source) {
+ LOG(INFO) << "url: " << url;
+ int* ids = NULL;
+ int ids_count = -1;
+ CloudStruct c_item;
+ bookmark_cond_h cond = NULL;
+
+ if (bookmark_adaptor_cond_create(
+ &cond, c_item.properties.parent, c_item.properties.type,
+ c_item.properties.is_operator, c_item.properties.is_editable,
+ BOOKMARK_PROPERTY_URL, c_item.conds.ordering) != 0) {
+ LOG(WARNING) << "bookmark_adaptor_cond_create returned error";
+ return false;
+ }
+ if (bookmark_adaptor_get_id_list_by_cond_and_keyword(
+ &ids, &ids_count, -1, 0, cond, BOOKMARK_PROPERTY_URL, url.c_str(),
+ 0) != 0) {
+ LOG(WARNING) << "Cannot get cond ids";
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return false;
+ }
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(WARNING) << "bookmark_adaptor_cond_destroy returned error";
+ free(ids);
+ return false;
+ }
+ LOG(INFO) << "ID Count: " << ids_count;
+ if (ids_count <= 0 || !ids) {
+ LOG(WARNING) << "Didn't find id with this url";
+ return false;
+ }
+
+ void* blobImage;
+ int blobImageLength = 0;
+ if (image->isCompressed) {
+ blobImageLength = image->dataSize;
+ blobImage = malloc(blobImageLength);
+ if (blobImage)
+ memcpy(blobImage, image->data, blobImageLength);
+ else {
+ free(ids);
+ return false;
+ }
+ } else {
+ switch (image->type) {
+ case samsung_browser_fw_core::Image::ImageType::Favicon:
+ blobImage = samsung_browser_fw_core::ImageTools::pngCompressImage(
+ image->width, image->height, image->stride, image->data,
+ &blobImageLength);
+ break;
+
+ case samsung_browser_fw_core::Image::ImageType::Thumb:
+ blobImage = samsung_browser_fw_core::ImageTools::jpegCompressImage(
+ image->width, image->height, image->stride, image->data,
+ &blobImageLength);
+ break;
+ case samsung_browser_fw_core::Image::ImageType::UserIcon:
+ default:
+ LOG(WARNING) << "Wrong ImageType to save to DB. ImageType = ";
+ free(ids);
+ return false;
+ }
+ }
+
+ if (image->type == samsung_browser_fw_core::Image::ImageType::Favicon) {
+ for (int i = 0; i < ids_count; ++i) {
+ if (bookmark_adaptor_set_icon_png(
+ ids[i], static_cast<const unsigned char*>(blobImage)) != 0) {
+ LOG(WARNING) << "Cannot set icon";
+ }
+ }
+ } else if (image->type == samsung_browser_fw_core::Image::ImageType::Thumb) {
+ for (int i = 0; i < ids_count; ++i) {
+ if (bookmark_adaptor_set_snapshot(
+ ids[i], image->width, image->height,
+ static_cast<const unsigned char*>(blobImage),
+ image->dataSize) != 0) {
+ LOG(WARNING) << "Cannot set snapshot";
+ }
+ }
+ }
+ free(ids);
+ free(blobImage);
+ return true;
+}
+
+bool BPBookmarkImageModel::removeImage(
+ const std::string& url,
+ samsung_browser_fw_core::Image::ImageType type,
+ const std::string& source) {
+ LOG(WARNING) << "removeImage";
+ CloudStruct c_item;
+
+ int* ids = NULL;
+ int ids_count = -1;
+ int id;
+ const unsigned char* emptyImage = nullptr;
+ bookmark_cond_h cond = NULL;
+ if (bookmark_adaptor_cond_create(
+ &cond, c_item.properties.parent, c_item.properties.type,
+ c_item.properties.is_operator, c_item.properties.is_editable,
+ BOOKMARK_PROPERTY_URL, c_item.conds.ordering) != 0) {
+ LOG(WARNING) << "bookmark_adaptor_cond_create returned error";
+ return false;
+ }
+ if (bookmark_adaptor_get_id_list_by_cond_and_keyword(
+ &ids, &ids_count, -1, 0, cond, BOOKMARK_PROPERTY_URL, url.c_str(),
+ 0) != 0) {
+ LOG(WARNING) << "Cannot get cond ids";
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return false;
+ }
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(WARNING) << "bookmark_adaptor_cond_destroy returned error";
+ free(ids);
+ return false;
+ }
+ if (ids_count <= 0 || !ids) {
+ LOG(WARNING) << "Didn't find id with this url";
+ return false;
+ }
+
+ id = ids[0];
+ if (type == samsung_browser_fw_core::Image::ImageType::Favicon) {
+ if (bookmark_adaptor_set_icon_png(id, emptyImage) != 0) {
+ LOG(WARNING) << "Cannot set icon";
+ free(ids);
+ return false;
+ }
+ } else if (type == samsung_browser_fw_core::Image::ImageType::Thumb) {
+ if (bookmark_adaptor_set_snapshot(id, 0, 0, emptyImage, 0) != 0) {
+ LOG(WARNING) << "Cannot set snapshot";
+ free(ids);
+ return false;
+ }
+ }
+ free(ids);
+ return true;
+}
+
+bool BPBookmarkImageModel::removeUnlinkedAccounts(
+ const std::vector<std::string>& linkedAccounts) {
+ LOG(WARNING) << "removeUnlinkedAccounts";
+ return true;
+}
+void BPBookmarkImageModel::cleanUp(
+ const std::vector<samsung_browser_fw_core::HistoryItem>& historyItems) {
+ LOG(WARNING) << "Not implemented";
+}
+
+bool BPBookmarkImageModel::removeAllImages(
+ samsung_browser_fw_core::Image::ImageType type,
+ const std::string& source) {
+ LOG(WARNING) << "removeAllImages";
+ int* ids = NULL;
+ int ids_count = -1;
+ const unsigned char* emptyImage = nullptr;
+ bookmark_cond_h cond = NULL;
+ if (bookmark_adaptor_cond_create(&cond, -1, -1, 0, 1,
+ BOOKMARK_PROPERTY_DATE_CREATED, 0) != 0) {
+ LOG(WARNING) << "bookmark_adaptor_cond_create returned error";
+ return false;
+ }
+ if (bookmark_adaptor_get_id_list_by_cond(&ids, &ids_count, -1, 0, cond) !=
+ 0) {
+ LOG(WARNING) << "Cannot get ids";
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return false;
+ }
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(WARNING) << "bookmark_adaptor_cond_destroy returned error";
+ free(ids);
+ return false;
+ }
+ if (ids_count <= 0 || !ids) {
+ LOG(WARNING) << "Didn't find id with this url";
+ return false;
+ }
+ for (int i = 0; i < ids_count; ++i) {
+ if (type == samsung_browser_fw_core::Image::ImageType::Favicon) {
+ if (bookmark_adaptor_set_icon_png(ids[i], emptyImage) != 0) {
+ LOG(WARNING) << "Cannot set icon";
+ free(ids);
+ return false;
+ }
+ } else if (type == samsung_browser_fw_core::Image::ImageType::Thumb) {
+ if (bookmark_adaptor_set_snapshot(ids[i], 0, 0, emptyImage, 0) != 0) {
+ LOG(WARNING) << "Cannot set snapshot";
+ free(ids);
+ return false;
+ }
+ }
+ }
+ free(ids);
+ return true;
+}
+} // namespace samsung_browser_storage
--- /dev/null
+#ifndef BPBookmarkImageModel_h
+#define BPBookmarkImageModel_h
+
+// #include <cloud_bookmark.h>
+#include <vector>
+
+#include "components/samsung/public/samsung_enums.h"
+#include "components/samsung/public/samsung_iimage_model.h"
+#include "components/samsung/public/samsung_image_tools.h"
+
+namespace samsung_browser_storage {
+typedef unsigned int bp_bookmark_offset;
+
+typedef struct {
+ int type; /**< Type @c 0: bookmark @c 1: folder */
+ int parent; /**< Parent ID */
+ int sequence; /**< The index of ordering */
+ int editable; /**< Is editable @c 0: editable, @c 1: read only */
+ int is_operator; /**< Is made by the operator, @c 0: made by the user @c 1: by
+ the operator */
+ int access_count; /**< Frequency of use */
+ int date_created; /**< Ignore this variable by setting it to zero */
+ int date_modified; /**< Ignore this variable by setting it to zero */
+ int date_visited; /**< Ignore this variable by setting it to zero */
+ int favicon_length; /**< Ignore this favicon by setting it to zero */
+ int favicon_width; /**< Favicon image's width. Ignore this variable by setting
+ it to zero */
+ int favicon_height; /**< Favicon image's height. Ignore this variable by
+ setting it to zero */
+ int thumbnail_length; /**< Ignore this thumbnail by setting it to zero */
+ int thumbnail_width; /**< Thumbnail image's width. Ignore this variable by
+ setting it to zero */
+ int thumbnail_height; /**< Thumbnail image's height. Ignore this variable by
+ setting it to zero */
+ int webicon_length; /**< Ignore this webicon by setting it to zero */
+ int webicon_width; /**< Web icon image's width. Ignore this variable by
+ setting it to zero */
+ int webicon_height; /**< Web icon image's height. Ignore this variable by
+ setting it to zero */
+ char* url; /**< Address of the bookmark. @c NULL if the type is folder */
+ char* title; /**< Title of the bookmark or folder */
+ char* account_name; /**< Account name for bookmark cloud sync */
+ char* account_type; /**< Acount type for bookmark cloud sync */
+ char* device_name; /**< Device name of cloud sync from which the bookmark
+ originated */
+ char* device_id; /**< Device ID of cloud sync from which the bookmark
+ originated */
+ unsigned char* favicon; /**< Raw data of the icon ( favorites icon ) */
+ unsigned char* thumbnail; /**< Raw data of the snapshot */
+ unsigned char* webicon; /**< Raw data of the webicon */
+ int tag_count; /**< Deprecated */
+ void* tags; /**< Deprecated */
+ char* sync; /**< Extra property to sync */
+ char* parent_sync; /**< Sync id of parent*/
+} bp_bookmark_info_fmt;
+
+/**
+ * * @brief The structure type that includes the basic conditions of the
+ * bookmark.
+ * * @since_tizen 2.3
+ * */
+typedef struct {
+ int parent; /**< Parent ID */
+ int type; /**< Type @c 0: bookmark @c 1: folder */
+ int is_operator; /**< Is made by the operator, @c 0: made by the user @c 1: by
+ the operator */
+ int is_editable; /**< Is editable @c 0: editable, @c 1: read only */
+} bp_bookmark_property_cond_fmt;
+
+/**
+ * * @brief The structure type that includes some conditions that are related
+ * to the period, the ordering, and the number of searched rows.
+ * * @since_tizen 2.3
+ * * @remarks The default offset is #BP_BOOKMARK_O_DATE_CREATED.
+ * */
+typedef struct {
+ int limit; /**< The maximum number of rows to get, negative means no
+ limitation */
+ int offset; /**< Starting index to get among entire rows */
+ int ordering; /**< The way of ordering, @c 0: ASC(default) @c 1: DESC */
+} bp_bookmark_rows_cond_fmt;
+
+class BPBookmarkImageModel : public samsung_browser_fw_core::IImageModel {
+ public:
+ /**
+ * @brief
+ *
+ * @fn BPBookmarkImageModel
+ */
+ BPBookmarkImageModel();
+ /**
+ * @brief
+ *
+ * @fn ~BPBookmarkImageModel
+ */
+ virtual ~BPBookmarkImageModel();
+ /**
+ * @brief
+ *
+ * @fn init
+ * @return bool
+ */
+ bool init() override;
+ void deinit() override;
+
+ /**
+ * @brief
+ *
+ * @fn getImage
+ * @param url
+ * @param type
+ * @param source
+ * @return std::shared_ptr<samsung_browser_fw_core::Image>
+ */
+ std::shared_ptr<samsung_browser_fw_core::Image> getImage(
+ const std::string& url,
+ samsung_browser_fw_core::Image::ImageType type,
+ const std::string& source) const override;
+ /**
+ * @brief
+ *
+ * @fn setImage
+ * @param thumb
+ * @param url
+ * @param source
+ * @return bool
+ */
+ bool setImage(const std::shared_ptr<samsung_browser_fw_core::Image> image,
+ const std::string& url,
+ const std::string& source) override;
+ /**
+ * @brief
+ *
+ * @fn removeImage
+ * @param url
+ * @param type
+ * @param source
+ * @return bool
+ */
+ bool removeImage(const std::string& url,
+ samsung_browser_fw_core::Image::ImageType type,
+ const std::string& source) override;
+ bool removeUnlinkedAccounts(
+ const std::vector<std::string>& linkedAccounts) override;
+ /**
+ * @brief
+ *
+ * @fn cleanUp
+ * @param HistoryType
+ * @param source
+ */
+ void cleanUp(const std::vector<samsung_browser_fw_core::HistoryItem>&
+ historyItems) override;
+ /**
+ * @brief
+ *
+ * @fn removeAllImages
+ * @param type
+ * @param source
+ * @return bool
+ */
+ bool removeAllImages(samsung_browser_fw_core::Image::ImageType type,
+ const std::string& source) override;
+ /**
+ * @brief
+ *
+ * @var sourceName
+ */
+ static std::string sourceName;
+ bool m_initialized;
+
+ private:
+};
+
+} // namespace samsung_browser_storage
+
+#endif // BPBookmarkImageModel_h
--- /dev/null
+source_set("bpbookmark_model") {
+ sources = [
+ "samsung_bookmark_id.h",
+ "samsung_bookmark_item.h",
+ "samsung_bookmark_item.cc",
+ "samsung_bookmark_model_common.h",
+ "samsung_bpbookmark_model.cc",
+ "samsung_bpbookmark_model.h",
+ "samsung_ibookmark_model.h",
+ "samsung_id_store.h",
+ ]
+
+ deps = [
+ "//skia",
+ ]
+
+ public_deps = [ "//base"]
+
+ configs += [
+ "//tizen_src/build:capi-cloud-bookmark",
+ "//tizen_src/build:libcapi-cloud-bookmark",
+ "//tizen_src/build:capi-media-image-util",
+ "//tizen_src/build:libcapi-media-image-util",
+ ]
+}
--- /dev/null
+
+#ifndef BookmarkID_h
+#define BookmarkID_h
+
+#include "components/samsung/public/samsung_abstract_id.h"
+
+namespace samsung_browser_fw_core {
+
+/**
+ * @brief
+ *
+ * @class BookmarkID BookmarkID.h "include/BookmarkID.h"
+ */
+class BookmarkID : public SamsungAbstractID {
+ public:
+ BookmarkID() : SamsungAbstractID() {}
+ /**
+ * @brief
+ *
+ * @fn BookmarkID
+ * @param str
+ */
+ explicit BookmarkID(const std::string& str) : SamsungAbstractID(str) {}
+
+ static BookmarkID NONE;
+};
+
+} // namespace samsung_browser_fw_core
+#endif // BookmarkID_h
--- /dev/null
+#include <chrono>
+#include <ctime>
+#include "components/samsung/bpbookmark_model/samsung_bpbookmark_model.h"
+
+namespace samsung_browser_fw_core {
+
+BookmarkItem::BookmarkItem()
+ : m_id(),
+ m_creationTime(std::chrono::system_clock::now()),
+ m_accessTime(std::chrono::system_clock::now()),
+ m_type(BookmarkType::UserBookmark),
+ m_itemType(BookmarkItemType::Bookmark),
+ m_parentID(samsung_browser_fw_core::BookmarkID::NONE) {}
+
+BookmarkItem::BookmarkItem(BookmarkID id)
+ : m_id(id),
+ m_creationTime(std::chrono::system_clock::now()),
+ m_accessTime(std::chrono::system_clock::now()),
+ m_type(BookmarkType::UserBookmark),
+ m_itemType(BookmarkItemType::Bookmark),
+ m_parentID(samsung_browser_fw_core::BookmarkID::NONE) {}
+
+BookmarkItem::~BookmarkItem() {}
+
+BookmarkItem& BookmarkItem::operator=(const BookmarkItem& other) {
+ if (this != &other) {
+ m_id = other.m_id;
+ m_url = other.m_url;
+ m_title = other.m_title;
+ m_creationTime = other.m_creationTime;
+ m_accessTime = other.m_creationTime;
+ m_sourceName = other.m_sourceName;
+ m_type = other.m_type;
+ m_itemType = other.m_itemType;
+ m_parentID = other.m_parentID;
+ }
+
+ return *this;
+}
+
+BookmarkItem::BookmarkItem(const std::string& url,
+ const std::string& title,
+ const std::string& source,
+ BookmarkType type,
+ BookmarkItemType itemType,
+ const std::string& parentID)
+ : m_id(),
+ m_url(url),
+ m_title(title),
+ m_creationTime(std::chrono::system_clock::now()),
+ m_accessTime(std::chrono::system_clock::now()),
+ m_sourceName(source),
+ m_type(type),
+ m_itemType(itemType),
+ m_parentID(parentID.empty() ? BookmarkID::NONE : BookmarkID(parentID)) {}
+
+BookmarkItem::BookmarkItem(const std::string& id,
+ const std::string& url,
+ const std::string& title,
+ const std::string& source,
+ BookmarkType type,
+ BookmarkItemType itemType,
+ const std::string& parentID)
+ : m_id(id),
+ m_url(url),
+ m_title(title),
+ m_creationTime(std::chrono::system_clock::now()),
+ m_accessTime(std::chrono::system_clock::now()),
+ m_sourceName(source),
+ m_type(type),
+ m_itemType(itemType),
+ m_parentID(parentID.empty() ? BookmarkID::NONE : BookmarkID(parentID)) {}
+
+BookmarkItem::BookmarkItem(const BookmarkItem& bi)
+ : m_id(bi.m_id),
+ m_url(bi.m_url),
+ m_title(bi.m_title),
+ m_creationTime(bi.m_creationTime),
+ m_accessTime(bi.m_accessTime),
+ m_sourceName(bi.m_sourceName),
+ m_type(bi.m_type),
+ m_itemType(bi.m_itemType),
+ m_parentID(bi.m_parentID) {}
+
+bool BookmarkItem::operator==(const BookmarkItem& other) const {
+ return m_id == other.m_id;
+}
+
+bool BookmarkItem::operator!=(const BookmarkItem& other) const {
+ return m_id != other.m_id;
+}
+
+} // namespace samsung_browser_fw_core
--- /dev/null
+
+#ifndef BookmarkItem_h
+#define BookmarkItem_h
+
+#include "components/samsung/bpbookmark_model/samsung_bookmark_id.h"
+#include "components/samsung/public/samsung_enums.h"
+
+#include <chrono>
+#include <ctime>
+
+namespace samsung_browser_fw_core {
+
+/**
+ * @brief
+ *
+ * @class BookmarkItem BookmarkItem.h "include/BookmarkItem.h"
+ */
+class BookmarkItem {
+ public:
+ /**
+ * @brief
+ *
+ * @fn BookmarkItem
+ */
+ BookmarkItem();
+
+ explicit BookmarkItem(BookmarkID);
+ /**
+ * @brief
+ *
+ * @fn BookmarkItem
+ * @param id
+ * @param url
+ * @param title
+ * @param source
+ * @param type
+ * @param itemType
+ * @param parent_id
+ */
+ BookmarkItem(const std::string& id,
+ const std::string& url,
+ const std::string& title,
+ const std::string& source,
+ BookmarkType type = BookmarkType::UserBookmark,
+ BookmarkItemType itemType = BookmarkItemType::Bookmark,
+ const std::string& parentID = "");
+ /**
+ * @brief
+ *
+ * @fn BookmarkItem
+ * @param url
+ * @param title
+ * @param source
+ * @param type
+ * @param itemType
+ * @param parent_id
+ */
+ BookmarkItem(const std::string& url,
+ const std::string& title,
+ const std::string& source,
+ BookmarkType type = BookmarkType::UserBookmark,
+ BookmarkItemType itemType = BookmarkItemType::Bookmark,
+ const std::string& parentID = "");
+ /**
+ * @brief
+ *
+ * @fn BookmarkItem
+ * @param
+ */
+ BookmarkItem(const BookmarkItem&);
+
+ /**
+ * @brief
+ *
+ * @fn ~BookmarkItem
+ */
+ virtual ~BookmarkItem();
+ /**
+ * @brief
+ *
+ * @fn operator =
+ * @param
+ * @return BookmarkItem &operator
+ */
+ virtual BookmarkItem& operator=(const BookmarkItem&);
+ /**
+ * @brief
+ *
+ * @fn operator ==
+ * @param other
+ * @return bool operator
+ */
+ virtual bool operator==(const BookmarkItem& other) const;
+ /**
+ * @brief
+ *
+ * @fn operator !=
+ * @param other
+ * @return bool operator
+ */
+ virtual bool operator!=(const BookmarkItem& other) const;
+
+ /**
+ * @brief
+ *
+ * @fn setID
+ * @param id
+ */
+ virtual void setID(BookmarkID id) { m_id = id; }
+ /**
+ * @brief
+ *
+ * @fn getID
+ * @return BookmarkID
+ */
+ virtual BookmarkID getID() const { return m_id; }
+ /**
+ * @brief
+ *
+ * @fn setURL
+ * @param url
+ */
+ virtual void setURL(const std::string& url) { m_url = url; }
+ /**
+ * @brief
+ *
+ * @fn getURL
+ * @return URIString
+ */
+ virtual std::string getURL() const { return m_url; }
+
+ /**
+ * @brief
+ *
+ * @fn setTitle
+ * @param title
+ */
+ virtual void setTitle(const std::string& title) { m_title = title; }
+ /**
+ * @brief
+ *
+ * @fn getTitle
+ * @return std::string
+ */
+ virtual std::string getTitle() const { return m_title; }
+ /**
+ * @brief
+ *
+ * @fn getID
+ * @return BookmarkID
+ */
+ virtual BookmarkID getParentID() const { return m_parentID; }
+ /**
+ * @brief
+ *
+ * @fn setCreationTime
+ * @param t
+ */
+ virtual void setCreationTime(
+ std::chrono::time_point<std::chrono::system_clock> t) {
+ m_creationTime = t;
+ }
+ /**
+ * @brief
+ *
+ * @fn getCreationTime
+ * @return std::chrono::time_point<std::chrono::system_clock>
+ */
+ virtual std::chrono::time_point<std::chrono::system_clock> getCreationTime()
+ const {
+ return m_creationTime;
+ }
+
+ /**
+ * @brief
+ *
+ * @fn setAccessTime
+ * @param t
+ */
+ virtual void setAccessTime(
+ std::chrono::time_point<std::chrono::system_clock> t) {
+ m_accessTime = t;
+ }
+ /**
+ * @brief
+ *
+ * @fn getAccessTime
+ * @return std::chrono::time_point<std::chrono::system_clock>
+ */
+ virtual std::chrono::time_point<std::chrono::system_clock> getAccessTime()
+ const {
+ return m_accessTime;
+ }
+
+ /**
+ * @brief
+ *
+ * @fn setSourceName
+ * @param src
+ */
+ virtual void setSourceName(const std::string& src) { m_sourceName = src; }
+ /**
+ * @brief
+ *
+ * @fn getSourceName
+ * @return std::string
+ */
+ virtual std::string getSourceName() const { return m_sourceName; }
+
+ /**
+ * @brief
+ *
+ * @fn setType
+ * @param type
+ */
+ virtual void setType(BookmarkType type) { m_type = type; }
+ /**
+ * @brief
+ *
+ * @fn getType
+ * @return BookmarkType
+ */
+ virtual BookmarkType getType() const { return m_type; }
+
+ /**
+ * @brief this function gets itemType current bookmark,
+ * whether it's a folder or bookmark
+ *
+ * @fn getItemType
+ * @return BookmarkItemType
+ */
+ virtual BookmarkItemType getItemType() const { return m_itemType; }
+
+ /**
+ * @brief
+ *
+ * @var INVALID
+ */
+ static BookmarkItem INVALID;
+
+ private:
+ /**
+ * @brief
+ *
+ * @var m_id
+ */
+ BookmarkID m_id;
+ /**
+ * @brief
+ *
+ * @var m_url
+ */
+ std::string m_url;
+ /**
+ * @brief
+ *
+ * @var m_title
+ */
+ std::string m_title;
+ /**
+ * @brief
+ *
+ * @var m_creationTime
+ */
+ std::chrono::time_point<std::chrono::system_clock> m_creationTime;
+ /**
+ * @brief
+ *
+ * @var m_accessTime
+ */
+ std::chrono::time_point<std::chrono::system_clock> m_accessTime;
+ /**
+ * @brief
+ *
+ * @var m_sourceName
+ */
+ std::string m_sourceName;
+ /**
+ * @brief
+ *
+ * @var m_type
+ */
+ BookmarkType m_type;
+ /**
+ * @brief
+ *
+ * @var m_itemType
+ */
+ BookmarkItemType m_itemType;
+ /**
+ * @brief
+ *
+ * @var m_parentID
+ */
+ BookmarkID m_parentID;
+};
+
+} // namespace samsung_browser_fw_core
+#endif // BookmarkItem_h
--- /dev/null
+// #ifndef BookmarkModelCommon_h
+// #define BookmarkModelCommon_h
+
+// #include "samsung_ibookmark_model.h"
+
+// #include <Ecore.h>
+
+// namespace BrowserStorage
+// {
+
+// class BookmarkSigData
+// {
+// public:
+// enum class SigType
+// {
+// BookmarkAdded,
+// BookmarkRemoved,
+// BookmarkChanged,
+// AllBookmarksRemoved
+// };
+// BookmarkSigData(BrowserFWCore::IBookmarkModel* s, SigType t, const
+// BrowserFWCore::BookmarkItem& i) : self(s) , notificationType(t) , item(i) { }
+// BookmarkSigData(BrowserFWCore::IBookmarkModel* s, SigType t, const
+// BrowserFWCore::BookmarkType& ht) : self(s) , notificationType(t) , type(ht)
+// { }
+
+// samsung_browser_fw_core::IBookmarkModel* self;
+// SigType notificationType;
+// samsung_browser_fw_core::BookmarkItem item;
+// samsung_browser_fw_core::BookmarkType type;
+// static void notify(void* data);
+// };
+
+// // inline void sendSignal(BookmarkSigData* n)
+// // {
+// // BROWSER_LOGD("");
+// // ecore_main_loop_thread_safe_call_async(BookmarkSigData::notify, n);
+// // BROWSER_LOGD("");
+// // }
+// } // BrowserStorage
+
+// #endif // BookmarkModelCommon_h
--- /dev/null
+#include "samsung_bpbookmark_model.h"
+#include <cloud_bookmark.h>
+
+#include <string.h>
+#include "base/logging.h"
+
+namespace samsung_browser_storage {
+
+std::string BPBookmarkModel::sourceName = "BrowserProviderBookmarks";
+constexpr int syncedBookmarksLimitPerFolder =
+ 100; // Number of bookmarks per folder displayed to user.
+
+namespace {
+
+struct CloudStruct {
+ CloudStruct(const samsung_browser_fw_core::BookmarkType type =
+ samsung_browser_fw_core::BookmarkType::AllBookmarks,
+ int parent_id = -1 /*main folder*/,
+ int limit = -1 /*no limits*/) {
+ memset(&properties, 0x00, sizeof(bp_bookmark_property_cond_fmt));
+ memset(&conds, 0x00, sizeof(bp_bookmark_rows_cond_fmt));
+ properties.parent = parent_id;
+ properties.type = 0;
+ switch (type) {
+ case samsung_browser_fw_core::BookmarkType::UserBookmark:
+ properties.is_operator = 0;
+ break;
+ case samsung_browser_fw_core::BookmarkType::DefaultBookmark:
+ properties.is_operator = 1;
+ break;
+ case samsung_browser_fw_core::BookmarkType::AllBookmarks:
+ properties.is_operator = -1;
+ break;
+ default:
+ break;
+ }
+ properties.is_editable = -1;
+ conds.limit = limit;
+ conds.offset = 0;
+ conds.ordering = 0;
+ }
+
+ bp_bookmark_property_cond_fmt properties;
+ bp_bookmark_rows_cond_fmt conds;
+};
+} // namespace
+
+BPBookmarkModel::BPBookmarkModel()
+ : m_BookmarkAdaptorInitialized(false),
+ m_shouldSendRefreshSignal(false),
+ m_initialized(false) {
+ LOG(INFO) << "BPBookmarkModel Constructor Called";
+}
+
+BPBookmarkModel::~BPBookmarkModel() {
+ LOG(INFO) << "BPBookmarkModel Destructor called";
+ if (m_initialized) {
+ deinit();
+ }
+}
+
+bool BPBookmarkModel::init() {
+ LOG(INFO) << "BPBookmarkModel init";
+ m_initialized = true;
+ return true;
+}
+
+void BPBookmarkModel::initializeBookMarkAdaptor() {
+ LOG(INFO) << "initializeBookMarkAdaptor";
+ int errorcode = 0;
+ if (m_BookmarkAdaptorInitialized) {
+ LOG(INFO) << "Bookmark Adaptor already initialized";
+ return;
+ }
+ errorcode = bookmark_adaptor_initialize();
+ if (errorcode != 0) {
+ LOG(ERROR) << "Failed to initialize Bookmark Adaptor. Error: " << errorcode;
+ return;
+ }
+
+ if (bookmark_adaptor_set_data_changed_cb(
+ &BPBookmarkModel::dataChangedCallback, this) != 0) {
+ LOG(ERROR) << "Failed to register Bookmark Adaptor data changed cb";
+ if (bookmark_adaptor_deinitialize() != 0) {
+ LOG(ERROR) << "Failed to deinitialize Bookmark Adaptor";
+ }
+ return;
+ }
+ m_BookmarkAdaptorInitialized = true;
+ LOG(INFO) << "Bookmark Adaptor Initialized";
+}
+
+void BPBookmarkModel::deinit() {
+ LOG(INFO) << "BPBookmarkModel deinit called";
+ if (m_BookmarkAdaptorInitialized) {
+ if (bookmark_adaptor_unset_data_changed_cb(
+ &BPBookmarkModel::dataChangedCallback) != 0) {
+ LOG(ERROR) << "Failed to unregister Bookmark Adaptor data changed cb";
+ }
+
+ if (bookmark_adaptor_deinitialize() != 0) {
+ LOG(ERROR) << "Failed to deinitialize bookmark adaptor";
+ }
+ m_BookmarkAdaptorInitialized = false;
+ }
+ m_initialized = false;
+}
+
+void BPBookmarkModel::bookmarkInfoFree(bp_bookmark_info_fmt* info) {
+ LOG(INFO) << "BPBookmarkModel bookmarkInfoFree called";
+ if (info != NULL) {
+ free(info->url);
+ free(info->title);
+ free(info->account_name);
+ free(info->account_type);
+ free(info->device_name);
+ free(info->device_id);
+ free(info->favicon);
+ free(info->thumbnail);
+ free(info->webicon);
+ free(info->sync);
+ free(info->tags);
+ free(info->parent_sync);
+ memset(info, 0x00, sizeof(bp_bookmark_info_fmt));
+ }
+}
+
+void BPBookmarkModel::dataChangedCallback(void* data) {
+ LOG(INFO) << "BPBookmarkModel dataChangedCallback called";
+
+ BPBookmarkModel* ptr = static_cast<BPBookmarkModel*>(data);
+ ptr->dataChanged();
+}
+
+void BPBookmarkModel::dataChanged() {
+ LOG(INFO) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ // TODO: convert to FireWebUIListener() call
+ // ecore_main_loop_thread_safe_call_async(BPBookmarkModel::notify, this);
+}
+
+// void BPBookmarkModel::notify(void* data)
+// {
+// BROWSER_LOGD("");
+// BPBookmarkModel* n = static_cast<BPBookmarkModel*>(data);
+// if (!n)
+// {
+// BROWSER_LOGW("empty self");
+// return;
+// }
+// if (BrowserMain::BrowserCore::isTerminated())
+// {
+// return;
+// }
+// n->m_shouldSendRefreshSignal = true;
+// if((!n->m_refreshIntervalTimer) &&
+// BrowserMain::BrowserCore::instance()->getState() ==
+// BrowserMain::BrowserCore::BrowserState::Running)
+// {
+// n->refreshIntervalCallback(n);
+// }
+// }
+
+// Eina_Bool BPBookmarkModel::refreshIntervalCallback(void* data)
+// {
+// BROWSER_LOGD("");
+// BPBookmarkModel* self = static_cast<BPBookmarkModel*>(data);
+// if (!self)
+// {
+// BROWSER_LOGW("empty self");
+// return ECORE_CALLBACK_CANCEL;
+// }
+// if (BrowserMain::BrowserCore::isTerminated())
+// {
+// return ECORE_CALLBACK_CANCEL;
+// }
+// BROWSER_LOGD("m_shouldSendRefreshSignal [%d], m_refreshIntervalTimer
+// [%p]", self->m_shouldSendRefreshSignal, self->m_refreshIntervalTimer);
+// if(self->m_refreshIntervalTimer)
+// {
+// ecore_timer_del(self->m_refreshIntervalTimer);
+// self->m_refreshIntervalTimer = nullptr;
+// }
+// if(self->m_shouldSendRefreshSignal)
+// {
+// self->m_shouldSendRefreshSignal = false;
+// self->bookmarkChanged(samsung_browser_fw_core::BookmarkItem::INVALID);
+// self->m_refreshIntervalTimer = ecore_timer_add(10.0f,
+// self->refreshIntervalCallback, self); BROWSER_LOGD("m_refreshIntervalTimer
+// [%p]", self->m_refreshIntervalTimer); return ECORE_CALLBACK_CANCEL;
+// }
+// BROWSER_LOGD("");
+// return ECORE_CALLBACK_CANCEL;
+// }
+
+// void
+// BPBookmarkModel::browserStateChanged(BrowserMain::BrowserCore::BrowserState
+// s)
+// {
+// BROWSER_LOGD("state=%d", s);
+// if(s == BrowserMain::BrowserCore::BrowserState::Paused)
+// {
+// m_shouldSendRefreshSignal = false;
+// if(m_refreshIntervalTimer)
+// {
+// ecore_timer_del(m_refreshIntervalTimer);
+// m_refreshIntervalTimer = nullptr;
+// }
+// }
+// else if(s == BrowserMain::BrowserCore::BrowserState::Terminated)
+// {
+// BrowserMain::BrowserCore::instance()->browserStateChanged.disconnect(boost::bind(&BPBookmarkModel::browserStateChanged,
+// this, _1));
+// }
+// }
+
+bool BPBookmarkModel::add(samsung_browser_fw_core::BookmarkItem& item) {
+ LOG(INFO) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ int id = m_idStore.find(item.getID());
+ bool isNewItem = (id == -1);
+ int parent_id = m_idStore.find(item.getParentID());
+
+ LOG(INFO) << "info.title = " << item.getTitle().c_str();
+ LOG(INFO) << "info.url = " << item.getURL().c_str();
+ // LOG(INFO) << "type = " << item.getItemType().to_string();
+ LOG(INFO) << "AccountName = " << getAccountName().c_str();
+ LOG(INFO) << "parent_id = " << parent_id;
+
+ bookmark_info_h handle = NULL;
+ if (bookmark_adaptor_info_create(&handle) != 0) {
+ LOG(INFO) << "SRPH bookmark_adaptor_info_create returned error";
+ return false;
+ }
+
+ if (item.getItemType() != samsung_browser_fw_core::BookmarkItemType::Folder) {
+ LOG(INFO) << "SRPH setting url!";
+ if (bookmark_adaptor_info_set_url(handle, item.getURL().c_str()) != 0) {
+ LOG(INFO) << "SRPH Cannot set url in bookmark on cloud";
+ bookmark_adaptor_info_destroy(handle);
+ return false;
+ }
+ } else {
+ LOG(INFO) << "SRPH not setting url.";
+ }
+
+ if (bookmark_adaptor_info_set_title(handle, item.getTitle().c_str()) != 0) {
+ LOG(INFO) << "SRPH Cannot set title in bookmark on cloud";
+ bookmark_adaptor_info_destroy(handle);
+ return false;
+ }
+
+ if (bookmark_adaptor_info_set_type(handle, (int)item.getItemType()) != 0) {
+ LOG(INFO) << "SRPH Cannot set type in bookmark on cloud";
+ bookmark_adaptor_info_destroy(handle);
+ return false;
+ }
+
+ if (parent_id >= 0) {
+ if (bookmark_adaptor_info_set_parent_id(handle, parent_id) != 0) {
+ LOG(INFO) << "SRPH Cannot set parent in bookmark on cloud";
+ bookmark_adaptor_info_destroy(handle);
+ return false;
+ }
+ }
+ // only if account is set (for UT)
+ if (getAccountName().size()) {
+ if (bookmark_adaptor_info_set_account_name(handle,
+ getAccountName().c_str()) != 0) {
+ LOG(INFO) << "SRPH Cannot set account in bookmark on cloud";
+ bookmark_adaptor_info_destroy(handle);
+ return false;
+ }
+ }
+
+ if (bookmark_adaptor_info_add_to_db(&id, handle) != 0) {
+ LOG(INFO) << "SRPH bookmark_adaptor_info_add_to_db returned error";
+ bookmark_adaptor_info_destroy(handle);
+ return false;
+ }
+
+ bookmark_adaptor_info_destroy(handle);
+
+ if (bookmark_adaptor_publish_notification() != 0) {
+ LOG(INFO) << "SRPH Cannot publish notification on cloud";
+ return false;
+ }
+
+ // r.canada - change this code block
+ // BookmarkSigData::SigType sig_type =
+ // BookmarkSigData::SigType::BookmarkChanged; if (isNewItem)
+ // {
+ // m_idStore.add(item.getID(), id);
+ // sig_type = BookmarkSigData::SigType::BookmarkAdded;
+ // }
+
+ // sendSignal(new BookmarkSigData(this, sig_type, item));
+ LOG(INFO) << "SRPH Returning true";
+ return true;
+}
+
+bool BPBookmarkModel::remove(
+ const samsung_browser_fw_core::BookmarkItem& item) {
+ LOG(INFO) << "m_BookmarkAdaptorInitialized = "
+ << m_BookmarkAdaptorInitialized;
+ int errorcode = 0;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+
+ auto cloudId = m_idStore.find(item.getID());
+ if (cloudId == -1) {
+ LOG(ERROR) << "Item not found";
+ return false;
+ }
+ errorcode = bookmark_adaptor_delete(cloudId);
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannod delete adaptor. ERROR: " << errorcode;
+ return false;
+ }
+
+ m_idStore.remove(item.getID());
+
+ errorcode = bookmark_adaptor_publish_notification();
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot publish notification on cloud. ERROR: " << errorcode;
+ return false;
+ }
+
+ // sendSignal(new BookmarkSigData(this,
+ // BookmarkSigData::SigType::BookmarkRemoved, item)); //r.canada - change this
+ // codeblock
+ return true;
+}
+bool BPBookmarkModel::removeChildren(
+ const samsung_browser_fw_core::BookmarkItem& item) {
+ LOG(INFO) << "m_BookmarkAdaptorInitialized: " << m_BookmarkAdaptorInitialized;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ auto bookmarks = this->getBookmarks(
+ samsung_browser_fw_core::IBookmarkModel::BookmarkItemOrder::CreationTime,
+ 0, 0, samsung_browser_fw_core::BookmarkType::AllBookmarks, item.getID());
+ if (bookmarks.empty()) {
+ LOG(INFO) << "no bookmarks for provided parent";
+ return false;
+ }
+
+ LOG(INFO) << "removing total of " << bookmarks.size() << " bookmarks";
+ for (const auto& bookmark : bookmarks) {
+ if (!this->remove(bookmark)) {
+ LOG(ERROR) << "failed to remove bookmark id= "
+ << m_idStore.find(bookmark.getID())
+ << " url= " << bookmark.getURL();
+ return false;
+ }
+ }
+
+ return true;
+}
+bool BPBookmarkModel::removeAll(samsung_browser_fw_core::BookmarkType type) {
+ LOG(INFO) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ int errorcode = 0;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ if (type == samsung_browser_fw_core::BookmarkType::AllBookmarks) {
+ errorcode = bookmark_adaptor_reset();
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot reset adaptor on cloud. ERROR: " << errorcode;
+ return false;
+ }
+
+ errorcode = bookmark_adaptor_publish_notification();
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot publish notification on cloud. ERROR: "
+ << errorcode;
+ return false;
+ }
+
+ m_idStore.clear();
+ // sendSignal(new BookmarkSigData(this,
+ // BookmarkSigData::SigType::AllBookmarksRemoved, type)); //r.canada -
+ // change this codeblock
+ return true;
+ }
+
+ CloudStruct c_item(type);
+ int* ids = NULL;
+ int ids_count = -1;
+ bookmark_cond_h cond = NULL;
+
+ if (bookmark_adaptor_cond_create(
+ &cond, c_item.properties.parent, c_item.properties.type,
+ c_item.properties.is_operator, c_item.properties.is_editable,
+ BOOKMARK_PROPERTY_TYPE, c_item.conds.ordering) != 0) {
+ LOG(ERROR) << "bookmark_adaptor_cond_create returned error";
+ return false;
+ }
+ errorcode =
+ bookmark_adaptor_get_id_list_by_cond(&ids, &ids_count, -1, 0, cond);
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot get adaptor cond ids. ERROR: " << errorcode;
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return false;
+ }
+ if (!ids) {
+ bookmark_adaptor_cond_destroy(cond);
+ return false;
+ }
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(ERROR) << "bookmark_Adaptor_cond_destroy returned error";
+ free(ids);
+ return false;
+ }
+ for (int i = 0; i < ids_count; ++i) {
+ errorcode = bookmark_adaptor_delete(ids[i]);
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot delete adaptor. ERROR: " << errorcode;
+ }
+ m_idStore.remove(ids[i]);
+ }
+
+ errorcode = bookmark_adaptor_publish_notification();
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot publish notification on cloud. ERROR: " << errorcode;
+ free(ids);
+ return false;
+ }
+
+ if (ids) {
+ free(ids);
+ }
+ // sendSignal(new BookmarkSigData(this,
+ // BookmarkSigData::SigType::AllBookmarksRemoved, type)); //r.canada - change
+ // this codeblock
+ return true;
+}
+
+bool BPBookmarkModel::removeURL(
+ const samsung_browser_fw_core::BookmarkItem& item) {
+ LOG(INFO) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ LOG(INFO) << "SRPH inside removeURL";
+
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ CloudStruct c_item;
+ int* ids = NULL;
+ int ids_count = -1;
+ int errorcode = 0;
+ bookmark_cond_h cond = NULL;
+
+ if (bookmark_adaptor_cond_create(
+ &cond, c_item.properties.parent, c_item.properties.type,
+ c_item.properties.is_operator, c_item.properties.is_editable,
+ BOOKMARK_PROPERTY_URL, c_item.conds.ordering) != 0) {
+ LOG(ERROR) << "SRPH bookmark_Adaptor_cond_create returned error";
+ return false;
+ }
+
+ errorcode = bookmark_adaptor_get_id_list_by_cond_and_keyword(
+ &ids, &ids_count, -1, 0, cond, BOOKMARK_PROPERTY_URL,
+ item.getURL().c_str(), 0);
+ if (errorcode != 0) {
+ LOG(ERROR) << "SRPH Cannot get cond ids. ERROR: " << errorcode;
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return false;
+ }
+ if (!ids) {
+ LOG(INFO) << "SRPH no ids";
+ bookmark_adaptor_cond_destroy(cond);
+ return false;
+ }
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(ERROR) << "SRPH bookmark_Adaptor_cond_destroy returned error";
+ free(ids);
+ return false;
+ }
+ for (int i = 0; i < ids_count; ++i) {
+ LOG(INFO) << "SRPH removing id= " << ids[i];
+ bookmark_adaptor_delete(ids[i]);
+ if (errorcode != 0) {
+ LOG(ERROR) << "SRPH ERROR " << errorcode;
+ }
+ m_idStore.remove(ids[i]);
+ }
+
+ errorcode = bookmark_adaptor_publish_notification();
+ if (errorcode != 0) {
+ LOG(ERROR) << "SRPH Cannot publish notification on cloud. ERROR: "
+ << errorcode;
+ free(ids);
+ return false;
+ }
+
+ if (ids) {
+ free(ids);
+ }
+ return true;
+}
+
+samsung_browser_fw_core::BookmarkItem BPBookmarkModel::getBookmarkItem(
+ int cloud_id) {
+ int errorcode = 0;
+ bp_bookmark_info_fmt info;
+ LOG(INFO) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ memset(&info, 0x00, sizeof(bp_bookmark_info_fmt));
+ bookmark_info_h handle = NULL;
+ errorcode = bookmark_adaptor_info_create(&handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_create returned error. Error: "
+ << errorcode;
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_from_db(cloud_id, handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_from_db returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ auto bookmark_id = m_idStore.find(cloud_id);
+ if (bookmark_id == samsung_browser_fw_core::BookmarkID::NONE) {
+ bookmark_id = samsung_browser_fw_core::BookmarkID();
+ m_idStore.add(bookmark_id, cloud_id);
+ }
+
+ errorcode = bookmark_adaptor_info_get_parent_id(handle, &info.parent);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_parent_id returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode =
+ bookmark_adaptor_info_get_account_name(handle, &info.account_name);
+ if (errorcode != 0) {
+ LOG(ERROR)
+ << "bookmark_adaptor_info_get_account_name returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_url(handle, &info.url);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_url returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_title(handle, &info.title);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_title returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_is_operator(handle, &info.is_operator);
+ if (errorcode != 0) {
+ LOG(ERROR)
+ << "bookmark_adaptor_info_get_is_operator returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_type(handle, &info.type);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_type returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_destroy(handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_destroy returned error. Error: "
+ << errorcode;
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+ auto parent = m_idStore.find(info.parent);
+ auto accountName = samsung_utility::stringFromCstr(info.account_name);
+ // LOG(INFO) << "SRPH accountName: " << accountName;
+ // if (accountName != getAccountName())
+ // {
+ // bookmarkInfoFree(&info);
+ // LOG(ERROR) << "SRPH Early Return on getAccountName " <<
+ // getAccountName().c_str(); return
+ // samsung_browser_fw_core::BookmarkItem::INVALID;
+ // }
+
+ samsung_browser_fw_core::BookmarkItem item(
+ bookmark_id.toString(), samsung_utility::stringFromCstr(info.url),
+ samsung_utility::stringFromCstr(info.title), getSourceName(),
+ samsung_browser_fw_core::BookmarkType(info.is_operator),
+ samsung_browser_fw_core::BookmarkItemType(info.type),
+ parent == samsung_browser_fw_core::BookmarkID::NONE ? ""
+ : parent.toString());
+
+ bookmarkInfoFree(&info);
+ return item;
+}
+
+std::vector<samsung_browser_fw_core::BookmarkItem>
+BPBookmarkModel::getBookmarks(
+ samsung_browser_fw_core::IBookmarkModel::BookmarkItemOrder order,
+ int limit,
+ int offset,
+ samsung_browser_fw_core::BookmarkType type,
+ samsung_browser_fw_core::BookmarkID parentID) {
+ LOG(INFO) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ int* folders = NULL;
+ int folder_count = 0;
+ int cloud_parent_id = parentID == samsung_browser_fw_core::BookmarkID::NONE
+ ? 0
+ : m_idStore.find(parentID);
+ int is_operator = 0;
+ bookmark_cond_h cond = NULL;
+
+ switch (type) {
+ case samsung_browser_fw_core::BookmarkType::UserBookmark:
+ is_operator = 0;
+ break;
+ case samsung_browser_fw_core::BookmarkType::DefaultBookmark:
+ is_operator = 1;
+ break;
+ case samsung_browser_fw_core::BookmarkType::AllBookmarks:
+ is_operator = -1;
+ break;
+ default:
+ break;
+ }
+
+ bookmark_property_defs orderType = BOOKMARK_PROPERTY_DATE_VISITED;
+
+ switch (order) {
+ case samsung_browser_fw_core::IBookmarkModel::BookmarkItemOrder::
+ CreationTime:
+ orderType = BOOKMARK_PROPERTY_DATE_CREATED;
+ break;
+ case samsung_browser_fw_core::IBookmarkModel::BookmarkItemOrder::AccessTime:
+ orderType = BOOKMARK_PROPERTY_DATE_VISITED;
+ break;
+ case samsung_browser_fw_core::IBookmarkModel::BookmarkItemOrder::Url:
+ orderType = BOOKMARK_PROPERTY_URL;
+ break;
+ case samsung_browser_fw_core::IBookmarkModel::BookmarkItemOrder::Title:
+ orderType = BOOKMARK_PROPERTY_TITLE;
+ break;
+ default:
+ orderType = BOOKMARK_PROPERTY_URL;
+ break;
+ }
+
+ // All the bookmark folders are added than all the bookmarks with a limit is
+ // added to root folder.
+ LOG(INFO) << "Get all the folders";
+ if (bookmark_adaptor_cond_create(&cond, cloud_parent_id, 1, is_operator, -1,
+ BOOKMARK_PROPERTY_DATE_CREATED,
+ 1) != 0) // type = 1 for folders
+ {
+ LOG(ERROR) << ("bookmark_Adaptor_cond_create returned error");
+ } else {
+ if (bookmark_adaptor_get_id_list_by_cond(&folders, &folder_count, -1, 0,
+ cond) != 0) {
+ LOG(ERROR) << "Cannot get folder ids";
+ bookmark_adaptor_cond_destroy(cond);
+ } else {
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(ERROR) << "bookmark_adaptor_cond_destroy returned error";
+ } else {
+ if (folder_count <= 0 || !folders) {
+ LOG(ERROR) << "Folder count zero";
+ } else {
+ LOG(ERROR) << "Folder Count : " << folder_count;
+ for (int i = 0; i < folder_count; i++) {
+ m_idStore.add(samsung_browser_fw_core::BookmarkID(), folders[i]);
+ }
+ }
+ }
+ }
+ }
+
+ // All the bookmarks are added now Max limit (100) for particular directory
+ LOG(INFO) << "Get all the bookmarks";
+ int* ids = NULL;
+ int ids_count = 0;
+ cond = NULL;
+ if (bookmark_adaptor_cond_create(&cond, cloud_parent_id, 0, is_operator, -1,
+ orderType,
+ 1) != 0) // type = 0 for bookmarks
+ {
+ LOG(ERROR) << "bookmark_Adaptor_cond_create returned error";
+ } else {
+ if (bookmark_adaptor_get_id_list_by_cond(
+ &ids, &ids_count, syncedBookmarksLimitPerFolder, 0, cond) !=
+ 0) // Max limit specified by browser (100 max)
+ {
+ LOG(ERROR) << "Cannot get bookmark ids";
+ bookmark_adaptor_cond_destroy(cond);
+ } else {
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(ERROR) << "bookmark_adaptor_cond_destroy returned error";
+ } else {
+ if (ids_count <= 0 || !ids) {
+ LOG(ERROR) << "Bookmarks count zero";
+ } else {
+ LOG(INFO) << "Bookmarks count : " << ids_count;
+ for (int i = 0; i < ids_count; i++) {
+ m_idStore.add(samsung_browser_fw_core::BookmarkID(), ids[i]);
+ }
+ }
+ }
+ }
+ }
+
+ std::vector<samsung_browser_fw_core::BookmarkItem> items =
+ std::vector<samsung_browser_fw_core::BookmarkItem>();
+ // items.size could be not equal than ids_count if will be other user in
+ // database and we will get bookmarks from mainfolder If we get from folder
+ // size should be the same
+ items.reserve(ids_count + folder_count);
+ if (folders) {
+ for (int i = 0; i < folder_count; i++) {
+ auto item = getBookmarkItem(folders[i]);
+ if (item != samsung_browser_fw_core::BookmarkItem::INVALID) {
+ items.push_back(item);
+ }
+ }
+ }
+ if (ids) {
+ for (int i = 0; i < ids_count; i++) {
+ auto item = getBookmarkItem(ids[i]);
+ if (item != samsung_browser_fw_core::BookmarkItem::INVALID) {
+ items.push_back(item);
+ }
+ }
+ }
+
+ if (folders) {
+ free(folders);
+ }
+ if (ids) {
+ free(ids);
+ }
+
+ return items;
+}
+
+samsung_browser_fw_core::BookmarkItem BPBookmarkModel::getBookmark(
+ const std::string& url) {
+ LOG(INFO) << "url= " << url << " m_BookmarkAdaptorInitialized= "
+ << m_BookmarkAdaptorInitialized;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ CloudStruct c_item;
+
+ int* ids = NULL;
+ int ids_count = -1;
+ bookmark_cond_h cond = NULL;
+ int errorcode = 0;
+ errorcode = bookmark_adaptor_cond_create(
+ &cond, c_item.properties.parent, c_item.properties.type,
+ c_item.properties.is_operator, c_item.properties.is_editable,
+ BOOKMARK_PROPERTY_URL, c_item.conds.ordering);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_cond_create returned error. Error: "
+ << errorcode;
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_get_id_list_by_cond_and_keyword(
+ &ids, &ids_count, -1, 0, cond, BOOKMARK_PROPERTY_URL, url.c_str(), 0);
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot get cond ids. ERROR: " << errorcode;
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(ERROR) << "bookmark_adaptor_cond_destroy returned error";
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ if (ids_count <= 0 || !ids) {
+ LOG(ERROR) << "Didn't find id with this url";
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+ LOG(INFO) << "Bookmarks Found: " << ids_count;
+ LOG(INFO) << "URL: " << url;
+ // we need to check every item, because we need to check account
+ for (int i = 0; i < ids_count; ++i) {
+ bp_bookmark_info_fmt info;
+ memset(&info, 0x00, sizeof(bp_bookmark_info_fmt));
+ bookmark_info_h handle = NULL;
+ errorcode = bookmark_adaptor_info_create(&handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_create returned error. Error: "
+ << errorcode;
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_from_db(ids[i], handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_from_db returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode =
+ bookmark_adaptor_info_get_account_name(handle, &info.account_name);
+ if (errorcode != 0) {
+ LOG(ERROR)
+ << "bookmark_adaptor_info_get_account_name returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_parent_id(handle, &info.parent);
+ if (errorcode != 0) {
+ LOG(ERROR)
+ << "bookmark_adaptor_info_get_parent_id returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_url(handle, &info.url);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_url returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_title(handle, &info.title);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_title returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode =
+ bookmark_adaptor_info_get_is_operator(handle, &info.is_operator);
+ if (errorcode != 0) {
+ LOG(ERROR)
+ << "bookmark_adaptor_info_get_is_operator returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+ errorcode = bookmark_adaptor_info_destroy(handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_destroy returned error. Error: "
+ << errorcode;
+ bookmarkInfoFree(&info);
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ auto accountName = samsung_utility::stringFromCstr(info.account_name);
+ LOG(INFO) << "SRPH value of accountName: " << accountName;
+ LOG(INFO) << "SRPH value of getAccountName: " << getAccountName();
+
+ if (accountName == getAccountName()) {
+ auto parent = m_idStore.find(info.parent);
+ int id = ids[i];
+ LOG(INFO) << "Found id= " << id;
+ LOG(INFO) << "SRPH m_id: " << m_idStore.find(id).toString();
+ free(ids);
+ samsung_browser_fw_core::BookmarkItem item(
+ m_idStore.find(id).toString(),
+ samsung_utility::stringFromCstr(info.url),
+ samsung_utility::stringFromCstr(info.title), getSourceName(),
+ samsung_browser_fw_core::BookmarkType(info.is_operator),
+ samsung_browser_fw_core::BookmarkItemType(info.type),
+ parent == samsung_browser_fw_core::BookmarkID::NONE
+ ? ""
+ : parent.toString());
+
+ bookmarkInfoFree(&info);
+ return item;
+ } else {
+ // BROWSER_LOGD("id=%d, different account name: %s != %s", ids[i],
+ // accountName.c_str(), getAccountName().c_str());
+ LOG(INFO) << "Error Occured";
+ }
+ bookmarkInfoFree(&info);
+ }
+
+ // if no item found
+ LOG(INFO) << "SRPH getBookmark returning an Invalid Item";
+ free(ids);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+}
+
+samsung_browser_fw_core::BookmarkItem BPBookmarkModel::getBookmark(
+ const samsung_browser_fw_core::BookmarkID& id) {
+ LOG(INFO) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ int errorcode = 0;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ auto cloudId = m_idStore.find(id);
+ if (cloudId == -1) {
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ bp_bookmark_info_fmt info;
+ memset(&info, 0x00, sizeof(bp_bookmark_info_fmt));
+
+ bookmark_info_h handle = NULL;
+ if (bookmark_adaptor_info_create(&handle) != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_create returned error";
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+ if (bookmark_adaptor_info_get_from_db(cloudId, handle) != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_from_db returned error";
+ bookmark_adaptor_info_destroy(handle);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode =
+ bookmark_adaptor_info_get_account_name(handle, &info.account_name);
+ if (errorcode != 0) {
+ LOG(ERROR)
+ << "bookmark_Adaptor_info_get_account_name returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_parent_id(handle, &info.parent);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_Adaptor_info_get_parent_id returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_url(handle, &info.url);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_Adaptor_info_get_url returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_title(handle, &info.title);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_title returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_is_operator(handle, &info.is_operator);
+ if (errorcode != 0) {
+ LOG(ERROR)
+ << "bookmark_adaptor_info_get_is_operator returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_get_type(handle, &info.type);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_type returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ errorcode = bookmark_adaptor_info_destroy(handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_destroy returned error. Error: "
+ << errorcode;
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ auto accountName = samsung_utility::stringFromCstr(info.account_name);
+ if (accountName != getAccountName()) {
+ bookmarkInfoFree(&info);
+ return samsung_browser_fw_core::BookmarkItem::INVALID;
+ }
+
+ auto parent = m_idStore.find(info.parent);
+
+ samsung_browser_fw_core::BookmarkItem item(
+ id.toString(), samsung_utility::stringFromCstr(info.url),
+ samsung_utility::stringFromCstr(info.title), getSourceName(),
+ samsung_browser_fw_core::BookmarkType(info.is_operator),
+ samsung_browser_fw_core::BookmarkItemType(info.type),
+ parent == samsung_browser_fw_core::BookmarkID::NONE ? ""
+ : parent.toString());
+
+ bookmarkInfoFree(&info);
+ return item;
+}
+
+int BPBookmarkModel::count() {
+ LOG(ERROR) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ int* ids = NULL;
+ int ids_count = -1;
+ bookmark_cond_h cond = NULL;
+
+ if (bookmark_adaptor_cond_create(&cond, -1, -1, -1, -1,
+ BOOKMARK_PROPERTY_SEQUENCE, 0) != 0) {
+ LOG(ERROR) << "bokmark_adaptor_cond_create returned error";
+ return 0;
+ }
+ if (bookmark_adaptor_get_id_list_by_cond(&ids, &ids_count, -1, 0, cond) !=
+ 0) {
+ LOG(ERROR) << "bookmark_adaptor_get_id_list_by_cond returned error";
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return 0;
+ }
+ if (bookmark_adaptor_cond_destroy(cond) != 0) {
+ LOG(ERROR) << "bookmark_adaptor_cond_destroy returned error";
+ free(ids);
+ return 0;
+ }
+ if (!ids) {
+ return 0;
+ }
+ auto tempCount = ids_count;
+ for (int i = 0; i < ids_count; i++) {
+ char* accountName = nullptr;
+ bookmark_info_h handle = NULL;
+ if (bookmark_adaptor_info_create(&handle) != 0) {
+ LOG(ERROR) << "bookmark_Adaptor_info returned error";
+ }
+ if (bookmark_adaptor_info_get_from_db(ids[i], handle) != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_from db returned error";
+ }
+ if (bookmark_adaptor_info_get_account_name(handle, &accountName) != 0) {
+ LOG(ERROR) << "Cannot get acount name for id= " << ids[i];
+ }
+ if (bookmark_adaptor_info_destroy(handle) != 0) {
+ LOG(ERROR) << "bookmark_Adaptor_info_destroy returned error";
+ }
+ if (samsung_utility::stringFromCstr(accountName) != getAccountName()) {
+ --tempCount;
+ }
+ if (accountName) {
+ free(accountName);
+ accountName = nullptr;
+ }
+ }
+
+ if (ids) {
+ free(ids);
+ }
+
+ return tempCount;
+}
+
+int BPBookmarkModel::count(const samsung_browser_fw_core::BookmarkType type) {
+ LOG(ERROR) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ CloudStruct c_item(type);
+
+ int* ids = NULL;
+ int ids_count = -1;
+ int errorcode = 0;
+ bookmark_cond_h cond = NULL;
+ if (bookmark_adaptor_cond_create(
+ &cond, c_item.properties.parent, c_item.properties.type,
+ c_item.properties.is_operator, c_item.properties.is_editable,
+ BOOKMARK_PROPERTY_IS_OPERATOR, -1) != 0) {
+ LOG(ERROR) << "bookmark_Adaptor_cond_create failed";
+ return -1;
+ }
+ errorcode =
+ bookmark_adaptor_get_id_list_by_cond(&ids, &ids_count, -1, 0, cond);
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot get cond ids. ERROR: " << errorcode;
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return -1;
+ }
+ errorcode = bookmark_adaptor_cond_destroy(cond);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_cond_Destroy returned error";
+ free(ids);
+ return -1;
+ }
+ if (!ids) {
+ return -1;
+ }
+ auto tempCount = ids_count;
+ for (int i = 0; i < ids_count; i++) {
+ char* accountName = nullptr;
+ bookmark_info_h handle = NULL;
+ errorcode = bookmark_adaptor_info_create(&handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_create returned error. Error: "
+ << errorcode;
+ free(ids);
+ return -1;
+ }
+
+ errorcode = bookmark_adaptor_info_get_from_db(ids[i], handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_from_db returned error. Error: "
+ << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ free(ids);
+ return -1;
+ }
+ errorcode = bookmark_adaptor_info_get_account_name(handle, &accountName);
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot get acount name for id= " << ids[1]
+ << " ERROR: " << errorcode;
+ bookmark_adaptor_info_destroy(handle);
+ free(ids);
+ return -1;
+ }
+ errorcode = bookmark_adaptor_info_destroy(handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "tab_Adaptor_info_destroy returned error";
+ free(ids);
+ return -1;
+ }
+ if (samsung_utility::stringFromCstr(accountName) != getAccountName()) {
+ --tempCount;
+ }
+ if (accountName) {
+ free(accountName);
+ accountName = nullptr;
+ }
+ }
+
+ if (ids) {
+ free(ids);
+ }
+
+ return tempCount;
+}
+
+int BPBookmarkModel::count(const std::string& url) {
+ LOG(ERROR) << "m_BookmarkAdaptorInitialized " << m_BookmarkAdaptorInitialized;
+ if (!m_BookmarkAdaptorInitialized) {
+ initializeBookMarkAdaptor();
+ }
+ CloudStruct c_item;
+
+ int* ids = NULL;
+ int ids_count = -1;
+ int errorcode = 0;
+ bookmark_cond_h cond;
+ errorcode = bookmark_adaptor_cond_create(
+ &cond, c_item.properties.parent, c_item.properties.type,
+ c_item.properties.is_operator, c_item.properties.is_editable,
+ BOOKMARK_PROPERTY_URL, 0);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_Adaptor_cond_create returned error. Error: "
+ << errorcode;
+ return -1;
+ }
+
+ errorcode = bookmark_adaptor_get_id_list_by_cond_and_keyword(
+ &ids, &ids_count, -1, 0, cond, BOOKMARK_PROPERTY_URL, url.c_str(), 0);
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot get cond ids. ERROR: " << errorcode;
+ if (ids) {
+ free(ids);
+ }
+ bookmark_adaptor_cond_destroy(cond);
+ return -1;
+ }
+ errorcode = bookmark_adaptor_cond_destroy(cond);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_cond_destroy returned error. Error: "
+ << errorcode;
+ free(ids);
+ return -1;
+ }
+ if (!ids) {
+ return -1;
+ }
+ auto tempCount = ids_count;
+ for (int i = 0; i < ids_count; i++) {
+ char* accountName = nullptr;
+ bookmark_info_h handle = NULL;
+ errorcode = bookmark_adaptor_info_create(&handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_create returned error. Error: "
+ << errorcode;
+ }
+
+ errorcode = bookmark_adaptor_info_get_from_db(ids[i], handle);
+ if (errorcode != 0) {
+ LOG(ERROR) << "bookmark_adaptor_info_get_from_db returned error. Error: "
+ << errorcode;
+ }
+ errorcode = bookmark_adaptor_info_get_account_name(handle, &accountName);
+ if (errorcode != 0) {
+ LOG(ERROR) << "Cannot get acount name for id= " << ids[i]
+ << " ERROR: " << errorcode;
+ }
+ if (samsung_utility::stringFromCstr(accountName) != getAccountName()) {
+ --tempCount;
+ }
+ if (accountName) {
+ free(accountName);
+ accountName = nullptr;
+ }
+ errorcode = bookmark_adaptor_info_destroy(handle);
+ {
+ LOG(ERROR) << "bookmark_adaptor_info_destroy returned error. ERROR: "
+ << errorcode;
+ }
+ }
+ if (ids) {
+ free(ids);
+ }
+
+ return tempCount;
+}
+
+} // namespace samsung_browser_storage
--- /dev/null
+#ifndef COMPONENTS_SAMSUNG_BPBOOKMARK_MODEL_SAMSUNG_BPBOOKMARK_MODEL
+#define COMPONENTS_SAMSUNG_BPBOOKMARK_MODEL_SAMSUNG_BPBOOKMARK_MODEL
+
+#include <vector>
+// #include "cloud_bookmark.h"
+
+#include "components/samsung/bpbookmark_image_model/samsung_bpbookmark_image_model.h"
+#include "components/samsung/bpbookmark_model/samsung_bookmark_id.h"
+#include "components/samsung/bpbookmark_model/samsung_bookmark_item.h"
+// #include
+// "components/samsung/bpbookmark_model/samsung_bookmark_model_common.h"
+// # include "components/samsung/public/samsung_utility.cc"
+#include "components/samsung/bpbookmark_model/samsung_ibookmark_model.h"
+#include "components/samsung/bpbookmark_model/samsung_id_store.h"
+#include "components/samsung/public/samsung_account_model.h"
+#include "components/samsung/public/samsung_enums.h"
+
+namespace samsung_browser_storage {
+
+class BPBookmarkModel : public samsung_browser_fw_core::IBookmarkModel,
+ public samsung_browser_fw_core::AccountModel {
+ public:
+ /**
+ * @brief
+ *
+ * @fn BPBookmarkModel
+ */
+ BPBookmarkModel();
+ /**
+ * @brief
+ *
+ * @fn ~BPBookmarkModel
+ */
+ virtual ~BPBookmarkModel();
+ /**
+ * @brief
+ *
+ * @fn init
+ * @return bool
+ */
+ bool init() override;
+ /**
+ * @brief
+ *
+ * @fn deinit
+ * @return void
+ */
+ void deinit() override;
+ /**
+ * @brief
+ *
+ * @fn bookmarkInfoFree
+ * @param bp_bookmark_info_fmt *info
+ * @return bool
+ */
+ void bookmarkInfoFree(bp_bookmark_info_fmt* info);
+ /**
+ * @brief
+ *
+ * @fn add
+ * @param BookmarkItem
+ * @return bool
+ */
+ bool add(samsung_browser_fw_core::BookmarkItem&) override;
+ /**
+ * @brief
+ *
+ * @fn remove
+ * @param BookmarkItem
+ * @return bool
+ */
+ bool remove(const samsung_browser_fw_core::BookmarkItem&) override;
+ /**
+ * @brief
+ *
+ * @fn remove
+ * @param BookmarkItem
+ * @return bool
+ */
+ bool removeChildren(const samsung_browser_fw_core::BookmarkItem&) override;
+ /**
+ * @brief
+ *
+ * @fn removeAll
+ * @param BookmarkType
+ * @return bool
+ */
+ bool removeAll(samsung_browser_fw_core::BookmarkType) override;
+ /**
+ * @brief
+ *
+ * @fn removeURL
+ * @param BookmarkItem
+ * @return bool
+ */
+ bool removeURL(const samsung_browser_fw_core::BookmarkItem&) override;
+ /**
+ * @brief
+ *
+ * @fn getBookmarks
+ * @param BookmarkItemOrder
+ * @param limit
+ * @param offset
+ * @param BookmarkType
+ * @param BookmarkID
+ * @return std::vector<BookmarkItem>
+ */
+ virtual std::vector<samsung_browser_fw_core::BookmarkItem> getBookmarks(
+ BookmarkItemOrder,
+ int limit,
+ int offset,
+ samsung_browser_fw_core::BookmarkType,
+ samsung_browser_fw_core::BookmarkID parent_id);
+ /**
+ * @brief
+ *
+ * @fn getBookmark
+ * @param url
+ * @return BookmarkItem
+ */
+ samsung_browser_fw_core::BookmarkItem getBookmark(
+ const std::string& url) override;
+ /**
+ * @brief
+ *
+ * @fn getBookmark
+ * @param
+ * @return BookmarkItem
+ */
+ samsung_browser_fw_core::BookmarkItem getBookmark(
+ const samsung_browser_fw_core::BookmarkID& id) override;
+ /**
+ * @brief
+ *
+ * @fn count
+ * @return int
+ */
+ int count() override;
+ /**
+ * @brief
+ *
+ * @fn count
+ * @param BrowserFWCore::BookmarkType
+ * @return int
+ */
+ int count(const samsung_browser_fw_core::BookmarkType) override;
+ /**
+ * @brief
+ *
+ * @fn count
+ * @param string
+ * @return int
+ */
+ int count(const std::string& url) override;
+ /**
+ * @brief
+ *
+ * @var sourceName
+ */
+ static std::string sourceName;
+ /**
+ * @brief
+ *
+ * @fn getInfoModel
+ * @return std::string
+ */
+ std::string getSourceName() const override { return sourceName; }
+
+ private:
+ samsung_browser_fw_core::BookmarkItem getBookmarkItem(int cloud_id);
+
+ static void dataChangedCallback(void* data /*BPBookmarkModel*/);
+ // static void notify(void* data);
+ // static Eina_Bool refreshIntervalCallback(void* data); //r.canada
+ // void browserStateChanged(BrowserMain::BrowserCore::BrowserState s);
+ void dataChanged();
+ void initializeBookMarkAdaptor();
+
+ IdStore m_idStore;
+ bool m_BookmarkAdaptorInitialized;
+ bool m_shouldSendRefreshSignal;
+ // Ecore_Timer* m_refreshIntervalTimer;
+ bool m_initialized;
+};
+
+} // namespace samsung_browser_storage
+
+#endif // BPBookmarkModel_h
--- /dev/null
+
+#ifndef IBookmarkModel_h
+#define IBookmarkModel_h
+
+#include "components/samsung/public/samsung_enums.h"
+#include "samsung_bookmark_id.h"
+#include "samsung_bookmark_item.h"
+
+// #include <boost/signals2/signal.hpp>
+
+namespace samsung_browser_fw_core {
+/**
+ * @brief
+ *
+ * @class IBookmarkModel IBookmarkModel.h "inc/IBookmarkModel.h"
+ */
+class IBookmarkModel {
+ public:
+ /**
+ * @brief
+ *
+ * @enum BookmarkItemOrder
+ */
+ enum BookmarkItemOrder {
+ CreationTime = 1,
+ AccessTime = 2,
+ Url = 3,
+ Title = 4
+ };
+ /**
+ * @brief
+ *
+ * @fn ~IBookmarkModel
+ */
+ virtual ~IBookmarkModel() {}
+
+ /**
+ * @brief
+ *
+ * @fn init
+ * @return bool
+ */
+ virtual bool init() = 0;
+ virtual void deinit() = 0;
+
+ /**
+ * @brief
+ *
+ * @fn add
+ * @param BookmarkItem
+ * @return bool
+ */
+ virtual bool add(BookmarkItem&) = 0;
+ /**
+ * @brief
+ *
+ * @fn remove
+ * @param BookmarkItem
+ * @return bool
+ */
+ virtual bool remove(const BookmarkItem&) = 0;
+ /**
+ * @brief
+ *
+ * @fn removeURL
+ * @param BookmarkItem
+ * @return bool
+ */
+ virtual bool removeURL(const BookmarkItem&) = 0;
+ /**
+ * @brief
+ *
+ * @fn removeAll
+ * @param BookmarkType
+ * @return bool
+ * when parentID is empty function removeAll go to removeChildren and remove
+ * all bookmarks which are in Main Folder and of course their children
+ */
+ virtual bool removeAll(BookmarkType) = 0;
+ /**
+ * @brief
+ *
+ * @fn removeContainedOfFolder
+ * @param BrowserFWCore::BookmarkItem
+ * @return bool
+ * this function is use when we want RemoveAll items and we are in folder.
+ * Function remove all items but doesn't remove this folder.
+ */
+ virtual bool removeChildren(const samsung_browser_fw_core::BookmarkItem&) = 0;
+ /**
+ * @brief
+ *
+ * @fn getBookmarks
+ * @param BookmarkItemOrder
+ * @param limit
+ * @param offset
+ * @param BookmarkType
+ * @return std::vector<BookmarkItem>
+ */
+ virtual std::vector<BookmarkItem> getBookmarks(
+ BookmarkItemOrder,
+ int limit,
+ int offset,
+ BookmarkType,
+ BookmarkID parentID = BookmarkID::NONE) = 0;
+ /**
+ * @brief
+ *
+ * @fn getBookmark
+ * @param url
+ * @return BookmarkItem
+ */
+ virtual BookmarkItem getBookmark(const std::string& url) = 0;
+ /**
+ * @brief
+ *
+ * @fn getBookmark
+ * @param
+ * @return BookmarkItem
+ */
+ virtual BookmarkItem getBookmark(const BookmarkID&) = 0;
+ /**
+ * @brief
+ *
+ * @fn count
+ * @return int
+ */
+ virtual int count() = 0;
+ /**
+ * @brief
+ *
+ * @fn count
+ * @param BrowserFWCore::BookmarkType
+ * @return int
+ */
+ virtual int count(const samsung_browser_fw_core::BookmarkType) = 0;
+ /**
+ * @brief
+ *
+ * @fn count
+ * @param URIString
+ * @return int
+ */
+ virtual int count(const std::string& url) = 0;
+ /**
+ * @brief
+ *
+ * @fn getInfoModel
+ * @return std::string
+ */
+ virtual std::string getSourceName() const = 0;
+
+ // // signals
+ // /**
+ // * @brief
+ // *
+ // * @fn bookmarkAdded
+ // * @param BookmarkItem
+ // * @return boost::signals2::signal<void >
+ // */
+ // boost::signals2::signal<void (BookmarkItem)> bookmarkAdded;
+ // /**
+ // * @brief
+ // *
+ // * @fn bookmarkRemoved
+ // * @param BookmarkItem
+ // * @return boost::signals2::signal<void >
+ // */
+ // boost::signals2::signal<void (BookmarkItem)> bookmarkRemoved;
+ // /**
+ // * @brief
+ // *
+ // * @fn bookmarkChanged
+ // * @param BookmarkItem
+ // * @return boost::signals2::signal<void >
+ // */
+ // boost::signals2::signal<void (BookmarkItem)> bookmarkChanged;
+ // /**
+ // * @brief
+ // *
+ // * @fn allBookmarksRemoved
+ // * @param BookmarkType
+ // * @return boost::signals2::signal<void >
+ // */
+ // boost::signals2::signal<void (BookmarkType)> allBookmarksRemoved;
+};
+
+} // namespace samsung_browser_fw_core
+
+#endif // IBookmarkModel_h
--- /dev/null
+#ifndef IdStore_h
+#define IdStore_h
+
+#include <functional>
+#include <set>
+
+#include "base/logging.h"
+#include "samsung_bookmark_id.h"
+
+/*
+ * IdStore is a class designed to store and manage matching between
+ * cloud and browser bookmark id's. It allows to to add and remove
+ * matching between id's, and basing on one type id value get matched
+ * value of second one.
+ */
+class IdStore {
+ class IdMatch {
+ enum class StoreType { Both, OnlyBP, OnlyCloud };
+
+ public:
+ /*
+ * This constructor should be used for constructing class object to
+ * store in a set.
+ */
+ IdMatch(samsung_browser_fw_core::BookmarkID bid, int cid)
+ : m_bid(bid), m_cid(cid), m_type(StoreType::Both) {}
+
+ /*
+ * This constructor should be used for constructing class object used
+ * to find in a set a cloud bookmark id matched to provided browser
+ * bookmark id
+ */
+ explicit IdMatch(samsung_browser_fw_core::BookmarkID bid)
+ : m_bid(bid), m_cid(-1), m_type(StoreType::OnlyBP) {}
+
+ /*
+ * This constructor should be used for constructing class object used
+ * to find in a set a browser bookmark id matched to provided cloud
+ * bookmark id
+ */
+ explicit IdMatch(int cid)
+ : m_bid(samsung_browser_fw_core::BookmarkID::NONE),
+ m_cid(cid),
+ m_type(StoreType::OnlyCloud) {}
+
+ samsung_browser_fw_core::BookmarkID getBookmardId() const { return m_bid; }
+ int getcid() const { return m_cid; }
+
+ /*
+ * Operator check which id are stored in both object and basing on this
+ * information validate if they are equal. If one value is not set then
+ * it is assumed that it should not be took into account in comparison.
+ */
+ bool operator==(const IdMatch& b) const {
+ /*
+ * Validate case when object doesn't hold same type of id's and
+ * are not able to compare.
+ */
+ if ((m_type == StoreType::OnlyBP && b.m_type == StoreType::OnlyCloud) ||
+ (m_type == StoreType::OnlyCloud && b.m_type == StoreType::OnlyBP)) {
+ return false;
+ }
+
+ /*
+ * Validate situation when at least one object hold only browser
+ * type of bookmark id. In such case only m_bid is comparable.
+ */
+ if (m_type == StoreType::OnlyBP || b.m_type == StoreType::OnlyBP) {
+ return m_bid == b.m_bid;
+ }
+
+ /*
+ * Validate situation when at least one object hold only cloud
+ * type of bookmark id. In such case only m_cid is comparable.
+ */
+ if (m_type == StoreType::OnlyCloud || b.m_type == StoreType::OnlyCloud) {
+ return m_cid == b.m_cid;
+ }
+
+ /*
+ * Case which left is that both object hold both types of id.
+ */
+ return ((m_bid == b.m_bid) && m_cid == b.m_cid);
+ }
+
+ /*
+ * This operator is used by a container object to build a search tree
+ * and speed up searching mechanism. It is not possible to build a right
+ * tree which will be navigate-able for both types of id's. If one type
+ * of id will be sorted, most probable second type of id will not be
+ * sorted. Thats why this operator prefers a cloud bookmark id. Thanks
+ * that a set of IdMatch can use build in search mechanism to find an
+ * object basing on a cloud bookmark id.
+ */
+ bool operator<(const IdMatch& b) const {
+ // This case should not occurs. Such object are not comparable
+ if ((m_type == StoreType::OnlyBP && b.m_type == StoreType::OnlyCloud) ||
+ (m_type == StoreType::OnlyCloud && b.m_type == StoreType::OnlyBP)) {
+ return false;
+ }
+
+ /*
+ * Validate case when one object has only browser type of id.
+ */
+ if (m_type == StoreType::OnlyBP || b.m_type == StoreType::OnlyBP) {
+ return m_bid < b.m_bid;
+ }
+
+ return m_cid < b.m_cid;
+ }
+
+ private:
+ samsung_browser_fw_core::BookmarkID m_bid;
+ int m_cid;
+ StoreType m_type;
+ };
+
+ public:
+ IdStore(){};
+
+ /*
+ * Add to base information about matching between provided id's.
+ */
+ void add(const samsung_browser_fw_core::BookmarkID& bid, int cid) {
+ m_idSet.insert(IdMatch(bid, cid));
+ }
+
+ /*
+ * Returns a cloud bookamrk id matched to a provided browser one.
+ * If provided id cannot be found in data base then will be returned
+ * -1, which represents main folder or invalid id, depends on context.
+ */
+ int find(const samsung_browser_fw_core::BookmarkID& bid) const {
+ if (bid == samsung_browser_fw_core::BookmarkID::NONE) {
+ return -1;
+ }
+ /*
+ * Search tree in data base is built basing on a cloud type of
+ * bookmark * id. Thats why 'find' provided by std::set will not work
+ * correctly and have to be used std::find.
+ */
+ auto it = std::find(m_idSet.begin(), m_idSet.end(), IdMatch(bid));
+ if (it != m_idSet.end()) {
+ return it->getcid();
+ }
+ return -1;
+ }
+
+ /*
+ * Returns a browser bookamrk id matched to a provided cloud one.
+ * If provided id cannot be found in data base then will be returned
+ * BookmarkID::NONE, which represents main folder or invalid id, depends
+ * on context.
+ */
+ samsung_browser_fw_core::BookmarkID find(int cid) const {
+ // LOG(INFO) << "SRPH inside samsung_id_store find";
+ if (cid == -1) {
+ // LOG(INFO) << "SRPH inside samsung_id_store find cid == -1";
+ return samsung_browser_fw_core::BookmarkID::NONE;
+ }
+ /*
+ * Search tree in data base is built basing on a cloud type of
+ * bookmark * id. Thats why 'find' provided by std::set can be used.
+ */
+ auto it = m_idSet.find(IdMatch(cid));
+ if (it != m_idSet.end()) {
+ // LOG(INFO) << "SRPH inside samsung_id_store find it != m_idSet.end()";
+ return it->getBookmardId();
+ }
+ // LOG(INFO) << "SRPH inside samsung_id_store find returning
+ // BookmarkId::NONE";
+ return samsung_browser_fw_core::BookmarkID::NONE;
+ }
+
+ /*
+ * Clear whole data base.
+ */
+ void clear() { m_idSet.clear(); }
+
+ /*
+ * Remove from data base matching related to provided browser bookmark id.
+ */
+ void remove(const samsung_browser_fw_core::BookmarkID& bid) {
+ auto it = std::find(m_idSet.begin(), m_idSet.end(), IdMatch(bid));
+ if (it != m_idSet.end()) {
+ m_idSet.erase(it);
+ }
+ }
+
+ /*
+ * Remove from data base matching related to provided cloud bookmark id.
+ */
+ void remove(int cid) {
+ auto it = m_idSet.find(IdMatch(cid));
+ if (it != m_idSet.end()) {
+ m_idSet.erase(it);
+ }
+ }
+
+ private:
+ std::set<IdMatch> m_idSet;
+};
+
+#endif // IdStore_h
--- /dev/null
+
+#ifndef TabID_h
+#define TabID_h
+
+#include "components/samsung/public/samsung_abstract_id.h"
+
+namespace samsung_browser_fw_core {
+
+/**
+ * @brief
+ *
+ * @class TabID TabID.h "include/TabID.h"
+ */
+class TabID : public SamsungAbstractID {
+ public:
+ /**
+ * @brief
+ *
+ * @var NONE
+ */
+ static TabID NONE;
+ TabID() : SamsungAbstractID() {}
+ TabID(const std::string& str) : SamsungAbstractID(str) {}
+};
+
+} // namespace samsung_browser_fw_core
+#endif // TabID_h
--- /dev/null
+#include "SQLBookmarkModel.h"
+
+#include "BookmarkItem.h"
+#include "BookmarkModelCommon.h"
+#include "Logger.h"
+#include "URIString.h"
+#include "sql-db.h"
+#include "sql-utility.h"
+
+#include <Ecore.h>
+
+#include <string>
+
+namespace BrowserStorage {
+
+const static std::string modelQueryItemsLoad(
+ " id, uuid, uri, title, creation_time, access_time,"
+ " type, source_name, item_type, parent_id ");
+
+std::string SQLBookmarkModel::sourceName = "SQLBookmarks";
+
+SQLBookmarkModel::SQLBookmarkModel(const std::string& tableName)
+ : m_tableName(tableName), m_initialized(false) {
+ BROWSER_LOGD("");
+}
+
+SQLBookmarkModel::~SQLBookmarkModel() {
+ BROWSER_LOGD("");
+ if (m_initialized) {
+ deinit();
+ }
+ if (m_db) {
+ m_db->close();
+ }
+}
+
+bool SQLBookmarkModel::init() {
+ BROWSER_LOGD("");
+ m_db = std::make_shared<sql_db>();
+
+ m_initialized = prepare_database(m_db, m_tableName);
+ return m_initialized;
+}
+
+void SQLBookmarkModel::deinit() {
+ BROWSER_LOGD("");
+ m_initialized = false;
+}
+
+bool SQLBookmarkModel::add(BrowserFWCore::BookmarkItem& item) {
+ BROWSER_LOGD("");
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return false;
+ }
+
+ if (item == BrowserFWCore::BookmarkItem::INVALID) {
+ BROWSER_LOGW("Invalid item.");
+ return false;
+ }
+
+ auto parentIDString = (item.getParentID() != BrowserFWCore::BookmarkID::NONE
+ ? item.getParentID().toString()
+ : "");
+ auto idString = item.getID().toString();
+
+ item.setSourceName(sourceName);
+
+ BrowserFWCore::BookmarkItem existingItem = getBookmark(item.getID());
+ if (existingItem != BrowserFWCore::BookmarkItem::INVALID) {
+ BROWSER_LOGD(
+ "Item with given ID is already stored in database, update it with new "
+ "values.");
+ sql_query query = m_db->prepare(
+ "UPDATE " + m_tableName +
+ " SET uri = ?, title = ?, creation_time = ?, access_time = ?,"
+ " type = ?, source_name = ?, item_type = ?, parent_id = ?"
+ " WHERE uuid = ?");
+
+ query.bind_text(1, item.getURL().getCStr());
+ query.bind_text(2, item.getTitle().c_str());
+ query.bind_time(3, item.getCreationTime());
+ query.bind_time(4, item.getAccessTime());
+ query.bind_int(5, static_cast<int>(item.getType()));
+ query.bind_text(6, item.getSourceName().c_str());
+ query.bind_int(
+ 7,
+ (item.getItemType() == BrowserFWCore::BookmarkItemType::Bookmark ? 0
+ : 1));
+ query.bind_text(8, parentIDString.c_str());
+ query.bind_text(9, idString.c_str());
+
+ if (!query.exec()) {
+ BROWSER_LOGW("Query execution failed");
+ return false;
+ }
+ BROWSER_LOGD("Successfully edited bookmark item");
+ sendSignal(new BookmarkSigData(
+ this, BookmarkSigData::SigType::BookmarkChanged, item));
+ return true;
+ }
+
+ BROWSER_LOGD("");
+
+ sql_query query = m_db->prepare(
+ "INSERT INTO " + m_tableName +
+ " (uuid, uri, title,"
+ "creation_time, access_time, type, source_name, item_type, parent_id)"
+ "VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)");
+
+ query.bind_text(1, idString.c_str());
+ query.bind_text(2, item.getURL().getCStr());
+ query.bind_text(3, item.getTitle().c_str());
+ query.bind_time(4, item.getCreationTime());
+ query.bind_time(5, item.getAccessTime());
+ query.bind_int(6, static_cast<int>(item.getType()));
+ query.bind_text(7, item.getSourceName().c_str());
+ query.bind_int(
+ 8, (item.getItemType() == BrowserFWCore::BookmarkItemType::Bookmark ? 0
+ : 1));
+ query.bind_text(9, parentIDString.c_str());
+
+ if (!query.is_valid()) {
+ BROWSER_LOGD("Invalid insert query");
+ return false;
+ }
+ if (!query.exec()) {
+ BROWSER_LOGD("Query execution failed");
+ return false;
+ }
+
+ BROWSER_LOGD("Successfully added bookmark item: id = %d",
+ m_db->last_insert_id());
+ sendSignal(
+ new BookmarkSigData(this, BookmarkSigData::SigType::BookmarkAdded, item));
+ return true;
+}
+
+bool SQLBookmarkModel::removeURL(const BrowserFWCore::BookmarkItem& item) {
+ BROWSER_LOGD("");
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return false;
+ }
+
+ std::string queryStr("DELETE FROM " + m_tableName + " WHERE uri = ?");
+
+ sql_query query(m_db->prepare(queryStr.c_str()));
+ query.bind_text(1, item.getURL().getRaw().c_str());
+
+ if (!query.exec()) {
+ BROWSER_LOGW("Query execution failed");
+ return false;
+ }
+
+ sendSignal(new BookmarkSigData(
+ this, BookmarkSigData::SigType::BookmarkRemoved, item));
+ return true;
+}
+
+bool SQLBookmarkModel::remove(const BrowserFWCore::BookmarkItem& item) {
+ BROWSER_LOGD("");
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return false;
+ }
+ if (item.getItemType() == BrowserFWCore::BookmarkItemType::Folder) {
+ auto children =
+ getBookmarks(BrowserFWCore::IBookmarkModel::CreationTime, 0, 0,
+ BrowserFWCore::BookmarkType::AllBookmarks, item.getID());
+ for (const auto& child : children) {
+ remove(child);
+ }
+ }
+ std::string queryStr("DELETE FROM " + m_tableName + " WHERE uuid = ?");
+
+ sql_query query(m_db->prepare(queryStr.c_str()));
+ query.bind_text(1, item.getID().toString().c_str());
+ if (!query.exec()) {
+ BROWSER_LOGW("Query execution failed");
+ return false;
+ }
+ if (query.changes() == 0) {
+ BROWSER_LOGW("No rows were changed.");
+ return false;
+ }
+ sendSignal(new BookmarkSigData(
+ this, BookmarkSigData::SigType::BookmarkRemoved, item));
+ return true;
+}
+
+bool SQLBookmarkModel::removeAll(BrowserFWCore::BookmarkType type) {
+ BROWSER_LOGD("");
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return false;
+ }
+
+ std::string queryStr("DELETE FROM " + m_tableName);
+
+ if (type != BrowserFWCore::BookmarkType::AllBookmarks) {
+ queryStr.append(" WHERE type = ?");
+ }
+
+ sql_query query(m_db->prepare(queryStr.c_str()));
+ if (type != BrowserFWCore::BookmarkType::AllBookmarks) {
+ query.bind_int(1, static_cast<int>(type));
+ }
+
+ if (!query.exec()) {
+ BROWSER_LOGW("Query execution failed");
+ return false;
+ }
+
+ sendSignal(new BookmarkSigData(
+ this, BookmarkSigData::SigType::AllBookmarksRemoved, type));
+ return true;
+}
+
+bool SQLBookmarkModel::removeChildren(const BrowserFWCore::BookmarkItem& item) {
+ BROWSER_LOGD("");
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return false;
+ }
+ auto children =
+ getBookmarks(BrowserFWCore::IBookmarkModel::CreationTime, 0, 0,
+ BrowserFWCore::BookmarkType::AllBookmarks, item.getID());
+ for (const auto& child : children) {
+ remove(child);
+ }
+
+ children =
+ getBookmarks(BrowserFWCore::IBookmarkModel::CreationTime, 0, 0,
+ BrowserFWCore::BookmarkType::AllBookmarks, item.getID());
+
+ if (children.empty()) {
+ return true;
+ }
+
+ return false;
+}
+
+std::vector<BrowserFWCore::BookmarkItem> SQLBookmarkModel::getBookmarks(
+ BrowserFWCore::IBookmarkModel::BookmarkItemOrder order,
+ int limit,
+ int offset,
+ BrowserFWCore::BookmarkType type,
+ BrowserFWCore::BookmarkID parentID) {
+ BROWSER_LOGD("");
+ std::vector<BrowserFWCore::BookmarkItem> items;
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return items;
+ }
+
+ std::string queryStr("SELECT ");
+ queryStr.append(modelQueryItemsLoad);
+ queryStr.append(" FROM " + m_tableName);
+ queryStr.append(" WHERE parent_id = ?");
+ if (type != BrowserFWCore::BookmarkType::AllBookmarks) {
+ queryStr.append(" AND type = ? ");
+ }
+
+ switch (order) {
+ case BrowserFWCore::IBookmarkModel::BookmarkItemOrder::AccessTime:
+ queryStr.append(" ORDER BY access_time DESC");
+ break;
+ case BrowserFWCore::IBookmarkModel::BookmarkItemOrder::CreationTime:
+ queryStr.append(" ORDER BY creation_time DESC");
+ break;
+ case BrowserFWCore::IBookmarkModel::BookmarkItemOrder::Url:
+ queryStr.append(" ORDER BY uri DESC");
+ break;
+ case BrowserFWCore::IBookmarkModel::BookmarkItemOrder::Title:
+ queryStr.append(" ORDER BY title DESC");
+ break;
+ default:
+ break;
+ }
+
+ if (limit > 0) {
+ queryStr.append(" LIMIT ");
+ queryStr.append(std::to_string(limit));
+ }
+
+ sql_query query(m_db->prepare(queryStr.c_str()));
+ std::string parentIDString =
+ (parentID != BrowserFWCore::BookmarkID::NONE ? parentID.toString() : "");
+
+ query.bind_text(1, parentIDString.c_str());
+
+ if (type != BrowserFWCore::BookmarkType::AllBookmarks) {
+ query.bind_int(2, static_cast<int>(type));
+ }
+
+ if (!query.exec()) {
+ BROWSER_LOGW("Query execution failed");
+ return items;
+ }
+
+ while (query.has_next()) {
+ items.push_back(loadItemFromQuery(&query));
+ query.next();
+ }
+ return items;
+}
+
+BrowserFWCore::BookmarkItem SQLBookmarkModel::getBookmark(
+ const BrowserFWCore::BookmarkID& id) {
+ BROWSER_LOGD("");
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return BrowserFWCore::BookmarkItem::INVALID;
+ }
+
+ std::string queryStr = "SELECT ";
+ queryStr.append(modelQueryItemsLoad);
+ queryStr.append(" FROM " + m_tableName);
+ queryStr.append(" WHERE uuid = ?");
+ sql_query query(m_db->prepare(queryStr.c_str()));
+ query.bind_text(1, id.toString().c_str());
+
+ if (!query.exec()) {
+ BROWSER_LOGD("Exec query failed");
+ return BrowserFWCore::BookmarkItem::INVALID;
+ }
+
+ if (!query.has_next()) {
+ BROWSER_LOGD("Item with ID %s not found", id.toString().c_str());
+ return BrowserFWCore::BookmarkItem::INVALID;
+ }
+ return loadItemFromQuery(&query);
+}
+
+BrowserFWCore::BookmarkItem SQLBookmarkModel::getBookmark(
+ const BrowserFWCore::URIString& url) {
+ BROWSER_LOGD("");
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return BrowserFWCore::BookmarkItem::INVALID;
+ }
+
+ std::string queryStr = "SELECT ";
+ queryStr.append(modelQueryItemsLoad);
+ queryStr.append(" FROM " + m_tableName);
+ queryStr.append(" WHERE uri = ? ");
+ sql_query query(m_db->prepare(queryStr.c_str()));
+ query.bind_text(1, url.getCStr());
+
+ if (!query.exec()) {
+ BROWSER_LOGD("Exec query failed");
+ return BrowserFWCore::BookmarkItem::INVALID;
+ }
+
+ if (!query.has_next()) {
+ BROWSER_LOGD("Item with URL %s not found", url.getCStr());
+ return BrowserFWCore::BookmarkItem::INVALID;
+ }
+ return loadItemFromQuery(&query);
+}
+
+int SQLBookmarkModel::count() {
+ BROWSER_LOGD("");
+ int itemCount = -1;
+
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return itemCount;
+ }
+ sql_query query(m_db->prepare("SELECT count(*) FROM " + m_tableName));
+
+ if (!query.exec() || !query.has_next()) {
+ BROWSER_LOGW("Query execution failed");
+ return itemCount;
+ }
+
+ itemCount = query.get_int(0);
+ return itemCount;
+}
+
+int SQLBookmarkModel::count(BrowserFWCore::BookmarkType type) {
+ BROWSER_LOGD("");
+
+ if (type == BrowserFWCore::BookmarkType::AllBookmarks) {
+ return count();
+ }
+
+ int itemCount = -1;
+
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return itemCount;
+ }
+ sql_query query(
+ m_db->prepare("SELECT count(*) FROM " + m_tableName + " WHERE type = ?"));
+
+ query.bind_int(1, static_cast<int>(type));
+
+ if (!query.exec() || !query.has_next()) {
+ BROWSER_LOGW("Query execution failed");
+ return itemCount;
+ }
+
+ itemCount = query.get_int(0);
+ return itemCount;
+}
+
+int SQLBookmarkModel::count(const BrowserFWCore::URIString& url) {
+ BROWSER_LOGD("");
+
+ int itemCount = -1;
+
+ if (!m_db) {
+ BROWSER_LOGW("Database not initialized.");
+ return itemCount;
+ }
+ sql_query query(
+ m_db->prepare("SELECT count(*) FROM " + m_tableName + " WHERE uri = ?"));
+
+ query.bind_text(1, url.getCStr());
+
+ if (!query.exec() || !query.has_next()) {
+ BROWSER_LOGW("Query execution failed");
+ return itemCount;
+ }
+
+ itemCount = query.get_int(0);
+ return itemCount;
+}
+
+BrowserFWCore::BookmarkItem SQLBookmarkModel::loadItemFromQuery(
+ sql_query* query) const {
+ if (!query) {
+ return BrowserFWCore::BookmarkItem();
+ }
+
+ std::string id = query->get_string(1);
+ std::string uri = query->get_string(2);
+ std::string title = query->get_string(3);
+ BrowserFWCore::BookmarkType type =
+ static_cast<BrowserFWCore::BookmarkType>(query->get_int(6));
+ std::string source = query->get_string(7);
+ BrowserFWCore::BookmarkItemType itemType =
+ static_cast<BrowserFWCore::BookmarkItemType>(query->get_int(8));
+ std::string parentID = query->get_string(9);
+ BrowserFWCore::BookmarkItem item(id, uri, title, source, type, itemType,
+ parentID);
+ item.setCreationTime(query->get_time(4));
+ item.setAccessTime(query->get_time(5));
+
+ return item;
+}
+
+} // namespace BrowserStorage
--- /dev/null
+
+#ifndef SQLBookmarkModel_h
+#define SQLBookmarkModel_h
+
+#include "components/samsung/bpbookmark_model/samsung_bookmark_id.h"
+#include "components/samsung/bpbookmark_model/samsung_bookmark_item.h"
+#include "components/samsung/bpbookmark_model/samsung_ibookmark_model.h"
+#include "samsung_enums.h"
+
+namespace sql {
+class Database;
+}
+
+class sql_query;
+
+namespace samsung_browser_storage {
+
+/**
+ * @brief
+ *
+ * @class SQLBookmarkModel SQLBookmarkModel.h
+ * "managers/StorageManager/SQLBookmarkModel/SQLBookmarkModel.h"
+ */
+class SQLBookmarkModel : public samsung_browser_fw_core::IBookmarkModel {
+ public:
+ explicit SQLBookmarkModel(const std::string&);
+ /**
+ * @brief
+ *
+ * @fn ~SQLBookmarkModel
+ */
+ ~SQLBookmarkModel();
+ /**
+ * @brief
+ *
+ * @fn init
+ * @return bool
+ */
+ bool init();
+ /**
+ * @brief
+ *
+ * @fn deinit
+ * @return bool
+ */
+ void deinit();
+ /**
+ * @brief
+ *
+ * @fn add
+ * @param samsung_browser_fw_core::BookmarkItem
+ * @return bool
+ */
+ bool add(samsung_browser_fw_core::BookmarkItem&);
+ /**
+ * @brief
+ *
+ * @fn remove
+ * @param samsung_browser_fw_core::BookmarkItem
+ * @return bool
+ */
+ bool remove(const samsung_browser_fw_core::BookmarkItem&);
+ /**
+ * @brief
+ *
+ * @fn removeURL
+ * @param samsung_browser_fw_core::BookmarkItem
+ * @return bool
+ */
+ bool removeURL(const samsung_browser_fw_core::BookmarkItem&);
+ /**
+ * @brief
+ *
+ * @fn removeAll
+ * @param samsung_browser_fw_core::BookmarkType
+ * @return bool
+ */
+ bool removeAll(samsung_browser_fw_core::BookmarkType) override;
+ /**
+ * @brief
+ *
+ * @fn removeContainedOfFolder
+ * @param samsung_browser_fw_core::BookmarkItem
+ * @return bool
+ */
+ bool removeChildren(const samsung_browser_fw_core::BookmarkItem&) override;
+ /**
+ * @brief
+ *
+ * @fn getBookmarks
+ * @param samsung_browser_fw_core::IBookmarkModel::BookmarkItemOrder
+ * @param limit
+ * @param offset
+ * @param samsung_browser_fw_core::BookmarkType
+ * @return std::vector<samsung_browser_fw_core::BookmarkItem>
+ */
+ std::vector<samsung_browser_fw_core::BookmarkItem> getBookmarks(
+ samsung_browser_fw_core::IBookmarkModel::BookmarkItemOrder,
+ int limit,
+ int offset,
+ samsung_browser_fw_core::BookmarkType,
+ samsung_browser_fw_core::BookmarkID parentID =
+ samsung_browser_fw_core::BookmarkID::NONE);
+ /**
+ * @brief
+ *
+ * @fn getBookmark
+ * @param url
+ * @return samsung_browser_fw_core::BookmarkItem
+ */
+ samsung_browser_fw_core::BookmarkItem getBookmark(const std::string& url);
+ /**
+ * @brief
+ *
+ * @fn getBookmark
+ * @param
+ * @return samsung_browser_fw_core::BookmarkItem
+ */
+ samsung_browser_fw_core::BookmarkItem getBookmark(
+ const samsung_browser_fw_core::BookmarkID&);
+ /**
+ * @brief
+ *
+ * @fn count
+ * @return int
+ */
+ int count();
+ /**
+ * @brief
+ *
+ * @fn count
+ * @param samsung_browser_fw_core::BookmarkType
+ * @return int
+ */
+ int count(samsung_browser_fw_core::BookmarkType);
+ /**
+ * @brief
+ *
+ * @fn count
+ * @param URIString
+ * @return int
+ */
+ virtual int count(const std::string& url);
+ /**
+ * @brief
+ *
+ * @var sourceName
+ */
+ static std::string sourceName;
+ /**
+ * @brief
+ *
+ * @fn getInfoModel
+ * @return std::string
+ */
+ std::string getSourceName() const { return sourceName; }
+
+ private:
+ /**
+ * @brief
+ *
+ * @fn loadItemFromQuery
+ * @param query
+ * @return samsung_browser_fw_core::BookmarkItem
+ */
+ samsung_browser_fw_core::BookmarkItem loadItemFromQuery(
+ sql_query* query) const;
+ /**
+ * @brief
+ *
+ * @var m_db
+ */
+ std::shared_ptr<sql_db> m_db;
+ const std::string m_tableName;
+ bool m_initialized;
+};
+
+} // namespace samsung_browser_storage
+#endif // SQLBookmarkModel_h
tizen_pkg_config("libcapi-cloud-tab") {
packages = [ "capi-cloud-tab" ]
}
+
+ config("capi-cloud-bookmark"){
+ ldflags = ["-lcapi-cloud-bookmark"]
+ cflags = ["-dapi-provider"]
+ }
+
+ tizen_pkg_config("libcapi-cloud-bookmark"){
+ packages = [ "capi-cloud-bookmark" ]
+ }
}
#Next browser package ends
projects / platform / framework / web / chromium-efl.git / commitdiff