layout: Address all other callsites w/ dirty+surface damage
[src/agl-compositor.git] / src / policy.c
1 /*
2  * Copyright © 2020 Collabora, Ltd.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining
5  * a copy of this software and associated documentation files (the
6  * "Software"), to deal in the Software without restriction, including
7  * without limitation the rights to use, copy, modify, merge, publish,
8  * distribute, sublicense, and/or sell copies of the Software, and to
9  * permit persons to whom the Software is furnished to do so, subject to
10  * the following conditions:
11  *
12  * The above copyright notice and this permission notice (including the
13  * next paragraph) shall be included in all copies or substantial
14  * portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
20  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
21  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23  * SOFTWARE.
24  */
25
26 #include <string.h>
27 #include <libweston/zalloc.h>
28 #include <assert.h>
29
30 #include "shared/helpers.h"
31 #include "ivi-compositor.h"
32
33 #include "policy.h"
34
35 static void
36 ivi_policy_remove_state_event(struct state_event *st_ev)
37 {
38         free(st_ev->name);
39         wl_list_remove(&st_ev->link);
40         free(st_ev);
41 }
42
43 static void
44 ivi_policy_destroy_state_event(struct wl_list *list)
45 {
46         struct state_event *st_ev, *tmp_st_ev;
47         wl_list_for_each_safe(st_ev, tmp_st_ev, list, link)
48                 ivi_policy_remove_state_event(st_ev);
49 }
50
51 static struct state_event *
52 ivi_policy_state_event_create(uint32_t val, const char *value)
53 {
54         struct state_event *ev_st = zalloc(sizeof(*ev_st));
55         size_t value_len = strlen(value);
56
57         ev_st->value = val;
58         ev_st->name = zalloc(sizeof(char) * value_len + 1);
59         memcpy(ev_st->name, value, value_len);
60
61         return ev_st;
62 }
63
64 void
65 ivi_policy_add_state(struct ivi_policy *policy, uint32_t state, const char *value)
66 {
67         struct state_event *ev_st;
68         if (!policy)
69                 return;
70
71         ev_st = ivi_policy_state_event_create(state, value);
72         wl_list_insert(&policy->states, &ev_st->link);
73 }
74
75 void
76 ivi_policy_add_event(struct ivi_policy *policy, uint32_t ev, const char *value)
77 {
78         struct state_event *ev_st;
79         if (!policy)
80                 return;
81
82         ev_st = ivi_policy_state_event_create(ev, value);
83         wl_list_insert(&policy->events, &ev_st->link);
84 }
85
86 static void
87 ivi_policy_add_default_states(struct ivi_policy *policy)
88 {
89         const char *default_states[] = { "invalid", "start", "stop", "reverse" };
90         if (!policy)
91                 return;
92
93         for (uint32_t i = 0; i < ARRAY_LENGTH(default_states); i ++) {
94                 struct state_event *ev_st =
95                         ivi_policy_state_event_create(i, default_states[i]);
96                 wl_list_insert(&policy->states, &ev_st->link);
97         }
98 }
99
100 static void
101 ivi_policy_add_default_events(struct ivi_policy *policy)
102 {
103         const char *default_events[] = { "show", "hide" };
104         if (!policy)
105                 return;
106
107         for (uint32_t i = 0; i < ARRAY_LENGTH(default_events); i ++) {
108                 struct state_event *ev_st =
109                         ivi_policy_state_event_create(i, default_events[i]);
110                 wl_list_insert(&policy->events, &ev_st->link);
111         }
112 }
113
114 static void
115 ivi_policy_try_event(struct ivi_a_policy *a_policy)
116 {
117         struct ivi_policy *policy = a_policy->policy;
118
119         if (policy->api.policy_rule_try_event)
120             return policy->api.policy_rule_try_event(a_policy);
121 }
122
123 static int
124 ivi_policy_try_event_timeout(void *user_data)
125 {
126         struct ivi_a_policy *a_policy = user_data;
127         ivi_policy_try_event(a_policy);
128         return 0;
129 }
130
131 static void
132 ivi_policy_setup_event_timeout(struct ivi_policy *ivi_policy,
133                                struct ivi_a_policy *a_policy)
134 {
135         struct ivi_compositor *ivi = ivi_policy->ivi;
136         struct wl_display *wl_display = ivi->compositor->wl_display;
137         struct wl_event_loop *loop = wl_display_get_event_loop(wl_display);
138
139         a_policy->timer = wl_event_loop_add_timer(loop,
140                                                   ivi_policy_try_event_timeout,
141                                                   a_policy);
142
143         wl_event_source_timer_update(a_policy->timer, a_policy->timeout);
144 }
145
146 static void
147 ivi_policy_check_policies(struct wl_listener *listener, void *data)
148 {
149         struct ivi_a_policy *a_policy;
150         struct ivi_policy *ivi_policy =
151                 wl_container_of(listener, ivi_policy, listener_check_policies);
152
153         ivi_policy->state_change_in_progress = true;
154         wl_list_for_each(a_policy, &ivi_policy->policies, link) {
155                 if (ivi_policy->current_state == a_policy->state) {
156                         /* check the timeout first to see if there's a timeout */
157                         if (a_policy->timeout > 0)
158                                 ivi_policy_setup_event_timeout(ivi_policy,
159                                                                a_policy);
160                         else
161                                 ivi_policy_try_event(a_policy);
162                 }
163         }
164
165         ivi_policy->previous_state = ivi_policy->current_state;
166         ivi_policy->state_change_in_progress = false;
167 }
168
169
170 struct ivi_policy *
171 ivi_policy_create(struct ivi_compositor *ivi,
172                   const struct ivi_policy_api *api, void *user_data)
173 {
174         struct ivi_policy *policy = zalloc(sizeof(*policy));
175
176         policy->user_data = user_data;
177         policy->ivi = ivi;
178         policy->state_change_in_progress = false;
179
180         policy->api.struct_size =
181                 MIN(sizeof(struct ivi_policy_api), api->struct_size);
182         /* install the hooks */
183         memcpy(&policy->api, api, policy->api.struct_size);
184
185         /* to trigger a check for policies use */
186         wl_signal_init(&policy->signal_state_change);
187
188         policy->listener_check_policies.notify = ivi_policy_check_policies;
189         wl_signal_add(&policy->signal_state_change,
190                       &policy->listener_check_policies);
191
192         policy->current_state = AGL_SHELL_POLICY_STATE_INVALID;
193         policy->previous_state = AGL_SHELL_POLICY_STATE_INVALID;
194
195         /* policy rules */
196         wl_list_init(&policy->policies);
197
198         wl_list_init(&policy->events);
199         wl_list_init(&policy->states);
200
201         /* add the default states and enums */
202         ivi_policy_add_default_states(policy);
203         ivi_policy_add_default_events(policy);
204
205         return policy;
206 }
207
208 void
209 ivi_policy_destroy(struct ivi_policy *ivi_policy)
210 {
211         struct ivi_a_policy *a_policy, *a_policy_tmp;
212
213         if (!ivi_policy)
214                 return;
215
216         wl_list_for_each_safe(a_policy, a_policy_tmp,
217                               &ivi_policy->policies, link) {
218                 free(a_policy->app_id);
219                 wl_list_remove(&a_policy->link);
220                 free(a_policy);
221         }
222
223         ivi_policy_destroy_state_event(&ivi_policy->states);
224         ivi_policy_destroy_state_event(&ivi_policy->events);
225
226         free(ivi_policy);
227 }
228
229
230 /* verifies if the state is one has been added */
231 static bool
232 ivi_policy_state_is_known(uint32_t state, struct ivi_policy *policy)
233 {
234         struct state_event *ev_st;
235
236         wl_list_for_each(ev_st, &policy->states, link) {
237                 if (ev_st->value == state) {
238                         return true;
239                 }
240         }
241         return false;
242 }
243
244 /*
245  * The generic way would be the following:
246  *
247  * - 'car' is in 'state' ->
248  *      { do 'event' for app 'app_id' at 'timeout' time if same state as 'car_state' }
249  *
250  * a 0 timeout means, immediately, a timeout > 0, means to install timer an
251  * execute when timeout expires
252  *
253  * The following happens:
254  * 'car' changes its state -> verify what policy needs to be run
255  * 'car' in same state -> no action
256  *
257  */
258 int
259 ivi_policy_add(struct ivi_policy *policy, const char *app_id, uint32_t state,
260                uint32_t event, uint32_t timeout, struct wl_resource *output_res)
261 {
262         size_t app_id_len;
263         struct weston_head *head = weston_head_from_resource(output_res);
264         struct weston_output *woutput = weston_head_get_output(head);
265         struct ivi_output *output = to_ivi_output(woutput);
266         struct ivi_a_policy *a_policy;
267
268         if (!policy) {
269                 weston_log("Failed to retrieve policy!\n");
270                 return -1;
271         }
272
273         a_policy = zalloc(sizeof(*a_policy));
274         if (!a_policy)
275                 return -1;
276
277         if (policy->state_change_in_progress)
278                 return -1;
279
280         /* we should be allow to do this in the first place, only if the
281          * hooks allows us to  */
282         if (policy->api.policy_rule_allow_to_add &&
283             !policy->api.policy_rule_allow_to_add(policy))
284                 return -1;
285
286         if (!ivi_policy_state_is_known(state, policy))
287                 return -1;
288
289         app_id_len = strlen(app_id);
290         a_policy->app_id = zalloc(sizeof(char) * app_id_len + 1);
291         memcpy(a_policy->app_id, app_id, app_id_len);
292
293         a_policy->state = state;
294         a_policy->event = event;
295         a_policy->timeout = timeout;
296         a_policy->output = output;
297         a_policy->policy = policy;
298
299         wl_list_insert(&policy->policies, &a_policy->link);
300
301         return 0;
302 }
303
304 /* we start with 'invalid' state, so a initial state to even 'stop' should
305  * trigger a check of policies
306  */
307 int
308 ivi_policy_state_change(struct ivi_policy *policy, uint32_t state)
309 {
310         bool found_state = false;
311         if (!policy) {
312                 weston_log("Failed to retrieve policy!\n");
313                 return -1;
314         }
315
316         if (policy->current_state == state) {
317                 return -1;
318         }
319
320         /* if we don't know the state, make sure it is first added */
321         found_state = ivi_policy_state_is_known(state, policy);
322         if (!found_state) {
323                 return -1;
324         }
325
326         /* current_state is actually the new state */
327         policy->current_state = state;
328
329         /* signal that we need to check the current policies */
330         wl_signal_emit(&policy->signal_state_change, policy);
331
332         return 0;
333 }