src/view/webkit/view_logic_geolocation_support.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
   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  * @file    view_logic_geolocation_support.cpp
  18  * @author  Grzegorz Krawczyk (g.krawczyk@samsung.com)
  19  */
  20
  21 #include "view_logic_geolocation_support.h"
  22
  23 #include <string>
  24 #include <sstream>
  25 #include <dpl/log/log.h>
  26 #include <dpl/assert.h>
  27 #include <wrt-commons/security-origin-dao/security_origin_dao_types.h>
  28 #include <wrt-commons/security-origin-dao/security_origin_dao.h>
  29 #include <EWebKit2.h>
  30 #include <widget_string.h>
  31 #include <common/view_logic_security_origin_support.h>
  32 #include <Elementary.h>
  33 #include <app.h>
  34
  35 namespace ViewModule {
  36 namespace GeolocationSupport {
  37 using namespace SecurityOriginDB;
  38 using namespace ViewModule::SecurityOriginSupportUtil;
  39
  40 namespace {
  41 // function declare
  42 void askUserForGeolocationPermission(
  43     Evas_Object* window,
  44     PermissionData* data);
  45 static void popupCallback(void* data, Evas_Object* obj, void* eventInfo);
  46
  47 void askUserForGeolocationPermission(
  48     Evas_Object* window,
  49     PermissionData* data)
  50 {
  51     LogDebug("askUserForGeolocationPermission called");
  52     std::string body = WRT_BODY_PS_REQUESTS_YOUR_LOCATION;
  53     std::string origin = DPL::ToUTF8String(data->m_originData.origin.host);
  54     if (origin.empty()) {
  55         char* name = NULL;
  56         if (app_get_name(&name) == APP_ERROR_NONE) {
  57             origin = name;
  58             free(name);
  59         } else {
  60             origin = "application";
  61         }
  62     }
  63     body.replace(body.find(WRT_PS),
  64                  std::string(WRT_PS).size(),
  65                  origin.c_str());
  66     Evas_Object* popup = createPopup(window,
  67                                      body.c_str(),
  68                                      WRT_BODY_REMEMBER_PREFERENCE,
  69                                      popupCallback,
  70                                      data);
  71
  72     if (popup == NULL) {
  73         LogError("Fail to create popup object");
  74         delete data;
  75         return;
  76     } else {
  77         evas_object_show(popup);
  78     }
  79 }
  80
  81 void popupCallback(void* data, Evas_Object* obj, void* /*eventInfo*/)
  82 {
  83     LogDebug("popupCallback");
  84     Assert(data);
  85     PermissionData* permData = static_cast<PermissionData*>(data);
  86     Ewk_Geolocation_Permission_Request* permissionRequest =
  87         static_cast<Ewk_Geolocation_Permission_Request*>(permData->m_data);
  88
  89     Evas_Object* popup = getPopup(obj);
  90     Result result = getResult(obj);
  91
  92     if (result != RESULT_UNKNOWN) {
  93         permData->m_originDao->setSecurityOriginData(permData->m_originData,
  94                                                      result);
  95     }
  96     Eina_Bool ret =
  97         (result == RESULT_ALLOW_ALWAYS || result == RESULT_ALLOW_ONCE) ?
  98         EINA_TRUE : EINA_FALSE;
  99     ewk_geolocation_permission_request_set(permissionRequest, ret);
 100     delete permData;
 101     evas_object_hide(popup);
 102     evas_object_del(popup);
 103 }
 104 } // namespace
 105
 106 void geolocationPermissionRequest(
 107     Evas_Object* window,
 108     SecurityOriginDB::SecurityOriginDAO* securityOriginDAO,
 109     void* data)
 110 {
 111     LogDebug("geolocationPermissionRequest called");
 112     Assert(securityOriginDAO);
 113     Assert(data);
 114     Ewk_Geolocation_Permission_Request* permissionRequest =
 115         static_cast<Ewk_Geolocation_Permission_Request*>(data);
 116     const Ewk_Security_Origin* ewkOrigin =
 117         ewk_geolocation_permission_request_origin_get(
 118             permissionRequest);
 119     Assert(ewkOrigin);
 120
 121     SecurityOriginData securityOriginData(
 122         WrtDB::FEATURE_GEOLOCATION,
 123         Origin(
 124             DPL::FromUTF8String(ewk_security_origin_protocol_get(ewkOrigin)),
 125             DPL::FromUTF8String(ewk_security_origin_host_get(ewkOrigin)),
 126             ewk_security_origin_port_get(ewkOrigin)));
 127
 128     // check cache database
 129     Result result = securityOriginDAO->getResult(securityOriginData);
 130     if (RESULT_ALLOW_ONCE == result || RESULT_ALLOW_ALWAYS == result) {
 131         LogDebug("allow");
 132         ewk_geolocation_permission_request_set(permissionRequest, EINA_TRUE);
 133         return;
 134     } else if (RESULT_DENY_ONCE == result || RESULT_DENY_ALWAYS == result) {
 135         LogDebug("deny");
 136         ewk_geolocation_permission_request_set(permissionRequest, EINA_FALSE);
 137         return;
 138     }
 139
 140     ewk_geolocation_permission_request_suspend(permissionRequest);
 141
 142     // ask to user
 143     PermissionData* permissionData =
 144         new PermissionData(securityOriginDAO,
 145                            securityOriginData,
 146                            permissionRequest);
 147     askUserForGeolocationPermission(window, permissionData);
 148     return;
 149 }
 150 } // namespace GeolocationSupport
 151 } // namespace ViewModule