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