#include "base/i18n/icu_util.h"
#if defined(OS_TIZEN)
+#include <Elementary.h>
+
+#include "atom/app/runtime.h"
#include "base/logging.h"
#include "tizen/common/application_data.h"
#include "tizen/common/command_line.h"
#include "tizen/loader/prelauncher.h"
-#include "base/logging.h"
#endif
namespace {
#elif defined(OS_LINUX) // defined(OS_WIN)
#if defined(OS_TIZEN)
+// For debug purpose only.
+// TODO: To be removed later
+bool hasTizenPackageID(int argc, const char* const* argv) {
+ if (argc > 3) {
+ if (0 == strncmp(argv[0], "/opt/usr/globalapps/", strlen("/opt/usr/globalapps/"))) {
+ return true;
+ }
+ }
+ return false;
+}
+
int real_main(int argc, char* argv[]) {
#else
int main(int argc, char* argv[]) {
params.argc = argc;
params.argv = const_cast<const char**>(argv);
atom::AtomCommandLine::Init(argc, argv);
+#if defined(OS_TIZEN)
+ if (hasTizenPackageID(argc,argv)) { // TODO: Check to be removed later
+ elm_init(argc, argv);
+ std::unique_ptr<runtime::Runtime> runtime = runtime::Runtime::MakeRuntime(¶ms);
+ return runtime->Exec();
+ }
+#endif
return content::ContentMain(params);
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "atom/app/runtime.h"
+#include "atom/app/ui_runtime.h"
+#include "base/logging.h"
+
+namespace runtime {
+
+Runtime::~Runtime() {
+}
+
+std::unique_ptr<Runtime> Runtime::MakeRuntime(content::ContentMainParams *params) {
+/* if (app_data->app_type() == common::ApplicationData::UI) {
+ return std::unique_ptr<Runtime>(new UiRuntime());
+ }
+#ifdef IME_FEATURE_SUPPORT
+ else if (app_data->app_type() == common::ApplicationData::IME) {
+ return std::unique_ptr<Runtime>(new ImeRuntime(app_data));
+ }
+#endif // IME_FEATURE_SUPPORT
+#ifdef WATCH_FACE_FEATURE_SUPPORT
+ else if (app_data->app_type() == common::ApplicationData::WATCH) {
+ return std::unique_ptr<Runtime>(new WatchRuntime(app_data));
+ }
+#endif // WATCH_FACE_FEATURE_SUPPORT
+ else { */
+ return std::unique_ptr<Runtime>(new UiRuntime(params));
+ //}
+}
+
+} // namespace runtime
\ No newline at end of file
--- /dev/null
+
+/*
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RUNTIME_H_
+#define RUNTIME_H_
+
+#include <memory>
+#include <string>
+
+#include "content/public/app/content_main.h"
+
+namespace runtime {
+
+class Runtime {
+ public:
+ virtual ~Runtime() = 0;
+
+ virtual int Exec() = 0;
+
+ static std::unique_ptr<Runtime> MakeRuntime(content::ContentMainParams *params);
+};
+
+} // namespace runtime
+
+#endif // RUNTIME_H_
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <app.h>
+#include <string>
+#include <vector>
+
+#include "atom/app/atom_main_delegate.h"
+#include "atom/app/ui_runtime.h"
+#include "atom/browser/browser.h"
+#include "atom/browser/atom_browser_client.h"
+#include "atom/common/atom_command_line.h"
+#include "base/logging.h"
+#include "content/public/app/content_main.h"
+
+namespace runtime {
+
+UiRuntime::UiRuntime(content::ContentMainParams *params) {
+ _params = params;
+}
+
+UiRuntime::~UiRuntime() {
+}
+
+
+bool UiRuntime::OnCreate() {
+ return true;
+}
+
+void UiRuntime::OnTerminate() {
+ atom::Browser *browser_model = atom::Browser::Get();
+ browser_model->Shutdown();
+}
+
+void UiRuntime::OnPause() {
+ LOG(ERROR) << "OnPause()";
+ atom::Browser *browser_model = atom::Browser::Get();
+ browser_model->Hide();
+}
+
+void UiRuntime::OnResume() {
+ LOG(ERROR) << "OnResume()";
+ atom::Browser *browser_model = atom::Browser::Get();
+ browser_model->Show();
+}
+
+void UiRuntime::OnAppControl(app_control_h app_control) {
+ LOG(ERROR) << "OnAppControl()";
+}
+
+void UiRuntime::OnLanguageChanged(const std::string& language) {
+ LOG(ERROR) << "OnLanguageChanged()";
+}
+
+void UiRuntime::OnLowMemory() {
+ LOG(ERROR) << "OnLowMemory()";
+}
+
+int UiRuntime::Exec() {
+ ui_app_lifecycle_callback_s ops = {NULL, NULL, NULL, NULL, NULL};
+
+ // onCreate
+ ops.create = [](void* data) -> bool {
+
+ LOG(ERROR) << "Create Tizen App.";
+ UiRuntime *runtime = (UiRuntime*)data;
+ content::ContentMain(*runtime->_params);
+ return true;
+ };
+
+ // onTerminate
+ ops.terminate = [](void* data) -> void {
+ LOG(ERROR) << "Terminate Tizen App.";
+ UiRuntime *runtime = (UiRuntime*)data;
+ runtime->OnTerminate();
+ };
+
+ // onPause
+ ops.pause = [](void* data) -> void {
+ LOG(ERROR) << "Pause Tizen App.";
+ UiRuntime *runtime = (UiRuntime*)data;
+ runtime->OnPause();
+ };
+
+ // onResume
+ ops.resume = [](void* data) -> void {
+ LOG(ERROR) << "Resume Tizen App.";
+ UiRuntime *runtime = (UiRuntime*)data;
+ runtime->OnResume();
+ };
+
+ // onAppControl
+ ops.app_control = [](app_control_h app_control, void* data) -> void {
+ LOG(ERROR) << "app_control Tizen App.";
+ UiRuntime *runtime = (UiRuntime*)data;
+ runtime->OnAppControl(app_control);
+ };
+
+ return ui_app_main(_params->argc, const_cast<char**>(_params->argv), &ops, this);
+}
+
+} //namespace
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UI_RUNTIME_H_
+#define UI_RUNTIME_H_
+
+#include <app.h>
+#include <string>
+#include "atom/app/runtime.h"
+#include "content/public/app/content_main.h"
+
+namespace runtime {
+
+class UiRuntime : public Runtime {
+ public:
+ UiRuntime(content::ContentMainParams *params);
+ virtual ~UiRuntime();
+
+ virtual int Exec();
+
+ protected:
+ virtual bool OnCreate();
+ virtual void OnTerminate();
+ virtual void OnPause();
+ virtual void OnResume();
+ virtual void OnAppControl(app_control_h app_control);
+ virtual void OnLanguageChanged(const std::string& language);
+ virtual void OnLowMemory();
+
+ private:
+ content::ContentMainParams *_params;
+};
+
+} // namespace runtime
+
+#endif // XWALK_RUNTIME_BROWSER_UI_RUNTIME_H_
}
#endif
+#if defined(USE_EFL)
+void Window::OnSuspend() {
+ Emit("app-on-suspend");
+}
+
+void Window::OnResume() {
+ Emit("app-on-resume");
+}
+#endif
+
// static
mate::WrappableBase* Window::New(mate::Arguments* args) {
if (!Browser::Get()->is_ready()) {
void OnWindowMessage(UINT message, WPARAM w_param, LPARAM l_param) override;
#endif
+#if defined(USE_EFL)
+ void OnSuspend();
+ void OnResume();
+#endif
+
private:
void Init(v8::Isolate* isolate,
v8::Local<v8::Object> wrapper,
}
}
+void Browser::Hide() {
+ for (BrowserObserver& observer : observers_)
+ observer.OnSuspend();
+}
+
+void Browser::Show() {
+ for (BrowserObserver& observer : observers_)
+ observer.OnResume();
+}
+
} // namespace atom
void SetLoginItemSettings(LoginItemSettings settings);
LoginItemSettings GetLoginItemSettings(const LoginItemSettings& options);
+ void Hide();
+ void Show();
#if defined(OS_MACOSX)
// Hide the application.
void Hide();
// The browser's accessibility suppport has changed.
virtual void OnAccessibilitySupportChanged() {}
+ virtual void OnSuspend() {}
+ virtual void OnResume() {}
#if defined(OS_MACOSX)
// The browser wants to resume a user activity via handoff. (macOS only)
virtual void OnContinueUserActivity(
}], # tizen_product_tv==1
],
}, # vd-win-util
+ {
+ 'target_name': 'capi-appfw-application',
+ 'type': 'none',
+ 'conditions': [
+ ['is_tizen==1', {
+ 'direct_dependent_settings': {
+ 'cflags': [
+ '<!@(<(pkg-config) --cflags capi-appfw-application)',
+ ],
+ },
+ 'link_settings': {
+ 'ldflags': [
+ '<!@(<(pkg-config) --libs-only-L --libs-only-other capi-appfw-application)',
+ ],
+ 'libraries': [
+ '<!@(<(pkg-config) --libs-only-l capi-appfw-application)',
+ ],
+ },
+ }],
+ ],
+ }, # capi-appfw-application
],
}
'tizen/loader/loader.gyp:wrt-loader',
'<(DEPTH)/efl/build/system.gyp:ecore',
'<(DEPTH)/efl/build/system.gyp:launchpad',
+ '<(DEPTH)/efl/build/system.gyp:capi-appfw-application',
+ '<(DEPTH)/efl/build/system.gyp:elementary',
],
'sources': [
'tizen/loader/prelauncher.h',
'<(DEPTH)/efl/build/system.gyp:efl-extension',
'<(DEPTH)/efl/build/system.gyp:evas',
'<(DEPTH)/efl/build/system.gyp:icu',
+ '<(DEPTH)/efl/build/system.gyp:capi-appfw-application',
'electron_shell_copy',
],
}, {
'atom/app/atom_main_delegate_mac.mm',
'atom/app/node_main.cc',
'atom/app/node_main.h',
+ 'atom/app/runtime.cc',
+ 'atom/app/runtime.h',
+ 'atom/app/ui_runtime.cc',
+ 'atom/app/ui_runtime.h',
'atom/app/uv_task_runner.cc',
'atom/app/uv_task_runner.h',
'atom/browser/api/atom_api_app.cc',
killAllProcesses() {}
handleWasEvents() {
var _this = this;
- events.on(WAS_EVENT.RUNTIME.FOCUS, (sender, id) => {
+ events.on(WAS_EVENT.WEBAPPLICATION.RESUME, (sender, id) => {
runtime_debug('handleWasMessages: focus ' + id);
return _this.onResume(id);
});
- events.on(WAS_EVENT.RUNTIME.UNFOCUS, (sender, id) => {
+ events.on(WAS_EVENT.WEBAPPLICATION.SUSPEND, (sender, id) => {
return _this.onPause(id);
});
}
this.mainWindow.on('language-changed', function(event, locale) {
webwindow_debug('WebWindow : language-changed event = ' + (JSON.stringify(locale)));
});
+ this.mainWindow.on('app-on-suspend', function() {
+ webwindow_debug('WebWindow : app-on-suspend');
+ events.emit(WAS_EVENT.WEBAPPLICATION.SUSPEND, 'web_window', self.mainWindow.id);
+ });
+ this.mainWindow.on('app-on-resume', function() {
+ webwindow_debug('WebWindow : app-on-resume');
+ events.emit(WAS_EVENT.WEBAPPLICATION.RESUME, 'web_window', self.mainWindow.id);
+ });
this.mainWindow.webContents.on('crashed', function() {
webwindow_debug('WebWindow : webContents crashed');
global.webApplication.exit(100);
this.mainWindow.on('language-changed', function(event, locale) {
webwindow_debug('WebWindow : language-changed event = ' + (JSON.stringify(locale)));
});
+ this.mainWindow.on('app-on-suspend', function() {
+ webwindow_debug('WebWindow : app-on-suspend');
+ events.emit(WAS_EVENT.WEBAPPLICATION.SUSPEND, 'web_window', self.mainWindow.id);
+ });
+ this.mainWindow.on('app-on-resume', function() {
+ webwindow_debug('WebWindow : app-on-resume');
+ events.emit(WAS_EVENT.WEBAPPLICATION.RESUME, 'web_window', self.mainWindow.id);
+ });
this.mainWindow.webContents.on('crashed', function() {
webwindow_debug('WebWindow : webContents crashed');
global.webApplication.exit(100);