Merge pull request #133 from JongHeonChoi/fx_User_exec
[platform/framework/web/crosswalk-tizen.git] / runtime / browser / web_view_impl.cc
1 /*
2  * Copyright (c) 2015 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
18 #include "runtime/browser/web_view_impl.h"
19
20 #include <ewk_chromium.h>
21 #include <functional>
22 #include <sstream>
23
24 #include "common/file_utils.h"
25 #include "common/logger.h"
26 #include "common/profiler.h"
27 #include "runtime/browser/native_window.h"
28
29 namespace runtime {
30
31 namespace {
32
33 const char* kKeyNameBack = "back";
34 const char* kKeyNameMenu = "menu";
35 const char* kDefaultEncoding = "UTF-8";
36 const char* kSmartClassUserDataKey = "__SC_USERDATA__";
37
38 static int ToWebRotation(int r) {
39   switch (r) {
40     case 90:
41       return -90;
42     case 270:
43       return 90;
44   }
45   return r;
46 }
47
48 static NativeWindow::ScreenOrientation ToNativeRotation(int r) {
49   if (r ==
50       (EWK_SCREEN_ORIENTATION_PORTRAIT_PRIMARY
51        | EWK_SCREEN_ORIENTATION_PORTRAIT_SECONDARY
52        | EWK_SCREEN_ORIENTATION_LANDSCAPE_PRIMARY
53        | EWK_SCREEN_ORIENTATION_LANDSCAPE_SECONDARY)) {
54     return NativeWindow::ScreenOrientation::ANY;
55   } else if (r ==
56       (EWK_SCREEN_ORIENTATION_PORTRAIT_PRIMARY
57        | EWK_SCREEN_ORIENTATION_LANDSCAPE_PRIMARY)) {
58     return NativeWindow::ScreenOrientation::NATURAL;
59   } else if (r & EWK_SCREEN_ORIENTATION_PORTRAIT_PRIMARY) {
60     return NativeWindow::ScreenOrientation::PORTRAIT_PRIMARY;
61   } else if (r & EWK_SCREEN_ORIENTATION_PORTRAIT_SECONDARY) {
62     return NativeWindow::ScreenOrientation::PORTRAIT_SECONDARY;
63   } else if (r & EWK_SCREEN_ORIENTATION_LANDSCAPE_PRIMARY) {
64     return NativeWindow::ScreenOrientation::LANDSCAPE_PRIMARY;
65   } else {
66     return NativeWindow::ScreenOrientation::LANDSCAPE_SECONDARY;
67   }
68 }
69
70 }  // namespace
71
72 WebViewImpl::WebViewImpl(WebView* view,
73                          NativeWindow* window,
74                          Ewk_Context* context)
75     : window_(window),
76       context_(context),
77       ewk_view_(NULL),
78       listener_(NULL),
79       rotation_handler_id_(0),
80       view_(view),
81       fullscreen_(false),
82       evas_smart_class_(NULL),
83       internal_popup_opened_(false),
84       ime_width_(0),
85       ime_height_(0) {
86   Initialize();
87 }
88
89 WebViewImpl::~WebViewImpl() {
90   if (internal_popup_opened_) {
91     ewk_view_javascript_alert_reply(ewk_view_);
92   }
93   Deinitialize();
94   evas_object_del(ewk_view_);
95   if (evas_smart_class_ != NULL)
96     evas_smart_free(evas_smart_class_);
97 }
98
99 void WebViewImpl::LoadUrl(const std::string& url, const std::string& mime) {
100   SCOPE_PROFILE();
101   if (!mime.empty()) {
102     mime_set_cb_ = [url, mime]
103                    (const char* request_url, const char* request_mime,
104                     char** new_mime, void* data) {
105       WebViewImpl* view = static_cast<WebViewImpl*>(data);
106       if (view != nullptr &&
107           common::utils::BaseName(url) ==
108           common::utils::BaseName(request_url)) {
109         *new_mime = strdup(mime.c_str());
110         LOGGER(DEBUG) << "ewk's new_mime: " << *new_mime;
111         return EINA_TRUE;
112       }
113       return EINA_FALSE;
114     };
115     auto mime_override_cb = [](const char* url, const char* mime,
116                                  char** new_mime, void* data) -> Eina_Bool {
117       WebViewImpl* view = static_cast<WebViewImpl*>(data);
118       return view->mime_set_cb_(url, mime, new_mime, data);
119     };
120     ewk_context_mime_override_callback_set(context_, mime_override_cb, this);
121   }
122   ewk_view_url_set(ewk_view_, url.c_str());
123 }
124
125 void WebViewImpl::Suspend() {
126   // suspend webview
127   ewk_view_suspend(ewk_view_);
128 }
129
130 void WebViewImpl::Resume() {
131   // resume webview
132   ewk_view_resume(ewk_view_);
133 }
134
135 void WebViewImpl::Reload() {
136   ewk_view_reload(ewk_view_);
137 }
138
139 bool WebViewImpl::Backward() {
140   if (ewk_view_back_possible(ewk_view_)) {
141     ewk_view_back(ewk_view_);
142     return EINA_TRUE;
143   }
144   return EINA_FALSE;
145 }
146
147 void WebViewImpl::SetVisibility(bool show) {
148   ewk_view_page_visibility_state_set(ewk_view_,
149                                      show ? EWK_PAGE_VISIBILITY_STATE_VISIBLE :
150                                             EWK_PAGE_VISIBILITY_STATE_HIDDEN,
151                                      EINA_FALSE);
152 }
153
154
155 bool WebViewImpl::EvalJavascript(const std::string& script) {
156   return ewk_view_script_execute(ewk_view_, script.c_str(), NULL, NULL);
157 }
158
159 void WebViewImpl::Initialize() {
160   ewk_smart_class_ = EWK_VIEW_SMART_CLASS_INIT_NAME_VERSION("WebView");
161   ewk_view_smart_class_set(&ewk_smart_class_);
162   ewk_smart_class_.orientation_lock = [](Ewk_View_Smart_Data *sd,
163                                          int orientation) {
164     WebViewImpl* self = static_cast<WebViewImpl*>(
165         evas_object_data_get(sd->self, kSmartClassUserDataKey));
166     if (self == NULL || self->listener_ == NULL)
167       return EINA_FALSE;
168     self->listener_->OnOrientationLock(self->view_,
169                                        true,
170                                        ToNativeRotation(orientation));
171     return EINA_TRUE;
172   };
173
174   ewk_smart_class_.orientation_unlock = [](Ewk_View_Smart_Data *sd) {
175     WebViewImpl* self = static_cast<WebViewImpl*>(
176         evas_object_data_get(sd->self, kSmartClassUserDataKey));
177     if (self == NULL || self->listener_ == NULL)
178       return;
179     self->listener_->OnOrientationLock(
180         self->view_,
181         false,
182         NativeWindow::ScreenOrientation::PORTRAIT_PRIMARY);
183   };
184
185   if (evas_smart_class_ != NULL)
186     evas_smart_free(evas_smart_class_);
187   evas_smart_class_ = evas_smart_class_new(&ewk_smart_class_.sc);
188   if (evas_smart_class_ == NULL) {
189     LOGGER(ERROR) << "Can't create evas smart class";
190     return;
191   }
192
193   Ewk_Page_Group* page_group = ewk_page_group_create("");
194   ewk_view_ = ewk_view_smart_add(evas_object_evas_get(window_->evas_object()),
195                                  evas_smart_class_,
196                                  context_,
197                                  page_group);
198   evas_object_data_set(ewk_view_, kSmartClassUserDataKey, this);
199
200   InitKeyCallback();
201   InitLoaderCallback();
202   InitPolicyDecideCallback();
203   InitQuotaExceededCallback();
204   InitIPCMessageCallback();
205   InitConsoleMessageCallback();
206   InitCustomContextMenuCallback();
207   InitRotationCallback();
208   InitWindowCreateCallback();
209   InitFullscreenCallback();
210   InitNotificationPermissionCallback();
211   InitGeolocationPermissionCallback();
212   InitAuthenticationCallback();
213   InitCertificateAllowCallback();
214   InitPopupWaitCallback();
215   InitUsermediaCallback();
216   InitEditorClientImeCallback();
217 #ifdef ROTARY_EVENT_FEATURE_SUPPORT
218   InitRotaryEventCallback();
219 #endif  // ROTARY_EVENT_FEATURE_SUPPORT
220
221   Ewk_Settings* settings = ewk_view_settings_get(ewk_view_);
222   ewk_settings_scripts_can_open_windows_set(settings, EINA_TRUE);
223   ewk_settings_default_text_encoding_name_set(settings, kDefaultEncoding);
224
225   // TODO(sngn.lee): "protocolhandler,registration,requested"
226   //                  custom protocol handler
227
228   // Show webview
229   evas_object_show(ewk_view_);
230 }
231
232 void WebViewImpl::Deinitialize() {
233   auto it = smart_callbacks_.begin();
234   for ( ; it != smart_callbacks_.end(); ++it) {
235     evas_object_smart_callback_del(
236         ewk_view_,
237         it->first.c_str(),
238         it->second);
239   }
240   eext_object_event_callback_del(ewk_view_,
241                                EEXT_CALLBACK_BACK,
242                                smart_callbacks_["key_callback"]);
243   ewk_view_exceeded_database_quota_callback_set(
244       ewk_view_,
245       NULL,
246       NULL);
247   ewk_view_exceeded_indexed_database_quota_callback_set(
248       ewk_view_,
249       NULL,
250       NULL);
251   ewk_view_exceeded_local_file_system_quota_callback_set(
252       ewk_view_,
253       NULL,
254       NULL);
255   ewk_view_notification_permission_callback_set(
256       ewk_view_,
257       NULL,
258       NULL);
259   ewk_view_geolocation_permission_callback_set(
260       ewk_view_,
261       NULL,
262       NULL);
263   ewk_view_user_media_permission_callback_set(
264       ewk_view_,
265       NULL,
266       NULL);
267   window_->RemoveRotationHandler(rotation_handler_id_);
268 }
269
270 void WebViewImpl::InitKeyCallback() {
271   auto key_callback = [](void* user_data,
272                          Evas_Object* /*obj*/,
273                          void* event_info) -> void {
274     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
275     Eext_Callback_Type key = static_cast<Eext_Callback_Type>(
276       reinterpret_cast<long long>(event_info));  // NOLINT
277     self->OnKeyEvent(key);
278   };
279   eext_object_event_callback_add(ewk_view_,
280                                EEXT_CALLBACK_BACK,
281                                key_callback,
282                                this);
283   eext_object_event_callback_add(ewk_view_,
284                                EEXT_CALLBACK_MORE,
285                                key_callback,
286                                this);
287   smart_callbacks_["key_callback"] = key_callback;
288 }
289
290 void WebViewImpl::InitLoaderCallback() {
291   // load statred callback
292   auto loadstart_callback = [](void* user_data,
293                                Evas_Object* /*obj*/,
294                                void*) {
295     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
296     if (self->listener_)
297       self->listener_->OnLoadStart(self->view_);
298   };
299   evas_object_smart_callback_add(ewk_view_,
300                                  "load,started",
301                                  loadstart_callback,
302                                  this);
303   // load finished callback
304   auto loadfinished_callback = [](void* user_data,
305                                   Evas_Object*,
306                                   void*) {
307     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
308     if (self->listener_)
309       self->listener_->OnLoadFinished(self->view_);
310   };
311   evas_object_smart_callback_add(ewk_view_,
312                                  "load,finished",
313                                  loadfinished_callback,
314                                  this);
315
316   // load progress callback
317   auto loadprogress_callback = [](void* user_data,
318                                   Evas_Object*,
319                                   void* event_info) {
320     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
321     double* progress = static_cast<double*>(event_info);
322     if (self->listener_)
323       self->listener_->OnLoadProgress(self->view_, *progress);
324   };
325   evas_object_smart_callback_add(ewk_view_,
326                                  "load,progress",
327                                  loadprogress_callback,
328                                  this);
329   // rendered callback
330   auto rendered_callback = [](void* user_data,
331                               Evas_Object*,
332                               void*) {
333     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
334     if (self->listener_)
335       self->listener_->OnRendered(self->view_);
336   };
337   evas_object_smart_callback_add(ewk_view_,
338                                  "frame,rendered",
339                                  rendered_callback,
340                                  this);
341   smart_callbacks_["load,started"] = loadstart_callback;
342   smart_callbacks_["load,finished"] = loadfinished_callback;
343   smart_callbacks_["load,progress"] = loadprogress_callback;
344   smart_callbacks_["frame,rendered"] = rendered_callback;
345
346 #ifdef MANUAL_ROTATE_FEATURE_SUPPORT
347   // rotate prepared callback
348   auto rotateprepared_callback = [](void* user_data,
349                               Evas_Object*,
350                               void*) {
351     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
352     if (self->listener_)
353       self->listener_->OnRotatePrepared(self->view_);
354   };
355   evas_object_smart_callback_add(ewk_view_,
356                                  "rotate,prepared",
357                                  rotateprepared_callback,
358                                  this);
359   smart_callbacks_["rotate,prepared"] = rotateprepared_callback;
360 #endif  // MANUAL_ROTATE_FEATURE_SUPPORT
361 }
362
363 void WebViewImpl::InitPolicyDecideCallback() {
364   // "policy,navigation,decide"
365   auto navigation_decide_callback = [](void* user_data,
366                                        Evas_Object*,
367                                        void* event_info) {
368     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
369     Ewk_Policy_Decision* policy =
370             static_cast<Ewk_Policy_Decision*>(event_info);
371     const char* url = ewk_policy_decision_url_get(policy);
372
373     if (self->listener_) {
374       if (self->listener_->OnDidNavigation(self->view_, url))
375         ewk_policy_decision_use(policy);
376       else
377         ewk_policy_decision_ignore(policy);
378     } else {
379       ewk_policy_decision_use(policy);
380     }
381   };
382   evas_object_smart_callback_add(ewk_view_,
383                                  "policy,navigation,decide",
384                                  navigation_decide_callback,
385                                  this);
386
387   // policy,newwindow,decide
388   auto newwindow_decide_callback = [](void* user_data,
389                                       Evas_Object*,
390                                       void* event_info) {
391     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
392     Ewk_Policy_Decision* policy =
393             static_cast<Ewk_Policy_Decision*>(event_info);
394
395     const char* url = ewk_policy_decision_url_get(policy);
396
397     if (self->listener_) {
398       if (self->listener_->OnDidNavigation(self->view_, url) &&
399          self->listener_->OnDidOpenWindow(self->view_, url)) {
400          ewk_policy_decision_use(policy);
401       } else {
402         ewk_policy_decision_ignore(policy);
403       }
404     } else {
405       ewk_policy_decision_use(policy);
406     }
407   };
408   evas_object_smart_callback_add(ewk_view_,
409                                  "policy,newwindow,decide",
410                                  newwindow_decide_callback,
411                                  this);
412   smart_callbacks_["policy,navigation,decide"] = navigation_decide_callback;
413   smart_callbacks_["policy,newwindow,decide"] = newwindow_decide_callback;
414 }
415
416 void WebViewImpl::InitQuotaExceededCallback() {
417   // TODO(sngn.lee): Need callback interface - OnQutaExceed
418   // check http://tizen.org/privilege/unlimitedstorage
419
420   // callback for database quota exceeded
421   auto database_exceeded_callback = [](Evas_Object* view,
422                                        Ewk_Security_Origin* origin,
423                                        const char*,
424                                        unsigned long long, // NOLINT
425                                        void* user_data) -> Eina_Bool {
426     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
427     if (self == NULL || self->listener_ == NULL)
428       return EINA_TRUE;
429
430     auto result_handler = [view](bool result) {
431       LOGGER(DEBUG) << "database quota Permission Result : " << result;
432       ewk_view_exceeded_database_quota_reply(view, result);
433     };
434     std::stringstream url;
435     url << ewk_security_origin_protocol_get(origin)
436         << "://"
437         << ewk_security_origin_host_get(origin)
438         << ":"
439         << ewk_security_origin_port_get(origin);
440     self->listener_->OnQuotaExceed(
441         self->view_,
442         url.str(),
443         result_handler);
444     return EINA_TRUE;
445   };
446   ewk_view_exceeded_database_quota_callback_set(
447     ewk_view_,
448     database_exceeded_callback,
449     this);
450
451   // callback for indexed database quota exceeded
452   auto indexed_db_exceeded_callback = [](Evas_Object* view,
453                                        Ewk_Security_Origin* origin,
454                                        long long, // NOLINT
455                                        void* user_data) -> Eina_Bool {
456     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
457     if (self == NULL || self->listener_ == NULL)
458       return EINA_TRUE;
459
460     auto result_handler = [view](bool result) {
461       LOGGER(DEBUG) << "indexed db quota Permission Result : " << result;
462       ewk_view_exceeded_indexed_database_quota_reply(view, result);
463     };
464     std::stringstream url;
465     url << ewk_security_origin_protocol_get(origin)
466         << "://"
467         << ewk_security_origin_host_get(origin)
468         << ":"
469         << ewk_security_origin_port_get(origin);
470     self->listener_->OnQuotaExceed(
471         self->view_,
472         url.str(),
473         result_handler);
474     return EINA_TRUE;
475   };
476   ewk_view_exceeded_indexed_database_quota_callback_set(
477     ewk_view_,
478     indexed_db_exceeded_callback,
479     this);
480
481   // callback for localfile quota exceeded
482   auto localfile_exceeded_callback = [](Evas_Object* view,
483                                        Ewk_Security_Origin* origin,
484                                        long long, // NOLINT
485                                        void* user_data) -> Eina_Bool {
486     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
487     if (self == NULL || self->listener_ == NULL)
488       return EINA_TRUE;
489
490     auto result_handler = [view](bool result) {
491       LOGGER(DEBUG) << "local file quota Permission Result : " << result;
492       ewk_view_exceeded_local_file_system_quota_reply(view, result);
493     };
494     std::stringstream url;
495     url << ewk_security_origin_protocol_get(origin)
496         << "://"
497         << ewk_security_origin_host_get(origin)
498         << ":"
499         << ewk_security_origin_port_get(origin);
500     self->listener_->OnQuotaExceed(
501         self->view_,
502         url.str(),
503         result_handler);
504     return EINA_TRUE;
505   };
506   ewk_view_exceeded_local_file_system_quota_callback_set(
507     ewk_view_,
508     localfile_exceeded_callback,
509     this);
510 }
511
512 void WebViewImpl::InitIPCMessageCallback() {
513   // wrt,message
514   auto wrt_message_callback = [](void* user_data,
515                                  Evas_Object*,
516                                  void* event_info) {
517     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
518     Ewk_IPC_Wrt_Message_Data* msg =
519         static_cast<Ewk_IPC_Wrt_Message_Data*>(event_info);
520     if (self->listener_)
521       self->listener_->OnReceivedWrtMessage(self->view_, msg);
522   };
523   evas_object_smart_callback_add(ewk_view_,
524                                  "wrt,message",
525                                  wrt_message_callback,
526                                  this);
527   smart_callbacks_["wrt,message"] = wrt_message_callback;
528 }
529
530 void WebViewImpl::InitConsoleMessageCallback() {
531   // console log
532   auto console_message_callback = [](void* user_data,
533                                  Evas_Object*,
534                                  void* event_info) {
535     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
536     if (!self->listener_) {
537       return;
538     }
539     Ewk_Console_Message* msg = static_cast<Ewk_Console_Message*>(event_info);
540     unsigned int line_number = ewk_console_message_line_get(msg);
541
542     std::stringstream buf;
543     if (line_number) {
544         buf << ewk_console_message_source_get(msg)
545             << ":" << line_number << ": ";
546     }
547     buf << ewk_console_message_text_get(msg);
548     int level = ewk_console_message_level_get(msg);
549     self->listener_->OnConsoleMessage(buf.str(), level);
550   };
551   evas_object_smart_callback_add(ewk_view_,
552                                  "console,message",
553                                  console_message_callback,
554                                  this);
555   smart_callbacks_["console,message"] = console_message_callback;
556 }
557
558 void WebViewImpl::InitCustomContextMenuCallback() {
559   auto custom_context_menu_callback = [](void* user_data,
560                                          Evas_Object*,
561                                          void* event_info) {
562     Ewk_Context_Menu* contextmenu = static_cast<Ewk_Context_Menu*>(event_info);
563     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
564     bool disabled = false;
565     if (self->listener_ &&
566         self->listener_->OnContextMenuDisabled(self->view_)) {
567       disabled = true;
568     }
569     int cnt = ewk_context_menu_item_count(contextmenu);
570     for (int idx = cnt-1; idx >= 0; --idx) {
571       auto* item = ewk_context_menu_nth_item_get(contextmenu, idx);
572       Ewk_Context_Menu_Item_Tag tag = ewk_context_menu_item_tag_get(item);
573       switch (tag) {
574         case EWK_CONTEXT_MENU_ITEM_TAG_OPEN_IMAGE_IN_NEW_WINDOW:
575         case EWK_CONTEXT_MENU_ITEM_TAG_OPEN_LINK_IN_NEW_WINDOW:
576         case EWK_CONTEXT_MENU_ITEM_TAG_OPEN_FRAME_IN_NEW_WINDOW:
577         case EWK_CONTEXT_MENU_ITEM_TAG_SEARCH_WEB:
578         case EWK_CONTEXT_MENU_ITEM_TAG_DOWNLOAD_IMAGE_TO_DISK:
579         case EWK_CONTEXT_MENU_ITEM_TAG_DOWNLOAD_LINK_TO_DISK:
580           ewk_context_menu_item_remove(contextmenu, item);
581           break;
582         default:
583           if (disabled)
584             ewk_context_menu_item_remove(contextmenu, item);
585       }
586     }
587   };
588   evas_object_smart_callback_add(ewk_view_,
589                                  "contextmenu,customize",
590                                  custom_context_menu_callback,
591                                  this);
592   smart_callbacks_["contextmenu,customize"] = custom_context_menu_callback;
593 }
594
595 void WebViewImpl::InitRotationCallback() {
596   // rotation support
597   ewk_view_orientation_send(ewk_view_, ToWebRotation(window_->rotation()));
598   rotation_handler_id_ = window_->AddRotationHandler(
599                                   std::bind(&WebViewImpl::OnRotation,
600                                   this,
601                                   std::placeholders::_1));
602 }
603
604 void WebViewImpl::InitWindowCreateCallback() {
605   auto create_callback = [](void* user_data,
606                             Evas_Object*,
607                             void* event_info) {
608     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
609     if (!self->listener_) {
610       return;
611     }
612     WebView* new_view = new WebView(self->window_, self->context_);
613     self->listener_->OnCreatedNewWebView(self->view_, new_view);
614     *(static_cast<Evas_Object **>(event_info)) = new_view->evas_object();
615   };
616
617   auto close_callback = [](void* user_data,
618                             Evas_Object*,
619                             void*) {
620     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
621     if (!self->listener_) {
622       return;
623     }
624     self->listener_->OnClosedWebView(self->view_);
625   };
626   evas_object_smart_callback_add(ewk_view_,
627                                  "create,window",
628                                  create_callback,
629                                  this);
630   evas_object_smart_callback_add(ewk_view_,
631                                  "close,window",
632                                  close_callback,
633                                  this);
634
635   smart_callbacks_["create,window"] = create_callback;
636   smart_callbacks_["close,window"] = close_callback;
637 }
638
639 void WebViewImpl::InitFullscreenCallback() {
640   auto enter_callback = [](void* user_data,
641                             Evas_Object*,
642                             void* /*event_info*/) {
643     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
644     self->fullscreen_ = true;
645     self->window_->FullScreen(true);
646   };
647   auto exit_callback =  [](void* user_data,
648                             Evas_Object*,
649                             void* /*event_info*/) {
650     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
651     self->fullscreen_ = false;
652     self->window_->FullScreen(false);
653   };
654   evas_object_smart_callback_add(ewk_view_,
655                                  "fullscreen,enterfullscreen",
656                                  enter_callback,
657                                  this);
658   evas_object_smart_callback_add(ewk_view_,
659                                  "fullscreen,exitfullscreen",
660                                  exit_callback,
661                                  this);
662   smart_callbacks_["fullscreen,enterfullscreen"] = enter_callback;
663   smart_callbacks_["fullscreen,exitfullscreen"] = exit_callback;
664 }
665
666 void WebViewImpl::InitNotificationPermissionCallback() {
667   auto request_callback = [](Evas_Object*,
668                              Ewk_Notification_Permission_Request* request,
669                              void* user_data) {
670     LOGGER(DEBUG) << "Notification Permission Request";
671     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
672     if (!self->listener_) {
673       ewk_notification_permission_reply(request, EINA_FALSE);
674       return EINA_TRUE;
675     }
676
677     ewk_notification_permission_request_suspend(request);
678     auto result_handler = [request](bool result) {
679       LOGGER(DEBUG) << "Notification Permission Result : %d" << result;
680       ewk_notification_permission_reply(request, result);
681     };
682     const Ewk_Security_Origin* ewk_origin =
683         ewk_notification_permission_request_origin_get(request);
684
685     std::stringstream url;
686     url << ewk_security_origin_protocol_get(ewk_origin)
687         << "://"
688         << ewk_security_origin_host_get(ewk_origin)
689         << ":"
690         << ewk_security_origin_port_get(ewk_origin);
691     self->listener_->OnNotificationPermissionRequest(
692         self->view_,
693         url.str(),
694         result_handler);
695     return EINA_TRUE;
696   };
697   ewk_view_notification_permission_callback_set(ewk_view_,
698                                                 request_callback,
699                                                 this);
700 }
701
702 void WebViewImpl::InitGeolocationPermissionCallback() {
703   auto permission_callback = [](
704       Evas_Object*,
705       Ewk_Geolocation_Permission_Request* request,
706       void* user_data) {
707     LOGGER(DEBUG) << "Geolocation Permission Request";
708     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
709     if (self == NULL || self->listener_ == NULL) {
710       ewk_geolocation_permission_reply(request, EINA_FALSE);
711       return EINA_TRUE;
712     }
713     ewk_geolocation_permission_request_suspend(request);
714
715     const Ewk_Security_Origin* ewk_origin =
716         ewk_geolocation_permission_request_origin_get(request);
717     auto result_handler = [request](bool result) {
718       LOGGER(DEBUG) << "Geolocation Permission Result : " << result;
719       ewk_geolocation_permission_reply(request, result);
720     };
721
722     std::stringstream url;
723     url << ewk_security_origin_protocol_get(ewk_origin)
724         << "://"
725         << ewk_security_origin_host_get(ewk_origin)
726         << ":"
727         << ewk_security_origin_port_get(ewk_origin);
728
729     self->listener_->OnGeolocationPermissionRequest(
730         self->view_,
731         url.str(),
732         result_handler);
733     return EINA_TRUE;
734   };
735   ewk_view_geolocation_permission_callback_set(ewk_view_,
736                                                permission_callback,
737                                                this);
738 }
739
740 void WebViewImpl::InitAuthenticationCallback() {
741   auto auth_callback = [](void* user_data,
742                           Evas_Object*,
743                           void* event_info) {
744     LOGGER(DEBUG) << "Authentication Request";
745     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
746     Ewk_Auth_Challenge* auth_challenge =
747         static_cast<Ewk_Auth_Challenge*>(event_info);
748
749     if (self == NULL || self->listener_ == NULL) {
750       ewk_auth_challenge_credential_cancel(auth_challenge);
751       return;
752     }
753     auto result_handler = [auth_challenge](bool submit,
754                                     const std::string& id,
755                                     const std::string& password) {
756       LOGGER(DEBUG) << "Authentication Result : submit = " << submit;
757       if (!submit) {
758         ewk_auth_challenge_credential_cancel(auth_challenge);
759         return;
760       }
761       ewk_auth_challenge_credential_use(auth_challenge,
762                                         id.c_str(),
763                                         password.c_str());
764     };
765     ewk_auth_challenge_suspend(auth_challenge);
766     const char* message =
767         ewk_auth_challenge_realm_get(auth_challenge);
768     std::string url = self->GetUrl();
769     self->listener_->OnAuthenticationRequest(self->view_,
770                                              url,
771                                              message,
772                                              result_handler);
773   };
774   // "authentication,challenge"
775   evas_object_smart_callback_add(ewk_view_,
776                                  "authentication,challenge",
777                                  auth_callback,
778                                  this);
779   smart_callbacks_["authentication,challenge"] = auth_callback;
780 }
781
782 void WebViewImpl::InitCertificateAllowCallback() {
783   auto certi_callback = [](void* user_data,
784                            Evas_Object*,
785                            void* event_info) {
786     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
787     Ewk_Certificate_Policy_Decision* policy =
788       static_cast<Ewk_Certificate_Policy_Decision*>(event_info);
789
790     if (self == NULL || self->listener_ == NULL) {
791       ewk_certificate_policy_decision_allowed_set(policy, EINA_FALSE);
792       return;
793     }
794
795     ewk_certificate_policy_decision_suspend(policy);
796     auto result_handler = [policy](bool allow) {
797       ewk_certificate_policy_decision_allowed_set(policy, allow);
798     };
799
800     auto ptr = ewk_certificate_policy_decision_url_get(policy);
801     std::string url(ptr ? ptr : "");
802     ptr = ewk_certificate_policy_decision_certificate_pem_get(policy);
803     std::string pem(ptr ? ptr : "");
804     self->listener_->OnCertificateAllowRequest(self->view_,
805                                                url,
806                                                pem,
807                                                result_handler);
808   };
809   evas_object_smart_callback_add(ewk_view_,
810                                  "request,certificate,confirm",
811                                  certi_callback,
812                                  this);
813   smart_callbacks_["request,certificate,confirm"] = certi_callback;
814 }
815
816 void WebViewImpl::InitPopupWaitCallback() {
817   evas_object_smart_callback_add(ewk_view_,
818       "popup,reply,wait,start",
819       [](void* user_data, Evas_Object* /*obj*/, void*) {
820         WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
821         self->internal_popup_opened_ = true;
822 #ifdef MANUAL_ROTATE_FEATURE_SUPPORT
823         self->window_->EnableManualRotation(false);
824 #endif  // MANUAL_ROTATE_FEATURE_SUPPORT
825       }, this);
826   evas_object_smart_callback_add(ewk_view_,
827       "popup,reply,wait,finish",
828       [](void* user_data, Evas_Object* /*obj*/, void*) {
829         WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
830         self->internal_popup_opened_ = false;
831 #ifdef MANUAL_ROTATE_FEATURE_SUPPORT
832         self->window_->EnableManualRotation(true);
833 #endif  // MANUAL_ROTATE_FEATURE_SUPPORT
834       }, this);
835 }
836
837 void WebViewImpl::InitUsermediaCallback() {
838   auto callback = [](Evas_Object*,
839                      Ewk_User_Media_Permission_Request* request,
840                      void* user_data) {
841     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
842     if (self == NULL || self->listener_ == NULL) {
843       ewk_user_media_permission_reply(request, EINA_FALSE);
844       return EINA_TRUE;
845     }
846
847     ewk_user_media_permission_request_suspend(request);
848     const Ewk_Security_Origin* origin =
849         ewk_user_media_permission_request_origin_get(request);
850     std::stringstream url;
851     url << ewk_security_origin_protocol_get(origin)
852         << "://"
853         << ewk_security_origin_host_get(origin)
854         << ":"
855         << ewk_security_origin_port_get(origin);
856
857     auto result_handler = [request](bool result) {
858       LOGGER(DEBUG) << "Getusermedia Permission Result : " << result;
859       ewk_user_media_permission_reply(request, result);
860     };
861     self->listener_->OnUsermediaPermissionRequest(self->view_,
862                                                   url.str(),
863                                                   result_handler);
864     return EINA_TRUE;
865   };
866   ewk_view_user_media_permission_callback_set(ewk_view_, callback, this);
867 }
868
869 void WebViewImpl::InitEditorClientImeCallback() {
870   auto ime_changed_callback = [](void* user_data,
871                            Evas_Object*,
872                            void* event_info) {
873     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
874
875     Eina_Rectangle *rect = static_cast<Eina_Rectangle *>(event_info);
876     self->ime_width_ = rect->w;
877     self->ime_height_ = rect->h;
878   };
879
880   auto ime_opened_callback = [](void* user_data,
881                            Evas_Object*,
882                            void* event_info) {
883     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
884
885     SoftKeyboardChangeEventValue softkeyboard_value;
886     softkeyboard_value.state = "on";
887     softkeyboard_value.width = self->ime_width_;
888     softkeyboard_value.height = self->ime_height_;
889
890     self->listener_->OnSoftKeyboardChangeEvent(self->view_, softkeyboard_value);
891   };
892
893   auto ime_closed_callback = [](void* user_data,
894                            Evas_Object*,
895                            void* event_info) {
896     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
897
898     SoftKeyboardChangeEventValue softkeyboard_value;
899     softkeyboard_value.state = "off";
900
901     self->listener_->OnSoftKeyboardChangeEvent(self->view_, softkeyboard_value);
902   };
903   evas_object_smart_callback_add(ewk_view_,
904                                  "inputmethod,changed",
905                                  ime_changed_callback,
906                                  this);
907   evas_object_smart_callback_add(ewk_view_,
908                                  "editorclient,ime,opened",
909                                  ime_opened_callback,
910                                  this);
911   evas_object_smart_callback_add(ewk_view_,
912                                  "editorclient,ime,closed",
913                                  ime_closed_callback,
914                                  this);
915   smart_callbacks_["inputmethod,changed"] = ime_changed_callback;
916   smart_callbacks_["editorclient,ime,opened"] = ime_opened_callback;
917   smart_callbacks_["editorclient,ime,closed"] = ime_closed_callback;
918 }
919
920 #ifdef ROTARY_EVENT_FEATURE_SUPPORT
921 void WebViewImpl::InitRotaryEventCallback() {
922   auto rotary_callback = [](void* user_data,
923                          Evas_Object*,
924                          Eext_Rotary_Event_Info* event_info) -> Eina_Bool {
925     WebViewImpl* self = static_cast<WebViewImpl*>(user_data);
926     Eext_Rotary_Event_Info* rotary = event_info;
927
928     RotaryEventType type;
929     if (rotary->direction == EEXT_ROTARY_DIRECTION_CLOCKWISE)
930       type = RotaryEventType::CLOCKWISE;
931     else
932       type = RotaryEventType::COUNTER_CLOCKWISE;
933
934     self->listener_->OnRotaryEvent(self->view_, type);
935     return EINA_TRUE;
936   };
937
938   // add callback to handle rotary event
939   eext_rotary_object_event_callback_add(ewk_view_, rotary_callback, this);
940   eext_rotary_object_event_activated_set(ewk_view_, EINA_TRUE);
941 }
942 #endif  // ROTARY_EVENT_FEATURE_SUPPORT
943
944 std::string WebViewImpl::GetUrl() {
945   return std::string(ewk_view_url_get(ewk_view_));
946 }
947
948 Evas_Object* WebViewImpl::evas_object() const {
949   return ewk_view_;
950 }
951
952 void WebViewImpl::OnRotation(int degree) {
953   ewk_view_orientation_send(ewk_view_, ToWebRotation(degree));
954 }
955
956 void WebViewImpl::OnKeyEvent(Eext_Callback_Type key_type) {
957   std::string keyname;
958   if (key_type == EEXT_CALLBACK_BACK) {
959     if (fullscreen_) {
960       ewk_view_fullscreen_exit(ewk_view_);
961       return;
962     }
963     if (EINA_TRUE == ewk_view_text_selection_clear(ewk_view_)) {
964       return;
965     }
966     keyname = kKeyNameBack;
967   } else if (key_type == EEXT_CALLBACK_MORE) {
968     keyname = kKeyNameMenu;
969   } else {
970     return;
971   }
972
973   if (listener_) {
974     listener_->OnHardwareKey(view_, keyname);
975   }
976 }
977
978 void WebViewImpl::SetEventListener(WebView::EventListener* listener) {
979   listener_ = listener;
980 }
981
982 void WebViewImpl::SetAppInfo(const std::string& app_name,
983                              const std::string& version) {
984   std::string ua = app_name + "/" + version;
985   ewk_view_application_name_for_user_agent_set(ewk_view_, ua.c_str());
986 }
987 bool WebViewImpl::SetUserAgent(const std::string& user_agent) {
988   return ewk_view_user_agent_set(ewk_view_, user_agent.c_str());
989 }
990
991 void WebViewImpl::SetCSPRule(const std::string& rule, bool report_only) {
992   ewk_view_content_security_policy_set(
993       ewk_view_,
994       rule.c_str(),
995       report_only ? EWK_REPORT_ONLY : EWK_ENFORCE_POLICY);
996 }
997
998 void WebViewImpl::SetDefaultEncoding(const std::string& encoding) {
999   if (ewk_settings_is_encoding_valid(encoding.c_str())) {
1000     Ewk_Settings* settings = ewk_view_settings_get(ewk_view_);
1001     ewk_settings_default_text_encoding_name_set(settings, encoding.c_str());
1002   }
1003 }
1004
1005 #ifdef PROFILE_WEARABLE
1006 void WebViewImpl::SetBGColor(int r, int g, int b, int a) {
1007   ewk_view_bg_color_set(ewk_view_, r, g, b, a);
1008 }
1009 #endif
1010
1011 }  // namespace runtime