]>
Commit | Line | Data |
---|---|---|
1 | %module classes | |
2 | ||
3 | /* Automatically load JNI library. */ | |
4 | %pragma(java) jniclasscode=%{ | |
5 | static { | |
6 | System.loadLibrary("sigrok_java_core_classes"); | |
7 | } | |
8 | %} | |
9 | ||
10 | /* Documentation & importing interfaces. */ | |
11 | %pragma(java) jniclassimports=%{ | |
12 | /** | |
13 | * @mainpage API Reference | |
14 | * | |
15 | * Introduction | |
16 | * ------------ | |
17 | * | |
18 | * The sigrok-java API provides an object-oriented Java interface to the | |
19 | * functionality in libsigrok. It is built on top of the libsigrokcxx C++ API. | |
20 | * | |
21 | * Getting started | |
22 | * --------------- | |
23 | * | |
24 | * Usage of the sigrok-java API needs to begin with a call to Context.create(). | |
25 | * This will create the global libsigrok context and returns a Context object. | |
26 | * Methods on this object provide access to the hardware drivers, input and | |
27 | * output formats supported by the library, as well as means of creating other | |
28 | * objects such as sessions and triggers. | |
29 | * | |
30 | * Error handling | |
31 | * -------------- | |
32 | * | |
33 | * When any libsigrok C API call returns an error, an Error exception is raised, | |
34 | * which provides access to the error code and description. | |
35 | */ | |
36 | ||
37 | import org.sigrok.core.interfaces.LogCallback; | |
38 | import org.sigrok.core.interfaces.DatafeedCallback; | |
39 | %} | |
40 | ||
41 | /* Map Glib::VariantBase to a Variant class in Java */ | |
42 | %rename(Variant) VariantBase; | |
43 | namespace Glib { | |
44 | class VariantBase {}; | |
45 | } | |
46 | ||
47 | /* Map between std::vector and java.util.Vector */ | |
48 | %define VECTOR(CValue, JValue) | |
49 | ||
50 | %typemap(jni) std::vector< CValue > "jobject" | |
51 | %typemap(jtype) std::vector< CValue > "java.util.Vector<JValue>" | |
52 | %typemap(jstype) std::vector< CValue > "java.util.Vector<JValue>" | |
53 | ||
54 | %typemap(javain, | |
55 | pre=" $javaclassname temp$javainput = $javaclassname.convertVector($javainput);", | |
56 | pgcppname="temp$javainput") | |
57 | std::vector< CValue > "$javaclassname.getCPtr(temp$javainput)" | |
58 | ||
59 | %typemap(javacode) std::vector< CValue > %{ | |
60 | static $javaclassname convertVector(java.util.Vector<JValue> in) | |
61 | { | |
62 | $javaclassname out = new $javaclassname(); | |
63 | for (JValue value : in) | |
64 | out.add(value); | |
65 | return out; | |
66 | } | |
67 | %} | |
68 | ||
69 | %typemap(javaout) std::vector< CValue > { | |
70 | return (java.util.Vector<JValue>)$jnicall; | |
71 | } | |
72 | ||
73 | %typemap(out) std::vector< CValue > { | |
74 | jclass Vector = jenv->FindClass("java/util/Vector"); | |
75 | jmethodID Vector_init = jenv->GetMethodID(Vector, "<init>", "()V"); | |
76 | jmethodID Vector_add = jenv->GetMethodID(Vector, "add", | |
77 | "(Ljava/lang/Object;)Z"); | |
78 | jclass Value = jenv->FindClass("org/sigrok/core/classes/" #JValue); | |
79 | jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V"); | |
80 | $result = jenv->NewObject(Vector, Vector_init); | |
81 | jlong value; | |
82 | for (auto entry : $1) | |
83 | { | |
84 | *(CValue **) &value = new CValue(entry); | |
85 | jenv->CallObjectMethod($result, Vector_add, | |
86 | jenv->NewObject(Value, Value_init, value, true)); | |
87 | } | |
88 | } | |
89 | ||
90 | %enddef | |
91 | ||
92 | VECTOR(std::shared_ptr<sigrok::Channel>, Channel) | |
93 | VECTOR(std::shared_ptr<sigrok::HardwareDevice>, HardwareDevice) | |
94 | ||
95 | /* Common macro for mapping between std::map and java.util.Map */ | |
96 | ||
97 | %define MAP_COMMON(CKey, CValue, JKey, JValue) | |
98 | ||
99 | %typemap(jstype) std::map< CKey, CValue > | |
100 | "java.util.Map<JKey, JValue>" | |
101 | ||
102 | %typemap(javain, | |
103 | pre=" $javaclassname temp$javainput = $javaclassname.convertMap($javainput);", | |
104 | pgcppname="temp$javainput") | |
105 | std::map< CKey, CValue > "$javaclassname.getCPtr(temp$javainput)" | |
106 | ||
107 | %typemap(javacode) std::map< CKey, CValue > %{ | |
108 | static $javaclassname convertMap(java.util.Map<JKey,JValue> in) | |
109 | { | |
110 | $javaclassname out = new $javaclassname(); | |
111 | for (java.util.Map.Entry<JKey, JValue> entry : in.entrySet()) | |
112 | out.set(entry.getKey(), entry.getValue()); | |
113 | return out; | |
114 | } | |
115 | %} | |
116 | ||
117 | %typemap(javaout) std::map< CKey, CValue > { | |
118 | return (java.util.Map<JKey, JValue>)$jnicall; | |
119 | } | |
120 | ||
121 | %enddef | |
122 | ||
123 | /* Specialisation for string->string maps. */ | |
124 | ||
125 | MAP_COMMON(std::string, std::string, String, String) | |
126 | ||
127 | %typemap(jni) std::map<std::string, std::string> | |
128 | "jobject" | |
129 | %typemap(jtype) std::map<std::string, std::string> | |
130 | "java.util.Map<String,String>" | |
131 | ||
132 | %typemap(out) std::map<std::string, std::string> { | |
133 | jclass HashMap = jenv->FindClass("java/util/HashMap"); | |
134 | jmethodID init = jenv->GetMethodID(HashMap, "<init>", "()V"); | |
135 | jmethodID put = jenv->GetMethodID(HashMap, "put", | |
136 | "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); | |
137 | $result = jenv->NewObject(HashMap, init); | |
138 | for (auto entry : $1) | |
139 | jenv->CallObjectMethod($result, put, | |
140 | jenv->NewStringUTF(entry.first.c_str()), | |
141 | jenv->NewStringUTF(entry.second.c_str())); | |
142 | } | |
143 | ||
144 | /* Specialisation macro for string->shared_ptr maps. */ | |
145 | ||
146 | %define STRING_TO_SHARED_PTR_MAP(ClassName) | |
147 | ||
148 | %typemap(jni) std::map<std::string, std::shared_ptr<sigrok::ClassName> > | |
149 | "jobject" | |
150 | %typemap(jtype) std::map<std::string, std::shared_ptr<sigrok::ClassName> > | |
151 | "java.util.Map<String,ClassName>" | |
152 | ||
153 | MAP_COMMON(std::string, std::shared_ptr<sigrok::ClassName>, String, ClassName) | |
154 | ||
155 | %typemap(out) std::map<std::string, std::shared_ptr<sigrok::ClassName> > { | |
156 | jclass HashMap = jenv->FindClass("java/util/HashMap"); | |
157 | jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V"); | |
158 | jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put", | |
159 | "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); | |
160 | jclass Value = jenv->FindClass("org/sigrok/core/classes/" #ClassName); | |
161 | jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V"); | |
162 | $result = jenv->NewObject(HashMap, HashMap_init); | |
163 | jlong value; | |
164 | for (auto entry : $1) | |
165 | { | |
166 | *(std::shared_ptr< sigrok::ClassName > **)&value = | |
167 | new std::shared_ptr< sigrok::ClassName>(entry.second); | |
168 | jenv->CallObjectMethod($result, HashMap_put, | |
169 | jenv->NewStringUTF(entry.first.c_str()), | |
170 | jenv->NewObject(Value, Value_init, value, true)); | |
171 | } | |
172 | } | |
173 | ||
174 | %enddef | |
175 | ||
176 | STRING_TO_SHARED_PTR_MAP(Driver) | |
177 | STRING_TO_SHARED_PTR_MAP(InputFormat) | |
178 | STRING_TO_SHARED_PTR_MAP(OutputFormat) | |
179 | ||
180 | /* Specialisation for ConfigKey->Variant maps */ | |
181 | ||
182 | MAP_COMMON(const sigrok::ConfigKey *, Glib::VariantBase, ConfigKey, Variant) | |
183 | ||
184 | %typemap(jni) std::map<const sigrok::ConfigKey, Glib::VariantBase> "jobject" | |
185 | %typemap(jtype) std::map<const sigrok::ConfigKey, Glib::VariantBase> | |
186 | "java.util.Map<ConfigKey,Variant>" | |
187 | ||
188 | %typemap(out) std::map<const sigrok::ConfigKey *, Glib::VariantBase> { | |
189 | jclass HashMap = jenv->FindClass("java/util/HashMap"); | |
190 | jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V"); | |
191 | jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put", | |
192 | "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); | |
193 | jclass ConfigKey = jenv->FindClass("org/sigrok/core/classes/ConfigKey"); | |
194 | jmethodID ConfigKey_init = jenv->GetMethodID(ConfigKey, "<init>", "(JZ)V"); | |
195 | jclass Variant = jenv->FindClass("org/sigrok/core/classes/Variant"); | |
196 | jmethodID Variant_init = jenv->GetMethodID(Variant, "<init>", "(JZ)V"); | |
197 | $result = jenv->NewObject(HashMap, HashMap_init); | |
198 | jlong key; | |
199 | jlong value; | |
200 | for (auto entry : $1) | |
201 | { | |
202 | *(const sigrok::ConfigKey **) &key = entry.first; | |
203 | *(Glib::VariantBase **) &value = new Glib::VariantBase(entry.second); | |
204 | jenv->CallObjectMethod($result, HashMap_put, | |
205 | jenv->NewObject(ConfigKey, ConfigKey_init, key, false)); | |
206 | jenv->NewObject(Variant, Variant_init, value, true)); | |
207 | } | |
208 | } | |
209 | ||
210 | /* Support Driver.scan() with no arguments. */ | |
211 | %ignore sigrok::Driver::scan; | |
212 | ||
213 | %extend sigrok::Driver { | |
214 | std::vector<std::shared_ptr<sigrok::HardwareDevice> > scan() | |
215 | { | |
216 | std::map<const sigrok::ConfigKey *, Glib::VariantBase> options; | |
217 | return $self->scan(options); | |
218 | } | |
219 | ||
220 | std::vector<std::shared_ptr<sigrok::HardwareDevice> > scan( | |
221 | std::map<const sigrok::ConfigKey *, Glib::VariantBase> options) | |
222 | { | |
223 | return $self->scan(options); | |
224 | } | |
225 | } | |
226 | ||
227 | /* Support InputFormat.create_input() with or without options. */ | |
228 | %ignore sigrok::InputFormat::create_input; | |
229 | ||
230 | %extend sigrok::InputFormat { | |
231 | std::shared_ptr<sigrok::Input> create_input() | |
232 | { | |
233 | return $self->create_input(); | |
234 | } | |
235 | ||
236 | std::shared_ptr<sigrok::Input> create_input( | |
237 | std::map<std::string, Glib::VariantBase> options) | |
238 | { | |
239 | return $self->create_input(options); | |
240 | } | |
241 | } | |
242 | ||
243 | /* Support OutputFormat.create_output() with or without options. */ | |
244 | %ignore sigrok::OutputFormat::create_output; | |
245 | ||
246 | %extend sigrok::OutputFormat { | |
247 | std::shared_ptr<sigrok::Output> create_output( | |
248 | std::shared_ptr<sigrok::Device> device) | |
249 | { | |
250 | return $self->create_output(device); | |
251 | } | |
252 | ||
253 | std::shared_ptr<sigrok::Output> create_output( | |
254 | std::shared_ptr<sigrok::Device> device, | |
255 | std::map<std::string, Glib::VariantBase> options) | |
256 | { | |
257 | return $self->create_output(device, options); | |
258 | } | |
259 | ||
260 | std::shared_ptr<sigrok::Output> create_output( | |
261 | std::string filename, | |
262 | std::shared_ptr<sigrok::Device> device) | |
263 | { | |
264 | return $self->create_output(filename, device); | |
265 | } | |
266 | ||
267 | std::shared_ptr<sigrok::Output> create_output( | |
268 | std::string filename, | |
269 | std::shared_ptr<sigrok::Device> device, | |
270 | std::map<std::string, Glib::VariantBase> options) | |
271 | { | |
272 | return $self->create_output(filename, device, options); | |
273 | } | |
274 | } | |
275 | ||
276 | /* Pass JNIEnv parameter to C++ extension methods requiring it. */ | |
277 | ||
278 | %typemap(in, numinputs=0) JNIEnv * %{ | |
279 | $1 = jenv; | |
280 | %} | |
281 | ||
282 | /* Support Java log callbacks. */ | |
283 | ||
284 | %typemap(javaimports) sigrok::Context | |
285 | "import org.sigrok.core.interfaces.LogCallback;" | |
286 | ||
287 | %inline { | |
288 | typedef jobject jlogcallback; | |
289 | } | |
290 | ||
291 | %typemap(jni) jlogcallback "jlogcallback" | |
292 | %typemap(jtype) jlogcallback "LogCallback" | |
293 | %typemap(jstype) jlogcallback "LogCallback" | |
294 | %typemap(javain) jlogcallback "$javainput" | |
295 | ||
296 | %extend sigrok::Context | |
297 | { | |
298 | void add_log_callback(JNIEnv *env, jlogcallback obj) | |
299 | { | |
300 | jclass obj_class = env->GetObjectClass(obj); | |
301 | jmethodID method = env->GetMethodID(obj_class, "run", | |
302 | "(Lorg/sigrok/core/classes/LogLevel;Ljava/lang/String;)V"); | |
303 | jclass LogLevel = (jclass) env->NewGlobalRef( | |
304 | env->FindClass("org/sigrok/core/classes/LogLevel")); | |
305 | jmethodID LogLevel_init = env->GetMethodID(LogLevel, "<init>", "(JZ)V"); | |
306 | jobject obj_ref = env->NewGlobalRef(obj); | |
307 | ||
308 | $self->set_log_callback([=] ( | |
309 | const sigrok::LogLevel *loglevel, | |
310 | std::string message) | |
311 | { | |
312 | jlong loglevel_addr; | |
313 | *(const sigrok::LogLevel **) &loglevel_addr = loglevel; | |
314 | jobject loglevel_obj = env->NewObject( | |
315 | LogLevel, LogLevel_init, loglevel_addr, false); | |
316 | jobject message_obj = env->NewStringUTF(message.c_str()); | |
317 | env->CallVoidMethod(obj_ref, method, loglevel_obj, message_obj); | |
318 | if (env->ExceptionCheck()) | |
319 | throw sigrok::Error(SR_ERR); | |
320 | }); | |
321 | } | |
322 | } | |
323 | ||
324 | /* Support Java datafeed callbacks. */ | |
325 | ||
326 | %typemap(javaimports) sigrok::Session | |
327 | "import org.sigrok.core.interfaces.DatafeedCallback;" | |
328 | ||
329 | %inline { | |
330 | typedef jobject jdatafeedcallback; | |
331 | } | |
332 | ||
333 | %typemap(jni) jdatafeedcallback "jdatafeedcallback" | |
334 | %typemap(jtype) jdatafeedcallback "DatafeedCallback" | |
335 | %typemap(jstype) jdatafeedcallback "DatafeedCallback" | |
336 | %typemap(javain) jdatafeedcallback "$javainput" | |
337 | ||
338 | %extend sigrok::Session | |
339 | { | |
340 | void add_datafeed_callback(JNIEnv *env, jdatafeedcallback obj) | |
341 | { | |
342 | jclass obj_class = env->GetObjectClass(obj); | |
343 | jmethodID method = env->GetMethodID(obj_class, "run", | |
344 | "(Lorg/sigrok/core/classes/Device;Lorg/sigrok/core/classes/Packet;)V"); | |
345 | jclass Device = (jclass) env->NewGlobalRef( | |
346 | env->FindClass("org/sigrok/core/classes/Device")); | |
347 | jmethodID Device_init = env->GetMethodID(Device, "<init>", "(JZ)V"); | |
348 | jclass Packet = (jclass) env->NewGlobalRef( | |
349 | env->FindClass("org/sigrok/core/classes/Packet")); | |
350 | jmethodID Packet_init = env->GetMethodID(Packet, "<init>", "(JZ)V"); | |
351 | jobject obj_ref = env->NewGlobalRef(obj); | |
352 | ||
353 | $self->add_datafeed_callback([=] ( | |
354 | std::shared_ptr<sigrok::Device> device, | |
355 | std::shared_ptr<sigrok::Packet> packet) | |
356 | { | |
357 | jlong device_addr; | |
358 | jlong packet_addr; | |
359 | *(std::shared_ptr<sigrok::Device> **) &device_addr = | |
360 | new std::shared_ptr<sigrok::Device>(device); | |
361 | *(std::shared_ptr<sigrok::Packet> **) &packet_addr = | |
362 | new std::shared_ptr<sigrok::Packet>(packet); | |
363 | jobject device_obj = env->NewObject( | |
364 | Device, Device_init, device_addr, true); | |
365 | jobject packet_obj = env->NewObject( | |
366 | Packet, Packet_init, packet_addr, true); | |
367 | env->CallVoidMethod(obj_ref, method, device_obj, packet_obj); | |
368 | if (env->ExceptionCheck()) | |
369 | throw sigrok::Error(SR_ERR); | |
370 | }); | |
371 | } | |
372 | } | |
373 | ||
374 | %include "doc.i" | |
375 | ||
376 | %define %attributevector(Class, Type, Name, Get) | |
377 | %attributeval(sigrok::Class, Type, Name, Get); | |
378 | %enddef | |
379 | ||
380 | %define %attributemap(Class, Type, Name, Get) | |
381 | %attributeval(sigrok::Class, Type, Name, Get); | |
382 | %enddef | |
383 | ||
384 | %define %enumextras(Class) | |
385 | %enddef | |
386 | ||
387 | /* Ignore this for now, needs a fix. */ | |
388 | %ignore sigrok::Context::create_analog_packet; | |
389 | ||
390 | %include "bindings/swig/classes.i" | |
391 |