2 * Copyright (c) 2018 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
23 #include "watchface-complication/include/watchface-editable.h"
24 #include "watchface-complication/include/watchface-editable-internal.h"
25 #include "watchface-complication/editables-container.hh"
26 #include "watchface-complication/design-element.hh"
27 #include "watchface-common/shared-handle.hh"
28 #include "watchface-complication/editables-manager.hh"
29 #include "watchface-common/watchface-util.hh"
30 #include "watchface-common/watchface-exception.hh"
36 #define LOG_TAG "WATCHFACE_COMPLICATION"
38 #define CANDIDATE_ID_KEY "__CANDIDATE_ID_KEY__"
39 #define CANDIDATE_NAME_KEY "__CANDIDATE_NAME_KEY__"
40 #define CANDIDATE_COLOR_R_KEY "__CANDIDATE_COLOR_R_KEY__"
41 #define CANDIDATE_COLOR_G_KEY "__CANDIDATE_COLOR_G_KEY__"
42 #define CANDIDATE_COLOR_B_KEY "__CANDIDATE_COLOR_B_KEY__"
43 #define CANDIDATE_COLOR_A_KEY "__CANDIDATE_COLOR_A_KEY__"
44 #define CANDIDATE_PREVIEW_IMAGE_KEY "__CANDIDATE_PREVIEW_IMAGE_KEY__"
47 using namespace tizen_base;
48 using namespace watchface_complication;
49 struct complication_candidates_list_ {
50 GList* candidates_list;
53 struct editable_color_ {
60 class ReadyCallbackInfo {
62 ReadyCallbackInfo(watchface_editable_edit_ready_cb cb, void* user_data)
63 : cb_(cb), user_data_(user_data) {
66 ReadyCallbackInfo(ReadyCallbackInfo&& b) noexcept {
68 user_data_ = b.user_data_;
70 b.user_data_ = nullptr;
73 void Invoke(void* stub, const std::string& editor_appid) {
74 cb_(stub, editor_appid.c_str(), user_data_);
77 watchface_editable_edit_ready_cb GetCallback() {
82 watchface_editable_edit_ready_cb cb_;
86 class UpdateCallbackInfo {
88 UpdateCallbackInfo(watchface_editable_update_requested_cb cb, void* user_data)
89 : cb_(cb), user_data_(user_data) {
92 UpdateCallbackInfo(UpdateCallbackInfo&& b) noexcept {
94 user_data_ = b.user_data_;
96 b.user_data_ = nullptr;
99 void Invoke(const void* handle, int selected_idx,
100 const watchface_editable_edit_state_e state) {
102 cb_(const_cast<void*>(handle), selected_idx, state, user_data_);
106 watchface_editable_update_requested_cb cb_;
110 class EditablesContainerStub : public EditablesContainer {
112 EditablesContainerStub()
113 : EditablesContainer() {
116 void OnEditReady(const std::string& editor_id) override {
117 for (auto& i : ready_cb_list_) {
118 i->Invoke(static_cast<void*>(this), editor_id);
120 LOGI("On edit call!! ready !!");
123 void OnUpdate(shared_ptr<IEditable> ed, int selected_idx,
124 IEditable::EditableState state) override {
125 SharedHandle<IEditable>* ptr = SharedHandle<IEditable>::Make(ed);
126 for (auto& i : update_cb_list_) {
127 i->Invoke(static_cast<const void*>(ptr), selected_idx,
128 static_cast<const watchface_editable_edit_state_e>(state));
133 int AddReadyCallbackInfo(unique_ptr<ReadyCallbackInfo> ci) {
134 for (auto& i : ready_cb_list_) {
135 if (i.get()->GetCallback() == ci->GetCallback()) {
136 LOGI("already registered callback");
137 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
141 ready_cb_list_.emplace_back(move(ci));
142 return WATCHFACE_COMPLICATION_ERROR_NONE;
145 int RemoveReadyCallbackInfo(watchface_editable_edit_ready_cb ci) {
146 for (auto& i : ready_cb_list_) {
147 if (i.get()->GetCallback() == ci) {
148 ready_cb_list_.remove(i);
149 return WATCHFACE_COMPLICATION_ERROR_NONE;
152 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
155 void ClearUpdateCallbackInfo() {
156 update_cb_list_.clear();
159 void AddUpdateCallbackInfo(unique_ptr<UpdateCallbackInfo> ci) {
160 update_cb_list_.emplace_back(move(ci));
164 std::list<std::unique_ptr<ReadyCallbackInfo>> ready_cb_list_;
165 std::list<std::unique_ptr<UpdateCallbackInfo>> update_cb_list_;
168 static EditablesContainerStub* __container;
170 extern "C" EXPORT_API int watchface_editable_add_design_element(
171 watchface_editable_container_h handle, int edit_id, int cur_data_idx,
172 complication_candidates_list_h list_handle,
173 watchface_editable_highlight_h highlight, const char* editable_name) {
174 if (!watchface_complication::util::CheckWatchFeatureEnabled())
175 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
177 if (handle == nullptr || list_handle == nullptr || editable_name == nullptr ||
178 list_handle->candidates_list == nullptr)
179 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
181 if (cur_data_idx < 0 ||
182 cur_data_idx >= static_cast<int>(
183 g_list_length(list_handle->candidates_list)))
184 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
186 EditablesContainerStub* ec = static_cast<EditablesContainerStub*>(handle);
187 GList* iter = list_handle->candidates_list;
188 std::list<std::shared_ptr<Bundle>> new_list;
190 for (; iter; iter = iter->next) {
191 bundle* data = reinterpret_cast<bundle*>(iter->data);
196 new_list.emplace_back(new Bundle(data));
197 } catch (const std::exception& e) {
198 LOGE("Exception occurred : %s", e.what());
199 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
203 if (ec->IsExist(edit_id)) {
204 LOGE("ID already exist");
205 return WATCHFACE_COMPLICATION_ERROR_EXIST_ID;
209 auto de = std::shared_ptr<IEditable>(
210 new DesignElement(edit_id, cur_data_idx));
212 /* Highlight should be copied */
213 IEditable::Highlight* high =
214 ((SharedHandle<IEditable::Highlight>*)highlight)->GetRawPtr();
215 de.get()->SetHighlight(
216 shared_ptr<IEditable::Highlight>(new IEditable::Highlight(*high)));
219 de.get()->SetLabel(std::string(editable_name));
220 int ret = de.get()->SetCandidates(new_list);
221 if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
224 ec->Add(de, edit_id);
225 } catch (const std::bad_alloc &ba) {
226 LOGE("DesignElement::Exception bad_alloc");
227 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
230 return WATCHFACE_COMPLICATION_ERROR_NONE;
233 extern "C" EXPORT_API int watchface_editable_add_complication(
234 watchface_editable_container_h handle, int edit_id, complication_h comp,
235 watchface_editable_highlight_h highlight) {
236 if (!watchface_complication::util::CheckWatchFeatureEnabled())
237 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
239 if (handle == nullptr || comp == nullptr)
240 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
242 EditablesContainerStub* ec = static_cast<EditablesContainerStub*>(handle);
243 SharedHandle<IEditable>* sh = static_cast<SharedHandle<IEditable>*>(comp);
246 /* Update candidates */
247 ret = SharedHandle<IEditable>::Share(sh).get()->SetCandidates(
248 std::list<std::shared_ptr<Bundle>>());
250 if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
254 /* Highlight should be copied */
255 IEditable::Highlight* high =
256 ((SharedHandle<IEditable::Highlight>*)highlight)->GetRawPtr();
257 SharedHandle<IEditable>::Share(sh).get()->SetHighlight(
258 shared_ptr<IEditable::Highlight>(new IEditable::Highlight(*high)));
261 if (ec->IsExist(edit_id)) {
262 LOGE("ID already exist");
263 return WATCHFACE_COMPLICATION_ERROR_EXIST_ID;
265 ec->Add(SharedHandle<IEditable>::Share(sh), edit_id);
266 LOGI("Add comp %d", edit_id);
268 return WATCHFACE_COMPLICATION_ERROR_NONE;
271 extern "C" EXPORT_API int watchface_editable_request_edit(
272 watchface_editable_container_h handle,
273 watchface_editable_update_requested_cb cb, void* user_data) {
274 if (!watchface_complication::util::CheckWatchFeatureEnabled())
275 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
277 if (handle == nullptr || cb == nullptr)
278 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
280 static cynara_result pcr = COMPLICATION_CYNARA_UNKNOWN;
281 int ret = util::CheckPrivilege(PRIVILEGE_DATASHARING, &pcr);
282 if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
285 EditablesContainerStub* ec = static_cast<EditablesContainerStub*>(handle);
286 unique_ptr<UpdateCallbackInfo> ci = unique_ptr<UpdateCallbackInfo>(
287 new (std::nothrow) UpdateCallbackInfo(cb, user_data));
288 if (ci.get() == nullptr) {
289 LOGE("Out of memory");
290 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
292 ec->ClearUpdateCallbackInfo();
293 ec->AddUpdateCallbackInfo(move(ci));
294 ret = ec->RequestEdit();
299 extern "C" EXPORT_API int watchface_editable_add_edit_ready_cb(
300 watchface_editable_edit_ready_cb cb, void* user_data) {
301 if (!watchface_complication::util::CheckWatchFeatureEnabled())
302 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
305 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
307 if (__container == nullptr) {
309 __container = new EditablesContainerStub();
310 } catch (const std::exception& e) {
311 LOGE("Exception occurred : %s", e.what());
312 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
315 if (__container == nullptr) {
316 LOGE("Out of memory");
317 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
320 unique_ptr<ReadyCallbackInfo> ci = unique_ptr<ReadyCallbackInfo>(
321 new (std::nothrow) ReadyCallbackInfo(cb, user_data));
322 if (ci.get() == nullptr) {
323 LOGE("Out of memory");
324 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
326 int ret = __container->AddReadyCallbackInfo(move(ci));
327 if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
330 return WATCHFACE_COMPLICATION_ERROR_NONE;
333 extern "C" EXPORT_API int watchface_editable_remove_edit_ready_cb(
334 watchface_editable_edit_ready_cb cb) {
335 if (!watchface_complication::util::CheckWatchFeatureEnabled())
336 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
338 if (cb == nullptr || __container == nullptr)
339 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
341 return __container->RemoveReadyCallbackInfo(cb);
344 extern "C" EXPORT_API int watchface_editable_get_current_data_idx(
345 const watchface_editable_h handle, int* idx) {
346 if (!watchface_complication::util::CheckWatchFeatureEnabled())
347 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
349 if (handle == nullptr || idx == nullptr)
350 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
352 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
353 *idx = ie->GetPtr()->GetCurDataIdx();
354 return WATCHFACE_COMPLICATION_ERROR_NONE;
357 extern "C" EXPORT_API int watchface_editable_get_current_data(
358 const watchface_editable_h handle, bundle** cur_data) {
359 if (!watchface_complication::util::CheckWatchFeatureEnabled())
360 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
362 if (handle == nullptr || cur_data == nullptr)
363 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
365 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
366 shared_ptr<Bundle> data = ie->GetPtr()->GetCurData();
367 if (data.get() == nullptr)
368 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
369 if (data->GetHandle() != nullptr) {
370 *cur_data = bundle_dup(data->GetHandle());
371 if (*cur_data == nullptr)
372 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
374 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
376 return WATCHFACE_COMPLICATION_ERROR_NONE;
379 extern "C" EXPORT_API int watchface_editable_get_nth_data(
380 const watchface_editable_h handle, int nth, bundle** nth_data) {
381 if (!watchface_complication::util::CheckWatchFeatureEnabled())
382 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
384 if (handle == nullptr || nth_data == nullptr)
385 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
387 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
388 shared_ptr<Bundle> data = ie->GetPtr()->GetNthData(nth);
389 if (data.get() == nullptr)
390 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
391 if (data->GetHandle() != nullptr) {
392 *nth_data = bundle_dup(data->GetHandle());
393 if (*nth_data == nullptr)
394 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
396 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
398 return WATCHFACE_COMPLICATION_ERROR_NONE;
401 extern "C" EXPORT_API int watchface_editable_get_editable_id(
402 const watchface_editable_h handle, int* editable_id) {
403 if (!watchface_complication::util::CheckWatchFeatureEnabled())
404 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
406 if (handle == nullptr || editable_id == nullptr)
407 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
409 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
410 *editable_id = ie->GetPtr()->GetEditableId();
412 return WATCHFACE_COMPLICATION_ERROR_NONE;
415 extern "C" EXPORT_API int watchface_editable_get_editable_name(
416 const watchface_editable_h handle, char** editable_name) {
417 if (!watchface_complication::util::CheckWatchFeatureEnabled())
418 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
420 if (handle == nullptr || editable_name == nullptr)
421 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
423 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
424 if (!ie->GetPtr()->GetLabel().empty()) {
425 *editable_name = strdup(ie->GetPtr()->GetLabel().c_str());
426 if (*editable_name == nullptr) {
427 LOGE("Out of memory");
428 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
431 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
433 return WATCHFACE_COMPLICATION_ERROR_NONE;
436 extern "C" EXPORT_API int watchface_editable_set_editable_name(
437 const watchface_editable_h handle, const char* editable_name) {
438 if (!watchface_complication::util::CheckWatchFeatureEnabled())
439 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
441 if (handle == nullptr || editable_name == nullptr)
442 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
444 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
445 ie->GetPtr()->SetLabel(std::string(editable_name));
446 return WATCHFACE_COMPLICATION_ERROR_NONE;
449 extern "C" EXPORT_API int watchface_editable_load_current_data(
450 int editable_id, bundle** selected_data) {
451 if (!watchface_complication::util::CheckWatchFeatureEnabled())
452 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
454 if (selected_data == nullptr)
455 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
457 std::unique_ptr<Bundle> setting_data;
459 setting_data = EditablesManager::GetInst().LoadSetting(editable_id);
460 } catch (watchface_complication::Exception &ex) {
461 LOGE("%s %d", ex.what(), ex.GetErrorCode());
462 return ex.GetErrorCode();
465 if (setting_data != nullptr) {
466 bundle* dup_bundle = bundle_dup(setting_data.get()->GetHandle());
467 if (dup_bundle == nullptr)
468 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
469 *selected_data = dup_bundle;
471 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
473 return WATCHFACE_COMPLICATION_ERROR_NONE;
476 extern "C" EXPORT_API int watchface_editable_candidate_create(
477 bundle** candidate, const char* id) {
478 if (candidate == nullptr || id == nullptr) {
479 LOGE("Invalid parameter");
480 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
483 bundle* data = bundle_create();
484 int ret = bundle_add_str(data, CANDIDATE_ID_KEY, id);
485 if (ret != BUNDLE_ERROR_NONE) {
486 LOGE("fail to add id (%d)", ret);
488 return WATCHFACE_COMPLICATION_ERROR_IO_ERROR;
492 return WATCHFACE_COMPLICATION_ERROR_NONE;
495 extern "C" EXPORT_API int watchface_editable_candidate_get_id(
496 bundle* candidate, char** id) {
497 if (candidate == nullptr || id == nullptr) {
498 LOGE("Invalid parameter");
499 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
503 int ret = bundle_get_str(candidate, CANDIDATE_ID_KEY, &data);
504 if (ret != BUNDLE_ERROR_NONE) {
506 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
510 return WATCHFACE_COMPLICATION_ERROR_NONE;
513 extern "C" EXPORT_API int watchface_editable_candidate_set_name(
514 bundle* candidate, const char* name) {
515 if (candidate == nullptr || name == nullptr) {
516 LOGE("Invalid parameter");
517 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
520 int ret = bundle_add_str(candidate, CANDIDATE_NAME_KEY, name);
521 if (ret != BUNDLE_ERROR_NONE) {
522 LOGE("fail to add name (%d)", ret);
523 return WATCHFACE_COMPLICATION_ERROR_IO_ERROR;
525 return WATCHFACE_COMPLICATION_ERROR_NONE;
528 extern "C" EXPORT_API int watchface_editable_candidate_get_name(
529 bundle* candidate, char** name) {
530 if (candidate == nullptr || name == nullptr) {
531 LOGE("Invalid parameter");
532 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
536 int ret = bundle_get_str(candidate, CANDIDATE_NAME_KEY, &data);
537 if (ret != BUNDLE_ERROR_NONE) {
539 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
541 *name = strdup(data);
543 return WATCHFACE_COMPLICATION_ERROR_NONE;
546 extern "C" EXPORT_API int watchface_editable_candidate_set_color(
547 bundle* candidate, watchface_editable_color_h color) {
548 if (candidate == nullptr) {
549 LOGE("Invalid parameter");
550 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
553 bundle_del(candidate, CANDIDATE_COLOR_A_KEY);
554 bundle_del(candidate, CANDIDATE_COLOR_R_KEY);
555 bundle_del(candidate, CANDIDATE_COLOR_G_KEY);
556 bundle_del(candidate, CANDIDATE_COLOR_B_KEY);
557 if (color != nullptr) {
558 bundle_add_str(candidate, CANDIDATE_COLOR_A_KEY, to_string(color->a).c_str());
559 bundle_add_str(candidate, CANDIDATE_COLOR_R_KEY, to_string(color->r).c_str());
560 bundle_add_str(candidate, CANDIDATE_COLOR_G_KEY, to_string(color->g).c_str());
561 bundle_add_str(candidate, CANDIDATE_COLOR_B_KEY, to_string(color->b).c_str());
563 return WATCHFACE_COMPLICATION_ERROR_NONE;
566 extern "C" EXPORT_API int watchface_editable_candidate_get_color(
567 bundle* candidate, watchface_editable_color_h* color) {
568 if (candidate == nullptr || color == nullptr) {
569 LOGE("Invalid parameter");
570 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
573 char* r_str = nullptr;
574 char* g_str = nullptr;
575 char* b_str = nullptr;
576 char* a_str = nullptr;
578 bundle_get_str(candidate, CANDIDATE_COLOR_A_KEY, &a_str);
579 bundle_get_str(candidate, CANDIDATE_COLOR_R_KEY, &r_str);
580 bundle_get_str(candidate, CANDIDATE_COLOR_G_KEY, &g_str);
581 bundle_get_str(candidate, CANDIDATE_COLOR_B_KEY, &b_str);
583 watchface_editable_color_h col;
584 if (r_str != nullptr) {
585 int ret = watchface_editable_candidate_color_create(&col,
586 stoi(r_str), stoi(g_str), stoi(b_str), stoi(a_str));
587 if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
592 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
595 return WATCHFACE_COMPLICATION_ERROR_NONE;
598 extern "C" EXPORT_API int watchface_editable_candidate_color_create(
599 watchface_editable_color_h* color, int r, int g, int b, int a) {
601 if (color == nullptr || r < 0 || r > 255
602 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255) {
603 LOGE("Invalid parameter");
604 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
606 watchface_editable_color_h col =
607 (watchface_editable_color_h)calloc(1, sizeof(struct editable_color_));
614 return WATCHFACE_COMPLICATION_ERROR_NONE;
617 extern "C" EXPORT_API int watchface_editable_candidate_color_get(
618 watchface_editable_color_h color, int* r, int* g, int* b, int* a) {
620 || r == nullptr || g == nullptr || b == nullptr || a == nullptr) {
621 LOGE("Invalid parameter");
622 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
630 return WATCHFACE_COMPLICATION_ERROR_NONE;
633 extern "C" EXPORT_API int watchface_editable_candidate_color_destroy(
634 watchface_editable_color_h color) {
635 if (color == nullptr) {
636 LOGE("Invalid parameter");
637 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
640 return WATCHFACE_COMPLICATION_ERROR_NONE;
643 extern "C" EXPORT_API int watchface_editable_candidate_set_preview_image(
644 bundle *candidate, const char *path) {
645 if (candidate == nullptr || path == nullptr) {
646 LOGE("Invalid parameter");
647 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
650 bundle_del(candidate, CANDIDATE_PREVIEW_IMAGE_KEY);
651 int ret = bundle_add_str(candidate, CANDIDATE_PREVIEW_IMAGE_KEY, path);
652 if (ret != BUNDLE_ERROR_NONE) {
653 LOGE("fail to add path");
654 return WATCHFACE_COMPLICATION_ERROR_IO_ERROR;
657 return WATCHFACE_COMPLICATION_ERROR_NONE;
660 extern "C" EXPORT_API int watchface_editable_candidate_get_preview_image(
661 bundle* candidate, char** path) {
662 if (candidate == nullptr || path == nullptr) {
663 LOGE("Invalid parameter");
664 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
668 int ret = bundle_get_str(candidate, CANDIDATE_PREVIEW_IMAGE_KEY, &image);
669 if (ret != BUNDLE_ERROR_NONE) {
671 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
673 *path = strdup(image);
675 return WATCHFACE_COMPLICATION_ERROR_NONE;
678 extern "C" EXPORT_API int watchface_editable_candidates_list_create(
679 complication_candidates_list_h* handle) {
680 complication_candidates_list_h h = nullptr;
682 if (!watchface_complication::util::CheckWatchFeatureEnabled())
683 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
685 if (handle == nullptr) {
686 LOGE("Invalid param");
687 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
690 h = (complication_candidates_list_h)calloc(1,
691 sizeof(struct complication_candidates_list_));
694 LOGE("Out of memory");
695 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
700 return WATCHFACE_COMPLICATION_ERROR_NONE;
703 extern "C" EXPORT_API int watchface_editable_candidates_list_add(
704 complication_candidates_list_h handle, bundle* candidate) {
705 if (!watchface_complication::util::CheckWatchFeatureEnabled())
706 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
708 if (handle == nullptr || candidate == nullptr) {
709 LOGE("Invalid param");
710 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
713 bundle* dup_candidate = bundle_dup(candidate);
714 if (dup_candidate == nullptr) {
715 LOGE("Out of memory");
716 return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
718 handle->candidates_list = g_list_append(
719 handle->candidates_list, dup_candidate);
721 return WATCHFACE_COMPLICATION_ERROR_NONE;
724 static void __free_candidate(gpointer data) {
725 bundle* candidate = reinterpret_cast<bundle*>(data);
726 bundle_free(candidate);
729 extern "C" EXPORT_API int watchface_editable_candidates_list_destroy(
730 complication_candidates_list_h handle) {
731 if (!watchface_complication::util::CheckWatchFeatureEnabled())
732 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
734 if (handle == nullptr) {
735 LOGE("Invalid param");
736 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
739 if (handle->candidates_list)
740 g_list_free_full(handle->candidates_list, __free_candidate);
743 return WATCHFACE_COMPLICATION_ERROR_NONE;
746 extern "C" EXPORT_API int watchface_editable_container_get(
747 watchface_editable_container_h* container) {
748 if (!watchface_complication::util::CheckWatchFeatureEnabled())
749 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
751 if (container == nullptr) {
752 LOGE("Invalid param");
753 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
756 if (__container == nullptr) {
757 LOGE("Container is not ready yet");
758 return WATCHFACE_COMPLICATION_ERROR_IO_ERROR;
761 *container = __container;
763 return WATCHFACE_COMPLICATION_ERROR_NONE;
766 extern "C" EXPORT_API int watchface_editable_highlight_create(
767 watchface_editable_highlight_h* handle,
768 watchface_editable_shape_type_e shape) {
769 watchface_editable_highlight_h h = nullptr;
771 if (!watchface_complication::util::CheckWatchFeatureEnabled())
772 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
774 if (handle == nullptr || shape < WATCHFACE_EDITABLE_SHAPE_TYPE_CIRCLE ||
775 WATCHFACE_EDITABLE_SHAPE_TYPE_RECT < shape) {
776 LOGE("Invalid param");
777 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
780 h = (watchface_editable_highlight_h)SharedHandle<IEditable::Highlight>::Make(
781 make_shared<IEditable::Highlight>((IEditable::EditableShapeType)shape)
785 return WATCHFACE_COMPLICATION_ERROR_NONE;
788 extern "C" EXPORT_API int watchface_editable_highlight_set_normalized_geometry(
789 watchface_editable_highlight_h handle, double x, double y, double w, double h) {
791 if (!watchface_complication::util::CheckWatchFeatureEnabled())
792 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
794 if (handle == nullptr || x < 0.0 || y < 0.0 || w < 0.0 || h < 0.0 ||
795 x > 1.0 || y > 1.0 || w > 1.0 || h > 1.0) {
796 LOGE("Invalid param");
797 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
800 shared_ptr<IEditable::Highlight> ptr =
801 ((SharedHandle<IEditable::Highlight>*)handle)->GetPtr();
802 ptr->SetNormalizedGeometry(
803 unique_ptr<IEditable::NormalizedGeometry>(
804 new IEditable::NormalizedGeometry(x, y, w, h)));
806 return WATCHFACE_COMPLICATION_ERROR_NONE;
809 extern "C" EXPORT_API int watchface_editable_highlight_get_normalized_geometry(
810 watchface_editable_highlight_h handle, double *x, double *y, double *w, double *h) {
811 if (!watchface_complication::util::CheckWatchFeatureEnabled())
812 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
814 if (handle == nullptr || x == nullptr || y == nullptr || w == nullptr || h == nullptr) {
815 LOGE("Invalid param");
816 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
819 shared_ptr<IEditable::Highlight> ptr =
820 ((SharedHandle<IEditable::Highlight>*)handle)->GetPtr();
821 *x = ptr->GetNormalizedGeometry()->GetNormalizedX();
822 *y = ptr->GetNormalizedGeometry()->GetNormalizedY();
823 *w = ptr->GetNormalizedGeometry()->GetNormalizedW();
824 *h = ptr->GetNormalizedGeometry()->GetNormalizedH();
826 return WATCHFACE_COMPLICATION_ERROR_NONE;
829 extern "C" EXPORT_API int watchface_editable_highlight_set_geometry(
830 watchface_editable_highlight_h handle, int x, int y, int w, int h) {
831 if (!watchface_complication::util::CheckWatchFeatureEnabled())
832 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
834 if (handle == nullptr || x < 0 || y < 0 || w < 0 || h < 0) {
835 LOGE("Invalid param");
836 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
839 shared_ptr<IEditable::Highlight> ptr =
840 ((SharedHandle<IEditable::Highlight>*)handle)->GetPtr();
841 IEditable::Geometry geo(x, y, w, h);
842 ptr->SetGeometry(geo);
844 return WATCHFACE_COMPLICATION_ERROR_NONE;
847 extern "C" EXPORT_API int watchface_editable_highlight_get_geometry(
848 watchface_editable_highlight_h handle, int* x, int* y, int* w, int* h) {
849 if (!watchface_complication::util::CheckWatchFeatureEnabled())
850 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
852 if (handle == nullptr || x == nullptr || y == nullptr || w == nullptr || h == nullptr) {
853 LOGE("Invalid param");
854 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
857 shared_ptr<IEditable::Highlight> ptr =
858 ((SharedHandle<IEditable::Highlight>*)handle)->GetPtr();
859 *x = ptr->GetGeometry()->GetX();
860 *y = ptr->GetGeometry()->GetY();
861 *w = ptr->GetGeometry()->GetW();
862 *h = ptr->GetGeometry()->GetH();
864 return WATCHFACE_COMPLICATION_ERROR_NONE;
867 extern "C" EXPORT_API int watchface_editable_highlight_set_shape_type(
868 watchface_editable_highlight_h handle,
869 watchface_editable_shape_type_e shape) {
870 if (!watchface_complication::util::CheckWatchFeatureEnabled())
871 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
873 if (handle == nullptr
874 || shape < WATCHFACE_EDITABLE_SHAPE_TYPE_CIRCLE
875 || shape > WATCHFACE_EDITABLE_SHAPE_TYPE_RECT) {
876 LOGE("Invalid param");
877 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
879 shared_ptr<IEditable::Highlight> ptr =
880 ((SharedHandle<IEditable::Highlight>*)handle)->GetPtr();
881 ptr->SetShapeType((IEditable::EditableShapeType)shape);
883 return WATCHFACE_COMPLICATION_ERROR_NONE;
886 extern "C" EXPORT_API int watchface_editable_highlight_get_shape_type(
887 watchface_editable_highlight_h handle,
888 watchface_editable_shape_type_e* shape) {
889 if (!watchface_complication::util::CheckWatchFeatureEnabled())
890 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
892 if (handle == nullptr || shape == nullptr) {
893 LOGE("Invalid param");
894 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
896 shared_ptr<IEditable::Highlight> ptr =
897 ((SharedHandle<IEditable::Highlight>*)handle)->GetPtr();
898 *shape = (watchface_editable_shape_type_e)ptr->GetShapeType();
900 return WATCHFACE_COMPLICATION_ERROR_NONE;
903 extern "C" EXPORT_API int watchface_editable_highlight_destroy(
904 watchface_editable_highlight_h handle) {
905 if (!watchface_complication::util::CheckWatchFeatureEnabled())
906 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
908 if (handle == nullptr) {
909 LOGE("Invalid param");
910 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
914 return WATCHFACE_COMPLICATION_ERROR_NONE;
917 extern "C" EXPORT_API int watchface_editable_get_highlight(
918 const watchface_editable_h handle,
919 watchface_editable_highlight_h* highlight) {
920 if (!watchface_complication::util::CheckWatchFeatureEnabled())
921 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
923 if (handle == nullptr || highlight == nullptr) {
924 LOGE("Invalid param");
925 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
928 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
929 shared_ptr<IEditable::Highlight> info = ie->GetPtr()->GetHighlight();
930 if (info == nullptr) {
931 LOGE("editor do not have highlight data");
932 return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
935 *highlight = SharedHandle<IEditable::Highlight>::Make(info);
937 return WATCHFACE_COMPLICATION_ERROR_NONE;
940 extern "C" EXPORT_API int watchface_editable_edit_done(
941 watchface_editable_h handle) {
942 if (!watchface_complication::util::CheckWatchFeatureEnabled())
943 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
945 if (handle == nullptr) {
946 LOGE("Invalid param");
947 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
950 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
951 shared_ptr<IEditable> ptr = ie->GetPtr();
952 if (!__container->SendEditResult(
953 ptr->GetEditableId(), ptr->GetEditSequence(),
954 WATCHFACE_COMPLICATION_ERROR_NONE)) {
955 LOGE("Fail to send edit result");
956 return WATCHFACE_COMPLICATION_ERROR_IO_ERROR;
959 return WATCHFACE_COMPLICATION_ERROR_NONE;
962 extern "C" EXPORT_API int watchface_editable_dup(
963 const watchface_editable_h handle, watchface_editable_h *dup_handle) {
964 if (!watchface_complication::util::CheckWatchFeatureEnabled())
965 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
967 if (handle == nullptr || dup_handle == nullptr) {
968 LOGE("Invalid param");
969 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
971 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
972 *dup_handle = SharedHandle<IEditable>::Make(ie->GetPtr());
973 return WATCHFACE_COMPLICATION_ERROR_NONE;
976 extern "C" EXPORT_API int watchface_editable_destroy(watchface_editable_h handle) {
977 if (!watchface_complication::util::CheckWatchFeatureEnabled())
978 return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
980 if (handle == nullptr) {
981 LOGE("Invalid param");
982 return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
984 SharedHandle<IEditable>* ie = static_cast<SharedHandle<IEditable>*>(handle);
986 return WATCHFACE_COMPLICATION_ERROR_NONE;