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
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
|
// SPDX-License-Identifier: MPL-2.0
// Copyright (C) 2014, PCA Peugeot Citro�n, XS Embedded GmbH, TomTom International B.V., Continental Automotive GmbH, BMW Car IT GmbH, Alpine Electronics R&D Europe GmbH, AISIN AW CO., LTD., Neusoft Technology Solutions GmbH, Jaguar Land Rover Limited, Visteon Corporation, Elektrobit Automotive GmbH
// This Source Code Form is subject to the terms of the
// Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with
// this file, you can obtain one at http://mozilla.org/MPL/2.0/.
package org.genivi.navigation.navigationcore
import org.genivi.CommonTypes.* from "../../CommonTypes.fidl"
import org.genivi.navigation.NavigationTypes.* from "../NavigationTypes.fidl"
import org.genivi.navigation.navigationcore.NavigationCoreTypes.* from "NavigationCoreTypes.fidl"
<**
@description : MapMatchedPosition = This interface offers functions to retrieve the map matched position and to simulate positioning
**>
interface MapMatchedPosition {
version {
major 4
minor 0
}
enumeration PositionItemKey extends PositionStatus { //Base 0x00a0
HEADING = 163
SPEED = 164
CLIMB = 165
}
enumeration AddressItemKey extends TimeStampedEnum {
TIMEZONE_OFFSET = 17
DAYLIGHT_OFFSET = 18
COUNTRY = 166 //Base 0x00a0
STATE = 167
CITY = 168
ZIPCODE = 169
STREET = 170
HOUSENUMBER = 171
CROSSING = 172
DISTRICT = 173
PHONENUMBER = 174
POINAME = 175
TOWNCENTER = 176
LOCATION_INPUT = 177
FULL_ADDRESS = 178
COUNTRYCODE = 179
HOUSENAME = 180
POSTAL_CODE = 181
}
enumeration PositionStatus extends GeoLocalizedEnum { //Base 0x00e0
GNSS_FIX_STATUS = 224
DR_STATUS = 225
MM_STATUS = 226
SIMULATION_MODE = 227
}
enumeration MatchMode { //Base 0x00f0
MATCH_TYPE = 240
ON_ROAD = 241
OFF_ROAD = 242
ON_FERRY = 243
IN_TUNNEL = 244
ON_CARPARK = 245
}
enumeration GnnsFixStatus extends BasicEnum { //Base 0x0100
NO_FIX = 256
TIME_FIX = 257
FIX_2D = 258 //2D_FIX is prohibited
FIX_3D = 259
}
enumeration PositionOnSegmentKey extends TimeStampedEnum { //Base 0x0110
SEGMENT_ID = 272
DIRECTION_ON_SEGMENT = 274
DISTANCE_ON_SEGMENT = 275
}
enumeration SimulationStatus extends BasicEnum { //Base 0x0220
SIMULATION_STATUS_NO_SIMULATION = 544
SIMULATION_STATUS_RUNNING = 545
SIMULATION_STATUS_PAUSED = 546
SIMULATION_STATUS_FIXED_POSITION = 547
}
union PositionItemValue {
Timestamp timestamp
Boolean status
GnnsFixStatus fix
Double doubleValue
Int32 intValue
}
map PositionItemDict {
PositionItemKey to PositionItemValue
}
union AddressItemValue {
String addressField
Int16 offset
Timestamp timestamp
MatchMode matchMode
}
map AddressItemDict {
AddressItemKey to AddressItemValue
}
union PositionOnSegmentValue {
Boolean directionOnSegment
Double distanceOnSegment //to be fixed, use of DistanceInMeters preferred ?
ByteBuffer segment
Timestamp timestamp
}
map PositionOnSegmentDict {
PositionOnSegmentKey to PositionOnSegmentValue
}
union PositionStatusValue {
Boolean statusValue
GnnsFixStatus fixStatus
Timestamp timestamp
}
map PositionStatusDict {
PositionStatus to PositionStatusValue
}
<**
@description : getVersion = This method returns the API version implemented by the server application
**>
method getVersion {
out {
Version ^version
}
}
<**
@description : setSimulationMode = This method activates or deactivates the simulation mode
**>
method setSimulationMode {
in {
<**
@description : sessionHandle = Session handle. Range[0x0:0x7fffffff]. 0x0 is reserved as an invalid handle value
**>
Handle sessionHandle
<**
@description : activate = flag. TRUE means that the simulation mode is activated.
**>
Boolean activate
}
}
<**
@description : getSimulationStatus = This method retrieves the simulation status
**>
method getSimulationStatus {
out {
<**
@description : simulationStatus = enum(SIMULATION_STATUS_NO_SIMULATION, SIMULATION_STATUS_RUNNING, SIMULATION_STATUS_PAUSED, SIMULATION_STATUS_FIXED_POSITION)
**>
SimulationStatus simulationStatus
}
}
<**
@description : AddSimulationStatusListener = Add this node as a listener to Simulation Status changes.
**>
method addSimulationStatusListener {
}
<**
@description : RemoveSimulationStatusListener = Remove this node as a listener to Simulation Status changes.
**>
method removeSimulationStatusListener {
}
<**
@description : setSimulationSpeed = This method sets the speed factor for the simulation mode
**>
method setSimulationSpeed {
in {
<**
@description : sessionHandle = Session handle. Range[0x0:0x7fffffff]. 0x0 is reserved as an invalid handle value
**>
Handle sessionHandle
<**
@description : speedFactor = speed factor
**>
UInt8 speedFactor
}
}
<**
@description : getSimulationSpeed = returns the speed factor for the simulation mode
**>
method getSimulationSpeed {
out {
<**
@description : speedFactor = speed factor
**>
UInt8 speedFactor
}
}
<**
@description : AddSimulationSpeedListener = Add this node as a listener to simulation speed factor changes.
**>
method addSimulationSpeedListener {
}
<**
@description : RemoveSimulationSpeedListener = Remove this node as a listener to simulation speed factor changes.
**>
method removeSimulationSpeedListener {
}
<**
@description : startSimulation = This method starts, or resumes, a Follow Active Route simulation
**>
method startSimulation {
in {
<**
@description : sessionHandle = Session handle. Range[0x0:0x7fffffff]. 0x0 is reserved as an invalid handle value
**>
Handle sessionHandle
}
}
<**
@description : pauseSimulation = This method freezes the current location
**>
method pauseSimulation {
in {
<**
@description : sessionHandle = Session handle. Range[0x0:0x7fffffff]. 0x0 is reserved as an invalid handle value
**>
Handle sessionHandle
}
}
<**
@description : getPosition = This method returns the current position
notify(MAPMATCHEDPOSITION_ERROR_NOPOSITION) is emitted if no position is available
**>
method getPosition {
in {
PositionItemKey[] valuesToReturn
}
out {
PositionItemDict position
}
}
<**
@description : setPosition = This method sets the position to a specific location
**>
method setPosition {
in {
<**
@description : sessionHandle = Session handle. Range[0x0:0x7fffffff]. 0x0 is reserved as an invalid handle value
**>
Handle sessionHandle
PositionItemDict position
}
}
<**
@description : getCurrentAddress = This method returns the current address
notify(MAPMATCHEDPOSITION_ERROR_NOMAP) is emitted if no map is available
notify(MAPMATCHEDPOSITION_ERROR_OUTOFKNOWNMAP) is emitted if the vehicle is located in a position outside of the known map
**>
method getCurrentAddress {
in {
AddressItemKey[] valuesToReturn
}
out {
AddressItemDict address
}
}
<**
@description : positionOnSegment = This method returns the vehicle position on a route segment
**>
method getPositionOnSegment {
in {
PositionOnSegmentKey [] valuesToReturn
}
out {
PositionOnSegmentDict positionOnSegment
}
}
<**
@description : getStatus = This method returns the current status
**>
method getStatus {
in {
PositionStatus [] valuesToReturn
}
out {
PositionStatusDict status
}
}
<**
@description : simulationStatusChanged = This signal is emitted when the Simulation Status has changed
**>
broadcast simulationStatusChanged {
out {
<**
@description : simulationStatus = enum(SIMULATION_STATUS_NO_SIMULATION, SIMULATION_STATUS_RUNNING, SIMULATION_STATUS_PAUSED, SIMULATION_STATUS_FIXED_POSITION)
**>
SimulationStatus simulationStatus
}
}
<**
@description : simulationSpeedChanged = This signal is emitted when the simulation speed factor has changed
**>
broadcast simulationSpeedChanged {
out {
<**
@description : speedFactor = speed factor
**>
UInt8 speedFactor
}
}
<**
@description : positionUpdate = This signal is called to notify a client application of a position change. The update frequency is implementation specific. The maximal allowed frequency is 10Hz
**>
broadcast positionUpdate {
out {
PositionItemKey [] changedValues
}
}
<**
@description : addressUpdate = This signal is called to notify a client application that the current address changed
**>
broadcast addressUpdate {
out {
AddressItemKey[] changedValues
}
}
<**
@description : positionOnSegmentUpdate = This signal is called to notify the client that the vehicle position on the route segment changed
**>
broadcast positionOnSegmentUpdate {
out {
PositionOnSegmentKey[] changedValues
}
}
<**
@description : statusUpdate = This signal is emitted to notifiy a client application that the current status changed
**>
broadcast statusUpdate {
out {
PositionStatus [] changedValues
}
}
<**
@description : offroadPositionChanged = This signal is emitted when the heading and the distance to the closest point on the road network changes
**>
broadcast offRoadPositionChanged {
out {
<**
@description : distance = distance in meters to the closest point on the road network
**>
UInt32 distance
<**
@description : direction = direction in degrees relatively to the closest point on the road network. Range [0:360]
**>
Int32 direction
}
}
<**
@description : notify = This signal is emitted when something wrong occured when invoking the API
**>
broadcast notify {
out {
Notification notification
}
}
}
|