Qt 6.x
The Qt SDK
Loading...
Searching...
No Matches
qjniobject.h
Go to the documentation of this file.
1// Copyright (C) 2022 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#ifndef QJNIOBJECT_H
5#define QJNIOBJECT_H
6
7#include <QtCore/qsharedpointer.h>
8
9#if defined(Q_QDOC) || defined(Q_OS_ANDROID)
10#include <jni.h>
11#include <QtCore/qjnienvironment.h>
12#include <QtCore/qjnitypes.h>
13
14QT_BEGIN_NAMESPACE
15
16class QJniObjectPrivate;
17
18class Q_CORE_EXPORT QJniObject
19{
20public:
21 QJniObject();
22 explicit QJniObject(const char *className);
23 explicit QJniObject(const char *className, const char *signature, ...);
24 template<typename ...Args
25#ifndef Q_QDOC
26 , std::enable_if_t<!std::disjunction_v<QtJniTypes::IsStringType<std::decay_t<Args>>...>>* = nullptr
27#endif
28 >
29 explicit QJniObject(const char *className, Args &&...args)
30 : QJniObject(className, QtJniTypes::constructorSignature<Args...>().data(),
31 std::forward<Args>(args)...)
32 {}
33 explicit QJniObject(jclass clazz);
34 explicit QJniObject(jclass clazz, const char *signature, ...);
35 template<typename ...Args
36#ifndef Q_QDOC
37 , std::enable_if_t<!std::disjunction_v<QtJniTypes::IsStringType<std::decay_t<Args>>...>>* = nullptr
38#endif
39 >
40 explicit QJniObject(jclass clazz, Args &&...args)
41 : QJniObject(clazz, QtJniTypes::constructorSignature<Args...>().data(),
42 std::forward<Args>(args)...)
43 {}
44 QJniObject(jobject globalRef);
45 inline QJniObject(QtJniTypes::Object wrapper) noexcept : QJniObject(jobject(wrapper)) {}
46 ~QJniObject();
47
48 template<typename Class, typename ...Args>
49 static inline QJniObject construct(Args &&...args)
50 {
51 return QJniObject(QtJniTypes::className<Class>().data(),
52 QtJniTypes::constructorSignature<Args...>().data(),
53 std::forward<Args>(args)...);
54 }
55
56 jobject object() const;
57 template <typename T> T object() const
58 {
59 QtJniTypes::assertObjectType<T>();
60 return static_cast<T>(javaObject());
61 }
62
63 jclass objectClass() const;
64 QByteArray className() const;
65
66 template <typename Ret, typename ...Args>
67 auto callMethod(const char *methodName, const char *signature, Args &&...args) const
68 {
69 if constexpr (QtJniTypes::isObjectType<Ret>()) {
70 return callObjectMethod(methodName, signature, std::forward<Args>(args)...);
71 } else {
72 QtJniTypes::assertPrimitiveType<Ret>();
73 QJniEnvironment env;
74 jmethodID id = getCachedMethodID(env.jniEnv(), methodName, signature);
75 if (id) {
76 if constexpr (std::is_same<Ret, void>::value) {
77 callVoidMethodV(env.jniEnv(), id, std::forward<Args>(args)...);
78 env.checkAndClearExceptions();
79 } else {
80 Ret res{};
81 callMethodForType<Ret>(env.jniEnv(), res, object(), id, std::forward<Args>(args)...);
82 if (env.checkAndClearExceptions())
83 res = {};
84 return res;
85 }
86 }
87 if constexpr (!std::is_same<Ret, void>::value)
88 return Ret{};
89 }
90 }
91
92 template <typename Ret, typename ...Args>
93 auto callMethod(const char *methodName, Args &&...args) const
94 {
95 constexpr auto signature = QtJniTypes::methodSignature<Ret, Args...>();
96 if constexpr (std::is_same<Ret, void>::value) {
97 callMethod<void>(methodName, signature.data(), std::forward<Args>(args)...);
98 } else {
99 return callMethod<Ret>(methodName, signature.data(), std::forward<Args>(args)...);
100 }
101 }
102
103 template <typename Ret, typename ...Args>
104 QJniObject callObjectMethod(const char *methodName, Args &&...args) const
105 {
106 QtJniTypes::assertObjectType<Ret>();
107 constexpr auto signature = QtJniTypes::methodSignature<Ret, Args...>();
108 return callObjectMethod(methodName, signature.data(), std::forward<Args>(args)...);
109 }
110
111 QJniObject callObjectMethod(const char *methodName, const char *signature, ...) const;
112
113 template <typename Ret, typename ...Args>
114 static auto callStaticMethod(const char *className, const char *methodName, const char *signature, Args &&...args)
115 {
116 QJniEnvironment env;
117 jclass clazz = QJniObject::loadClass(className, env.jniEnv());
118 return callStaticMethod<Ret>(clazz, methodName, signature, std::forward<Args>(args)...);
119 }
120
121 template <typename Ret, typename ...Args>
122 static auto callStaticMethod(jclass clazz, const char *methodName, const char *signature, Args &&...args)
123 {
124 QJniEnvironment env;
125 jmethodID id = getMethodID(env.jniEnv(), clazz, methodName, signature, true);
126 return callStaticMethod<Ret, Args...>(clazz, id, std::forward<Args>(args)...);
127 }
128
129 template <typename Ret, typename ...Args>
130 static auto callStaticMethod(jclass clazz, jmethodID methodId, Args &&...args)
131 {
132 if constexpr (QtJniTypes::isObjectType<Ret>()) {
133 return callStaticObjectMethod(clazz, methodId, std::forward<Args>(args)...);
134 } else {
135 QtJniTypes::assertPrimitiveType<Ret>();
136 QJniEnvironment env;
137 if (clazz && methodId) {
138 if constexpr (std::is_same<Ret, void>::value) {
139 callStaticMethodForVoid(env.jniEnv(), clazz, methodId, std::forward<Args>(args)...);
140 env.checkAndClearExceptions();
141 } else {
142 Ret res{};
143 callStaticMethodForType<Ret>(env.jniEnv(), res, clazz, methodId, std::forward<Args>(args)...);
144 if (env.checkAndClearExceptions())
145 res = {};
146 return res;
147 }
148 }
149 if constexpr (!std::is_same<Ret, void>::value)
150 return Ret{};
151 }
152 }
153
154 template <typename Ret, typename ...Args>
155 static auto callStaticMethod(const char *className, const char *methodName, Args &&...args)
156 {
157 QJniEnvironment env;
158 jclass clazz = QJniObject::loadClass(className, env.jniEnv());
159 return callStaticMethod<Ret, Args...>(clazz, methodName, std::forward<Args>(args)...);
160 }
161
162 template <typename Ret, typename ...Args>
163 static auto callStaticMethod(jclass clazz, const char *methodName, Args &&...args)
164 {
165 constexpr auto signature = QtJniTypes::methodSignature<Ret, Args...>();
166 return callStaticMethod<Ret>(clazz, methodName, signature.data(), std::forward<Args>(args)...);
167 }
168
169 static QJniObject callStaticObjectMethod(const char *className, const char *methodName,
170 const char *signature, ...);
171
172 static QJniObject callStaticObjectMethod(jclass clazz, const char *methodName,
173 const char *signature, ...);
174
175 static QJniObject callStaticObjectMethod(jclass clazz, jmethodID methodId, ...);
176
177
178 template <typename Ret, typename ...Args>
179 static QJniObject callStaticObjectMethod(const char *className, const char *methodName, Args &&...args)
180 {
181 QtJniTypes::assertObjectType<Ret>();
182 constexpr auto signature = QtJniTypes::methodSignature<Ret, Args...>();
183 return callStaticObjectMethod(className, methodName, signature.data(), std::forward<Args>(args)...);
184 }
185
186 template <typename Ret, typename ...Args>
187 static QJniObject callStaticObjectMethod(jclass clazz, const char *methodName, Args &&...args)
188 {
189 QtJniTypes::assertObjectType<Ret>();
190 constexpr auto signature = QtJniTypes::methodSignature<Ret, Args...>();
191 return callStaticObjectMethod(clazz, methodName, signature.data(), std::forward<Args>(args)...);
192 }
193
194 template <typename T> auto getField(const char *fieldName) const
195 {
196 if constexpr (QtJniTypes::isObjectType<T>()) {
197 return getObjectField<T>(fieldName);
198 } else {
199 QtJniTypes::assertPrimitiveType<T>();
200 QJniEnvironment env;
201 T res{};
202 constexpr auto signature = QtJniTypes::fieldSignature<T>();
203 jfieldID id = getCachedFieldID(env.jniEnv(), fieldName, signature);
204 if (id) {
205 getFieldForType<T>(env.jniEnv(), res, object(), id);
206 if (env.checkAndClearExceptions())
207 res = {};
208 }
209 return res;
210 }
211 }
212
213 template <typename T>
214 static auto getStaticField(const char *className, const char *fieldName)
215 {
216 if constexpr (QtJniTypes::isObjectType<T>()) {
217 return getStaticObjectField<T>(className, fieldName);
218 } else {
219 QtJniTypes::assertPrimitiveType<T>();
220 QJniEnvironment env;
221 jclass clazz = QJniObject::loadClass(className, env.jniEnv());
222 T res{};
223 if (!clazz)
224 return res;
225
226 constexpr auto signature = QtJniTypes::fieldSignature<T>();
227 jfieldID id = getCachedFieldID(env.jniEnv(), clazz,
228 QJniObject::toBinaryEncClassName(className),
229 fieldName,
230 signature, true);
231 if (!id)
232 return res;
233
234 getStaticFieldForType<T>(env.jniEnv(), res, clazz, id);
235 if (env.checkAndClearExceptions())
236 res = {};
237 return res;
238 }
239 }
240
241 template <typename T>
242 static auto getStaticField(jclass clazz, const char *fieldName)
243 {
244 if constexpr (QtJniTypes::isObjectType<T>()) {
245 return getStaticObjectField<T>(clazz, fieldName);
246 } else {
247 QtJniTypes::assertPrimitiveType<T>();
248 QJniEnvironment env;
249 T res{};
250 constexpr auto signature = QtJniTypes::fieldSignature<T>();
251 jfieldID id = getFieldID(env.jniEnv(), clazz, fieldName, signature, true);
252 if (id) {
253 getStaticFieldForType<T>(env.jniEnv(), res, clazz, id);
254 if (env.checkAndClearExceptions())
255 res = {};
256 }
257 return res;
258 }
259 }
260
261 template <typename Klass, typename T>
262 static auto getStaticField(const char *fieldName)
263 {
264 return getStaticField<T>(QtJniTypes::className<Klass>(), fieldName);
265 }
266
267 template <typename T>
268 QJniObject getObjectField(const char *fieldName) const
269 {
270 QtJniTypes::assertObjectType<T>();
271 constexpr auto signature = QtJniTypes::fieldSignature<T>();
272 return getObjectField(fieldName, signature);
273 }
274
275 QJniObject getObjectField(const char *fieldName, const char *signature) const;
276
277 template <typename T>
278 static QJniObject getStaticObjectField(const char *className, const char *fieldName)
279 {
280 QtJniTypes::assertObjectType<T>();
281 constexpr auto signature = QtJniTypes::fieldSignature<T>();
282 return getStaticObjectField(className, fieldName, signature);
283 }
284
285 static QJniObject getStaticObjectField(const char *className,
286 const char *fieldName,
287 const char *signature);
288
289 template <typename T>
290 static QJniObject getStaticObjectField(jclass clazz, const char *fieldName)
291 {
292 QtJniTypes::assertObjectType<T>();
293 constexpr auto signature = QtJniTypes::fieldSignature<T>();
294 return getStaticObjectField(clazz, fieldName, signature);
295 }
296
297 static QJniObject getStaticObjectField(jclass clazz, const char *fieldName,
298 const char *signature);
299
300 template <typename T> void setField(const char *fieldName, T value)
301 {
302 QtJniTypes::assertType<T>();
303 QJniEnvironment env;
304 constexpr auto signature = QtJniTypes::fieldSignature<T>();
305 jfieldID id = getCachedFieldID(env.jniEnv(), fieldName, signature);
306 if (id) {
307 setFieldForType<T>(env.jniEnv(), object(), id, value);
308 env.checkAndClearExceptions();
309 }
310 }
311
312 template <typename T>
313 void setField(const char *fieldName, const char *signature, T value)
314 {
315 QtJniTypes::assertType<T>();
316 QJniEnvironment env;
317 jfieldID id = getCachedFieldID(env.jniEnv(), fieldName, signature);
318 if (id) {
319 setFieldForType<T>(env.jniEnv(), object(), id, value);
320 env.checkAndClearExceptions();
321 }
322 }
323
324 template <typename T>
325 static void setStaticField(const char *className, const char *fieldName, T value)
326 {
327 QtJniTypes::assertType<T>();
328 QJniEnvironment env;
329 jclass clazz = QJniObject::loadClass(className, env.jniEnv());
330 if (!clazz)
331 return;
332
333 constexpr auto signature = QtJniTypes::fieldSignature<T>();
334 jfieldID id = getCachedFieldID(env.jniEnv(), clazz, className, fieldName,
335 signature, true);
336 if (!id)
337 return;
338
339 setStaticFieldForType<T>(env.jniEnv(), clazz, id, value);
340 env.checkAndClearExceptions();
341 }
342
343 template <typename T>
344 static void setStaticField(const char *className, const char *fieldName,
345 const char *signature, T value)
346 {
347 QtJniTypes::assertType<T>();
348 QJniEnvironment env;
349 jclass clazz = QJniObject::loadClass(className, env.jniEnv());
350
351 if (!clazz)
352 return;
353
354 jfieldID id = getCachedFieldID(env.jniEnv(), clazz, className, fieldName,
355 signature, true);
356 if (id) {
357 setStaticFieldForType<T>(env.jniEnv(), clazz, id, value);
358 env.checkAndClearExceptions();
359 }
360 }
361
362 template <typename T>
363 static void setStaticField(jclass clazz, const char *fieldName,
364 const char *signature, T value)
365 {
366 QtJniTypes::assertType<T>();
367 QJniEnvironment env;
368 jfieldID id = getFieldID(env.jniEnv(), clazz, fieldName, signature, true);
369
370 if (id) {
371 setStaticFieldForType<T>(env.jniEnv(), clazz, id, value);
372 env.checkAndClearExceptions();
373 }
374 }
375
376 template <typename T>
377 static void setStaticField(jclass clazz, const char *fieldName, T value)
378 {
379 QtJniTypes::assertType<T>();
380 QJniEnvironment env;
381 constexpr auto signature = QtJniTypes::fieldSignature<T>();
382 jfieldID id = getFieldID(env.jniEnv(), clazz, fieldName, signature, true);
383 if (id) {
384 setStaticFieldForType<T>(env.jniEnv(), clazz, id, value);
385 env.checkAndClearExceptions();
386 }
387 }
388
389 template <typename Klass, typename T>
390 static void setStaticField(const char *fieldName, T value)
391 {
392 setStaticField(QtJniTypes::className<Klass>(), fieldName, value);
393 }
394
395 static QJniObject fromString(const QString &string);
396 QString toString() const;
397
398 static bool isClassAvailable(const char *className);
399 bool isValid() const;
400
401 // This function takes ownership of the jobject and releases the local ref. before returning.
402 static QJniObject fromLocalRef(jobject lref);
403
404 template <typename T> QJniObject &operator=(T obj)
405 {
406 QtJniTypes::assertType<T>();
407 assign(static_cast<T>(obj));
408 return *this;
409 }
410
411private:
412 struct QVaListPrivate { operator va_list &() const { return m_args; } va_list &m_args; };
413 QJniObject(const char *className, const char *signature, const QVaListPrivate &args);
414 QJniObject(jclass clazz, const char *signature, const QVaListPrivate &args);
415
416 static jclass loadClass(const QByteArray &className, JNIEnv *env, bool binEncoded = false);
417 static QByteArray toBinaryEncClassName(const QByteArray &className);
418 static QJniObject getCleanJniObject(jobject obj);
419
420 static jfieldID getCachedFieldID(JNIEnv *env, jclass clazz, const QByteArray &className,
421 const char *name, const char *signature,
422 bool isStatic = false);
423 jfieldID getCachedFieldID(JNIEnv *env, const char *name, const char *signature,
424 bool isStatic = false) const;
425 static jmethodID getCachedMethodID(JNIEnv *env, jclass clazz, const QByteArray &className,
426 const char *name, const char *signature,
427 bool isStatic = false);
428 jmethodID getCachedMethodID(JNIEnv *env, const char *name, const char *signature,
429 bool isStatic = false) const;
430
431 static jfieldID getFieldID(JNIEnv *env, jclass clazz, const char *name,
432 const char *signature, bool isStatic = false);
433 static jmethodID getMethodID(JNIEnv *env, jclass clazz, const char *name,
434 const char *signature, bool isStatic = false);
435
436 void callVoidMethodV(JNIEnv *env, jmethodID id, ...) const;
437 // ### Qt 7: merge into ... overload
438 void callVoidMethodV(JNIEnv *env, jmethodID id, va_list args) const;
439 // ### Qt 7: remove unused
440 QJniObject callObjectMethodV(const char *methodName, const char *signature,
441 va_list args) const;
442 // ### Qt 7: remove unused
443 static QJniObject callStaticObjectMethodV(const char *className, const char *methodName,
444 const char *signature, va_list args);
445 // ### Qt 7: remove unused
446 static QJniObject callStaticObjectMethodV(jclass clazz, const char *methodName,
447 const char *signature, va_list args);
448
449 bool isSameObject(jobject obj) const;
450 bool isSameObject(const QJniObject &other) const;
451 void assign(jobject obj);
452 jobject javaObject() const;
453
454 friend bool operator==(const QJniObject &, const QJniObject &);
455 friend bool operator!=(const QJniObject&, const QJniObject&);
456
457 template<typename T>
458 static constexpr void callMethodForType(JNIEnv *env, T &res, jobject obj,
459 jmethodID id, ...)
460 {
461 va_list args = {};
462 va_start(args, id);
463
464 if constexpr(std::is_same<T, jboolean>::value)
465 res = env->CallBooleanMethodV(obj, id, args);
466 else if constexpr(std::is_same<T, jbyte>::value)
467 res = env->CallByteMethodV(obj, id, args);
468 else if constexpr(std::is_same<T, jchar>::value)
469 res = env->CallCharMethodV(obj, id, args);
470 else if constexpr(std::is_same<T, jshort>::value)
471 res = env->CallShortMethodV(obj, id, args);
472 else if constexpr(std::is_same<T, jint>::value)
473 res = env->CallIntMethodV(obj, id, args);
474 else if constexpr(std::is_same<T, jlong>::value)
475 res = env->CallLongMethodV(obj, id, args);
476 else if constexpr(std::is_same<T, jfloat>::value)
477 res = env->CallFloatMethodV(obj, id, args);
478 else if constexpr(std::is_same<T, jdouble>::value)
479 res = env->CallDoubleMethodV(obj, id, args);
480 else
481 QtJniTypes::staticAssertTypeMismatch();
482 va_end(args);
483 }
484
485 template<typename T>
486 static constexpr void callStaticMethodForType(JNIEnv *env, T &res, jclass clazz,
487 jmethodID id, ...)
488 {
489 va_list args = {};
490 va_start(args, id);
491 if constexpr(std::is_same<T, jboolean>::value)
492 res = env->CallStaticBooleanMethodV(clazz, id, args);
493 else if constexpr(std::is_same<T, jbyte>::value)
494 res = env->CallStaticByteMethodV(clazz, id, args);
495 else if constexpr(std::is_same<T, jchar>::value)
496 res = env->CallStaticCharMethodV(clazz, id, args);
497 else if constexpr(std::is_same<T, jshort>::value)
498 res = env->CallStaticShortMethodV(clazz, id, args);
499 else if constexpr(std::is_same<T, jint>::value)
500 res = env->CallStaticIntMethodV(clazz, id, args);
501 else if constexpr(std::is_same<T, jlong>::value)
502 res = env->CallStaticLongMethodV(clazz, id, args);
503 else if constexpr(std::is_same<T, jfloat>::value)
504 res = env->CallStaticFloatMethodV(clazz, id, args);
505 else if constexpr(std::is_same<T, jdouble>::value)
506 res = env->CallStaticDoubleMethodV(clazz, id, args);
507 else
508 QtJniTypes::staticAssertTypeMismatch();
509 va_end(args);
510 }
511
512 static void callStaticMethodForVoid(JNIEnv *env, jclass clazz, jmethodID id, ...)
513 {
514 va_list args;
515 va_start(args, id);
516 env->CallStaticVoidMethodV(clazz, id, args);
517 va_end(args);
518 }
519
520
521 template<typename T>
522 static constexpr void getFieldForType(JNIEnv *env, T &res, jobject obj,
523 jfieldID id)
524 {
525 if constexpr(std::is_same<T, jboolean>::value)
526 res = env->GetBooleanField(obj, id);
527 else if constexpr(std::is_same<T, jbyte>::value)
528 res = env->GetByteField(obj, id);
529 else if constexpr(std::is_same<T, jchar>::value)
530 res = env->GetCharField(obj, id);
531 else if constexpr(std::is_same<T, jshort>::value)
532 res = env->GetShortField(obj, id);
533 else if constexpr(std::is_same<T, jint>::value)
534 res = env->GetIntField(obj, id);
535 else if constexpr(std::is_same<T, jlong>::value)
536 res = env->GetLongField(obj, id);
537 else if constexpr(std::is_same<T, jfloat>::value)
538 res = env->GetFloatField(obj, id);
539 else if constexpr(std::is_same<T, jdouble>::value)
540 res = env->GetDoubleField(obj, id);
541 else
542 QtJniTypes::staticAssertTypeMismatch();
543 }
544
545 template<typename T>
546 static constexpr void getStaticFieldForType(JNIEnv *env, T &res, jclass clazz,
547 jfieldID id)
548 {
549 if constexpr(std::is_same<T, jboolean>::value)
550 res = env->GetStaticBooleanField(clazz, id);
551 else if constexpr(std::is_same<T, jbyte>::value)
552 res = env->GetStaticByteField(clazz, id);
553 else if constexpr(std::is_same<T, jchar>::value)
554 res = env->GetStaticCharField(clazz, id);
555 else if constexpr(std::is_same<T, jshort>::value)
556 res = env->GetStaticShortField(clazz, id);
557 else if constexpr(std::is_same<T, jint>::value)
558 res = env->GetStaticIntField(clazz, id);
559 else if constexpr(std::is_same<T, jlong>::value)
560 res = env->GetStaticLongField(clazz, id);
561 else if constexpr(std::is_same<T, jfloat>::value)
562 res = env->GetStaticFloatField(clazz, id);
563 else if constexpr(std::is_same<T, jdouble>::value)
564 res = env->GetStaticDoubleField(clazz, id);
565 else
566 QtJniTypes::staticAssertTypeMismatch();
567 }
568
569 template<typename T>
570 static constexpr void setFieldForType(JNIEnv *env, jobject obj,
571 jfieldID id, T value)
572 {
573 if constexpr(std::is_same<T, jboolean>::value)
574 env->SetBooleanField(obj, id, value);
575 else if constexpr(std::is_same<T, jbyte>::value)
576 env->SetByteField(obj, id, value);
577 else if constexpr(std::is_same<T, jchar>::value)
578 env->SetCharField(obj, id, value);
579 else if constexpr(std::is_same<T, jshort>::value)
580 env->SetShortField(obj, id, value);
581 else if constexpr(std::is_same<T, jint>::value)
582 env->SetIntField(obj, id, value);
583 else if constexpr(std::is_same<T, jlong>::value)
584 env->SetLongField(obj, id, value);
585 else if constexpr(std::is_same<T, jfloat>::value)
586 env->SetFloatField(obj, id, value);
587 else if constexpr(std::is_same<T, jdouble>::value)
588 env->SetDoubleField(obj, id, value);
589 else if constexpr(std::is_convertible<T, jobject>::value)
590 env->SetObjectField(obj, id, value);
591 else
592 QtJniTypes::staticAssertTypeMismatch();
593 }
594
595 template<typename T>
596 static constexpr void setStaticFieldForType(JNIEnv *env, jclass clazz,
597 jfieldID id, T value)
598 {
599 if constexpr(std::is_same<T, jboolean>::value)
600 env->SetStaticBooleanField(clazz, id, value);
601 else if constexpr(std::is_same<T, jbyte>::value)
602 env->SetStaticByteField(clazz, id, value);
603 else if constexpr(std::is_same<T, jchar>::value)
604 env->SetStaticCharField(clazz, id, value);
605 else if constexpr(std::is_same<T, jshort>::value)
606 env->SetStaticShortField(clazz, id, value);
607 else if constexpr(std::is_same<T, jint>::value)
608 env->SetStaticIntField(clazz, id, value);
609 else if constexpr(std::is_same<T, jlong>::value)
610 env->SetStaticLongField(clazz, id, value);
611 else if constexpr(std::is_same<T, jfloat>::value)
612 env->SetStaticFloatField(clazz, id, value);
613 else if constexpr(std::is_same<T, jdouble>::value)
614 env->SetStaticDoubleField(clazz, id, value);
615 else if constexpr(std::is_convertible<T, jobject>::value)
616 env->SetStaticObjectField(clazz, id, value);
617 else
618 QtJniTypes::staticAssertTypeMismatch();
619 }
620
621 friend QJniObjectPrivate;
622 QSharedPointer<QJniObjectPrivate> d;
623};
624
625inline bool operator==(const QJniObject &obj1, const QJniObject &obj2)
626{
627 return obj1.isSameObject(obj2);
628}
629
630inline bool operator!=(const QJniObject &obj1, const QJniObject &obj2)
631{
632 return !obj1.isSameObject(obj2);
633}
634
635QT_END_NAMESPACE
636
637#endif
638
639#endif // QJNIOBJECT_H
QByteArray
\inmodule QtCore
Definition qbytearray.h:57
QJniEnvironment
\inmodule QtCore
QJniObject
\inmodule QtCore
QSharedPointer
\inmodule QtCore
Definition qsharedpointer_impl.h:256
QString
\macro QT_RESTRICTED_CAST_FROM_ASCII
Definition qstring.h:127
QDBusMetaTypeId::signature
QMetaType signature()
Definition qdbusmetatype_p.h:55
QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qstandardpaths_haiku.cpp:21
QT_END_NAMESPACE
Definition qsharedpointer.cpp:1545
QtMetaTypePrivate::construct
void construct(const QtPrivate::QMetaTypeInterface *iface, void *where, const void *copy)
Definition qmetatype_p.h:190
operator!=
constexpr bool operator!=(const timespec &t1, const timespec &t2)
Definition qcore_unix_p.h:114
methodName
static QString methodName(const QDBusIntrospection::Method &method)
Definition qdbusxml2cpp.cpp:497
value
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
Definition qeglstreamconvenience_p.h:46
id
GLenum GLuint id
[7]
Definition qopengles2ext.h:151
object
GLuint object
[3]
Definition qopengles2ext.h:1248
data
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
Definition qopengles2ext.h:206
name
GLuint name
Definition qopengles2ext.h:156
obj
GLhandleARB obj
[2]
Definition qopenglext.h:4164
res
GLuint res
Definition qopenglext.h:8867
fromString
static bool fromString(const QMetaObject *mo, QString s, Allocate &&allocate)
Definition qqmlglobal.cpp:175
operator==
bool operator==(const QRandomGenerator &rng1, const QRandomGenerator &rng2)
Definition qrandom.cpp:1219
className
const char className[16]
[1]
Definition qwizard.cpp:100
d
double d
Definition src_corelib_text_qlocale.cpp:9
other
QSharedPointer< T > other(t)
[5]
toString
char * toString(const MyType &t)
[31]
Definition src_qtestlib_qtestcase_snippet.cpp:115
args
QJSValueList args
Definition src_script_qjsengine.cpp:12
wrapper
void wrapper()
Definition supportedformat.cpp:6