src/view/webkit/view_logic.h

   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.h
  18  * @author  Lukasz Wrzosek (l.wrzosek@samsung.com)
  19  * @brief   Declaration file for view logic for Webkit2
  20  */
  21
  22 #ifndef VIEW_LOGIC_H_
  23 #define VIEW_LOGIC_H_
  24
  25 #include <i_view_module.h>
  26 #include <memory>
  27 #include <map>
  28 #include <string>
  29 #include <dpl/log/log.h>
  30 #include <dpl/assert.h>
  31
  32 #include <widget_model.h>
  33 #include <i_runnable_widget_object.h>
  34 #include <common/view_logic_apps_support.h>
  35 #include <common/view_logic_vibration_support.h>
  36
  37 #include <EWebKit2.h>
  38
  39 class SchemeSupport;
  40 namespace ViewModule {
  41 class SecurityOriginSupport;
  42 }
  43
  44 class ViewLogic : public ViewModule::IViewModule
  45 {
  46   public:
  47     ViewLogic();
  48     virtual ~ViewLogic();
  49
  50     void createWebView(Ewk_Context* context,
  51                        Evas_Object* window);
  52     void destroyWebView();
  53     void initialize();
  54     void terminate();
  55     void prepareView(WidgetModel* m, const std::string &startUrl);
  56     void showWidget();
  57     void hideWidget();
  58     void changeViewVisibility(bool isVisible);
  59     void suspendWidget();
  60     void resumeWidget();
  61     void resetWidget();
  62     void backward();
  63     void reloadStartPage();
  64     Evas_Object* getCurrentWebview();
  65     void fireJavascriptEvent(int event, void* data);
  66     void setUserCallbacks(const WRT::UserDelegatesPtr& cbs);
  67
  68     // Ewk_Context operations
  69     void initializeEwkContext(Ewk_Context* context);
  70     void finalizeEwkContext();
  71
  72   private:
  73     void initializeSupport();
  74     void initializePluginLoading();
  75
  76     // EwkView operations
  77     void ewkClientInit(Evas_Object *wkView);
  78     void ewkClientDeinit(Evas_Object *wkView);
  79     void createEwkView(Evas* canvas);
  80     void setStartPage();
  81     void prepareEwkView(Evas_Object *wkView);
  82     void removeEwkView(Evas_Object *wkView);
  83     void resumeEwkView(Evas_Object *wkView);
  84     void suspendEwkView(Evas_Object *wkView);
  85     void resumeWebkit(Evas_Object *wkView);
  86     void suspendWebkit(Evas_Object *wkView);
  87
  88     // message from injected bundle Callback
  89     static void contextMessageFromInjectedBundleCallback(
  90             const char* name,
  91             const char* body,
  92             char** returnData,
  93             void* userData);
  94
  95     // EWK Context Callback
  96     static void didStartDownloadCallback(
  97             const char* downloadUrl,
  98             void* data);
  99
 100     // WKPageLoaderClient
 101     static void loadStartedCallback(
 102             void* data,
 103             Evas_Object* obj,
 104             void* eventInfo);
 105     static void loadFinishedCallback(
 106             void* data,
 107             Evas_Object* obj,
 108             void* eventInfo);
 109     static void titleChangedCallback(
 110             void* data,
 111             Evas_Object* obj,
 112             void* eventInfo);
 113     static void loadProgressCallback(
 114             void* data,
 115             Evas_Object* obj,
 116             void* eventInfo);
 117     static void loadProgressFinishedCallback(
 118             void* data,
 119             Evas_Object* obj,
 120             void* eventInfo);
 121     static void processCrashedCallback(
 122             void* data,
 123             Evas_Object* obj,
 124             void* eventInfo);
 125
 126     // EWK Callback
 127     static void createWindowCallback(
 128             void* data,
 129             Evas_Object* obj,
 130             void* eventInfo);
 131     static void closeWindowCallback(
 132             void* data,
 133             Evas_Object* obj,
 134             void* eventInfo);
 135
 136     // EWK PolicyDecide Callback
 137     static void policyNavigationDecideCallback(
 138             void* data,
 139             Evas_Object* obj,
 140             void* eventInfo);
 141     static void policyNewWindowDecideCallback(
 142             void* data,
 143             Evas_Object* obj,
 144             void* eventInfo);
 145     static void pageResponseDecideCallback(
 146             void* data,
 147             Evas_Object* obj,
 148             void* eventInfo);
 149
 150     // EWK ContextMenu Callback
 151     static void contextmenuCustomizeCallback(
 152             void* data,
 153             Evas_Object* obj,
 154             void* eventInfo);
 155
 156     // EWK FormClient Callback
 157     static void formSubmitCallback(
 158             void *data,
 159             Evas_Object *obj,
 160             void *eventInfo);
 161
 162     // EWK Geolocation Callback
 163     static void geolocationPermissionRequestCallback(
 164             void* data,
 165             Evas_Object* obj,
 166             void* eventInfo);
 167
 168     // EWK Notification Callback
 169     static void notificationShowCallback(
 170             void* data,
 171             Evas_Object* obj,
 172             void* eventInfo);
 173     static void notificationCancelCallback(
 174             void* data,
 175             Evas_Object* obj,
 176             void* eventInfo);
 177     static void notificationPermissionRequestCallback(
 178             void* data,
 179             Evas_Object* obj,
 180             void* eventInfo);
 181
 182     // EWK Vibration Callback
 183     static void vibrationVibrateCallback(
 184             void* data,
 185             Evas_Object* obj,
 186             void* eventInfo);
 187     static void vibrationCancelCallback(
 188             void* data,
 189             Evas_Object* obj,
 190             void* eventInfo);
 191
 192     // EWK Orientation Callback
 193     static Eina_Bool orientationLockCallback(
 194             Evas_Object* obj,
 195             Eina_Bool needLock,
 196             int orientation,
 197             void* data);
 198
 199     // EWK Fullscreen API callbacks
 200     static void enterFullscreenCallback(
 201             void* data,
 202             Evas_Object* obj,
 203             void* eventInfo);
 204     static void exitFullscreenCallback(
 205             void* data,
 206             Evas_Object* obj,
 207             void* eventInfo);
 208
 209     // EWK IME Change/Show/Hide Callback
 210     static void imeChangedCallback(
 211             void* data,
 212             Evas_Object* obj,
 213             void* eventInfo);
 214     static void imeOpenedCallback(
 215             void* data,
 216             Evas_Object* obj,
 217             void* eventInfo);
 218     static void imeClosedCallback(
 219             void* data,
 220             Evas_Object* obj,
 221             void* eventInfo);
 222
 223     // EWK Usermedia Callback
 224     static void usermediaPermissionRequestCallback(
 225             void* data,
 226             Evas_Object* obj,
 227             void* eventInfo);
 228
 229     // custom content/scheme handlers
 230     static void protocolHandlerRegistrationCallback(void* data,
 231             Evas_Object* obj,
 232             void* eventInfo);
 233     static void protocolHandlerIsRegisteredCallback(void* data,
 234             Evas_Object* obj,
 235             void* eventInfo);
 236     static void protocolHandlerUnregistrationCallback(void* data,
 237             Evas_Object* obj,
 238             void* eventInfo);
 239
 240     static void contentHandlerRegistrationCallback(void* data,
 241             Evas_Object* obj,
 242             void* eventInfo);
 243     static void contentHandlerIsRegisteredCallback(void* data,
 244             Evas_Object* obj,
 245             void* eventInfo);
 246     static void contentHandlerUnregistrationCallback(void* data,
 247             Evas_Object* obj,
 248             void* eventInfo);
 249
 250     // database usage permission request callback
 251     static void databaseUsagePermissionRequestCallback(
 252         void* data,
 253         Evas_Object* obj,
 254         void* eventInfo);
 255     // file System Permission Request Callback
 256     static void fileSystemPermissionRequestCallback(
 257         void* data,
 258         Evas_Object* obj,
 259         void* eventInfo);
 260
 261     void attachToCustomHandlersDao();
 262     void detachFromCustomHandlersDao();
 263
 264     // JS execute callback
 265     static void didRunJavaScriptCallback(
 266             Evas_Object* obj,
 267             const char* result,
 268             void* userData);
 269
 270     // idler callback
 271     static Eina_Bool windowCloseIdlerCallback(void *data);
 272
 273     // appcore event callback
 274     static int appcoreLowMemoryCallback(void *data);
 275
 276     //bundle
 277     void didRecieveMessageFromInjectedBundle(
 278             const char* name,
 279             const char* body);
 280     void didReceiveSynchronousMessage(
 281             const char* name,
 282             const char* body,
 283             char** returnData);
 284
 285     // security
 286     void rememberBlockedURI(const DPL::String& str);
 287     std::string requestUriChanged(const DPL::String& changedURL);
 288
 289     // window
 290     void windowClose(void);
 291
 292     Ewk_Context* m_ewkContext;
 293     std::list<Evas_Object*> m_ewkViewList;
 294     Evas_Object* m_currentEwkView;
 295     Evas_Object* m_closedEwkView;
 296     Evas_Object* m_window;
 297     WidgetModel* m_model;
 298     std::string m_currentUri;
 299     std::string m_blockedUri;
 300     std::string m_theme;
 301     std::string m_startUrl;
 302     WRT::UserDelegatesPtr m_cbs;
 303     size_t m_imeWidth;
 304     size_t m_imeHeight;
 305     bool m_isBackgroundReload;
 306
 307     std::unique_ptr<SchemeSupport> m_schemeSupport;
 308     std::unique_ptr<ViewModule::AppsSupport> m_appsSupport;
 309     std::unique_ptr<ViewModule::VibrationSupport> m_vibrationSupport;
 310     std::unique_ptr<ViewModule::SecurityOriginSupport> m_securityOriginSupport;
 311     bool m_attachedToCustomHandlerDao;
 312
 313     static std::map<const std::string, const Evas_Smart_Cb> m_ewkCallbacksMap;
 314 };
 315
 316 #endif //VIEW_LOGIC_H_