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