src/controls/FWebCtrl_UserConfirmPopup.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FWebCtrl_UserConfirmPopup.cpp
  20  * @brief               The file contains the definition of _UserConfirmPopup class.
  21  */
  22 #include <FAppApp.h>
  23 #include <FBaseColArrayList.h>
  24 #include <FBaseSysLog.h>
  25 #include <FBaseUtilUri.h>
  26 #include <FGrpDimension.h>
  27 #include <FGrpRectangle.h>
  28 #include <FIoDbEnumerator.h>
  29 #include <FIoDbStatement.h>
  30 #include <FSecCertX509Certificate.h>
  31 #include <FUiCtrlButton.h>
  32 #include <FUiCtrlLabel.h>
  33 #include <FUiCtrlPanel.h>
  34 #include <FUiLayout.h>
  35 #include <FUiVerticalBoxLayout.h>
  36 #include <FIo_DatabaseImpl.h>
  37 #include <FUi_ControlManager.h>
  38 #include <FUi_ResourceManager.h>
  39 #include "FWebCtrl_EflWebkit.h"
  40 #include "FWebCtrl_UserConfirmPopup.h"
  41 #include "FWebCtrl_Utility.h"
  42
  43
  44 using namespace Tizen::Base;
  45 using namespace Tizen::Base::Collection;
  46 using namespace Tizen::Base::Utility;
  47 using namespace Tizen::Graphics;
  48 using namespace Tizen::Io;
  49 using namespace Tizen::Security::Cert;
  50 using namespace Tizen::Ui;
  51 using namespace Tizen::Ui::Controls;
  52
  53
  54 namespace Tizen { namespace Web { namespace Controls
  55 {
  56
  57
  58 _UserConfirmPopup::_UserConfirmPopup(void)
  59         : __pUserPolicyData(null)
  60         , __userConfirmMode(USER_CONFIRM_USERMEDIA)
  61         , __pCheckButton(null)
  62         , __sync(false)
  63 {
  64 }
  65
  66
  67 _UserConfirmPopup::~_UserConfirmPopup(void)
  68 {
  69 }
  70
  71
  72 result
  73 _UserConfirmPopup::Construct(_UserConfirmMode userConfirmMode, void* pEventInfo, bool sync)
  74 {
  75         result r = E_SUCCESS;
  76         SysTryReturnResult(NID_WEB_CTRL, pEventInfo, E_INVALID_ARG, "Invalid argument(s) is used. pPolicy is null.");
  77         SysTryReturnResult(NID_WEB_CTRL, userConfirmMode >= USER_CONFIRM_USERMEDIA && userConfirmMode <= USER_CONFIRM_GEOLOCATION, E_INVALID_ARG,
  78                                         "Invalid userConfirmMode is used. [%d]", userConfirmMode);
  79
  80         _WebPopupData* pPopupData = _WebPopup::GetPopupData();
  81         SysTryReturn(NID_WEB_CTRL, pPopupData, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
  82
  83         __pUserPolicyData = pEventInfo;
  84         __userConfirmMode = userConfirmMode;
  85         __sync = sync;
  86
  87         int popupMaxHeight = 2*pPopupData->labelDim.height + 2*pPopupData->btnDim.height + 6*pPopupData->sideMargin;
  88         if (__userConfirmMode == USER_CONFIRM_GEOLOCATION)
  89         {
  90                 popupMaxHeight +=  pPopupData->checkDim.height;
  91         }
  92
  93         r = _WebPopup::Construct(true, Dimension(pPopupData->popupDim.width, popupMaxHeight));
  94         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
  95
  96         SetTitleText("Security Warning");
  97
  98         Rectangle rect(0, 0, 0, 0);
  99
 100         //label
 101         rect.height = 2*pPopupData->labelDim.height;
 102         rect.width = pPopupData->labelDim.width;
 103
 104         std::unique_ptr<Label> pLabel(new (std::nothrow) Label());
 105         SysTryReturnResult(NID_WEB_CTRL, pLabel.get(), E_OUT_OF_MEMORY, "Memory Allocation failed.");
 106
 107         String message = GetMessageFromPolicy();
 108         r = pLabel->Construct(rect, message);
 109         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 110
 111         pLabel->SetTextConfig(pPopupData->labelFontSize, LABEL_TEXT_STYLE_NORMAL);
 112
 113         r = AddControl(*pLabel);
 114         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 115
 116         Label* pInfoLabel = pLabel.release();
 117         //checkbutton
 118         if (__userConfirmMode == USER_CONFIRM_GEOLOCATION)
 119         {
 120                 rect.y = 0;
 121                 rect.height = pPopupData->checkDim.height;
 122
 123                 std::unique_ptr<CheckButton> pCheckButton (new (std::nothrow) CheckButton());
 124                 SysTryReturnResult(NID_WEB_CTRL, pCheckButton.get(), E_OUT_OF_MEMORY, "Memory Allocation failed.");
 125
 126                 r = pCheckButton->Construct(Rectangle(0, 0, rect.width, rect.height), CHECK_BUTTON_STYLE_MARK, BACKGROUND_STYLE_NONE, false, L"Remember Preference");
 127                 SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 128
 129                 r = AddControl(*pCheckButton);
 130                 SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 131
 132                 __pCheckButton = pCheckButton.release();
 133         }
 134
 135         Panel* pButtonPanel = CreateAndAddPanel();
 136         SysTryReturn(NID_WEB_CTRL, pButtonPanel, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 137
 138         ArrayList idList;
 139         r = idList.Construct();
 140         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 141         idList.Add(*(new Integer(ID_BUTTON_USER_ALLOW)));
 142         idList.Add(*(new Integer(ID_BUTTON_USER_CANCEL)));
 143
 144         ArrayList titleList;
 145         r = titleList.Construct();
 146         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 147         titleList.Add(*(new String(L"Allow")));
 148         titleList.Add(*(new String(L"Cancel")));
 149
 150         r = CreateAndAddButtons(idList, titleList, pButtonPanel);
 151         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 152
 153         std::unique_ptr<VerticalBoxLayout> pLayout(dynamic_cast< VerticalBoxLayout* >(GetLayoutN()));
 154         SysTryReturn(NID_WEB_CTRL, pLayout.get(), r = GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 155
 156         pLayout->SetHorizontalAlignment(*pInfoLabel, LAYOUT_HORIZONTAL_ALIGN_CENTER);
 157         if (__userConfirmMode == USER_CONFIRM_GEOLOCATION)
 158         {
 159                 pLayout->SetHorizontalAlignment(*__pCheckButton, LAYOUT_HORIZONTAL_ALIGN_CENTER);
 160         }
 161         pLayout->SetHorizontalAlignment(*pButtonPanel, LAYOUT_HORIZONTAL_ALIGN_CENTER);
 162
 163         pLayout->SetSpacing(*pButtonPanel, 2*pPopupData->sideMargin);
 164
 165         return E_SUCCESS;
 166 }
 167
 168
 169 void
 170 _UserConfirmPopup::OnActionPerformed(const Control& source, int actionId)
 171 {
 172         result r = E_SUCCESS;
 173
 174         switch (actionId)
 175         {
 176         case ID_BUTTON_USER_ALLOW:
 177                 HandleUserAction(EINA_TRUE);
 178                 break;
 179
 180         case ID_BUTTON_USER_CANCEL:
 181                 HandleUserAction(EINA_FALSE);
 182                 break;
 183
 184         default:
 185                 break;
 186         }
 187
 188         r = HidePopup();
 189         if (IsFailed(r))
 190         {
 191                 SysLogException(NID_WEB_CTRL, r, "[%s] Propagating.", GetErrorMessage(r));
 192         }
 193
 194         if (!__sync)
 195         {
 196                 delete this;
 197         }
 198 }
 199
 200
 201 String
 202 _UserConfirmPopup::GetMessageFromPolicy(void)
 203 {
 204         String message;
 205
 206         switch(__userConfirmMode)
 207         {
 208         case USER_CONFIRM_USERMEDIA:
 209         {
 210                 message = L"Do you want to allow acccess to media?\n";
 211                 break;
 212         }
 213         case USER_PROTOCOL_HANDLER:
 214         {
 215                 Ewk_Custom_Handlers_Data* pHandlerData = reinterpret_cast< Ewk_Custom_Handlers_Data* >(__pUserPolicyData);
 216                 SysAssertf(pHandlerData, "Failed to request");
 217
 218                 String target(ewk_custom_handlers_data_target_get(pHandlerData));
 219                 String baseUri(ewk_custom_handlers_data_base_url_get(pHandlerData));
 220
 221                 message = baseUri + String(L" is asking to register ") + target + String(L" protocol handler.");
 222                 break;
 223         }
 224         case USER_CONTENT_HANDLER:
 225         {
 226                 Ewk_Custom_Handlers_Data* pHandlerData = reinterpret_cast< Ewk_Custom_Handlers_Data* >(__pUserPolicyData);
 227                 SysAssertf(pHandlerData, "Failed to request");
 228
 229                 String target(ewk_custom_handlers_data_target_get(pHandlerData));
 230                 String baseUri(ewk_custom_handlers_data_base_url_get(pHandlerData));
 231
 232                 message = String(baseUri) + String(L" is asking to register ") + String(target) + String(L" content handler.");
 233                 break;
 234         }
 235         case USER_CONFIRM_GEOLOCATION:
 236         {
 237                 Ewk_Geolocation_Permission_Request* pGeoLocPermReq = reinterpret_cast< Ewk_Geolocation_Permission_Request* >(__pUserPolicyData);
 238                 const Ewk_Security_Origin* pSecurityOrigin = ewk_geolocation_permission_request_origin_get(pGeoLocPermReq);
 239
 240                 message = _Utility::CreateOrigin(pSecurityOrigin);
 241                 message.Append(" Requests your Location");
 242                 break;
 243         }
 244         default:
 245                 SysAssert(false);
 246         }
 247
 248         return message;
 249 }
 250
 251
 252 void
 253 _UserConfirmPopup::HandleUserAction(Eina_Bool allow)
 254 {
 255         switch (__userConfirmMode)
 256         {
 257         case USER_CONFIRM_USERMEDIA:
 258         {
 259                 Ewk_User_Media_Permission_Request* pPolicy = reinterpret_cast< Ewk_User_Media_Permission_Request* >(__pUserPolicyData);
 260                 ewk_user_media_permission_request_set(pPolicy, allow);
 261                 break;
 262         }
 263         case USER_PROTOCOL_HANDLER:
 264         {
 265                 RegisterHandler(false, allow);
 266                 break;
 267         }
 268         case USER_CONTENT_HANDLER:
 269         {
 270                 RegisterHandler(true, allow);
 271                 break;
 272         }
 273         case USER_CONFIRM_GEOLOCATION:
 274         {
 275                 Ewk_Geolocation_Permission_Request* pPolicy =  reinterpret_cast< Ewk_Geolocation_Permission_Request* >(__pUserPolicyData);
 276                 if (__pCheckButton->IsSelected())
 277                 {
 278                         result r = AddGeolocationDb(pPolicy, static_cast < bool >(allow));
 279                         SysTryCatch(NID_WEB_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 280                 }
 281 CATCH:
 282                 ewk_geolocation_permission_request_set(pPolicy, allow);
 283                 break;
 284         }
 285         default:
 286                 SysAssert(false);
 287         }
 288 }
 289
 290
 291 result
 292 _UserConfirmPopup::AddGeolocationDb(Ewk_Geolocation_Permission_Request* pPolicy, bool enable)
 293 {
 294         _DatabaseImpl db;
 295         String geolocationPath(Tizen::App::App::GetInstance()->GetAppRootPath() + CUSTOM_DB_DIRECTORY_PATH + USER_CONFIRM_DB_NAME);
 296         String table(GEOLOCATION_TABLE_NAME);
 297
 298         const Ewk_Security_Origin* pSecurityOrigin = ewk_geolocation_permission_request_origin_get(pPolicy);
 299         String origin = _Utility::CreateOrigin(pSecurityOrigin);
 300
 301         result r = db.Construct(geolocationPath, "r+", null);
 302         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 303
 304         std::unique_ptr<DbStatement> pStmt(db.CreateStatementN(L"Insert Into " + table + L" (origin, permission) Values (?, ?)"));
 305         SysTryReturn(NID_WEB_CTRL, pStmt.get(), GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 306
 307         SysLog(NID_WEB_CTRL, "The current value of stmt is %u, host is %ls", pStmt.get(), origin.GetPointer());
 308
 309         pStmt->BindString(0, origin);
 310         pStmt->BindInt(1, static_cast < int >(enable));
 311
 312         db.BeginTransaction();
 313
 314         std::unique_ptr<DbEnumerator> pEnum(db.ExecuteStatementN(*pStmt));
 315
 316         db.CommitTransaction();
 317
 318         return E_SUCCESS;
 319 }
 320
 321 void
 322 _UserConfirmPopup::RegisterHandler(bool checkHandler, Eina_Bool allow)
 323 {
 324         _DatabaseImpl db;
 325         String handlerPath(Tizen::App::App::GetInstance()->GetAppRootPath() + CUSTOM_DB_DIRECTORY_PATH + USER_CONFIRM_DB_NAME);
 326         String table;
 327         int checkId = 0;
 328
 329         if(checkHandler == true)
 330         {
 331                 table = CUSTOM_CONTENT_TABLE_NAME;
 332         }
 333         else
 334         {
 335                 table = CUSTOM_PROTOCOL_TABLE_NAME;
 336         }
 337         Ewk_Custom_Handlers_Data* pHandlerData = reinterpret_cast< Ewk_Custom_Handlers_Data* >(__pUserPolicyData);
 338         SysAssertf(pHandlerData, "Failed to request");
 339
 340         String baseUri(ewk_custom_handlers_data_base_url_get(pHandlerData));
 341         String uri = ewk_custom_handlers_data_url_get(pHandlerData);
 342         String target = ewk_custom_handlers_data_target_get(pHandlerData);
 343
 344         result r = db.Construct(handlerPath, "r+", null);
 345         SysTryReturnVoidResult(NID_WEB_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 346
 347         std::unique_ptr<DbEnumerator> pEnum(db.QueryN(L"Select id From " + table + L" Where baseUrl = '" + baseUri + L"' AND url = '" + uri + L"' AND mime = '" + target + L"'"));
 348
 349         if(pEnum.get())
 350         {
 351                 pEnum->MoveNext();
 352                 pEnum->GetIntAt(0, checkId);
 353
 354                 std::unique_ptr<DbStatement> pUpdateStmt(db.CreateStatementN(L"Update " + table + L" Set allow = (?) Where id = (?)"));
 355                 SysTryReturnVoidResult(NID_WEB_CTRL, pUpdateStmt.get(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 356
 357                 pUpdateStmt->BindInt(0, static_cast < int >(allow));
 358                 pUpdateStmt->BindInt(1, checkId);
 359
 360                 db.BeginTransaction();
 361
 362                 std::unique_ptr<DbEnumerator> pEnum(db.ExecuteStatementN(*pUpdateStmt));
 363
 364                 db.CommitTransaction();
 365
 366         }
 367         else
 368         {
 369                 std::unique_ptr<DbStatement> pStmt(db.CreateStatementN(L"Insert Into " + table + L" (baseUrl, url, mime, allow) Values (?, ?, ?, ?)"));
 370                 SysTryReturnVoidResult(NID_WEB_CTRL, pStmt.get(),  GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 371
 372                 pStmt->BindString(0, baseUri);
 373                 pStmt->BindString(1, uri);
 374                 pStmt->BindString(2, target);
 375                 pStmt->BindInt(3, static_cast < int >(allow));
 376
 377                 db.BeginTransaction();
 378
 379                 std::unique_ptr<DbEnumerator> pRegisterEnum(db.ExecuteStatementN(*pStmt));
 380
 381                 db.CommitTransaction();
 382         }
 383 }
 384
 385 }}} // Tizen::Web::Controls