--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+
+ADD_SUBDIRECTORY(clock-viewer)
+ADD_SUBDIRECTORY(default-clock)
--- /dev/null
+PROJECT(w-clock-viewer C)
+
+IF("${ARCH}" STREQUAL "arm")
+ OPTION(RUN_ON_DEVICE "Run on device" ON)
+ ADD_DEFINITIONS("-DRUN_ON_DEVICE")
+ELSE()
+ OPTION(RUN_ON_EMULATOR "Run on emulator" ON)
+ ADD_DEFINITIONS("-DRUN_ON_EMULATOR")
+ENDIF()
+MESSAGE("ARCH: ${ARCH}")
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(PKGS REQUIRED
+ capi-appfw-application
+ capi-system-device
+ elementary
+ minicontrol-viewer
+ minicontrol-monitor
+ minicontrol-handler
+ widget_viewer_evas
+ widget_service
+ alarm-service
+ pkgmgr-info
+ vconf
+ dlog
+)
+
+SET(PACKAGE_NAME "org.tizen.${PROJECT_NAME}")
+SET(PREFIX "/usr/apps/${PACKAGE_NAME}")
+SET(BINDIR "${PREFIX}/bin")
+SET(RESDIR "${PREFIX}/res")
+SET(DATADIR "/opt${PREFIX}/data")
+SET(EDJEDIR "${RESDIR}/edje")
+
+REMOVE_DEFINITIONS("-DLOG_TAG")
+ADD_DEFINITIONS("-DPREFIX=\"${PREFIX}\"")
+ADD_DEFINITIONS("-DPROJECT=\"${PROJECT_NAME}\"")
+ADD_DEFINITIONS("-DPACKAGE=\"${PACKAGE_NAME}\"")
+ADD_DEFINITIONS("-DVERSION=\"${VERSION}\"")
+ADD_DEFINITIONS("-DDATADIR=\"${DATADIR}\"")
+ADD_DEFINITIONS("-DRESDIR=\"${RESDIR}\"")
+ADD_DEFINITIONS("-DIMAGEDIR=\"${IMAGEDIR}\"")
+ADD_DEFINITIONS("-DEDJEDIR=\"${EDJEDIR}\"")
+ADD_DEFINITIONS("-DLOCALEDIR=\"${LOCALEDIR}\"")
+
+IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+ SET(CMAKE_BUILD_TYPE "Release")
+ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
+
+FOREACH(flag ${PKGS_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+FOREACH(flag ${PKGS_ARM_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(PRIVATE_C_FLAGS "-I${CMAKE_CURRENT_SOURCE_DIR}/include")
+SET(CMAKE_C_FLAGS " ${PRIVATE_C_FLAGS} ${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIE ${ADD_VIEWER_CFLAGS}")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_C_FLAGS_RELEASE "-O2")
+
+FIND_PROGRAM(UNAME NAMES uname)
+EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
+
+SET(EXTRA_LDFLAGS "-ldl")
+SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed")
+
+ADD_EXECUTABLE(${PROJECT_NAME}
+ src/clock-viewer-main.c
+ src/clock-viewer.c
+ src/clock-viewer-util-dbus.c
+ src/clock-viewer-util-pkginfo.c
+ src/clock-viewer-util-winset.c
+ src/clock-viewer-util-alarm.c
+ src/clock-viewer-display.c
+ src/clock-viewer-window.c
+ src/clock-viewer-minicontrol.c
+ src/clock-viewer-widget.c
+ src/clock-viewer-default-clock.c
+ src/clock-viewer-default-clock-fallback.c
+ src/clock-viewer-plugin.c
+)
+
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${PKGS_LDFLAGS} ${EXTRA_LDFLAGS} -lm -Wl,--hash-style=both -Wl,--as-needed -pie )
+IF(RUN_ON_DEVICE)
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${PKGS_ARM_LDFLAGS} -lm)
+ENDIF()
+
+# Install
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${BINDIR})
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/LICENSE DESTINATION /usr/share/license RENAME ${PACKAGE_NAME})
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/${PACKAGE_NAME}.xml.in ${CMAKE_BINARY_DIR}/${PACKAGE_NAME}.xml)
+INSTALL(FILES ${CMAKE_BINARY_DIR}/${PACKAGE_NAME}.xml DESTINATION /usr/share/packages)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${PACKAGE_NAME}.rule DESTINATION /etc/smack/accesses.d)
+
+# data
+ADD_SUBDIRECTORY(data)
+
+# End of a file
--- /dev/null
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ 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.
--- /dev/null
+# install edj
+ADD_CUSTOM_TARGET(clock-viewer.edj
+ COMMAND edje_cc -id ${CMAKE_CURRENT_SOURCE_DIR}/images ${EDJE_CFLAGS}
+ ${CMAKE_CURRENT_SOURCE_DIR}/clock-viewer.edc clock-viewer.edj
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/clock-viewer.edc
+)
+ADD_DEPENDENCIES(${PROJECT_NAME} clock-viewer.edj)
+ADD_CUSTOM_TARGET(default-clock-fallback.edj
+ COMMAND edje_cc -id ${CMAKE_CURRENT_SOURCE_DIR}/images ${EDJE_CFLAGS}
+ ${CMAKE_CURRENT_SOURCE_DIR}/default-clock-fallback.edc default-clock-fallback.edj
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/default-clock-fallback.edc
+)
+ADD_DEPENDENCIES(${PROJECT_NAME} default-clock-fallback.edj)
+
+INSTALL(FILES clock-viewer.edj DESTINATION ${EDJEDIR})
+INSTALL(FILES default-clock-fallback.edj DESTINATION ${EDJEDIR})
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#define IDLE_CLOCK_ALPM_STATE_CHANGE(title,state)\
+ program {\
+ signal: title.state;\
+ source: title;\
+ action: STATE_SET state 0.0;\
+ target: title;\
+ }
+
+collections {
+ group {
+ name: "layout_manual_clock_position";
+ parts {
+ part {
+ name: "bg";
+ type: RECT;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ rel1 { relative: 0.0 0.0; }
+ rel2 { relative: 1.0 1.0; }
+ color: 0 0 0 255;
+ }
+ }
+ part {
+ name: "elm.swallow.body";
+ type: SWALLOW;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ rel1 { relative: 0.0 0.0; to: "bg"; }
+ rel2 { relative: 1.0 1.0; to: "bg"; }
+ }
+ description {
+ state: "top" 0.0;
+ rel1 { relative: 0.0 -0.02; to: "bg"; }
+ rel2 { relative: 1.0 0.98; to: "bg"; }
+ }
+ description {
+ state: "right" 0.0;
+ rel1 { relative: 0.02 0.0; to: "bg"; }
+ rel2 { relative: 1.02 1.0; to: "bg"; }
+ }
+ description {
+ state: "bottom" 0.0;
+ rel1 { relative: 0.0 0.02; to: "bg"; }
+ rel2 { relative: 1.0 1.02; to: "bg"; }
+ }
+ description {
+ state: "left" 0.0;
+ rel1 { relative: -0.02 0.0; to: "bg"; }
+ rel2 { relative: 0.98 1.0; to: "bg"; }
+ }
+ description {
+ state: "topright" 0.0;
+ rel1 { relative: 0.02 -0.02; to: "bg"; }
+ rel2 { relative: 1.02 0.98; to: "bg"; }
+ }
+ description {
+ state: "bottomright" 0.0;
+ rel1 { relative: 0.02 0.02; to: "bg"; }
+ rel2 { relative: 1.02 1.02; to: "bg"; }
+ }
+ description {
+ state: "bottomleft" 0.0;
+ rel1 { relative: -0.02 0.02; to: "bg"; }
+ rel2 { relative: 0.98 1.02; to: "bg"; }
+ }
+ description {
+ state: "topleft" 0.0;
+ rel1 { relative: -0.02 -0.02; to: "bg"; }
+ rel2 { relative: 0.98 0.98; to: "bg"; }
+ }
+ }
+ }
+ programs {
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, default)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, top)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, right)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, bottom)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, left)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, topright)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, bottomright)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, bottomleft)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, topleft)
+ }
+ }
+}
+
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#define IDLE_CLOCK_ALPM_STATE_CHANGE(title,state)\
+ program {\
+ signal: title.state;\
+ source: title;\
+ action: STATE_SET state 0.0;\
+ target: title;\
+ }
+
+collections {
+ group {
+ name: "layout_clock_position";
+ parts {
+ part {
+ name: "bg";
+ type: RECT;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ rel1 { relative: 0.0 0.0; }
+ rel2 { relative: 1.0 1.0; }
+ color: 0 0 0 255;
+ }
+ }
+ part {
+ name: "elm.swallow.body";
+ type: SWALLOW;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ rel1 { relative: 0.0 15/480; to: "bg"; }
+ rel2 { relative: 1.0 121/480; to: "bg"; }
+ }
+ description {
+ state: "middle1" 0.0;
+ rel1 { relative: 0.0 58/480; to: "bg"; }
+ rel2 { relative: 1.0 164/480; to: "bg"; }
+ }
+ description {
+ state: "middle2" 0.0;
+ rel1 { relative: 0.0 101/480; to: "bg"; }
+ rel2 { relative: 1.0 207/480; to: "bg"; }
+ }
+ description {
+ state: "middle3" 0.0;
+ rel1 { relative: 0.0 144/480; to: "bg"; }
+ rel2 { relative: 1.0 250/480; to: "bg"; }
+ }
+ description {
+ state: "middle4" 0.0;
+ rel1 { relative: 0.0 187/480; to: "bg"; }
+ rel2 { relative: 1.0 293/480; to: "bg"; }
+ }
+ description {
+ state: "middle5" 0.0;
+ rel1 { relative: 0.0 230/480; to: "bg"; }
+ rel2 { relative: 1.0 336/480; to: "bg"; }
+ }
+ description {
+ state: "middle6" 0.0;
+ rel1 { relative: 0.0 273/480; to: "bg"; }
+ rel2 { relative: 1.0 379/480; to: "bg"; }
+ }
+ description {
+ state: "middle7" 0.0;
+ rel1 { relative: 0.0 316/480; to: "bg"; }
+ rel2 { relative: 1.0 422/480; to: "bg"; }
+ }
+ description {
+ state: "bottom" 0.0;
+ rel1 { relative: 0.0 359/480; to: "bg"; }
+ rel2 { relative: 1.0 465/480; to: "bg"; }
+ }
+ }
+ }
+ programs {
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, default)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, middle1)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, middle2)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, middle3)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, middle4)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, middle5)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, middle6)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, middle7)
+ IDLE_CLOCK_ALPM_STATE_CHANGE(elm.swallow.body, bottom)
+ }
+ }
+
+ group {
+ name: "layout_clock_tb";
+ styles {
+ style {
+ name: "textblock_digit_style2";
+ base: "font=SamsungNeoNum-3T:style=Light font_size=78 color=#ffffff align=center style=shadow,bottom shadow_color=#00000088";
+ tag: "br" "\n";
+ tag: "hilight" "+ font_weight=Bold";
+ tag: "b" "+ font_weight=Bold";
+ tag: "tab" "\t";
+ }
+ }
+
+ parts {
+ part {
+ name: "text.clock";
+ type: TEXTBLOCK;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ rel1 { relative: 0.0 0.0; }
+ rel2 { relative: 1.0 1.0; }
+ fixed: 1 1;
+ visible: 1;
+ color: 255 255 255 255;
+ //align: 0.5 1.0;
+ text{
+ text: "";
+ style: "textblock_digit_style2";
+ align: 0.5 0.5;
+ }
+ }
+ }
+ }
+ }
+}
+
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_DEBUG_H__
+#define __CLOCK_VIEWER_DEBUG_H__
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "W_CLOCK_VIEWER"
+
+#include <dlog.h>
+
+#define _ERR(fmt, arg...) LOGE(" "fmt, ##arg)
+#define _WARN(fmt, arg...) LOGW(" "fmt, ##arg)
+#define _DBG(fmt, arg...) LOGD(" "fmt, ##arg)
+
+#define _SERR(fmt, arg...) SECURE_LOGE(" "fmt, ##arg)
+#define _SWARN(fmt, arg...) SECURE_LOGW(" "fmt, ##arg)
+#define _SDBG(fmt, arg...) SECURE_LOGD(" "fmt, ##arg)
+
+#endif /* __CLOCK_VIEWER_DEBUG_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_DEFAULT_CLOCK_FALLBACK_H__
+#define __CLOCK_VIEWER_DEFAULT_CLOCK_FALLBACK_H__
+
+#include <Elementary.h>
+
+#include "clock-viewer.h"
+
+/**
+ * @brief initialize fallback digital clock
+ *
+ * @param[in] data user data
+ * @param[in] parent it should be window evas object
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_default_clock_fallback_init(void *data, Evas_Object *parent);
+
+/**
+ * @brief finalize fallback digital clock
+ *
+ * @param[in] data user data
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_default_clock_fallback_fini(void *data);
+
+/**
+ * @brief update fallback digital clock
+ *
+ * @param[in] data user data
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_default_clock_fallback_update(void *data);
+
+#endif /* __CLOCK_VIEWER_DEFAULT_CLOCK_FALLBACK_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_DEFAULT_CLOCK_H__
+#define __CLOCK_VIEWER_DEFAULT_CLOCK_H__
+
+#include <Elementary.h>
+
+#include "clock-viewer.h"
+
+/**
+ * @brief initialize default clock
+ *
+ * @param[in] data user data
+ * @param[in] parent it should be window evas object
+ * @param[in] ambient_type ambient clock type
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_default_clock_init(void *data, Evas_Object *parent, clock_viewer_ambient_type ambient_type);
+
+/**
+ * @brief finalize default clock
+ *
+ * @param[in] data user data
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_default_clock_fini(void *data);
+
+/**
+ * @brief pause default clock
+ *
+ * @param[in] data user data
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_default_clock_pause(void *data);
+
+/**
+ * @brief resume default clock
+ *
+ * @param[in] data user data
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_default_clock_resume(void *data);
+
+#endif /* __CLOCK_VIEWER_DEFAULT_CLOCK_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_DISPLAY_H__
+#define __CLOCK_VIEWER_DISPLAY_H__
+
+enum
+{
+ CLOCK_VIEWER_DISPLAY_MODE_NONE = 0,
+ CLOCK_VIEWER_DISPLAY_MODE_RESUME,
+ CLOCK_VIEWER_DISPLAY_MODE_PAUSE,
+ CLOCK_VIEWER_DISPLAY_MODE_MAX,
+};
+
+extern void clock_viewer_display_set_dpms_mode(int mode);
+
+#endif /* __CLOCK_VIEWER_DISPLAY_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_FEATURE_H__
+#define __CLOCK_VIEWER_FEATURE_H__
+
+#ifndef PACKAGE
+#define PACKAGE "w-clock-viewer"
+#endif
+
+#ifndef EDJEDIR
+#define EDJEDIR "/usr/apps/org.tizen.w-clock-viewer/res/edje"
+#endif
+
+/* for window */
+#define _CLOCK_VIEWER_FEATURE_ALPHA_WINDOW_ 0
+
+/* for display */
+#define _CLOCK_VIEWER_FEATURE_DPMS_CALL_ENABLED_ 0
+
+/* for preloaded watchface app */
+#define _CLOCK_VIEWER_FEATURE_VI_BY_HOMESCREEN_STATUS_ENABLED_ 1
+
+#endif /* __CLOCK_VIEWER_FEATURE_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_MINICONTROL_H__
+#define __CLOCK_VIEWER_MINICONTROL_H__
+
+#include "clock-viewer.h"
+
+extern void clock_viewer_minicontrol_init(void *data, Evas_Object *parent);
+extern void clock_viewer_minicontrol_fini(void *data);
+
+#endif /* __CLOCK_VIEWER_MINICONTROL_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_PLUGIN_H__
+#define __CLOCK_VIEWER_PLUGIN_H__
+
+#include "clock-viewer.h"
+
+#ifndef ALPM_CLOCK_PLUGIN_MODULE_INIT_SYM
+#define ALPM_CLOCK_PLUGIN_MODULE_INIT_SYM "ALPM_CLOCK_PLUGIN_MODULE_INIT"
+#endif
+
+#ifndef ALPM_CLOCK_PLUGIN_MODULE_EXIT_SYM
+#define ALPM_CLOCK_PLUGIN_MODULE_EXIT_SYM "ALPM_CLOCK_PLUGIN_MODULE_EXIT"
+#endif
+
+#ifndef ALPM_CLOCK_PLUGIN_MODULE_LOCALE_UPDATE_SYM
+#define ALPM_CLOCK_PLUGIN_MODULE_LOCALE_UPDATE_SYM "ALPM_CLOCK_PLUGIN_MODULE_LOCALE_UPDATE"
+#endif
+
+#ifndef ALPM_CLOCK_PLUGIN_EXPORT_API
+#define ALPM_CLOCK_PLUGIN_EXPORT_API __attribute__ ((visibility("default")))
+#endif
+
+typedef struct _alpm_clock_plugin_module_ops
+{
+ /* struct modules is initialized by alpm-clock module. */
+ struct
+ {
+ int (*ui_runtime_plugin_init)(void *ops, void *data); /* data will be parent evas object */
+ int (*ui_runtime_plugin_deinit)(void *ops, void *data);
+ int (*ui_runtime_plugin_update_clock)(void *ops, void *data);
+ void *priv;
+ } modules;
+
+} alpm_clock_plugin_module_ops;
+
+/**
+ * @brief initialize plugin clock
+ *
+ * @param[in] data user data
+ * @param[in] parent it should be window evas object
+ * @param[in] ambient_type ambient clock type
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_plugin_init(void *data, Evas_Object *parent, clock_viewer_ambient_type ambient_type);
+
+/**
+ * @brief finalize plugin clock
+ *
+ * @param[in] data user data
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_plugin_fini(void *data);
+
+extern int clock_viewer_plugin_locale_update(void *data);
+
+/**
+ * @brief update plugin clock
+ *
+ * @param[in] data user data
+ * @return CLOCK_VIEWER_SUCCESS if success, otherwise CLOCK_VIEWER_FAIL
+ */
+extern int clock_viewer_plugin_update(void *data);
+
+#endif /* __CLOCK_VIEWER_PLUGIN_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_UTIL_ALARM_H__
+#define __CLOCK_VIEWER_UTIL_ALARM_H__
+
+#include <alarm.h>
+
+extern int clock_viewer_util_alarm_init(void);
+extern void clock_viewer_util_alarm_fini(void);
+
+extern alarm_id_t clock_viewer_util_alarm_add(time_t start, time_t interval, alarm_cb_t func, void *data);
+extern void clock_viewer_util_alarm_remove(alarm_id_t alarm_id);
+
+#endif /* __CLOCK_VIEWER_UTIL_ALARM_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_UTIL_DBUS_H__
+#define __CLOCK_VIEWER_UTIL_DBUS_H__
+
+#include <E_DBus.h>
+
+#define DEVICED_PATH "/Org/Tizen/System/DeviceD"
+#define DEVICED_INTERFACE "org.tizen.system.deviced"
+
+#define DEVICED_DISPLAY_PATH "/Org/Tizen/System/DeviceD/Display"
+#define DEVICED_DISPLAY_INTERFACE "org.tizen.system.deviced.display"
+#define LCDON_SIGNAL_NAME "LCDOn"
+#define LCDOFF_SIGNAL_NAME "LCDOff"
+
+#define CLOCKDRAW_PATH "/Org/Tizen/Coreapps/Alpmviewer/Clockdraw"
+#define CLOCKDRAW_INTERFACE "org.tizen.coreapps.alpmviewer.clockdraw"
+#define CLOCKDRAW_NAME "drawdone"
+
+extern void clock_viewer_util_dbus_broadcast_signal(void *data, char *path, char *interface, char *name, const char *type, char *signal[]);
+
+extern void clock_viewer_util_dbus_init_lcdoff_signal(void *data, E_DBus_Signal_Cb cb_signal);
+extern void clock_viewer_util_dbus_fini_lcdoff_signal(void *data);
+
+extern void clock_viewer_util_dbus_init_lcdon_signal(void *data, E_DBus_Signal_Cb cb_signal);
+extern void clock_viewer_util_dbus_fini_lcdon_signal(void *data);
+
+extern void clock_viewer_util_dbus_init_clockdraw_signal(void *data, E_DBus_Signal_Cb cb_signal);
+extern void clock_viewer_util_dbus_fini_clockdraw_signal(void *data);
+
+extern int clock_viewer_util_dbus_message_is_signal(DBusMessage *msg, const char *interface, const char *signal);
+
+#endif /* __CLOCK_VIEWER_UTIL_DBUS_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_UTIL_PKGINFO_H__
+#define __CLOCK_VIEWER_UTIL_PKGINFO_H__
+
+#include <vconf.h>
+
+#include "clock-viewer.h"
+
+extern void clock_viewer_util_pkginfo_init_clock_package_event(void *data, vconf_callback_fn cb);
+extern void clock_viewer_util_pkginfo_fini_clock_package_event(vconf_callback_fn cb);
+
+extern char *clock_viewer_util_pkginfo_get_clock_package(void);
+
+extern clock_viewer_ambient_type clock_viewer_util_pkginfo_get_ambient_type(char *appid);
+
+extern int clock_viewer_util_pkginfo_is_widget(char *appid);
+
+#endif /* __CLOCK_VIEWER_UTIL_PKGINFO_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_UTIL_STATUS_H__
+#define __CLOCK_VIEWER_UTIL_STATUS_H__
+
+extern void clock_viewer_util_status_init(void);
+extern void clock_viewer_util_status_fini(void);
+
+extern int clock_viewer_util_status_get_reserved_apps_status(void);
+
+#endif /* __CLOCK_VIEWER_UTIL_STATUS_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_UTIL_WINSET_H__
+#define __CLOCK_VIEWER_UTIL_WINSET_H__
+
+#include <Elementary.h>
+
+#include "clock-viewer.h"
+
+/**
+ * @brief create background
+ *
+ * @param[in] parent parent evas object
+ * @return bg if success, otherwise NULL
+ */
+
+extern Evas_Object *clock_viewer_util_winset_create_bg(Evas_Object *parent);
+
+/**
+ * @brief create layout
+ *
+ * @param[in] parent parent evas object
+ * @param[in] file edj file path
+ * @param[in] group group in edc
+ * @return layout if success, otherwise NULL
+ */
+extern Evas_Object *clock_viewer_util_winset_create_layout(Evas_Object *parent, const char *file, const char *group);
+
+#endif /* __CLOCK_VIEWER_UTIL_WINSET_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_WIDGET_H__
+#define __CLOCK_VIEWER_WIDGET_H__
+
+#include <Elementary.h>
+
+#include "clock-viewer.h"
+
+extern void clock_viewer_widget_init(void *data, Evas_Object *parent, char *pkgname);
+extern void clock_viewer_widget_fini(void *data);
+extern void clock_viewer_widget_pause(void);
+extern void clock_viewer_widget_resume(void);
+
+extern void clock_viewer_widget_update_position(void);
+
+extern void clock_viewer_widget_register_render_event(Evas_Smart_Cb func, void *data);
+extern void clock_viewer_widget_unregister_render_event(Evas_Smart_Cb func, void *data);
+
+#endif /* __CLOCK_VIEWER_WIDGET_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_WINDOW_H__
+#define __CLOCK_VIEWER_WINDOW_H__
+
+#include "clock-viewer.h"
+
+extern Evas_Object *clock_viewer_window_create(void);
+extern void clock_viewer_window_destroy(Evas_Object *window);
+
+#endif /* __CLOCK_VIEWER_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_H__
+#define __CLOCK_VIEWER_H__
+
+#include <Elementary.h>
+
+#include "clock-viewer-feature.h"
+#include "clock-viewer-debug.h"
+
+typedef enum _clock_viewer_type_e
+{
+ CLOCK_VIEWER_TYPE_NONE = 0,
+ CLOCK_VIEWER_TYPE_MINICTRL,
+ CLOCK_VIEWER_TYPE_WIDGET,
+ CLOCK_VIEWER_TYPE_DEFAULT_CLOCK,
+} clock_viewer_type_e;
+
+typedef enum _clock_viewer_ambient_type
+{
+ CLOCK_VIEWER_AMBIENT_TYPE_ANALOG = 1,
+ CLOCK_VIEWER_AMBIENT_TYPE_MANUAL,
+} clock_viewer_ambient_type;
+
+typedef enum _clock_viewer_pm_step_e
+{
+ CLOCK_VIEWER_PM_STEP_NONE = 0,
+ CLOCK_VIEWER_PM_STEP_CLOCKSTART,
+ CLOCK_VIEWER_PM_STEP_CLOCKEND,
+} clock_viewer_pm_step_e;
+
+typedef void (*clock_viewer_render_cb)(void *data, int type);
+
+typedef struct _clock_viewer_s
+{
+ Evas_Object *window;
+ Evas_Object *evas;
+
+ int win_width;
+ int win_height;
+
+ clock_viewer_type_e current_type;
+
+ // flag
+ clock_viewer_pm_step_e request_pm_status;
+ int is_lckoff; // 0 : on 1 : off
+} clock_viewer_s;
+
+#define CLOCK_VIEWER_SUCCESS 1
+#define CLOCK_VIEWER_FAIL 0
+
+#define CLOCK_VIEWER_TIZEN_CLOCK_CATEGORY "http://tizen.org/category/wearable_clock"
+
+#define HAPI __attribute__((visibility("hidden")))
+
+extern void clock_viewer_create(clock_viewer_s *clock_viewer);
+extern void clock_viewer_destroy(clock_viewer_s *clock_viewer);
+
+extern void clock_viewer_resume(clock_viewer_s *clock_viewer);
+extern void clock_viewer_pause(clock_viewer_s *clock_viewer);
+
+extern void clock_viewer_show(clock_viewer_s *clock_viewer, int is_hide_launch);
+extern void clock_viewer_hide(clock_viewer_s *clock_viewer);
+
+#endif /* __CLOCK_VIEWER_H__ */
--- /dev/null
+<manifest>
+ <define>
+ <domain name="org.tizen.w-clock-viewer"/>
+ </define>
+ <request>
+ <domain name="org.tizen.w-clock-viewer"/>
+ </request>
+</manifest>
--- /dev/null
+org.tizen.w-clock-viewer system::use_internet r----- ------
+org.tizen.w-clock-viewer net-config r----- ------
+org.tizen.w-clock-viewer xorg rw---- ------
+org.tizen.w-clock-viewer isf rwx--- ------
+org.tizen.w-clock-viewer sound_server rw---- ------
+org.tizen.w-clock-viewer syspopup::db rw---- ------
+org.tizen.w-clock-viewer dbus rwx--- ------
+org.tizen.w-clock-viewer pulseaudio rwxat- ------
+org.tizen.w-clock-viewer ail::db rw---- ------
+org.tizen.w-clock-viewer connman r----- ------
+org.tizen.w-clock-viewer system rwx--- ------
+org.tizen.w-clock-viewer immvibed rw---- ------
+org.tizen.w-clock-viewer svi-data r-x--- ------
+org.tizen.w-clock-viewer e17 r-x--- ------
+org.tizen.w-clock-viewer deviced rwx--- ------
+org.tizen.w-clock-viewer deviced::display rw---- ------
+org.tizen.w-clock-viewer deviced::haptic rw---- ------
+org.tizen.w-clock-viewer data-provider-master::data --x--- ------
+org.tizen.w-clock-viewer data-provider-master::db rw---- ------
+org.tizen.w-clock-viewer data-provider-master::share rwxat- ------
+org.tizen.w-clock-viewer data-provider-master::client rw---- ------
+org.tizen.w-clock-viewer data-provider-master rw---- ------
+org.tizen.w-clock-viewer app-svc::db rw---- ------
+org.tizen.w-clock-viewer org.tizen.alarm rwx--- ------
+org.tizen.w-clock-viewer org.tizen.setting::system rwx--- ------
+org.tizen.w-clock-viewer org.tizen.wfmd rwx--- ------
+org.tizen.w-clock-viewer pkgmgr::db rwx--- ------
+org.tizen.w-clock-viewer pkgmgr-client r-x--- ------
+org.tizen.w-clock-viewer pkgmgr::svc r-x--- ------
+org.tizen.w-clock-viewer pkgmgr::info r----- ------
+org.tizen.w-clock-viewer efreet rwx--- ------
+org.tizen.w-clock-viewer org.tizen.clocksetting rwx--- ------
+org.tizen.w-clock-viewer org.tizen.clocksetting::default-resources r-x--- ------
+org.tizen.w-clock-viewer org.tizen.w-idle-clock-weather2 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-pedometer rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-dual rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-digital rwx--- ------
+org.tizen.w-clock-viewer org.tizen.w-idle-clock-shortcut2 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style01 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style02 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style03 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style04 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style05 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style06 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style07 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style08 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style09 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.idle-clock-style10 rwx--- ------
+org.tizen.w-clock-viewer org.tizen.alpm-clock-manager rwx--- ------
+org.tizen.w-clock-viewer tizen::vconf::setting::admin rw---- ------
+org.tizen.w-clock-viewer data-provider-master::badge rw---- ------
+org.tizen.w-clock-viewer data-provider-master::badge.client -w---- ------
+org.tizen.w-clock-viewer samsung::vconf::widget rw---- ------
+org.tizen.w-clock-viewer aul::launch --x--- ------
+org.tizen.w-clock-viewer aul::terminate --x--- ------
+org.tizen.w-clock-viewer alarm-server::alarm rw---l ------
+org.tizen.w-clock-viewer alarm-manager::alarm rw---l ------
+aul org.tizen.w-clock-viewer r-x--- ------
+dbus org.tizen.w-clock-viewer rwx--- ------
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns="http://tizen.org/ns/packages" package="@PACKAGE_NAME@" version="0.0.1" install-location="internal-only" support-mode="screen-reader">
+ <label>W-Clock-Viewer</label>
+ <description>W-Clock-Viewer Application</description>
+ <ui-application appid="@PACKAGE_NAME@" exec="@BINDIR@/@PROJECT_NAME@" nodisplay="true" multiple="false" type="capp" taskmanage="false" process-pool="false">
+ <label>w-clock-viewer</label>
+ </ui-application>
+ <privileges>
+ <privilege>http://tizen.org/privilege/setting</privilege>
+ <privilege>http://tizen.org/privilege/power</privilege>
+ </privileges>
+</manifest>
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <glib.h>
+#include <unicode/utypes.h>
+#include <unicode/putil.h>
+#include <unicode/uiter.h>
+#include <unicode/udat.h>
+#include <unicode/udatpg.h>
+#include <unicode/ustring.h>
+
+#include <vconf.h>
+
+#include "clock-viewer-util-winset.h"
+#include "clock-viewer-default-clock-fallback.h"
+
+#define EDJ_APP EDJEDIR"/default-clock-fallback.edj"
+#define MAX_VIEW_STATE 8
+
+static struct _default_clock_fallback_info
+{
+ Evas_Object *parent; // window
+ Evas_Object *bg;
+ Evas_Object *position_layout;
+ Evas_Object *clock_layout;
+
+ Eina_Bool is_pre;
+
+ int timeformat;
+ char *timeregion_format;
+ char *timezone_id;
+
+ UDateTimePatternGenerator *generator;
+ UDateFormat *formatter_time;
+ UDateFormat *formatter_ampm;
+ UDateFormat *formatter_time_24;
+ UDateFormat *formatter_date;
+
+ int view_state;
+} s_default_clock_info = {
+ .parent = NULL,
+ .bg = NULL,
+ .position_layout = NULL,
+ .clock_layout = NULL,
+
+ .is_pre = 0,
+
+ .timeformat = 0,
+ .timeregion_format = NULL,
+ .timezone_id = NULL,
+
+ .generator = NULL,
+ .formatter_time = NULL,
+ .formatter_ampm = NULL,
+ .formatter_time_24 = NULL,
+ .formatter_date = NULL,
+
+ .view_state = -1,
+};
+
+static UChar *uastrcpy(const char *chars)
+{
+ int len = 0;
+ UChar *str = NULL;
+ len = strlen(chars);
+ str = (UChar *) malloc(sizeof(UChar) * (len + 1));
+ if (!str) {
+ return NULL;
+ }
+ u_uastrcpy(str, chars);
+ return str;
+}
+
+static char* _clock_viewer_default_clock_fallback_get_timezone(void)
+{
+ char buf[1024] = { 0, };
+ ssize_t len = readlink("/opt/etc/localtime", buf, sizeof(buf) - 1);
+
+ if (len != -1) {
+ buf[len] = '\0';
+ } else {
+ /* handle error condition */
+ _ERR("readlink() failed");
+ return vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_ID);
+ }
+
+ return strdup(buf + 20);
+}
+
+static char *_clock_viewer_default_clock_fallback_get_locale(void)
+{
+ char *locale = NULL;
+ char *str = NULL;
+ int count = 0;
+ gchar **ptr = NULL;
+ gchar **split_str = NULL;
+
+ locale = vconf_get_str(VCONFKEY_REGIONFORMAT);
+ if (!locale) {
+ _ERR("Failed to get region format");
+ return strdup("en_US");
+ }
+
+ split_str = g_strsplit(locale, ".", 0);
+
+ for (ptr = split_str; *ptr; ptr++) {
+ count++;
+ }
+
+ _DBG("count[%d] original locale[%s]", count, locale);
+
+ if (count == 2) {
+ if (!strcmp(split_str[1], "UTF-8")) {
+ str = g_strdup_printf("%s", split_str[0]);
+ free(locale);
+ _DBG("dest locale[%s]", str);
+ g_strfreev(split_str);
+ return str;
+ } else {
+ g_strfreev(split_str);
+ return locale;
+ }
+ } else {
+ g_strfreev(split_str);
+ return locale;
+ }
+}
+
+static UDateTimePatternGenerator *_clock_viewer_default_clock_fallback_get_generator(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ UDateTimePatternGenerator *generator = NULL;
+ UChar u_skeleton[64] = { 0, };
+
+ uloc_setDefault(getenv("LC_TIME"), &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to set default");
+ return NULL;
+ }
+
+ u_uastrncpy(u_skeleton, "hhmm", strlen("hhmm"));
+
+ if (!s_default_clock_info.timeregion_format) {
+ s_default_clock_info.timeregion_format = _clock_viewer_default_clock_fallback_get_locale();
+ }
+
+ generator = udatpg_open(s_default_clock_info.timeregion_format, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udatpg_open");
+ generator = NULL;
+ return NULL;
+ }
+
+ return generator;
+}
+
+static UDateFormat *_clock_viewer_default_clock_fallback_get_time_formatter(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+
+ UChar u_pattern[64] = { 0, };
+ UChar u_timezone[64] = { 0, };
+ UChar u_best_pattern[64] = { 0, };
+ int32_t u_best_pattern_capacity;
+ UDateFormat *formatter = NULL;
+
+ if (!s_default_clock_info.generator) {
+ s_default_clock_info.generator = _clock_viewer_default_clock_fallback_get_generator();
+ }
+
+ /* only 12 format */
+ if (u_uastrncpy(u_pattern, "h:mm", sizeof(u_pattern)) == NULL) {
+ _ERR("Failed to u_uastrncpy");
+ return NULL;
+ }
+
+ u_best_pattern_capacity = (int32_t) (sizeof(u_best_pattern) / sizeof((u_best_pattern)[0]));
+
+ udatpg_getBestPattern(s_default_clock_info.generator, u_pattern, u_strlen(u_pattern), u_best_pattern, u_best_pattern_capacity, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udatpg_getBestPattern");
+ return NULL;
+ }
+
+ /* remove am/pm of best pattern */
+ char a_best_pattern[64] = { 0. };
+ char *buffer = NULL;
+ u_austrcpy(a_best_pattern, u_best_pattern);
+ char *a_best_pattern_fixed = strtok_r(a_best_pattern, "a", &buffer);
+ a_best_pattern_fixed = strtok_r(a_best_pattern_fixed, " ", &buffer);
+
+ _DBG("best pattern [%s] fixed [%s]", a_best_pattern, a_best_pattern_fixed);
+
+ if (a_best_pattern_fixed) {
+ /* exception - da_DK */
+ if (strncmp(s_default_clock_info.timeregion_format, "da_DK", 5) == 0 || strncmp(s_default_clock_info.timeregion_format, "mr_IN", 5) == 0) {
+ char *a_best_pattern_changed = g_strndup("h:mm", 4);
+
+ _DBG("best pattern is changed [%s]", a_best_pattern_changed);
+ if (a_best_pattern_changed) {
+ u_uastrcpy(u_best_pattern, a_best_pattern_changed);
+ g_free(a_best_pattern_changed);
+ }
+ } else {
+ u_uastrcpy(u_best_pattern, a_best_pattern_fixed);
+ }
+ }
+
+ /* change char to UChar */
+ u_strncpy(u_pattern, u_best_pattern, sizeof(u_pattern));
+
+ /* get formatter */
+ u_uastrncpy(u_timezone, s_default_clock_info.timezone_id, sizeof(u_timezone));
+ formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, s_default_clock_info.timeregion_format, u_timezone, -1, u_pattern, -1, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udat_open");
+ return NULL;
+ }
+
+ return formatter;
+}
+
+static UDateFormat *_clock_viewer_default_clock_fallback_get_time_formatter_24(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+
+ UChar u_pattern[64] = { 0, };
+ UChar u_timezone[64] = { 0, };
+ UChar u_best_pattern[64] = { 0, };
+ int32_t u_best_pattern_capacity;
+ UDateFormat *formatter = NULL;
+
+ if (!s_default_clock_info.generator) {
+ s_default_clock_info.generator = _clock_viewer_default_clock_fallback_get_generator();
+ }
+
+ /* only 12 format */
+ if (u_uastrncpy(u_pattern, "H:mm", sizeof(u_pattern)) == NULL) {
+ _ERR("Failed to u_uastrncpy");
+ return NULL;
+ }
+
+ u_best_pattern_capacity = (int32_t) (sizeof(u_best_pattern) / sizeof((u_best_pattern)[0]));
+
+ udatpg_getBestPattern(s_default_clock_info.generator, u_pattern, u_strlen(u_pattern), u_best_pattern, u_best_pattern_capacity, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udatpg_getBestPattern");
+ return NULL;
+ }
+
+ /* remove am/pm of best pattern */
+ char a_best_pattern[64] = { 0. };
+ char *buffer = NULL;
+ u_austrcpy(a_best_pattern, u_best_pattern);
+ char *a_best_pattern_fixed = strtok_r(a_best_pattern, "a", &buffer);
+ a_best_pattern_fixed = strtok_r(a_best_pattern_fixed, " ", &buffer);
+
+ _DBG("best pattern [%s] fixed [%s]", a_best_pattern, a_best_pattern_fixed);
+
+ if (a_best_pattern_fixed) {
+ /* exception - pt_BR(HH'h'mm), id_ID, da_DK */
+ if (strncmp(a_best_pattern_fixed, "HH'h'mm", 7) == 0
+ || strncmp(s_default_clock_info.timeregion_format, "id_ID", 5) == 0
+ || strncmp(s_default_clock_info.timeregion_format, "da_DK", 5) == 0
+ || strncmp(s_default_clock_info.timeregion_format, "mr_IN", 5) == 0)
+ {
+ char *a_best_pattern_changed = g_strndup("HH:mm", 5);
+ _DBG("best pattern is changed [%s]", a_best_pattern_changed);
+ if (a_best_pattern_changed) {
+ u_uastrcpy(u_best_pattern, a_best_pattern_changed);
+ g_free(a_best_pattern_changed);
+ }
+ } else {
+ u_uastrcpy(u_best_pattern, a_best_pattern_fixed);
+ }
+ }
+
+ /* change char to UChar */
+ u_strncpy(u_pattern, u_best_pattern, sizeof(u_pattern));
+
+ /* get formatter */
+ u_uastrncpy(u_timezone, s_default_clock_info.timezone_id, sizeof(u_timezone));
+ formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, s_default_clock_info.timeregion_format, u_timezone, -1, u_pattern, -1, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udat_open");
+ return NULL;
+ }
+
+ return formatter;
+}
+
+static UDateFormat *_clock_viewer_default_clock_fallback_get_date_formatter()
+{
+ UErrorCode status = U_ZERO_ERROR;
+ UChar u_timezone[64] = { 0, };
+ UChar u_skeleton[64] = { 0, };
+ int skeleton_len = 0;
+
+ UChar u_best_pattern[64] = { 0, };
+ int32_t u_best_pattern_capacity;
+ UDateFormat *formatter = NULL;
+
+ u_uastrncpy(u_skeleton, "MMMEd", strlen("MMMEd"));
+ skeleton_len = u_strlen(u_skeleton);
+
+ u_best_pattern_capacity = (int32_t) (sizeof(u_best_pattern) / sizeof((u_best_pattern)[0]));
+ udatpg_getBestPattern(s_default_clock_info.generator, u_skeleton, skeleton_len, u_best_pattern, u_best_pattern_capacity, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udatpg_getBestPattern");
+ return NULL;
+ }
+
+ if (strncmp(s_default_clock_info.timeregion_format, "fi_FI", 5) == 0) {
+ char *a_best_pattern_changed = g_strndup("ccc, d. MMM", 11);
+ _DBG("date formatter best pattern is changed [%s]", a_best_pattern_changed);
+ if (a_best_pattern_changed) {
+ u_uastrcpy(u_best_pattern, a_best_pattern_changed);
+ g_free(a_best_pattern_changed);
+ }
+ }
+
+ /* get formatter */
+ u_uastrncpy(u_timezone, s_default_clock_info.timezone_id, sizeof(u_timezone));
+ formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, s_default_clock_info.timeregion_format, u_timezone, -1, u_best_pattern, -1, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udat_open");
+ return NULL;
+ }
+
+ return formatter;
+}
+
+static UDateFormat *_clock_viewer_default_clock_fallback_get_ampm_formatter()
+{
+ UErrorCode status = U_ZERO_ERROR;
+
+ char a_best_pattern[64] = { 0. };
+
+ UChar u_timezone[64] = { 0, };
+ UChar u_skeleton[64] = { 0, };
+ int skeleton_len = 0;
+
+ UChar u_best_pattern[64] = { 0, };
+ int32_t u_best_pattern_capacity;
+ UDateFormat *formatter = NULL;
+
+ u_uastrncpy(u_skeleton, "hhmm", strlen("hhmm"));
+ skeleton_len = u_strlen(u_skeleton);
+
+ u_best_pattern_capacity = (int32_t) (sizeof(u_best_pattern) / sizeof((u_best_pattern)[0]));
+ udatpg_getBestPattern(s_default_clock_info.generator, u_skeleton, skeleton_len, u_best_pattern, u_best_pattern_capacity, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udatpg_getBestPattern");
+ return NULL;
+ }
+
+ u_austrcpy(a_best_pattern, u_best_pattern);
+ u_uastrcpy(u_best_pattern, "a");
+
+ if (a_best_pattern[0] == 'a') {
+ s_default_clock_info.is_pre = EINA_TRUE;
+ } else {
+ s_default_clock_info.is_pre = EINA_FALSE;
+ }
+
+ /* get formatter */
+ u_uastrncpy(u_timezone, s_default_clock_info.timezone_id, sizeof(u_timezone));
+ formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, s_default_clock_info.timeregion_format, u_timezone, -1, u_best_pattern, -1, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udat_open");
+ return NULL;
+ }
+
+ return formatter;
+}
+
+static void _clock_viewer_default_clock_fallback_set_icu_timezone(void)
+{
+ if (!s_default_clock_info.timezone_id) {
+ _ERR("Invalid timezone");
+ return;
+ }
+
+ UErrorCode ec = U_ZERO_ERROR;
+ UChar *str = uastrcpy(s_default_clock_info.timezone_id);
+ if (str) {
+ ucal_setDefaultTimeZone(str, &ec);
+ if (!U_SUCCESS(ec)) {
+ _ERR("Failed set default timezone[%s]", u_errorName(ec));
+ }
+ free(str);
+ }
+}
+
+static void _clock_viewer_default_clock_fallback_set_formatters(void)
+{
+ s_default_clock_info.generator = _clock_viewer_default_clock_fallback_get_generator();
+ s_default_clock_info.formatter_time = _clock_viewer_default_clock_fallback_get_time_formatter();
+ s_default_clock_info.formatter_ampm = _clock_viewer_default_clock_fallback_get_ampm_formatter();
+ s_default_clock_info.formatter_time_24 = _clock_viewer_default_clock_fallback_get_time_formatter_24();
+ s_default_clock_info.formatter_date = _clock_viewer_default_clock_fallback_get_date_formatter();
+}
+
+static void _clock_viewer_default_clock_fallback_remove_formatters(void)
+{
+ if (s_default_clock_info.generator) {
+ udat_close(s_default_clock_info.generator);
+ s_default_clock_info.generator = NULL;
+ }
+
+ if (s_default_clock_info.formatter_time) {
+ udat_close(s_default_clock_info.formatter_time);
+ s_default_clock_info.formatter_time = NULL;
+ }
+
+ if (s_default_clock_info.formatter_ampm) {
+ udat_close(s_default_clock_info.formatter_ampm);
+ s_default_clock_info.formatter_ampm = NULL;
+ }
+
+ if (s_default_clock_info.formatter_time_24) {
+ udat_close(s_default_clock_info.formatter_time_24);
+ s_default_clock_info.formatter_time_24 = NULL;
+ }
+
+ if (s_default_clock_info.formatter_date) {
+ udat_close(s_default_clock_info.formatter_date);
+ s_default_clock_info.formatter_date = NULL;
+ }
+}
+
+static int _clock_viewer_default_clock_fallback_get_formatted_ampm_from_utc_time(void *data, time_t intime, char *buf, int buf_len, int *ampm_len)
+{
+ UDate u_time = (UDate) intime * 1000;
+ UChar u_formatted_str[64] = { 0, };
+ int32_t u_formatted_str_capacity;
+ int formatted_str_len = -1;
+ UErrorCode status = U_ZERO_ERROR;
+
+ /* calculate formatted string capacity */
+ u_formatted_str_capacity = (int32_t) (sizeof(u_formatted_str) / sizeof((u_formatted_str)[0]));
+
+ /* fomatting date using formatter */
+ formatted_str_len = udat_format(s_default_clock_info.formatter_ampm, u_time, u_formatted_str, u_formatted_str_capacity, NULL, &status);
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udat_format");
+ return -1;
+ }
+
+ if (formatted_str_len <= 0) {
+ _ERR("formatted_str_len is less than 0");
+ }
+
+ (*ampm_len) = u_strlen(u_formatted_str);
+
+ buf = u_austrncpy(buf, u_formatted_str, buf_len);
+ _SDBG("ampm[%d][%s][%d]", formatted_str_len, buf, intime);
+
+ return 0;
+}
+
+static int _clock_viewer_default_clock_fallback_get_formatted_time_from_utc_time(void *data, time_t intime, char *buf, int buf_len, Eina_Bool is_time_24)
+{
+ UDate u_time = (UDate) intime * 1000;
+ UChar u_formatted_str[64] = { 0, };
+ int32_t u_formatted_str_capacity;
+ int formatted_str_len = -1;
+ UErrorCode status = U_ZERO_ERROR;
+
+ /* calculate formatted string capacity */
+ u_formatted_str_capacity = (int32_t) (sizeof(u_formatted_str) / sizeof((u_formatted_str)[0]));
+
+ /* fomatting date using formatter */
+ if (is_time_24) {
+ formatted_str_len = udat_format(s_default_clock_info.formatter_time_24, u_time, u_formatted_str, u_formatted_str_capacity, NULL, &status);
+ } else {
+ formatted_str_len = udat_format(s_default_clock_info.formatter_time, u_time, u_formatted_str, u_formatted_str_capacity, NULL, &status);
+ }
+
+ if (U_FAILURE(status)) {
+ _ERR("Failed to udat_format");
+ return -1;
+ }
+
+ if (formatted_str_len <= 0) {
+ _ERR("formatted_str_len is less than 0");
+ }
+
+ buf = u_austrncpy(buf, u_formatted_str, buf_len);
+ _SDBG("time[%d][%s][%d]", formatted_str_len, buf, intime);
+
+ return 0;
+}
+
+static void _clock_viewer_default_clock_fallback_set_view_state(void)
+{
+ if (++s_default_clock_info.view_state > MAX_VIEW_STATE) {
+ s_default_clock_info.view_state = 0;
+ }
+}
+
+static int _clock_viewer_default_clock_fallback_set_info_time()
+{
+ struct tm ts;
+ struct tm *ret_tm = NULL;
+ time_t tt;
+
+ tt = time(NULL);
+ ret_tm = localtime_r(&tt, &ts);
+
+ if (!ret_tm) {
+ _ERR("Failed to get the local time");
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ // display position position
+ if (!s_default_clock_info.clock_layout) {
+ s_default_clock_info.clock_layout = clock_viewer_util_winset_create_layout(s_default_clock_info.position_layout, EDJ_APP, "layout_clock_tb");
+ if (!s_default_clock_info.clock_layout) {
+ _ERR("Failed to create clock layout");
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ if (s_default_clock_info.position_layout) {
+ elm_object_part_content_set(s_default_clock_info.position_layout, "elm.swallow.body", s_default_clock_info.clock_layout);
+ }
+ }
+
+ if (s_default_clock_info.view_state == 1) {
+ edje_object_signal_emit(elm_layout_edje_get(s_default_clock_info.position_layout), "elm.swallow.body.default", "elm.swallow.body");
+ } else if (s_default_clock_info.view_state == 2) {
+ edje_object_signal_emit(elm_layout_edje_get(s_default_clock_info.position_layout), "elm.swallow.body.middle1", "elm.swallow.body");
+ } else if (s_default_clock_info.view_state == 3) {
+ edje_object_signal_emit(elm_layout_edje_get(s_default_clock_info.position_layout), "elm.swallow.body.middle2", "elm.swallow.body");
+ } else if (s_default_clock_info.view_state == 4) {
+ edje_object_signal_emit(elm_layout_edje_get(s_default_clock_info.position_layout), "elm.swallow.body.middle3", "elm.swallow.body");
+ } else if (s_default_clock_info.view_state == 5) {
+ edje_object_signal_emit(elm_layout_edje_get(s_default_clock_info.position_layout), "elm.swallow.body.middle4", "elm.swallow.body");
+ } else if (s_default_clock_info.view_state == 6) {
+ edje_object_signal_emit(elm_layout_edje_get(s_default_clock_info.position_layout), "elm.swallow.body.middle5", "elm.swallow.body");
+ } else if (s_default_clock_info.view_state == 7) {
+ edje_object_signal_emit(elm_layout_edje_get(s_default_clock_info.position_layout), "elm.swallow.body.middle6", "elm.swallow.body");
+ } else if (s_default_clock_info.view_state == 8) {
+ edje_object_signal_emit(elm_layout_edje_get(s_default_clock_info.position_layout), "elm.swallow.body.middle7", "elm.swallow.body");
+ } else {
+ edje_object_signal_emit(elm_layout_edje_get(s_default_clock_info.position_layout), "elm.swallow.body.bottom", "elm.swallow.body");
+ }
+
+ edje_object_message_signal_process(elm_layout_edje_get(s_default_clock_info.position_layout));
+
+ char utc_time[256] = { 0 };
+ char utc_ampm[256] = { 0 };
+ int ampm_length = 0;
+ Eina_Bool is_24hour = EINA_FALSE;
+
+ if (s_default_clock_info.timeformat == VCONFKEY_TIME_FORMAT_12) {
+ _clock_viewer_default_clock_fallback_get_formatted_ampm_from_utc_time(NULL, tt, utc_ampm, sizeof(utc_ampm), &m_length);
+ _clock_viewer_default_clock_fallback_get_formatted_time_from_utc_time(NULL, tt, utc_time, sizeof(utc_time), EINA_FALSE);
+ is_24hour = EINA_FALSE;
+ } else {
+ _clock_viewer_default_clock_fallback_get_formatted_time_from_utc_time(NULL, tt, utc_time, sizeof(utc_time), EINA_TRUE);
+ is_24hour = EINA_TRUE;
+ }
+
+ _DBG("utc_time=%s, utc_ampm=[%d]%s", utc_time, ampm_length, utc_ampm);
+
+ if (ampm_length >= 3) {
+ _DBG("AM PM string is too long, changed to default AM/PM");
+
+ if (strncmp(s_default_clock_info.timeregion_format, "fa", 2) == 0) {
+ _DBG("In Farsi, AM/PM text abbreviated.");
+
+ if (ts.tm_hour >= 0 && ts.tm_hour < 12) {
+ snprintf(utc_ampm, sizeof(utc_ampm), "%s", "ق.ظ");
+ } else {
+ snprintf(utc_ampm, sizeof(utc_ampm), "%s", "ب.ظ");
+ }
+ } else {
+ if (ts.tm_hour >= 0 && ts.tm_hour < 12)
+ snprintf(utc_ampm, sizeof(utc_ampm), "%s", "AM");
+ else
+ snprintf(utc_ampm, sizeof(utc_ampm), "%s", "PM");
+ }
+ }
+
+ char *time_str = NULL;
+
+ if (is_24hour == EINA_TRUE) {
+ time_str = g_strdup_printf("%s", utc_time);
+ } else {
+ if (s_default_clock_info.is_pre == EINA_TRUE) {
+ time_str = g_strdup_printf("<font_size=24><font=SamsungSans:style=Regular>%s</font></font_size>%s", utc_ampm, utc_time);
+ } else {
+ time_str = g_strdup_printf("%s<font_size=24><font=SamsungSans:style=Regular> %s</font></font_size>", utc_time, utc_ampm);
+ }
+ }
+
+ _DBG("View state[%d] time[%s]", s_default_clock_info.view_state, time_str);
+
+ elm_object_part_text_set(s_default_clock_info.clock_layout, "text.clock", time_str);
+
+ g_free(time_str);
+
+ return CLOCK_VIEWER_SUCCESS;
+}
+
+HAPI int clock_viewer_default_clock_fallback_init(void *data, Evas_Object *parent)
+{
+ if (!parent) {
+ _ERR("invalid parent");
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ s_default_clock_info.parent = parent;
+
+ // create bg
+ if (!s_default_clock_info.bg) {
+ s_default_clock_info.bg = clock_viewer_util_winset_create_bg(parent);
+ if (!s_default_clock_info.bg) {
+ _ERR("Failed to create clock bg");
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ elm_win_resize_object_add(parent, s_default_clock_info.bg);
+ } else {
+ _DBG("default clock bg is already created");
+ }
+
+ // create position layout
+ if (!s_default_clock_info.position_layout) {
+ s_default_clock_info.position_layout = clock_viewer_util_winset_create_layout(s_default_clock_info.bg, EDJ_APP, "layout_clock_position");
+ if (!s_default_clock_info.position_layout) {
+ _ERR("Failed to create clock position layout");
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ evas_object_size_hint_weight_set(s_default_clock_info.position_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_object_content_set(s_default_clock_info.bg, s_default_clock_info.position_layout);
+ evas_object_show(s_default_clock_info.position_layout);
+ } else {
+ _DBG("default clock layout is already created");
+ }
+
+ // TODO: need to notify these?
+ vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &s_default_clock_info.timeformat);
+ s_default_clock_info.timeregion_format = _clock_viewer_default_clock_fallback_get_locale();
+ s_default_clock_info.timezone_id = _clock_viewer_default_clock_fallback_get_timezone();
+
+ _DBG("[%d][%s][%s]", s_default_clock_info.timeformat, s_default_clock_info.timeregion_format, s_default_clock_info.timezone_id);
+
+ _clock_viewer_default_clock_fallback_set_icu_timezone();
+
+ _clock_viewer_default_clock_fallback_remove_formatters();
+ _clock_viewer_default_clock_fallback_set_formatters();
+
+ return CLOCK_VIEWER_SUCCESS;
+}
+
+HAPI int clock_viewer_default_clock_fallback_fini(void *data)
+{
+ if (s_default_clock_info.timeregion_format) {
+ free(s_default_clock_info.timeregion_format);
+ }
+
+ if (s_default_clock_info.timezone_id) {
+ free(s_default_clock_info.timezone_id);
+ }
+
+ _clock_viewer_default_clock_fallback_remove_formatters();
+
+ if (s_default_clock_info.clock_layout) {
+ evas_object_del(s_default_clock_info.clock_layout);
+ s_default_clock_info.clock_layout = NULL;
+ }
+
+ if (s_default_clock_info.position_layout) {
+ if (s_default_clock_info.bg) {
+ Evas_Object *content = elm_object_content_get(s_default_clock_info.bg);
+ if (content && content == s_default_clock_info.position_layout) {
+ elm_object_content_unset(s_default_clock_info.bg);
+ }
+ }
+
+ evas_object_del(s_default_clock_info.position_layout);
+ s_default_clock_info.position_layout = NULL;
+ }
+
+ if (s_default_clock_info.bg) {
+ if (s_default_clock_info.parent) {
+ elm_win_resize_object_del(s_default_clock_info.parent, s_default_clock_info.bg);
+ }
+ evas_object_del(s_default_clock_info.bg);
+ s_default_clock_info.bg = NULL;
+ }
+
+ s_default_clock_info.parent = NULL;
+
+ return CLOCK_VIEWER_SUCCESS;
+}
+
+HAPI int clock_viewer_default_clock_fallback_update(void *data)
+{
+ _clock_viewer_default_clock_fallback_set_view_state();
+
+ return _clock_viewer_default_clock_fallback_set_info_time();
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <time.h>
+#include <vconf.h>
+
+#include "clock-viewer-default-clock.h"
+#include "clock-viewer-default-clock-fallback.h"
+#include "clock-viewer-plugin.h"
+#include "clock-viewer-util-alarm.h"
+
+static struct _default_clock_info {
+ Evas_Object *parent;
+
+ int is_fallback;
+ int is_alarm_init;
+ alarm_id_t alarm_id;
+
+ int is_event_registered;
+} s_default_clock_info = {
+ .parent = NULL,
+
+ .is_fallback = 0,
+ .is_alarm_init = 0,
+ .alarm_id = 0,
+
+ .is_event_registered = 0,
+};
+
+static int __clock_viewer_default_clock_alarm_cb(alarm_id_t alarm_id, void *user_param)
+{
+ int ret = 0;
+ _DBG("Alarm timer expired");
+
+ if (s_default_clock_info.is_fallback) {
+ ret = clock_viewer_default_clock_fallback_update(user_param);
+ if (!ret) {
+ _ERR("Failed to update fallback");
+ }
+ } else {
+ ret = clock_viewer_plugin_update(user_param);
+ if (!ret) {
+ _ERR("Failed to update plugin");
+ }
+ }
+
+ return 1;
+}
+
+static void __clock_viewer_default_clock_time_format_changed_cb(keynode_t *node, void *data)
+{
+ int ret = 0;
+ _DBG("time format changed");
+
+ if (!s_default_clock_info.is_fallback) {
+ ret = clock_viewer_plugin_locale_update(data);
+ if (!ret) {
+ _ERR("Failed to locale update plugin");
+ }
+ ret = clock_viewer_plugin_update(data);
+ if (!ret) {
+ _ERR("Failed to update plugin");
+ }
+ }
+}
+
+HAPI int clock_viewer_default_clock_init(void *data, Evas_Object *parent, clock_viewer_ambient_type ambient_type)
+{
+ int ret = 0;
+
+ // display default clock
+ ret = clock_viewer_plugin_init(data, parent, ambient_type);
+ if (ret) {
+ _DBG("Success to load plugin");
+ s_default_clock_info.is_fallback = 0;
+ } else {
+ _DBG("Failed to load plugin. Go fallback");
+ ret = clock_viewer_default_clock_fallback_init(data, parent);
+ if (ret) {
+ s_default_clock_info.is_fallback = 1;
+ } else {
+ _ERR("Failed to load fallback");
+ return CLOCK_VIEWER_FAIL;
+ }
+ }
+
+ // init alarm manager
+ if (!s_default_clock_info.is_alarm_init) {
+ ret = clock_viewer_util_alarm_init();
+ if (ret != CLOCK_VIEWER_SUCCESS) {
+ _ERR("Failed to init alarm[%d]", ret);
+ s_default_clock_info.is_alarm_init = 0;
+ } else {
+ s_default_clock_info.is_alarm_init = 1;
+ }
+ } else {
+ _DBG("Alarm is already initialized");
+ }
+
+ // register locale changed event
+ if (!s_default_clock_info.is_event_registered) {
+ ret = vconf_notify_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, __clock_viewer_default_clock_time_format_changed_cb, data);
+ if (ret != 0) {
+ _ERR("Failed to notify system time changed event[%d]", ret);
+ }
+ ret = vconf_notify_key_changed(VCONFKEY_REGIONFORMAT_TIME1224, __clock_viewer_default_clock_time_format_changed_cb, data);
+ if (ret != 0) {
+ _ERR("Failed to notify region format time1224 event[%d]", ret);
+ }
+ s_default_clock_info.is_event_registered = 1;
+ }
+
+ return CLOCK_VIEWER_SUCCESS;
+}
+
+HAPI int clock_viewer_default_clock_fini(void *data)
+{
+ int ret = 0;
+
+ if (s_default_clock_info.is_event_registered) {
+ ret = vconf_ignore_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, __clock_viewer_default_clock_time_format_changed_cb);
+ if (ret != 0) {
+ _ERR("Failed to ignore system time changed event[%d]", ret);
+ }
+ ret = vconf_ignore_key_changed(VCONFKEY_REGIONFORMAT_TIME1224, __clock_viewer_default_clock_time_format_changed_cb);
+ if (ret != 0) {
+ _ERR("Failed to ignore region format time1224 event[%d]", ret);
+ }
+ s_default_clock_info.is_event_registered = 0;
+ }
+
+ // delete default clock
+ if (s_default_clock_info.is_fallback) {
+ ret = clock_viewer_default_clock_fallback_fini(data);
+ if (!ret) {
+ _ERR("Failed to finalize fallback");
+ }
+ } else {
+ ret = clock_viewer_plugin_fini(data);
+ if (!ret) {
+ _ERR("Failed to finalize plugin");
+ }
+ }
+
+ s_default_clock_info.is_fallback = 0;
+
+ // remove remain alarm
+ if (s_default_clock_info.alarm_id) {
+ _DBG("Delete alarm id[%d] by terminate", s_default_clock_info.alarm_id);
+ clock_viewer_util_alarm_remove(s_default_clock_info.alarm_id);
+ s_default_clock_info.alarm_id = 0;
+ }
+
+ // fini alarm manager
+ if (s_default_clock_info.is_alarm_init) {
+ clock_viewer_util_alarm_fini();
+ s_default_clock_info.is_alarm_init = 0;
+ }
+
+ return CLOCK_VIEWER_SUCCESS;
+}
+
+HAPI int clock_viewer_default_clock_pause(void *data)
+{
+ if (s_default_clock_info.alarm_id) {
+ _DBG("Delete alarm id[%d] by pause", s_default_clock_info.alarm_id);
+ clock_viewer_util_alarm_remove(s_default_clock_info.alarm_id);
+ s_default_clock_info.alarm_id = 0;
+ }
+
+ return CLOCK_VIEWER_SUCCESS;
+}
+
+HAPI int clock_viewer_default_clock_resume(void *data)
+{
+ int ret = 0;
+ struct tm ts;
+ struct tm *ret_tm = NULL;
+ time_t tt;
+
+ tt = time(NULL);
+ ret_tm = localtime_r(&tt, &ts);
+
+ if (!ret_tm) {
+ _ERR("Failed to get the local time");
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ time_t start = 60 - ts.tm_sec;
+ time_t interval = 60;
+
+ if (s_default_clock_info.alarm_id) {
+ _DBG("Delete alarm id[%d] by resume", s_default_clock_info.alarm_id);
+ clock_viewer_util_alarm_remove(s_default_clock_info.alarm_id);
+ s_default_clock_info.alarm_id = 0;
+ }
+
+ _DBG("Add alarm start[%d], interval[%d]", start, interval);
+
+ s_default_clock_info.alarm_id = clock_viewer_util_alarm_add(start, interval, __clock_viewer_default_clock_alarm_cb, data);
+ if (s_default_clock_info.alarm_id == 0) {
+ _ERR("Failed to add alarm[%d]", ret);
+ }
+
+ if (s_default_clock_info.is_fallback) {
+ ret = clock_viewer_default_clock_fallback_update(data);
+ if (!ret) {
+ _ERR("Failed to update fallback");
+ }
+ } else {
+ ret = clock_viewer_plugin_update(data);
+ if (!ret) {
+ _ERR("Failed to update plugin");
+ }
+ }
+
+ return CLOCK_VIEWER_SUCCESS;
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 "clock-viewer.h"
+#include "clock-viewer-display.h"
+
+static struct _display_info {
+ int mode;
+} s_display_info = {
+ .mode = CLOCK_VIEWER_DISPLAY_MODE_NONE,
+};
+
+static void _clock_viewer_display_resume_dpms_mode()
+{
+ /**
+ * @TODO Set DPMS Mode to Standby
+ */
+ LOGE("Change the DPMS Mode to Standby");
+}
+
+static void _clock_viewer_display_pause_dpms_mode()
+{
+ /**
+ * @TODO Set DEPMS Mode to Suspend
+ */
+ LOGE("Change the DPMS Mode to Suspend");
+}
+
+HAPI void clock_viewer_display_set_dpms_mode(int mode)
+{
+ _DBG("Change dpms mode [%d] -> [%d]", s_display_info.mode, mode);
+
+ switch (mode) {
+ case CLOCK_VIEWER_DISPLAY_MODE_NONE:
+ if (s_display_info.mode == CLOCK_VIEWER_DISPLAY_MODE_RESUME) {
+ _clock_viewer_display_pause_dpms_mode();
+ }
+ s_display_info.mode = mode;
+ break;
+ case CLOCK_VIEWER_DISPLAY_MODE_RESUME:
+ if (s_display_info.mode == CLOCK_VIEWER_DISPLAY_MODE_NONE || s_display_info.mode == CLOCK_VIEWER_DISPLAY_MODE_PAUSE) {
+ _clock_viewer_display_resume_dpms_mode();
+ }
+ s_display_info.mode = mode;
+ break;
+ case CLOCK_VIEWER_DISPLAY_MODE_PAUSE:
+ if (s_display_info.mode == CLOCK_VIEWER_DISPLAY_MODE_RESUME) {
+ // it may need to lazy pause
+ _clock_viewer_display_pause_dpms_mode();
+ }
+ s_display_info.mode = mode;
+ break;
+ default:
+ _ERR("invalid mode");
+ break;
+ }
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * 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 <stdio.h>
+
+#include <app.h>
+
+#include "clock-viewer.h"
+
+static bool _app_create(void *data)
+{
+ _DBG("");
+
+ clock_viewer_s *clock_viewer = (clock_viewer_s *) data;
+ if (!clock_viewer) {
+ _ERR("invalid app data");
+ return false;
+ }
+
+ clock_viewer_create(clock_viewer);
+
+ return true;
+}
+
+static void _app_terminate(void *data)
+{
+ _DBG("");
+
+ clock_viewer_s *clock_viewer = (clock_viewer_s *) data;
+ if (!clock_viewer) {
+ _ERR("invalid app data");
+ return;
+ }
+
+ clock_viewer_destroy(clock_viewer);
+ free(clock_viewer);
+}
+
+static void _app_pause(void *data)
+{
+ _DBG("");
+
+ clock_viewer_pause(data);
+}
+
+static void _app_resume(void *data)
+{
+ _DBG("");
+
+ clock_viewer_resume(data);
+}
+
+static void _app_control(app_control_h service, void *data)
+{
+ _DBG("");
+}
+
+int main(int argc, char *argv[])
+{
+ clock_viewer_s *clock_viewer = NULL;
+ clock_viewer = (clock_viewer_s *) malloc(sizeof(clock_viewer_s));
+ if (clock_viewer) {
+ memset(clock_viewer, 0x00, sizeof(clock_viewer_s));
+ } else {
+ _ERR("Failed to create app data");
+ }
+
+ app_event_callback_s event_callback;
+
+ event_callback.create = _app_create;
+ event_callback.terminate = _app_terminate;
+ event_callback.pause = _app_pause;
+ event_callback.resume = _app_resume;
+ event_callback.app_control = _app_control;
+ event_callback.language_changed = NULL;
+ event_callback.low_memory = NULL;
+ event_callback.low_battery = NULL;
+ event_callback.device_orientation = NULL;
+ event_callback.region_format_changed = NULL;
+
+ return app_efl_main(&argc, &argv, &event_callback, clock_viewer);
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <minicontrol-viewer.h>
+#include <minicontrol-monitor.h>
+#include <minicontrol-handler.h>
+
+#include "clock-viewer-feature.h"
+#include "clock-viewer-debug.h"
+#include "clock-viewer-minicontrol.h"
+#include "clock-viewer-util-winset.h"
+
+static struct _minictrl_info {
+ Evas_Object *parent;
+ Evas_Object *bg;
+ Evas_Object *minictrl;
+
+ int is_monitor_start;
+} s_minictrl_info = {
+ .parent = NULL,
+ .bg = NULL,
+ .minictrl = NULL,
+
+ .is_monitor_start = 0,
+};
+
+static void __clock_viewer_minicontrol_monitor_with_handler_cb(minicontrol_action_e action, const char *name, unsigned int width, unsigned int height, minicontrol_priority_e priority, minicontrol_h handler, void *data)
+{
+ Evas_Object *minictrl = NULL;
+ _DBG("action[%d] name[%s], size[%dx%d], priority[%d], handler[%p]", action, name, width, height, priority, handler);
+
+ switch (action) {
+ case MINICONTROL_ACTION_START:
+ if (s_minictrl_info.bg) {
+ s_minictrl_info.minictrl = minicontrol_viewer_add(s_minictrl_info.bg, name);
+
+ minictrl = elm_object_content_unset(s_minictrl_info.bg);
+ if (minictrl && minictrl != s_minictrl_info.bg) {
+ evas_object_del(minictrl);
+ }
+
+ if (s_minictrl_info.minictrl) {
+ elm_object_content_set(s_minictrl_info.bg, s_minictrl_info.minictrl);
+ evas_object_show(s_minictrl_info.minictrl);
+ }
+ }
+ break;
+ case MINICONTROL_ACTION_STOP:
+ break;
+ case MINICONTROL_ACTION_RESIZE:
+ break;
+ case MINICONTROL_ACTION_REQUEST:
+ break;
+ case MINICONTROL_ACTION_REALIZE:
+ break;
+ }
+}
+
+HAPI void clock_viewer_minicontrol_init(void *data, Evas_Object *parent)
+{
+ int ret = 0;
+
+ if (!parent) {
+ _ERR("invalid parent");
+ return;
+ }
+
+ if (s_minictrl_info.is_monitor_start) {
+ _DBG("minictrl clock already started");
+ return;
+ }
+
+ // create bg
+ if (!s_minictrl_info.bg) {
+ s_minictrl_info.bg = clock_viewer_util_winset_create_bg(parent);
+ if (!s_minictrl_info.bg) {
+ _ERR("Failed to create clock bg");
+ return;
+ }
+
+ elm_win_resize_object_add(parent, s_minictrl_info.bg);
+ } else {
+ _DBG("minictrl clock bg is already created");
+ }
+
+ ret = minicontrol_monitor_start_with_handler(__clock_viewer_minicontrol_monitor_with_handler_cb, data);
+ if (ret != MINICONTROL_ERROR_NONE) {
+ _ERR("Failed to start mini control monitor[%d]", ret);
+ }
+
+ s_minictrl_info.is_monitor_start = 1;
+ s_minictrl_info.parent = parent;
+}
+
+HAPI void clock_viewer_minicontrol_fini(void *data)
+{
+ int ret = 0;
+
+ if (s_minictrl_info.is_monitor_start) {
+ ret = minicontrol_monitor_stop();
+ if (ret != MINICONTROL_ERROR_NONE) {
+ _ERR("Failed to stop mini control monitor[%d]", ret);
+ }
+ s_minictrl_info.is_monitor_start = 0;
+ }
+
+ if (s_minictrl_info.minictrl) {
+ evas_object_del(s_minictrl_info.minictrl);
+ s_minictrl_info.minictrl = NULL;
+ }
+
+ if (s_minictrl_info.bg) {
+ if (s_minictrl_info.parent) {
+ elm_win_resize_object_del(s_minictrl_info.parent, s_minictrl_info.bg);
+ }
+ evas_object_del(s_minictrl_info.bg);
+ s_minictrl_info.bg = NULL;
+ }
+
+ s_minictrl_info.parent = NULL;
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h> /* for open */
+
+#include <dlfcn.h> /* for dlopen, dlsym and dlclose */
+
+#include "clock-viewer-plugin.h"
+
+#define CLOCK_VIEWER_PLUGIN_DIGITAL_PATH "/usr/apps/org.tizen.w-clock-viewer/shared/lib/libdigital.so"
+#define CLOCK_VIEWER_PLUGIN_ANALOG_PATH "/usr/apps/org.tizen.w-clock-viewer/shared/lib/libalnalog.so"
+
+static struct _plugin_info {
+ Evas_Object *parent;
+
+ clock_viewer_ambient_type ambient_type;
+
+ void *module_data;
+ alpm_clock_plugin_module_ops ops;
+} s_plugin_info = {
+ .parent = NULL,
+
+ .ambient_type = CLOCK_VIEWER_AMBIENT_TYPE_ANALOG,
+
+ .module_data = NULL,
+ .ops.modules.ui_runtime_plugin_init = NULL,
+ .ops.modules.ui_runtime_plugin_deinit = NULL,
+ .ops.modules.ui_runtime_plugin_update_clock = NULL,
+ .ops.modules.priv = NULL,
+};
+
+HAPI int clock_viewer_plugin_init(void *data, Evas_Object *parent, clock_viewer_ambient_type ambient_type)
+{
+ int (*init)(alpm_clock_plugin_module_ops *ops);
+ int ret = 0;
+
+ if (s_plugin_info.module_data) {
+ _ERR("Previous module is not finalized");
+ ret = clock_viewer_plugin_fini(data);
+ if (!ret) {
+ _ERR("Failed to finalize plugin");
+ }
+ }
+
+ if (ambient_type == CLOCK_VIEWER_AMBIENT_TYPE_MANUAL) {
+ _DBG("invalid ambient type[%d]", ambient_type);
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ s_plugin_info.module_data = dlopen(CLOCK_VIEWER_PLUGIN_ANALOG_PATH, RTLD_LAZY);
+ if (!s_plugin_info.module_data) {
+ _DBG("Failed to load plugin clock[%s]", dlerror());
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ init = dlsym(s_plugin_info.module_data, ALPM_CLOCK_PLUGIN_MODULE_INIT_SYM);
+ if (!init) {
+ _ERR("Failed to dlsym[%s]", dlerror());
+ if (s_plugin_info.module_data) {
+ dlclose(s_plugin_info.module_data);
+ s_plugin_info.module_data = NULL;
+ }
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ if (init(&s_plugin_info.ops) == -1) {
+ _ERR("Failed to init");
+ if (s_plugin_info.module_data) {
+ dlclose(s_plugin_info.module_data);
+ s_plugin_info.module_data = NULL;
+ }
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ if (s_plugin_info.ops.modules.ui_runtime_plugin_init) {
+ s_plugin_info.ops.modules.ui_runtime_plugin_init(&s_plugin_info.ops, parent);
+ }
+
+ s_plugin_info.parent = parent;
+ s_plugin_info.ambient_type = ambient_type;
+
+ return CLOCK_VIEWER_SUCCESS;
+}
+
+HAPI int clock_viewer_plugin_fini(void *data)
+{
+ int (*exit)(alpm_clock_plugin_module_ops *ops);
+
+ if (s_plugin_info.ops.modules.ui_runtime_plugin_deinit) {
+ s_plugin_info.ops.modules.ui_runtime_plugin_deinit(&s_plugin_info.ops, s_plugin_info.parent);
+ }
+
+ if (s_plugin_info.module_data) {
+ exit = dlsym(s_plugin_info.module_data, ALPM_CLOCK_PLUGIN_MODULE_EXIT_SYM);
+ if (!exit || (exit && exit(&s_plugin_info.ops) == -1)) {
+ _ERR("Failed to plugin exit");
+ }
+
+ dlclose(s_plugin_info.module_data);
+ s_plugin_info.module_data = NULL;
+ }
+
+ s_plugin_info.ops.modules.ui_runtime_plugin_init = NULL;
+ s_plugin_info.ops.modules.ui_runtime_plugin_deinit = NULL;
+ s_plugin_info.ops.modules.ui_runtime_plugin_update_clock = NULL;
+ s_plugin_info.ops.modules.priv = NULL;
+
+ s_plugin_info.parent = NULL;
+ s_plugin_info.ambient_type = CLOCK_VIEWER_AMBIENT_TYPE_ANALOG;
+
+ return CLOCK_VIEWER_SUCCESS;
+}
+
+HAPI int clock_viewer_plugin_locale_update(void *data)
+{
+ int (*locale_update)(alpm_clock_plugin_module_ops *ops);
+
+ if (s_plugin_info.module_data) {
+ locale_update = dlsym(s_plugin_info.module_data, ALPM_CLOCK_PLUGIN_MODULE_LOCALE_UPDATE_SYM);
+ if (!locale_update) {
+ _ERR("Failed to dlsym[%s]", dlerror());
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ if (locale_update(&s_plugin_info.ops) == -1) {
+ _ERR("Failed to locale update");
+ return CLOCK_VIEWER_FAIL;
+ }
+
+ return CLOCK_VIEWER_SUCCESS;
+ }
+
+ return CLOCK_VIEWER_FAIL;
+}
+
+HAPI int clock_viewer_plugin_update(void *data)
+{
+ if (s_plugin_info.ops.modules.ui_runtime_plugin_update_clock) {
+ s_plugin_info.ops.modules.ui_runtime_plugin_update_clock(&s_plugin_info.ops, s_plugin_info.parent);
+ return CLOCK_VIEWER_SUCCESS;
+ }
+
+ return CLOCK_VIEWER_FAIL;
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 "clock-viewer.h"
+#include "clock-viewer-util-alarm.h"
+
+static struct _util_alarm_info
+{
+ int ref_count;
+} s_util_alarm_info = {
+ .ref_count = 0,
+};
+
+static int __clock_viewer_util_alarm_ids_cb(alarm_id_t alarm_id, void *user_param)
+{
+ _WARN("Delete alarm id[%d]", alarm_id);
+ clock_viewer_util_alarm_remove(alarm_id);
+
+ return 1;
+}
+
+HAPI int clock_viewer_util_alarm_init(void)
+{
+ int ret = 0;
+
+ if (s_util_alarm_info.ref_count == 0) {
+ ret = alarmmgr_init(PACKAGE);
+ if (ret != ALARMMGR_RESULT_SUCCESS) {
+ _ERR("Failed to init alarm[%d]", ret);
+ return CLOCK_VIEWER_FAIL;
+ } else {
+ s_util_alarm_info.ref_count++;
+ _DBG("Alarm initialized[%d]", s_util_alarm_info.ref_count);
+
+ // when first initialized, remove previous alarms
+ ret = alarmmgr_enum_alarm_ids(__clock_viewer_util_alarm_ids_cb, NULL);
+ if (ret != ALARMMGR_RESULT_SUCCESS) {
+ _ERR("Failed to enum alarm ids[%d]", ret);
+ }
+ }
+ } else {
+ s_util_alarm_info.ref_count++;
+ _DBG("Add alarm reference count[%d]", s_util_alarm_info.ref_count);
+ }
+
+ return CLOCK_VIEWER_SUCCESS;
+}
+
+HAPI void clock_viewer_util_alarm_fini(void)
+{
+ if (s_util_alarm_info.ref_count == 0) {
+ _WARN("Already alarm finalized");
+ } else {
+ _DBG("Delete alarm reference count[%d]", s_util_alarm_info.ref_count);
+ s_util_alarm_info.ref_count--;
+ if (s_util_alarm_info.ref_count == 0) {
+ _DBG("alarm finalized");
+ alarmmgr_fini();
+ }
+ }
+}
+
+HAPI alarm_id_t clock_viewer_util_alarm_add(time_t start, time_t interval, alarm_cb_t func, void *data)
+{
+ alarm_id_t alarm_id = 0;
+ int ret = 0;
+
+ ret = alarmmgr_add_alarm_withcb(ALARM_TYPE_VOLATILE, start, interval, func, data, &alarm_id);
+ if (ret != ALARMMGR_RESULT_SUCCESS) {
+ _ERR("Failed to add alarm[%d]", ret);
+ }
+
+ return alarm_id;
+}
+
+HAPI void clock_viewer_util_alarm_remove(alarm_id_t alarm_id)
+{
+ int ret = 0;
+
+ ret = alarmmgr_remove_alarm(alarm_id);
+ if (ret != ALARMMGR_RESULT_SUCCESS) {
+ _ERR("Failed to remove alarm[%d]", ret);
+ }
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 "clock-viewer.h"
+#include "clock-viewer-util-dbus.h"
+#include <vconf.h>
+
+struct cb_item {
+ E_DBus_Signal_Cb cb;
+ void *data;
+};
+
+static struct info {
+ Eina_List *lcdoff_list;
+ Eina_List *lcdon_list;
+ Eina_List *clockdraw_list;
+} s_info = {
+ .lcdoff_list = NULL,
+ .lcdon_list = NULL,
+ .clockdraw_list = NULL,
+};
+
+static void lcdoff_cb(keynode_t *node, void *user_data)
+{
+ Eina_List *l;
+ struct cb_item *item;
+
+ EINA_LIST_FOREACH(s_info.lcdoff_list, l, item) {
+ LOGD("Invoke lcdoff vcon");
+ item->cb(item->data, NULL);
+ }
+}
+
+static void lcdon_cb(keynode_t *node, void *user_data)
+{
+ Eina_List *l;
+ struct cb_item *item;
+
+ EINA_LIST_FOREACH(s_info.lcdon_list, l, item) {
+ LOGD("Invoke lcdoff vcon");
+ item->cb(item->data, NULL);
+ }
+}
+
+static void clockdraw_cb(keynode_t *node, void *user_data)
+{
+ Eina_List *l;
+ struct cb_item *item;
+
+ EINA_LIST_FOREACH(s_info.clockdraw_list, l, item) {
+ LOGD("Invoke lcdoff vcon");
+ item->cb(item->data, NULL);
+ }
+}
+
+static inline int register_event_callback(Eina_List **list, void (*event_cb)(keynode_t *, void *), const char *key, void *data, E_DBus_Signal_Cb signal)
+{
+ struct cb_item *item;
+
+ item = malloc(sizeof(*item));
+ if (!item) {
+ LOGE("malloc: %s\n", strerror(errno));
+ return -1;
+ }
+
+ item->cb = signal;
+ item->data = data;
+
+ if (!*list) {
+ int ret;
+
+ ret = vconf_notify_key_changed(key, event_cb, NULL);
+ if (ret < 0) {
+ LOGE("Failed to add vconf for lock state: %d\n", ret);
+ }
+ }
+
+ *list = eina_list_append(*list, item);
+ return 0;
+}
+
+static inline int unregister_event_callback(Eina_List **list, void (*event_cb)(keynode_t *, void *), const char *key, void *data)
+{
+ Eina_List *l;
+ Eina_List *n;
+ struct cb_item *item;
+
+ item = NULL;
+ EINA_LIST_FOREACH_SAFE(*list, l, n, item) {
+ if (item->data == data) {
+ break;
+ }
+ item = NULL;
+ }
+
+ if (!item) {
+ /* not found */
+ return -1;
+ }
+
+ *list = eina_list_remove(*list, item);
+ free(item);
+
+ if (!*list) {
+ vconf_ignore_key_changed(key, event_cb);
+ }
+
+ return 0;
+}
+
+HAPI void clock_viewer_util_dbus_broadcast_signal(void *data, char *path, char *interface, char *name, const char *type, char *signal[])
+{
+ LOGD("Broadcast signal path[%s] interface[%s] name[%s] type[%s]\n", path, interface, name, type);
+}
+
+HAPI void clock_viewer_util_dbus_init_lcdoff_signal(void *data, E_DBus_Signal_Cb cb_signal)
+{
+ register_event_callback(&s_info.lcdoff_list, lcdoff_cb, "memory/clock_viewer/lcdoff", data, cb_signal);
+}
+
+HAPI void clock_viewer_util_dbus_fini_lcdoff_signal(void *data)
+{
+ unregister_event_callback(&s_info.lcdoff_list, lcdoff_cb, "memory/clock_viewer/lcdoff", data);
+}
+
+HAPI void clock_viewer_util_dbus_init_lcdon_signal(void *data, E_DBus_Signal_Cb cb_signal)
+{
+ register_event_callback(&s_info.lcdon_list, lcdon_cb, "memory/clock_viewer/lcdon", data, cb_signal);
+}
+
+HAPI void clock_viewer_util_dbus_fini_lcdon_signal(void *data)
+{
+ unregister_event_callback(&s_info.lcdon_list, lcdon_cb, "memory/clock_viewer/lcdon", data);
+}
+
+HAPI void clock_viewer_util_dbus_init_clockdraw_signal(void *data, E_DBus_Signal_Cb cb_signal)
+{
+ register_event_callback(&s_info.clockdraw_list, clockdraw_cb, "memory/clock_viewer/clockdraw", data, cb_signal);
+}
+
+HAPI void clock_viewer_util_dbus_fini_clockdraw_signal(void *data)
+{
+ unregister_event_callback(&s_info.clockdraw_list, clockdraw_cb, "memory/clock_viewer/clockdraw", data);
+}
+
+HAPI int clock_viewer_util_dbus_message_is_signal(DBusMessage *msg, const char *interface, const char *signal)
+{
+ if (!strcmp(interface, DEVICED_DISPLAY_INTERFACE)) {
+ if (!strcmp(signal, LCDON_SIGNAL_NAME)) {
+ int lcdon;
+
+ if (vconf_get_int("memory/clock_viewer/lcdon", &lcdon) < 0) {
+ LOGE("Failed to get lcdon status");
+ lcdon = 0;
+ }
+
+ return lcdon;
+ } else if (!strcmp(signal, LCDOFF_SIGNAL_NAME)) {
+ int lcdoff;
+
+ if (vconf_get_int("memory/clock_viewer/lcdoff", &lcdoff) < 0) {
+ LOGE("Failed to get lcdoff status");
+ lcdoff = 0;
+ }
+
+ return lcdoff;
+ }
+ }
+
+ return 0;
+}
+
+/* End of a file */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 "clock-viewer.h"
+#include "clock-viewer-util-dbus.h"
+
+static struct _dbus_info
+{
+ DBusConnection *dbus_conn;
+ E_DBus_Connection *e_dbus_conn;
+
+ E_DBus_Signal_Handler *dbus_lcdon_signal_handler;
+ E_DBus_Signal_Handler *dbus_lcdoff_signal_handler;
+ E_DBus_Signal_Handler *dbus_clockdraw_signal_handler;
+} s_dbus_info = {
+ .dbus_conn = NULL,
+ .e_dbus_conn = NULL,
+
+ .dbus_lcdon_signal_handler = NULL,
+ .dbus_lcdoff_signal_handler = NULL,
+ .dbus_clockdraw_signal_handler = NULL,
+};
+
+static int _clock_viewer_util_dbus_append_variant(DBusMessageIter *iter, const char *sig, char *param[])
+{
+ char *ch;
+ int i;
+ int int_type;
+ uint64_t int64_type;
+
+ if (!sig || !param) {
+ return 0;
+ }
+
+ for (ch = (char*) sig, i = 0; *ch != '\0'; ++i, ++ch) {
+ switch (*ch) {
+ case 'i':
+ int_type = atoi(param[i]);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &int_type);
+ break;
+ case 'u':
+ int_type = strtoul(param[i], NULL, 10);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &int_type);
+ break;
+ case 't':
+ int64_type = atoll(param[i]);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT64, &int64_type);
+ break;
+ case 's':
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, ¶m[i]);
+ break;
+ default:
+ return -EINVAL;
+
+ }
+ }
+
+ return 0;
+}
+
+HAPI void clock_viewer_util_dbus_broadcast_signal(void *data, char *path, char *interface, char *name, const char *type, char *signal[])
+{
+ DBusMessage *msg;
+ DBusMessageIter iter;
+ int r;
+
+ msg = dbus_message_new_signal(path, interface, name);
+ if (!msg) {
+ _ERR("Failed to new signal");
+ return;
+ }
+
+ dbus_message_iter_init_append(msg, &iter);
+ r = _clock_viewer_util_dbus_append_variant(&iter, type, signal);
+ if (r < 0) {
+ _ERR("Failed to append variant[%d]", r);
+ return;
+ }
+
+ if (s_dbus_info.dbus_conn == NULL) {
+ s_dbus_info.dbus_conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
+ if (s_dbus_info.dbus_conn == NULL) {
+ _ERR("Failed to get bus");
+ return;
+ }
+ }
+
+ r = dbus_connection_send(s_dbus_info.dbus_conn, msg, NULL);
+ if (!r) {
+ _ERR("Failed to send message[%s][%s][%s]", path, interface, name);
+ return;
+ }
+
+ dbus_message_unref(msg);
+}
+
+HAPI void clock_viewer_util_dbus_init_lcdoff_signal(void *data, E_DBus_Signal_Cb cb_signal)
+{
+ if (s_dbus_info.e_dbus_conn == NULL) {
+ e_dbus_init();
+
+ s_dbus_info.e_dbus_conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
+ if (s_dbus_info.e_dbus_conn == NULL) {
+ _ERR("Failed to get e dbus");
+ return;
+ }
+ }
+
+ s_dbus_info.dbus_lcdoff_signal_handler = e_dbus_signal_handler_add(s_dbus_info.e_dbus_conn, NULL, DEVICED_DISPLAY_PATH, DEVICED_DISPLAY_INTERFACE, LCDOFF_SIGNAL_NAME, cb_signal, data);
+
+ if (s_dbus_info.dbus_lcdoff_signal_handler == NULL) {
+ _ERR("Failed to add lcd off signal");
+ }
+}
+
+HAPI void clock_viewer_util_dbus_fini_lcdoff_signal(void *data)
+{
+ if (s_dbus_info.e_dbus_conn && s_dbus_info.dbus_lcdoff_signal_handler) {
+ e_dbus_signal_handler_del(s_dbus_info.e_dbus_conn, s_dbus_info.dbus_lcdoff_signal_handler);
+ s_dbus_info.dbus_lcdoff_signal_handler = NULL;
+ }
+}
+
+HAPI void clock_viewer_util_dbus_init_lcdon_signal(void *data, E_DBus_Signal_Cb cb_signal)
+{
+ if (s_dbus_info.e_dbus_conn == NULL) {
+ e_dbus_init();
+
+ s_dbus_info.e_dbus_conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
+ if (s_dbus_info.e_dbus_conn == NULL) {
+ _ERR("Failed to get e dbus");
+ return;
+ }
+ }
+
+ s_dbus_info.dbus_lcdon_signal_handler = e_dbus_signal_handler_add(s_dbus_info.e_dbus_conn, NULL, DEVICED_DISPLAY_PATH, DEVICED_DISPLAY_INTERFACE, LCDON_SIGNAL_NAME, cb_signal, data);
+
+ if (s_dbus_info.dbus_lcdon_signal_handler == NULL) {
+ _ERR("Failed to add lcd on signal");
+ }
+}
+
+HAPI void clock_viewer_util_dbus_fini_lcdon_signal(void *data)
+{
+ if (s_dbus_info.e_dbus_conn && s_dbus_info.dbus_lcdon_signal_handler) {
+ e_dbus_signal_handler_del(s_dbus_info.e_dbus_conn, s_dbus_info.dbus_lcdon_signal_handler);
+ s_dbus_info.dbus_lcdon_signal_handler = NULL;
+ }
+}
+
+HAPI void clock_viewer_util_dbus_init_clockdraw_signal(void *data, E_DBus_Signal_Cb cb_signal)
+{
+ if (s_dbus_info.e_dbus_conn == NULL) {
+ e_dbus_init();
+
+ s_dbus_info.e_dbus_conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
+ if (s_dbus_info.e_dbus_conn == NULL) {
+ _ERR("Failed to get e dbus");
+ return;
+ }
+ }
+
+ s_dbus_info.dbus_clockdraw_signal_handler = e_dbus_signal_handler_add(s_dbus_info.e_dbus_conn, NULL, CLOCKDRAW_PATH, CLOCKDRAW_INTERFACE, CLOCKDRAW_NAME, cb_signal, data);
+
+ if (s_dbus_info.dbus_clockdraw_signal_handler == NULL) {
+ _ERR("Failed to add clockdraw signal");
+ }
+}
+
+HAPI void clock_viewer_util_dbus_fini_clockdraw_signal(void *data)
+{
+ if (s_dbus_info.e_dbus_conn && s_dbus_info.dbus_clockdraw_signal_handler) {
+ e_dbus_signal_handler_del(s_dbus_info.e_dbus_conn, s_dbus_info.dbus_clockdraw_signal_handler);
+ s_dbus_info.dbus_clockdraw_signal_handler = NULL;
+ }
+}
+
+HAPI int clock_viewer_util_dbus_message_is_signal(DBusMessage *msg, const char *interface, const char *signal)
+{
+ return dbus_message_is_signal(msg, interface, signal);
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <pkgmgr-info.h>
+#include <widget_service.h>
+#include <widget_service_internal.h>
+
+#include "clock-viewer-util-pkginfo.h"
+
+HAPI void clock_viewer_util_pkginfo_init_clock_package_event(void *data, vconf_callback_fn cb)
+{
+ int ret = 0;
+
+ ret = vconf_notify_key_changed(VCONFKEY_WMS_CLOCKS_SET_IDLE, cb, data);
+ if (ret != 0) {
+ _ERR("Failed to notify clock set");
+ }
+}
+
+HAPI void clock_viewer_util_pkginfo_fini_clock_package_event(vconf_callback_fn cb)
+{
+ int ret = 0;
+
+ ret = vconf_ignore_key_changed(VCONFKEY_WMS_CLOCKS_SET_IDLE, cb);
+ if (ret != 0) {
+ _ERR("Failed to ignore clock set");
+ }
+}
+
+HAPI char *clock_viewer_util_pkginfo_get_clock_package(void)
+{
+ return vconf_get_str(VCONFKEY_WMS_CLOCKS_SET_IDLE);
+}
+
+static inline char *pkgmgr_get_mainapp(const char *pkgid)
+{
+ pkgmgrinfo_pkginfo_h handle;
+ char *ret;
+
+ if (pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle) != PMINFO_R_OK) {
+ _ERR("Unable to get mainapp: %s\n", pkgid);
+ return NULL;
+ }
+
+ ret = NULL;
+ if (pkgmgrinfo_pkginfo_get_mainappid(handle, &ret) == PMINFO_R_OK) {
+ if (ret) {
+ ret = strdup(ret);
+ if (!ret) {
+ _ERR("strdup: %d\n", errno);
+ }
+ }
+ } else {
+ _ERR("Failed to get mainappid\n");
+ ret = NULL; /* I cannot believe the pkgmgrinfo_pkginfo_get_mainappid. it maybe able to touch my "ret" even though it fails */
+ }
+
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ return ret;
+}
+
+HAPI clock_viewer_ambient_type clock_viewer_util_pkginfo_get_ambient_type(char *pkgid)
+{
+ int ret;
+ pkgmgrinfo_appinfo_h handle = NULL;
+ bool ambient_mode = false;
+ char *appid;
+
+ appid = pkgmgr_get_mainapp(pkgid);
+ if (!appid) {
+ _ERR("Failed to get appid. try to use the pkgid again\n");
+ appid = strdup(pkgid);
+ if (!appid) {
+ _ERR("strdup: %d\n", errno);
+ return CLOCK_VIEWER_AMBIENT_TYPE_ANALOG;
+ }
+ }
+
+ _DBG("App: %s\n", appid);
+ ret = pkgmgrinfo_appinfo_get_appinfo(appid, &handle);
+ free(appid);
+ if (ret != PMINFO_R_OK || handle == NULL) {
+ return CLOCK_VIEWER_AMBIENT_TYPE_ANALOG;
+ }
+
+ ret = pkgmgrinfo_appinfo_get_ambient_support(handle, &ambient_mode);
+ pkgmgrinfo_appinfo_destroy_appinfo(handle);
+ if (ret != PMINFO_R_OK) {
+ return CLOCK_VIEWER_AMBIENT_TYPE_ANALOG;
+ }
+
+ _DBG("ambient mode[%s]", ambient_mode ? "manual" : "analog");
+
+ return ambient_mode ? CLOCK_VIEWER_AMBIENT_TYPE_MANUAL : CLOCK_VIEWER_AMBIENT_TYPE_ANALOG;
+}
+
+HAPI int clock_viewer_util_pkginfo_is_widget(char *appid)
+{
+ int is_widget = 0;
+ char *widget_id = NULL;
+
+ widget_id = widget_service_get_widget_id(appid);
+ if (widget_id != NULL) {
+ char *category = NULL;
+ category = widget_service_get_category(widget_id);
+
+ if (category != NULL) {
+ if (!strcmp(category, CLOCK_VIEWER_TIZEN_CLOCK_CATEGORY)) {
+ is_widget = 1;
+ }
+ free(category);
+ }
+ free(widget_id);
+ }
+
+ return is_widget;
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <vconf.h>
+
+#include "clock-viewer.h"
+#include "clock-viewer-util-status.h"
+
+#define CLOCK_VIEWER_UTIL_STATUS_VCONFKEY_RESERVED_APPS_STATUS "memory/starter/reserved_apps_status"
+
+static struct _util_status_info
+{
+ int reserved_apps_status;
+} s_util_status_info = {
+ .reserved_apps_status = 0,
+};
+
+static void __clock_viewer_util_status_reserved_apps_status_changed_cb(keynode_t *node, void *data)
+{
+ int ret = 0;
+ int value = 0;
+
+ ret = vconf_get_int(CLOCK_VIEWER_UTIL_STATUS_VCONFKEY_RESERVED_APPS_STATUS, &value);
+ if (ret != 0) {
+ _ERR("Failed to get reserved apps status[%d]", ret);
+ s_util_status_info.reserved_apps_status = 0;
+ } else {
+ _DBG("Reserved apps status[%d]", value);
+ s_util_status_info.reserved_apps_status = value;
+ }
+}
+
+HAPI void clock_viewer_util_status_init(void)
+{
+ int ret = 0;
+
+ // reserved apps status
+ ret = vconf_notify_key_changed(CLOCK_VIEWER_UTIL_STATUS_VCONFKEY_RESERVED_APPS_STATUS, __clock_viewer_util_status_reserved_apps_status_changed_cb, NULL);
+ if (ret != 0) {
+ _ERR("Failed to notify reserved apps status changed event[%d]", ret);
+ }
+ __clock_viewer_util_status_reserved_apps_status_changed_cb(NULL, NULL);
+}
+
+HAPI void clock_viewer_util_status_fini(void)
+{
+ int ret = 0;
+
+ // reserved apps status
+ ret = vconf_ignore_key_changed(CLOCK_VIEWER_UTIL_STATUS_VCONFKEY_RESERVED_APPS_STATUS, __clock_viewer_util_status_reserved_apps_status_changed_cb);
+ if (ret != 0) {
+ _ERR("Failed to ignore reserved apps status changed event[%d]", ret);
+ }
+}
+
+HAPI int clock_viewer_util_status_get_reserved_apps_status(void)
+{
+ return s_util_status_info.reserved_apps_status;
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 "clock-viewer-util-winset.h"
+
+HAPI Evas_Object *clock_viewer_util_winset_create_bg(Evas_Object *parent)
+{
+ Evas_Object *bg = NULL;
+
+ if (!parent) {
+ _ERR("Invalid parent");
+ return NULL;
+ }
+
+ bg = elm_bg_add(parent);
+ if (!bg) {
+ _ERR("Failed to create bg");
+ return NULL;
+ }
+
+ elm_bg_color_set(bg, 0, 0, 0);
+
+ evas_object_show(bg);
+
+ return bg;
+}
+
+HAPI Evas_Object *clock_viewer_util_winset_create_layout(Evas_Object *parent, const char *file, const char *group)
+{
+ Evas_Object *layout = NULL;
+ int ret = 0;
+
+ if (!parent) {
+ _ERR("Invalid parent");
+ return NULL;
+ }
+
+ layout = elm_layout_add(parent);
+ if (!layout) {
+ _ERR("Failed to add layout");
+ return NULL;
+ }
+
+ ret = elm_layout_file_set(layout, file, group);
+ if (!ret) {
+ _ERR("Failed to set file[%s], group[%s]", file, group);
+ evas_object_del(layout);
+ return NULL;
+ }
+
+ evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_show(layout);
+
+ return layout;
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <Elementary.h>
+#include <widget_service.h>
+#include <widget_service_internal.h>
+#include <widget_viewer_evas.h>
+#include <widget_viewer_evas_internal.h>
+
+#include "clock-viewer-widget.h"
+#include "clock-viewer-util-winset.h"
+
+#define EDJ_APP EDJEDIR"/clock-viewer.edj"
+#define MAX_VIEW_STATE 8
+
+static struct _widget_info
+{
+ Evas_Object *parent;
+ Evas_Object *layout;
+ Evas_Object *widget;
+
+ int is_widget_init;
+ int is_widget_resumed;
+
+ char *pkgname;
+
+ int view_pos;
+ int view_pos_timestamp;
+} s_widget_info = {
+ .parent = NULL,
+ .layout = NULL,
+ .widget = NULL,
+
+ .is_widget_init = 0,
+ .is_widget_resumed = 0,
+
+ .pkgname = NULL,
+
+ .view_pos = 0,
+ .view_pos_timestamp = 0,
+};
+
+static void __clock_viewer_widget_raw_event_cb(struct widget_evas_raw_event_info *info, void *data)
+{
+ Evas_Object *widget = NULL;
+
+ if (info) {
+ if (info->type == WIDGET_VIEWER_EVAS_RAW_CREATE) {
+ _DBG("Widget Created[%s] it should be [%s]", info->pkgname, s_widget_info.pkgname);
+
+ if (s_widget_info.pkgname && info->pkgname) {
+ if (strcmp(s_widget_info.pkgname, info->pkgname)) {
+ _ERR("invalid widget pkgname");
+ return;
+ }
+ }
+
+ if (s_widget_info.layout) {
+ widget = elm_object_content_unset(s_widget_info.layout);
+ if (widget && widget != info->widget) {
+ // delete old widget
+ evas_object_del(widget);
+ }
+
+ elm_object_part_content_set(s_widget_info.layout, "elm.swallow.body", info->widget);
+ evas_object_show(info->widget);
+
+ s_widget_info.widget = info->widget;
+
+ if (s_widget_info.is_widget_resumed) {
+ _DBG("resume when it created");
+ widget_viewer_evas_resume_widget(s_widget_info.widget);
+ }
+ }
+ } else if (info->type == WIDGET_VIEWER_EVAS_RAW_DELETE) {
+ _DBG("Widget deleted[%s]", info->pkgname);
+ // unset will be done when another evas object is set or fini
+ } else {
+ _ERR("invalid type[%d]", info->type);
+ }
+ }
+}
+
+HAPI void clock_viewer_widget_init(void *data, Evas_Object *parent, char *pkgname)
+{
+ int ret = 0;
+
+ if (s_widget_info.is_widget_init) {
+ _DBG("widget already init");
+ return;
+ }
+
+ // create layouot
+ if (!s_widget_info.layout) {
+ s_widget_info.layout = clock_viewer_util_winset_create_layout(parent, EDJ_APP, "layout_manual_clock_position");
+ if (!s_widget_info.layout) {
+ _ERR("Failed to create clock layout");
+ return;
+ }
+
+ elm_win_resize_object_add(parent, s_widget_info.layout);
+ } else {
+ _DBG("widget clock bg is already created");
+ }
+
+ ret = widget_viewer_evas_init(s_widget_info.layout);
+ if (ret != 0) {
+ _ERR("Failed to init widget[%d]", ret);
+ return;
+ }
+ s_widget_info.is_widget_init = 1;
+
+ widget_viewer_evas_set_option(WIDGET_VIEWER_EVAS_MANUAL_PAUSE_RESUME, 1);
+
+ ret = widget_viewer_evas_set_raw_event_callback(WIDGET_VIEWER_EVAS_RAW_CREATE, __clock_viewer_widget_raw_event_cb, data);
+ if (ret != 0) {
+ _ERR("Failed to set widget create callback[%d]", ret);
+ }
+
+ ret = widget_viewer_evas_set_raw_event_callback(WIDGET_VIEWER_EVAS_RAW_DELETE, __clock_viewer_widget_raw_event_cb, data);
+ if (ret != 0) {
+ _ERR("Failed to set widget delete callback[%d]", ret);
+ }
+
+ ret = widget_viewer_evas_subscribe_category(CLOCK_VIEWER_TIZEN_CLOCK_CATEGORY);
+ if (ret != 0) {
+ _ERR("Failed to subscribe category[%d]", ret);
+ }
+
+ if (pkgname) {
+ s_widget_info.pkgname = strdup(pkgname);
+ }
+
+ s_widget_info.parent = parent;
+}
+
+HAPI void clock_viewer_widget_fini(void *data)
+{
+ int ret = 0;
+
+ if (s_widget_info.is_widget_init) {
+ ret = widget_viewer_evas_unset_raw_event_callback(WIDGET_VIEWER_EVAS_RAW_CREATE, __clock_viewer_widget_raw_event_cb, data);
+ if (ret != 0) {
+ _ERR("Failed to unset widget create callback[%d]", ret);
+ }
+
+ ret = widget_viewer_evas_unset_raw_event_callback(WIDGET_VIEWER_EVAS_RAW_DELETE, __clock_viewer_widget_raw_event_cb, data);
+ if (ret != 0) {
+ _ERR("Failed to unset widget delete callback[%d]", ret);
+ }
+
+ ret = widget_viewer_evas_unsubscribe_category(CLOCK_VIEWER_TIZEN_CLOCK_CATEGORY);
+ if (ret != 0) {
+ _ERR("Failed to subscribe category[%d]", ret);
+ }
+
+ widget_viewer_evas_fini();
+ s_widget_info.is_widget_init = 0;
+ }
+
+ if (s_widget_info.widget) {
+ evas_object_del(s_widget_info.widget);
+ s_widget_info.widget = NULL;
+ }
+
+ if (s_widget_info.layout) {
+ if (s_widget_info.parent) {
+ elm_win_resize_object_del(s_widget_info.parent, s_widget_info.layout);
+ }
+ evas_object_del(s_widget_info.layout);
+ s_widget_info.layout = NULL;
+ }
+
+ if (s_widget_info.pkgname) {
+ free(s_widget_info.pkgname);
+ s_widget_info.pkgname = NULL;
+ }
+
+ s_widget_info.parent = NULL;
+}
+
+HAPI void clock_viewer_widget_pause(void)
+{
+ _DBG("");
+ if (s_widget_info.widget) {
+ widget_viewer_evas_pause_widget(s_widget_info.widget);
+ }
+ s_widget_info.is_widget_resumed = 0;
+
+ // reset position
+ if (s_widget_info.layout) {
+ edje_object_signal_emit(elm_layout_edje_get(s_widget_info.layout), "elm.swallow.body.default", "elm.swallow.body");
+ edje_object_message_signal_process(elm_layout_edje_get(s_widget_info.layout));
+ }
+}
+
+HAPI void clock_viewer_widget_resume(void)
+{
+ _DBG("");
+ if (s_widget_info.widget) {
+ evas_object_show(s_widget_info.widget);
+ widget_viewer_evas_resume_widget(s_widget_info.widget);
+ }
+ s_widget_info.is_widget_resumed = 1;
+}
+
+HAPI void clock_viewer_widget_update_position(void)
+{
+ int timestamp = time(NULL);
+ static const struct signal_list {
+ char *emission;
+ char *source;
+ } signal_list[] = {
+ [0] = {
+ .emission = NULL,
+ .source = NULL
+ },
+ [1] = {
+ .emission = "elm.swallow.body.top",
+ .source = "elm.swallow.body"
+ },
+ [2] = {
+ .emission = "elm.swallow.body.right",
+ .source = "elm.swallow.body"
+ },
+ [3] = {
+ .emission = "elm.swallow.body.bottom",
+ .source = "elm.swallow.body"
+ },
+ [4] = {
+ .emission = "elm.swallow.body.left",
+ .source = "elm.swallow.body"
+ },
+ [5] = {
+ .emission = "elm.swallow.body.topright",
+ .source = "elm.swallow.body"
+ },
+ [6] = {
+ .emission = "elm.swallow.body.bottomright",
+ .source = "elm.swallow.body"
+ },
+ [7] = {
+ .emission = "elm.swallow.body.bottomleft",
+ .source = "elm.swallow.body"
+ },
+ [8] = {
+ .emission = "elm.swallow.body.topleft",
+ .source = "elm.swallow.body"
+ },
+ [9] = {
+ .emission = NULL,
+ .source = NULL
+ }
+ };
+
+ if (timestamp - s_widget_info.view_pos_timestamp < 60) {
+ return;
+ }
+ s_widget_info.view_pos_timestamp = timestamp;
+
+ if (++s_widget_info.view_pos > MAX_VIEW_STATE) {
+ s_widget_info.view_pos = 0;
+ }
+
+ _DBG("moved pos[%d]", s_widget_info.view_pos);
+
+ if (s_widget_info.view_pos >= 1 && s_widget_info.view_pos <= 8) {
+ edje_object_signal_emit(elm_layout_edje_get(s_widget_info.layout), signal_list[s_widget_info.view_pos].emission, signal_list[s_widget_info.view_pos].source);
+ } else {
+ edje_object_signal_emit(elm_layout_edje_get(s_widget_info.layout), "elm.swallow.body.default", "elm.swallow.body");
+ }
+
+ edje_object_message_signal_process(elm_layout_edje_get(s_widget_info.layout));
+}
+
+HAPI void clock_viewer_widget_register_render_event(Evas_Smart_Cb func, void *data)
+{
+ if (!s_widget_info.widget) {
+ return;
+ }
+
+ evas_object_smart_callback_add(s_widget_info.widget, WIDGET_SMART_SIGNAL_UPDATED, func, data);
+}
+
+HAPI void clock_viewer_widget_unregister_render_event(Evas_Smart_Cb func, void *data)
+{
+ if (!s_widget_info.widget) {
+ return;
+ }
+
+ evas_object_smart_callback_del(s_widget_info.widget, WIDGET_SMART_SIGNAL_UPDATED, func);
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <Ecore_X.h>
+
+#include "clock-viewer-window.h"
+
+static Evas_Object *_clock_viewer_window_create_window()
+{
+ Evas_Object *win = NULL;
+
+ win = elm_win_add(NULL, PACKAGE, ELM_WIN_BASIC);
+ if (win) {
+ elm_win_title_set(win, PACKAGE);
+ elm_win_borderless_set(win, EINA_TRUE);
+ elm_win_alpha_set(win, EINA_FALSE);
+ elm_win_indicator_mode_set(win, ELM_WIN_INDICATOR_HIDE);
+ elm_win_indicator_opacity_set(win, ELM_WIN_INDICATOR_BG_TRANSPARENT);
+ } else {
+ _ERR("Failed to create window");
+ }
+
+ return win;
+}
+
+HAPI Evas_Object *clock_viewer_window_create(void)
+{
+ Evas_Object *window = NULL;
+ int w, h;
+
+ window = _clock_viewer_window_create_window();
+ if (!window) {
+ _ERR("Failed to create window");
+ return NULL;
+ }
+
+ /**
+ * @TODO
+ * Set window class name as "CLOCK_VIEWER"
+ * Disable launch effect
+ */
+ elm_win_screen_size_get(window, NULL, NULL, &w, &h);
+ evas_object_resize(window, w, h);
+ LOGD("Window is resized to %dx%d\n", w, h);
+
+ return window;
+}
+
+HAPI void clock_viewer_window_destroy(Evas_Object *window)
+{
+ if (window) {
+ evas_object_del(window);
+ }
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <Ecore.h>
+#include <Ecore_Evas.h>
+#include <device/power.h>
+
+#include "clock-viewer.h"
+#include "clock-viewer-window.h"
+#include "clock-viewer-util-dbus.h"
+#include "clock-viewer-util-pkginfo.h"
+#include "clock-viewer-display.h"
+#include "clock-viewer-minicontrol.h"
+#include "clock-viewer-widget.h"
+#include "clock-viewer-default-clock.h"
+
+#define CV_WINDOW_SHOW_POS_X 0
+#define CV_WINDOW_SHOW_POS_Y 0
+#define CV_WINDOW_HIDE_POS_X 10000
+#define CV_WINDOW_HIDE_POS_Y 10000
+
+#define CLOCK_VIEWER_TIMER_CLOCKEND 0.1
+#define CLOCK_VIEWER_TIMER_RENDER_CHECK 0.5
+
+#define CLOCK_VIEWER_VCONF_HOMESCREEN_CLOCK_VISIBILITY "memory/homescreen/clock_visibility" /* Set by homescreen */
+#define CLOCK_VIEWER_VCONF_CLOCK_VIEWER_CLOCK_VISIBILITY "memory/clock_viewer/clock_visibility"
+
+static struct _info {
+ Evas_Object *parent;
+ Evas_Object *widget;
+
+ int is_render_added; // 0 : deleted, 1 : added
+ int is_clock_resumed;
+
+ int home_clock_visibitity; // homescreen clock status
+ int clock_visibitity; // clock status
+
+ clock_viewer_ambient_type ambient_type;
+ char *clock_pkgname;
+
+ /* clockend condition check list */
+ int is_drawdone;
+ int is_render_check_timer_expired;
+
+ Ecore_Timer *render_first_timer;
+ Ecore_Timer *render_check_timer;
+ Ecore_Timer *clockend_timer;
+} s_info = {
+ .parent = NULL,
+ .widget = NULL,
+
+ .is_render_added = 0,
+ .is_clock_resumed = 0,
+
+ .home_clock_visibitity = 0,
+ .clock_visibitity = 0,
+
+ .ambient_type = CLOCK_VIEWER_AMBIENT_TYPE_ANALOG,
+ .clock_pkgname = NULL,
+
+ .is_drawdone = 0,
+ .is_render_check_timer_expired = 0,
+
+ .render_first_timer = NULL,
+ .render_check_timer = NULL,
+ .clockend_timer = NULL,
+};
+
+static int _clock_viewer_try_clockend(clock_viewer_s *clock_viewer);
+static void _clock_viewer_set_current_clock(clock_viewer_s *clock_viewer);
+
+static Eina_Bool __clock_viewer_clockend_timer_cb(void *data)
+{
+ char *clock_signal[1] = { "clockend" };
+ _WARN("clock end <<");
+ clock_viewer_util_dbus_broadcast_signal(data, DEVICED_PATH, DEVICED_INTERFACE, "HomeScreen", "s", &clock_signal[0]);
+ device_power_release_lock(POWER_LOCK_CPU);
+
+ s_info.clockend_timer = NULL;
+
+ return EINA_FALSE;
+}
+
+static Eina_Bool __clock_viewer_render_check_timer_cb(void *data)
+{
+ clock_viewer_s *clock_viewer = (clock_viewer_s *) data;
+ _DBG("Render check timer expired");
+
+ s_info.is_render_check_timer_expired = 1;
+
+ if (!_clock_viewer_try_clockend(clock_viewer)) {
+ _DBG("clockend condition is unmet");
+ }
+
+ s_info.render_check_timer = NULL;
+
+ return EINA_FALSE;
+}
+
+static void __clock_viewer_render_pre_cb(void *data, Evas *e, void *event_info)
+{
+ clock_viewer_s *clock_viewer = (clock_viewer_s *) data;
+ if (!clock_viewer) {
+ _ERR("invalid data");
+ return;
+ }
+
+ _WARN("RENDER PRE [%d] timer[%d]", clock_viewer->request_pm_status, s_info.is_render_check_timer_expired);
+
+ if (!s_info.is_render_check_timer_expired) {
+ return;
+ }
+
+ if (clock_viewer->request_pm_status == CLOCK_VIEWER_PM_STEP_CLOCKSTART
+ || clock_viewer->request_pm_status == CLOCK_VIEWER_PM_STEP_CLOCKEND)
+ {
+ clock_viewer_display_set_dpms_mode(CLOCK_VIEWER_DISPLAY_MODE_RESUME);
+
+ if (s_info.ambient_type == CLOCK_VIEWER_AMBIENT_TYPE_MANUAL) {
+ clock_viewer_widget_update_position();
+ }
+ }
+}
+
+static void __clock_viewer_render_post_cb(void *data, Evas *e, void *event_info)
+{
+ clock_viewer_s *clock_viewer = (clock_viewer_s *) data;
+ if (!clock_viewer) {
+ _ERR("invalid data");
+ return;
+ }
+
+ _WARN("RENDER POST [%d] timer[%d]", clock_viewer->request_pm_status, s_info.is_render_check_timer_expired);
+
+ if (!s_info.is_render_check_timer_expired) {
+ if (s_info.render_check_timer) {
+ ecore_timer_del(s_info.render_check_timer);
+ }
+ s_info.render_check_timer = ecore_timer_add(CLOCK_VIEWER_TIMER_RENDER_CHECK, __clock_viewer_render_check_timer_cb, clock_viewer);
+ return;
+ }
+
+ if (clock_viewer->request_pm_status == CLOCK_VIEWER_PM_STEP_CLOCKEND) {
+ clock_viewer_display_set_dpms_mode(CLOCK_VIEWER_DISPLAY_MODE_PAUSE);
+ }
+}
+
+static void __clock_viewer_widget_updated_cb(void *data, Evas_Object *obj, void *event_info)
+{
+ __clock_viewer_render_pre_cb(data, NULL, NULL);
+ __clock_viewer_render_post_cb(data, NULL, NULL);
+}
+
+Eina_Bool __clock_viewer_render_first_timer_cb(void *data)
+{
+ _DBG("Render first done");
+
+ clock_viewer_s *clock_viewer = (clock_viewer_s *) data;
+ if (!clock_viewer) {
+ _ERR("invalid data");
+ return EINA_FALSE;
+ }
+
+ if (clock_viewer->request_pm_status == CLOCK_VIEWER_PM_STEP_CLOCKSTART) {
+ clock_viewer->request_pm_status = CLOCK_VIEWER_PM_STEP_CLOCKEND;
+
+ s_info.is_drawdone = 1;
+ if (!_clock_viewer_try_clockend(clock_viewer)) {
+ _DBG("clockend condition is unmet");
+ }
+ }
+
+ s_info.render_first_timer = NULL;
+
+ return EINA_FALSE;
+}
+
+static void __clock_viewer_clockdraw_cb(void *data, DBusMessage *msg)
+{
+ _DBG("Clock draw done");
+
+ clock_viewer_s *clock_viewer = (clock_viewer_s *) data;
+ if (!clock_viewer) {
+ _ERR("invalid data");
+ return;
+ }
+
+ if (clock_viewer->request_pm_status == CLOCK_VIEWER_PM_STEP_CLOCKSTART) {
+ clock_viewer->request_pm_status = CLOCK_VIEWER_PM_STEP_CLOCKEND;
+
+ s_info.is_drawdone = 1;
+ if (!_clock_viewer_try_clockend(clock_viewer)) {
+ _DBG("clockend condition is unmet");
+ }
+ }
+}
+
+static void __clock_viewer_lcdon_cb(void *data, DBusMessage *msg)
+{
+ clock_viewer_s *clock_viewer = (clock_viewer_s *) data;
+ if (!clock_viewer) {
+ _ERR("invalid data");
+ return;
+ }
+
+ int is_lcdon = clock_viewer_util_dbus_message_is_signal(msg, DEVICED_DISPLAY_INTERFACE, LCDON_SIGNAL_NAME);
+ _DBG("event lcdon[%d]", is_lcdon);
+
+ clock_viewer->is_lckoff = 0;
+ if (is_lcdon) {
+ clock_viewer_hide(clock_viewer);
+
+ clock_viewer->request_pm_status = CLOCK_VIEWER_PM_STEP_NONE;
+ }
+}
+
+static void __clock_viewer_lcdoff_cb(void *data, DBusMessage *msg)
+{
+ clock_viewer_s *clock_viewer = (clock_viewer_s *) data;
+ if (!clock_viewer) {
+ _ERR("invalid data");
+ return;
+ }
+
+ int ret = 0;
+ int is_lcdoff = clock_viewer_util_dbus_message_is_signal(msg, DEVICED_DISPLAY_INTERFACE, LCDOFF_SIGNAL_NAME);
+ _DBG("event pre lcdoff[%d]", is_lcdoff);
+
+ clock_viewer->is_lckoff = 1;
+ if (is_lcdoff) {
+#ifdef _CLOCK_VIEWER_FEATURE_VI_BY_HOMESCREEN_STATUS_ENABLED_
+ // set clock visibility first
+ s_info.clock_visibitity = s_info.home_clock_visibitity;
+#else
+ // default is 1
+ s_info.clock_visibitity = 1;
+#endif
+ ret = vconf_set_int(CLOCK_VIEWER_VCONF_CLOCK_VIEWER_CLOCK_VISIBILITY, s_info.home_clock_visibitity);
+ if (ret != 0) {
+ _ERR("Failed to set clock visibility");
+ } else {
+ _DBG("Clock visibility set to [%d]", s_info.home_clock_visibitity);
+ }
+
+ // init clockend condition
+ s_info.is_drawdone = 0;
+ s_info.is_render_check_timer_expired = 0;
+
+ clock_viewer->request_pm_status = CLOCK_VIEWER_PM_STEP_CLOCKSTART;
+
+ if (s_info.clock_visibitity) {
+ clock_viewer_show(clock_viewer, 0);
+ }
+
+ char *clock_signal[1] = { "clockstart" };
+ _WARN("clock start >>");
+ device_power_request_lock(POWER_LOCK_CPU, 0);
+ clock_viewer_util_dbus_broadcast_signal(clock_viewer, DEVICED_PATH, DEVICED_INTERFACE, "HomeScreen", "s", &clock_signal[0]);
+
+ if (s_info.ambient_type == CLOCK_VIEWER_AMBIENT_TYPE_MANUAL) {
+ char *clock_begin_signal[1] = { "clockbegin" };
+ _WARN("clock begin >>");
+ clock_viewer_util_dbus_broadcast_signal(clock_viewer, DEVICED_PATH, DEVICED_INTERFACE, "HomeScreen", "s", &clock_begin_signal[0]);
+ }
+
+ if (clock_viewer->current_type != CLOCK_VIEWER_TYPE_WIDGET) {
+ // if dbox, wait draw done signal. others are not send draw done signal
+ s_info.render_first_timer = ecore_timer_add(1.0, __clock_viewer_render_first_timer_cb, clock_viewer);
+ }
+
+ if (!s_info.clock_visibitity) {
+ clock_viewer_show(clock_viewer, 0);
+ }
+ }
+}
+
+static void __clock_viewer_clock_package_event_cb(keynode_t *node, void *user_data)
+{
+ _DBG("clock package has been changed");
+
+ _clock_viewer_set_current_clock(user_data);
+}
+
+static int _clock_viewer_try_clockend(clock_viewer_s *clock_viewer)
+{
+ _DBG("drawdone[%d] render timer expired[%d]", s_info.is_drawdone, s_info.is_render_check_timer_expired);
+
+ if (s_info.is_drawdone && s_info.is_render_check_timer_expired) {
+ if (!s_info.clock_visibitity) {
+ // [LCDOFF Flow 2] manual render
+ int w, h;
+ Evas *e;
+ Ecore_Evas *ee;
+ ee = ecore_evas_ecore_evas_get(evas_object_evas_get(clock_viewer->window));
+ e = ecore_evas_get(ee);
+ evas_output_viewport_get(e, NULL, NULL, &w, &h);
+ evas_obscured_clear(e);
+ evas_damage_rectangle_add(e, 0, 0, w, h);
+ ecore_evas_manual_render(ee);
+
+ // [LCDOFF Flow 3] move to view area
+ evas_object_resize(clock_viewer->window, clock_viewer->win_width, clock_viewer->win_height);
+ evas_object_move(clock_viewer->window, CV_WINDOW_SHOW_POS_X, CV_WINDOW_SHOW_POS_Y);
+ evas_object_show(clock_viewer->window);
+ }
+
+ if (s_info.clockend_timer) {
+ ecore_timer_del(s_info.clockend_timer);
+ }
+ s_info.clockend_timer = ecore_timer_add(CLOCK_VIEWER_TIMER_CLOCKEND, __clock_viewer_clockend_timer_cb, clock_viewer);
+
+ return CLOCK_VIEWER_SUCCESS;
+ }
+
+ return CLOCK_VIEWER_FAIL;
+}
+
+static void __clock_viewer_homescreen_clock_visibility_changed_cb(keynode_t *node, void *data)
+{
+ int ret = 0;
+ int value = 0;
+
+ ret = vconf_get_int(CLOCK_VIEWER_VCONF_HOMESCREEN_CLOCK_VISIBILITY, &value);
+ if (ret != 0) {
+ _ERR("Failed to get homescreen clock visibility[%d]", ret);
+ }
+
+ _DBG("homescreen clock visibility changed [%d]->[%d]", s_info.home_clock_visibitity, value);
+ s_info.home_clock_visibitity = value;
+}
+
+static void _clock_viewer_set_current_clock(clock_viewer_s *clock_viewer)
+{
+ clock_viewer_ambient_type ambient_type;
+ char *pkgname;
+
+ pkgname = clock_viewer_util_pkginfo_get_clock_package();
+ if (!pkgname) {
+ _ERR("pkgname is not valid\n");
+ return;
+ }
+
+ if (s_info.clock_pkgname) {
+ if (!strcmp(s_info.clock_pkgname, pkgname)) {
+ _WARN("same pkgname(%s), skip!", pkgname);
+ free(pkgname);
+ return;
+ }
+ } else {
+ _DBG("First time\n");
+ }
+
+ ambient_type = clock_viewer_util_pkginfo_get_ambient_type(pkgname);
+ _WARN("package[%s] ambient type[%d]", pkgname, ambient_type);
+
+ // unload clock
+ clock_viewer_default_clock_fini(clock_viewer);
+ clock_viewer_minicontrol_fini(clock_viewer);
+ clock_viewer_widget_fini(clock_viewer);
+
+ // load clock
+ if (ambient_type == CLOCK_VIEWER_AMBIENT_TYPE_MANUAL) {
+ if (clock_viewer_util_pkginfo_is_widget(pkgname)) {
+ clock_viewer_widget_init(clock_viewer, clock_viewer->window, pkgname);
+ clock_viewer->current_type = CLOCK_VIEWER_TYPE_WIDGET;
+ } else {
+ clock_viewer_minicontrol_init(clock_viewer, clock_viewer->window);
+ clock_viewer->current_type = CLOCK_VIEWER_TYPE_MINICTRL;
+ }
+ } else {
+ clock_viewer_default_clock_init(clock_viewer, clock_viewer->window, ambient_type);
+ clock_viewer->current_type = CLOCK_VIEWER_TYPE_DEFAULT_CLOCK;
+ }
+
+ s_info.is_clock_resumed = 0;
+ s_info.ambient_type = ambient_type;
+
+ free(s_info.clock_pkgname);
+ s_info.clock_pkgname = pkgname;
+
+ _DBG("type changed to [%d](%s)", clock_viewer->current_type, s_info.clock_pkgname);
+}
+
+static void _clock_viewer_register_event(clock_viewer_s *clock_viewer)
+{
+ int ret = 0;
+
+ // dbus event
+ clock_viewer_util_dbus_init_lcdon_signal(clock_viewer, __clock_viewer_lcdon_cb);
+ clock_viewer_util_dbus_init_lcdoff_signal(clock_viewer, __clock_viewer_lcdoff_cb);
+ clock_viewer_util_dbus_init_clockdraw_signal(clock_viewer, __clock_viewer_clockdraw_cb);
+
+ // pkginfo event
+ clock_viewer_util_pkginfo_init_clock_package_event(clock_viewer, __clock_viewer_clock_package_event_cb);
+
+ // vconf event
+ ret = vconf_notify_key_changed(CLOCK_VIEWER_VCONF_HOMESCREEN_CLOCK_VISIBILITY, __clock_viewer_homescreen_clock_visibility_changed_cb, clock_viewer);
+ if (ret != 0) {
+ _ERR("Failed to notify homescreen clock visibility changed event[%d]", ret);
+ }
+ __clock_viewer_homescreen_clock_visibility_changed_cb(NULL, NULL);
+}
+
+static void _clock_viewer_unregister_event(clock_viewer_s *clock_viewer)
+{
+ // dbus event
+ clock_viewer_util_dbus_fini_lcdon_signal(clock_viewer);
+ clock_viewer_util_dbus_fini_lcdoff_signal(clock_viewer);
+ clock_viewer_util_dbus_fini_clockdraw_signal(clock_viewer);
+
+ // pkginfo event
+ clock_viewer_util_pkginfo_fini_clock_package_event(__clock_viewer_clock_package_event_cb);
+}
+
+HAPI void clock_viewer_create(clock_viewer_s *clock_viewer)
+{
+ if (!clock_viewer) {
+ _ERR("invalid data");
+ return;
+ }
+
+ _clock_viewer_register_event(clock_viewer);
+
+ // create base winset
+ clock_viewer->window = clock_viewer_window_create();
+
+ elm_win_screen_size_get(clock_viewer->window, NULL, NULL, &clock_viewer->win_width, &clock_viewer->win_height);
+ evas_object_move(clock_viewer->window, CV_WINDOW_HIDE_POS_X, CV_WINDOW_HIDE_POS_Y);
+ evas_object_show(clock_viewer->window);
+
+ _clock_viewer_set_current_clock(clock_viewer);
+}
+
+HAPI void clock_viewer_destroy(clock_viewer_s *clock_viewer)
+{
+ _clock_viewer_unregister_event(clock_viewer);
+}
+
+HAPI void clock_viewer_resume(clock_viewer_s *clock_viewer)
+{
+ _DBG("");
+}
+
+HAPI void clock_viewer_pause(clock_viewer_s *clock_viewer)
+{
+ _DBG("");
+}
+
+HAPI void clock_viewer_show(clock_viewer_s *clock_viewer, int is_hide_launch)
+{
+ _DBG("hide_launch[%d]", is_hide_launch);
+ Evas_Object *win = NULL;
+ Evas *evas = NULL;
+
+ if (!clock_viewer) {
+ _ERR("invalid data");
+ return;
+ }
+
+ win = clock_viewer->window;
+ if (win) {
+ if (!s_info.is_render_added) {
+ if (clock_viewer->current_type == CLOCK_VIEWER_TYPE_WIDGET) {
+ clock_viewer_widget_register_render_event(__clock_viewer_widget_updated_cb, clock_viewer);
+ } else {
+ evas = evas_object_evas_get(win);
+
+ evas_event_callback_add(evas, EVAS_CALLBACK_RENDER_PRE, __clock_viewer_render_pre_cb, clock_viewer);
+ evas_event_callback_add(evas, EVAS_CALLBACK_RENDER_POST, __clock_viewer_render_post_cb, clock_viewer);
+ }
+
+ s_info.is_render_added = 1;
+ }
+
+ // [LCDOFF Flow 1] widget or mc resume
+ if (!s_info.is_clock_resumed) {
+ if (clock_viewer->current_type == CLOCK_VIEWER_TYPE_DEFAULT_CLOCK) {
+ clock_viewer_default_clock_resume(clock_viewer);
+ } else if (clock_viewer->current_type == CLOCK_VIEWER_TYPE_WIDGET) {
+ clock_viewer_widget_resume();
+ }
+
+ s_info.is_clock_resumed = 1;
+ } else {
+ // only widget is working with render event
+ if (clock_viewer->current_type != CLOCK_VIEWER_TYPE_WIDGET) {
+ // temporary move to set visible so we can receive render pre/post
+ evas_object_move(win, clock_viewer->win_width - 1, clock_viewer->win_height - 1);
+ }
+ }
+
+ // [LCDOFF Flow 2] manual render
+ int w, h;
+ Evas *e;
+ Ecore_Evas *ee;
+
+ ee = ecore_evas_ecore_evas_get(evas_object_evas_get(clock_viewer->window));
+ e = ecore_evas_get(ee);
+
+ evas_output_viewport_get(e, NULL, NULL, &w, &h);
+ evas_obscured_clear(e);
+ evas_damage_rectangle_add(e, 0, 0, w, h);
+ ecore_evas_manual_render(ee);
+
+ if (s_info.clock_visibitity) {
+ // if homescreen is not clock, do move in drawdone
+ // [LCDOFF Flow 3] move to view area
+ evas_object_resize(win, clock_viewer->win_width, clock_viewer->win_height);
+ evas_object_move(win, CV_WINDOW_SHOW_POS_X, CV_WINDOW_SHOW_POS_Y);
+ evas_object_show(win);
+ } else {
+ if (clock_viewer->current_type != CLOCK_VIEWER_TYPE_WIDGET) {
+ // temporary move to set visible so we can receive render pre/post
+ evas_object_move(win, clock_viewer->win_width - 1, clock_viewer->win_height - 1);
+ }
+ }
+
+ // Raise up the Clock Viewer Window
+ _DBG("Raise up the window\n");
+ elm_win_raise(win);
+ } else {
+ _ERR("window is not created");
+ }
+}
+
+HAPI void clock_viewer_hide(clock_viewer_s *clock_viewer)
+{
+ _DBG("");
+ Evas_Object *win = NULL;
+ Evas *evas = NULL;
+
+ if (!clock_viewer) {
+ _ERR("invalid data");
+ return;
+ }
+
+ win = clock_viewer->window;
+ if (win) {
+ if (s_info.is_render_added) {
+ if (clock_viewer->current_type == CLOCK_VIEWER_TYPE_WIDGET) {
+ clock_viewer_widget_unregister_render_event(__clock_viewer_widget_updated_cb, clock_viewer);
+ } else {
+ evas = evas_object_evas_get(win);
+
+ evas_event_callback_del(evas, EVAS_CALLBACK_RENDER_PRE, __clock_viewer_render_pre_cb);
+ evas_event_callback_del(evas, EVAS_CALLBACK_RENDER_POST, __clock_viewer_render_post_cb);
+ }
+
+ s_info.is_render_added = 0;
+ }
+
+ // TODO: when it should be called?
+ clock_viewer_display_set_dpms_mode(CLOCK_VIEWER_DISPLAY_MODE_PAUSE);
+
+ if (s_info.is_clock_resumed) {
+ if (clock_viewer->current_type == CLOCK_VIEWER_TYPE_DEFAULT_CLOCK) {
+ clock_viewer_default_clock_pause(clock_viewer);
+ } else if (clock_viewer->current_type == CLOCK_VIEWER_TYPE_WIDGET) {
+ clock_viewer_widget_pause();
+ }
+ s_info.is_clock_resumed = 0;
+
+ if (s_info.ambient_type == CLOCK_VIEWER_AMBIENT_TYPE_MANUAL) {
+ char *clock_signal[1] = { "clockstop" };
+ _WARN("clock stop <<");
+ clock_viewer_util_dbus_broadcast_signal(clock_viewer, DEVICED_PATH, DEVICED_INTERFACE, "HomeScreen", "s", &clock_signal[0]);
+ }
+ }
+
+ evas_object_move(win, CV_WINDOW_HIDE_POS_X, CV_WINDOW_HIDE_POS_Y);
+ } else {
+ _ERR("window is not created");
+ }
+}
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(idle-clock-alpm C)
+
+SET(ANALOG "alnalog")
+SET(DIGITAL "digital")
+
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+SET(SHAREDDIR "${PREFIX}/shared")
+SET(LIBDIR "${SHAREDDIR}/lib")
+SET(RESDIR "${SHAREDDIR}/res")
+SET(CHGDIR "${SHAREDDIR}/res/tables")
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(pkgs REQUIRED
+ elementary
+ ecore-x
+ evas
+ dlog
+ vconf
+)
+
+FOREACH(flag ${pkgs_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fvisibility=hidden -Wall")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_C_FLAGS}")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_C_FLAGS_RELEASE "-O2")
+
+SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed")
+
+ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
+ADD_DEFINITIONS("-DCHGDIR=\"${CHGDIR}\"")
+
+ADD_LIBRARY(${ANALOG} SHARED src/analog.c)
+TARGET_LINK_LIBRARIES(${ANALOG} ${pkgs_LDFLAGS})
+INSTALL(TARGETS ${ANALOG} DESTINATION ${LIBDIR})
+
+ADD_LIBRARY(${DIGITAL} SHARED src/digital.c)
+TARGET_LINK_LIBRARIES(${DIGITAL} ${pkgs_LDFLAGS})
+INSTALL(TARGETS ${DIGITAL} DESTINATION ${LIBDIR})
+
+# data
+ADD_SUBDIRECTORY(data)
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+
+# install edj
+ADD_CUSTOM_TARGET(alpm.edj
+ COMMAND edje_cc -id ${CMAKE_CURRENT_SOURCE_DIR}/images ${EDJE_CFLAGS}
+ ${CMAKE_CURRENT_SOURCE_DIR}/alpm.edc alpm.edj
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/alpm.edc
+)
+ADD_DEPENDENCIES(${DIGITAL} alpm.edj)
+ADD_DEPENDENCIES(${ANALOG} alpm.edj)
+
+INSTALL(FILES alpm.edj DESTINATION ${RESDIR})
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+collections {
+ base_scale: 1.3;
+
+ group {
+ name: "layout_clock_position";
+ parts {
+ part {
+ name: "bg";
+ type: RECT;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ color: 0 0 0 255;
+ }
+ }
+ part {
+ name: "elm.swallow.body";
+ type: SWALLOW;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ }
+ }
+ }
+ }
+
+ group {
+ name: "layout_clock_tb";
+ styles {
+ style {
+ name: "textblock_digit_style2";
+ base: "font=TIZEN:style=Regular font_size=104 color=#ffffff align=center style=shadow,bottom shadow_color=#00000088";
+ tag: "br" "\n";
+ tag: "hilight" "+ font_weight=Bold";
+ tag: "b" "+ font_weight=Bold";
+ tag: "tab" "\t";
+ }
+ }
+
+ parts {
+ part {
+ name: "text.clock";
+ type: TEXTBLOCK;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ fixed: 1 1;
+ visible: 1;
+ color: 255 255 255 255;
+ text{
+ text: "";
+ style: "textblock_digit_style2";
+ align: 0.5 0.5;
+ }
+ }
+ }
+ }
+ }
+
+ group {
+ name: "analog";
+ parts {
+ part {
+ name: "bg";
+ type: RECT;
+ description {
+ state: "default" 0.0;
+ //color_class: "AO011";
+ color: 100 100 100 255;
+ }
+ }
+ }
+ }
+
+ group {
+ name: "hour_hand";
+ images.image: "alpm_hands_hr.png" COMP;
+ parts {
+ part {
+ name: "bg";
+ type: SPACER;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ min, 360 360;
+ max, 360 360;
+ fixed, 1 1;
+ }
+ }
+ part {
+ name: "image";
+ type: IMAGE;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ min: 34 264;
+ max: 34 264;
+ fixed: 1 1;
+ image.normal: "alpm_hands_hr.png";
+ rel1.relative: 0.5 0.5;
+ rel2.relative: 0.5 0.5;
+ }
+ }
+ }
+ }
+
+ group {
+ name: "minute_hand";
+ images.image: "alpm_hands_min.png" COMP;
+ parts {
+ part {
+ name: "bg";
+ type: SPACER;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ min, 360 360;
+ max, 360 360;
+ fixed, 1 1;
+ }
+ }
+ part {
+ name: "image";
+ type: IMAGE;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ min: 34 324;
+ max: 34 324;
+ fixed: 1 1;
+ image.normal: "alpm_hands_min.png";
+ rel1.relative: 0.5 0.5;
+ rel2.relative: 0.5 0.5;
+ }
+ }
+ }
+ }
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __ALPM_H__
+#define __ALPM_H__
+
+#include <Elementary.h>
+#include <dlog.h>
+
+#include <unicode/utypes.h>
+#include <unicode/putil.h>
+#include <unicode/uiter.h>
+#include <unicode/udat.h>
+#include <unicode/udatpg.h>
+#include <unicode/ustring.h>
+
+
+#define FREEIF(p) ({if (p) {free(p); p = NULL; }})
+
+#define EDJ_APP "/usr/apps/org.tizen.w-clock-viewer/shared/res/alpm.edj"
+
+#undef LOG_TAG
+#define LOG_TAG "IDLE-CLOCK-ALPM"
+#define _E(fmt, arg...) LOGE("[%s:%d] "fmt,__FUNCTION__,__LINE__,##arg)
+#define _D(fmt, arg...) LOGD("[%s:%d] "fmt,__FUNCTION__,__LINE__,##arg)
+#define _SECURE_E(fmt, arg...) SECURE_LOGE("[%s:%d] "fmt,__FUNCTION__,__LINE__,##arg)
+#define _SECURE_D(fmt, arg...) SECURE_LOGD("[%s:%d] "fmt,__FUNCTION__,__LINE__,##arg)
+#define ENTER() LOGD(COLOR_GREEN"BEGIN >>>"COLOR_END);
+
+#define retvm_if_timer(timer, expr, val, fmt, arg...) do { \
+ if(expr) { \
+ _E(fmt, ##arg); \
+ _E("(%s) -> %s() return", #expr, __FUNCTION__); \
+ timer = NULL; \
+ return (val); \
+ } \
+} while (0)
+
+#define retvm_if(expr, val, fmt, arg...) do { \
+ if(expr) { \
+ _E(fmt, ##arg); \
+ _E("(%s) -> %s() return", #expr, __FUNCTION__); \
+ return (val); \
+ } \
+} while (0)
+
+#define retv_if(expr, val) do { \
+ if(expr) { \
+ _E("(%s) -> %s() return", #expr, __FUNCTION__); \
+ return (val); \
+ } \
+} while (0)
+
+#define retm_if(expr, fmt, arg...) do { \
+ if(expr) { \
+ _E(fmt, ##arg); \
+ _E("(%s) -> %s() return", #expr, __FUNCTION__); \
+ return; \
+ } \
+} while (0)
+
+#define ret_if(expr) do { \
+ if(expr) { \
+ _E("(%s) -> %s() return", #expr, __FUNCTION__); \
+ return; \
+ } \
+} while (0)
+
+typedef struct _alpm_module_data
+{
+ Evas_Object *parent;
+ Evas_Object *bg;
+ Evas_Object *ly_main;
+ Evas_Object *ly_clock;
+
+ /* for time display */
+ Eina_Bool is_pre;
+ int timeformat;
+ char *timeregion_format;
+ char *timezone_id;
+ UDateFormat *formatter_time;
+ UDateFormat *formatter_ampm;
+ UDateFormat *formatter_time_24;
+ UDateFormat *formatter_date;
+ UDateTimePatternGenerator *generator;
+
+ /* private data. you can expand these data structure.*/
+}alpm_module_data;
+
+ALPM_CLOCK_PLUGIN_EXPORT_API int ALPM_CLOCK_PLUGIN_MODULE_INIT(alpm_clock_plugin_module_ops *ops);
+ALPM_CLOCK_PLUGIN_EXPORT_API int ALPM_CLOCK_PLUGIN_MODULE_EXIT(alpm_clock_plugin_module_ops *ops);
+ALPM_CLOCK_PLUGIN_EXPORT_API int ALPM_CLOCK_PLUGIN_MODULE_LOCALE_UPDATE(alpm_clock_plugin_module_ops *ops);
+#endif /* __ALPM_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __CLOCK_VIEWER_PLUGIN_H__
+#define __CLOCK_VIEWER_PLUGIN_H__
+
+#ifndef ALPM_CLOCK_PLUGIN_MODULE_INIT_SYM
+#define ALPM_CLOCK_PLUGIN_MODULE_INIT_SYM "ALPM_CLOCK_PLUGIN_MODULE_INIT"
+#endif
+
+#ifndef ALPM_CLOCK_PLUGIN_MODULE_EXIT_SYM
+#define ALPM_CLOCK_PLUGIN_MODULE_EXIT_SYM "ALPM_CLOCK_PLUGIN_MODULE_EXIT"
+#endif
+
+#ifndef ALPM_CLOCK_PLUGIN_EXPORT_API
+#define ALPM_CLOCK_PLUGIN_EXPORT_API __attribute__ ((visibility("default")))
+#endif
+
+typedef enum
+{
+ ALPM_ERROR=-1,
+ ALPM_NONE=0,
+ ALPM_SUCCESS=1,
+ ALPM_NEED_UPDATE=2
+}ALPM_RET_TYPE;
+
+typedef struct _alpm_clock_plugin_module_ops
+{
+ /* struct modules is initialized by alpm-clock module. */
+ struct {
+ int (*ui_runtime_plugin_init)(void *ops, void *data); /* data will be parent evas object */
+ int (*ui_runtime_plugin_deinit)(void *ops, void *data);
+ int (*ui_runtime_plugin_update_clock)(void *ops, void *data);
+ void *priv;
+ } modules;
+
+}alpm_clock_plugin_module_ops;
+
+#endif /* __CLOCK_VIEWER_PLUGIN_H__ */
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <stdio.h>
+
+#include "clock-viewer-plugin.h"
+#include "alpm.h"
+
+static Evas_Object *_add_layout(Evas_Object *parent, const char *file, const char *group)
+{
+ _D("%s", __func__);
+ Evas_Object *eo = NULL;
+ int r = -1;
+
+ retvm_if(parent == NULL, NULL, "Invalid argument: parent is NULL\n");
+ retvm_if(file == NULL, NULL, "Invalid argument: file is NULL\n");
+ retvm_if(group == NULL, NULL, "Invalid argument: group is NULL\n");
+
+ eo = elm_layout_add(parent);
+ retvm_if(eo == NULL, NULL, "Failed to add layout\n");
+
+ r = elm_layout_file_set(eo, file, group);
+ if (!r) {
+ _E("Failed to set file[%s]\n", file);
+ evas_object_del(eo);
+ return NULL;
+ }
+
+ evas_object_size_hint_weight_set(eo, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_show(eo);
+ return eo;
+}
+
+/**
+ * @brief Initialize ALPM UI.
+ * @param[in] data : Evas Object pointer for elm_win.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+static int alpm_module_init(void *module_ops, void *data)
+{
+ alpm_module_data *alpm_md;
+ alpm_clock_plugin_module_ops *ops;
+
+ _E("module init!!");
+ ops = (alpm_clock_plugin_module_ops *)module_ops;
+ if (!ops) {
+ _E("ops is NULL!!");
+ return -1;
+ }
+
+ if(!data) {
+ _E("data is NULL!!");
+ return -1;
+ }
+
+ alpm_md = ops->modules.priv;
+ if(!alpm_md) {
+ _E("alpm_md is NULL!");
+ return -1;
+ }
+
+ alpm_md->parent = (Evas_Object *)data;
+
+ /* Implement main layout for ALPM clock */
+ //Add BG
+ if (!alpm_md->bg) {
+ alpm_md->bg = elm_bg_add(alpm_md->parent);
+ evas_object_size_hint_weight_set(alpm_md->bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_win_resize_object_add(alpm_md->parent, alpm_md->bg);
+ evas_object_show(alpm_md->bg);
+ }
+
+ //Create main layout
+ if (!alpm_md->ly_main) {
+ alpm_md->ly_main = _add_layout(alpm_md->parent, EDJ_APP, "layout_clock_position");
+ evas_object_size_hint_weight_set(alpm_md->ly_main, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_win_resize_object_add(alpm_md->parent, alpm_md->ly_main);
+ }
+
+ Evas_Coord x, y, w, h;
+ evas_object_geometry_get(alpm_md->ly_main, &x, &y, &w, &h);
+ _D("Layout %dx%d - %dx%d\n", x, y, w, h);
+ evas_object_geometry_get(alpm_md->parent, &x, &y, &w, &h);
+ _D("Window %dx%d - %dx%d\n", x, y, w, h);
+
+ return 1;
+}
+
+/**
+ * @brief clean up ALPM UI.
+ * @param[in] data : Evas Object pointer for elm_win.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+static int alpm_module_deinit(void *module_ops, void *data)
+{
+ alpm_module_data *alpm_md;
+ alpm_clock_plugin_module_ops *ops;
+
+ _E("module deinit!!");
+
+ ops = (alpm_clock_plugin_module_ops *)module_ops;
+ if (!ops) {
+ _E("ops is NULL!!");
+ return -1;
+ }
+
+ if (!data) {
+ _E("data is NULL!!");
+ return -1;
+ }
+
+ alpm_md = ops->modules.priv;
+ if(!alpm_md) {
+ _E("alpm_md is NULL!");
+ return -1;
+ }
+
+ /* destroy main layout for ALPM clock */
+
+ if (alpm_md->bg) {
+ evas_object_del(alpm_md->bg);
+ }
+ if (alpm_md->ly_main) {
+ evas_object_del(alpm_md->ly_main);
+ }
+
+ if (ops->modules.priv) {
+ free(ops->modules.priv);
+ ops->modules.priv = NULL;
+ alpm_md = NULL;
+ }
+
+ return 1;
+}
+
+static double __get_hour_degree()
+{
+ time_t now = time(NULL);
+ struct tm tm_now;
+ struct tm *tm_ret = localtime_r(&now, &tm_now);
+
+ if (!tm_ret) {
+ _E("Failed to get the localtime");
+ return 0.0f;
+ }
+
+ return tm_now.tm_hour * 360 / 12 + tm_now.tm_min * 360 / 60 / 12;
+}
+
+static double __get_minute_degree()
+{
+ time_t now = time(NULL);
+ struct tm tm_now;
+ struct tm *tm_ret = localtime_r(&now, &tm_now);
+
+ if (!tm_ret) {
+ _E("Failed to get the localtime");
+ return 0.0f;
+ }
+
+ return tm_now.tm_min * 360 / 60;
+}
+
+static Evas_Object* __create_hour_hand(Evas_Object* parent)
+{
+ Evas_Object* hand = NULL;
+
+ hand = _add_layout(parent, EDJ_APP, "hour_hand");
+ evas_object_resize(hand, 360, 360);
+ evas_object_move(hand, 0, 0);
+
+ return hand;
+}
+
+static Evas_Object* __create_minute_hand(Evas_Object* parent)
+{
+ Evas_Object* hand = NULL;
+
+ hand = _add_layout(parent, EDJ_APP, "minute_hand");
+ evas_object_resize(hand, 360, 360);
+ evas_object_move(hand, 0, 0);
+
+ return hand;
+}
+
+static void __rotate(Evas_Object* obj, double degree)
+{
+ Evas_Map* map = evas_map_new(4);
+ evas_map_util_points_populate_from_object(map, obj);
+
+ Evas_Coord_Rectangle r = {0};
+ evas_object_geometry_get(obj, &r.x, &r.y, &r.w, &r.h);
+
+ evas_map_util_rotate(map, degree, r.x + r.w/2, r.y + r.h/2);
+
+ evas_object_map_set(obj, map);
+ evas_object_map_enable_set(obj, EINA_TRUE);
+ evas_map_free(map);
+}
+
+static void _set_analog(void *data)
+{
+ alpm_module_data *alpm_md = (alpm_module_data *)data;
+
+ if (alpm_md->ly_clock != NULL)
+ {
+ evas_object_del(alpm_md->ly_clock);
+ alpm_md->ly_clock = NULL;
+ }
+
+ alpm_md->ly_clock = _add_layout(alpm_md->ly_main, EDJ_APP, "analog");
+ elm_object_part_content_set(alpm_md->ly_main, "elm.swallow.body", alpm_md->ly_clock);
+
+ __rotate(__create_minute_hand(alpm_md->ly_clock), __get_minute_degree());
+ __rotate(__create_hour_hand(alpm_md->ly_clock), __get_hour_degree());
+
+ evas_object_show(alpm_md->ly_clock);
+}
+
+/**
+ * @brief Update ALPM UI.
+ * Evas Rendering will be done in alpm parent modules.
+ * So in alpm_module_update_clock(), just update clock infomation and add damage in evas object.
+ * @param[in] data : Evas Object pointer for elm_win.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+static int alpm_module_update_clock(void *module_ops, void *data)
+{
+ alpm_module_data *alpm_md;
+ alpm_clock_plugin_module_ops *ops;
+
+ _E("update clock!");
+
+ ops = (alpm_clock_plugin_module_ops *)module_ops;
+ if (!ops) {
+ _E("ops is NULL!!");
+ return -1;
+ }
+
+ if (!data) {
+ _E("data is NULL!!");
+ return -1;
+ }
+
+ alpm_md = ops->modules.priv;
+ if (!alpm_md) {
+ _E("alpm_md is NULL!");
+ return -1;
+ }
+
+ /* update time and rendering for ALPM clock */
+ _set_analog(alpm_md);
+
+ return ALPM_NEED_UPDATE;
+}
+
+/**
+ * @brief Initialize ALPM clock plugin module.
+ * @param[in] ops : plugin module ops.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+ALPM_CLOCK_PLUGIN_EXPORT_API int ALPM_CLOCK_PLUGIN_MODULE_INIT(alpm_clock_plugin_module_ops *ops)
+{
+ alpm_module_data *alpm_md;
+
+ _D("ALPM_CLOCK_PLUGIN_MODULE INIT!!");
+ if( !ops )
+ return -1;
+
+ alpm_md = calloc(1, sizeof(alpm_module_data));
+ if( !alpm_md )
+ return -1;
+
+ ops->modules.ui_runtime_plugin_init = alpm_module_init;
+ ops->modules.ui_runtime_plugin_deinit = alpm_module_deinit;
+ ops->modules.ui_runtime_plugin_update_clock = alpm_module_update_clock;
+ ops->modules.priv = alpm_md;
+
+ return 1;
+}
+
+/**
+ * @brief Exit ALPM clock plugin module.
+ * @param[in] ops : plugin module ops.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+ALPM_CLOCK_PLUGIN_EXPORT_API int ALPM_CLOCK_PLUGIN_MODULE_EXIT(alpm_clock_plugin_module_ops *ops)
+{
+ alpm_module_data *alpm_md;
+
+ _D("ALPM_CLOCK_PLUGIN_MODULE EXIT!!");
+ if( !ops )
+ return -1;
+
+ alpm_md = ops->modules.priv;
+ if( alpm_md )
+ free(alpm_md);
+
+ return 1;
+}
+
+/**
+ * @brief Update Locale information for ALPM clock plugin module.
+ * @param[in] ops : plugin module ops.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+ALPM_CLOCK_PLUGIN_EXPORT_API int ALPM_CLOCK_PLUGIN_MODULE_LOCALE_UPDATE(alpm_clock_plugin_module_ops *ops)
+{
+ alpm_module_data *alpm_md;
+
+ _D("ALPM_CLOCK_PLUGIN_MODULE_LOCALE_UPDATE!!");
+ if( !ops )
+ return -1;
+
+ alpm_md = ops->modules.priv;
+ if( !alpm_md )
+ return -1;
+
+ return 1;
+}
--- /dev/null
+/*
+ * W Clock Viewer
+ *
+ * Copyright (c) 2000 - 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 <glib.h>
+#include <stdio.h>
+#include <vconf.h>
+#include <vconf-keys.h>
+#include <math.h>
+
+#include "clock-viewer-plugin.h"
+#include "alpm.h"
+
+static Evas_Object *_add_layout(Evas_Object *parent, const char *file, const char *group)
+{
+ _D("%s", __func__);
+ Evas_Object *eo = NULL;
+ int r = -1;
+
+ retvm_if(parent == NULL, NULL, "Invalid argument: parent is NULL\n");
+ retvm_if(file == NULL, NULL, "Invalid argument: file is NULL\n");
+ retvm_if(group == NULL, NULL, "Invalid argument: group is NULL\n");
+
+ eo = elm_layout_add(parent);
+ retvm_if(eo == NULL, NULL, "Failed to add layout\n");
+
+ r = elm_layout_file_set(eo, file, group);
+ if (!r) {
+ _E("Failed to set file[%s]\n", file);
+ evas_object_del(eo);
+ return NULL;
+ }
+
+ evas_object_size_hint_weight_set(eo, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_show(eo);
+ return eo;
+}
+
+static char* __get_timezone(void)
+{
+ char buf[1024];
+ ssize_t len = readlink("/opt/etc/localtime", buf, sizeof(buf)-1);
+
+ if (len != -1) {
+ buf[len] = '\0';
+ }
+ else {
+ /* handle error condition */
+ _E("readlink() failed");
+ return vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_ID);
+ }
+ return strdup(buf+20);
+}
+
+static char *__get_locale(void)
+{
+ char *locale = vconf_get_str(VCONFKEY_REGIONFORMAT);
+ if(locale == NULL) {
+ _E("vconf_get_str() failed : region format");
+ return strdup("en_US");
+ }
+
+ char *str = NULL;
+ int count = 0;
+ gchar **ptr = NULL;
+ gchar **split_str = NULL;
+
+ split_str = g_strsplit(locale, ".", 0);
+
+ for(ptr = split_str; *ptr; ptr++) {
+ count++;
+ }
+
+ _D("count:%d", count);
+ _D("orig_locale:%s", locale);
+
+ if(count == 2) {
+ if(!strcmp(split_str[1], "UTF-8")) {
+ str = g_strdup_printf("%s", split_str[0]);
+ free(locale);
+ _D("dest_locale:%s", str);
+ g_strfreev(split_str);
+ return str;
+ } else {
+ g_strfreev(split_str);
+ return locale;
+ }
+ } else {
+ g_strfreev(split_str);
+ return locale;
+ }
+}
+
+static UDateTimePatternGenerator *__get_generator(void *data)
+{
+ _D("");
+
+ UErrorCode status = U_ZERO_ERROR;
+ UDateTimePatternGenerator *generator = NULL;
+
+ UChar u_skeleton[64] = {0,};
+
+ alpm_module_data *alpm_md = data;
+ retv_if(alpm_md == NULL, NULL);
+
+
+ uloc_setDefault(getenv("LC_TIME"), &status);
+ if (U_FAILURE(status)) {
+ _E("uloc_setDefault() is failed.");
+ return NULL;
+ }
+
+ u_uastrncpy(u_skeleton, "hhmm", strlen("hhmm"));
+
+ if(alpm_md->timeregion_format == NULL) {
+ alpm_md->timeregion_format = __get_locale();
+ }
+
+ generator = udatpg_open(alpm_md->timeregion_format, &status);
+ if(U_FAILURE(status)) {
+ _E("udatpg_open() failed");
+ generator = NULL;
+ return NULL;
+ }
+
+ _D("get_generator success");
+ return generator;
+}
+
+static UDateFormat *__get_time_formatter(void *data)
+{
+ _D("");
+
+ UErrorCode status = U_ZERO_ERROR;
+
+ UChar u_pattern[64] = {0,};
+ UChar u_timezone[64] = {0,};
+ UChar u_best_pattern[64] = {0,};
+ int32_t u_best_pattern_capacity;
+ UDateFormat *formatter = NULL;
+
+ alpm_module_data *alpm_md = data;
+ retv_if(alpm_md == NULL, NULL);
+
+ if(alpm_md->generator == NULL) {
+ alpm_md->generator = __get_generator(alpm_md);
+ }
+
+ /* only 12 format */
+ if(u_uastrncpy(u_pattern, "h:mm", sizeof(u_pattern)) == NULL) {
+ _E("u_uastrncpy() is failed.");
+ return NULL;
+ }
+
+ u_best_pattern_capacity =
+ (int32_t) (sizeof(u_best_pattern) / sizeof((u_best_pattern)[0]));
+
+ udatpg_getBestPattern(alpm_md->generator, u_pattern, u_strlen(u_pattern),
+ u_best_pattern, u_best_pattern_capacity, &status);
+ if(U_FAILURE(status)) {
+ _E("udatpg_getBestPattern() failed");
+ return NULL;
+ }
+
+ /* remove am/pm of best pattern */
+ char a_best_pattern[64] = {0.};
+ char *buffer = NULL;
+ u_austrcpy(a_best_pattern, u_best_pattern);
+ _D("best pattern [%s]", a_best_pattern);
+ char *a_best_pattern_fixed = strtok_r(a_best_pattern, "a", &buffer);
+ a_best_pattern_fixed = strtok_r(a_best_pattern_fixed, " ", &buffer);
+ _D("best pattern fixed [%s]", a_best_pattern_fixed);
+
+ if(a_best_pattern_fixed) {
+ /* exception - da_DK */
+ if(strncmp(alpm_md->timeregion_format, "da_DK", 5) == 0
+ || strncmp(alpm_md->timeregion_format, "mr_IN", 5) == 0){
+
+ char *a_best_pattern_changed = g_strndup("h:mm", 4);
+ _D("best pattern is changed [%s]", a_best_pattern_changed);
+ if(a_best_pattern_changed) {
+ u_uastrcpy(u_best_pattern, a_best_pattern_changed);
+ g_free(a_best_pattern_changed);
+ }
+ }
+ else {
+ u_uastrcpy(u_best_pattern, a_best_pattern_fixed);
+ }
+ }
+
+ /* change char to UChar */
+ u_strncpy(u_pattern, u_best_pattern, sizeof(u_pattern));
+
+ /* get formatter */
+ u_uastrncpy(u_timezone, alpm_md->timezone_id, sizeof(u_timezone));
+ formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, alpm_md->timeregion_format, u_timezone, -1,
+ u_pattern, -1, &status);
+ if (U_FAILURE(status)) {
+ _E("udat_open() is failed.");
+ return NULL;
+ }
+
+ _D("getting time formatter success");
+ return formatter;
+}
+
+static UDateFormat *__get_time_formatter_24(void *data)
+{
+ _D("");
+
+ UErrorCode status = U_ZERO_ERROR;
+
+ UChar u_pattern[64] = {0,};
+ UChar u_timezone[64] = {0,};
+ UChar u_best_pattern[64] = {0,};
+ int32_t u_best_pattern_capacity;
+ UDateFormat *formatter = NULL;
+
+ alpm_module_data *alpm_md = data;
+ retv_if(alpm_md == NULL, NULL);
+
+ if(alpm_md->generator == NULL) {
+ alpm_md->generator = __get_generator(alpm_md);
+ }
+
+ /* only 12 format */
+ if(u_uastrncpy(u_pattern, "H:mm", sizeof(u_pattern)) == NULL) {
+ _E("u_uastrncpy() is failed.");
+ return NULL;
+ }
+
+ u_best_pattern_capacity =
+ (int32_t) (sizeof(u_best_pattern) / sizeof((u_best_pattern)[0]));
+
+ udatpg_getBestPattern(alpm_md->generator, u_pattern, u_strlen(u_pattern),
+ u_best_pattern, u_best_pattern_capacity, &status);
+ if(U_FAILURE(status)) {
+ _E("udatpg_getBestPattern() failed");
+ return NULL;
+ }
+
+ /* remove am/pm of best pattern */
+ char a_best_pattern[64] = {0.};
+ char *buffer = NULL;
+ u_austrcpy(a_best_pattern, u_best_pattern);
+ _D("best pattern [%s]", a_best_pattern);
+ char *a_best_pattern_fixed = strtok_r(a_best_pattern, "a", &buffer);
+ a_best_pattern_fixed = strtok_r(a_best_pattern_fixed, " ", &buffer);
+ _D("best pattern fixed [%s]", a_best_pattern_fixed);
+
+ if(a_best_pattern_fixed) {
+ /* exception - pt_BR(HH'h'mm), id_ID, da_DK */
+ if(strncmp(a_best_pattern_fixed, "HH'h'mm", 7) == 0
+ || strncmp(alpm_md->timeregion_format, "id_ID", 5) == 0
+ || strncmp(alpm_md->timeregion_format, "da_DK", 5) == 0
+ || strncmp(alpm_md->timeregion_format, "mr_IN", 5) == 0){
+
+ char *a_best_pattern_changed = g_strndup("HH:mm", 5);
+ _D("best pattern is changed [%s]", a_best_pattern_changed);
+ if(a_best_pattern_changed) {
+ u_uastrcpy(u_best_pattern, a_best_pattern_changed);
+ g_free(a_best_pattern_changed);
+ }
+ }
+ else {
+ u_uastrcpy(u_best_pattern, a_best_pattern_fixed);
+ }
+ }
+
+ /* change char to UChar */
+ u_strncpy(u_pattern, u_best_pattern, sizeof(u_pattern));
+
+ /* get formatter */
+ u_uastrncpy(u_timezone, alpm_md->timezone_id, sizeof(u_timezone));
+ formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, alpm_md->timeregion_format, u_timezone, -1,
+ u_pattern, -1, &status);
+ if (U_FAILURE(status)) {
+ _E("udat_open() is failed.");
+ return NULL;
+ }
+
+ _D("getting time formatter success");
+ return formatter;
+}
+
+static UDateFormat *__get_date_formatter(void *data)
+{
+ _D("");
+
+ UErrorCode status = U_ZERO_ERROR;
+ UChar u_timezone[64] = {0,};
+ UChar u_skeleton[64] = {0,};
+ int skeleton_len = 0;
+
+ UChar u_best_pattern[64] = {0,};
+ int32_t u_best_pattern_capacity;
+ UDateFormat *formatter = NULL;
+
+ alpm_module_data *alpm_md = data;
+ retv_if(alpm_md == NULL, NULL);
+
+ u_uastrncpy(u_skeleton, "MMMEd", strlen("MMMEd"));
+ skeleton_len = u_strlen(u_skeleton);
+
+ u_best_pattern_capacity =
+ (int32_t) (sizeof(u_best_pattern) / sizeof((u_best_pattern)[0]));
+ udatpg_getBestPattern(alpm_md->generator, u_skeleton, skeleton_len,
+ u_best_pattern, u_best_pattern_capacity, &status);
+ if(U_FAILURE(status)) {
+ _E("udatpg_getBestPattern() failed");
+ return NULL;
+ }
+
+ if(strncmp(alpm_md->timeregion_format, "fi_FI", 5) == 0) {
+ char *a_best_pattern_changed = g_strndup("ccc, d. MMM", 11);
+ _D("date formatter best pattern is changed [%s]", a_best_pattern_changed);
+ if(a_best_pattern_changed) {
+ u_uastrcpy(u_best_pattern, a_best_pattern_changed);
+ g_free(a_best_pattern_changed);
+ }
+ }
+
+ /* get formatter */
+ u_uastrncpy(u_timezone, alpm_md->timezone_id, sizeof(u_timezone));
+ formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, alpm_md->timeregion_format, u_timezone, -1,
+ u_best_pattern, -1, &status);
+ if (U_FAILURE(status)) {
+ _E("udat_open() is failed.");
+ return NULL;
+ }
+
+ _D("getting date formatter success");
+
+ return formatter;
+
+}
+
+
+static UDateFormat *__get_ampm_formatter(void *data)
+{
+ _D("");
+
+ UErrorCode status = U_ZERO_ERROR;
+
+ char a_best_pattern[64] = {0.};
+
+ UChar u_timezone[64] = {0,};
+ UChar u_skeleton[64] = {0,};
+ int skeleton_len = 0;
+
+ UChar u_best_pattern[64] = {0,};
+ int32_t u_best_pattern_capacity;
+ UDateFormat *formatter = NULL;
+
+ alpm_module_data *alpm_md = data;
+ retv_if(alpm_md == NULL, NULL);
+
+ u_uastrncpy(u_skeleton, "hhmm", strlen("hhmm"));
+ skeleton_len = u_strlen(u_skeleton);
+
+ u_best_pattern_capacity =
+ (int32_t) (sizeof(u_best_pattern) / sizeof((u_best_pattern)[0]));
+ udatpg_getBestPattern(alpm_md->generator, u_skeleton, skeleton_len,
+ u_best_pattern, u_best_pattern_capacity, &status);
+ if(U_FAILURE(status)) {
+ _E("udatpg_getBestPattern() failed");
+ return NULL;
+ }
+
+ u_austrcpy(a_best_pattern, u_best_pattern);
+ u_uastrcpy(u_best_pattern, "a");
+
+ if(a_best_pattern[0] == 'a') {
+ alpm_md->is_pre = EINA_TRUE;
+ } else {
+ alpm_md->is_pre = EINA_FALSE;
+ }
+
+ /* get formatter */
+ u_uastrncpy(u_timezone, alpm_md->timezone_id, sizeof(u_timezone));
+ formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, alpm_md->timeregion_format, u_timezone, -1,
+ u_best_pattern, -1, &status);
+ if (U_FAILURE(status)) {
+ _E("udat_open() is failed.");
+ return NULL;
+ }
+
+ _D("getting ampm formatter success");
+
+ return formatter;
+
+}
+
+static UChar *uastrcpy(const char *chars)
+{
+ int len = 0;
+ UChar *str = NULL;
+ len = strlen(chars);
+ str = (UChar *) malloc(sizeof(UChar) *(len + 1));
+ if (!str)
+ return NULL;
+ u_uastrcpy(str, chars);
+ return str;
+}
+
+static void __set_icu_timezone(const char *timezone)
+{
+ _D("%s", __func__);
+ if(timezone == NULL) {
+ _E("TIMEZONE is NULL");
+ return;
+ }
+
+ UErrorCode ec = U_ZERO_ERROR;
+ UChar *str = uastrcpy(timezone);
+
+ if (!str) {
+ _E("Failed to string about timezone");
+ return;
+ }
+
+ ucal_setDefaultTimeZone(str, &ec);
+ if (U_SUCCESS(ec)) {
+ } else {
+ _E("ucal_setDefaultTimeZone() FAILED : %s ",
+ u_errorName(ec));
+ }
+ free(str);
+}
+
+static void __set_formatters(void *data)
+{
+ alpm_module_data *alpm_md = data;
+ ret_if(alpm_md == NULL);
+
+ /* generator */
+ alpm_md->generator = __get_generator(alpm_md);
+ /* time formatter */
+ alpm_md->formatter_time = __get_time_formatter(alpm_md);
+ /* ampm formatter */
+ alpm_md->formatter_ampm = __get_ampm_formatter(alpm_md);
+ /* 24 time formatter */
+ alpm_md->formatter_time_24 = __get_time_formatter_24(alpm_md);
+ /* date formatter */
+ alpm_md->formatter_date = __get_date_formatter(alpm_md);
+}
+
+static void __remove_formatters(void *data)
+{
+ alpm_module_data *alpm_md = data;
+ ret_if(alpm_md == NULL);
+
+ if(alpm_md->generator) {
+ udat_close(alpm_md->generator);
+ alpm_md->generator = NULL;
+ }
+ if(alpm_md->formatter_time) {
+ udat_close(alpm_md->formatter_time);
+ alpm_md->formatter_time = NULL;
+ }
+ if(alpm_md->formatter_ampm) {
+ udat_close(alpm_md->formatter_ampm);
+ alpm_md->formatter_ampm = NULL;
+ }
+ if(alpm_md->formatter_time_24) {
+ udat_close(alpm_md->formatter_time_24);
+ alpm_md->formatter_time_24 = NULL;
+ }
+ if(alpm_md->formatter_date) {
+ udat_close(alpm_md->formatter_date);
+ alpm_md->formatter_date = NULL;
+ }
+}
+/**
+ * @brief Initialize ALPM UI.
+ * @param[in] data : Evas Object pointer for elm_win.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+static int alpm_module_init(void *module_ops, void *data)
+{
+ alpm_module_data *alpm_md;
+ alpm_clock_plugin_module_ops *ops;
+
+ _E("module init!!");
+ ops = (alpm_clock_plugin_module_ops *)module_ops;
+ if (!ops) {
+ _E("ops is NULL!!");
+ return -1;
+ }
+
+ if(!data) {
+ _E("data is NULL!!");
+ return -1;
+ }
+
+ alpm_md = ops->modules.priv;
+ if(!alpm_md) {
+ _E("alpm_md is NULL!");
+ return -1;
+ }
+
+ alpm_md->parent = (Evas_Object *)data;
+
+ /* Implement main layout for ALPM clock */
+ //Add BG
+ if (!alpm_md->bg) {
+ alpm_md->bg = elm_bg_add(alpm_md->parent);
+ evas_object_size_hint_weight_set(alpm_md->bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_win_resize_object_add(alpm_md->parent, alpm_md->bg);
+ evas_object_show(alpm_md->bg);
+ }
+
+ //Create main layout
+ if (!alpm_md->ly_main) {
+ alpm_md->ly_main = _add_layout(alpm_md->parent, EDJ_APP, "layout_clock_position");
+ evas_object_size_hint_weight_set(alpm_md->ly_main, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_win_resize_object_add(alpm_md->parent, alpm_md->ly_main);
+ }
+
+ alpm_md->timezone_id = __get_timezone();
+ __set_icu_timezone(alpm_md->timezone_id);
+ alpm_md->timeregion_format = __get_locale();
+ vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &alpm_md->timeformat);
+
+ _D("[%d][%s][%s]", alpm_md->timeformat, alpm_md->timeregion_format, alpm_md->timezone_id);
+
+ __remove_formatters(alpm_md);
+ __set_formatters(alpm_md);
+
+ return 1;
+}
+
+/**
+ * @brief clean up ALPM UI.
+ * @param[in] data : Evas Object pointer for elm_win.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+static int alpm_module_deinit(void *module_ops, void *data)
+{
+ alpm_module_data *alpm_md;
+ alpm_clock_plugin_module_ops *ops;
+
+ _E("module deinit!!");
+
+ ops = (alpm_clock_plugin_module_ops *)module_ops;
+ if (!ops) {
+ _E("ops is NULL!!");
+ return -1;
+ }
+
+ if (!data) {
+ _E("data is NULL!!");
+ return -1;
+ }
+
+ alpm_md = ops->modules.priv;
+ if(!alpm_md) {
+ _E("alpm_md is NULL!");
+ return -1;
+ }
+
+ /* destroy main layout for ALPM clock */
+ FREEIF(alpm_md->timezone_id);
+ FREEIF(alpm_md->timeregion_format);
+ __remove_formatters(alpm_md);
+
+ if (alpm_md->bg) {
+ evas_object_del(alpm_md->bg);
+ }
+ if (alpm_md->ly_main) {
+ evas_object_del(alpm_md->ly_main);
+ }
+
+ if (ops->modules.priv) {
+ free(ops->modules.priv);
+ ops->modules.priv = NULL;
+ alpm_md = NULL;
+ }
+
+ return 1;
+}
+
+static int __get_formatted_ampm_from_utc_time(void *data, time_t intime, char *buf, int buf_len, int *ampm_len)
+{
+ alpm_module_data *alpm_md = (alpm_module_data *)data;
+ retv_if(alpm_md == NULL, -1);
+ retv_if(alpm_md->formatter_ampm == NULL, -1);
+
+ UDate u_time = (UDate)intime * 1000;
+ UChar u_formatted_str[64] = {0,};
+ int32_t u_formatted_str_capacity;
+ int formatted_str_len = -1;
+ UErrorCode status = U_ZERO_ERROR;
+
+ /* calculate formatted string capacity */
+ u_formatted_str_capacity =
+ (int32_t)(sizeof(u_formatted_str) / sizeof((u_formatted_str)[0]));
+
+ /* fomatting date using formatter */
+ formatted_str_len = udat_format(alpm_md->formatter_ampm, u_time, u_formatted_str, u_formatted_str_capacity,
+ NULL, &status);
+ if(U_FAILURE(status)) {
+ _E("udat_format() failed");
+ return -1;
+ }
+
+ if(formatted_str_len <= 0)
+ _E("formatted_str_len is less than 0");
+
+ (*ampm_len) = u_strlen(u_formatted_str);
+
+ buf = u_austrncpy(buf, u_formatted_str, buf_len);
+ _SECURE_D("ampm:(%d)[%s][%d]", formatted_str_len, buf, intime);
+
+ return 0;
+}
+static int __get_formatted_time_from_utc_time(void *data, time_t intime, char *buf, int buf_len, Eina_Bool is_time_24)
+{
+ alpm_module_data *alpm_md = (alpm_module_data *)data;
+ retv_if(alpm_md == NULL, -1);
+
+ UDate u_time = (UDate)intime * 1000;
+ UChar u_formatted_str[64] = {0,};
+ int32_t u_formatted_str_capacity;
+ int formatted_str_len = -1;
+ UErrorCode status = U_ZERO_ERROR;
+
+ /* calculate formatted string capacity */
+ u_formatted_str_capacity =
+ (int32_t)(sizeof(u_formatted_str) / sizeof((u_formatted_str)[0]));
+
+ /* fomatting date using formatter */
+ if(is_time_24) {
+ retv_if(alpm_md->formatter_time_24 == NULL, -1);
+ formatted_str_len = udat_format(alpm_md->formatter_time_24, u_time, u_formatted_str, u_formatted_str_capacity,
+ NULL, &status);
+ } else {
+ retv_if(alpm_md->formatter_time == NULL, -1);
+ formatted_str_len = udat_format(alpm_md->formatter_time, u_time, u_formatted_str, u_formatted_str_capacity,
+ NULL, &status);
+ }
+ if(U_FAILURE(status)) {
+ _E("udat_format() failed");
+ return -1;
+ }
+
+ if(formatted_str_len <= 0)
+ _E("formatted_str_len is less than 0");
+
+ buf = u_austrncpy(buf, u_formatted_str, buf_len);
+ _SECURE_D("time:(%d)[%s][%d]", formatted_str_len, buf, intime);
+
+ return 0;
+}
+
+static void _get_random_distance(int radius, int* dx, int* dy)
+{
+ srand(time(NULL));
+
+ unsigned int seed = time(NULL);
+ int random = rand_r(&seed);
+
+ *dx = (int)round(sin(random) * radius);
+ *dy = (int)round(cos(random) * radius);
+}
+
+static void _get_random_position(const int radius, const int width, const int height, int* position_x, int* position_y)
+{
+ if (!position_x || !position_y)
+ return;
+
+ int dx = 0;
+ int dy = 0;
+ _get_random_distance(radius, &dx, &dy);
+
+ const int center_x = 180 - width / 2;
+ const int center_y = 180 - height / 2;
+
+ *position_x = center_x + dx;
+ *position_y = center_y + dy;
+}
+
+static void _set_info_time(void *data)
+{
+ alpm_module_data *alpm_md = (alpm_module_data *)data;
+ if (alpm_md == NULL) {
+ _D("appdata is NULL");
+ return;
+ }
+
+ struct tm ts;
+ struct tm *ret_tm = NULL;
+ time_t tt;
+ char bf1[32] = { 0, };
+ int hour, minute;
+ int err_code = 0;
+ int regionformat_value = 0;
+
+ tt = time(NULL);
+ ret_tm = localtime_r(&tt, &ts);
+ if (!ret_tm) {
+ _E("Failed to get the local time");
+ return;
+ }
+
+ _D("TIME[%d]:[%d] DAY[%d]", ts.tm_hour, ts.tm_min, ts.tm_mday);
+
+ /* if %l is 1 ~9, it has blank space in front. Trim it using atoi function */
+ strftime(bf1, sizeof(bf1), "%H", &ts);
+ hour = atoi(bf1);
+ _D("hour %d", hour);
+ strftime(bf1, sizeof(bf1), "%M", &ts);
+ minute = atoi(bf1);
+ _D("minute %d", minute);
+
+ err_code = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, ®ionformat_value);
+ if(err_code != 0) {
+ _E("vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224) error");
+ }
+
+ if (alpm_md->ly_clock) {
+ evas_object_del(alpm_md->ly_clock);
+ alpm_md->ly_clock = NULL;
+ }
+
+ alpm_md->ly_clock = _add_layout(alpm_md->ly_main, EDJ_APP, "layout_clock_tb");
+ edje_object_signal_emit(elm_layout_edje_get(alpm_md->ly_main), "elm.swallow.body.middle4", "elm.swallow.body");
+
+ char utc_time[256] = { 0 };
+ char utc_ampm[256] = { 0 };
+ int ampm_length = 0;
+ Eina_Bool is_pre = alpm_md->is_pre;
+ Eina_Bool is_24hour = EINA_FALSE;
+
+ if(alpm_md->timeformat == VCONFKEY_TIME_FORMAT_12) {
+ __get_formatted_ampm_from_utc_time(alpm_md, tt, utc_ampm, sizeof(utc_ampm), &m_length);
+ __get_formatted_time_from_utc_time(alpm_md, tt, utc_time, sizeof(utc_time), EINA_FALSE);
+ is_24hour = EINA_FALSE;
+ } else {
+ __get_formatted_time_from_utc_time(alpm_md, tt, utc_time, sizeof(utc_time), EINA_TRUE);
+ is_24hour = EINA_TRUE;
+ }
+
+ _D("utc_time=%s, utc_ampm=[%d]%s", utc_time, ampm_length, utc_ampm);
+
+ if(ampm_length >= 3) {
+ _D("AM PM string is too long, changed to default AM/PM");
+
+ if(strncmp(alpm_md->timeregion_format, "fa", 2) == 0)
+ {
+ _D("In Farsi, AM/PM text abbreviated.");
+
+ if (ts.tm_hour >= 0 && ts.tm_hour < 12)
+ snprintf(utc_ampm, sizeof(utc_ampm), "%s", "ق.ظ");
+ else
+ snprintf(utc_ampm, sizeof(utc_ampm), "%s", "ب.ظ");
+ }
+ else
+ {
+ if (ts.tm_hour >= 0 && ts.tm_hour < 12)
+ snprintf(utc_ampm, sizeof(utc_ampm), "%s", "AM");
+ else
+ snprintf(utc_ampm, sizeof(utc_ampm), "%s", "PM");
+ }
+ }
+
+ char *time_str = NULL;
+
+ if(is_24hour == EINA_TRUE){
+ time_str = g_strdup_printf("%s", utc_time);
+ }
+ else {
+ if(is_pre== EINA_TRUE)
+ time_str = g_strdup_printf("<font_size=32><font=SamsungSans:style=Regular>%s</font></font_size>%s", utc_ampm, utc_time);
+ else {
+ time_str = g_strdup_printf("%s<font_size=32><font=SamsungSans:style=Regular> %s</font></font_size>", utc_time, utc_ampm);
+ }
+ }
+ _D("time_str=%s", time_str);
+
+ elm_object_part_text_set(alpm_md->ly_clock, "text.clock", time_str);
+
+ g_free(time_str);
+
+ // radius can be modified if text is not clipped.
+ const int movable_radius = 40;
+ //TODO need to set as exact size
+ const int width = 280;
+ const int height = 100;
+ evas_object_resize(alpm_md->ly_clock, width, height);
+
+ int position_x = 0;
+ int position_y = 0;
+ _get_random_position(movable_radius, width, height, &position_x, &position_y);
+ evas_object_move(alpm_md->ly_clock, position_x, position_y);
+
+ evas_object_show(alpm_md->ly_clock);
+}
+
+/**
+ * @brief Update ALPM UI.
+ * Evas Rendering will be done in alpm parent modules.
+ * So in alpm_module_update_clock(), just update clock infomation and add damage in evas object.
+ * @param[in] data : Evas Object pointer for elm_win.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+static int alpm_module_update_clock(void *module_ops, void *data)
+{
+ alpm_module_data *alpm_md;
+ alpm_clock_plugin_module_ops *ops;
+
+ _E("update clock!");
+
+ ops = (alpm_clock_plugin_module_ops *)module_ops;
+ if (!ops) {
+ _E("ops is NULL!!");
+ return -1;
+ }
+
+ if (!data) {
+ _E("data is NULL!!");
+ return -1;
+ }
+
+ alpm_md = ops->modules.priv;
+ if (!alpm_md) {
+ _E("alpm_md is NULL!");
+ return -1;
+ }
+
+ /* update time and rendering for ALPM clock */
+ _set_info_time(alpm_md);
+
+ return ALPM_NEED_UPDATE;
+}
+
+/**
+ * @brief Initialize ALPM clock plugin module.
+ * @param[in] ops : plugin module ops.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+ALPM_CLOCK_PLUGIN_EXPORT_API int ALPM_CLOCK_PLUGIN_MODULE_INIT(alpm_clock_plugin_module_ops *ops)
+{
+ alpm_module_data *alpm_md;
+
+ _D("ALPM_CLOCK_PLUGIN_MODULE INIT!!");
+ if( !ops )
+ return -1;
+
+ alpm_md = calloc(1, sizeof(alpm_module_data));
+ if( !alpm_md )
+ return -1;
+
+ ops->modules.ui_runtime_plugin_init = alpm_module_init;
+ ops->modules.ui_runtime_plugin_deinit = alpm_module_deinit;
+ ops->modules.ui_runtime_plugin_update_clock = alpm_module_update_clock;
+ ops->modules.priv = alpm_md;
+
+ return 1;
+}
+
+/**
+ * @brief Exit ALPM clock plugin module.
+ * @param[in] ops : plugin module ops.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+ALPM_CLOCK_PLUGIN_EXPORT_API int ALPM_CLOCK_PLUGIN_MODULE_EXIT(alpm_clock_plugin_module_ops *ops)
+{
+ alpm_module_data *alpm_md;
+
+ _D("ALPM_CLOCK_PLUGIN_MODULE EXIT!!");
+ if( !ops )
+ return -1;
+
+ alpm_md = ops->modules.priv;
+ if( alpm_md )
+ free(alpm_md);
+
+ return 1;
+}
+
+/**
+ * @brief Update Locale information for ALPM clock plugin module.
+ * @param[in] ops : plugin module ops.
+ * @return return -1 if an error occurred. Otherwise return 1.
+ */
+ALPM_CLOCK_PLUGIN_EXPORT_API int ALPM_CLOCK_PLUGIN_MODULE_LOCALE_UPDATE(alpm_clock_plugin_module_ops *ops)
+{
+ alpm_module_data *alpm_md;
+
+ _D("ALPM_CLOCK_PLUGIN_MODULE_LOCALE_UPDATE!!");
+ if( !ops )
+ return -1;
+
+ alpm_md = ops->modules.priv;
+ if( !alpm_md )
+ return -1;
+
+ /* Update locale information. */
+ if( alpm_md->timezone_id ) {
+ free(alpm_md->timezone_id);
+ alpm_md->timezone_id = NULL;
+ }
+ if( alpm_md->timeregion_format ) {
+ free(alpm_md->timeregion_format);
+ alpm_md->timeregion_format = NULL;
+ }
+
+ alpm_md->timezone_id = __get_timezone();
+ __set_icu_timezone(alpm_md->timezone_id);
+ alpm_md->timeregion_format = __get_locale();
+ vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &alpm_md->timeformat);
+
+ _D("[%d][%s][%s]", alpm_md->timeformat, alpm_md->timeregion_format, alpm_md->timezone_id);
+
+ __remove_formatters(alpm_md);
+ __set_formatters(alpm_md);
+
+ return 1;
+}
+
--- /dev/null
+Name: org.tizen.w-clock-viewer
+Summary: Clock viewer for the wearable devices
+Version: 0.0.1
+Release: 1
+Group: Applications/System
+License: Apache-2.0
+Source0: %{name}-%{version}.tar.gz
+
+BuildRequires: pkgconfig(capi-appfw-application)
+BuildRequires: pkgconfig(capi-system-device)
+BuildRequires: pkgconfig(elementary)
+BuildRequires: pkgconfig(minicontrol-monitor)
+BuildRequires: pkgconfig(minicontrol-viewer)
+BuildRequires: pkgconfig(minicontrol-handler)
+BuildRequires: pkgconfig(widget_viewer_evas)
+BuildRequires: pkgconfig(widget_service)
+BuildRequires: pkgconfig(alarm-service)
+BuildRequires: pkgconfig(pkgmgr-info)
+BuildRequires: pkgconfig(vconf)
+BuildRequires: pkgconfig(dlog)
+BuildRequires: edje-bin
+
+BuildRequires: cmake
+BuildRequires: model-build-features
+BuildRequires: hash-signer
+
+%description
+Clock viewer for wearable devices
+
+%prep
+%setup -q
+
+%define PREFIX /usr/apps/%{name}
+%define DATADIR /opt%{PREFIX}/data
+
+%build
+%if 0%{?tizen_build_binary_release_type_eng}
+export CFLAGS="$CFLAGS -DTIZEN_ENGINEER_MODE"
+export CXXFLAGS="$CXXFLAGS -DTIZEN_ENGINEER_MODE"
+export FFLAGS="$FFLAGS -DTIZEN_ENGINEER_MODE"
+%endif
+
+%if 0%{?sec_build_binary_debug_enable}
+export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE"
+export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE"
+export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE"
+%endif
+
+RPM_OPT=`echo $CFLAGS|sed 's/-Wp,-D_FORTIFY_SOURCE=2//'`
+export CFLAGS=$RPM_OPT
+cmake -DCMAKE_INSTALL_PREFIX="%{PREFIX}"
+make %{?jobs:-j%jobs}
+
+%install
+rm -rf %{buildroot}
+%make_install
+mkdir -p %{buildroot}/usr/share/license
+
+%define tizen_sign 1
+%define tizen_sign_base /usr/apps/%{name}
+%define tizen_sign_level platform
+%define tizen_author_sign 1
+%define tizen_dist_sign 1
+
+%post
+/usr/bin/signing-client/hash-signer-client.sh -a -d -p platform /usr/apps/%{name}
+
+INHOUSE_ID="5000"
+SETTING_LABEL="tizen::vconf::setting::admin"
+
+vconftool set -t int "memory/clock_viewer/clock_visibility" 0 -i -g $INHOUSE_ID -f -s $SETTING_LABEL
+vconftool set -t int "memory/clock_viewer/lcdon" 0 -i -g $INHOUSE_ID -f -s $SETTING_LABEL
+vconftool set -t int "memory/clock_viewer/lcdoff" 0 -i -g $INHOUSE_ID -f -s $SETTING_LABEL
+vconftool set -t int "memory/clock_viewer/clockdraw" 0 -i -g $INHOUSE_ID -f -s $SETTING_LABEL
+
+%files
+%manifest clock-viewer/%{name}.manifest
+%defattr(-,root,root,-)
+/usr/share/license/%{name}
+/usr/share/packages/%{name}.xml
+/etc/smack/accesses.d/%{name}.rule
+%{PREFIX}/*.xml
+%{PREFIX}/bin/*
+%{PREFIX}/res/*
+%{PREFIX}/shared/*
projects / apps / home / w-clock-viewer.git / commitdiff
