matrixfurry.com
The open source OpenXR runtime
external: Add android-jni-wrap.
+3138
-1
+11
-1
src/external/CMakeLists.txt
+11
-1
src/external/CMakeLists.txt
···
25
25
add_library(xrt-external-hungarian INTERFACE)
26
26
target_include_directories(xrt-external-hungarian INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/hungarian)
27
27
28
-
# JNIPP
28
+
# JNIPP and Android JNI wrappers
29
29
if(ANDROID)
30
30
add_library(xrt-external-jnipp STATIC
31
31
jnipp/jnipp.cpp)
32
32
target_include_directories(xrt-external-jnipp PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/jnipp)
33
+
34
+
file(GLOB WRAP_SOURCES android-jni-wrap/wrap/*.cpp)
35
+
add_library(xrt-external-jni-wrap STATIC
36
+
${WRAP_SOURCES})
37
+
target_include_directories(xrt-external-jni-wrap PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/android-jni-wrap)
38
+
target_link_libraries(xrt-external-jni-wrap PUBLIC xrt-external-jnipp)
39
+
set_target_properties(xrt-external-jni-wrap
40
+
PROPERTIES
41
+
CXX_STANDARD 17
42
+
CXX_STANDARD_REQUIRED ON)
33
43
endif()
34
44
35
45
# OpenXR
+319
src/external/android-jni-wrap/wrap/ObjectWrapperBase.h
+319
src/external/android-jni-wrap/wrap/ObjectWrapperBase.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
#include <jni.h>
7
+
#include <jnipp.h>
8
+
9
+
namespace wrap {
10
+
11
+
/*!
12
+
* Base class for types wrapping Java types.
13
+
*
14
+
* Derived types are encouraged to have a nested `struct Meta`, inheriting
15
+
* publicly from MetaBaseDroppable or MetaBase, with a singleton accessor named
16
+
* `data()`, and a private constructor (implemented in a .cpp file, not the
17
+
* header) that populates jni::method_t, jni::field_t, etc. members for each
18
+
* method, etc. of interest.
19
+
*/
20
+
class ObjectWrapperBase {
21
+
public:
22
+
/*!
23
+
* Default constructor.
24
+
*/
25
+
ObjectWrapperBase() = default;
26
+
27
+
/*!
28
+
* Construct from a jni::Object.
29
+
*/
30
+
explicit ObjectWrapperBase(jni::Object obj) : obj_(std::move(obj)) {}
31
+
32
+
/*!
33
+
* Construct from a nullptr.
34
+
*/
35
+
explicit ObjectWrapperBase(std::nullptr_t const &) : obj_() {}
36
+
37
+
/*!
38
+
* Evaluate if this is non-null
39
+
*/
40
+
explicit operator bool() const noexcept { return !obj_.isNull(); }
41
+
42
+
/*!
43
+
* Is this object null?
44
+
*/
45
+
bool isNull() const noexcept { return obj_.isNull(); }
46
+
47
+
/*!
48
+
* Get the wrapped jni::Object
49
+
*/
50
+
jni::Object &object() noexcept { return obj_; }
51
+
52
+
/*!
53
+
* Get the wrapped jni::Object (const overload)
54
+
*/
55
+
jni::Object const &object() const noexcept { return obj_; }
56
+
57
+
private:
58
+
jni::Object obj_;
59
+
};
60
+
61
+
/*!
62
+
* Equality comparison for a wrapped Java object.
63
+
*/
64
+
static inline bool operator==(ObjectWrapperBase const &lhs,
65
+
ObjectWrapperBase const &rhs) noexcept {
66
+
return lhs.object() == rhs.object();
67
+
}
68
+
69
+
/*!
70
+
* Inequality comparison for a wrapped Java object.
71
+
*/
72
+
static inline bool operator!=(ObjectWrapperBase const &lhs,
73
+
ObjectWrapperBase const &rhs) noexcept {
74
+
return lhs.object() != rhs.object();
75
+
}
76
+
77
+
/*!
78
+
* Equality comparison between a wrapped Java object and @p nullptr.
79
+
*/
80
+
static inline bool operator==(ObjectWrapperBase const &obj,
81
+
std::nullptr_t) noexcept {
82
+
return obj.isNull();
83
+
}
84
+
85
+
/*!
86
+
* Equality comparison between a wrapped Java object and @p nullptr.
87
+
*/
88
+
static inline bool operator==(std::nullptr_t,
89
+
ObjectWrapperBase const &obj) noexcept {
90
+
return obj.isNull();
91
+
}
92
+
93
+
/*!
94
+
* Inequality comparison between a wrapped Java object and @p nullptr.
95
+
*/
96
+
static inline bool operator!=(ObjectWrapperBase const &obj,
97
+
std::nullptr_t) noexcept {
98
+
return !(obj == nullptr);
99
+
}
100
+
101
+
/*!
102
+
* Inequality comparison between a wrapped Java object and @p nullptr.
103
+
*/
104
+
static inline bool operator!=(std::nullptr_t,
105
+
ObjectWrapperBase const &obj) noexcept {
106
+
return !(obj == nullptr);
107
+
}
108
+
109
+
/*!
110
+
* Base class for Meta structs where you want the reference to the Class object
111
+
* to persist (indefinitely).
112
+
*
113
+
* Mostly for classes that would stick around anyway (e.g.
114
+
* @p java.lang.ClassLoader ) where many operations are on static
115
+
* methods/fields. Use of a non-static method or field does not require such a
116
+
* reference, use MetaBaseDroppable in those cases.
117
+
*/
118
+
class MetaBase {
119
+
public:
120
+
/*!
121
+
* Gets a reference to the class object.
122
+
*
123
+
* Unlike MetaBaseDroppable, here we know that the class object ref is
124
+
* alive.
125
+
*/
126
+
jni::Class const &clazz() const noexcept { return clazz_; }
127
+
/*!
128
+
* Gets a reference to the class object.
129
+
*
130
+
* Provided here for parallel API to MetaBaseDroppable, despite being
131
+
* synonymous with clazz() here.
132
+
*/
133
+
jni::Class const &classRef() const noexcept { return clazz_; }
134
+
135
+
/*!
136
+
* Get the class name, with namespaces delimited by `/`.
137
+
*/
138
+
const char *className() const noexcept { return classname_; }
139
+
140
+
protected:
141
+
/*!
142
+
* Construct.
143
+
*
144
+
* @param classname The class name, fully qualified, with namespaces
145
+
* delimited by `/`.
146
+
*/
147
+
explicit MetaBase(const char *classname)
148
+
: classname_(classname), clazz_(classname_) {}
149
+
150
+
private:
151
+
const char *classname_;
152
+
jni::Class clazz_;
153
+
};
154
+
155
+
/*!
156
+
* Base class for Meta structs where you don't need the reference to the Class
157
+
* object to persist. (This is most uses.)
158
+
*/
159
+
class MetaBaseDroppable {
160
+
public:
161
+
/*!
162
+
* Gets the class object.
163
+
*
164
+
* Works regardless of whether dropClassRef() has been called - it's just
165
+
* slower if it has.
166
+
*/
167
+
jni::Class clazz() const {
168
+
if (clazz_.isNull()) {
169
+
return {classname_};
170
+
}
171
+
return clazz_;
172
+
}
173
+
174
+
/*!
175
+
* Get the class name, with namespaces delimited by `/`.
176
+
*/
177
+
const char *className() const noexcept { return classname_; }
178
+
179
+
/*!
180
+
* May be called in/after the derived constructor, to drop the reference to
181
+
* the class object if it's no longer needed.
182
+
*/
183
+
void dropClassRef() { clazz_ = jni::Class{}; }
184
+
185
+
protected:
186
+
/*!
187
+
* Construct.
188
+
*
189
+
* Once you are done constructing your derived struct, you may call
190
+
* dropClassRef() and still safely use non-static method and field IDs
191
+
* retrieved.
192
+
*
193
+
* @param classname The class name, fully qualified, with namespaces
194
+
* delimited by `/`.
195
+
*/
196
+
explicit MetaBaseDroppable(const char *classname)
197
+
: classname_(classname), clazz_(classname_) {}
198
+
199
+
/*!
200
+
* Gets a reference to the class object, but is non-null only if it's still
201
+
* cached.
202
+
*
203
+
* Only for used in derived constructors/initializers, where you know you
204
+
* haven't dropped this yet.
205
+
*/
206
+
jni::Class const &classRef() const { return clazz_; }
207
+
208
+
private:
209
+
const char *classname_;
210
+
jni::Class clazz_;
211
+
};
212
+
213
+
/*!
214
+
* Implementation namespace for these JNI wrappers.
215
+
*
216
+
* They can be ignored if you aren't adding/extending wrappers.
217
+
*/
218
+
namespace impl {
219
+
/*!
220
+
* Type-aware wrapper for a field ID.
221
+
*
222
+
* This is a smarter alternative to just using jni::field_t since it avoids
223
+
* having to repeat the type in the accessor, without using any more storage.
224
+
*
225
+
* @see StaticFieldId for the equivalent for static fields.
226
+
* @see WrappedFieldId for the equivalent for structures that we wrap.
227
+
*/
228
+
template <typename T> struct FieldId {
229
+
public:
230
+
FieldId(jni::Class const &clazz, const char *name)
231
+
: id(clazz.getField<T>(name)) {}
232
+
233
+
const jni::field_t id;
234
+
};
235
+
236
+
/*!
237
+
* Get the value of field @p field in Java object @p obj.
238
+
*
239
+
* This is found by argument-dependent lookup and can be used unqualified.
240
+
*
241
+
* @relates FieldId
242
+
*/
243
+
template <typename T>
244
+
static inline T get(FieldId<T> const &field, jni::Object const &obj) {
245
+
assert(!obj.isNull());
246
+
return obj.get<T>(field.id);
247
+
}
248
+
/*!
249
+
* Type-aware wrapper for a static field ID.
250
+
*
251
+
* This is a smarter alternative to just using jni::field_t since it avoids
252
+
* having to repeat the type in the accessor, without using any more storage.
253
+
*
254
+
* @see FieldId
255
+
*/
256
+
template <typename T> struct StaticFieldId {
257
+
public:
258
+
StaticFieldId(jni::Class const &clazz, const char *name)
259
+
: id(clazz.getStaticField<T>(name)) {}
260
+
261
+
const jni::field_t id;
262
+
};
263
+
264
+
/*!
265
+
* Get the value of static field @p field in Java type @p clazz.
266
+
*
267
+
* This is found by argument-dependent lookup and can be used unqualified.
268
+
*
269
+
* @relates FieldId
270
+
*/
271
+
template <typename T>
272
+
static inline T get(StaticFieldId<T> const &field, jni::Class const &clazz) {
273
+
assert(!clazz.isNull());
274
+
return clazz.get<T>(field.id);
275
+
}
276
+
277
+
/*!
278
+
* Type-aware wrapper for a field ID of a wrapped structure type.
279
+
*
280
+
* This is a smarter alternative to just using jni::field_t since it avoids
281
+
* having to repeat the type in the accessor, without using any more storage.
282
+
*
283
+
* Requires that the structure wrapper provides
284
+
* `static constexpr const char *getTypeName() noexcept;`
285
+
*
286
+
* @see FieldId
287
+
*/
288
+
template <typename T> struct WrappedFieldId {
289
+
public:
290
+
WrappedFieldId(jni::Class const &clazz, const char *name)
291
+
: id(lookupField(clazz, name)) {}
292
+
293
+
const jni::field_t id;
294
+
295
+
private:
296
+
/*!
297
+
* Helper for field ID lookup, mostly to avoid calling c_str() on a string
298
+
* temporary.
299
+
*/
300
+
static jni::field_t lookupField(jni::Class const &clazz, const char *name) {
301
+
std::string fullType = std::string("L") + T::getTypeName() + ";";
302
+
return clazz.getField(name, fullType.c_str());
303
+
}
304
+
};
305
+
306
+
/*!
307
+
* Get the value of field @p field in Java object @p obj.
308
+
*
309
+
* This is found by argument-dependent lookup and can be used unqualified.
310
+
*
311
+
* @relates WrappedFieldId
312
+
*/
313
+
template <typename T>
314
+
static inline T get(WrappedFieldId<T> const &field, jni::Object const &obj) {
315
+
assert(!obj.isNull());
316
+
return T{obj.get<jni::Object>(field.id)};
317
+
}
318
+
} // namespace impl
319
+
} // namespace wrap
+29
src/external/android-jni-wrap/wrap/README.md
+29
src/external/android-jni-wrap/wrap/README.md
···
1
+
# About these JNI Wrappers
2
+
3
+
<!--
4
+
Copyright 2020, Collabora, Ltd.
5
+
SPDX-License-Identifier: BSL-1.0
6
+
-->
7
+
8
+
These are fairly simple wrappers around Java classes, using JNI and JNIPP to allow relatively-painless use of Java classes from C++. They are populated as-needed: if you need a method/property that's missing, add it!
9
+
10
+
## Conventions
11
+
12
+
All classes derive from ObjectWrapperBase or one of its subclasses. (Yes, you
13
+
can directly mirror inheritance in Java with inheritance in these wrappers.)
14
+
15
+
All should have a public internal struct called `Meta` that derives publicly
16
+
from either `MetaBase` or `MetaBaseDroppable` (the more common option, when you
17
+
don't often need the class object itself), with a member for each method ID.
18
+
Only the `Meta()` constructor should be in the `.cpp` file for a given wrapper:
19
+
the rest lives in the header so it may be inlined and thus optimized away.
20
+
21
+
## Finding signatures
22
+
23
+
A command like the following can help you get the JNI signatures of methods:
24
+
25
+
```sh
26
+
javap -s -classpath ~/Android/Sdk/platforms/android-26/android.jar android.service.vr.VrListenerService
27
+
```
28
+
29
+
Adjust the location of the SDK and the class under investigation as needed.
+21
src/external/android-jni-wrap/wrap/android.app.cpp
+21
src/external/android-jni-wrap/wrap/android.app.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.app.h"
6
+
7
+
namespace wrap {
8
+
namespace android::app {
9
+
Service::Meta::Meta() : MetaBaseDroppable(Service::getTypeName()) {
10
+
MetaBaseDroppable::dropClassRef();
11
+
}
12
+
Activity::Meta::Meta()
13
+
: MetaBaseDroppable(Activity::getTypeName()),
14
+
getSystemService(classRef().getMethod(
15
+
"getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;")),
16
+
setVrModeEnabled(classRef().getMethod(
17
+
"setVrModeEnabled", "(ZLandroid/content/ComponentName;)V")) {
18
+
MetaBaseDroppable::dropClassRef();
19
+
}
20
+
} // namespace android::app
21
+
} // namespace wrap
+100
src/external/android-jni-wrap/wrap/android.app.h
+100
src/external/android-jni-wrap/wrap/android.app.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "android.content.h"
8
+
9
+
namespace wrap {
10
+
namespace android::content {
11
+
class ComponentName;
12
+
} // namespace android::content
13
+
14
+
} // namespace wrap
15
+
16
+
namespace wrap {
17
+
namespace android::app {
18
+
/*!
19
+
* Wrapper for android.app.Service objects.
20
+
*/
21
+
class Service : public content::Context {
22
+
public:
23
+
using Context::Context;
24
+
static constexpr const char *getTypeName() noexcept {
25
+
return "android/app/Service";
26
+
}
27
+
28
+
/*!
29
+
* Class metadata
30
+
*/
31
+
struct Meta : public MetaBaseDroppable {
32
+
33
+
/*!
34
+
* Singleton accessor
35
+
*/
36
+
static Meta &data() {
37
+
static Meta instance;
38
+
return instance;
39
+
}
40
+
41
+
private:
42
+
Meta();
43
+
};
44
+
};
45
+
/*!
46
+
* Wrapper for android.app.Activity objects.
47
+
*/
48
+
class Activity : public content::Context {
49
+
public:
50
+
using Context::Context;
51
+
static constexpr const char *getTypeName() noexcept {
52
+
return "android/app/Activity";
53
+
}
54
+
55
+
/*!
56
+
* Wrapper for the getSystemService method
57
+
*
58
+
* Java prototype:
59
+
* `public java.lang.Object getSystemService(java.lang.String);`
60
+
*
61
+
* JNI signature: (Ljava/lang/String;)Ljava/lang/Object;
62
+
*
63
+
*/
64
+
jni::Object getSystemService(std::string const &name);
65
+
66
+
/*!
67
+
* Wrapper for the setVrModeEnabled method
68
+
*
69
+
* Java prototype:
70
+
* `public void setVrModeEnabled(boolean, android.content.ComponentName)
71
+
* throws android.content.pm.PackageManager$NameNotFoundException;`
72
+
*
73
+
* JNI signature: (ZLandroid/content/ComponentName;)V
74
+
*
75
+
*/
76
+
void setVrModeEnabled(bool enabled,
77
+
content::ComponentName const &requestedComponent);
78
+
79
+
/*!
80
+
* Class metadata
81
+
*/
82
+
struct Meta : public MetaBaseDroppable {
83
+
jni::method_t getSystemService;
84
+
jni::method_t setVrModeEnabled;
85
+
86
+
/*!
87
+
* Singleton accessor
88
+
*/
89
+
static Meta &data() {
90
+
static Meta instance;
91
+
return instance;
92
+
}
93
+
94
+
private:
95
+
Meta();
96
+
};
97
+
};
98
+
} // namespace android::app
99
+
} // namespace wrap
100
+
#include "android.app.impl.h"
+26
src/external/android-jni-wrap/wrap/android.app.impl.h
+26
src/external/android-jni-wrap/wrap/android.app.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "android.content.h"
8
+
#include <string>
9
+
10
+
namespace wrap {
11
+
namespace android::app {
12
+
13
+
inline jni::Object Activity::getSystemService(std::string const &name) {
14
+
assert(!isNull());
15
+
return object().call<jni::Object>(Meta::data().getSystemService, name);
16
+
}
17
+
18
+
inline void
19
+
Activity::setVrModeEnabled(bool enabled,
20
+
content::ComponentName const &requestedComponent) {
21
+
assert(!isNull());
22
+
return object().call<void>(Meta::data().setVrModeEnabled, enabled,
23
+
requestedComponent.object());
24
+
}
25
+
} // namespace android::app
26
+
} // namespace wrap
+55
src/external/android-jni-wrap/wrap/android.content.cpp
+55
src/external/android-jni-wrap/wrap/android.content.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.content.h"
6
+
7
+
namespace wrap {
8
+
namespace android::content {
9
+
Context::Meta::Meta(bool deferDrop)
10
+
: MetaBaseDroppable(Context::getTypeName()),
11
+
DISPLAY_SERVICE(classRef(), "DISPLAY_SERVICE"),
12
+
WINDOW_SERVICE(classRef(), "WINDOW_SERVICE"),
13
+
getPackageManager(classRef().getMethod(
14
+
"getPackageManager", "()Landroid/content/pm/PackageManager;")),
15
+
getApplicationContext(classRef().getMethod(
16
+
"getApplicationContext", "()Landroid/content/Context;")),
17
+
getClassLoader(
18
+
classRef().getMethod("getClassLoader", "()Ljava/lang/ClassLoader;")),
19
+
startActivity(
20
+
classRef().getMethod("startActivity", "(Landroid/content/Intent;)V")),
21
+
startActivity1(classRef().getMethod(
22
+
"startActivity", "(Landroid/content/Intent;Landroid/os/Bundle;)V")),
23
+
createPackageContext(classRef().getMethod(
24
+
"createPackageContext",
25
+
"(Ljava/lang/String;I)Landroid/content/Context;")) {
26
+
if (!deferDrop) {
27
+
MetaBaseDroppable::dropClassRef();
28
+
}
29
+
}
30
+
ComponentName::Meta::Meta()
31
+
: MetaBase(ComponentName::getTypeName()),
32
+
init(classRef().getMethod("<init>",
33
+
"(Ljava/lang/String;Ljava/lang/String;)V")),
34
+
init1(classRef().getMethod(
35
+
"<init>", "(Landroid/content/Context;Ljava/lang/String;)V")),
36
+
init2(classRef().getMethod(
37
+
"<init>", "(Landroid/content/Context;Ljava/lang/Class;)V")),
38
+
init3(classRef().getMethod("<init>", "(Landroid/os/Parcel;)V")) {}
39
+
Intent::Meta::Meta()
40
+
: MetaBase(Intent::getTypeName()),
41
+
FLAG_ACTIVITY_NEW_TASK(classRef(), "FLAG_ACTIVITY_NEW_TASK"),
42
+
init(classRef().getMethod("<init>", "()V")),
43
+
init1(classRef().getMethod("<init>", "(Landroid/content/Intent;)V")),
44
+
init2(classRef().getMethod("<init>", "(Ljava/lang/String;)V")),
45
+
init3(classRef().getMethod("<init>",
46
+
"(Ljava/lang/String;Landroid/net/Uri;)V")),
47
+
init4(classRef().getMethod(
48
+
"<init>", "(Landroid/content/Context;Ljava/lang/Class;)V")),
49
+
init5(classRef().getMethod("<init>",
50
+
"(Ljava/lang/String;Landroid/net/Uri;Landroid/"
51
+
"content/Context;Ljava/lang/Class;)V")),
52
+
setFlags(
53
+
classRef().getMethod("setFlags", "(I)Landroid/content/Intent;")) {}
54
+
} // namespace android::content
55
+
} // namespace wrap
+379
src/external/android-jni-wrap/wrap/android.content.h
+379
src/external/android-jni-wrap/wrap/android.content.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
#include <string>
9
+
10
+
namespace wrap {
11
+
namespace android::content {
12
+
class ComponentName;
13
+
class Context;
14
+
class Intent;
15
+
} // namespace android::content
16
+
17
+
namespace android::content::pm {
18
+
class PackageManager;
19
+
} // namespace android::content::pm
20
+
21
+
namespace android::os {
22
+
class Bundle;
23
+
} // namespace android::os
24
+
25
+
namespace java::lang {
26
+
class Class;
27
+
class ClassLoader;
28
+
} // namespace java::lang
29
+
30
+
} // namespace wrap
31
+
32
+
namespace wrap {
33
+
namespace android::content {
34
+
/*!
35
+
* Wrapper for android.content.Context objects.
36
+
*/
37
+
class Context : public ObjectWrapperBase {
38
+
public:
39
+
using ObjectWrapperBase::ObjectWrapperBase;
40
+
static constexpr const char *getTypeName() noexcept {
41
+
return "android/content/Context";
42
+
}
43
+
44
+
/*!
45
+
* Getter for the DISPLAY_SERVICE static field value
46
+
*
47
+
* Java prototype:
48
+
* `public static final java.lang.String DISPLAY_SERVICE;`
49
+
*
50
+
* JNI signature: Ljava/lang/String;
51
+
*
52
+
*/
53
+
static std::string DISPLAY_SERVICE();
54
+
55
+
/*!
56
+
* Getter for the WINDOW_SERVICE static field value
57
+
*
58
+
* Java prototype:
59
+
* `public static final java.lang.String WINDOW_SERVICE;`
60
+
*
61
+
* JNI signature: Ljava/lang/String;
62
+
*
63
+
*/
64
+
static std::string WINDOW_SERVICE();
65
+
66
+
/*!
67
+
* Wrapper for the getPackageManager method
68
+
*
69
+
* Java prototype:
70
+
* `public abstract android.content.pm.PackageManager getPackageManager();`
71
+
*
72
+
* JNI signature: ()Landroid/content/pm/PackageManager;
73
+
*
74
+
*/
75
+
pm::PackageManager getPackageManager();
76
+
77
+
/*!
78
+
* Wrapper for the getApplicationContext method
79
+
*
80
+
* Java prototype:
81
+
* `public abstract android.content.Context getApplicationContext();`
82
+
*
83
+
* JNI signature: ()Landroid/content/Context;
84
+
*
85
+
*/
86
+
Context getApplicationContext();
87
+
88
+
/*!
89
+
* Wrapper for the getClassLoader method
90
+
*
91
+
* Java prototype:
92
+
* `public abstract java.lang.ClassLoader getClassLoader();`
93
+
*
94
+
* JNI signature: ()Ljava/lang/ClassLoader;
95
+
*
96
+
*/
97
+
java::lang::ClassLoader getClassLoader();
98
+
99
+
/*!
100
+
* Wrapper for the startActivity method
101
+
*
102
+
* Java prototype:
103
+
* `public abstract void startActivity(android.content.Intent);`
104
+
*
105
+
* JNI signature: (Landroid/content/Intent;)V
106
+
*
107
+
*/
108
+
void startActivity(Intent const &intent);
109
+
110
+
/*!
111
+
* Wrapper for the startActivity method
112
+
*
113
+
* Java prototype:
114
+
* `public abstract void startActivity(android.content.Intent,
115
+
* android.os.Bundle);`
116
+
*
117
+
* JNI signature: (Landroid/content/Intent;Landroid/os/Bundle;)V
118
+
*
119
+
*/
120
+
void startActivity(Intent const &intent, os::Bundle const &bundle);
121
+
122
+
/*!
123
+
* Wrapper for the createPackageContext method
124
+
*
125
+
* Java prototype:
126
+
* `public abstract android.content.Context
127
+
* createPackageContext(java.lang.String, int) throws
128
+
* android.content.pm.PackageManager$NameNotFoundException;`
129
+
*
130
+
* JNI signature: (Ljava/lang/String;I)Landroid/content/Context;
131
+
*
132
+
*/
133
+
Context createPackageContext(std::string const &packageName, int32_t flags);
134
+
135
+
enum {
136
+
CONTEXT_INCLUDE_CODE = 1,
137
+
CONTEXT_IGNORE_SECURITY = 2,
138
+
};
139
+
140
+
/*!
141
+
* Class metadata
142
+
*/
143
+
struct Meta : public MetaBaseDroppable {
144
+
impl::StaticFieldId<std::string> DISPLAY_SERVICE;
145
+
impl::StaticFieldId<std::string> WINDOW_SERVICE;
146
+
jni::method_t getPackageManager;
147
+
jni::method_t getApplicationContext;
148
+
jni::method_t getClassLoader;
149
+
jni::method_t startActivity;
150
+
jni::method_t startActivity1;
151
+
jni::method_t createPackageContext;
152
+
153
+
/*!
154
+
* Singleton accessor
155
+
*/
156
+
static Meta &data(bool deferDrop = false) {
157
+
static Meta instance{deferDrop};
158
+
return instance;
159
+
}
160
+
161
+
private:
162
+
explicit Meta(bool deferDrop);
163
+
};
164
+
};
165
+
/*!
166
+
* Wrapper for android.content.ComponentName objects.
167
+
*/
168
+
class ComponentName : public ObjectWrapperBase {
169
+
public:
170
+
using ObjectWrapperBase::ObjectWrapperBase;
171
+
static constexpr const char *getTypeName() noexcept {
172
+
return "android/content/ComponentName";
173
+
}
174
+
175
+
/*!
176
+
* Wrapper for a constructor
177
+
*
178
+
* Java prototype:
179
+
* `public android.content.ComponentName(java.lang.String,
180
+
* java.lang.String);`
181
+
*
182
+
* JNI signature: (Ljava/lang/String;Ljava/lang/String;)V
183
+
*
184
+
*/
185
+
static ComponentName construct(std::string const &pkg,
186
+
std::string const &cls);
187
+
188
+
/*!
189
+
* Wrapper for a constructor
190
+
*
191
+
* Java prototype:
192
+
* `public android.content.ComponentName(android.content.Context,
193
+
* java.lang.String);`
194
+
*
195
+
* JNI signature: (Landroid/content/Context;Ljava/lang/String;)V
196
+
*
197
+
*/
198
+
static ComponentName construct(Context const &pkg, std::string const &cls);
199
+
200
+
/*!
201
+
* Wrapper for a constructor
202
+
*
203
+
* Java prototype:
204
+
* `public android.content.ComponentName(android.content.Context,
205
+
* java.lang.Class<?>);`
206
+
*
207
+
* JNI signature: (Landroid/content/Context;Ljava/lang/Class;)V
208
+
*
209
+
*/
210
+
static ComponentName construct(Context const &pkg,
211
+
java::lang::Class const &cls);
212
+
213
+
/*!
214
+
* Wrapper for a constructor
215
+
*
216
+
* Java prototype:
217
+
* `public android.content.ComponentName(android.os.Parcel);`
218
+
*
219
+
* JNI signature: (Landroid/os/Parcel;)V
220
+
*
221
+
*/
222
+
static ComponentName construct(jni::Object const &parcel);
223
+
224
+
/*!
225
+
* Class metadata
226
+
*/
227
+
struct Meta : public MetaBase {
228
+
jni::method_t init;
229
+
jni::method_t init1;
230
+
jni::method_t init2;
231
+
jni::method_t init3;
232
+
233
+
/*!
234
+
* Singleton accessor
235
+
*/
236
+
static Meta &data() {
237
+
static Meta instance;
238
+
return instance;
239
+
}
240
+
241
+
private:
242
+
Meta();
243
+
};
244
+
};
245
+
/*!
246
+
* Wrapper for android.content.Intent objects.
247
+
*/
248
+
class Intent : public ObjectWrapperBase {
249
+
public:
250
+
using ObjectWrapperBase::ObjectWrapperBase;
251
+
static constexpr const char *getTypeName() noexcept {
252
+
return "android/content/Intent";
253
+
}
254
+
255
+
/*!
256
+
* Getter for the FLAG_ACTIVITY_NEW_TASK static field value
257
+
*
258
+
* Java prototype:
259
+
* `public static final int FLAG_ACTIVITY_NEW_TASK;`
260
+
*
261
+
* JNI signature: I
262
+
*
263
+
*/
264
+
static int32_t FLAG_ACTIVITY_NEW_TASK();
265
+
266
+
#if 0
267
+
// disabled because of zero-length array warning in jnipp
268
+
/*!
269
+
* Wrapper for a constructor
270
+
*
271
+
* Java prototype:
272
+
* `public android.content.Intent();`
273
+
*
274
+
* JNI signature: ()V
275
+
*
276
+
*/
277
+
static Intent construct();
278
+
#endif
279
+
280
+
/*!
281
+
* Wrapper for a constructor
282
+
*
283
+
* Java prototype:
284
+
* `public android.content.Intent(android.content.Intent);`
285
+
*
286
+
* JNI signature: (Landroid/content/Intent;)V
287
+
*
288
+
*/
289
+
static Intent construct(Intent &intent);
290
+
291
+
/*!
292
+
* Wrapper for a constructor
293
+
*
294
+
* Java prototype:
295
+
* `public android.content.Intent(java.lang.String);`
296
+
*
297
+
* JNI signature: (Ljava/lang/String;)V
298
+
*
299
+
*/
300
+
static Intent construct(std::string const &action);
301
+
302
+
/*!
303
+
* Wrapper for a constructor
304
+
*
305
+
* Java prototype:
306
+
* `public android.content.Intent(java.lang.String, android.net.Uri);`
307
+
*
308
+
* JNI signature: (Ljava/lang/String;Landroid/net/Uri;)V
309
+
*
310
+
*/
311
+
static Intent construct(std::string const &action, jni::Object const &uri);
312
+
313
+
/*!
314
+
* Wrapper for a constructor
315
+
*
316
+
* Java prototype:
317
+
* `public android.content.Intent(android.content.Context,
318
+
* java.lang.Class<?>);`
319
+
*
320
+
* JNI signature: (Landroid/content/Context;Ljava/lang/Class;)V
321
+
*
322
+
*/
323
+
static Intent construct(Context const &context,
324
+
java::lang::Class const &classParam);
325
+
326
+
/*!
327
+
* Wrapper for a constructor
328
+
*
329
+
* Java prototype:
330
+
* `public android.content.Intent(java.lang.String, android.net.Uri,
331
+
* android.content.Context, java.lang.Class<?>);`
332
+
*
333
+
* JNI signature:
334
+
* (Ljava/lang/String;Landroid/net/Uri;Landroid/content/Context;Ljava/lang/Class;)V
335
+
*
336
+
*/
337
+
static Intent construct(std::string const &action, jni::Object const &uri,
338
+
Context const &context,
339
+
java::lang::Class const &classParam);
340
+
341
+
/*!
342
+
* Wrapper for the setFlags method
343
+
*
344
+
* Java prototype:
345
+
* `public android.content.Intent setFlags(int);`
346
+
*
347
+
* JNI signature: (I)Landroid/content/Intent;
348
+
*
349
+
*/
350
+
Intent setFlags(int32_t flags);
351
+
352
+
/*!
353
+
* Class metadata
354
+
*/
355
+
struct Meta : public MetaBase {
356
+
impl::StaticFieldId<int32_t> FLAG_ACTIVITY_NEW_TASK;
357
+
jni::method_t init;
358
+
jni::method_t init1;
359
+
jni::method_t init2;
360
+
jni::method_t init3;
361
+
jni::method_t init4;
362
+
jni::method_t init5;
363
+
jni::method_t setFlags;
364
+
365
+
/*!
366
+
* Singleton accessor
367
+
*/
368
+
static Meta &data() {
369
+
static Meta instance;
370
+
return instance;
371
+
}
372
+
373
+
private:
374
+
Meta();
375
+
};
376
+
};
377
+
} // namespace android::content
378
+
} // namespace wrap
379
+
#include "android.content.impl.h"
+135
src/external/android-jni-wrap/wrap/android.content.impl.h
+135
src/external/android-jni-wrap/wrap/android.content.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "android.content.pm.h"
8
+
#include "android.os.h"
9
+
#include "java.lang.h"
10
+
#include <string>
11
+
12
+
namespace wrap {
13
+
namespace android::content {
14
+
inline std::string Context::DISPLAY_SERVICE() {
15
+
// Defer dropping the class ref to avoid having to do two class lookups
16
+
// by name for this static field. Instead, drop it before we return.
17
+
auto &data = Meta::data(true);
18
+
auto ret = get(data.DISPLAY_SERVICE, data.clazz());
19
+
data.dropClassRef();
20
+
return ret;
21
+
}
22
+
23
+
inline std::string Context::WINDOW_SERVICE() {
24
+
// Defer dropping the class ref to avoid having to do two class lookups
25
+
// by name for this static field. Instead, drop it before we return.
26
+
auto &data = Meta::data(true);
27
+
auto ret = get(data.WINDOW_SERVICE, data.clazz());
28
+
data.dropClassRef();
29
+
return ret;
30
+
}
31
+
32
+
inline pm::PackageManager Context::getPackageManager() {
33
+
assert(!isNull());
34
+
return pm::PackageManager(
35
+
object().call<jni::Object>(Meta::data().getPackageManager));
36
+
}
37
+
38
+
inline Context Context::getApplicationContext() {
39
+
assert(!isNull());
40
+
return Context(
41
+
object().call<jni::Object>(Meta::data().getApplicationContext));
42
+
}
43
+
44
+
inline java::lang::ClassLoader Context::getClassLoader() {
45
+
assert(!isNull());
46
+
return java::lang::ClassLoader(
47
+
object().call<jni::Object>(Meta::data().getClassLoader));
48
+
}
49
+
50
+
inline void Context::startActivity(Intent const &intent) {
51
+
assert(!isNull());
52
+
return object().call<void>(Meta::data().startActivity, intent.object());
53
+
}
54
+
55
+
inline void Context::startActivity(Intent const &intent,
56
+
os::Bundle const &bundle) {
57
+
assert(!isNull());
58
+
return object().call<void>(Meta::data().startActivity1, intent.object(),
59
+
bundle.object());
60
+
}
61
+
62
+
inline Context Context::createPackageContext(std::string const &packageName,
63
+
int32_t flags) {
64
+
assert(!isNull());
65
+
return Context(object().call<jni::Object>(Meta::data().createPackageContext,
66
+
packageName, flags));
67
+
}
68
+
inline ComponentName ComponentName::construct(std::string const &pkg,
69
+
std::string const &cls) {
70
+
return ComponentName(
71
+
Meta::data().clazz().newInstance(Meta::data().init, pkg, cls));
72
+
}
73
+
74
+
inline ComponentName ComponentName::construct(Context const &pkg,
75
+
std::string const &cls) {
76
+
return ComponentName(Meta::data().clazz().newInstance(Meta::data().init1,
77
+
pkg.object(), cls));
78
+
}
79
+
80
+
inline ComponentName ComponentName::construct(Context const &pkg,
81
+
java::lang::Class const &cls) {
82
+
return ComponentName(Meta::data().clazz().newInstance(
83
+
Meta::data().init2, pkg.object(), cls.object()));
84
+
}
85
+
86
+
inline ComponentName ComponentName::construct(jni::Object const &parcel) {
87
+
return ComponentName(
88
+
Meta::data().clazz().newInstance(Meta::data().init3, parcel));
89
+
}
90
+
inline int32_t Intent::FLAG_ACTIVITY_NEW_TASK() {
91
+
return get(Meta::data().FLAG_ACTIVITY_NEW_TASK, Meta::data().clazz());
92
+
}
93
+
94
+
#if 0
95
+
// disabled because of zero-length array warning in jnipp
96
+
inline Intent Intent::construct() {
97
+
return Intent(Meta::data().clazz().newInstance(Meta::data().init));
98
+
}
99
+
#endif
100
+
101
+
inline Intent Intent::construct(Intent &intent) {
102
+
return Intent(
103
+
Meta::data().clazz().newInstance(Meta::data().init1, intent.object()));
104
+
}
105
+
106
+
inline Intent Intent::construct(std::string const &action) {
107
+
return Intent(Meta::data().clazz().newInstance(Meta::data().init2, action));
108
+
}
109
+
110
+
inline Intent Intent::construct(std::string const &action,
111
+
jni::Object const &uri) {
112
+
return Intent(
113
+
Meta::data().clazz().newInstance(Meta::data().init3, action, uri));
114
+
}
115
+
116
+
inline Intent Intent::construct(Context const &context,
117
+
java::lang::Class const &classParam) {
118
+
return Intent(Meta::data().clazz().newInstance(
119
+
Meta::data().init4, context.object(), classParam.object()));
120
+
}
121
+
122
+
inline Intent Intent::construct(std::string const &action,
123
+
jni::Object const &uri, Context const &context,
124
+
java::lang::Class const &classParam) {
125
+
return Intent(Meta::data().clazz().newInstance(Meta::data().init5, action,
126
+
uri, context.object(),
127
+
classParam.object()));
128
+
}
129
+
130
+
inline Intent Intent::setFlags(int32_t flags) {
131
+
assert(!isNull());
132
+
return Intent(object().call<jni::Object>(Meta::data().setFlags, flags));
133
+
}
134
+
} // namespace android::content
135
+
} // namespace wrap
+55
src/external/android-jni-wrap/wrap/android.content.pm.cpp
+55
src/external/android-jni-wrap/wrap/android.content.pm.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.content.pm.h"
6
+
7
+
namespace wrap {
8
+
namespace android::content::pm {
9
+
PackageItemInfo::Meta::Meta()
10
+
: MetaBaseDroppable(PackageItemInfo::getTypeName()),
11
+
metaData(classRef(), "metaData"), name(classRef(), "name"),
12
+
packageName(classRef(), "packageName") {
13
+
MetaBaseDroppable::dropClassRef();
14
+
}
15
+
ComponentInfo::Meta::Meta() : MetaBaseDroppable(ComponentInfo::getTypeName()) {
16
+
MetaBaseDroppable::dropClassRef();
17
+
}
18
+
ServiceInfo::Meta::Meta() : MetaBaseDroppable(ServiceInfo::getTypeName()) {
19
+
MetaBaseDroppable::dropClassRef();
20
+
}
21
+
ApplicationInfo::Meta::Meta()
22
+
: MetaBaseDroppable(ApplicationInfo::getTypeName()),
23
+
nativeLibraryDir(classRef(), "nativeLibraryDir"),
24
+
publicSourceDir(classRef(), "publicSourceDir") {
25
+
MetaBaseDroppable::dropClassRef();
26
+
}
27
+
PackageInfo::Meta::Meta()
28
+
: MetaBaseDroppable(PackageInfo::getTypeName()),
29
+
applicationInfo(classRef(), "applicationInfo"),
30
+
packageName(classRef(), "packageName") {
31
+
MetaBaseDroppable::dropClassRef();
32
+
}
33
+
ResolveInfo::Meta::Meta()
34
+
: MetaBaseDroppable(ResolveInfo::getTypeName()),
35
+
serviceInfo(classRef(), "serviceInfo") {
36
+
MetaBaseDroppable::dropClassRef();
37
+
}
38
+
PackageManager::Meta::Meta()
39
+
: MetaBaseDroppable(PackageManager::getTypeName()),
40
+
getPackageInfo(classRef().getMethod(
41
+
"getPackageInfo",
42
+
"(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;")),
43
+
getPackageInfo1(classRef().getMethod(
44
+
"getPackageInfo", "(Landroid/content/pm/VersionedPackage;I)Landroid/"
45
+
"content/pm/PackageInfo;")),
46
+
getApplicationInfo(classRef().getMethod(
47
+
"getApplicationInfo",
48
+
"(Ljava/lang/String;I)Landroid/content/pm/ApplicationInfo;")),
49
+
queryIntentServices(
50
+
classRef().getMethod("queryIntentServices",
51
+
"(Landroid/content/Intent;I)Ljava/util/List;")) {
52
+
MetaBaseDroppable::dropClassRef();
53
+
}
54
+
} // namespace android::content::pm
55
+
} // namespace wrap
+387
src/external/android-jni-wrap/wrap/android.content.pm.h
+387
src/external/android-jni-wrap/wrap/android.content.pm.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
#include "android.os.h"
9
+
#include <string>
10
+
11
+
namespace wrap {
12
+
namespace android::content {
13
+
class Intent;
14
+
} // namespace android::content
15
+
16
+
namespace android::content::pm {
17
+
class ApplicationInfo;
18
+
class PackageInfo;
19
+
class ServiceInfo;
20
+
} // namespace android::content::pm
21
+
22
+
namespace android::os {
23
+
class Bundle;
24
+
} // namespace android::os
25
+
26
+
namespace java::util {
27
+
class List;
28
+
} // namespace java::util
29
+
30
+
} // namespace wrap
31
+
32
+
namespace wrap {
33
+
namespace android::content::pm {
34
+
/*!
35
+
* Wrapper for android.content.pm.PackageItemInfo objects.
36
+
*/
37
+
class PackageItemInfo : public ObjectWrapperBase {
38
+
public:
39
+
using ObjectWrapperBase::ObjectWrapperBase;
40
+
static constexpr const char *getTypeName() noexcept {
41
+
return "android/content/pm/PackageItemInfo";
42
+
}
43
+
44
+
/*!
45
+
* Getter for the metaData field value
46
+
*
47
+
* Java prototype:
48
+
* `public android.os.Bundle metaData;`
49
+
*
50
+
* JNI signature: Landroid/os/Bundle;
51
+
*
52
+
*/
53
+
os::Bundle getMetaData() const;
54
+
55
+
/*!
56
+
* Getter for the name field value
57
+
*
58
+
* Java prototype:
59
+
* `public java.lang.String name;`
60
+
*
61
+
* JNI signature: Ljava/lang/String;
62
+
*
63
+
*/
64
+
std::string getName() const;
65
+
66
+
/*!
67
+
* Getter for the packageName field value
68
+
*
69
+
* Java prototype:
70
+
* `public java.lang.String packageName;`
71
+
*
72
+
* JNI signature: Ljava/lang/String;
73
+
*
74
+
*/
75
+
std::string getPackageName() const;
76
+
77
+
/*!
78
+
* Class metadata
79
+
*/
80
+
struct Meta : public MetaBaseDroppable {
81
+
impl::WrappedFieldId<os::Bundle> metaData;
82
+
impl::FieldId<std::string> name;
83
+
impl::FieldId<std::string> packageName;
84
+
85
+
/*!
86
+
* Singleton accessor
87
+
*/
88
+
static Meta &data() {
89
+
static Meta instance;
90
+
return instance;
91
+
}
92
+
93
+
private:
94
+
Meta();
95
+
};
96
+
};
97
+
/*!
98
+
* Wrapper for android.content.pm.ComponentInfo objects.
99
+
*/
100
+
class ComponentInfo : public PackageItemInfo {
101
+
public:
102
+
using PackageItemInfo::PackageItemInfo;
103
+
static constexpr const char *getTypeName() noexcept {
104
+
return "android/content/pm/ComponentInfo";
105
+
}
106
+
107
+
/*!
108
+
* Class metadata
109
+
*/
110
+
struct Meta : public MetaBaseDroppable {
111
+
112
+
/*!
113
+
* Singleton accessor
114
+
*/
115
+
static Meta &data() {
116
+
static Meta instance;
117
+
return instance;
118
+
}
119
+
120
+
private:
121
+
Meta();
122
+
};
123
+
};
124
+
/*!
125
+
* Wrapper for android.content.pm.ServiceInfo objects.
126
+
*/
127
+
class ServiceInfo : public PackageItemInfo {
128
+
public:
129
+
using PackageItemInfo::PackageItemInfo;
130
+
static constexpr const char *getTypeName() noexcept {
131
+
return "android/content/pm/ServiceInfo";
132
+
}
133
+
134
+
/*!
135
+
* Class metadata
136
+
*/
137
+
struct Meta : public MetaBaseDroppable {
138
+
139
+
/*!
140
+
* Singleton accessor
141
+
*/
142
+
static Meta &data() {
143
+
static Meta instance;
144
+
return instance;
145
+
}
146
+
147
+
private:
148
+
Meta();
149
+
};
150
+
};
151
+
/*!
152
+
* Wrapper for android.content.pm.ApplicationInfo objects.
153
+
*/
154
+
class ApplicationInfo : public PackageItemInfo {
155
+
public:
156
+
using PackageItemInfo::PackageItemInfo;
157
+
static constexpr const char *getTypeName() noexcept {
158
+
return "android/content/pm/ApplicationInfo";
159
+
}
160
+
161
+
/*!
162
+
* Getter for the nativeLibraryDir field value
163
+
*
164
+
* Java prototype:
165
+
* `public java.lang.String nativeLibraryDir;`
166
+
*
167
+
* JNI signature: Ljava/lang/String;
168
+
*
169
+
*/
170
+
std::string getNativeLibraryDir() const;
171
+
172
+
/*!
173
+
* Getter for the publicSourceDir field value
174
+
*
175
+
* Java prototype:
176
+
* `public java.lang.String publicSourceDir;`
177
+
*
178
+
* JNI signature: Ljava/lang/String;
179
+
*
180
+
*/
181
+
std::string getPublicSourceDir() const;
182
+
183
+
/*!
184
+
* Class metadata
185
+
*/
186
+
struct Meta : public MetaBaseDroppable {
187
+
impl::FieldId<std::string> nativeLibraryDir;
188
+
impl::FieldId<std::string> publicSourceDir;
189
+
190
+
/*!
191
+
* Singleton accessor
192
+
*/
193
+
static Meta &data() {
194
+
static Meta instance;
195
+
return instance;
196
+
}
197
+
198
+
private:
199
+
Meta();
200
+
};
201
+
};
202
+
/*!
203
+
* Wrapper for android.content.pm.PackageInfo objects.
204
+
*/
205
+
class PackageInfo : public ObjectWrapperBase {
206
+
public:
207
+
using ObjectWrapperBase::ObjectWrapperBase;
208
+
static constexpr const char *getTypeName() noexcept {
209
+
return "android/content/pm/PackageInfo";
210
+
}
211
+
212
+
/*!
213
+
* Getter for the applicationInfo field value
214
+
*
215
+
* Java prototype:
216
+
* `public android.content.pm.ApplicationInfo applicationInfo;`
217
+
*
218
+
* JNI signature: Landroid/content/pm/ApplicationInfo;
219
+
*
220
+
*/
221
+
ApplicationInfo getApplicationInfo() const;
222
+
223
+
/*!
224
+
* Getter for the packageName field value
225
+
*
226
+
* Java prototype:
227
+
* `public java.lang.String packageName;`
228
+
*
229
+
* JNI signature: Ljava/lang/String;
230
+
*
231
+
*/
232
+
std::string getPackageName() const;
233
+
234
+
/*!
235
+
* Class metadata
236
+
*/
237
+
struct Meta : public MetaBaseDroppable {
238
+
impl::WrappedFieldId<ApplicationInfo> applicationInfo;
239
+
impl::FieldId<std::string> packageName;
240
+
241
+
/*!
242
+
* Singleton accessor
243
+
*/
244
+
static Meta &data() {
245
+
static Meta instance;
246
+
return instance;
247
+
}
248
+
249
+
private:
250
+
Meta();
251
+
};
252
+
};
253
+
/*!
254
+
* Wrapper for android.content.pm.ResolveInfo objects.
255
+
*/
256
+
class ResolveInfo : public ObjectWrapperBase {
257
+
public:
258
+
using ObjectWrapperBase::ObjectWrapperBase;
259
+
static constexpr const char *getTypeName() noexcept {
260
+
return "android/content/pm/ResolveInfo";
261
+
}
262
+
263
+
/*!
264
+
* Getter for the serviceInfo field value
265
+
*
266
+
* Java prototype:
267
+
* `public android.content.pm.ServiceInfo serviceInfo;`
268
+
*
269
+
* JNI signature: Landroid/content/pm/ServiceInfo;
270
+
*
271
+
*/
272
+
ServiceInfo getServiceInfo() const;
273
+
274
+
/*!
275
+
* Class metadata
276
+
*/
277
+
struct Meta : public MetaBaseDroppable {
278
+
impl::WrappedFieldId<ServiceInfo> serviceInfo;
279
+
280
+
/*!
281
+
* Singleton accessor
282
+
*/
283
+
static Meta &data() {
284
+
static Meta instance;
285
+
return instance;
286
+
}
287
+
288
+
private:
289
+
Meta();
290
+
};
291
+
};
292
+
/*!
293
+
* Wrapper for android.content.pm.PackageManager objects.
294
+
*/
295
+
class PackageManager : public ObjectWrapperBase {
296
+
public:
297
+
using ObjectWrapperBase::ObjectWrapperBase;
298
+
static constexpr const char *getTypeName() noexcept {
299
+
return "android/content/pm/PackageManager";
300
+
}
301
+
302
+
/*!
303
+
* Wrapper for the getPackageInfo method
304
+
*
305
+
* Java prototype:
306
+
* `public abstract android.content.pm.PackageInfo
307
+
* getPackageInfo(java.lang.String, int) throws
308
+
* android.content.pm.PackageManager$NameNotFoundException;`
309
+
*
310
+
* JNI signature: (Ljava/lang/String;I)Landroid/content/pm/PackageInfo;
311
+
*
312
+
*/
313
+
PackageInfo getPackageInfo(std::string const &name, int32_t flags);
314
+
315
+
#if 0
316
+
// Ambiguous overload until we wrap VersionedPackage
317
+
/*!
318
+
* Wrapper for the getPackageInfo method
319
+
*
320
+
* Java prototype:
321
+
* `public abstract android.content.pm.PackageInfo
322
+
* getPackageInfo(android.content.pm.VersionedPackage, int) throws
323
+
* android.content.pm.PackageManager$NameNotFoundException;`
324
+
*
325
+
* JNI signature:
326
+
* (Landroid/content/pm/VersionedPackage;I)Landroid/content/pm/PackageInfo;
327
+
*
328
+
*/
329
+
PackageInfo getPackageInfo(jni::Object &versionedPackage, int32_t flags);
330
+
331
+
#endif
332
+
333
+
/*!
334
+
* Wrapper for the getApplicationInfo method
335
+
*
336
+
* Java prototype:
337
+
* `public abstract android.content.pm.ApplicationInfo
338
+
* getApplicationInfo(java.lang.String, int) throws
339
+
* android.content.pm.PackageManager$NameNotFoundException;`
340
+
*
341
+
* JNI signature: (Ljava/lang/String;I)Landroid/content/pm/ApplicationInfo;
342
+
*
343
+
*/
344
+
ApplicationInfo getApplicationInfo(std::string const &packageName,
345
+
int32_t flags);
346
+
347
+
/*!
348
+
* Wrapper for the queryIntentServices method
349
+
*
350
+
* Java prototype:
351
+
* `public abstract java.util.List<android.content.pm.ResolveInfo>
352
+
* queryIntentServices(android.content.Intent, int);`
353
+
*
354
+
* JNI signature: (Landroid/content/Intent;I)Ljava/util/List;
355
+
*
356
+
*/
357
+
java::util::List queryIntentServices(Intent &intent, int32_t intParam);
358
+
359
+
enum {
360
+
GET_META_DATA = 128,
361
+
GET_SHARED_LIBRARY_FILES = 1024,
362
+
};
363
+
364
+
/*!
365
+
* Class metadata
366
+
*/
367
+
struct Meta : public MetaBaseDroppable {
368
+
jni::method_t getPackageInfo;
369
+
jni::method_t getPackageInfo1;
370
+
jni::method_t getApplicationInfo;
371
+
jni::method_t queryIntentServices;
372
+
373
+
/*!
374
+
* Singleton accessor
375
+
*/
376
+
static Meta &data() {
377
+
static Meta instance;
378
+
return instance;
379
+
}
380
+
381
+
private:
382
+
Meta();
383
+
};
384
+
};
385
+
} // namespace android::content::pm
386
+
} // namespace wrap
387
+
#include "android.content.pm.impl.h"
+83
src/external/android-jni-wrap/wrap/android.content.pm.impl.h
+83
src/external/android-jni-wrap/wrap/android.content.pm.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "android.content.h"
8
+
#include "java.util.h"
9
+
#include <string>
10
+
11
+
namespace wrap {
12
+
namespace android::content::pm {
13
+
inline os::Bundle PackageItemInfo::getMetaData() const {
14
+
assert(!isNull());
15
+
return get(Meta::data().metaData, object());
16
+
}
17
+
18
+
inline std::string PackageItemInfo::getName() const {
19
+
assert(!isNull());
20
+
return get(Meta::data().name, object());
21
+
}
22
+
23
+
inline std::string PackageItemInfo::getPackageName() const {
24
+
assert(!isNull());
25
+
return get(Meta::data().packageName, object());
26
+
}
27
+
28
+
inline std::string ApplicationInfo::getNativeLibraryDir() const {
29
+
assert(!isNull());
30
+
return get(Meta::data().nativeLibraryDir, object());
31
+
}
32
+
33
+
inline std::string ApplicationInfo::getPublicSourceDir() const {
34
+
assert(!isNull());
35
+
return get(Meta::data().publicSourceDir, object());
36
+
}
37
+
inline ApplicationInfo PackageInfo::getApplicationInfo() const {
38
+
assert(!isNull());
39
+
return get(Meta::data().applicationInfo, object());
40
+
}
41
+
42
+
inline std::string PackageInfo::getPackageName() const {
43
+
assert(!isNull());
44
+
return get(Meta::data().packageName, object());
45
+
}
46
+
inline ServiceInfo ResolveInfo::getServiceInfo() const {
47
+
assert(!isNull());
48
+
return get(Meta::data().serviceInfo, object());
49
+
}
50
+
inline PackageInfo PackageManager::getPackageInfo(std::string const &name,
51
+
int32_t flags) {
52
+
assert(!isNull());
53
+
return PackageInfo(
54
+
object().call<jni::Object>(Meta::data().getPackageInfo, name, flags));
55
+
}
56
+
57
+
#if 0
58
+
// Ambiguous overload until we wrap VersionedPackage
59
+
inline PackageInfo
60
+
PackageManager::getPackageInfo(jni::Object const &versionedPackage,
61
+
int32_t flags) {
62
+
assert(!isNull());
63
+
return PackageInfo(object().call<jni::Object>(Meta::data().getPackageInfo1,
64
+
versionedPackage, flags));
65
+
}
66
+
#endif
67
+
68
+
inline ApplicationInfo
69
+
PackageManager::getApplicationInfo(std::string const &packageName,
70
+
int32_t flags) {
71
+
assert(!isNull());
72
+
return ApplicationInfo(object().call<jni::Object>(
73
+
Meta::data().getApplicationInfo, packageName, flags));
74
+
}
75
+
76
+
inline java::util::List PackageManager::queryIntentServices(Intent &intent,
77
+
int32_t intParam) {
78
+
assert(!isNull());
79
+
return java::util::List(object().call<jni::Object>(
80
+
Meta::data().queryIntentServices, intent.object(), intParam));
81
+
}
82
+
} // namespace android::content::pm
83
+
} // namespace wrap
+15
src/external/android-jni-wrap/wrap/android.graphics.cpp
+15
src/external/android-jni-wrap/wrap/android.graphics.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.graphics.h"
6
+
7
+
namespace wrap {
8
+
namespace android::graphics {
9
+
Point::Meta::Meta()
10
+
: MetaBaseDroppable(Point::getTypeName()), x(classRef(), "x"),
11
+
y(classRef(), "y") {
12
+
MetaBaseDroppable::dropClassRef();
13
+
}
14
+
} // namespace android::graphics
15
+
} // namespace wrap
+64
src/external/android-jni-wrap/wrap/android.graphics.h
+64
src/external/android-jni-wrap/wrap/android.graphics.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
9
+
namespace wrap {
10
+
namespace android::graphics {
11
+
/*!
12
+
* Wrapper for android.graphics.Point objects.
13
+
*/
14
+
class Point : public ObjectWrapperBase {
15
+
public:
16
+
using ObjectWrapperBase::ObjectWrapperBase;
17
+
static constexpr const char *getTypeName() noexcept {
18
+
return "android/graphics/Point";
19
+
}
20
+
21
+
/*!
22
+
* Getter for the x field value
23
+
*
24
+
* Java prototype:
25
+
* `public int x;`
26
+
*
27
+
* JNI signature: I
28
+
*
29
+
*/
30
+
int32_t getX() const;
31
+
32
+
/*!
33
+
* Getter for the y field value
34
+
*
35
+
* Java prototype:
36
+
* `public int y;`
37
+
*
38
+
* JNI signature: I
39
+
*
40
+
*/
41
+
int32_t getY() const;
42
+
43
+
/*!
44
+
* Class metadata
45
+
*/
46
+
struct Meta : public MetaBaseDroppable {
47
+
impl::FieldId<int32_t> x;
48
+
impl::FieldId<int32_t> y;
49
+
50
+
/*!
51
+
* Singleton accessor
52
+
*/
53
+
static Meta &data() {
54
+
static Meta instance;
55
+
return instance;
56
+
}
57
+
58
+
private:
59
+
Meta();
60
+
};
61
+
};
62
+
} // namespace android::graphics
63
+
} // namespace wrap
64
+
#include "android.graphics.impl.h"
+19
src/external/android-jni-wrap/wrap/android.graphics.impl.h
+19
src/external/android-jni-wrap/wrap/android.graphics.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
namespace wrap {
8
+
namespace android::graphics {
9
+
inline int32_t Point::getX() const {
10
+
assert(!isNull());
11
+
return get(Meta::data().x, object());
12
+
}
13
+
14
+
inline int32_t Point::getY() const {
15
+
assert(!isNull());
16
+
return get(Meta::data().y, object());
17
+
}
18
+
} // namespace android::graphics
19
+
} // namespace wrap
+33
src/external/android-jni-wrap/wrap/android.os.cpp
+33
src/external/android-jni-wrap/wrap/android.os.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.os.h"
6
+
7
+
namespace wrap {
8
+
namespace android::os {
9
+
BaseBundle::Meta::Meta()
10
+
: MetaBaseDroppable(BaseBundle::getTypeName()),
11
+
containsKey(classRef().getMethod("containsKey", "(Ljava/lang/String;)Z")),
12
+
getString(classRef().getMethod("getString",
13
+
"(Ljava/lang/String;)Ljava/lang/String;")),
14
+
getString1(classRef().getMethod(
15
+
"getString",
16
+
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;")) {
17
+
MetaBaseDroppable::dropClassRef();
18
+
}
19
+
Bundle::Meta::Meta() : MetaBaseDroppable(Bundle::getTypeName()) {
20
+
MetaBaseDroppable::dropClassRef();
21
+
}
22
+
ParcelFileDescriptor::Meta::Meta()
23
+
: MetaBaseDroppable(ParcelFileDescriptor::getTypeName()),
24
+
adoptFd(classRef().getStaticMethod(
25
+
"adoptFd", "(I)Landroid/os/ParcelFileDescriptor;")),
26
+
getFd(classRef().getMethod("getFd", "()I")),
27
+
detachFd(classRef().getMethod("detachFd", "()I")),
28
+
close(classRef().getMethod("close", "()V")),
29
+
checkError(classRef().getMethod("checkError", "()V")) {
30
+
MetaBaseDroppable::dropClassRef();
31
+
}
32
+
} // namespace android::os
33
+
} // namespace wrap
+199
src/external/android-jni-wrap/wrap/android.os.h
+199
src/external/android-jni-wrap/wrap/android.os.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
9
+
namespace wrap {
10
+
namespace android::os {
11
+
class ParcelFileDescriptor;
12
+
} // namespace android::os
13
+
14
+
} // namespace wrap
15
+
16
+
namespace wrap {
17
+
namespace android::os {
18
+
/*!
19
+
* Wrapper for android.os.BaseBundle objects.
20
+
*/
21
+
class BaseBundle : public ObjectWrapperBase {
22
+
public:
23
+
using ObjectWrapperBase::ObjectWrapperBase;
24
+
static constexpr const char *getTypeName() noexcept {
25
+
return "android/os/BaseBundle";
26
+
}
27
+
28
+
/*!
29
+
* Wrapper for the containsKey method
30
+
*
31
+
* Java prototype:
32
+
* `public boolean containsKey(java.lang.String);`
33
+
*
34
+
* JNI signature: (Ljava/lang/String;)Z
35
+
*
36
+
*/
37
+
bool containsKey(std::string const &key);
38
+
39
+
/*!
40
+
* Wrapper for the getString method
41
+
*
42
+
* Java prototype:
43
+
* `public java.lang.String getString(java.lang.String);`
44
+
*
45
+
* JNI signature: (Ljava/lang/String;)Ljava/lang/String;
46
+
*
47
+
*/
48
+
std::string getString(std::string const &key);
49
+
50
+
/*!
51
+
* Wrapper for the getString method
52
+
*
53
+
* Java prototype:
54
+
* `public java.lang.String getString(java.lang.String, java.lang.String);`
55
+
*
56
+
* JNI signature: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
57
+
*
58
+
*/
59
+
std::string getString(std::string const &key,
60
+
std::string const &defaultValue);
61
+
62
+
/*!
63
+
* Class metadata
64
+
*/
65
+
struct Meta : public MetaBaseDroppable {
66
+
jni::method_t containsKey;
67
+
jni::method_t getString;
68
+
jni::method_t getString1;
69
+
70
+
/*!
71
+
* Singleton accessor
72
+
*/
73
+
static Meta &data() {
74
+
static Meta instance;
75
+
return instance;
76
+
}
77
+
78
+
private:
79
+
Meta();
80
+
};
81
+
};
82
+
/*!
83
+
* Wrapper for android.os.Bundle objects.
84
+
*/
85
+
class Bundle : public BaseBundle {
86
+
public:
87
+
using BaseBundle::BaseBundle;
88
+
static constexpr const char *getTypeName() noexcept {
89
+
return "android/os/Bundle";
90
+
}
91
+
92
+
/*!
93
+
* Class metadata
94
+
*/
95
+
struct Meta : public MetaBaseDroppable {
96
+
97
+
/*!
98
+
* Singleton accessor
99
+
*/
100
+
static Meta &data() {
101
+
static Meta instance;
102
+
return instance;
103
+
}
104
+
105
+
private:
106
+
Meta();
107
+
};
108
+
};
109
+
110
+
/*!
111
+
* Wrapper for android.os.ParcelFileDescriptor objects.
112
+
*/
113
+
class ParcelFileDescriptor : public ObjectWrapperBase {
114
+
public:
115
+
using ObjectWrapperBase::ObjectWrapperBase;
116
+
static constexpr const char *getTypeName() noexcept {
117
+
return "android/os/ParcelFileDescriptor";
118
+
}
119
+
120
+
/*!
121
+
* Wrapper for the adoptFd static method
122
+
*
123
+
* Java prototype:
124
+
* `public static android.os.ParcelFileDescriptor adoptFd(int);`
125
+
*
126
+
* JNI signature: (I)Landroid/os/ParcelFileDescriptor;
127
+
*
128
+
*/
129
+
static ParcelFileDescriptor adoptFd(int fd);
130
+
131
+
/*!
132
+
* Wrapper for the getFd method
133
+
*
134
+
* Java prototype:
135
+
* `public int getFd();`
136
+
*
137
+
* JNI signature: ()I
138
+
*
139
+
*/
140
+
int getFd() const;
141
+
142
+
/*!
143
+
* Wrapper for the detachFd method
144
+
*
145
+
* Java prototype:
146
+
* `public int detachFd();`
147
+
*
148
+
* JNI signature: ()I
149
+
*
150
+
*/
151
+
int detachFd();
152
+
153
+
/*!
154
+
* Wrapper for the close method
155
+
*
156
+
* Java prototype:
157
+
* `public void close() throws java.io.IOException;`
158
+
*
159
+
* JNI signature: ()V
160
+
*
161
+
*/
162
+
void close();
163
+
164
+
/*!
165
+
* Wrapper for the checkError method
166
+
*
167
+
* Java prototype:
168
+
* `public void checkError() throws java.io.IOException;`
169
+
*
170
+
* JNI signature: ()V
171
+
*
172
+
*/
173
+
void checkError() const;
174
+
175
+
/*!
176
+
* Class metadata
177
+
*/
178
+
struct Meta : public MetaBaseDroppable {
179
+
jni::method_t adoptFd;
180
+
jni::method_t getFd;
181
+
jni::method_t detachFd;
182
+
jni::method_t close;
183
+
jni::method_t checkError;
184
+
185
+
/*!
186
+
* Singleton accessor
187
+
*/
188
+
static Meta &data() {
189
+
static Meta instance;
190
+
return instance;
191
+
}
192
+
193
+
private:
194
+
Meta();
195
+
};
196
+
};
197
+
} // namespace android::os
198
+
} // namespace wrap
199
+
#include "android.os.impl.h"
+53
src/external/android-jni-wrap/wrap/android.os.impl.h
+53
src/external/android-jni-wrap/wrap/android.os.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include <string>
8
+
9
+
namespace wrap {
10
+
namespace android::os {
11
+
inline bool BaseBundle::containsKey(std::string const &key) {
12
+
assert(!isNull());
13
+
return object().call<bool>(Meta::data().containsKey, key);
14
+
}
15
+
16
+
inline std::string BaseBundle::getString(std::string const &key) {
17
+
assert(!isNull());
18
+
return object().call<std::string>(Meta::data().getString, key);
19
+
}
20
+
21
+
inline std::string BaseBundle::getString(std::string const &key,
22
+
std::string const &defaultValue) {
23
+
assert(!isNull());
24
+
return object().call<std::string>(Meta::data().getString1, key,
25
+
defaultValue);
26
+
}
27
+
28
+
inline ParcelFileDescriptor ParcelFileDescriptor::adoptFd(int fd) {
29
+
return ParcelFileDescriptor(
30
+
Meta::data().clazz().call<jni::Object>(Meta::data().adoptFd, fd));
31
+
}
32
+
33
+
inline int ParcelFileDescriptor::getFd() const {
34
+
assert(!isNull());
35
+
return object().call<int>(Meta::data().getFd);
36
+
}
37
+
38
+
inline int ParcelFileDescriptor::detachFd() {
39
+
assert(!isNull());
40
+
return object().call<int>(Meta::data().detachFd);
41
+
}
42
+
43
+
inline void ParcelFileDescriptor::close() {
44
+
assert(!isNull());
45
+
return object().call<void>(Meta::data().close);
46
+
}
47
+
48
+
inline void ParcelFileDescriptor::checkError() const {
49
+
assert(!isNull());
50
+
return object().call<void>(Meta::data().checkError);
51
+
}
52
+
} // namespace android::os
53
+
} // namespace wrap
+13
src/external/android-jni-wrap/wrap/android.provider.cpp
+13
src/external/android-jni-wrap/wrap/android.provider.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.provider.h"
6
+
7
+
namespace wrap {
8
+
namespace android::provider {
9
+
Settings::Meta::Meta()
10
+
: MetaBase(Settings::getTypeName()),
11
+
ACTION_VR_LISTENER_SETTINGS(classRef(), "ACTION_VR_LISTENER_SETTINGS") {}
12
+
} // namespace android::provider
13
+
} // namespace wrap
+53
src/external/android-jni-wrap/wrap/android.provider.h
+53
src/external/android-jni-wrap/wrap/android.provider.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
#include <string>
9
+
10
+
namespace wrap {
11
+
namespace android::provider {
12
+
/*!
13
+
* Wrapper for android.provider.Settings objects.
14
+
*/
15
+
class Settings : public ObjectWrapperBase {
16
+
public:
17
+
using ObjectWrapperBase::ObjectWrapperBase;
18
+
static constexpr const char *getTypeName() noexcept {
19
+
return "android/provider/Settings";
20
+
}
21
+
22
+
/*!
23
+
* Getter for the ACTION_VR_LISTENER_SETTINGS static field value
24
+
*
25
+
* Java prototype:
26
+
* `public static final java.lang.String ACTION_VR_LISTENER_SETTINGS;`
27
+
*
28
+
* JNI signature: Ljava/lang/String;
29
+
*
30
+
*/
31
+
static std::string ACTION_VR_LISTENER_SETTINGS();
32
+
33
+
/*!
34
+
* Class metadata
35
+
*/
36
+
struct Meta : public MetaBase {
37
+
impl::StaticFieldId<std::string> ACTION_VR_LISTENER_SETTINGS;
38
+
39
+
/*!
40
+
* Singleton accessor
41
+
*/
42
+
static Meta &data() {
43
+
static Meta instance;
44
+
return instance;
45
+
}
46
+
47
+
private:
48
+
Meta();
49
+
};
50
+
};
51
+
} // namespace android::provider
52
+
} // namespace wrap
53
+
#include "android.provider.impl.h"
+13
src/external/android-jni-wrap/wrap/android.provider.impl.h
+13
src/external/android-jni-wrap/wrap/android.provider.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
namespace wrap {
8
+
namespace android::provider {
9
+
inline std::string Settings::ACTION_VR_LISTENER_SETTINGS() {
10
+
return get(Meta::data().ACTION_VR_LISTENER_SETTINGS, Meta::data().clazz());
11
+
}
12
+
} // namespace android::provider
13
+
} // namespace wrap
+15
src/external/android-jni-wrap/wrap/android.service.vr.cpp
+15
src/external/android-jni-wrap/wrap/android.service.vr.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.service.vr.h"
6
+
7
+
namespace wrap {
8
+
namespace android::service::vr {
9
+
VrListenerService::Meta::Meta()
10
+
: MetaBase(VrListenerService::getTypeName()),
11
+
isVrModePackageEnabled(classRef().getStaticMethod(
12
+
"isVrModePackageEnabled",
13
+
"(Landroid/content/Context;Landroid/content/ComponentName;)Z")) {}
14
+
} // namespace android::service::vr
15
+
} // namespace wrap
+65
src/external/android-jni-wrap/wrap/android.service.vr.h
+65
src/external/android-jni-wrap/wrap/android.service.vr.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "android.app.h"
8
+
9
+
namespace wrap {
10
+
namespace android::content {
11
+
class ComponentName;
12
+
class Context;
13
+
} // namespace android::content
14
+
15
+
} // namespace wrap
16
+
17
+
namespace wrap {
18
+
namespace android::service::vr {
19
+
/*!
20
+
* Wrapper for android.service.vr.VrListenerService objects.
21
+
*/
22
+
class VrListenerService : public app::Service {
23
+
public:
24
+
using Service::Service;
25
+
static constexpr const char *getTypeName() noexcept {
26
+
return "android/service/vr/VrListenerService";
27
+
}
28
+
29
+
/*!
30
+
* Wrapper for the isVrModePackageEnabled static method
31
+
*
32
+
* Java prototype:
33
+
* `public static final boolean
34
+
* isVrModePackageEnabled(android.content.Context,
35
+
* android.content.ComponentName);`
36
+
*
37
+
* JNI signature:
38
+
* (Landroid/content/Context;Landroid/content/ComponentName;)Z
39
+
*
40
+
*/
41
+
static bool
42
+
isVrModePackageEnabled(content::Context const &context,
43
+
content::ComponentName const &componentName);
44
+
45
+
/*!
46
+
* Class metadata
47
+
*/
48
+
struct Meta : public MetaBase {
49
+
jni::method_t isVrModePackageEnabled;
50
+
51
+
/*!
52
+
* Singleton accessor
53
+
*/
54
+
static Meta &data() {
55
+
static Meta instance;
56
+
return instance;
57
+
}
58
+
59
+
private:
60
+
Meta();
61
+
};
62
+
};
63
+
} // namespace android::service::vr
64
+
} // namespace wrap
65
+
#include "android.service.vr.impl.h"
+19
src/external/android-jni-wrap/wrap/android.service.vr.impl.h
+19
src/external/android-jni-wrap/wrap/android.service.vr.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "android.content.h"
8
+
9
+
namespace wrap {
10
+
namespace android::service::vr {
11
+
inline bool VrListenerService::isVrModePackageEnabled(
12
+
content::Context const &context,
13
+
content::ComponentName const &componentName) {
14
+
return Meta::data().clazz().call<bool>(Meta::data().isVrModePackageEnabled,
15
+
context.object(),
16
+
componentName.object());
17
+
}
18
+
} // namespace android::service::vr
19
+
} // namespace wrap
+16
src/external/android-jni-wrap/wrap/android.util.cpp
+16
src/external/android-jni-wrap/wrap/android.util.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.util.h"
6
+
7
+
namespace wrap {
8
+
namespace android::util {
9
+
DisplayMetrics::Meta::Meta()
10
+
: MetaBaseDroppable(DisplayMetrics::getTypeName()),
11
+
heightPixels(classRef(), "heightPixels"),
12
+
widthPixels(classRef(), "widthPixels") {
13
+
MetaBaseDroppable::dropClassRef();
14
+
}
15
+
} // namespace android::util
16
+
} // namespace wrap
+64
src/external/android-jni-wrap/wrap/android.util.h
+64
src/external/android-jni-wrap/wrap/android.util.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
9
+
namespace wrap {
10
+
namespace android::util {
11
+
/*!
12
+
* Wrapper for android.util.DisplayMetrics objects.
13
+
*/
14
+
class DisplayMetrics : public ObjectWrapperBase {
15
+
public:
16
+
using ObjectWrapperBase::ObjectWrapperBase;
17
+
static constexpr const char *getTypeName() noexcept {
18
+
return "android/util/DisplayMetrics";
19
+
}
20
+
21
+
/*!
22
+
* Getter for the heightPixels field value
23
+
*
24
+
* Java prototype:
25
+
* `public int heightPixels;`
26
+
*
27
+
* JNI signature: I
28
+
*
29
+
*/
30
+
int32_t getHeightPixels() const;
31
+
32
+
/*!
33
+
* Getter for the widthPixels field value
34
+
*
35
+
* Java prototype:
36
+
* `public int widthPixels;`
37
+
*
38
+
* JNI signature: I
39
+
*
40
+
*/
41
+
int32_t getWidthPixels() const;
42
+
43
+
/*!
44
+
* Class metadata
45
+
*/
46
+
struct Meta : public MetaBaseDroppable {
47
+
impl::FieldId<int32_t> heightPixels;
48
+
impl::FieldId<int32_t> widthPixels;
49
+
50
+
/*!
51
+
* Singleton accessor
52
+
*/
53
+
static Meta &data() {
54
+
static Meta instance;
55
+
return instance;
56
+
}
57
+
58
+
private:
59
+
Meta();
60
+
};
61
+
};
62
+
} // namespace android::util
63
+
} // namespace wrap
64
+
#include "android.util.impl.h"
+19
src/external/android-jni-wrap/wrap/android.util.impl.h
+19
src/external/android-jni-wrap/wrap/android.util.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
namespace wrap {
8
+
namespace android::util {
9
+
inline int32_t DisplayMetrics::getHeightPixels() const {
10
+
assert(!isNull());
11
+
return get(Meta::data().heightPixels, object());
12
+
}
13
+
14
+
inline int32_t DisplayMetrics::getWidthPixels() const {
15
+
assert(!isNull());
16
+
return get(Meta::data().widthPixels, object());
17
+
}
18
+
} // namespace android::util
19
+
} // namespace wrap
+29
src/external/android-jni-wrap/wrap/android.view.cpp
+29
src/external/android-jni-wrap/wrap/android.view.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.view.h"
6
+
7
+
namespace wrap {
8
+
namespace android::view {
9
+
Display::Meta::Meta()
10
+
: MetaBaseDroppable(Display::getTypeName()),
11
+
getRealSize(
12
+
classRef().getMethod("getRealSize", "(Landroid/graphics/Point;)V")),
13
+
getRealMetrics(classRef().getMethod("getRealMetrics",
14
+
"(Landroid/util/DisplayMetrics;)V")) {
15
+
MetaBaseDroppable::dropClassRef();
16
+
}
17
+
Surface::Meta::Meta()
18
+
: MetaBaseDroppable(Surface::getTypeName()),
19
+
isValid(classRef().getMethod("isValid", "()Z")) {
20
+
MetaBaseDroppable::dropClassRef();
21
+
}
22
+
SurfaceHolder::Meta::Meta()
23
+
: MetaBaseDroppable(SurfaceHolder::getTypeName()),
24
+
getSurface(
25
+
classRef().getMethod("getSurface", "()Landroid/view/Surface;")) {
26
+
MetaBaseDroppable::dropClassRef();
27
+
}
28
+
} // namespace android::view
29
+
} // namespace wrap
+157
src/external/android-jni-wrap/wrap/android.view.h
+157
src/external/android-jni-wrap/wrap/android.view.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
9
+
namespace wrap {
10
+
namespace android::graphics {
11
+
class Point;
12
+
} // namespace android::graphics
13
+
14
+
namespace android::util {
15
+
class DisplayMetrics;
16
+
} // namespace android::util
17
+
18
+
namespace android::view {
19
+
class Surface;
20
+
} // namespace android::view
21
+
22
+
} // namespace wrap
23
+
24
+
namespace wrap {
25
+
namespace android::view {
26
+
/*!
27
+
* Wrapper for android.view.Display objects.
28
+
*/
29
+
class Display : public ObjectWrapperBase {
30
+
public:
31
+
using ObjectWrapperBase::ObjectWrapperBase;
32
+
static constexpr const char *getTypeName() noexcept {
33
+
return "android/view/Display";
34
+
}
35
+
36
+
/*!
37
+
* Wrapper for the getRealSize method
38
+
*
39
+
* Java prototype:
40
+
* `public void getRealSize(android.graphics.Point);`
41
+
*
42
+
* JNI signature: (Landroid/graphics/Point;)V
43
+
*
44
+
*/
45
+
void getRealSize(graphics::Point &out_size);
46
+
47
+
/*!
48
+
* Wrapper for the getRealMetrics method
49
+
*
50
+
* Java prototype:
51
+
* `public void getRealMetrics(android.util.DisplayMetrics);`
52
+
*
53
+
* JNI signature: (Landroid/util/DisplayMetrics;)V
54
+
*
55
+
*/
56
+
void getRealMetrics(util::DisplayMetrics &out_displayMetrics);
57
+
58
+
/*!
59
+
* Class metadata
60
+
*/
61
+
struct Meta : public MetaBaseDroppable {
62
+
jni::method_t getRealSize;
63
+
jni::method_t getRealMetrics;
64
+
65
+
/*!
66
+
* Singleton accessor
67
+
*/
68
+
static Meta &data() {
69
+
static Meta instance;
70
+
return instance;
71
+
}
72
+
73
+
private:
74
+
Meta();
75
+
};
76
+
};
77
+
/*!
78
+
* Wrapper for android.view.Surface objects.
79
+
*/
80
+
class Surface : public ObjectWrapperBase {
81
+
public:
82
+
using ObjectWrapperBase::ObjectWrapperBase;
83
+
static constexpr const char *getTypeName() noexcept {
84
+
return "android/view/Surface";
85
+
}
86
+
87
+
/*!
88
+
* Wrapper for the isValid method
89
+
*
90
+
* Java prototype:
91
+
* `public boolean isValid();`
92
+
*
93
+
* JNI signature: ()Z
94
+
*
95
+
*/
96
+
bool isValid() const;
97
+
98
+
/*!
99
+
* Class metadata
100
+
*/
101
+
struct Meta : public MetaBaseDroppable {
102
+
jni::method_t isValid;
103
+
104
+
/*!
105
+
* Singleton accessor
106
+
*/
107
+
static Meta &data() {
108
+
static Meta instance;
109
+
return instance;
110
+
}
111
+
112
+
private:
113
+
Meta();
114
+
};
115
+
};
116
+
/*!
117
+
* Wrapper for android.view.SurfaceHolder objects.
118
+
*/
119
+
class SurfaceHolder : public ObjectWrapperBase {
120
+
public:
121
+
using ObjectWrapperBase::ObjectWrapperBase;
122
+
static constexpr const char *getTypeName() noexcept {
123
+
return "android/view/SurfaceHolder";
124
+
}
125
+
126
+
/*!
127
+
* Wrapper for the getSurface method
128
+
*
129
+
* Java prototype:
130
+
* `public abstract android.view.Surface getSurface();`
131
+
*
132
+
* JNI signature: ()Landroid/view/Surface;
133
+
*
134
+
*/
135
+
Surface getSurface();
136
+
137
+
/*!
138
+
* Class metadata
139
+
*/
140
+
struct Meta : public MetaBaseDroppable {
141
+
jni::method_t getSurface;
142
+
143
+
/*!
144
+
* Singleton accessor
145
+
*/
146
+
static Meta &data() {
147
+
static Meta instance;
148
+
return instance;
149
+
}
150
+
151
+
private:
152
+
Meta();
153
+
};
154
+
};
155
+
} // namespace android::view
156
+
} // namespace wrap
157
+
#include "android.view.impl.h"
+31
src/external/android-jni-wrap/wrap/android.view.impl.h
+31
src/external/android-jni-wrap/wrap/android.view.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "android.graphics.h"
8
+
#include "android.util.h"
9
+
10
+
namespace wrap {
11
+
namespace android::view {
12
+
inline void Display::getRealSize(graphics::Point &out_size) {
13
+
assert(!isNull());
14
+
return object().call<void>(Meta::data().getRealSize, out_size.object());
15
+
}
16
+
17
+
inline void Display::getRealMetrics(util::DisplayMetrics &out_displayMetrics) {
18
+
assert(!isNull());
19
+
return object().call<void>(Meta::data().getRealMetrics,
20
+
out_displayMetrics.object());
21
+
}
22
+
inline bool Surface::isValid() const {
23
+
assert(!isNull());
24
+
return object().call<bool>(Meta::data().isValid);
25
+
}
26
+
inline Surface SurfaceHolder::getSurface() {
27
+
assert(!isNull());
28
+
return Surface(object().call<jni::Object>(Meta::data().getSurface));
29
+
}
30
+
} // namespace android::view
31
+
} // namespace wrap
+19
src/external/android-jni-wrap/wrap/android.widget.cpp
+19
src/external/android-jni-wrap/wrap/android.widget.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "android.widget.h"
6
+
7
+
namespace wrap {
8
+
namespace android::widget {
9
+
Toast::Meta::Meta()
10
+
: MetaBase(Toast::getTypeName()), LENGTH_LONG(classRef(), "LENGTH_LONG"),
11
+
LENGTH_SHORT(classRef(), "LENGTH_SHORT"),
12
+
show(classRef().getMethod("show", "()V")),
13
+
makeText(classRef().getStaticMethod(
14
+
"makeText", "(Landroid/content/Context;Ljava/lang/"
15
+
"CharSequence;I)Landroid/widget/Toast;")),
16
+
makeText1(classRef().getStaticMethod(
17
+
"makeText", "(Landroid/content/Context;II)Landroid/widget/Toast;")) {}
18
+
} // namespace android::widget
19
+
} // namespace wrap
+116
src/external/android-jni-wrap/wrap/android.widget.h
+116
src/external/android-jni-wrap/wrap/android.widget.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
9
+
namespace wrap {
10
+
namespace android::content {
11
+
class Context;
12
+
} // namespace android::content
13
+
14
+
namespace android::widget {
15
+
class Toast;
16
+
} // namespace android::widget
17
+
18
+
} // namespace wrap
19
+
20
+
namespace wrap {
21
+
namespace android::widget {
22
+
/*!
23
+
* Wrapper for android.widget.Toast objects.
24
+
*/
25
+
class Toast : public ObjectWrapperBase {
26
+
public:
27
+
using ObjectWrapperBase::ObjectWrapperBase;
28
+
static constexpr const char *getTypeName() noexcept {
29
+
return "android/widget/Toast";
30
+
}
31
+
32
+
/*!
33
+
* Getter for the LENGTH_LONG static field value
34
+
*
35
+
* Java prototype:
36
+
* `public static final int LENGTH_LONG;`
37
+
*
38
+
* JNI signature: I
39
+
*
40
+
*/
41
+
static int32_t LENGTH_LONG();
42
+
43
+
/*!
44
+
* Getter for the LENGTH_SHORT static field value
45
+
*
46
+
* Java prototype:
47
+
* `public static final int LENGTH_SHORT;`
48
+
*
49
+
* JNI signature: I
50
+
*
51
+
*/
52
+
static int32_t LENGTH_SHORT();
53
+
54
+
/*!
55
+
* Wrapper for the show method
56
+
*
57
+
* Java prototype:
58
+
* `public void show();`
59
+
*
60
+
* JNI signature: ()V
61
+
*
62
+
*/
63
+
void show() const;
64
+
65
+
/*!
66
+
* Wrapper for the makeText static method
67
+
*
68
+
* Java prototype:
69
+
* `public static android.widget.Toast makeText(android.content.Context,
70
+
* java.lang.CharSequence, int);`
71
+
*
72
+
* JNI signature:
73
+
* (Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast;
74
+
*
75
+
*/
76
+
static Toast makeText(content::Context const &context,
77
+
std::string const &stringParam, int32_t duration);
78
+
79
+
/*!
80
+
* Wrapper for the makeText static method
81
+
*
82
+
* Java prototype:
83
+
* `public static android.widget.Toast makeText(android.content.Context,
84
+
* int, int) throws android.content.res.Resources$NotFoundException;`
85
+
*
86
+
* JNI signature: (Landroid/content/Context;II)Landroid/widget/Toast;
87
+
*
88
+
*/
89
+
static Toast makeText(content::Context &context, int32_t resId,
90
+
int32_t duration);
91
+
92
+
/*!
93
+
* Class metadata
94
+
*/
95
+
struct Meta : public MetaBase {
96
+
impl::StaticFieldId<int32_t> LENGTH_LONG;
97
+
impl::StaticFieldId<int32_t> LENGTH_SHORT;
98
+
jni::method_t show;
99
+
jni::method_t makeText;
100
+
jni::method_t makeText1;
101
+
102
+
/*!
103
+
* Singleton accessor
104
+
*/
105
+
static Meta &data() {
106
+
static Meta instance;
107
+
return instance;
108
+
}
109
+
110
+
private:
111
+
Meta();
112
+
};
113
+
};
114
+
} // namespace android::widget
115
+
} // namespace wrap
116
+
#include "android.widget.impl.h"
+36
src/external/android-jni-wrap/wrap/android.widget.impl.h
+36
src/external/android-jni-wrap/wrap/android.widget.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "android.content.h"
8
+
9
+
namespace wrap {
10
+
namespace android::widget {
11
+
inline int32_t Toast::LENGTH_LONG() {
12
+
return get(Meta::data().LENGTH_LONG, Meta::data().clazz());
13
+
}
14
+
15
+
inline int32_t Toast::LENGTH_SHORT() {
16
+
return get(Meta::data().LENGTH_SHORT, Meta::data().clazz());
17
+
}
18
+
19
+
inline void Toast::show() const {
20
+
assert(!isNull());
21
+
return object().call<void>(Meta::data().show);
22
+
}
23
+
24
+
inline Toast Toast::makeText(content::Context const &context,
25
+
std::string const &stringParam, int32_t duration) {
26
+
return Toast(Meta::data().clazz().call<jni::Object>(
27
+
Meta::data().makeText, context.object(), stringParam, duration));
28
+
}
29
+
30
+
inline Toast Toast::makeText(content::Context &context, int32_t resId,
31
+
int32_t duration) {
32
+
return Toast(Meta::data().clazz().call<jni::Object>(
33
+
Meta::data().makeText1, context.object(), resId, duration));
34
+
}
35
+
} // namespace android::widget
36
+
} // namespace wrap
+15
src/external/android-jni-wrap/wrap/dalvik.system.cpp
+15
src/external/android-jni-wrap/wrap/dalvik.system.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "dalvik.system.h"
6
+
7
+
namespace wrap {
8
+
namespace dalvik::system {
9
+
DexClassLoader::Meta::Meta()
10
+
: MetaBase(DexClassLoader::getTypeName()),
11
+
init(classRef().getMethod("<init>",
12
+
"(Ljava/lang/String;Ljava/lang/String;Ljava/"
13
+
"lang/String;Ljava/lang/ClassLoader;)V")) {}
14
+
} // namespace dalvik::system
15
+
} // namespace wrap
+67
src/external/android-jni-wrap/wrap/dalvik.system.h
+67
src/external/android-jni-wrap/wrap/dalvik.system.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
9
+
namespace wrap {
10
+
namespace dalvik::system {
11
+
class DexClassLoader;
12
+
} // namespace dalvik::system
13
+
14
+
namespace java::lang {
15
+
class ClassLoader;
16
+
} // namespace java::lang
17
+
18
+
} // namespace wrap
19
+
20
+
namespace wrap {
21
+
namespace dalvik::system {
22
+
/*!
23
+
* Wrapper for dalvik.system.DexClassLoader objects.
24
+
*/
25
+
class DexClassLoader : public ObjectWrapperBase {
26
+
public:
27
+
using ObjectWrapperBase::ObjectWrapperBase;
28
+
static constexpr const char *getTypeName() noexcept {
29
+
return "dalvik/system/DexClassLoader";
30
+
}
31
+
32
+
/*!
33
+
* Wrapper for a constructor
34
+
*
35
+
* Java prototype:
36
+
* `public dalvik.system.DexClassLoader(java.lang.String, java.lang.String,
37
+
* java.lang.String, java.lang.ClassLoader);`
38
+
*
39
+
* JNI signature:
40
+
* (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/ClassLoader;)V
41
+
*
42
+
*/
43
+
static DexClassLoader construct(std::string const &searchPath,
44
+
std::string const &nativeSearchPath,
45
+
jni::Object parentClassLoader);
46
+
47
+
/*!
48
+
* Class metadata
49
+
*/
50
+
struct Meta : public MetaBase {
51
+
jni::method_t init;
52
+
53
+
/*!
54
+
* Singleton accessor
55
+
*/
56
+
static Meta &data() {
57
+
static Meta instance;
58
+
return instance;
59
+
}
60
+
61
+
private:
62
+
Meta();
63
+
};
64
+
};
65
+
} // namespace dalvik::system
66
+
} // namespace wrap
67
+
#include "dalvik.system.impl.h"
+21
src/external/android-jni-wrap/wrap/dalvik.system.impl.h
+21
src/external/android-jni-wrap/wrap/dalvik.system.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "java.lang.h"
8
+
#include <string>
9
+
10
+
namespace wrap {
11
+
namespace dalvik::system {
12
+
inline DexClassLoader
13
+
DexClassLoader::construct(std::string const &searchPath,
14
+
std::string const &nativeSearchPath,
15
+
jni::Object parentClassLoader) {
16
+
return DexClassLoader{
17
+
Meta::data().clazz().newInstance(Meta::data().init, searchPath, "",
18
+
nativeSearchPath, parentClassLoader)};
19
+
}
20
+
} // namespace dalvik::system
21
+
} // namespace wrap
+34
src/external/android-jni-wrap/wrap/java.lang.cpp
+34
src/external/android-jni-wrap/wrap/java.lang.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "java.lang.h"
6
+
7
+
namespace wrap {
8
+
namespace java::lang {
9
+
Class::Meta::Meta()
10
+
: MetaBase(Class::getTypeName()),
11
+
forName(classRef().getStaticMethod(
12
+
"forName", "(Ljava/lang/String;)Ljava/lang/Class;")),
13
+
forName1(classRef().getStaticMethod(
14
+
"forName",
15
+
"(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;")),
16
+
forName2(classRef().getStaticMethod(
17
+
"forName",
18
+
"(Ljava/lang/Module;Ljava/lang/String;)Ljava/lang/Class;")),
19
+
getCanonicalName(
20
+
classRef().getMethod("getCanonicalName", "()Ljava/lang/String;")) {}
21
+
ClassLoader::Meta::Meta()
22
+
: MetaBaseDroppable(ClassLoader::getTypeName()),
23
+
loadClass(classRef().getMethod("loadClass",
24
+
"(Ljava/lang/String;)Ljava/lang/Class;")),
25
+
findLibrary(classRef().getMethod(
26
+
"findLibrary", "(Ljava/lang/String;)Ljava/lang/String;")) {
27
+
MetaBaseDroppable::dropClassRef();
28
+
}
29
+
System::Meta::Meta()
30
+
: MetaBase(System::getTypeName()),
31
+
mapLibraryName(classRef().getStaticMethod(
32
+
"mapLibraryName", "(Ljava/lang/String;)Ljava/lang/String;")) {}
33
+
} // namespace java::lang
34
+
} // namespace wrap
+195
src/external/android-jni-wrap/wrap/java.lang.h
+195
src/external/android-jni-wrap/wrap/java.lang.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
9
+
namespace wrap {
10
+
namespace java::lang {
11
+
class Class;
12
+
class ClassLoader;
13
+
} // namespace java::lang
14
+
15
+
} // namespace wrap
16
+
17
+
namespace wrap {
18
+
namespace java::lang {
19
+
/*!
20
+
* Wrapper for java.lang.Class objects.
21
+
*/
22
+
class Class : public ObjectWrapperBase {
23
+
public:
24
+
using ObjectWrapperBase::ObjectWrapperBase;
25
+
static constexpr const char *getTypeName() noexcept {
26
+
return "java/lang/Class";
27
+
}
28
+
29
+
/*!
30
+
* Wrapper for the forName static method
31
+
*
32
+
* Java prototype:
33
+
* `public static java.lang.Class<?> forName(java.lang.String) throws
34
+
* java.lang.ClassNotFoundException;`
35
+
*
36
+
* JNI signature: (Ljava/lang/String;)Ljava/lang/Class;
37
+
*
38
+
*/
39
+
static Class forName(std::string &stringParam);
40
+
41
+
/*!
42
+
* Wrapper for the forName static method
43
+
*
44
+
* Java prototype:
45
+
* `public static java.lang.Class<?> forName(java.lang.String, boolean,
46
+
* java.lang.ClassLoader) throws java.lang.ClassNotFoundException;`
47
+
*
48
+
* JNI signature:
49
+
* (Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;
50
+
*
51
+
*/
52
+
static Class forName(std::string const &name, bool initialize,
53
+
jni::Object classLoader);
54
+
55
+
//! @overload
56
+
static Class forName(jstring name, bool initialize,
57
+
jni::Object classLoader);
58
+
/*!
59
+
* Wrapper for the forName static method
60
+
*
61
+
* Java prototype:
62
+
* `public static java.lang.Class<?> forName(java.lang.Module,
63
+
* java.lang.String);`
64
+
*
65
+
* JNI signature: (Ljava/lang/Module;Ljava/lang/String;)Ljava/lang/Class;
66
+
*
67
+
*/
68
+
static Class forName(jni::Object const &module, std::string const &name);
69
+
70
+
/*!
71
+
* Wrapper for the getCanonicalName method
72
+
*
73
+
* Java prototype:
74
+
* `public java.lang.String getCanonicalName();`
75
+
*
76
+
* JNI signature: ()Ljava/lang/String;
77
+
*
78
+
*/
79
+
std::string getCanonicalName();
80
+
81
+
/*!
82
+
* Class metadata
83
+
*/
84
+
struct Meta : public MetaBase {
85
+
jni::method_t forName;
86
+
jni::method_t forName1;
87
+
jni::method_t forName2;
88
+
jni::method_t getCanonicalName;
89
+
90
+
/*!
91
+
* Singleton accessor
92
+
*/
93
+
static Meta &data() {
94
+
static Meta instance;
95
+
return instance;
96
+
}
97
+
98
+
private:
99
+
Meta();
100
+
};
101
+
};
102
+
/*!
103
+
* Wrapper for java.lang.ClassLoader objects.
104
+
*/
105
+
class ClassLoader : public ObjectWrapperBase {
106
+
public:
107
+
using ObjectWrapperBase::ObjectWrapperBase;
108
+
static constexpr const char *getTypeName() noexcept {
109
+
return "java/lang/ClassLoader";
110
+
}
111
+
112
+
/*!
113
+
* Wrapper for the loadClass method
114
+
*
115
+
* Java prototype:
116
+
* `public java.lang.Class<?> loadClass(java.lang.String) throws
117
+
* java.lang.ClassNotFoundException;`
118
+
*
119
+
* JNI signature: (Ljava/lang/String;)Ljava/lang/Class;
120
+
*
121
+
*/
122
+
Class loadClass(std::string const &name);
123
+
124
+
//! @overload
125
+
Class loadClass(jstring name);
126
+
127
+
/*!
128
+
* Wrapper for the findLibrary method
129
+
*
130
+
* JNI signature: (Ljava/lang/String;)Ljava/lang/String;
131
+
*
132
+
*/
133
+
std::string findLibrary(std::string const &name);
134
+
135
+
/*!
136
+
* Class metadata
137
+
*/
138
+
struct Meta : public MetaBaseDroppable {
139
+
jni::method_t loadClass;
140
+
jni::method_t findLibrary;
141
+
142
+
/*!
143
+
* Singleton accessor
144
+
*/
145
+
static Meta &data() {
146
+
static Meta instance;
147
+
return instance;
148
+
}
149
+
150
+
private:
151
+
Meta();
152
+
};
153
+
};
154
+
/*!
155
+
* Wrapper for java.lang.System objects.
156
+
*/
157
+
class System : public ObjectWrapperBase {
158
+
public:
159
+
using ObjectWrapperBase::ObjectWrapperBase;
160
+
static constexpr const char *getTypeName() noexcept {
161
+
return "java/lang/System";
162
+
}
163
+
164
+
/*!
165
+
* Wrapper for the mapLibraryName static method
166
+
*
167
+
* Java prototype:
168
+
* `public static native java.lang.String mapLibraryName(java.lang.String);`
169
+
*
170
+
* JNI signature: (Ljava/lang/String;)Ljava/lang/String;
171
+
*
172
+
*/
173
+
static std::string mapLibraryName(std::string const &name);
174
+
175
+
/*!
176
+
* Class metadata
177
+
*/
178
+
struct Meta : public MetaBase {
179
+
jni::method_t mapLibraryName;
180
+
181
+
/*!
182
+
* Singleton accessor
183
+
*/
184
+
static Meta &data() {
185
+
static Meta instance;
186
+
return instance;
187
+
}
188
+
189
+
private:
190
+
Meta();
191
+
};
192
+
};
193
+
} // namespace java::lang
194
+
} // namespace wrap
195
+
#include "java.lang.impl.h"
+59
src/external/android-jni-wrap/wrap/java.lang.impl.h
+59
src/external/android-jni-wrap/wrap/java.lang.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include <string>
8
+
9
+
namespace wrap {
10
+
namespace java::lang {
11
+
inline Class Class::forName(std::string &stringParam) {
12
+
return Class(Meta::data().clazz().call<jni::Object>(Meta::data().forName,
13
+
stringParam));
14
+
}
15
+
16
+
inline Class Class::forName(std::string const &name, bool initialize,
17
+
jni::Object classLoader) {
18
+
return Class(Meta::data().clazz().call<jni::Object>(
19
+
Meta::data().forName1, name, initialize, classLoader));
20
+
}
21
+
22
+
inline Class Class::forName(jstring name, bool initialize,
23
+
jni::Object classLoader) {
24
+
return Class{Meta::data().clazz().call<jni::Object>(
25
+
Meta::data().forName, name, initialize, classLoader)};
26
+
}
27
+
28
+
inline Class Class::forName(jni::Object const &module,
29
+
std::string const &name) {
30
+
return Class(Meta::data().clazz().call<jni::Object>(Meta::data().forName2,
31
+
module, name));
32
+
}
33
+
34
+
inline std::string Class::getCanonicalName() {
35
+
assert(!isNull());
36
+
return object().call<std::string>(Meta::data().getCanonicalName);
37
+
}
38
+
39
+
inline Class ClassLoader::loadClass(std::string const &name) {
40
+
assert(!isNull());
41
+
return Class(object().call<jni::Object>(Meta::data().loadClass, name));
42
+
}
43
+
44
+
inline Class ClassLoader::loadClass(jstring name) {
45
+
assert(!isNull());
46
+
return Class{object().call<jni::Object>(Meta::data().loadClass, name)};
47
+
}
48
+
49
+
inline std::string ClassLoader::findLibrary(std::string const &name) {
50
+
assert(!isNull());
51
+
return object().call<std::string>(Meta::data().findLibrary, name);
52
+
}
53
+
54
+
inline std::string System::mapLibraryName(std::string const &name) {
55
+
return Meta::data().clazz().call<std::string>(Meta::data().mapLibraryName,
56
+
name);
57
+
}
58
+
} // namespace java::lang
59
+
} // namespace wrap
+16
src/external/android-jni-wrap/wrap/java.util.cpp
+16
src/external/android-jni-wrap/wrap/java.util.cpp
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#include "java.util.h"
6
+
7
+
namespace wrap {
8
+
namespace java::util {
9
+
List::Meta::Meta()
10
+
: MetaBaseDroppable(List::getTypeName()),
11
+
size(classRef().getMethod("size", "()I")),
12
+
get(classRef().getMethod("get", "(I)Ljava/lang/Object;")) {
13
+
MetaBaseDroppable::dropClassRef();
14
+
}
15
+
} // namespace java::util
16
+
} // namespace wrap
+64
src/external/android-jni-wrap/wrap/java.util.h
+64
src/external/android-jni-wrap/wrap/java.util.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
#include "ObjectWrapperBase.h"
8
+
9
+
namespace wrap {
10
+
namespace java::util {
11
+
/*!
12
+
* Wrapper for java.util.List objects.
13
+
*/
14
+
class List : public ObjectWrapperBase {
15
+
public:
16
+
using ObjectWrapperBase::ObjectWrapperBase;
17
+
static constexpr const char *getTypeName() noexcept {
18
+
return "java/util/List";
19
+
}
20
+
21
+
/*!
22
+
* Wrapper for the size method
23
+
*
24
+
* Java prototype:
25
+
* `public abstract int size();`
26
+
*
27
+
* JNI signature: ()I
28
+
*
29
+
*/
30
+
int32_t size() const;
31
+
32
+
/*!
33
+
* Wrapper for the get method
34
+
*
35
+
* Java prototype:
36
+
* `public abstract E get(int);`
37
+
*
38
+
* JNI signature: (I)Ljava/lang/Object;
39
+
*
40
+
*/
41
+
jni::Object get(int32_t index) const;
42
+
43
+
/*!
44
+
* Class metadata
45
+
*/
46
+
struct Meta : public MetaBaseDroppable {
47
+
jni::method_t size;
48
+
jni::method_t get;
49
+
50
+
/*!
51
+
* Singleton accessor
52
+
*/
53
+
static Meta &data() {
54
+
static Meta instance;
55
+
return instance;
56
+
}
57
+
58
+
private:
59
+
Meta();
60
+
};
61
+
};
62
+
} // namespace java::util
63
+
} // namespace wrap
64
+
#include "java.util.impl.h"
+19
src/external/android-jni-wrap/wrap/java.util.impl.h
+19
src/external/android-jni-wrap/wrap/java.util.impl.h
···
1
+
// Copyright 2020, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
// Author: Ryan Pavlik <ryan.pavlik@collabora.com>
4
+
5
+
#pragma once
6
+
7
+
namespace wrap {
8
+
namespace java::util {
9
+
inline int32_t List::size() const {
10
+
assert(!isNull());
11
+
return object().call<int32_t>(Meta::data().size);
12
+
}
13
+
14
+
inline jni::Object List::get(int32_t index) const {
15
+
assert(!isNull());
16
+
return object().call<jni::Object>(Meta::data().get, index);
17
+
}
18
+
} // namespace java::util
19
+
} // namespace wrap