|
|
1 | /** |
|
|
2 | * ZANavi, Zoff Android Navigation system. |
|
|
3 | * Copyright (C) 2011-2012 Zoff <zoff@zoff.cc> |
|
|
4 | * |
|
|
5 | * This program is free software; you can redistribute it and/or |
|
|
6 | * modify it under the terms of the GNU General Public License |
|
|
7 | * version 2 as published by the Free Software Foundation. |
|
|
8 | * |
|
|
9 | * This program is distributed in the hope that it will be useful, |
|
|
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
12 | * GNU General Public License for more details. |
|
|
13 | * |
|
|
14 | * You should have received a copy of the GNU General Public License |
|
|
15 | * along with this program; if not, write to the |
|
|
16 | * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
|
|
17 | * Boston, MA 02110-1301, USA. |
|
|
18 | */ |
|
|
19 | |
1 | /** |
20 | /** |
2 | * Navit, a modular navigation system. |
21 | * Navit, a modular navigation system. |
3 | * Copyright (C) 2005-2008 Navit Team |
22 | * Copyright (C) 2005-2008 Navit Team |
4 | * |
23 | * |
5 | * This program is free software; you can redistribute it and/or |
24 | * This program is free software; you can redistribute it and/or |
… | |
… | |
31 | #include "plugin.h" |
50 | #include "plugin.h" |
32 | #include "vehicle.h" |
51 | #include "vehicle.h" |
33 | #include "event.h" |
52 | #include "event.h" |
34 | #include "util.h" |
53 | #include "util.h" |
35 | |
54 | |
36 | struct vehicle_priv { |
55 | struct vehicle_priv |
|
|
56 | { |
37 | int interval; |
57 | int interval; |
38 | int position_set; |
58 | int position_set; |
39 | struct callback_list *cbl; |
59 | struct callback_list *cbl; |
40 | struct navit *navit; |
60 | struct navit *navit; |
41 | struct coord_geo geo; |
61 | struct coord_geo geo; |
… | |
… | |
47 | struct event_timeout *timer; |
67 | struct event_timeout *timer; |
48 | char *timep; |
68 | char *timep; |
49 | |
69 | |
50 | }; |
70 | }; |
51 | |
71 | |
52 | static void |
|
|
53 | vehicle_demo_destroy(struct vehicle_priv *priv) |
72 | static void vehicle_demo_destroy(struct vehicle_priv *priv) |
54 | { |
73 | { |
55 | g_free(priv->timep); |
74 | g_free(priv->timep); |
56 | g_free(priv); |
75 | g_free(priv); |
57 | } |
76 | } |
58 | |
77 | |
59 | static int |
78 | static int vehicle_demo_position_attr_get(struct vehicle_priv *priv, enum attr_type type, struct attr *attr) |
60 | vehicle_demo_position_attr_get(struct vehicle_priv *priv, |
|
|
61 | enum attr_type type, struct attr *attr) |
|
|
62 | { |
79 | { |
63 | switch (type) { |
80 | switch (type) |
|
|
81 | { |
64 | case attr_position_speed: |
82 | case attr_position_speed: |
65 | attr->u.numd = &priv->speed; |
83 | attr->u.numd = &priv->speed; |
66 | break; |
84 | break; |
67 | case attr_position_direction: |
85 | case attr_position_direction: |
68 | attr->u.numd = &priv->direction; |
86 | attr->u.numd = &priv->direction; |
69 | break; |
87 | break; |
70 | case attr_position_coord_geo: |
88 | case attr_position_coord_geo: |
71 | attr->u.coord_geo = &priv->geo; |
89 | attr->u.coord_geo = &priv->geo; |
72 | break; |
90 | break; |
73 | case attr_position_time_iso8601: |
91 | case attr_position_time_iso8601: |
74 | g_free(priv->timep); |
92 | g_free(priv->timep); |
75 | priv->timep=current_to_iso8601(); |
93 | priv->timep = current_to_iso8601(); |
76 | attr->u.str=priv->timep; |
94 | attr->u.str = priv->timep; |
77 | break; |
95 | break; |
78 | default: |
96 | default: |
79 | return 0; |
97 | return 0; |
80 | } |
98 | } |
81 | attr->type = type; |
99 | attr->type = type; |
82 | return 1; |
100 | return 1; |
83 | } |
101 | } |
84 | |
102 | |
85 | static int |
|
|
86 | vehicle_demo_set_attr(struct vehicle_priv *priv, struct attr *attr) |
103 | static int vehicle_demo_set_attr(struct vehicle_priv *priv, struct attr *attr) |
87 | { |
104 | { |
88 | if (attr->type == attr_navit) |
105 | if (attr->type == attr_navit) |
89 | priv->navit = attr->u.navit; |
106 | priv->navit = attr->u.navit; |
90 | return 1; |
107 | return 1; |
91 | } |
108 | } |
92 | |
109 | |
93 | struct vehicle_methods vehicle_demo_methods = { |
110 | struct vehicle_methods vehicle_demo_methods = |
94 | vehicle_demo_destroy, |
111 | { vehicle_demo_destroy, vehicle_demo_position_attr_get, vehicle_demo_set_attr, }; |
95 | vehicle_demo_position_attr_get, |
|
|
96 | vehicle_demo_set_attr, |
|
|
97 | }; |
|
|
98 | |
112 | |
99 | static void |
|
|
100 | vehicle_demo_timer(struct vehicle_priv *priv) |
113 | static void vehicle_demo_timer(struct vehicle_priv *priv) |
101 | { |
114 | { |
102 | struct coord c, c2, pos, ci; |
115 | struct coord c, c2, pos, ci; |
103 | int slen, len, dx, dy; |
116 | int slen, len, dx, dy; |
104 | struct route *route=NULL; |
117 | struct route *route = NULL; |
105 | struct map *route_map=NULL; |
118 | struct map *route_map = NULL; |
106 | struct map_rect *mr=NULL; |
119 | struct map_rect *mr = NULL; |
107 | struct item *item=NULL; |
120 | struct item *item = NULL; |
108 | |
121 | |
109 | len = (priv->config_speed * priv->interval / 1000)/ 3.6; |
122 | len = (priv->config_speed * priv->interval / 1000) / 3.6; |
110 | dbg(1, "###### Entering simulation loop\n"); |
123 | //DBG dbg(0, "###### Entering simulation loop\n"); |
111 | if (priv->navit) |
124 | if (priv->navit) |
|
|
125 | { |
112 | route=navit_get_route(priv->navit); |
126 | route = navit_get_route(priv->navit); |
|
|
127 | } |
|
|
128 | //DBG dbg(0,"rr 1\n"); |
113 | if (route) |
129 | if (route) |
|
|
130 | { |
114 | route_map=route_get_map(route); |
131 | route_map = route_get_map(route); |
|
|
132 | } |
|
|
133 | //DBG dbg(0,"rr 2\n"); |
115 | if (route_map) |
134 | if (route_map) |
|
|
135 | { |
116 | mr=map_rect_new(route_map, NULL); |
136 | mr = map_rect_new(route_map, NULL); |
|
|
137 | } |
|
|
138 | //DBG dbg(0,"rr 3\n"); |
117 | if (mr) |
139 | if (mr) |
|
|
140 | { |
118 | item=map_rect_get_item(mr); |
141 | item = map_rect_get_item(mr); |
|
|
142 | } |
|
|
143 | //DBG dbg(0,"rr 4\n"); |
119 | if (item && item->type == type_route_start) |
144 | if (item && item->type == type_route_start) |
|
|
145 | { |
120 | item=map_rect_get_item(mr); |
146 | item = map_rect_get_item(mr); |
|
|
147 | } |
|
|
148 | //DBG dbg(0,"rr 5\n"); |
121 | if (item && item_coord_get(item, &pos, 1)) { |
149 | if (item && item_coord_get(item, &pos, 1)) |
|
|
150 | { |
122 | priv->position_set=0; |
151 | priv->position_set = 0; |
123 | dbg(1, "current pos=0x%x,0x%x\n", pos.x, pos.y); |
152 | ////DBG dbg(0, "current pos=0x%x,0x%x\n", pos.x, pos.y); |
124 | dbg(1, "last pos=0x%x,0x%x\n", priv->last.x, priv->last.y); |
153 | ////DBG dbg(0, "last pos=0x%x,0x%x\n", priv->last.x, priv->last.y); |
125 | if (priv->last.x == pos.x && priv->last.y == pos.y) { |
154 | if (priv->last.x == pos.x && priv->last.y == pos.y) |
|
|
155 | { |
126 | dbg(1, "endless loop\n"); |
156 | //dbg(1, "endless loop\n"); |
127 | } |
157 | } |
128 | priv->last = pos; |
158 | priv->last = pos; |
129 | while (item && priv->config_speed) { |
159 | while (item && priv->config_speed) |
|
|
160 | { |
130 | if (!item_coord_get(item, &c, 1)) { |
161 | if (!item_coord_get(item, &c, 1)) |
|
|
162 | { |
131 | item=map_rect_get_item(mr); |
163 | item = map_rect_get_item(mr); |
132 | continue; |
164 | continue; |
133 | } |
165 | } |
134 | dbg(1, "next pos=0x%x,0x%x\n", c.x, c.y); |
166 | ////DBG dbg(0, "next pos=0x%x,0x%x\n", c.x, c.y); |
135 | slen = transform_distance(projection_mg, &pos, &c); |
167 | slen = transform_distance(projection_mg, &pos, &c); |
136 | dbg(1, "len=%d slen=%d\n", len, slen); |
168 | ////DBG dbg(0, "len=%d slen=%d\n", len, slen); |
137 | if (slen < len) { |
169 | if (slen < len) |
|
|
170 | { |
138 | len -= slen; |
171 | len -= slen; |
139 | pos = c; |
172 | pos = c; |
|
|
173 | } |
140 | } else { |
174 | else |
|
|
175 | { |
141 | if (item_coord_get(item, &c2, 1) || map_rect_get_item(mr)) { |
176 | if (item_coord_get(item, &c2, 1) || map_rect_get_item(mr)) |
|
|
177 | { |
142 | dx = c.x - pos.x; |
178 | dx = c.x - pos.x; |
143 | dy = c.y - pos.y; |
179 | dy = c.y - pos.y; |
144 | ci.x = pos.x + dx * len / slen; |
180 | ci.x = pos.x + dx * len / slen; |
145 | ci.y = pos.y + dy * len / slen; |
181 | ci.y = pos.y + dy * len / slen; |
146 | priv->direction = |
|
|
147 | transform_get_angle_delta(&pos, &c, 0); |
182 | priv->direction = transform_get_angle_delta(&pos, &c, 0); |
148 | priv->speed=priv->config_speed; |
183 | priv->speed = priv->config_speed; |
|
|
184 | } |
149 | } else { |
185 | else |
|
|
186 | { |
150 | ci.x = pos.x; |
187 | ci.x = pos.x; |
151 | ci.y = pos.y; |
188 | ci.y = pos.y; |
152 | priv->speed=0; |
189 | priv->speed = 0; |
153 | dbg(0,"destination reached\n"); |
190 | ////DBG dbg(0, "destination reached\n"); |
154 | } |
191 | } |
155 | dbg(1, "ci=0x%x,0x%x\n", ci.x, ci.y); |
192 | //dbg(1, "ci=0x%x,0x%x\n", ci.x, ci.y); |
156 | transform_to_geo(projection_mg, &ci, |
193 | transform_to_geo(projection_mg, &ci, &priv->geo); |
157 | &priv->geo); |
|
|
158 | callback_list_call_attr_0(priv->cbl, attr_position_coord_geo); |
194 | callback_list_call_attr_0(priv->cbl, attr_position_coord_geo); |
159 | break; |
195 | break; |
160 | } |
196 | } |
161 | } |
197 | } |
162 | } else { |
198 | } |
|
|
199 | else |
|
|
200 | { |
163 | if (priv->position_set) |
201 | if (priv->position_set) |
164 | callback_list_call_attr_0(priv->cbl, attr_position_coord_geo); |
202 | callback_list_call_attr_0(priv->cbl, attr_position_coord_geo); |
165 | } |
203 | } |
|
|
204 | //DBG dbg(0,"rr 6\n"); |
166 | if (mr) |
205 | if (mr) |
|
|
206 | { |
167 | map_rect_destroy(mr); |
207 | map_rect_destroy(mr); |
|
|
208 | } |
|
|
209 | //DBG dbg(0,"rr F\n"); |
168 | } |
210 | } |
169 | |
|
|
170 | |
|
|
171 | |
211 | |
172 | static struct vehicle_priv * |
212 | static struct vehicle_priv * |
173 | vehicle_demo_new(struct vehicle_methods |
213 | vehicle_demo_new(struct vehicle_methods *meth, struct callback_list *cbl, struct attr **attrs) |
174 | *meth, struct callback_list |
|
|
175 | *cbl, struct attr **attrs) |
|
|
176 | { |
214 | { |
177 | struct vehicle_priv *ret; |
215 | struct vehicle_priv *ret; |
178 | struct attr *interval,*speed,*position_coord_geo; |
216 | struct attr *interval, *speed, *position_coord_geo; |
179 | |
217 | |
180 | dbg(1, "enter\n"); |
218 | //DBG dbg(0, "enter\n"); |
181 | ret = g_new0(struct vehicle_priv, 1); |
219 | ret = g_new0(struct vehicle_priv, 1); |
182 | ret->cbl = cbl; |
220 | ret->cbl = cbl; |
183 | ret->interval=1000; |
221 | ret->interval = 1200; |
184 | ret->config_speed=40; |
222 | ret->config_speed = 41; |
|
|
223 | |
|
|
224 | //dbg(0, "vd 3.1 %d %d\n", ret->interval, ret->config_speed); |
|
|
225 | |
|
|
226 | //DBG dbg(0, "vd 1\n"); |
185 | if ((speed=attr_search(attrs, NULL, attr_speed))) { |
227 | if ((speed = attr_search(attrs, NULL, attr_speed))) |
|
|
228 | { |
186 | ret->config_speed=speed->u.num; |
229 | ret->config_speed = speed->u.num; |
187 | } |
230 | } |
|
|
231 | |
|
|
232 | //DBG dbg(0, "vd 2\n"); |
188 | if ((interval=attr_search(attrs, NULL, attr_interval))) |
233 | if ((interval = attr_search(attrs, NULL, attr_interval))) |
|
|
234 | { |
189 | ret->interval=interval->u.num; |
235 | ret->interval = interval->u.num; |
|
|
236 | } |
|
|
237 | |
|
|
238 | // ret->geo.lat = 0; |
|
|
239 | // ret->geo.lng = 0; |
|
|
240 | // //DBG dbg(0, "position_default %f %f\n", ret->geo.lat, ret->geo.lng); |
|
|
241 | |
|
|
242 | //dbg(0, "vd 3.2 %d %d\n", ret->interval, ret->config_speed); |
190 | if ((position_coord_geo=attr_search(attrs, NULL, attr_position_coord_geo))) { |
243 | if ((position_coord_geo = attr_search(attrs, NULL, attr_position_coord_geo))) |
|
|
244 | { |
191 | ret->geo=*(position_coord_geo->u.coord_geo); |
245 | ret->geo = *(position_coord_geo->u.coord_geo); |
192 | ret->position_set=1; |
246 | ret->position_set = 1; |
193 | dbg(0,"position_set %f %f\n", ret->geo.lat, ret->geo.lng); |
247 | //DBG dbg(0, "position_set %f %f\n", ret->geo.lat, ret->geo.lng); |
194 | } |
248 | } |
|
|
249 | |
|
|
250 | //DBG dbg(0, "vd 4\n"); |
195 | *meth = vehicle_demo_methods; |
251 | *meth = vehicle_demo_methods; |
196 | ret->timer_callback=callback_new_1(callback_cast(vehicle_demo_timer), ret); |
252 | ret->timer_callback = callback_new_1(callback_cast(vehicle_demo_timer), ret); |
|
|
253 | //DBG dbg(0, "vd 5\n"); |
|
|
254 | dbg(0, "event_add_timeout %d,%d,%p", ret->interval, 1, ret->timer_callback); |
197 | ret->timer=event_add_timeout(ret->interval, 1, ret->timer_callback); |
255 | ret->timer = event_add_timeout(ret->interval, 1, ret->timer_callback); |
|
|
256 | //DBG dbg(0, "leave\n"); |
198 | return ret; |
257 | return ret; |
199 | } |
258 | } |
200 | |
259 | |
201 | void |
|
|
202 | plugin_init(void) |
260 | void plugin_init(void) |
203 | { |
261 | { |
204 | dbg(1, "enter\n"); |
262 | //DBG dbg(0, "enter\n"); |
205 | plugin_register_vehicle_type("demo", vehicle_demo_new); |
263 | plugin_register_vehicle_type("demo", vehicle_demo_new); |
206 | } |
264 | } |