Add APIs which can get information about the display and the surface area
[apps/agl-service-windowmanager-2017.git] / src / app.hpp
1 /*
2  * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
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 #ifndef TMCAGLWM_APP_HPP
18 #define TMCAGLWM_APP_HPP
19
20 #include <json-c/json.h>
21
22 #include <atomic>
23 #include <memory>
24 #include <unordered_map>
25 #include <unordered_set>
26 #include <experimental/optional>
27 #include "config.hpp"
28 #include "controller_hooks.hpp"
29 #include "layers.hpp"
30 #include "layout.hpp"
31 #include "policy.hpp"
32 #include "result.hpp"
33 #include "wayland_ivi_wm.hpp"
34 #include "hmi-debug.h"
35
36 namespace wl {
37 struct display;
38 }
39
40 namespace compositor {
41 struct controller;
42 }
43
44 namespace wm {
45
46 using std::experimental::optional;
47
48 /* DrawingArea name used by "{layout}.{area}" */
49 extern const char kNameLayoutNormal[];
50 extern const char kNameLayoutSplit[];
51 extern const char kNameAreaFull[];
52 extern const char kNameAreaMain[];
53 extern const char kNameAreaSub[];
54
55 /* Key for json obejct */
56 extern const char kKeyDrawingName[];
57 extern const char kKeyDrawingArea[];
58 extern const char kKeyDrawingRect[];
59 extern const char kKeyX[];
60 extern const char kKeyY[];
61 extern const char kKeyWidth[];
62 extern const char kKeyHeigh[];
63 extern const char kKeyWidthPixel[];
64 extern const char kKeyHeightPixel[];
65 extern const char kKeyWidthMm[];
66 extern const char kKeyHeightMm[];
67
68
69 struct id_allocator {
70    unsigned next = 1;
71
72    // Surfaces that where requested but not yet created
73    std::unordered_map<unsigned, std::string> id2name;
74    // std::unordered_set<unsigned> pending_surfaces;
75    std::unordered_map<std::string, unsigned> name2id;
76
77    id_allocator(id_allocator const &) = delete;
78    id_allocator(id_allocator &&) = delete;
79    id_allocator &operator=(id_allocator const &);
80    id_allocator &operator=(id_allocator &&) = delete;
81
82    // Insert and return a new ID
83    unsigned generate_id(std::string const &name) {
84       unsigned sid = this->next++;
85       this->id2name[sid] = name;
86       // this->pending_surfaces.insert({sid});
87       this->name2id[name] = sid;
88       HMI_DEBUG("wm", "allocated new id %u with name %s", sid, name.c_str());
89       return sid;
90    }
91
92    // Insert a new ID which defined outside
93    void register_name_id(std::string const &name, unsigned sid) {
94       this->id2name[sid] = name;
95       this->name2id[name] = sid;
96       HMI_DEBUG("wm", "register id %u with name %s", sid, name.c_str());
97       return;
98    }
99
100    // Lookup by ID or by name
101    optional<unsigned> lookup(std::string const &name) const {
102       auto i = this->name2id.find(name);
103       return i == this->name2id.end() ? nullopt : optional<unsigned>(i->second);
104    }
105
106    optional<std::string> lookup(unsigned id) const {
107       auto i = this->id2name.find(id);
108       return i == this->id2name.end() ? nullopt
109                                        : optional<std::string>(i->second);
110    }
111
112    // Remove a surface id and name
113    void remove_id(std::string const &name) {
114       auto i = this->name2id.find(name);
115       if (i != this->name2id.end()) {
116          this->id2name.erase(i->second);
117          this->name2id.erase(i);
118       }
119    }
120
121    void remove_id(unsigned id) {
122       auto i = this->id2name.find(id);
123       if (i != this->id2name.end()) {
124          this->name2id.erase(i->second);
125          this->id2name.erase(i);
126       }
127    }
128 };
129
130 struct App {
131
132    typedef std::unordered_map<uint32_t, struct compositor::rect> rect_map;
133
134    enum EventType {
135       Event_Val_Min = 0,
136
137       Event_Active = Event_Val_Min,
138       Event_Inactive,
139
140       Event_Visible,
141       Event_Invisible,
142
143       Event_SyncDraw,
144       Event_FlushDraw,
145
146       Event_Val_Max = Event_FlushDraw,
147    };
148
149    const std::vector<const char *> kListEventName{
150      "active",
151      "inactive",
152      "visible",
153      "invisible",
154      "syncdraw",
155      "flushdraw"
156    };
157
158    struct controller_hooks chooks;
159
160    // This is the one thing, we do not own.
161    struct wl::display *display;
162
163    std::unique_ptr<struct compositor::controller> controller;
164    std::vector<std::unique_ptr<struct wl::output>> outputs;
165
166    struct config config;
167
168    // track current layouts separately
169    layer_map layers;
170
171    // ID allocation and proxy methods for lookup
172    struct id_allocator id_alloc;
173
174    // Set by AFB API when wayland events need to be dispatched
175    std::atomic<bool> pending_events;
176
177    std::vector<int> pending_end_draw;
178
179    Policy policy;
180
181    std::map<const char *, struct afb_event> map_afb_event;
182
183    // Surface are info (x, y, w, h)
184    rect_map area_info;
185
186    // FOR CES DEMO
187    std::vector<int> surface_bg;
188
189    explicit App(wl::display *d);
190    ~App() = default;
191
192    App(App const &) = delete;
193    App &operator=(App const &) = delete;
194    App(App &&) = delete;
195    App &operator=(App &&) = delete;
196
197    int init();
198
199    int dispatch_pending_events();
200
201    void set_pending_events();
202
203    result<int> api_request_surface(char const *drawing_name);
204    char const *api_request_surface(char const *drawing_name, char const *ivi_id);
205    char const *api_activate_surface(char const *drawing_name, char const *drawing_area);
206    char const *api_deactivate_surface(char const *drawing_name);
207    char const *api_enddraw(char const *drawing_name);
208    result<json_object *> api_get_display_info();
209    result<json_object *> api_get_area_info(char const *drawing_name);
210    char const *api_subscribe(afb_req *req, char const *event_name);
211    void api_ping();
212    void send_event(char const *evname, char const *label);
213    void send_event(char const *evname, char const *label, char const *area, int x, int y, int w, int h);
214
215    // Events from the compositor we are interested in
216    void surface_created(uint32_t surface_id);
217    void surface_removed(uint32_t surface_id);
218
219 private:
220    optional<int> lookup_id(char const *name);
221    optional<std::string> lookup_name(int id);
222
223    bool pop_pending_events();
224
225    void enqueue_flushdraw(int surface_id);
226    void check_flushdraw(int surface_id);
227
228    int init_layers();
229
230    void surface_set_layout(int surface_id, optional<int> sub_surface_id = nullopt);
231    void layout_commit();
232
233    // TMC WM Events to clients
234    void emit_activated(char const *label);
235    void emit_deactivated(char const *label);
236    void emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h);
237    void emit_flushdraw(char const *label);
238    void emit_visible(char const *label, bool is_visible);
239    void emit_invisible(char const *label);
240    void emit_visible(char const *label);
241
242    void activate(int id);
243    void deactivate(int id);
244    void deactivate_main_surface();
245
246    bool can_split(struct LayoutState const &state, int new_id);
247    void try_layout(struct LayoutState &state,
248                    struct LayoutState const &new_layout,
249                    std::function<void(LayoutState const &nl)> apply);
250 };
251
252 }  // namespace wm
253
254 #endif  // TMCAGLWM_APP_HPP