3 /* Automatically load JNI library. */
4 %pragma(java) jniclasscode=%{
6 System.loadLibrary("sigrok_java_core_classes");
10 /* Map Java FileDescriptor objects to int fds */
11 %typemap(jni) int fd "jobject"
12 %typemap(jtype) int fd "java.io.FileDescriptor"
13 %typemap(jstype) int fd "java.io.FileDescriptor"
14 %typemap(javain) int fd "$javainput"
17 jclass FileDescriptor = jenv->FindClass("java/io/FileDescriptor");
18 jfieldID fd = jenv->GetFieldID(FileDescriptor, "fd", "I");
19 $1 = jenv->GetIntField($input, fd);
22 /* Map Glib::VariantBase to a Variant class in Java */
23 %rename(Variant) VariantBase;
28 /* Map between std::vector and java.util.Vector */
29 %define VECTOR(CValue, JValue)
31 %typemap(jni) std::vector< CValue > "jobject"
32 %typemap(jtype) std::vector< CValue > "java.util.Vector<JValue>"
33 %typemap(jstype) std::vector< CValue > "java.util.Vector<JValue>"
36 pre=" $javaclassname temp$javainput = $javaclassname.convertVector($javainput);",
37 pgcppname="temp$javainput")
38 std::vector< CValue > "$javaclassname.getCPtr(temp$javainput)"
40 %typemap(javacode) std::vector< CValue > %{
41 static $javaclassname convertVector(java.util.Vector<JValue> in)
43 $javaclassname out = new $javaclassname();
44 for (JValue value : in)
50 %typemap(javaout) std::vector< CValue > {
51 return (java.util.Vector<JValue>)$jnicall;
54 %typemap(out) std::vector< CValue > {
55 jclass Vector = jenv->FindClass("java/util/Vector");
56 jmethodID Vector_init = jenv->GetMethodID(Vector, "<init>", "()V");
57 jmethodID Vector_add = jenv->GetMethodID(Vector, "add",
58 "(Ljava/lang/Object;)Z");
59 jclass Value = jenv->FindClass("org/sigrok/core/classes/" #JValue);
60 jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
61 $result = jenv->NewObject(Vector, Vector_init);
65 *(CValue **) &value = new CValue(entry);
66 jenv->CallObjectMethod($result, Vector_add,
67 jenv->NewObject(Value, Value_init, value, true));
73 VECTOR(std::shared_ptr<sigrok::Channel>, Channel)
74 VECTOR(std::shared_ptr<sigrok::HardwareDevice>, HardwareDevice)
76 /* Common macro for mapping between std::map and java.util.Map */
78 %define MAP_COMMON(CKey, CValue, JKey, JValue)
80 %typemap(jstype) std::map< CKey, CValue >
81 "java.util.Map<JKey, JValue>"
84 pre=" $javaclassname temp$javainput = $javaclassname.convertMap($javainput);",
85 pgcppname="temp$javainput")
86 std::map< CKey, CValue > "$javaclassname.getCPtr(temp$javainput)"
88 %typemap(javacode) std::map< CKey, CValue > %{
89 static $javaclassname convertMap(java.util.Map<JKey,JValue> in)
91 $javaclassname out = new $javaclassname();
92 for (java.util.Map.Entry<JKey, JValue> entry : in.entrySet())
93 out.set(entry.getKey(), entry.getValue());
98 %typemap(javaout) std::map< CKey, CValue > {
99 return (java.util.Map<JKey, JValue>)$jnicall;
104 /* Specialisation for string->string maps. */
106 MAP_COMMON(std::string, std::string, String, String)
108 %typemap(out) std::map<std::string, std::string> {
109 jclass HashMap = jenv->FindClass("java/util/HashMap");
110 jmethodID init = jenv->GetMethodID(HashMap, "<init>", "()V");
111 jmethodID put = jenv->GetMethodID(HashMap, "put",
112 "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
113 $result = jenv->NewObject(HashMap, init);
114 for (auto entry : $1)
115 jenv->CallObjectMethod($result, put,
116 jenv->NewStringUTF(entry.first.c_str()),
117 jenv->NewStringUTF(entry.second.c_str()));
120 /* Specialisation macro for string->shared_ptr maps. */
122 %define STRING_TO_SHARED_PTR_MAP(ClassName)
124 %typemap(jni) std::map<std::string, std::shared_ptr<sigrok::ClassName> >
126 %typemap(jtype) std::map<std::string, std::shared_ptr<sigrok::ClassName> >
127 "java.util.Map<String,ClassName>"
129 MAP_COMMON(std::string, std::shared_ptr<sigrok::ClassName>, String, ClassName)
131 %typemap(out) std::map<std::string, std::shared_ptr<sigrok::ClassName> > {
132 jclass HashMap = jenv->FindClass("java/util/HashMap");
133 jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V");
134 jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put",
135 "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
136 jclass Value = jenv->FindClass("org/sigrok/core/classes/" #ClassName);
137 jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
138 $result = jenv->NewObject(HashMap, HashMap_init);
140 for (auto entry : $1)
142 *(std::shared_ptr< sigrok::ClassName > **)&value =
143 new std::shared_ptr< sigrok::ClassName>(entry.second);
144 jenv->CallObjectMethod($result, HashMap_put,
145 jenv->NewStringUTF(entry.first.c_str()),
146 jenv->NewObject(Value, Value_init, value, true));
152 STRING_TO_SHARED_PTR_MAP(Driver)
153 STRING_TO_SHARED_PTR_MAP(InputFormat)
154 STRING_TO_SHARED_PTR_MAP(OutputFormat)
156 /* Specialisation for ConfigKey->Variant maps */
158 MAP_COMMON(const sigrok::ConfigKey *, Glib::VariantBase, ConfigKey, Variant)
160 %typemap(jni) std::map<const sigrok::ConfigKey, Glib::VariantBase> "jobject"
161 %typemap(jtype) std::map<const sigrok::ConfigKey, Glib::VariantBase>
162 "java.util.Map<ConfigKey,Variant>"
164 %typemap(out) std::map<const sigrok::ConfigKey *, Glib::VariantBase> {
165 jclass HashMap = jenv->FindClass("java/util/HashMap");
166 jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V");
167 jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put",
168 "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
169 jclass ConfigKey = jenv->FindClass("org/sigrok/core/classes/ConfigKey");
170 jmethodID ConfigKey_init = jenv->GetMethodID(ConfigKey, "<init>", "(JZ)V");
171 jclass Variant = jenv->FindClass("org/sigrok/core/classes/Variant");
172 jmethodID Variant_init = jenv->GetMethodID(Variant, "<init>", "(JZ)V");
173 $result = jenv->NewObject(HashMap, HashMap_init);
176 for (auto entry : $1)
178 *(const sigrok::ConfigKey **) &key = entry.first;
179 *(Glib::VariantBase **) &value = new Glib::VariantBase(entry.second);
180 jenv->CallObjectMethod($result, HashMap_put,
181 jenv->NewObject(ConfigKey, ConfigKey_init, key, false));
182 jenv->NewObject(Variant, Variant_init, value, true));
186 /* Support Driver.scan() with no arguments. */
187 %extend sigrok::Driver {
188 std::vector<std::shared_ptr<sigrok::HardwareDevice> > scan()
190 std::map<const sigrok::ConfigKey *, Glib::VariantBase> options;
191 return $self->scan(options);
195 /* Support OutputFormat.create_output(device) with no options. */
196 %extend sigrok::OutputFormat {
197 std::shared_ptr<sigrok::Output> create_output(
198 std::shared_ptr<sigrok::Device> device)
200 std::map<std::string, std::string> options;
201 return $self->create_output(device, options);
205 /* Pass JNIEnv parameter to C++ extension methods requiring it. */
207 %typemap(in, numinputs=0) JNIEnv * %{
211 /* Support Java log callbacks. */
214 typedef jobject jlogcallback;
217 %typemap(jni) jlogcallback "jlogcallback"
218 %typemap(jtype) jlogcallback "LogCallback"
219 %typemap(jstype) jlogcallback "LogCallback"
220 %typemap(javain) jlogcallback "$javainput"
222 %extend sigrok::Context
224 void add_log_callback(JNIEnv *env, jlogcallback obj)
226 jclass obj_class = env->GetObjectClass(obj);
227 jmethodID method = env->GetMethodID(obj_class, "run",
228 "(Lorg/sigrok/core/classes/LogLevel;Ljava/lang/String;)V");
229 jclass LogLevel = (jclass) env->NewGlobalRef(
230 env->FindClass("org/sigrok/core/classes/LogLevel"));
231 jmethodID LogLevel_init = env->GetMethodID(LogLevel, "<init>", "(JZ)V");
232 jobject obj_ref = env->NewGlobalRef(obj);
234 $self->set_log_callback([=] (
235 const sigrok::LogLevel *loglevel,
239 *(const sigrok::LogLevel **) &loglevel_addr = loglevel;
240 jobject loglevel_obj = env->NewObject(
241 LogLevel, LogLevel_init, loglevel_addr, false);
242 jobject message_obj = env->NewStringUTF(message.c_str());
243 env->CallVoidMethod(obj_ref, method, loglevel_obj, message_obj);
244 if (env->ExceptionCheck())
245 throw sigrok::Error(SR_ERR);
250 /* Support Java datafeed callbacks. */
253 typedef jobject jdatafeedcallback;
256 %typemap(jni) jdatafeedcallback "jdatafeedcallback"
257 %typemap(jtype) jdatafeedcallback "DatafeedCallback"
258 %typemap(jstype) jdatafeedcallback "DatafeedCallback"
259 %typemap(javain) jdatafeedcallback "$javainput"
261 %extend sigrok::Session
263 void add_datafeed_callback(JNIEnv *env, jdatafeedcallback obj)
265 jclass obj_class = env->GetObjectClass(obj);
266 jmethodID method = env->GetMethodID(obj_class, "run",
267 "(Lorg/sigrok/core/classes/Device;Lorg/sigrok/core/classes/Packet;)V");
268 jclass Device = (jclass) env->NewGlobalRef(
269 env->FindClass("org/sigrok/core/classes/Device"));
270 jmethodID Device_init = env->GetMethodID(Device, "<init>", "(JZ)V");
271 jclass Packet = (jclass) env->NewGlobalRef(
272 env->FindClass("org/sigrok/core/classes/Packet"));
273 jmethodID Packet_init = env->GetMethodID(Packet, "<init>", "(JZ)V");
274 jobject obj_ref = env->NewGlobalRef(obj);
276 $self->add_datafeed_callback([=] (
277 std::shared_ptr<sigrok::Device> device,
278 std::shared_ptr<sigrok::Packet> packet)
282 *(std::shared_ptr<sigrok::Device> **) &device_addr =
283 new std::shared_ptr<sigrok::Device>(device);
284 *(std::shared_ptr<sigrok::Packet> **) &packet_addr =
285 new std::shared_ptr<sigrok::Packet>(packet);
286 jobject device_obj = env->NewObject(
287 Device, Device_init, device_addr, true);
288 jobject packet_obj = env->NewObject(
289 Packet, Packet_init, packet_addr, true);
290 env->CallVoidMethod(obj_ref, method, device_obj, packet_obj);
291 if (env->ExceptionCheck())
292 throw sigrok::Error(SR_ERR);
297 /* Support Java event source callbacks. */
300 typedef jobject jsourcecallback;
303 %typemap(jni) jsourcecallback "jsourcecallback"
304 %typemap(jtype) jsourcecallback "SourceCallback"
305 %typemap(jstype) jsourcecallback "SourceCallback"
306 %typemap(javain) jsourcecallback "$javainput"
308 %extend sigrok::EventSource
310 std::shared_ptr<sigrok::EventSource> create(
311 int fd, Glib::IOCondition events, int timeout,
312 JNIEnv *env, jsourcecallback obj)
315 jclass obj_class = env->GetObjectClass(obj);
316 jmethodID method = env->GetMethodID(obj_class, "run", "(I)V");
317 jobject obj_ref = env->NewGlobalRef(obj);
319 return sigrok::EventSource::create(fd, events, timeout, [=] (int revents)
321 bool result = env->CallBooleanMethod(obj_ref, method, revents);
322 if (env->ExceptionCheck())
323 throw sigrok::Error(SR_ERR);
329 %include "bindings/swig/classes.i"