1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
/*
* Copyright (c) 2017 TOYOTA MOTOR CORPORATION
*
* 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 <assert.h>
#include <unistd.h>
#include "wm_layer_control.hpp"
#include "wm_layer.hpp"
#include "json_helper.hpp"
#define LC_AREA_PATH "/etc/area.db"
#define LC_LAYER_SETTING_PATH "/etc/layer_setting.json"
using std::string;
namespace wm {
static void notification_static(ilmObjectType object,
t_ilm_uint id,
t_ilm_bool created,
void* data)
{
static_cast<LayerControl*>(data)->dispatchILMEvent(object, id, created);
}
LayerControl::LayerControl(const std::string& root)
{
string area_path = root + LC_AREA_PATH;
string layer_path= root + LC_LAYER_SETTING_PATH;
// load layers.setting.json
WMError ret = this->loadLayerSetting(layer_path);
assert(ret == WMError::SUCCESS);
// load area.db
ret = this->loadAreaDb(area_path);
assert(ret == WMError::SUCCESS);
}
WMError LayerControl::init()
{
ilmErrorTypes rc = ilm_init();
t_ilm_uint num = 0;
t_ilm_uint *ids;
int cnt = 0;
while (rc != ILM_SUCCESS)
{
cnt++;
if (20 <= cnt)
{
HMI_ERROR("Could not connect to compositor");
goto lc_init_error;
}
HMI_ERROR("Wait to start weston ...");
sleep(1);
ilm_init();
}
if(rc != ILM_SUCCESS) goto lc_init_error;
rc = ilm_getScreenIDs(&num, &ids);
if(rc != ILM_SUCCESS) goto lc_init_error;
for(unsigned i = 0; i < num; i++)
{
HMI_INFO("get screen: %d", ids[i]);
}
// Currently, 0 is only available
this->screenID = ids[0];
rc = ilm_getPropertiesOfScreen(this->screenID, &this->screen_prop);
if(rc != ILM_SUCCESS) goto lc_init_error;
// Register Callback from ILM
ilm_registerNotification(notification_static, this);
return WMError::SUCCESS;
lc_init_error:
HMI_ERROR("Failed to initialize. Terminate WM");
return WMError::FAIL;
}
unsigned LayerControl::getNewLayerID(const string& role)
{
unsigned ret = 0;
for(const auto& l: this->wm_layers)
{
ret = l->getNewLayerID(role);
if(ret != 0)
{
break;
}
}
return ret;
}
WMError LayerControl::updateLayer(WMLayer& wm_layer)
{
return WMError::SUCCESS;
}
void LayerControl::commitChange() {}
void LayerControl::undoUpdate() {}
WMError LayerControl::loadLayerSetting(const string &path)
{
HMI_DEBUG("loading WMLayer(Application Containers) Setting from %s", path);
json_object *json_obj, *json_cfg;
int ret = jh::inputJsonFilie(path.c_str(), &json_obj);
if (0 > ret)
{
HMI_DEBUG("Could not open %s, so use default area information", path.c_str());
return WMError::FAIL;
}
HMI_INFO("json_obj dump:%s", json_object_get_string(json_obj));
if (!json_object_object_get_ex(json_obj, "mappings", &json_cfg))
{
HMI_ERROR("Parse Error!!");
return WMError::FAIL;
}
int len = json_object_array_length(json_cfg);
HMI_DEBUG("json_cfg len:%d", len);
for (int i = 0; i < len; i++)
{
json_object *json_tmp = json_object_array_get_idx(json_cfg, i);
HMI_DEBUG("> json_tmp dump:%s", json_object_get_string(json_tmp));
this->wm_layers.emplace_back(std::make_shared<WMLayer>(json_tmp));
}
return WMError::SUCCESS;
}
WMError LayerControl::loadAreaDb(const std::string& path)
{
// Load area.db
json_object *json_obj;
int ret = jh::inputJsonFilie(path.c_str(), &json_obj);
if (0 > ret)
{
HMI_DEBUG("Could not open %s, so use default area information", path.c_str());
return WMError::FAIL;
}
HMI_INFO("json_obj dump:%s", json_object_get_string(json_obj));
// Perse areas
json_object *json_cfg;
if (!json_object_object_get_ex(json_obj, "areas", &json_cfg))
{
HMI_ERROR("Parse Error!!");
return WMError::FAIL;
}
int len = json_object_array_length(json_cfg);
HMI_DEBUG("json_cfg len:%d", len);
const char *area;
for (int i = 0; i < len; i++)
{
json_object *json_tmp = json_object_array_get_idx(json_cfg, i);
HMI_DEBUG("> json_tmp dump:%s", json_object_get_string(json_tmp));
area = jh::getStringFromJson(json_tmp, "name");
if (nullptr == area)
{
HMI_ERROR("Parse Error!!");
return WMError::FAIL;
}
HMI_DEBUG("> area:%s", area);
json_object *json_rect;
if (!json_object_object_get_ex(json_tmp, "rect", &json_rect))
{
HMI_ERROR("Parse Error!!");
return WMError::FAIL;
}
HMI_DEBUG("> json_rect dump:%s", json_object_get_string(json_rect));
struct rect area_size;
area_size.x = jh::getIntFromJson(json_rect, "x");
area_size.y = jh::getIntFromJson(json_rect, "y");
area_size.w = jh::getIntFromJson(json_rect, "w");
area_size.h = jh::getIntFromJson(json_rect, "h");
this->area2size[area] = area_size;
}
// Check
for (const auto& itr : this->area2size)
{
HMI_DEBUG("area:%s x:%d y:%d w:%d h:%d",
itr.first.c_str(), itr.second.x, itr.second.y,
itr.second.w, itr.second.h);
}
// Release json_object
json_object_put(json_obj);
return WMError::SUCCESS;
}
void LayerControl::dispatchILMEvent(ilmObjectType object, t_ilm_uint id, t_ilm_bool created)
{
;
}
} // namespace wm
|
