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     bool 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 suspendWidget();
  59     void resumeWidget();
  60     void resetWidget();
  61     void backward();
  62     void reloadStartPage();
  63     Evas_Object* getCurrentWebview();
  64     void fireJavascriptEvent(int event, void* data);
  65     void setUserCallbacks(const WRT::UserDelegatesPtr& cbs);
  66
  67     // Ewk_Context operations
  68     void initializeEwkContext(Ewk_Context* context);
  69     void finalizeEwkContext();
  70
  71   private:
  72     void initializeSupport();
  73     void initializePluginLoading();
  74
  75     // EwkView operations
  76     void ewkClientInit(Evas_Object *wkView);
  77     void ewkClientDeinit(Evas_Object *wkView);
  78     bool createEwkView(Evas* canvas);
  79     void setStartPage();
  80     void prepareEwkView(Evas_Object *wkView);
  81     void removeEwkView(Evas_Object *wkView);
  82     void resumeEwkView(Evas_Object *wkView);
  83     void suspendEwkView(Evas_Object *wkView);
  84     void setEwkViewVisible(Evas_Object *wkView);
  85     void setEwkViewInvisible(Evas_Object *wkView);
  86     void resumeWebkit(Evas_Object *wkView);
  87     void suspendWebkit(Evas_Object *wkView);
  88
  89     // message from injected bundle Callback
  90     static void contextMessageFromInjectedBundleCallback(
  91         const char* name,
  92         const char* body,
  93         char** returnData,
  94         void* userData);
  95
  96     // EWK Context Callback
  97     static void didStartDownloadCallback(
  98         const char* downloadUrl,
  99         void* data);
 100
 101     // WKPageLoaderClient
 102     static void loadStartedCallback(
 103         void* data,
 104         Evas_Object* obj,
 105         void* eventInfo);
 106     static void loadFinishedCallback(
 107         void* data,
 108         Evas_Object* obj,
 109         void* eventInfo);
 110     static void titleChangedCallback(
 111         void* data,
 112         Evas_Object* obj,
 113         void* eventInfo);
 114     static void loadProgressCallback(
 115         void* data,
 116         Evas_Object* obj,
 117         void* eventInfo);
 118     static void loadProgressFinishedCallback(
 119         void* data,
 120         Evas_Object* obj,
 121         void* eventInfo);
 122     static void processCrashedCallback(
 123         void* data,
 124         Evas_Object* obj,
 125         void* eventInfo);
 126
 127     // EWK Callback
 128     static void createWindowCallback(
 129         void* data,
 130         Evas_Object* obj,
 131         void* eventInfo);
 132     static void closeWindowCallback(
 133         void* data,
 134         Evas_Object* obj,
 135         void* eventInfo);
 136
 137     // EWK PolicyDecide Callback
 138     static void policyNavigationDecideCallback(
 139         void* data,
 140         Evas_Object* obj,
 141         void* eventInfo);
 142     static void policyNewWindowDecideCallback(
 143         void* data,
 144         Evas_Object* obj,
 145         void* eventInfo);
 146     static void pageResponseDecideCallback(
 147         void* data,
 148         Evas_Object* obj,
 149         void* eventInfo);
 150
 151     // EWK ContextMenu Callback
 152     static void contextmenuCustomizeCallback(
 153         void* data,
 154         Evas_Object* obj,
 155         void* eventInfo);
 156
 157     // EWK FormClient Callback
 158     static void formSubmitCallback(
 159         void *data,
 160         Evas_Object *obj,
 161         void *eventInfo);
 162
 163     // EWK Geolocation Callback
 164     static void geolocationPermissionRequestCallback(
 165         void* data,
 166         Evas_Object* obj,
 167         void* eventInfo);
 168
 169     // EWK Notification Callback
 170     static void notificationShowCallback(
 171         void* data,
 172         Evas_Object* obj,
 173         void* eventInfo);
 174     static void notificationCancelCallback(
 175         void* data,
 176         Evas_Object* obj,
 177         void* eventInfo);
 178     static void notificationPermissionRequestCallback(
 179         void* data,
 180         Evas_Object* obj,
 181         void* eventInfo);
 182
 183     // EWK Vibration Callback
 184     static void vibrationVibrateCallback(uint64_t time, void* data);
 185     static void vibrationCancelCallback(void* data);
 186
 187     // EWK Orientation Callback
 188     static Eina_Bool orientationLockCallback(
 189         Evas_Object* obj,
 190         Eina_Bool needLock,
 191         int orientation,
 192         void* data);
 193
 194     // EWK Fullscreen API callbacks
 195     static void enterFullscreenCallback(
 196         void* data,
 197         Evas_Object* obj,
 198         void* eventInfo);
 199     static void exitFullscreenCallback(
 200         void* data,
 201         Evas_Object* obj,
 202         void* eventInfo);
 203
 204     // EWK IME Change/Show/Hide Callback
 205     static void imeChangedCallback(
 206         void* data,
 207         Evas_Object* obj,
 208         void* eventInfo);
 209     static void imeOpenedCallback(
 210         void* data,
 211         Evas_Object* obj,
 212         void* eventInfo);
 213     static void imeClosedCallback(
 214         void* data,
 215         Evas_Object* obj,
 216         void* eventInfo);
 217
 218     // EWK Usermedia Callback
 219     static void usermediaPermissionRequestCallback(
 220         void* data,
 221         Evas_Object* obj,
 222         void* eventInfo);
 223
 224     // custom content/scheme handlers
 225     static void protocolHandlerRegistrationCallback(void* data,
 226                                                     Evas_Object* obj,
 227                                                     void* eventInfo);
 228     static void protocolHandlerIsRegisteredCallback(void* data,
 229                                                     Evas_Object* obj,
 230                                                     void* eventInfo);
 231     static void protocolHandlerUnregistrationCallback(void* data,
 232                                                       Evas_Object* obj,
 233                                                       void* eventInfo);
 234
 235     static void contentHandlerRegistrationCallback(void* data,
 236                                                    Evas_Object* obj,
 237                                                    void* eventInfo);
 238     static void contentHandlerIsRegisteredCallback(void* data,
 239                                                    Evas_Object* obj,
 240                                                    void* eventInfo);
 241     static void contentHandlerUnregistrationCallback(void* data,
 242                                                      Evas_Object* obj,
 243                                                      void* eventInfo);
 244
 245     // database usage permission request callback
 246     static void databaseUsagePermissionRequestCallback(
 247         void* data,
 248         Evas_Object* obj,
 249         void* eventInfo);
 250     // file System Permission Request Callback
 251     static void fileSystemPermissionRequestCallback(
 252         void* data,
 253         Evas_Object* obj,
 254         void* eventInfo);
 255     static void certificateConfirmRequestCallback(
 256         void* data,
 257         Evas_Object* obj,
 258         void* eventInfo);
 259     bool askUserForCertificateConfirm();
 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     bool m_isBackgroundSupport;
 307
 308     std::unique_ptr<SchemeSupport> m_schemeSupport;
 309     std::unique_ptr<ViewModule::AppsSupport> m_appsSupport;
 310     std::unique_ptr<ViewModule::VibrationSupport> m_vibrationSupport;
 311     std::unique_ptr<ViewModule::SecurityOriginSupport> m_securityOriginSupport;
 312     bool m_attachedToCustomHandlerDao;
 313
 314     static std::map<const std::string, const Evas_Smart_Cb> m_ewkCallbacksMap;
 315 };
 316
 317 #endif //VIEW_LOGIC_H_