Update api about private_id
[platform/core/api/notification.git] / notification-ex / manager.cc
1 /*
2  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <dlog.h>
18 #include <glib.h>
19 #include <unistd.h>
20
21 #include <list>
22
23 #include "notification-ex/item_inflator.h"
24 #include "notification-ex/manager.h"
25 #include "notification-ex/manager_implementation.h"
26 #include "notification-ex/event_info_internal.h"
27 #include "notification-ex/dbus_connection_manager.h"
28 #include "notification-ex/ex_util.h"
29 #include "notification-ex/item_info_internal.h"
30 #include "notification-ex/null_item.h"
31
32 #ifdef LOG_TAG
33 #undef LOG_TAG
34 #endif
35
36 #define LOG_TAG "NOTIFICATION_EX"
37
38 #define MAX_PACKAGE_STR_SIZE 512
39 #define NOTIFICATION_EX_MANAGER_OBJECT_PATH "/org/tizen/notification_ex_manager"
40 #define DATA_PROVIDER_MASTER_ID "data-provider-master"
41
42 using namespace std;
43 using namespace tizen_base;
44 using namespace notification::item;
45 namespace notification {
46
47 Manager::Manager(unique_ptr<IEventSender> sender,
48     unique_ptr<IEventListener> listener, string receiver_group)
49   : impl_(new Impl(this, move(sender), move(listener), receiver_group)) {
50 }
51 Manager::~Manager() = default;
52
53 Manager::Impl::~Impl() {
54   listener_->UnRegisterObserver(parent_);
55
56   list<Bundle> dummy_list {};
57   EventInfo info(EventInfo::Unregister, util::GetAppId(), "", "");
58   sender_->Notify(info, dummy_list, DATA_PROVIDER_MASTER_ID);
59 }
60 Manager::Impl::Impl(Manager* parent,
61     unique_ptr<IEventSender> sender,
62     unique_ptr<IEventListener> listener, string receiver_group)
63   : sender_(move(sender)), listener_(move(listener)),
64     receiver_group_(receiver_group),
65     parent_(parent) {
66   LOGI("impl created");
67   listener_->RegisterObserver(parent_);
68
69   list<Bundle> serialized_list {};
70   EventInfo info(EventInfo::Register, util::GetAppId(), receiver_group, "");
71   sender_->Notify(info, serialized_list, DATA_PROVIDER_MASTER_ID);
72 }
73
74 int Manager::Impl::SendNotify(shared_ptr<item::AbstractItem> noti,
75     IEventInfo::EventType type) {
76   Bundle serialized = noti->Serialize();
77   EventInfo info(type, util::GetAppId(), noti->GetChannel(), noti->GetId());
78   list<Bundle> serialized_list {serialized};
79
80   /* Reply to Sender */
81   sender_->Notify(info, serialized_list, noti->GetSenderAppId());
82   return info.GetRequestId();
83 }
84
85 void Manager::SendError(const IEventInfo& info, NotificationError error) {
86   list<Bundle> serialized_list {};
87   IEventInfo& i = const_cast<IEventInfo&>(info);
88   static_cast<IEventInfoInternal&>(i).SetError(error);
89   static_cast<IEventInfoInternal&>(i).SetEventType(EventInfo::Error);
90   impl_->sender_->Notify(info, serialized_list, info.GetOwner());
91 }
92
93 int Manager::Update(shared_ptr<item::AbstractItem> noti) {
94   return impl_->SendNotify(noti, EventInfo::Update);
95 }
96
97 int Manager::Delete(shared_ptr<item::AbstractItem> noti) {
98   return impl_->SendNotify(noti, EventInfo::Delete);
99 }
100
101 int Manager::DeleteAll() {
102   Bundle serialized;
103   EventInfo info(EventInfo::DeleteAll, util::GetAppId(), "");
104   list<Bundle> serialized_list {serialized};
105   impl_->sender_->Notify(info, serialized_list, util::GetAppId());
106   return info.GetRequestId();
107 }
108
109 int Manager::DeleteByChannel(string channel) {
110   Bundle serialized;
111   EventInfo info(EventInfo::DeleteAll, util::GetAppId(), channel);
112   list<Bundle> serialized_list {serialized};
113   impl_->sender_->Notify(info, serialized_list, util::GetAppId());
114   return info.GetRequestId();
115 }
116
117 int Manager::DeleteByAppId(string appId) {
118   Bundle serialized;
119   EventInfo info(EventInfo::DeleteAll, util::GetAppId(), "", appId);
120   list<Bundle> serialized_list {serialized};
121   impl_->sender_->Notify(info, serialized_list, util::GetAppId());
122   return info.GetRequestId();
123 }
124
125 int Manager::GetCount() const {
126   EventInfo info(EventInfo::Count, util::GetAppId(), "");
127   int num = impl_->sender_->RequestNumber(info);
128   return num;
129 }
130
131 int Manager::Hide(shared_ptr<item::AbstractItem> noti) {
132   (reinterpret_cast<IItemInfoInternal*>(noti->GetInfo().get()))->AddHideViewer(util::GetAppId());
133   return impl_->SendNotify(noti, EventInfo::Update);
134 }
135
136 unique_ptr<item::AbstractItem> Manager::FindByRootID(string id) {
137   EventInfo info(EventInfo::Get, util::GetAppId(), "", id);
138   list<Bundle> result = impl_->sender_->Request(info);
139   if (result.size() == 0) {
140     LOGE("Fail to get noti");
141     return unique_ptr<item::AbstractItem>{};
142   }
143   Bundle b = result.front();
144   unique_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
145   return gen_item;
146 }
147
148 list<unique_ptr<item::AbstractItem>> Manager::Get(string channel) {
149   EventInfo info(EventInfo::Get, util::GetAppId(), channel);
150   list<Bundle> result = impl_->sender_->Request(info);
151   list<unique_ptr<item::AbstractItem>> gen_list;
152   for (auto& i : result) {
153     unique_ptr<AbstractItem> gen_item = ItemInflator::Create(i);
154     gen_list.push_back(move(gen_item));
155   }
156   return gen_list;
157 }
158
159 int Manager::SendEvent(const IEventInfo& info,
160     shared_ptr<item::AbstractItem> noti) {
161   Bundle serialized = noti->Serialize();
162   Bundle serialized_info = info.Serialize();
163   list<Bundle> serialized_list {serialized};
164   impl_->sender_->Notify(info, serialized_list, noti->GetSenderAppId());
165   return info.GetRequestId();
166 }
167
168 int Manager::SendEvent(const IEventInfo& info,
169     list<shared_ptr<item::AbstractItem>> notiList) {
170   list<Bundle> serialized_list;
171   for (auto& i : notiList) {
172     Bundle b = i->Serialize();
173     serialized_list.push_back(b);
174   }
175   impl_->sender_->Notify(info, serialized_list);
176   return info.GetRequestId();
177 }
178
179 list<Bundle> Manager::OnRequest(const IEventInfo& info) {
180   list<shared_ptr<item::AbstractItem>> item_list = OnRequestEvent(info);
181   list<Bundle> serialized_list;
182   for (auto& i : item_list) {
183     if (std::static_pointer_cast<IItemInfoInternal>(i->GetInfo())
184           ->CanReceive(impl_->receiver_group_))
185       serialized_list.push_back(i->Serialize());
186   }
187   return serialized_list;
188 }
189
190 int Manager::OnRequestNumber(const IEventInfo& info) {
191   return OnRequestNumberEvent(info);
192 }
193
194 void Manager::OnEvent(const IEventInfo& info, list<Bundle> serialized) {
195   shared_ptr<AbstractItem> gen_item;
196   int type = info.GetEventType();
197   NotificationError error =
198       (static_cast<const IEventInfoInternal&>(info)).GetError();
199   if (error != ERROR_NONE) {
200     LOGE("Handling error event (%d)", error);
201     OnError(error, info.GetRequestId());
202     return;
203   }
204
205   switch (type) {
206     case EventInfo::Post: {
207       list<shared_ptr<item::AbstractItem>> added;
208       for (auto& i : serialized) {
209         gen_item = ItemInflator::Create(i);
210         if (std::static_pointer_cast<IItemInfoInternal>(gen_item->GetInfo())
211               ->CanReceive(impl_->receiver_group_))
212           added.emplace_back(gen_item);
213       }
214       if (added.size() > 0)
215         OnAdd(info, added);
216       break;
217     }
218     case EventInfo::Update: {
219       list<shared_ptr<item::AbstractItem>> updated;
220       for (auto& i : serialized) {
221         gen_item = ItemInflator::Create(i);
222         if (std::static_pointer_cast<IItemInfoInternal>(gen_item->GetInfo())
223               ->CanReceive(impl_->receiver_group_))
224           updated.emplace_back(gen_item);
225       }
226       if (updated.size() > 0)
227         OnUpdate(info, updated);
228       break;
229     }
230     case EventInfo::Delete: {
231       list<shared_ptr<item::AbstractItem>> deleted;
232       for (auto& i : serialized) {
233         gen_item = ItemInflator::Create(i);
234         if (std::static_pointer_cast<IItemInfoInternal>(gen_item->GetInfo())
235               ->CanReceive(impl_->receiver_group_))
236           deleted.emplace_back(gen_item);
237       }
238       if (deleted.size() > 0)
239         OnDelete(info, deleted);
240       break;
241     }
242     case EventInfo::Get:
243       break;
244     case EventInfo::Error:
245       break;
246     case EventInfo::Count:
247       break;
248     case EventInfo::DeleteAll: {
249       list<shared_ptr<item::AbstractItem>> deleted;
250       deleted.emplace_back(new NullItem());
251       OnDelete(info, deleted);
252       break;
253     }
254     case EventInfo::Custom:
255       break;
256   }
257 }
258
259 void Manager::OnAdd(const IEventInfo& info,
260       list<shared_ptr<item::AbstractItem>> addedList) {
261 }
262
263 void Manager::OnUpdate(const IEventInfo& info,
264       list<shared_ptr<item::AbstractItem>> updatedList) {
265 }
266
267 void Manager::OnDelete(const IEventInfo& info,
268       list<shared_ptr<item::AbstractItem>> deletedList) {
269 }
270
271 void Manager::OnError(NotificationError error, int requestId) {
272 }
273
274 list<shared_ptr<item::AbstractItem>> Manager::OnRequestEvent(const IEventInfo& info) {
275   return list<shared_ptr<item::AbstractItem>>({});
276 }
277
278 int Manager::OnRequestNumberEvent(const IEventInfo& info) {
279   return 0;
280 }
281
282 string Manager::GetPath() {
283   return NOTIFICATION_EX_MANAGER_OBJECT_PATH;
284 }
285
286 }  // namespace notification