webapp-detail/advancedview.cpp

   1 /*
   2   * Copyright 2012  Samsung Electronics Co., Ltd
   3   *
   4   * Licensed under the Flora License, Version 1.0 (the "License");
   5   * you may not use this file except in compliance with the License.
   6   * You may obtain a copy of the License at
   7   *
   8   *     http://floralicense.org/license/
   9   *
  10   * Unless required by applicable law or agreed to in writing, software
  11   * distributed under the License is distributed on an "AS IS" BASIS,
  12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13   * See the License for the specific language governing permissions and
  14   * limitations under the License.
  15   */
  16
  17 #include "advancedview.h"
  18
  19 #include <vector>
  20 #include <map>
  21 #include <string>
  22 #include <cstring>
  23 #include <Elementary.h>
  24 #include <vconf.h>
  25
  26 #include <dpl/foreach.h>
  27 #include <dpl/assert.h>
  28 #include <dpl/wrt-dao-ro/WrtDatabase.h>
  29 #include <dpl/wrt-dao-ro/vconf_config.h>
  30 #include <dpl/wrt-dao-rw/widget_dao.h>
  31 #include "exceptionsview.h"
  32 #include "util.h"
  33
  34 namespace WebAppDetailSetting {
  35
  36 namespace  {
  37 const char* const ELM_STYLE_ON_OFF = "on&off";
  38 const char* const ELM_PART_ICON = "elm.icon";
  39 const char* const EVAS_SMART_CALLBACK_CHANGED = "changed";
  40 const char* const ELM_GENLIST_ITEM_CLASS_STYLE_GROUPINDEX = "groupindex";
  41 const char* const ELM_GENLIST_ITEM_CLASS_STYLE_1TEXT = "1text";
  42 const char* const ELM_GENLIST_ITEM_CLASS_STYLE_1TEXT_1ICON_6 = "1text.1icon.6";
  43 const char* const TEXT_NAVIFRAME_TITLE = "Advanced Settings";
  44 }
  45
  46 AdvancedView::AdvancedView(Evas_Object *navi, int appID) :
  47     m_naviframe(navi),
  48     m_appID(appID)
  49 {
  50     m_groupMenuMap[GROUP_IDX_SECURITY_SETTINGS] = "Security Settings";
  51     m_groupMenuMap[GROUP_IDX_DEVELOPER_OPTIONS] = "Developer Options";
  52
  53     m_menuMap[SECURITY_SETTINGS_IDX_SECURITY_POPUP_USAGE] =
  54         "Show security warnings";
  55     m_menuMap[SECURITY_SETTINGS_IDX_GEOLOCATION_USAGE] =
  56         "Location";
  57     m_menuMap[SECURITY_SETTINGS_IDX_WEB_NOTIFICATION_USAGE] =
  58         "Web notification";
  59     m_menuMap[SECURITY_SETTINGS_IDX_WEB_DATABASE_USAGE] =
  60         "Web database";
  61     m_menuMap[SECURITY_SETTINGS_IDX_FILE_SYSTEM_USAGE] =
  62         "File system access";
  63     m_menuMap[SECURITY_SETTINGS_IDX_EXCEPTIONS_SETTINGS] =
  64         "Exceptions Settings";
  65     m_menuMap[DEVELOPER_OPTIONS_IDX_MEMORY_SAVING_MODE] =
  66         "Memory Saving Mode";
  67 }
  68
  69 AdvancedView::~AdvancedView(void)
  70 {
  71 }
  72
  73 char* AdvancedView::getGroupText(void* data,
  74                                  Evas_Object* /*obj*/,
  75                                  const char* /*part*/)
  76 {
  77     Assert(data);
  78     AdvancedSettingsGroupData* advancedSettingsData =
  79         static_cast<AdvancedSettingsGroupData*>(data);
  80     return strdup(advancedSettingsData->m_menuText.c_str());
  81 }
  82
  83 void AdvancedView::delGroupData(void* data,
  84                                 Evas_Object* /*obj*/)
  85 {
  86     Assert(data);
  87     AdvancedSettingsGroupData* advancedSettingsData =
  88         static_cast<AdvancedSettingsGroupData*>(data);
  89     delete advancedSettingsData;
  90 }
  91
  92 char* AdvancedView::getSettingText(void *data,
  93                                            Evas_Object* /*obj*/,
  94                                            const char* /*part*/)
  95 {
  96     Assert(data);
  97     SettingData* settingData = static_cast<SettingData*>(data);
  98     return strdup(settingData->m_menuText.c_str());
  99 }
 100
 101 Evas_Object* AdvancedView::getSettingContent(void* data,
 102                                                      Evas_Object* obj,
 103                                                      const char* /*part*/)
 104 {
 105     Assert(data);
 106     SettingData* settingData =
 107         static_cast<SettingData*>(data);
 108
 109     Assert(obj);
 110     Evas_Object* icon = elm_check_add(obj);
 111     elm_check_state_set(icon, EINA_TRUE);
 112     elm_object_style_set(icon, ELM_STYLE_ON_OFF);
 113     settingData->m_iconPart = ELM_PART_ICON;
 114
 115     evas_object_propagate_events_set(
 116         icon,
 117         EINA_FALSE);
 118     elm_check_state_set(icon, settingData->isEnabled() ? EINA_TRUE : EINA_FALSE);
 119     evas_object_smart_callback_add(icon,
 120                                    EVAS_SMART_CALLBACK_CHANGED,
 121                                    settingChangedCallback,
 122                                    data);
 123
 124     return icon;
 125 }
 126
 127 void AdvancedView::delSettingData(void* data,
 128                                           Evas_Object* /*obj*/)
 129 {
 130     Assert(data);
 131     SettingData* settingData = static_cast<SettingData*>(data);
 132     delete settingData;
 133 }
 134
 135 void AdvancedView::settingSelectedCallback(void* data,
 136                                                    Evas_Object* obj,
 137                                                    void* eventInfo)
 138 {
 139     Assert(eventInfo);
 140     Elm_Object_Item* item = static_cast<Elm_Object_Item*>(eventInfo);
 141     elm_genlist_item_selected_set(item, EINA_FALSE);
 142
 143     SettingData* settingData =
 144         static_cast<SettingData*>(elm_object_item_data_get(item));
 145     Assert(settingData);
 146
 147     Evas_Object* check =
 148         elm_object_item_part_content_get(item,
 149                                          settingData->m_iconPart.c_str());
 150     Assert(check);
 151     bool state = !elm_check_state_get(check);
 152     settingData->saveChange(state);
 153     elm_check_state_set(check, state);
 154 }
 155
 156 void AdvancedView::settingChangedCallback(void* data,
 157                                                   Evas_Object* obj,
 158                                                   void* eventInfo)
 159 {
 160     Assert(data);
 161     SettingData* settingData =
 162         static_cast<SettingData*>(data);
 163     Assert(obj);
 164     settingData->saveChange(elm_check_state_get(obj));
 165 }
 166
 167 char* AdvancedView::getSecurityExceptionsSettingsText(void *data,
 168                                                       Evas_Object *obj,
 169                                                       const char *part)
 170 {
 171     Assert(data);
 172     return strdup("Exceptions Settings");
 173 }
 174
 175 void AdvancedView::securityExceptionsSettingsSelectedCallback(void* data,
 176                                                               Evas_Object* obj,
 177                                                               void* eventInfo)
 178 {
 179     Assert(eventInfo);
 180     Elm_Object_Item* item = static_cast<Elm_Object_Item*>(eventInfo);
 181     elm_genlist_item_selected_set(item, EINA_FALSE);
 182
 183     AdvancedView* This =
 184         static_cast<AdvancedView*>(elm_object_item_data_get(item));
 185     Assert(This);
 186     This->m_exceptionsView.Reset(
 187         new ExceptionsView(This->m_naviframe, This->m_appID));
 188     if (!This->m_exceptionsView->loadView()) {
 189         This->m_exceptionsView.Reset();
 190     }
 191 }
 192
 193 bool AdvancedView::loadView(void)
 194 {
 195     resetBase();
 196
 197     Evas_Object* genlist = NULL;
 198     genlist = elm_genlist_add(m_naviframe);
 199
 200     // create group menu
 201     static Elm_Genlist_Item_Class itcGroup = {0,};
 202     itcGroup.item_style = ELM_GENLIST_ITEM_CLASS_STYLE_GROUPINDEX;
 203     itcGroup.func.text_get = getGroupText;
 204     itcGroup.func.del = delGroupData;
 205
 206     for (int index = GROUP_IDX_START; index <= GROUP_IDX_END; index++) {
 207         Elm_Object_Item* groupItem =
 208             elm_genlist_item_append(genlist,
 209                                     &itcGroup,
 210                                     static_cast<void*>(
 211                                         new AdvancedSettingsGroupData(
 212                                             m_groupMenuMap[index])),
 213                                     NULL,
 214                                     ELM_GENLIST_ITEM_NONE,
 215                                     NULL,
 216                                     NULL);
 217         elm_genlist_item_select_mode_set(groupItem,
 218                                          ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 219
 220         if (index == GROUP_IDX_SECURITY_SETTINGS) {
 221             // create Security Settings menu
 222             loadSecuritySettingsMenu(genlist);
 223         } else if (index == GROUP_IDX_DEVELOPER_OPTIONS) {
 224             // create developer Options menu
 225             loadDeveloperOptionsMenu(genlist);
 226         } else {
 227             LogError("Wrong index");
 228         }
 229     }
 230     elm_naviframe_item_push(m_naviframe,
 231                             TEXT_NAVIFRAME_TITLE,
 232                             NULL,
 233                             NULL,
 234                             genlist,
 235                             NULL);
 236     resetBase(genlist);
 237     return true;
 238 }
 239
 240 void AdvancedView::loadSecuritySettingsMenu(Evas_Object* genlist)
 241 {
 242     for (int index = SECURITY_SETTINGS_IDX_START; index <= SECURITY_SETTINGS_IDX_END; index++) {
 243         if (index == SECURITY_SETTINGS_IDX_EXCEPTIONS_SETTINGS) {
 244             // create exceptions security settings menu
 245             static Elm_Genlist_Item_Class itcSecurityExceptionsSettings = {0,};
 246             itcSecurityExceptionsSettings.item_style =
 247                 ELM_GENLIST_ITEM_CLASS_STYLE_1TEXT;
 248             itcSecurityExceptionsSettings.func.text_get = getSecurityExceptionsSettingsText;
 249             itcSecurityExceptionsSettings.func.content_get = NULL;
 250             itcSecurityExceptionsSettings.func.state_get = NULL;
 251             itcSecurityExceptionsSettings.func.del = NULL;
 252             elm_genlist_item_append(genlist,
 253                                     &itcSecurityExceptionsSettings,
 254                                     static_cast<void*>(this),
 255                                     NULL,
 256                                     ELM_GENLIST_ITEM_NONE,
 257                                     securityExceptionsSettingsSelectedCallback,
 258                                     NULL);
 259
 260         } else {
 261             // create usage menu
 262             static Elm_Genlist_Item_Class itcSecuritySettings = {0,};
 263             itcSecuritySettings.item_style =
 264                 ELM_GENLIST_ITEM_CLASS_STYLE_1TEXT_1ICON_6;
 265             itcSecuritySettings.func.text_get = getSettingText;
 266             itcSecuritySettings.func.content_get = getSettingContent;
 267             itcSecuritySettings.func.state_get = NULL;
 268             itcSecuritySettings.func.del = delSettingData;
 269
 270             elm_genlist_item_append(genlist,
 271                                     &itcSecuritySettings,
 272                                     static_cast<void*>(
 273                                         new SettingData(
 274                                             m_appID, index, m_menuMap[index])),
 275                                     NULL,
 276                                     ELM_GENLIST_ITEM_NONE,
 277                                     settingSelectedCallback,
 278                                     NULL);
 279         }
 280     }
 281 }
 282
 283 void AdvancedView::loadDeveloperOptionsMenu(Evas_Object* genlist)
 284 {
 285     static Elm_Genlist_Item_Class itcDeveloperOptions = {0,};
 286     itcDeveloperOptions.item_style =
 287         ELM_GENLIST_ITEM_CLASS_STYLE_1TEXT_1ICON_6;
 288     itcDeveloperOptions.func.text_get = getSettingText;
 289     itcDeveloperOptions.func.content_get = getSettingContent;
 290     itcDeveloperOptions.func.state_get = NULL;
 291     itcDeveloperOptions.func.del = delSettingData;
 292
 293     for (int index = DEVELOPER_OPTIONS_IDX_START; index <= DEVELOPER_OPTIONS_IDX_END; index++) {
 294         elm_genlist_item_append(genlist,
 295                                 &itcDeveloperOptions,
 296                                 static_cast<void*>(
 297                                     new SettingData(
 298                                         m_appID, index, m_menuMap[index])),
 299                                 NULL,
 300                                 ELM_GENLIST_ITEM_NONE,
 301                                 settingSelectedCallback,
 302                                 NULL);
 303     }
 304 }
 305
 306 SettingData::SettingData(int appID, int index, std::string menuText) :
 307     m_index(static_cast<MenuIndex>(index)),
 308     m_menuText(menuText)
 309 {
 310     m_dao.Reset(new WrtDB::WidgetDAO(appID));
 311 }
 312
 313 bool SettingData::isEnabled()
 314 {
 315     using namespace WrtDB;
 316     std::string key;
 317     if (m_index == SECURITY_SETTINGS_IDX_SECURITY_POPUP_USAGE) {
 318         key = VconfConfig::GetVconfKeyPopupUsage(m_dao->getPkgName());
 319     } else if (m_index == SECURITY_SETTINGS_IDX_GEOLOCATION_USAGE) {
 320         key = VconfConfig::GetVconfKeyGeolocationUsage(m_dao->getPkgName());
 321     } else if (m_index == SECURITY_SETTINGS_IDX_WEB_NOTIFICATION_USAGE) {
 322         key = VconfConfig::GetVconfKeyWebNotificationUsage(
 323             m_dao->getPkgName());
 324     } else if (m_index == SECURITY_SETTINGS_IDX_WEB_DATABASE_USAGE) {
 325         key = VconfConfig::GetVconfKeyWebDatabaseUsage(m_dao->getPkgName());
 326     } else if (m_index == SECURITY_SETTINGS_IDX_FILE_SYSTEM_USAGE) {
 327         key = VconfConfig::GetVconfKeyFilesystemUsage(m_dao->getPkgName());
 328     } else if (m_index == DEVELOPER_OPTIONS_IDX_MEMORY_SAVING_MODE) {
 329         key = VconfConfig::GetVconfKeyMemorySavingMode(m_dao->getPkgName());
 330     } else {
 331         Assert("Wrong menu index");
 332     }
 333
 334     int ret = 0;
 335     vconf_get_int(key.c_str(), &ret);
 336     if (static_cast<SettingsType>(ret) == SETTINGS_TYPE_ON) {
 337         return true;
 338     } else if (static_cast<SettingsType>(ret) == SETTINGS_TYPE_OFF) {
 339         return false;
 340     }
 341
 342     Assert("Unsupported value");
 343     // For preventing compile warning, even this code isn't necessary.
 344     return false;
 345 }
 346
 347 void SettingData::saveChange(bool state)
 348 {
 349     using namespace WrtDB;
 350     SettingsType result = state ? SETTINGS_TYPE_ON : SETTINGS_TYPE_OFF;
 351
 352     std::string key;
 353     if (m_index == SECURITY_SETTINGS_IDX_SECURITY_POPUP_USAGE) {
 354         key = VconfConfig::GetVconfKeyPopupUsage(m_dao->getPkgName());
 355     } else if (m_index == SECURITY_SETTINGS_IDX_GEOLOCATION_USAGE) {
 356         key = VconfConfig::GetVconfKeyGeolocationUsage(m_dao->getPkgName());
 357     } else if (m_index == SECURITY_SETTINGS_IDX_WEB_NOTIFICATION_USAGE) {
 358         key = VconfConfig::GetVconfKeyWebNotificationUsage(
 359             m_dao->getPkgName());
 360     } else if (m_index == SECURITY_SETTINGS_IDX_WEB_DATABASE_USAGE) {
 361         key = VconfConfig::GetVconfKeyWebDatabaseUsage(m_dao->getPkgName());
 362     } else if (m_index == SECURITY_SETTINGS_IDX_FILE_SYSTEM_USAGE) {
 363         key = VconfConfig::GetVconfKeyFilesystemUsage(m_dao->getPkgName());
 364     } else if (m_index == DEVELOPER_OPTIONS_IDX_MEMORY_SAVING_MODE) {
 365         key = VconfConfig::GetVconfKeyMemorySavingMode(m_dao->getPkgName());
 366     } else {
 367         Assert("Wrong menu index");
 368     }
 369     vconf_set_int(key.c_str(), static_cast<int>(result));
 370 }
 371
 372 } /* WebAppDetailSetting */