From 879ab7eeb82edbf992cf2501463de4f27c6d4169 Mon Sep 17 00:00:00 2001 From: rikner Date: Thu, 13 Jul 2017 16:59:11 +0200 Subject: [PATCH 01/84] wrap with swift (SwiftPM 3.1) --- CMakeLists.txt | 45 - JNIArrays.swift.gyb | 106 -- JNIFields.swift.gyb | 56 - JNIMethods.swift.gyb | 120 -- LICENSE | 201 --- Package.swift | 13 + Sources/CJNI/include/jni.h | 1175 +++++++++++++++++ Sources/CJNI/include/module.modulemap | 5 + Sources/CJNI/jni.c | 4 + JNI.swift => Sources/JNISwift/JNI.swift | 38 +- .../JNISwift/JNIClassManipulation.swift | 18 +- .../JNISwift/JNIExceptions.swift | 14 +- .../JNISwift/JNIObjects.swift | 17 +- .../JNISwift/JNIRefs.swift | 26 +- .../JNISwift/JNIStrings.swift | 24 +- .../JNISwift/SwiftJNI.swift | 89 +- module.map.in | 17 - 17 files changed, 1320 insertions(+), 648 deletions(-) delete mode 100644 CMakeLists.txt delete mode 100644 JNIArrays.swift.gyb delete mode 100644 JNIFields.swift.gyb delete mode 100644 JNIMethods.swift.gyb delete mode 100644 LICENSE create mode 100644 Package.swift create mode 100644 Sources/CJNI/include/jni.h create mode 100644 Sources/CJNI/include/module.modulemap create mode 100644 Sources/CJNI/jni.c rename JNI.swift => Sources/JNISwift/JNI.swift (56%) rename JNIClassManipulation.swift => Sources/JNISwift/JNIClassManipulation.swift (60%) rename JNIExceptions.swift => Sources/JNISwift/JNIExceptions.swift (61%) rename JNIObjects.swift => Sources/JNISwift/JNIObjects.swift (53%) rename JNIRefs.swift => Sources/JNISwift/JNIRefs.swift (61%) rename JNIStrings.swift => Sources/JNISwift/JNIStrings.swift (63%) rename SwiftJNI.swift => Sources/JNISwift/SwiftJNI.swift (70%) delete mode 100644 module.map.in diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index 0edff8e..0000000 --- a/CMakeLists.txt +++ /dev/null @@ -1,45 +0,0 @@ -set(sources - JNI.swift - JNIArrays.swift.gyb - JNIClassManipulation.swift - JNIExceptions.swift - JNIFields.swift.gyb - JNIMethods.swift.gyb - JNIObjects.swift - JNIRefs.swift - JNIStrings.swift - SwiftJNI.swift -) - -set(output_dir "${SWIFTLIB_DIR}/jni") - -# Set correct paths to glibc headers -set(JNI_INCLUDE_PATH "${SWIFT_SDK_ANDROID_PATH}/usr/include") -if (NOT EXISTS "${JNI_INCLUDE_PATH}/jni.h") - message(FATAL_ERROR "JNI header was not found at ${JNI_INCLUDE_PATH}.") -endif() - -# Generate module.map -configure_file(module.map.in "${CMAKE_CURRENT_BINARY_DIR}/module.map" @ONLY) - -add_custom_command_target(unused_var - COMMAND - "${CMAKE_COMMAND}" "-E" "make_directory" "${output_dir}" - COMMAND - "${CMAKE_COMMAND}" "-E" "copy_if_different" - "${CMAKE_CURRENT_BINARY_DIR}/module.map" - "${output_dir}/module.map" - CUSTOM_TARGET_NAME "copy_jni_module" - OUTPUT "${output_dir}/module.map" "${output_dir}" - DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/module.map" - COMMENT "Copying JNI module to ${output_dir}") - -swift_install_in_component(stdlib - FILES "${output_dir}/module.map" - DESTINATION "lib/swift/jni") - -add_swift_library(swiftJNI IS_SDK_OVERLAY - ${sources} - FILE_DEPENDS copy_jni_module "${output_dir}" - TARGET_SDKS ANDROID - INSTALL_IN_COMPONENT stdlib-experimental) diff --git a/JNIArrays.swift.gyb b/JNIArrays.swift.gyb deleted file mode 100644 index 2f114d7..0000000 --- a/JNIArrays.swift.gyb +++ /dev/null @@ -1,106 +0,0 @@ -import CJNI - -%{ - jTypes = [ - - # You can only set / get one jobject array element at a time - # So we handle that case manually, and automate the rest... - # ('Object', 'jobject'), - - ('Boolean', 'jboolean'), - ('Byte', 'jbyte'), - ('Char', 'jchar'), - ('Short', 'jshort'), - ('Int', 'jint'), - ('Long', 'jlong'), - ('Float', 'jfloat'), - ('Double', 'jdouble') - ] -}% - -public extension JNI { - - public func GetArrayLength(array: jarray) -> jsize { - let env = self._env - return env.memory.memory.GetArrayLength(env, array) - } - -% # You can only set / get one object element at a time - public func NewObjectArray(length: jsize, _ elementClass: jclass, _ initialElement: jobject) -> jobjectArray { - let env = self._env - return env.memory.memory.NewObjectArray(env, length, elementClass, initialElement) - } - - public func GetObjectArrayElement(array: jobjectArray, _ index: jsize) -> jobject { - let env = self._env - return env.memory.memory.GetObjectArrayElement(env, array, index) - } - - public func SetObjectArrayElement(array: jobjectArray, _ index: jsize, _ value: jobject) { - let env = self._env - env.memory.memory.SetObjectArrayElement(env, array, index, value) - } - - -% # But we can automate the rest -% for (TypeName, type) in jTypes: - - public func New${TypeName}Array(length: jsize) -> ${type}Array { - let env = self._env - return env.memory.memory.New${TypeName}Array(env, length) - } - - public func Get${TypeName}ArrayElements(array: ${type}Array, _ isCopy: UnsafeMutablePointer) -> UnsafeMutablePointer<${type}> { - let env = self._env - return env.memory.memory.Get${TypeName}ArrayElements(env, array, isCopy) - } - - public func Release${TypeName}ArrayElements(array: ${type}Array, _ elems: UnsafeMutablePointer<${type}>, _ mode: jint) { - let env = self._env - env.memory.memory.Release${TypeName}ArrayElements(env, array, elems, mode) - } - - public func Get${TypeName}ArrayRegion(array: ${type}Array, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer<${type}>) { - let env = self._env - env.memory.memory.Get${TypeName}ArrayRegion(env, array, start, len, buf) - } - - public func Set${TypeName}ArrayRegion(array: ${type}Array, _ start: jsize, _ len: jsize, _ buf: UnsafePointer<${type}>) { - let env = self._env - env.memory.memory.Set${TypeName}ArrayRegion(env, array, start, len, buf) - } - -% end -} - -/// High performance JNI extensions -public extension JNI { - public func GetPrimitiveArrayCritical(array: jarray, _ isCopy: UnsafeMutablePointer) -> UnsafeMutablePointer { - let env = self._env - return env.memory.memory.GetPrimitiveArrayCritical(env, array, isCopy) - } - - public func ReleasePrimitiveArrayCritical(array: jarray, _ carray: UnsafeMutablePointer, _ mode: jint) { - let env = self._env - env.memory.memory.ReleasePrimitiveArrayCritical(env, array, carray, mode) - } - - public func NewDirectByteBuffer(address: UnsafeMutablePointer, _ capacity: jlong) -> jobject { - let env = self._env - return env.memory.memory.NewDirectByteBuffer(env, address, capacity) - } - - public func GetDirectBufferAddress(buf: jobject) -> UnsafeMutablePointer { - let env = self._env - return env.memory.memory.GetDirectBufferAddress(env, buf) - } - - public func GetDirectBufferCapacity(buf: jobject) -> jlong { - let env = self._env - return env.memory.memory.GetDirectBufferCapacity(env, buf) - } -} - -// ${'Local Variables'}: -// eval: (read-only-mode 1) -// End: diff --git a/JNIFields.swift.gyb b/JNIFields.swift.gyb deleted file mode 100644 index 1c8ea4a..0000000 --- a/JNIFields.swift.gyb +++ /dev/null @@ -1,56 +0,0 @@ -// Hash maps and fields - -import CJNI - -%{ - jTypes = [ - ('Object', 'jobject'), - ('Boolean', 'jboolean'), - ('Byte', 'jbyte'), - ('Char', 'jchar'), - ('Short', 'jshort'), - ('Int', 'jint'), - ('Long', 'jlong'), - ('Float', 'jfloat'), - ('Double', 'jdouble') - ] -}% - -public extension JNI { - - public func GetFieldID(targetClass: jclass, _ name: String, _ sig: String) -> jfieldID { - let env = self._env - return env.memory.memory.GetFieldID(env, targetClass, name, sig) - } - - public func GetStaticFieldID(targetClass: jclass, _ name: String, _ sig: String) -> jfieldID { - let env = self._env - return env.memory.memory.GetStaticFieldID(env, targetClass, name, sig) - } - -% for (TypeName, Type) in jTypes: - public func Get${TypeName}Field(obj: jobject, _ fieldID: jfieldID) -> ${Type} { - let env = self._env - return env.memory.memory.Get${TypeName}Field(env, obj, fieldID) - } - - public func Set${TypeName}Field(obj: jobject, _ fieldID: jfieldID, _ value: ${Type}) { - let env = self._env - env.memory.memory.Set${TypeName}Field(env, obj, fieldID, value) - } - - public func GetStatic${TypeName}Field(targetClass: jclass, _ fieldID: jfieldID) -> ${Type} { - let env = self._env - return env.memory.memory.GetStatic${TypeName}Field(env, targetClass, fieldID) - } - - public func SetStatic${TypeName}Field(targetClass: jclass, _ fieldID: jfieldID, _ value: ${Type}) { - let env = self._env - env.memory.memory.SetStatic${TypeName}Field(env, targetClass, fieldID, value) - } -% end -} - -// ${'Local Variables'}: -// eval: (read-only-mode 1) -// End: diff --git a/JNIMethods.swift.gyb b/JNIMethods.swift.gyb deleted file mode 100644 index 31a4b3f..0000000 --- a/JNIMethods.swift.gyb +++ /dev/null @@ -1,120 +0,0 @@ -//===--- JNIMethods.swift.gyb ---------------------------------*- swift -*-===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See http://swift.org/LICENSE.txt for license information -// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -import CJNI - -%{ - jTypes = [ - ('Void', 'Void'), # returning Void is also valid in swift - ('Object', 'jobject'), - ('Boolean', 'jboolean'), - ('Byte', 'jbyte'), - ('Char', 'jchar'), - ('Short', 'jshort'), - ('Int', 'jint'), - ('Long', 'jlong'), - ('Float', 'jfloat'), - ('Double', 'jdouble') - ] -}% - - -public extension JNI { - -% # Standard Java method calls - - public func GetMethodID(targetClass: jclass, methodName name: String, methodSignature sig: String) -> jmethodID? { - let env = self._env - let result = env.memory.memory.GetMethodID(env, targetClass, name, sig) - return (result == nil) ? .None : result - } - -%for (TypeName, type) in jTypes: - - public func Call${TypeName}Method(obj: jobject, _ methodID: jmethodID, _ args: jvalue...) -> ${type} { - return Call${TypeName}MethodA(obj, _ methodID: methodID, _ args: args) - } - - @available(*, unavailable, message="CVaListPointers are not supported, use `Call${TypeName}Method` or `Call${TypeName}MethodA` instead") - public func Call${TypeName}MethodV(obj: jobject, _ methodID: jmethodID, _ args: CVaListPointer) -> ${type} { - // let env = self._env - // return env.memory.memory.Call${TypeName}MethodV(env, obj, methodID, args) - return ${type}() - } - - public func Call${TypeName}MethodA(obj: jobject, _ methodID: jmethodID, _ args: [jvalue]) -> ${type} { - let env = self._env - var mutableArgs = args - return env.memory.memory.Call${TypeName}MethodA(env, obj, methodID, &mutableArgs) - } - -%end #standard methods - - - -% # Nonvirtual Java method calls -%for (TypeName, type) in jTypes: - - public func CallNonvirtual${TypeName}Method(obj: jobject, _ targetClass: jclass, _ methodID: jmethodID, _ args: jvalue...) -> ${type} { - return self.CallNonvirtual${TypeName}MethodA(obj, _ targetClass: targetClass, _ methodID: methodID, _ args: args) - } - - @available(*, unavailable, message="CVaListPointers are not supported, use `CallNonvirtual${TypeName}Method` or `CallNonvirtual${TypeName}MethodA` instead") - public func CallNonvirtual${TypeName}MethodV(obj: jobject, _ targetClass: jclass, _ methodID: jmethodID, _ args: CVaListPointer) -> ${type} { - // let env = self._env - // return env.memory.memory.CallNonvirtual${TypeName}MethodV(env, obj, methodID, args) - return ${type}() - } - - public func CallNonvirtual${TypeName}MethodA(obj: jobject, _ targetClass: jclass, _ methodID: jmethodID, _ args: [jvalue]) -> ${type} { - let env = self._env - var mutableArgs = args - return env.memory.memory.CallNonvirtual${TypeName}MethodA(env, obj, targetClass, methodID, &mutableArgs) - } - -%end #nonvirtual methods - - - -%# Static Java method calls - - public func GetStaticMethodID(targetClass: jclass, _ name: String, _ sig: String) -> jmethodID { - let env = self._env - return env.memory.memory.GetStaticMethodID(env, targetClass, name, sig) - } - -%for (TypeName, type) in jTypes: - - public func CallStatic${TypeName}Method(targetClass: jclass, _ methodID: jmethodID, _ args: jvalue...) -> ${type} { - return CallStatic${TypeName}MethodA(targetClass, _ methodID: methodID, _ args: args) - } - - @available(*, unavailable, message="CVaListPointers are not supported, use `CallStatic${TypeName}Method` or `CallStatic${TypeName}MethodA` instead") - public func CallStatic${TypeName}MethodV(targetClass: jclass, _ methodID: jmethodID, _ args: CVaListPointer) -> ${type} { - // let env = self._env - // return env.memory.memory.CallStatic${TypeName}MethodV(env, class, methodID, args) - return ${type}() - } - - public func CallStatic${TypeName}MethodA(targetClass: jclass, _ methodID: jmethodID, _ args: [jvalue]) -> ${type} { - let env = self._env - var mutableArgs = args - return env.memory.memory.CallStatic${TypeName}MethodA(env, targetClass, methodID, &mutableArgs) - } - -%end #static methods -} - -// ${'Local Variables'}: -// eval: (read-only-mode 1) -// End: - diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 8dada3e..0000000 --- a/LICENSE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/Package.swift b/Package.swift new file mode 100644 index 0000000..a0a0192 --- /dev/null +++ b/Package.swift @@ -0,0 +1,13 @@ +// swift-tools-version:3.1 + +import PackageDescription + +let package = Package( + name: "JNISwift", + targets: [ + Target(name: "JNISwift", dependencies: ["CJNI"]), + Target(name: "CJNI", dependencies: []) + ] +) + +products.append(Product(name: "JNISwift", type: .Library(.Dynamic), modules: ["JNISwift"])) diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h new file mode 100644 index 0000000..fc92515 --- /dev/null +++ b/Sources/CJNI/include/jni.h @@ -0,0 +1,1175 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * JNI specification, as defined by Sun: + * http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/jniTOC.html + * + * Everything here is expected to be VM-neutral. + */ + +#ifndef JNI_H_ +#define JNI_H_ + +#include +#include + +/* + * Primitive types that match up with Java equivalents. + */ +#ifdef HAVE_INTTYPES_H +# include /* C99 */ +typedef uint8_t jboolean; /* unsigned 8 bits */ +typedef int8_t jbyte; /* signed 8 bits */ +typedef uint16_t jchar; /* unsigned 16 bits */ +typedef int16_t jshort; /* signed 16 bits */ +typedef int32_t jint; /* signed 32 bits */ +typedef int64_t jlong; /* signed 64 bits */ +typedef float jfloat; /* 32-bit IEEE 754 */ +typedef double jdouble; /* 64-bit IEEE 754 */ +#else +typedef unsigned char jboolean; /* unsigned 8 bits */ +typedef signed char jbyte; /* signed 8 bits */ +typedef unsigned short jchar; /* unsigned 16 bits */ +typedef short jshort; /* signed 16 bits */ +typedef int jint; /* signed 32 bits */ +typedef long long jlong; /* signed 64 bits */ +typedef float jfloat; /* 32-bit IEEE 754 */ +typedef double jdouble; /* 64-bit IEEE 754 */ +#endif + +/* "cardinal indices and sizes" */ +typedef jint jsize; + +#ifdef __cplusplus +/* + * Reference types, in C++ + */ +class _jobject {}; +class _jclass : public _jobject {}; +class _jstring : public _jobject {}; +class _jarray : public _jobject {}; +class _jobjectArray : public _jarray {}; +class _jbooleanArray : public _jarray {}; +class _jbyteArray : public _jarray {}; +class _jcharArray : public _jarray {}; +class _jshortArray : public _jarray {}; +class _jintArray : public _jarray {}; +class _jlongArray : public _jarray {}; +class _jfloatArray : public _jarray {}; +class _jdoubleArray : public _jarray {}; +class _jthrowable : public _jobject {}; + +typedef _jobject* jobject; +typedef _jclass* jclass; +typedef _jstring* jstring; +typedef _jarray* jarray; +typedef _jobjectArray* jobjectArray; +typedef _jbooleanArray* jbooleanArray; +typedef _jbyteArray* jbyteArray; +typedef _jcharArray* jcharArray; +typedef _jshortArray* jshortArray; +typedef _jintArray* jintArray; +typedef _jlongArray* jlongArray; +typedef _jfloatArray* jfloatArray; +typedef _jdoubleArray* jdoubleArray; +typedef _jthrowable* jthrowable; +typedef _jobject* jweak; + + +#else /* not __cplusplus */ + +/* + * Reference types, in C. + */ +typedef void* jobject; +typedef jobject jclass; +typedef jobject jstring; +typedef jobject jarray; +typedef jarray jobjectArray; +typedef jarray jbooleanArray; +typedef jarray jbyteArray; +typedef jarray jcharArray; +typedef jarray jshortArray; +typedef jarray jintArray; +typedef jarray jlongArray; +typedef jarray jfloatArray; +typedef jarray jdoubleArray; +typedef jobject jthrowable; +typedef jobject jweak; + +#endif /* not __cplusplus */ + +struct _jfieldID; /* opaque structure */ +typedef struct _jfieldID* jfieldID; /* field IDs */ + +struct _jmethodID; /* opaque structure */ +typedef struct _jmethodID* jmethodID; /* method IDs */ + +struct JNIInvokeInterface; + +typedef union jvalue { + jboolean z; + jbyte b; + jchar c; + jshort s; + jint i; + jlong j; + jfloat f; + jdouble d; + jobject l; +} jvalue; + +typedef enum jobjectRefType { + JNIInvalidRefType = 0, + JNILocalRefType = 1, + JNIGlobalRefType = 2, + JNIWeakGlobalRefType = 3 +} jobjectRefType; + +typedef struct { + const char* name; + const char* signature; + void* fnPtr; +} JNINativeMethod; + +struct _JNIEnv; +struct _JavaVM; +typedef const struct JNINativeInterface* C_JNIEnv; + +#if defined(__cplusplus) +typedef _JNIEnv JNIEnv; +typedef _JavaVM JavaVM; +#else +typedef const struct JNINativeInterface* JNIEnv; +typedef const struct JNIInvokeInterface* JavaVM; +#endif + +/* + * Table of interface function pointers. + */ +struct JNINativeInterface { + void* reserved0; + void* reserved1; + void* reserved2; + void* reserved3; + + jint (*GetVersion)(JNIEnv *); + + jclass (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*, + jsize); + jclass (*FindClass)(JNIEnv*, const char*); + + jmethodID (*FromReflectedMethod)(JNIEnv*, jobject); + jfieldID (*FromReflectedField)(JNIEnv*, jobject); + /* spec doesn't show jboolean parameter */ + jobject (*ToReflectedMethod)(JNIEnv*, jclass, jmethodID, jboolean); + + jclass (*GetSuperclass)(JNIEnv*, jclass); + jboolean (*IsAssignableFrom)(JNIEnv*, jclass, jclass); + + /* spec doesn't show jboolean parameter */ + jobject (*ToReflectedField)(JNIEnv*, jclass, jfieldID, jboolean); + + jint (*Throw)(JNIEnv*, jthrowable); + jint (*ThrowNew)(JNIEnv *, jclass, const char *); + jthrowable (*ExceptionOccurred)(JNIEnv*); + void (*ExceptionDescribe)(JNIEnv*); + void (*ExceptionClear)(JNIEnv*); + void (*FatalError)(JNIEnv*, const char*); + + jint (*PushLocalFrame)(JNIEnv*, jint); + jobject (*PopLocalFrame)(JNIEnv*, jobject); + + jobject (*NewGlobalRef)(JNIEnv*, jobject); + void (*DeleteGlobalRef)(JNIEnv*, jobject); + void (*DeleteLocalRef)(JNIEnv*, jobject); + jboolean (*IsSameObject)(JNIEnv*, jobject, jobject); + + jobject (*NewLocalRef)(JNIEnv*, jobject); + jint (*EnsureLocalCapacity)(JNIEnv*, jint); + + jobject (*AllocObject)(JNIEnv*, jclass); + jobject (*NewObject)(JNIEnv*, jclass, jmethodID, ...); + jobject (*NewObjectV)(JNIEnv*, jclass, jmethodID, va_list); + jobject (*NewObjectA)(JNIEnv*, jclass, jmethodID, jvalue*); + + jclass (*GetObjectClass)(JNIEnv*, jobject); + jboolean (*IsInstanceOf)(JNIEnv*, jobject, jclass); + jmethodID (*GetMethodID)(JNIEnv*, jclass, const char*, const char*); + + jobject (*CallObjectMethod)(JNIEnv*, jobject, jmethodID, ...); + jobject (*CallObjectMethodV)(JNIEnv*, jobject, jmethodID, va_list); + jobject (*CallObjectMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + jboolean (*CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...); + jboolean (*CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list); + jboolean (*CallBooleanMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + jbyte (*CallByteMethod)(JNIEnv*, jobject, jmethodID, ...); + jbyte (*CallByteMethodV)(JNIEnv*, jobject, jmethodID, va_list); + jbyte (*CallByteMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + jchar (*CallCharMethod)(JNIEnv*, jobject, jmethodID, ...); + jchar (*CallCharMethodV)(JNIEnv*, jobject, jmethodID, va_list); + jchar (*CallCharMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + jshort (*CallShortMethod)(JNIEnv*, jobject, jmethodID, ...); + jshort (*CallShortMethodV)(JNIEnv*, jobject, jmethodID, va_list); + jshort (*CallShortMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + jint (*CallIntMethod)(JNIEnv*, jobject, jmethodID, ...); + jint (*CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list); + jint (*CallIntMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + jlong (*CallLongMethod)(JNIEnv*, jobject, jmethodID, ...); + jlong (*CallLongMethodV)(JNIEnv*, jobject, jmethodID, va_list); + jlong (*CallLongMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + jfloat (*CallFloatMethod)(JNIEnv*, jobject, jmethodID, ...); + jfloat (*CallFloatMethodV)(JNIEnv*, jobject, jmethodID, va_list); + jfloat (*CallFloatMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + jdouble (*CallDoubleMethod)(JNIEnv*, jobject, jmethodID, ...); + jdouble (*CallDoubleMethodV)(JNIEnv*, jobject, jmethodID, va_list); + jdouble (*CallDoubleMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + void (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...); + void (*CallVoidMethodV)(JNIEnv*, jobject, jmethodID, va_list); + void (*CallVoidMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); + + jobject (*CallNonvirtualObjectMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + jobject (*CallNonvirtualObjectMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + jobject (*CallNonvirtualObjectMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + jboolean (*CallNonvirtualBooleanMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + jboolean (*CallNonvirtualBooleanMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + jboolean (*CallNonvirtualBooleanMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + jbyte (*CallNonvirtualByteMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + jbyte (*CallNonvirtualByteMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + jbyte (*CallNonvirtualByteMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + jchar (*CallNonvirtualCharMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + jchar (*CallNonvirtualCharMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + jchar (*CallNonvirtualCharMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + jshort (*CallNonvirtualShortMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + jshort (*CallNonvirtualShortMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + jshort (*CallNonvirtualShortMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + jint (*CallNonvirtualIntMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + jint (*CallNonvirtualIntMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + jint (*CallNonvirtualIntMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + jlong (*CallNonvirtualLongMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + jlong (*CallNonvirtualLongMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + jlong (*CallNonvirtualLongMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + jfloat (*CallNonvirtualFloatMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + jfloat (*CallNonvirtualFloatMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + jfloat (*CallNonvirtualFloatMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + jdouble (*CallNonvirtualDoubleMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + jdouble (*CallNonvirtualDoubleMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + jdouble (*CallNonvirtualDoubleMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + void (*CallNonvirtualVoidMethod)(JNIEnv*, jobject, jclass, + jmethodID, ...); + void (*CallNonvirtualVoidMethodV)(JNIEnv*, jobject, jclass, + jmethodID, va_list); + void (*CallNonvirtualVoidMethodA)(JNIEnv*, jobject, jclass, + jmethodID, jvalue*); + + jfieldID (*GetFieldID)(JNIEnv*, jclass, const char*, const char*); + + jobject (*GetObjectField)(JNIEnv*, jobject, jfieldID); + jboolean (*GetBooleanField)(JNIEnv*, jobject, jfieldID); + jbyte (*GetByteField)(JNIEnv*, jobject, jfieldID); + jchar (*GetCharField)(JNIEnv*, jobject, jfieldID); + jshort (*GetShortField)(JNIEnv*, jobject, jfieldID); + jint (*GetIntField)(JNIEnv*, jobject, jfieldID); + jlong (*GetLongField)(JNIEnv*, jobject, jfieldID); + jfloat (*GetFloatField)(JNIEnv*, jobject, jfieldID); + jdouble (*GetDoubleField)(JNIEnv*, jobject, jfieldID); + + void (*SetObjectField)(JNIEnv*, jobject, jfieldID, jobject); + void (*SetBooleanField)(JNIEnv*, jobject, jfieldID, jboolean); + void (*SetByteField)(JNIEnv*, jobject, jfieldID, jbyte); + void (*SetCharField)(JNIEnv*, jobject, jfieldID, jchar); + void (*SetShortField)(JNIEnv*, jobject, jfieldID, jshort); + void (*SetIntField)(JNIEnv*, jobject, jfieldID, jint); + void (*SetLongField)(JNIEnv*, jobject, jfieldID, jlong); + void (*SetFloatField)(JNIEnv*, jobject, jfieldID, jfloat); + void (*SetDoubleField)(JNIEnv*, jobject, jfieldID, jdouble); + + jmethodID (*GetStaticMethodID)(JNIEnv*, jclass, const char*, const char*); + + jobject (*CallStaticObjectMethod)(JNIEnv*, jclass, jmethodID, ...); + jobject (*CallStaticObjectMethodV)(JNIEnv*, jclass, jmethodID, va_list); + jobject (*CallStaticObjectMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); + jboolean (*CallStaticBooleanMethod)(JNIEnv*, jclass, jmethodID, ...); + jboolean (*CallStaticBooleanMethodV)(JNIEnv*, jclass, jmethodID, + va_list); + jboolean (*CallStaticBooleanMethodA)(JNIEnv*, jclass, jmethodID, + jvalue*); + jbyte (*CallStaticByteMethod)(JNIEnv*, jclass, jmethodID, ...); + jbyte (*CallStaticByteMethodV)(JNIEnv*, jclass, jmethodID, va_list); + jbyte (*CallStaticByteMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); + jchar (*CallStaticCharMethod)(JNIEnv*, jclass, jmethodID, ...); + jchar (*CallStaticCharMethodV)(JNIEnv*, jclass, jmethodID, va_list); + jchar (*CallStaticCharMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); + jshort (*CallStaticShortMethod)(JNIEnv*, jclass, jmethodID, ...); + jshort (*CallStaticShortMethodV)(JNIEnv*, jclass, jmethodID, va_list); + jshort (*CallStaticShortMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); + jint (*CallStaticIntMethod)(JNIEnv*, jclass, jmethodID, ...); + jint (*CallStaticIntMethodV)(JNIEnv*, jclass, jmethodID, va_list); + jint (*CallStaticIntMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); + jlong (*CallStaticLongMethod)(JNIEnv*, jclass, jmethodID, ...); + jlong (*CallStaticLongMethodV)(JNIEnv*, jclass, jmethodID, va_list); + jlong (*CallStaticLongMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); + jfloat (*CallStaticFloatMethod)(JNIEnv*, jclass, jmethodID, ...); + jfloat (*CallStaticFloatMethodV)(JNIEnv*, jclass, jmethodID, va_list); + jfloat (*CallStaticFloatMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); + jdouble (*CallStaticDoubleMethod)(JNIEnv*, jclass, jmethodID, ...); + jdouble (*CallStaticDoubleMethodV)(JNIEnv*, jclass, jmethodID, va_list); + jdouble (*CallStaticDoubleMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); + void (*CallStaticVoidMethod)(JNIEnv*, jclass, jmethodID, ...); + void (*CallStaticVoidMethodV)(JNIEnv*, jclass, jmethodID, va_list); + void (*CallStaticVoidMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); + + jfieldID (*GetStaticFieldID)(JNIEnv*, jclass, const char*, + const char*); + + jobject (*GetStaticObjectField)(JNIEnv*, jclass, jfieldID); + jboolean (*GetStaticBooleanField)(JNIEnv*, jclass, jfieldID); + jbyte (*GetStaticByteField)(JNIEnv*, jclass, jfieldID); + jchar (*GetStaticCharField)(JNIEnv*, jclass, jfieldID); + jshort (*GetStaticShortField)(JNIEnv*, jclass, jfieldID); + jint (*GetStaticIntField)(JNIEnv*, jclass, jfieldID); + jlong (*GetStaticLongField)(JNIEnv*, jclass, jfieldID); + jfloat (*GetStaticFloatField)(JNIEnv*, jclass, jfieldID); + jdouble (*GetStaticDoubleField)(JNIEnv*, jclass, jfieldID); + + void (*SetStaticObjectField)(JNIEnv*, jclass, jfieldID, jobject); + void (*SetStaticBooleanField)(JNIEnv*, jclass, jfieldID, jboolean); + void (*SetStaticByteField)(JNIEnv*, jclass, jfieldID, jbyte); + void (*SetStaticCharField)(JNIEnv*, jclass, jfieldID, jchar); + void (*SetStaticShortField)(JNIEnv*, jclass, jfieldID, jshort); + void (*SetStaticIntField)(JNIEnv*, jclass, jfieldID, jint); + void (*SetStaticLongField)(JNIEnv*, jclass, jfieldID, jlong); + void (*SetStaticFloatField)(JNIEnv*, jclass, jfieldID, jfloat); + void (*SetStaticDoubleField)(JNIEnv*, jclass, jfieldID, jdouble); + + jstring (*NewString)(JNIEnv*, const jchar*, jsize); + jsize (*GetStringLength)(JNIEnv*, jstring); + const jchar* (*GetStringChars)(JNIEnv*, jstring, jboolean*); + void (*ReleaseStringChars)(JNIEnv*, jstring, const jchar*); + jstring (*NewStringUTF)(JNIEnv*, const char*); + jsize (*GetStringUTFLength)(JNIEnv*, jstring); + /* JNI spec says this returns const jbyte*, but that's inconsistent */ + const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*); + void (*ReleaseStringUTFChars)(JNIEnv*, jstring, const char*); + jsize (*GetArrayLength)(JNIEnv*, jarray); + jobjectArray (*NewObjectArray)(JNIEnv*, jsize, jclass, jobject); + jobject (*GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize); + void (*SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject); + + jbooleanArray (*NewBooleanArray)(JNIEnv*, jsize); + jbyteArray (*NewByteArray)(JNIEnv*, jsize); + jcharArray (*NewCharArray)(JNIEnv*, jsize); + jshortArray (*NewShortArray)(JNIEnv*, jsize); + jintArray (*NewIntArray)(JNIEnv*, jsize); + jlongArray (*NewLongArray)(JNIEnv*, jsize); + jfloatArray (*NewFloatArray)(JNIEnv*, jsize); + jdoubleArray (*NewDoubleArray)(JNIEnv*, jsize); + + jboolean* (*GetBooleanArrayElements)(JNIEnv*, jbooleanArray, jboolean*); + jbyte* (*GetByteArrayElements)(JNIEnv*, jbyteArray, jboolean*); + jchar* (*GetCharArrayElements)(JNIEnv*, jcharArray, jboolean*); + jshort* (*GetShortArrayElements)(JNIEnv*, jshortArray, jboolean*); + jint* (*GetIntArrayElements)(JNIEnv*, jintArray, jboolean*); + jlong* (*GetLongArrayElements)(JNIEnv*, jlongArray, jboolean*); + jfloat* (*GetFloatArrayElements)(JNIEnv*, jfloatArray, jboolean*); + jdouble* (*GetDoubleArrayElements)(JNIEnv*, jdoubleArray, jboolean*); + + void (*ReleaseBooleanArrayElements)(JNIEnv*, jbooleanArray, + jboolean*, jint); + void (*ReleaseByteArrayElements)(JNIEnv*, jbyteArray, + jbyte*, jint); + void (*ReleaseCharArrayElements)(JNIEnv*, jcharArray, + jchar*, jint); + void (*ReleaseShortArrayElements)(JNIEnv*, jshortArray, + jshort*, jint); + void (*ReleaseIntArrayElements)(JNIEnv*, jintArray, + jint*, jint); + void (*ReleaseLongArrayElements)(JNIEnv*, jlongArray, + jlong*, jint); + void (*ReleaseFloatArrayElements)(JNIEnv*, jfloatArray, + jfloat*, jint); + void (*ReleaseDoubleArrayElements)(JNIEnv*, jdoubleArray, + jdouble*, jint); + + void (*GetBooleanArrayRegion)(JNIEnv*, jbooleanArray, + jsize, jsize, jboolean*); + void (*GetByteArrayRegion)(JNIEnv*, jbyteArray, + jsize, jsize, jbyte*); + void (*GetCharArrayRegion)(JNIEnv*, jcharArray, + jsize, jsize, jchar*); + void (*GetShortArrayRegion)(JNIEnv*, jshortArray, + jsize, jsize, jshort*); + void (*GetIntArrayRegion)(JNIEnv*, jintArray, + jsize, jsize, jint*); + void (*GetLongArrayRegion)(JNIEnv*, jlongArray, + jsize, jsize, jlong*); + void (*GetFloatArrayRegion)(JNIEnv*, jfloatArray, + jsize, jsize, jfloat*); + void (*GetDoubleArrayRegion)(JNIEnv*, jdoubleArray, + jsize, jsize, jdouble*); + + /* spec shows these without const; some jni.h do, some don't */ + void (*SetBooleanArrayRegion)(JNIEnv*, jbooleanArray, + jsize, jsize, const jboolean*); + void (*SetByteArrayRegion)(JNIEnv*, jbyteArray, + jsize, jsize, const jbyte*); + void (*SetCharArrayRegion)(JNIEnv*, jcharArray, + jsize, jsize, const jchar*); + void (*SetShortArrayRegion)(JNIEnv*, jshortArray, + jsize, jsize, const jshort*); + void (*SetIntArrayRegion)(JNIEnv*, jintArray, + jsize, jsize, const jint*); + void (*SetLongArrayRegion)(JNIEnv*, jlongArray, + jsize, jsize, const jlong*); + void (*SetFloatArrayRegion)(JNIEnv*, jfloatArray, + jsize, jsize, const jfloat*); + void (*SetDoubleArrayRegion)(JNIEnv*, jdoubleArray, + jsize, jsize, const jdouble*); + + jint (*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*, + jint); + jint (*UnregisterNatives)(JNIEnv*, jclass); + jint (*MonitorEnter)(JNIEnv*, jobject); + jint (*MonitorExit)(JNIEnv*, jobject); + jint (*GetJavaVM)(JNIEnv*, JavaVM**); + + void (*GetStringRegion)(JNIEnv*, jstring, jsize, jsize, jchar*); + void (*GetStringUTFRegion)(JNIEnv*, jstring, jsize, jsize, char*); + + void* (*GetPrimitiveArrayCritical)(JNIEnv*, jarray, jboolean*); + void (*ReleasePrimitiveArrayCritical)(JNIEnv*, jarray, void*, jint); + + const jchar* (*GetStringCritical)(JNIEnv*, jstring, jboolean*); + void (*ReleaseStringCritical)(JNIEnv*, jstring, const jchar*); + + jweak (*NewWeakGlobalRef)(JNIEnv*, jobject); + void (*DeleteWeakGlobalRef)(JNIEnv*, jweak); + + jboolean (*ExceptionCheck)(JNIEnv*); + + jobject (*NewDirectByteBuffer)(JNIEnv*, void*, jlong); + void* (*GetDirectBufferAddress)(JNIEnv*, jobject); + jlong (*GetDirectBufferCapacity)(JNIEnv*, jobject); + + /* added in JNI 1.6 */ + jobjectRefType (*GetObjectRefType)(JNIEnv*, jobject); +}; + +/* + * C++ object wrapper. + * + * This is usually overlaid on a C struct whose first element is a + * JNINativeInterface*. We rely somewhat on compiler behavior. + */ +struct _JNIEnv { + /* do not rename this; it does not seem to be entirely opaque */ + const struct JNINativeInterface* functions; + +#if defined(__cplusplus) + + jint GetVersion() + { return functions->GetVersion(this); } + + jclass DefineClass(const char *name, jobject loader, const jbyte* buf, + jsize bufLen) + { return functions->DefineClass(this, name, loader, buf, bufLen); } + + jclass FindClass(const char* name) + { return functions->FindClass(this, name); } + + jmethodID FromReflectedMethod(jobject method) + { return functions->FromReflectedMethod(this, method); } + + jfieldID FromReflectedField(jobject field) + { return functions->FromReflectedField(this, field); } + + jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) + { return functions->ToReflectedMethod(this, cls, methodID, isStatic); } + + jclass GetSuperclass(jclass clazz) + { return functions->GetSuperclass(this, clazz); } + + jboolean IsAssignableFrom(jclass clazz1, jclass clazz2) + { return functions->IsAssignableFrom(this, clazz1, clazz2); } + + jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) + { return functions->ToReflectedField(this, cls, fieldID, isStatic); } + + jint Throw(jthrowable obj) + { return functions->Throw(this, obj); } + + jint ThrowNew(jclass clazz, const char* message) + { return functions->ThrowNew(this, clazz, message); } + + jthrowable ExceptionOccurred() + { return functions->ExceptionOccurred(this); } + + void ExceptionDescribe() + { functions->ExceptionDescribe(this); } + + void ExceptionClear() + { functions->ExceptionClear(this); } + + void FatalError(const char* msg) + { functions->FatalError(this, msg); } + + jint PushLocalFrame(jint capacity) + { return functions->PushLocalFrame(this, capacity); } + + jobject PopLocalFrame(jobject result) + { return functions->PopLocalFrame(this, result); } + + jobject NewGlobalRef(jobject obj) + { return functions->NewGlobalRef(this, obj); } + + void DeleteGlobalRef(jobject globalRef) + { functions->DeleteGlobalRef(this, globalRef); } + + void DeleteLocalRef(jobject localRef) + { functions->DeleteLocalRef(this, localRef); } + + jboolean IsSameObject(jobject ref1, jobject ref2) + { return functions->IsSameObject(this, ref1, ref2); } + + jobject NewLocalRef(jobject ref) + { return functions->NewLocalRef(this, ref); } + + jint EnsureLocalCapacity(jint capacity) + { return functions->EnsureLocalCapacity(this, capacity); } + + jobject AllocObject(jclass clazz) + { return functions->AllocObject(this, clazz); } + + jobject NewObject(jclass clazz, jmethodID methodID, ...) + { + va_list args; + va_start(args, methodID); + jobject result = functions->NewObjectV(this, clazz, methodID, args); + va_end(args); + return result; + } + + jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args) + { return functions->NewObjectV(this, clazz, methodID, args); } + + jobject NewObjectA(jclass clazz, jmethodID methodID, jvalue* args) + { return functions->NewObjectA(this, clazz, methodID, args); } + + jclass GetObjectClass(jobject obj) + { return functions->GetObjectClass(this, obj); } + + jboolean IsInstanceOf(jobject obj, jclass clazz) + { return functions->IsInstanceOf(this, obj, clazz); } + + jmethodID GetMethodID(jclass clazz, const char* name, const char* sig) + { return functions->GetMethodID(this, clazz, name, sig); } + +#define CALL_TYPE_METHOD(_jtype, _jname) \ + \ + _jtype Call##_jname##Method(jobject obj, jmethodID methodID, ...) \ + { \ + _jtype result; \ + va_list args; \ + va_start(args, methodID); \ + result = functions->Call##_jname##MethodV(this, obj, methodID, \ + args); \ + va_end(args); \ + return result; \ + } +#define CALL_TYPE_METHODV(_jtype, _jname) \ + \ + _jtype Call##_jname##MethodV(jobject obj, jmethodID methodID, \ + va_list args) \ + { return functions->Call##_jname##MethodV(this, obj, methodID, args); } +#define CALL_TYPE_METHODA(_jtype, _jname) \ + \ + _jtype Call##_jname##MethodA(jobject obj, jmethodID methodID, \ + jvalue* args) \ + { return functions->Call##_jname##MethodA(this, obj, methodID, args); } + +#define CALL_TYPE(_jtype, _jname) \ + CALL_TYPE_METHOD(_jtype, _jname) \ + CALL_TYPE_METHODV(_jtype, _jname) \ + CALL_TYPE_METHODA(_jtype, _jname) + + CALL_TYPE(jobject, Object) + CALL_TYPE(jboolean, Boolean) + CALL_TYPE(jbyte, Byte) + CALL_TYPE(jchar, Char) + CALL_TYPE(jshort, Short) + CALL_TYPE(jint, Int) + CALL_TYPE(jlong, Long) + CALL_TYPE(jfloat, Float) + CALL_TYPE(jdouble, Double) + + void CallVoidMethod(jobject obj, jmethodID methodID, ...) + { + va_list args; + va_start(args, methodID); + functions->CallVoidMethodV(this, obj, methodID, args); + va_end(args); + } + void CallVoidMethodV(jobject obj, jmethodID methodID, va_list args) + { functions->CallVoidMethodV(this, obj, methodID, args); } + void CallVoidMethodA(jobject obj, jmethodID methodID, jvalue* args) + { functions->CallVoidMethodA(this, obj, methodID, args); } + +#define CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ + \ + _jtype CallNonvirtual##_jname##Method(jobject obj, jclass clazz, \ + jmethodID methodID, ...) \ + { \ + _jtype result; \ + va_list args; \ + va_start(args, methodID); \ + result = functions->CallNonvirtual##_jname##MethodV(this, obj, \ + clazz, methodID, args); \ + va_end(args); \ + return result; \ + } +#define CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ + \ + _jtype CallNonvirtual##_jname##MethodV(jobject obj, jclass clazz, \ + jmethodID methodID, va_list args) \ + { return functions->CallNonvirtual##_jname##MethodV(this, obj, clazz, \ + methodID, args); } +#define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) \ + \ + _jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz, \ + jmethodID methodID, jvalue* args) \ + { return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz, \ + methodID, args); } + +#define CALL_NONVIRT_TYPE(_jtype, _jname) \ + CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ + CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ + CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) + + CALL_NONVIRT_TYPE(jobject, Object) + CALL_NONVIRT_TYPE(jboolean, Boolean) + CALL_NONVIRT_TYPE(jbyte, Byte) + CALL_NONVIRT_TYPE(jchar, Char) + CALL_NONVIRT_TYPE(jshort, Short) + CALL_NONVIRT_TYPE(jint, Int) + CALL_NONVIRT_TYPE(jlong, Long) + CALL_NONVIRT_TYPE(jfloat, Float) + CALL_NONVIRT_TYPE(jdouble, Double) + + void CallNonvirtualVoidMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) + { + va_list args; + va_start(args, methodID); + functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); + va_end(args); + } + void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) + { functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); } + void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue* args) + { functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); } + + jfieldID GetFieldID(jclass clazz, const char* name, const char* sig) + { return functions->GetFieldID(this, clazz, name, sig); } + + jobject GetObjectField(jobject obj, jfieldID fieldID) + { return functions->GetObjectField(this, obj, fieldID); } + jboolean GetBooleanField(jobject obj, jfieldID fieldID) + { return functions->GetBooleanField(this, obj, fieldID); } + jbyte GetByteField(jobject obj, jfieldID fieldID) + { return functions->GetByteField(this, obj, fieldID); } + jchar GetCharField(jobject obj, jfieldID fieldID) + { return functions->GetCharField(this, obj, fieldID); } + jshort GetShortField(jobject obj, jfieldID fieldID) + { return functions->GetShortField(this, obj, fieldID); } + jint GetIntField(jobject obj, jfieldID fieldID) + { return functions->GetIntField(this, obj, fieldID); } + jlong GetLongField(jobject obj, jfieldID fieldID) + { return functions->GetLongField(this, obj, fieldID); } + + jfloat GetFloatField(jobject obj, jfieldID fieldID) + { return functions->GetFloatField(this, obj, fieldID); } + + jdouble GetDoubleField(jobject obj, jfieldID fieldID) + { return functions->GetDoubleField(this, obj, fieldID); } + + void SetObjectField(jobject obj, jfieldID fieldID, jobject value) + { functions->SetObjectField(this, obj, fieldID, value); } + void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value) + { functions->SetBooleanField(this, obj, fieldID, value); } + void SetByteField(jobject obj, jfieldID fieldID, jbyte value) + { functions->SetByteField(this, obj, fieldID, value); } + void SetCharField(jobject obj, jfieldID fieldID, jchar value) + { functions->SetCharField(this, obj, fieldID, value); } + void SetShortField(jobject obj, jfieldID fieldID, jshort value) + { functions->SetShortField(this, obj, fieldID, value); } + void SetIntField(jobject obj, jfieldID fieldID, jint value) + { functions->SetIntField(this, obj, fieldID, value); } + void SetLongField(jobject obj, jfieldID fieldID, jlong value) + { functions->SetLongField(this, obj, fieldID, value); } + + void SetFloatField(jobject obj, jfieldID fieldID, jfloat value) + { functions->SetFloatField(this, obj, fieldID, value); } + + void SetDoubleField(jobject obj, jfieldID fieldID, jdouble value) + { functions->SetDoubleField(this, obj, fieldID, value); } + + jmethodID GetStaticMethodID(jclass clazz, const char* name, const char* sig) + { return functions->GetStaticMethodID(this, clazz, name, sig); } + +#define CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ + \ + _jtype CallStatic##_jname##Method(jclass clazz, jmethodID methodID, \ + ...) \ + { \ + _jtype result; \ + va_list args; \ + va_start(args, methodID); \ + result = functions->CallStatic##_jname##MethodV(this, clazz, \ + methodID, args); \ + va_end(args); \ + return result; \ + } +#define CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ + \ + _jtype CallStatic##_jname##MethodV(jclass clazz, jmethodID methodID, \ + va_list args) \ + { return functions->CallStatic##_jname##MethodV(this, clazz, methodID, \ + args); } +#define CALL_STATIC_TYPE_METHODA(_jtype, _jname) \ + \ + _jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID, \ + jvalue* args) \ + { return functions->CallStatic##_jname##MethodA(this, clazz, methodID, \ + args); } + +#define CALL_STATIC_TYPE(_jtype, _jname) \ + CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ + CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ + CALL_STATIC_TYPE_METHODA(_jtype, _jname) + + CALL_STATIC_TYPE(jobject, Object) + CALL_STATIC_TYPE(jboolean, Boolean) + CALL_STATIC_TYPE(jbyte, Byte) + CALL_STATIC_TYPE(jchar, Char) + CALL_STATIC_TYPE(jshort, Short) + CALL_STATIC_TYPE(jint, Int) + CALL_STATIC_TYPE(jlong, Long) + CALL_STATIC_TYPE(jfloat, Float) + CALL_STATIC_TYPE(jdouble, Double) + + void CallStaticVoidMethod(jclass clazz, jmethodID methodID, ...) + { + va_list args; + va_start(args, methodID); + functions->CallStaticVoidMethodV(this, clazz, methodID, args); + va_end(args); + } + void CallStaticVoidMethodV(jclass clazz, jmethodID methodID, va_list args) + { functions->CallStaticVoidMethodV(this, clazz, methodID, args); } + void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, jvalue* args) + { functions->CallStaticVoidMethodA(this, clazz, methodID, args); } + + jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig) + { return functions->GetStaticFieldID(this, clazz, name, sig); } + + jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) + { return functions->GetStaticObjectField(this, clazz, fieldID); } + jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) + { return functions->GetStaticBooleanField(this, clazz, fieldID); } + jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) + { return functions->GetStaticByteField(this, clazz, fieldID); } + jchar GetStaticCharField(jclass clazz, jfieldID fieldID) + { return functions->GetStaticCharField(this, clazz, fieldID); } + jshort GetStaticShortField(jclass clazz, jfieldID fieldID) + { return functions->GetStaticShortField(this, clazz, fieldID); } + jint GetStaticIntField(jclass clazz, jfieldID fieldID) + { return functions->GetStaticIntField(this, clazz, fieldID); } + jlong GetStaticLongField(jclass clazz, jfieldID fieldID) + { return functions->GetStaticLongField(this, clazz, fieldID); } + + jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) + { return functions->GetStaticFloatField(this, clazz, fieldID); } + + jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) + { return functions->GetStaticDoubleField(this, clazz, fieldID); } + + void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value) + { functions->SetStaticObjectField(this, clazz, fieldID, value); } + void SetStaticBooleanField(jclass clazz, jfieldID fieldID, jboolean value) + { functions->SetStaticBooleanField(this, clazz, fieldID, value); } + void SetStaticByteField(jclass clazz, jfieldID fieldID, jbyte value) + { functions->SetStaticByteField(this, clazz, fieldID, value); } + void SetStaticCharField(jclass clazz, jfieldID fieldID, jchar value) + { functions->SetStaticCharField(this, clazz, fieldID, value); } + void SetStaticShortField(jclass clazz, jfieldID fieldID, jshort value) + { functions->SetStaticShortField(this, clazz, fieldID, value); } + void SetStaticIntField(jclass clazz, jfieldID fieldID, jint value) + { functions->SetStaticIntField(this, clazz, fieldID, value); } + void SetStaticLongField(jclass clazz, jfieldID fieldID, jlong value) + { functions->SetStaticLongField(this, clazz, fieldID, value); } + + void SetStaticFloatField(jclass clazz, jfieldID fieldID, jfloat value) + { functions->SetStaticFloatField(this, clazz, fieldID, value); } + + void SetStaticDoubleField(jclass clazz, jfieldID fieldID, jdouble value) + { functions->SetStaticDoubleField(this, clazz, fieldID, value); } + + jstring NewString(const jchar* unicodeChars, jsize len) + { return functions->NewString(this, unicodeChars, len); } + + jsize GetStringLength(jstring string) + { return functions->GetStringLength(this, string); } + + const jchar* GetStringChars(jstring string, jboolean* isCopy) + { return functions->GetStringChars(this, string, isCopy); } + + void ReleaseStringChars(jstring string, const jchar* chars) + { functions->ReleaseStringChars(this, string, chars); } + + jstring NewStringUTF(const char* bytes) + { return functions->NewStringUTF(this, bytes); } + + jsize GetStringUTFLength(jstring string) + { return functions->GetStringUTFLength(this, string); } + + const char* GetStringUTFChars(jstring string, jboolean* isCopy) + { return functions->GetStringUTFChars(this, string, isCopy); } + + void ReleaseStringUTFChars(jstring string, const char* utf) + { functions->ReleaseStringUTFChars(this, string, utf); } + + jsize GetArrayLength(jarray array) + { return functions->GetArrayLength(this, array); } + + jobjectArray NewObjectArray(jsize length, jclass elementClass, + jobject initialElement) + { return functions->NewObjectArray(this, length, elementClass, + initialElement); } + + jobject GetObjectArrayElement(jobjectArray array, jsize index) + { return functions->GetObjectArrayElement(this, array, index); } + + void SetObjectArrayElement(jobjectArray array, jsize index, jobject value) + { functions->SetObjectArrayElement(this, array, index, value); } + + jbooleanArray NewBooleanArray(jsize length) + { return functions->NewBooleanArray(this, length); } + jbyteArray NewByteArray(jsize length) + { return functions->NewByteArray(this, length); } + jcharArray NewCharArray(jsize length) + { return functions->NewCharArray(this, length); } + jshortArray NewShortArray(jsize length) + { return functions->NewShortArray(this, length); } + jintArray NewIntArray(jsize length) + { return functions->NewIntArray(this, length); } + jlongArray NewLongArray(jsize length) + { return functions->NewLongArray(this, length); } + jfloatArray NewFloatArray(jsize length) + { return functions->NewFloatArray(this, length); } + jdoubleArray NewDoubleArray(jsize length) + { return functions->NewDoubleArray(this, length); } + + jboolean* GetBooleanArrayElements(jbooleanArray array, jboolean* isCopy) + { return functions->GetBooleanArrayElements(this, array, isCopy); } + jbyte* GetByteArrayElements(jbyteArray array, jboolean* isCopy) + { return functions->GetByteArrayElements(this, array, isCopy); } + jchar* GetCharArrayElements(jcharArray array, jboolean* isCopy) + { return functions->GetCharArrayElements(this, array, isCopy); } + jshort* GetShortArrayElements(jshortArray array, jboolean* isCopy) + { return functions->GetShortArrayElements(this, array, isCopy); } + jint* GetIntArrayElements(jintArray array, jboolean* isCopy) + { return functions->GetIntArrayElements(this, array, isCopy); } + jlong* GetLongArrayElements(jlongArray array, jboolean* isCopy) + { return functions->GetLongArrayElements(this, array, isCopy); } + jfloat* GetFloatArrayElements(jfloatArray array, jboolean* isCopy) + { return functions->GetFloatArrayElements(this, array, isCopy); } + jdouble* GetDoubleArrayElements(jdoubleArray array, jboolean* isCopy) + { return functions->GetDoubleArrayElements(this, array, isCopy); } + + void ReleaseBooleanArrayElements(jbooleanArray array, jboolean* elems, + jint mode) + { functions->ReleaseBooleanArrayElements(this, array, elems, mode); } + void ReleaseByteArrayElements(jbyteArray array, jbyte* elems, + jint mode) + { functions->ReleaseByteArrayElements(this, array, elems, mode); } + void ReleaseCharArrayElements(jcharArray array, jchar* elems, + jint mode) + { functions->ReleaseCharArrayElements(this, array, elems, mode); } + void ReleaseShortArrayElements(jshortArray array, jshort* elems, + jint mode) + { functions->ReleaseShortArrayElements(this, array, elems, mode); } + void ReleaseIntArrayElements(jintArray array, jint* elems, + jint mode) + { functions->ReleaseIntArrayElements(this, array, elems, mode); } + void ReleaseLongArrayElements(jlongArray array, jlong* elems, + jint mode) + { functions->ReleaseLongArrayElements(this, array, elems, mode); } + void ReleaseFloatArrayElements(jfloatArray array, jfloat* elems, + jint mode) + { functions->ReleaseFloatArrayElements(this, array, elems, mode); } + void ReleaseDoubleArrayElements(jdoubleArray array, jdouble* elems, + jint mode) + { functions->ReleaseDoubleArrayElements(this, array, elems, mode); } + + void GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, + jboolean* buf) + { functions->GetBooleanArrayRegion(this, array, start, len, buf); } + void GetByteArrayRegion(jbyteArray array, jsize start, jsize len, + jbyte* buf) + { functions->GetByteArrayRegion(this, array, start, len, buf); } + void GetCharArrayRegion(jcharArray array, jsize start, jsize len, + jchar* buf) + { functions->GetCharArrayRegion(this, array, start, len, buf); } + void GetShortArrayRegion(jshortArray array, jsize start, jsize len, + jshort* buf) + { functions->GetShortArrayRegion(this, array, start, len, buf); } + void GetIntArrayRegion(jintArray array, jsize start, jsize len, + jint* buf) + { functions->GetIntArrayRegion(this, array, start, len, buf); } + void GetLongArrayRegion(jlongArray array, jsize start, jsize len, + jlong* buf) + { functions->GetLongArrayRegion(this, array, start, len, buf); } + void GetFloatArrayRegion(jfloatArray array, jsize start, jsize len, + jfloat* buf) + { functions->GetFloatArrayRegion(this, array, start, len, buf); } + void GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, + jdouble* buf) + { functions->GetDoubleArrayRegion(this, array, start, len, buf); } + + void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, + const jboolean* buf) + { functions->SetBooleanArrayRegion(this, array, start, len, buf); } + void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, + const jbyte* buf) + { functions->SetByteArrayRegion(this, array, start, len, buf); } + void SetCharArrayRegion(jcharArray array, jsize start, jsize len, + const jchar* buf) + { functions->SetCharArrayRegion(this, array, start, len, buf); } + void SetShortArrayRegion(jshortArray array, jsize start, jsize len, + const jshort* buf) + { functions->SetShortArrayRegion(this, array, start, len, buf); } + void SetIntArrayRegion(jintArray array, jsize start, jsize len, + const jint* buf) + { functions->SetIntArrayRegion(this, array, start, len, buf); } + void SetLongArrayRegion(jlongArray array, jsize start, jsize len, + const jlong* buf) + { functions->SetLongArrayRegion(this, array, start, len, buf); } + void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, + const jfloat* buf) + { functions->SetFloatArrayRegion(this, array, start, len, buf); } + void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, + const jdouble* buf) + { functions->SetDoubleArrayRegion(this, array, start, len, buf); } + + jint RegisterNatives(jclass clazz, const JNINativeMethod* methods, + jint nMethods) + { return functions->RegisterNatives(this, clazz, methods, nMethods); } + + jint UnregisterNatives(jclass clazz) + { return functions->UnregisterNatives(this, clazz); } + + jint MonitorEnter(jobject obj) + { return functions->MonitorEnter(this, obj); } + + jint MonitorExit(jobject obj) + { return functions->MonitorExit(this, obj); } + + jint GetJavaVM(JavaVM** vm) + { return functions->GetJavaVM(this, vm); } + + void GetStringRegion(jstring str, jsize start, jsize len, jchar* buf) + { functions->GetStringRegion(this, str, start, len, buf); } + + void GetStringUTFRegion(jstring str, jsize start, jsize len, char* buf) + { return functions->GetStringUTFRegion(this, str, start, len, buf); } + + void* GetPrimitiveArrayCritical(jarray array, jboolean* isCopy) + { return functions->GetPrimitiveArrayCritical(this, array, isCopy); } + + void ReleasePrimitiveArrayCritical(jarray array, void* carray, jint mode) + { functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); } + + const jchar* GetStringCritical(jstring string, jboolean* isCopy) + { return functions->GetStringCritical(this, string, isCopy); } + + void ReleaseStringCritical(jstring string, const jchar* carray) + { functions->ReleaseStringCritical(this, string, carray); } + + jweak NewWeakGlobalRef(jobject obj) + { return functions->NewWeakGlobalRef(this, obj); } + + void DeleteWeakGlobalRef(jweak obj) + { functions->DeleteWeakGlobalRef(this, obj); } + + jboolean ExceptionCheck() + { return functions->ExceptionCheck(this); } + + jobject NewDirectByteBuffer(void* address, jlong capacity) + { return functions->NewDirectByteBuffer(this, address, capacity); } + + void* GetDirectBufferAddress(jobject buf) + { return functions->GetDirectBufferAddress(this, buf); } + + jlong GetDirectBufferCapacity(jobject buf) + { return functions->GetDirectBufferCapacity(this, buf); } + + /* added in JNI 1.6 */ + jobjectRefType GetObjectRefType(jobject obj) + { return functions->GetObjectRefType(this, obj); } +#endif /*__cplusplus*/ +}; + + +/* + * JNI invocation interface. + */ +struct JNIInvokeInterface { + void* reserved0; + void* reserved1; + void* reserved2; + + jint (*DestroyJavaVM)(JavaVM*); + jint (*AttachCurrentThread)(JavaVM*, JNIEnv**, void*); + jint (*DetachCurrentThread)(JavaVM*); + jint (*GetEnv)(JavaVM*, void**, jint); + jint (*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*); +}; + +/* + * C++ version. + */ +struct _JavaVM { + const struct JNIInvokeInterface* functions; + +#if defined(__cplusplus) + jint DestroyJavaVM() + { return functions->DestroyJavaVM(this); } + jint AttachCurrentThread(JNIEnv** p_env, void* thr_args) + { return functions->AttachCurrentThread(this, p_env, thr_args); } + jint DetachCurrentThread() + { return functions->DetachCurrentThread(this); } + jint GetEnv(void** env, jint version) + { return functions->GetEnv(this, env, version); } + jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args) + { return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); } +#endif /*__cplusplus*/ +}; + +struct JavaVMAttachArgs { + jint version; /* must be >= JNI_VERSION_1_2 */ + const char* name; /* NULL or name of thread as modified UTF-8 str */ + jobject group; /* global ref of a ThreadGroup object, or NULL */ +}; +typedef struct JavaVMAttachArgs JavaVMAttachArgs; + +/* + * JNI 1.2+ initialization. (As of 1.6, the pre-1.2 structures are no + * longer supported.) + */ +typedef struct JavaVMOption { + const char* optionString; + void* extraInfo; +} JavaVMOption; + +typedef struct JavaVMInitArgs { + jint version; /* use JNI_VERSION_1_2 or later */ + + jint nOptions; + JavaVMOption* options; + jboolean ignoreUnrecognized; +} JavaVMInitArgs; + +#ifdef __cplusplus +extern "C" { +#endif +/* + * VM initialization functions. + * + * Note these are the only symbols exported for JNI by the VM. + */ +#if 0 /* In practice, these are not exported by the NDK so don't declare them */ +jint JNI_GetDefaultJavaVMInitArgs(void*); +jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void*); +jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize*); +#endif + +#define JNIIMPORT +#define JNIEXPORT __attribute__ ((visibility ("default"))) +#define JNICALL + +/* + * Prototypes for functions exported by loadable shared libs. These are + * called by JNI, not provided by JNI. + */ +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved); +JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved); + +#ifdef __cplusplus +} +#endif + + +/* + * Manifest constants. + */ +#define JNI_FALSE 0 +#define JNI_TRUE 1 + +#define JNI_VERSION_1_1 0x00010001 +#define JNI_VERSION_1_2 0x00010002 +#define JNI_VERSION_1_4 0x00010004 +#define JNI_VERSION_1_6 0x00010006 + +#define JNI_OK (0) /* no error */ +#define JNI_ERR (-1) /* generic error */ +#define JNI_EDETACHED (-2) /* thread detached from the VM */ +#define JNI_EVERSION (-3) /* JNI version error */ + +#define JNI_COMMIT 1 /* copy content, do not free buffer */ +#define JNI_ABORT 2 /* free buffer w/o copying back */ + +#endif /* JNI_H_ */ + diff --git a/Sources/CJNI/include/module.modulemap b/Sources/CJNI/include/module.modulemap new file mode 100644 index 0000000..d24ac59 --- /dev/null +++ b/Sources/CJNI/include/module.modulemap @@ -0,0 +1,5 @@ +module CJNI { + header "jni.h" + export * +} + diff --git a/Sources/CJNI/jni.c b/Sources/CJNI/jni.c new file mode 100644 index 0000000..82acb49 --- /dev/null +++ b/Sources/CJNI/jni.c @@ -0,0 +1,4 @@ +// Stub method to avoid no debug symbol warning from compiler. +int swiftpm_cjni_anchor() { + return 0; +} diff --git a/JNI.swift b/Sources/JNISwift/JNI.swift similarity index 56% rename from JNI.swift rename to Sources/JNISwift/JNI.swift index 6f0a045..adb3f5b 100644 --- a/JNI.swift +++ b/Sources/JNISwift/JNI.swift @@ -1,35 +1,35 @@ -@_exported import CJNI // Clang module +import CJNI public class JNI { /// Our reference to the Java Virtual Machine, to be set on init - let _jvm: UnsafeMutablePointer + let _jvm: UnsafeMutablePointer /// Ensure the _env pointer we have is always attached to the JVM - var _env: UnsafeMutablePointer { - let jvm = _jvm.memory.memory + var _env: UnsafeMutablePointer { + let jvm = _jvm.pointee?.pointee // The type `JNIEnv` is defined as a non-mutable pointer, // so use this mutable _tmpPointer as an intermediate: - var _tmpPointer = UnsafeMutablePointer() - let threadStatus = jvm.GetEnv(_jvm, &_tmpPointer, jint(JNI_VERSION_1_6)) - var _env = UnsafeMutablePointer(_tmpPointer) + var _tmpPointer: UnsafeMutableRawPointer? + let threadStatus = jvm?.GetEnv(_jvm, &_tmpPointer, jint(JNI_VERSION_1_6)) + var _env = _tmpPointer?.bindMemory(to: JNIEnv?.self, capacity: 1) - switch threadStatus { + switch threadStatus?.bigEndian ?? 0 { case JNI_OK: break // if we're already attached, do nothing case JNI_EDETACHED: // We weren't attached to the Java UI thread - jvm.AttachCurrentThread(_jvm, &_env, nil) + _ = jvm?.AttachCurrentThread(_jvm, &_env, nil) case JNI_EVERSION: fatalError("This version of JNI is not supported") default: break } - return _env + return _env! } // Normally we init the jni global ourselves in JNI_OnLoad - public init?(jvm: UnsafeMutablePointer) { - if jvm == nil { return nil } + public init?(jvm: UnsafeMutablePointer) { + if jvm.pointee == nil { return nil } self._jvm = jvm } } @@ -37,31 +37,31 @@ public class JNI { public extension JNI { public func GetVersion() -> jint { let env = self._env - return env.memory.memory.GetVersion(env) + return env.pointee!.pointee.GetVersion(env) } - public func GetJavaVM(vm: UnsafeMutablePointer>) -> jint { + public func GetJavaVM(vm: UnsafeMutablePointer?>) -> jint { let env = self._env - return env.memory.memory.GetJavaVM(env, vm) + return env.pointee!.pointee.GetJavaVM(env, vm) } public func RegisterNatives(targetClass: jclass, _ methods: UnsafePointer, _ nMethods: jint) -> jint { let env = self._env - return env.memory.memory.RegisterNatives(env, targetClass, methods, nMethods) + return env.pointee!.pointee.RegisterNatives(env, targetClass, methods, nMethods) } public func UnregisterNatives(targetClass: jclass) -> jint { let env = self._env - return env.memory.memory.UnregisterNatives(env, targetClass) + return env.pointee!.pointee.UnregisterNatives(env, targetClass) } public func MonitorEnter(obj: jobject) -> jint { let env = self._env - return env.memory.memory.MonitorEnter(env, obj) + return env.pointee!.pointee.MonitorEnter(env, obj) } public func MonitorExit(obj: jobject) -> jint { let env = self._env - return env.memory.memory.MonitorExit(env, obj) + return env.pointee!.pointee.MonitorExit(env, obj) } } diff --git a/JNIClassManipulation.swift b/Sources/JNISwift/JNIClassManipulation.swift similarity index 60% rename from JNIClassManipulation.swift rename to Sources/JNISwift/JNIClassManipulation.swift index fee6c5a..177c4d6 100644 --- a/JNIClassManipulation.swift +++ b/Sources/JNISwift/JNIClassManipulation.swift @@ -3,41 +3,41 @@ import CJNI public extension JNI { public func DefineClass(name: String, _ loader: jobject, _ buffer: UnsafePointer, _ bufferLength: jsize) -> jclass { let env = self._env - return env.memory.memory.DefineClass(env, name, loader, buffer, bufferLength) + return env.pointee!.pointee.DefineClass(env, name, loader, buffer, bufferLength)! } public func FindClass(name: String) -> jclass { let env = self._env - return env.memory.memory.FindClass(env, name) + return env.pointee!.pointee.FindClass(env, name)! } public func FromReflectedMethod(method: jobject) -> jmethodID { let env = self._env - return env.memory.memory.FromReflectedMethod(env, method) + return env.pointee!.pointee.FromReflectedMethod(env, method)! } public func FromReflectedField(field: jobject) -> jfieldID { let env = self._env - return env.memory.memory.FromReflectedField(env, field) + return env.pointee!.pointee.FromReflectedField(env, field)! } public func ToReflectedMethod(targetClass: jclass, _ methodID: jmethodID, _ isStatic: jboolean) -> jobject { let env = self._env - return env.memory.memory.ToReflectedMethod(env, cls, methodID, isStatic) + return env.pointee!.pointee.ToReflectedMethod(env, targetClass, methodID, isStatic)! } public func GetSuperclass(targetClass: jclass) -> jclass { let env = self._env - return env.memory.memory.GetSuperclass(env, targetClass) + return env.pointee!.pointee.GetSuperclass(env, targetClass)! } public func IsAssignableFrom(classA: jclass, _ classB: jclass) -> jboolean { let env = self._env - return env.memory.memory.IsAssignableFrom(env, classA, classB) + return env.pointee!.pointee.IsAssignableFrom(env, classA, classB) } public func ToReflectedField(targetClass: jclass, _ fieldID: jfieldID, _ isStatic: jboolean) -> jobject { let env = self._env - return env.memory.memory.ToReflectedField(env, cls, fieldID, isStatic) + return env.pointee!.pointee.ToReflectedField(env, targetClass, fieldID, isStatic)! } -} \ No newline at end of file +} diff --git a/JNIExceptions.swift b/Sources/JNISwift/JNIExceptions.swift similarity index 61% rename from JNIExceptions.swift rename to Sources/JNISwift/JNIExceptions.swift index 6d3884b..972627e 100644 --- a/JNIExceptions.swift +++ b/Sources/JNISwift/JNIExceptions.swift @@ -3,36 +3,36 @@ import CJNI public extension JNI { public func ExceptionCheck() -> jboolean { let env = self._env - return env.memory.memory.ExceptionCheck(env) + return env.pointee!.pointee.ExceptionCheck(env) } public func ExceptionDescribe() { let env = self._env - env.memory.memory.ExceptionDescribe(env) + env.pointee!.pointee.ExceptionDescribe(env) } public func ExceptionClear() { let env = self._env - env.memory.memory.ExceptionClear(env) + env.pointee!.pointee.ExceptionClear(env) } public func ExceptionOccurred() -> jthrowable { let env = self._env - return env.memory.memory.ExceptionOccurred(env) + return env.pointee!.pointee.ExceptionOccurred(env)! } public func Throw(obj: jthrowable) -> jint { let env = self._env - return env.memory.memory.Throw(env, obj) + return env.pointee!.pointee.Throw(env, obj) } public func ThrowNew(targetClass: jclass, _ message: String) -> jint { let env = self._env - return env.memory.memory.ThrowNew(env, targetClass, message) + return env.pointee!.pointee.ThrowNew(env, targetClass, message) } public func FatalError(msg: String) { let env = self._env - env.memory.memory.FatalError(env, msg) + env.pointee!.pointee.FatalError(env, msg) } } diff --git a/JNIObjects.swift b/Sources/JNISwift/JNIObjects.swift similarity index 53% rename from JNIObjects.swift rename to Sources/JNISwift/JNIObjects.swift index 7cc8979..f9e1095 100644 --- a/JNIObjects.swift +++ b/Sources/JNISwift/JNIObjects.swift @@ -4,30 +4,29 @@ public extension JNI { public func AllocObject(targetClass: jclass) -> jobject { let env = self._env - return env.memory.memory.AllocObject(env, targetClass) + return env.pointee!.pointee.AllocObject(env, targetClass)! } public func NewObject(targetClass: jclass, _ methodID: jmethodID, _ args: jvalue...) -> jobject { - return self.NewObjectA(targetClass, _ methodID: methodID, _ args: args) + return self.NewObjectA(targetClass: targetClass, methodID, args) } - @available(*, unavailable, message="CVaListPointer unavailable, use NewObject or NewObjectA") + @available(*, unavailable, message:"CVaListPointer unavailable, use NewObject or NewObjectA") public func NewObjectV(targetClass: jclass, _ methodID: jmethodID, _ args: CVaListPointer) -> jobject { - // let env = self._env - // return env.memory.memory.NewObjectV(env, targetClass, methodID, args) - return jobject() + let env = self._env + return env.pointee!.pointee.NewObjectV(env, targetClass, methodID, args)! } public func NewObjectA(targetClass: jclass, _ methodID: jmethodID, _ args: [jvalue]) -> jobject { let env = self._env var mutableArgs = args - return env.memory.memory.NewObjectA(env, targetClass, methodID, &mutableArgs) + return env.pointee!.pointee.NewObjectA(env, targetClass, methodID, &mutableArgs)! } public func GetObjectClass(obj: jobject) -> jclass? { let env = self._env - let result = env.memory.memory.GetObjectClass(env, obj) - return (result != nil) ? result : .None + let result = env.pointee!.pointee.GetObjectClass(env, obj) + return (result != nil) ? result : .none } } diff --git a/JNIRefs.swift b/Sources/JNISwift/JNIRefs.swift similarity index 61% rename from JNIRefs.swift rename to Sources/JNISwift/JNIRefs.swift index 581920c..6706143 100644 --- a/JNIRefs.swift +++ b/Sources/JNISwift/JNIRefs.swift @@ -3,62 +3,62 @@ import CJNI public extension JNI { public func NewGlobalRef(obj: jobject) -> jobject { let env = self._env - return env.memory.memory.NewGlobalRef(env, obj) + return env.pointee!.pointee.NewGlobalRef(env, obj)! } public func DeleteGlobalRef(globalRef: jobject) { let env = self._env - env.memory.memory.DeleteGlobalRef(env, globalRef) + env.pointee!.pointee.DeleteGlobalRef(env, globalRef) } public func NewLocalRef(ref: jobject) -> jobject { let env = self._env - return env.memory.memory.NewLocalRef(env, ref) + return env.pointee!.pointee.NewLocalRef(env, ref)! } public func DeleteLocalRef(localRef: jobject) { let env = self._env - env.memory.memory.DeleteLocalRef(env, localRef) + env.pointee!.pointee.DeleteLocalRef(env, localRef) } public func PushLocalFrame(capacity: jint) -> jint { let env = self._env - return env.memory.memory.PushLocalFrame(env, capacity) + return env.pointee!.pointee.PushLocalFrame(env, capacity) } public func PopLocalFrame(result: jobject) -> jobject { let env = self._env - return env.memory.memory.PopLocalFrame(env, result) + return env.pointee!.pointee.PopLocalFrame(env, result)! } public func EnsureLocalCapacity(capacity: jint) -> jint { let env = self._env - return env.memory.memory.EnsureLocalCapacity(env, capacity) + return env.pointee!.pointee.EnsureLocalCapacity(env, capacity) } public func IsSameObject(ref1: jobject, _ ref2: jobject) -> jboolean { let env = self._env - return env.memory.memory.IsSameObject(env, ref1, ref2) + return env.pointee!.pointee.IsSameObject(env, ref1, ref2) } public func IsInstanceOf(obj: jobject, _ targetClass: jclass) -> jboolean { let env = self._env - return env.memory.memory.IsInstanceOf(env, obj, targetClass) + return env.pointee!.pointee.IsInstanceOf(env, obj, targetClass) } public func NewWeakGlobalRef(obj: jobject) -> jweak { let env = self._env - return env.memory.memory.NewWeakGlobalRef(env, obj) + return env.pointee!.pointee.NewWeakGlobalRef(env, obj)! } public func DeleteWeakGlobalRef(obj: jweak) { let env = self._env - env.memory.memory.DeleteWeakGlobalRef(env, obj) + env.pointee!.pointee.DeleteWeakGlobalRef(env, obj) } /* added in 1: JNI.6 */ public func GetObjectRefType(obj: jobject) -> jobjectRefType { let env = self._env - return env.memory.memory.GetObjectRefType(env, obj) + return env.pointee!.pointee.GetObjectRefType(env, obj) } -} \ No newline at end of file +} diff --git a/JNIStrings.swift b/Sources/JNISwift/JNIStrings.swift similarity index 63% rename from JNIStrings.swift rename to Sources/JNISwift/JNIStrings.swift index d85abf7..a494075 100644 --- a/JNIStrings.swift +++ b/Sources/JNISwift/JNIStrings.swift @@ -3,61 +3,61 @@ import CJNI public extension JNI { public func NewString(unicodeChars: UnsafePointer, _ len: jsize) -> jstring { let env = self._env - return env.memory.memory.NewString(env, unicodeChars, len) + return env.pointee!.pointee.NewString(env, unicodeChars, len)! } public func GetStringLength(string: jstring) -> jsize { let env = self._env - return env.memory.memory.GetStringLength(env, string) + return env.pointee!.pointee.GetStringLength(env, string) } public func GetStringChars(string: jstring, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env - return env.memory.memory.GetStringChars(env, string, isCopy) + return env.pointee!.pointee.GetStringChars(env, string, isCopy)! } public func ReleaseStringChars(string: jstring, _ chars: UnsafePointer) { let env = self._env - env.memory.memory.ReleaseStringChars(env, string, chars) + env.pointee!.pointee.ReleaseStringChars(env, string, chars) } public func NewStringUTF(bytes: String) -> jstring { let env = self._env - return env.memory.memory.NewStringUTF(env, bytes) + return env.pointee!.pointee.NewStringUTF(env, bytes)! } public func GetStringUTFLength(string: jstring) -> jsize { let env = self._env - return env.memory.memory.GetStringUTFLength(env, string) + return env.pointee!.pointee.GetStringUTFLength(env, string) } public func GetStringUTFChars(string: jstring, _ isCopy: UnsafeMutablePointer) -> String { let env = self._env - return String(env.memory.memory.GetStringUTFChars(env, string, isCopy)) + return String(describing: env.pointee!.pointee.GetStringUTFChars(env, string, isCopy)) } public func ReleaseStringUTFChars(string: jstring, _ utf: String) { let env = self._env - env.memory.memory.ReleaseStringUTFChars(env, string, utf) + env.pointee!.pointee.ReleaseStringUTFChars(env, string, utf) } public func GetStringRegion(str: jstring, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer) { let env = self._env - env.memory.memory.GetStringRegion(env, str, start, len, buf) + env.pointee!.pointee.GetStringRegion(env, str, start, len, buf) } public func GetStringUTFRegion(str: jstring, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer) { let env = self._env - env.memory.memory.GetStringUTFRegion(env, str, start, len, buf) + env.pointee!.pointee.GetStringUTFRegion(env, str, start, len, buf) } public func GetStringCritical(string: jstring, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env - return env.memory.memory.GetStringCritical(env, string, isCopy) + return env.pointee!.pointee.GetStringCritical(env, string, isCopy)! } public func ReleaseStringCritical(string: jstring, _ carray: UnsafePointer) { let env = self._env - env.memory.memory.ReleaseStringCritical(env, string, carray) + env.pointee!.pointee.ReleaseStringCritical(env, string, carray) } } diff --git a/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift similarity index 70% rename from SwiftJNI.swift rename to Sources/JNISwift/SwiftJNI.swift index 61c4a63..1e58536 100644 --- a/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -1,9 +1,10 @@ import CJNI +import Dispatch public var jni: JNI! // this gets set "OnLoad" so should always exist @_silgen_name("JNI_OnLoad") -public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutablePointer) -> jint { +public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutablePointer) -> jint { guard let localJNI = JNI(jvm: jvm) else { fatalError("Couldn't initialise JNI") @@ -11,9 +12,18 @@ public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutabl jni = localJNI // set the global for use elsewhere + #if os(Android) + // FIXME: Only available in Swift 4.0 + // DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) + #endif + return JNI_VERSION_1_6 } +public func JNI_DetachCurrentThread() { + jni._jvm.pointee?.pointee.DetachCurrentThread(jni._jvm) +} + extension jboolean : BooleanLiteralConvertible { public init(booleanLiteral value: Bool) { self = value ? jboolean(JNI_TRUE) : jboolean(JNI_FALSE) @@ -21,17 +31,17 @@ extension jboolean : BooleanLiteralConvertible { } // SwiftJNI Public API -public class SwiftJNI : JNI { +extension JNI { public func RegisterNatives(jClass: jclass, methods: [JNINativeMethod]) -> Bool { let _env = self._env - let env = _env.memory.memory + let env = _env.pointee!.pointee let result = env.RegisterNatives(_env, jClass, methods, jint(methods.count)) return (result == 0) } public func ThrowNew(message: String) { let _env = self._env - let env = _env.memory.memory + let env = _env.pointee!.pointee env.ThrowNew(_env, env.FindClass(_env, "java/lang/Exception"), message) } @@ -39,50 +49,62 @@ public class SwiftJNI : JNI { public func GetStringUTFChars(string: jstring) -> UnsafePointer { let _env = self._env var didCopyStringChars = jboolean() // XXX: this gets set below, check it! - return _env.memory.memory.GetStringUTFChars(_env, string, &didCopyStringChars) + return _env.pointee!.pointee.GetStringUTFChars(_env, string, &didCopyStringChars)! } // MARK: References public func NewGlobalRef(object: jobject) -> jobject? { let _env = self._env - let result = _env.memory.memory.NewGlobalRef(_env, object) - return (result != nil) ? result : .None + let result = _env.pointee!.pointee.NewGlobalRef(_env, object) + return (result != nil) ? result : .none } // MARK: Classes and Methods public func FindClass(className: String) -> jclass? { let _env = self._env - let result = _env.memory.memory.FindClass(_env, className) - return (result != nil) ? result : .None + let result = _env.pointee!.pointee.FindClass(_env, className) + return (result != nil) ? result : .none } public func GetMethodID(javaClass: jclass, methodName: UnsafePointer, methodSignature: UnsafePointer) -> jmethodID? { let _env = self._env - let result = _env.memory.memory.GetMethodID(_env, javaClass, methodName, methodSignature) - return (result != nil) ? result : .None + let result = _env.pointee!.pointee.GetMethodID(_env, javaClass, methodName, methodSignature) + return (result != nil) ? result : .none + } + + public func GetStaticMethodID(javaClass: jclass, methodName: UnsafePointer, methodSignature: UnsafePointer) -> jmethodID? { + let _env = self._env + let result = _env.pointee!.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) + return (result != nil) ? result : .none } // TODO: make parameters take [JValue], being a swifty version of [jvalue] with reference counting etc. public func CallVoidMethodA(object: jobject, methodID method: jmethodID, parameters: [jvalue]) { let _env = self._env var methodArgs = parameters - _env.memory.memory.CallVoidMethodA(_env, object, method, &methodArgs) + _env.pointee!.pointee.CallVoidMethodA(_env, object, method, &methodArgs) + } + + public func CallStaticIntMethodA(javaClass: jclass, method: jmethodID, parameters: [jvalue]) -> jint { + let _env = self._env + var methodArgs = parameters + return _env.pointee!.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) } // MARK: Arrays public func GetArrayLength(array: jarray) -> Int { let _env = self._env - let result = _env.memory.memory.GetArrayLength(_env, array) + let result = _env.pointee!.pointee.GetArrayLength(_env, array) return Int(result) } public func NewIntArray(count: Int) -> jarray? { let _env = self._env - let result = _env.memory.memory.NewIntArray(_env, jsize(count)) - return (result != nil) ? result : .None + let result = _env.pointee!.pointee.NewIntArray(_env, jsize(count)) + return (result != nil) ? result : .none } public func GetIntArrayRegion(array: jintArray, startIndex: Int = 0, numElements: Int = -1) -> [Int] { @@ -90,24 +112,24 @@ public class SwiftJNI : JNI { var count = numElements if numElements < 0 { - count = GetArrayLength(array) + count = GetArrayLength(array: array) } - var result = [jint](count: count, repeatedValue: 0) - _env.memory.memory.GetIntArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + var result = [jint](repeating: 0, count: count) + _env.pointee!.pointee.GetIntArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) return result.map { Int($0) } } public func SetIntArrayRegion(array: jintArray, startIndex: Int = 0, from sourceElements: [Int]) { let _env = self._env var newElements = sourceElements.map { jint($0) } // make mutable copy - _env.memory.memory.SetIntArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + _env.pointee!.pointee.SetIntArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } public func NewFloatArray(count: Int) -> jarray? { let _env = self._env - let result = _env.memory.memory.NewFloatArray(_env, jsize(count)) - return (result != nil) ? result : .None + let result = _env.pointee!.pointee.NewFloatArray(_env, jsize(count)) + return (result != nil) ? result : .none } public func GetFloatArrayRegion(array: jfloatArray, startIndex: Int = 0, numElements: Int = -1) -> [Float] { @@ -115,25 +137,25 @@ public class SwiftJNI : JNI { var count = numElements if numElements < 0 { - count = GetArrayLength(array) + count = GetArrayLength(array: array) } - var result = [jfloat](count: count, repeatedValue: 0) - _env.memory.memory.GetFloatArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + var result = [jfloat](repeating: 0, count: count) + _env.pointee!.pointee.GetFloatArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) return result.map { Float($0) } } public func SetFloatArrayRegion(array: jfloatArray, startIndex: Int = 0, from sourceElements: [Float]) { let _env = self._env var newElements = sourceElements.map { jfloat($0) } // make mutable copy - _env.memory.memory.SetFloatArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + _env.pointee!.pointee.SetFloatArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } } /** Allows a (Void) Java method to be called from Swift. Takes a global jobj (a class instance), a method name and its signature. The resulting callback can be called via javaCallback.call(param1, param2...), or javaCallback.apply([params]). Each param must be a jvalue. - + Needs more error checking and handling. The basis is there, but from memory I had issues with either the optional or the throwing on Android. */ public struct JavaCallback { @@ -149,8 +171,8 @@ public struct JavaCallback { /// - __InvalidParameters__: One character per method parameter is required. For example, with a methodSignature of "(FF)V", you need to pass two floats as parameters. /// - __InvalidMethod__: Couldn't get the requested method from the jobject provided (are you calling with the right jobject instance / calling on the correct class?) /// - __IncorrectMethodSignature__: The JNI is separated into Java method calls to functions with various return types. So if you perform `callJavaMethod`, you need to accept the return value with the corresponding type. *XXX: currently only Void methods are implemented*. - - enum Error: ErrorType { + + enum JavaError: Error { case JNINotReady case InvalidParameters case IncorrectMethodSignature @@ -181,7 +203,7 @@ public struct JavaCallback { */ public init (_ globalJobj: jobject, methodName: String, methodSignature: String) { // At the moment we can only call Void methods, fail if user tries to return something else - guard let returnType = methodSignature.characters.last where returnType == "V"/*oid*/ else { + guard let returnType = methodSignature.characters.last, returnType == "V"/*oid*/ else { // LOG JavaMethodCallError.IncorrectMethodSignature fatalError("JavaMethodCallError.IncorrectMethodSignature") } @@ -193,8 +215,8 @@ public struct JavaCallback { // TODO: Check methodSignature here and determine expectedParameterCount guard - let javaClass = jni.GetObjectClass(globalJobj), - let methodID = jni.GetMethodID(javaClass, methodName: methodName, methodSignature: methodSignature) + let javaClass = jni.GetObjectClass(obj: globalJobj), + let methodID = jni.GetMethodID(javaClass: javaClass, methodName: methodName, methodSignature: methodSignature) else { // XXX: We should throw here and keep throwing til it gets back to Java fatalError("Failed to make JavaCallback") @@ -205,12 +227,11 @@ public struct JavaCallback { } public func apply(args: [jvalue]) { - jni.CallVoidMethodA(jobj, methodID: methodID, args: args) + jni.CallVoidMethodA(object: jobj, methodID: methodID, parameters: args) } /// Send variadic parameters to the func that takes an array public func call(args: jvalue...) { - self.apply(args) + self.apply(args: args) } } - diff --git a/module.map.in b/module.map.in deleted file mode 100644 index f18ff87..0000000 --- a/module.map.in +++ /dev/null @@ -1,17 +0,0 @@ -//===--- module.map -------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See http://swift.org/LICENSE.txt for license information -// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -module CJNI [system] { - header "@JNI_INCLUDE_PATH@/jni.h" - export * -} - From 3f658dc035b0e93342dbb30983de552f574fa139 Mon Sep 17 00:00:00 2001 From: rikner Date: Thu, 13 Jul 2017 18:08:35 +0200 Subject: [PATCH 02/84] header with renamed types --- Sources/CJNI/include/jni.h | 1813 +++++++++++++++++++++--------------- 1 file changed, 1045 insertions(+), 768 deletions(-) diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index fc92515..fd2bfbd 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -21,6 +21,9 @@ * Everything here is expected to be VM-neutral. */ +#define SWIFT_UNAVAILABLE(reason) __attribute__((unavailable(#reason))) +#define CF_SWIFT_NAME(x) __attribute__((swift_name(#x))) + #ifndef JNI_H_ #define JNI_H_ @@ -31,106 +34,133 @@ * Primitive types that match up with Java equivalents. */ #ifdef HAVE_INTTYPES_H -# include /* C99 */ -typedef uint8_t jboolean; /* unsigned 8 bits */ -typedef int8_t jbyte; /* signed 8 bits */ -typedef uint16_t jchar; /* unsigned 16 bits */ -typedef int16_t jshort; /* signed 16 bits */ -typedef int32_t jint; /* signed 32 bits */ -typedef int64_t jlong; /* signed 64 bits */ -typedef float jfloat; /* 32-bit IEEE 754 */ -typedef double jdouble; /* 64-bit IEEE 754 */ +#include /* C99 */ +typedef uint8_t jboolean; /* unsigned 8 bits */ +typedef int8_t jbyte; /* signed 8 bits */ +typedef uint16_t jchar; /* unsigned 16 bits */ +typedef int16_t jshort; /* signed 16 bits */ +typedef int32_t jint; /* signed 32 bits */ +typedef int64_t jlong; /* signed 64 bits */ +typedef float jfloat; /* 32-bit IEEE 754 */ +typedef double jdouble; /* 64-bit IEEE 754 */ #else -typedef unsigned char jboolean; /* unsigned 8 bits */ -typedef signed char jbyte; /* signed 8 bits */ -typedef unsigned short jchar; /* unsigned 16 bits */ -typedef short jshort; /* signed 16 bits */ -typedef int jint; /* signed 32 bits */ -typedef long long jlong; /* signed 64 bits */ -typedef float jfloat; /* 32-bit IEEE 754 */ -typedef double jdouble; /* 64-bit IEEE 754 */ +typedef unsigned char jboolean CF_SWIFT_NAME(JavaBoolean); /* unsigned 8 bits */ +typedef signed char jbyte CF_SWIFT_NAME(JavaByte); /* signed 8 bits */ +typedef unsigned short jchar CF_SWIFT_NAME(JavaChar); /* unsigned 16 bits */ +typedef short jshort CF_SWIFT_NAME(JavaShort); /* signed 16 bits */ +typedef int jint CF_SWIFT_NAME(JavaInt); /* signed 32 bits */ +typedef long long jlong CF_SWIFT_NAME(JavaLong); /* signed 64 bits */ +typedef float jfloat CF_SWIFT_NAME(JavaFloat); /* 32-bit IEEE 754 */ +typedef double jdouble CF_SWIFT_NAME(JavaDouble); /* 64-bit IEEE 754 */ #endif /* "cardinal indices and sizes" */ -typedef jint jsize; +typedef jint jsize; #ifdef __cplusplus /* * Reference types, in C++ */ -class _jobject {}; -class _jclass : public _jobject {}; -class _jstring : public _jobject {}; -class _jarray : public _jobject {}; -class _jobjectArray : public _jarray {}; -class _jbooleanArray : public _jarray {}; -class _jbyteArray : public _jarray {}; -class _jcharArray : public _jarray {}; -class _jshortArray : public _jarray {}; -class _jintArray : public _jarray {}; -class _jlongArray : public _jarray {}; -class _jfloatArray : public _jarray {}; -class _jdoubleArray : public _jarray {}; -class _jthrowable : public _jobject {}; - -typedef _jobject* jobject; -typedef _jclass* jclass; -typedef _jstring* jstring; -typedef _jarray* jarray; -typedef _jobjectArray* jobjectArray; -typedef _jbooleanArray* jbooleanArray; -typedef _jbyteArray* jbyteArray; -typedef _jcharArray* jcharArray; -typedef _jshortArray* jshortArray; -typedef _jintArray* jintArray; -typedef _jlongArray* jlongArray; -typedef _jfloatArray* jfloatArray; -typedef _jdoubleArray* jdoubleArray; -typedef _jthrowable* jthrowable; -typedef _jobject* jweak; +class _jobject +{ +}; +class _jclass : public _jobject +{ +}; +class _jstring : public _jobject +{ +}; +class _jarray : public _jobject +{ +}; +class _jobjectArray : public _jarray +{ +}; +class _jbooleanArray : public _jarray +{ +}; +class _jbyteArray : public _jarray +{ +}; +class _jcharArray : public _jarray +{ +}; +class _jshortArray : public _jarray +{ +}; +class _jintArray : public _jarray +{ +}; +class _jlongArray : public _jarray +{ +}; +class _jfloatArray : public _jarray +{ +}; +class _jdoubleArray : public _jarray +{ +}; +class _jthrowable : public _jobject +{ +}; +typedef _jobject *jobject; +typedef _jclass *jclass; +typedef _jstring *jstring; +typedef _jarray *jarray; +typedef _jobjectArray *jobjectArray; +typedef _jbooleanArray *jbooleanArray; +typedef _jbyteArray *jbyteArray; +typedef _jcharArray *jcharArray; +typedef _jshortArray *jshortArray; +typedef _jintArray *jintArray; +typedef _jlongArray *jlongArray; +typedef _jfloatArray *jfloatArray; +typedef _jdoubleArray *jdoubleArray; +typedef _jthrowable *jthrowable; +typedef _jobject *jweak; #else /* not __cplusplus */ /* * Reference types, in C. */ -typedef void* jobject; -typedef jobject jclass; -typedef jobject jstring; -typedef jobject jarray; -typedef jarray jobjectArray; -typedef jarray jbooleanArray; -typedef jarray jbyteArray; -typedef jarray jcharArray; -typedef jarray jshortArray; -typedef jarray jintArray; -typedef jarray jlongArray; -typedef jarray jfloatArray; -typedef jarray jdoubleArray; -typedef jobject jthrowable; -typedef jobject jweak; +typedef void *_Nullable jobject CF_SWIFT_NAME(JavaObject); +typedef jobject jclass CF_SWIFT_NAME(JavaClass); +typedef jobject jstring CF_SWIFT_NAME(JavaString); +typedef jobject jarray CF_SWIFT_NAME(JavaArray); +typedef jarray jobjectArray CF_SWIFT_NAME(JavaObjectArray); +typedef jarray jbooleanArray CF_SWIFT_NAME(JavaBooleanArray); +typedef jarray jbyteArray CF_SWIFT_NAME(JavaByteArray); +typedef jarray jcharArray CF_SWIFT_NAME(JavaCharArray); +typedef jarray jshortArray CF_SWIFT_NAME(JavaShortArray); +typedef jarray jintArray CF_SWIFT_NAME(JavaIntArray); +typedef jarray jlongArray CF_SWIFT_NAME(JavaLongArray); +typedef jarray jfloatArray CF_SWIFT_NAME(JavaFloatArray); +typedef jarray jdoubleArray CF_SWIFT_NAME(JavaDoubleArray); +typedef jobject jthrowable CF_SWIFT_NAME(JavaThrowable); +typedef jobject jweak CF_SWIFT_NAME(JavaWeakReference); #endif /* not __cplusplus */ -struct _jfieldID; /* opaque structure */ -typedef struct _jfieldID* jfieldID; /* field IDs */ +struct _jfieldID; /* opaque structure */ +typedef struct _jfieldID *_Nullable jfieldID; /* field IDs */ -struct _jmethodID; /* opaque structure */ -typedef struct _jmethodID* jmethodID; /* method IDs */ +struct _jmethodID; /* opaque structure */ +typedef struct _jmethodID *_Nullable jmethodID CF_SWIFT_NAME(JavaMethodID); /* method IDs */ struct JNIInvokeInterface; -typedef union jvalue { - jboolean z; - jbyte b; - jchar c; - jshort s; - jint i; - jlong j; - jfloat f; - jdouble d; - jobject l; +typedef union CF_SWIFT_NAME(JavaParameter) jvalue { + jboolean z CF_SWIFT_NAME(bool); + jbyte b CF_SWIFT_NAME(byte); + jchar c CF_SWIFT_NAME(char); + jshort s CF_SWIFT_NAME(short); + jint i CF_SWIFT_NAME(int); + jlong j CF_SWIFT_NAME(long); + jfloat f CF_SWIFT_NAME(float); + jdouble d CF_SWIFT_NAME(double); + jobject l CF_SWIFT_NAME(object); } jvalue; typedef enum jobjectRefType { @@ -140,360 +170,303 @@ typedef enum jobjectRefType { JNIWeakGlobalRefType = 3 } jobjectRefType; -typedef struct { - const char* name; - const char* signature; - void* fnPtr; +typedef struct +{ + const char *_Nonnull name; + const char *_Nonnull signature; + void *_Nonnull fnPtr; } JNINativeMethod; struct _JNIEnv; struct _JavaVM; -typedef const struct JNINativeInterface* C_JNIEnv; +typedef const struct JNINativeInterface *_Nonnull C_JNIEnv; #if defined(__cplusplus) typedef _JNIEnv JNIEnv; typedef _JavaVM JavaVM; #else -typedef const struct JNINativeInterface* JNIEnv; -typedef const struct JNIInvokeInterface* JavaVM; +typedef const struct JNINativeInterface *_Nonnull JNIEnv; +typedef const struct JNIInvokeInterface *_Nonnull JavaVM; #endif /* * Table of interface function pointers. */ -struct JNINativeInterface { - void* reserved0; - void* reserved1; - void* reserved2; - void* reserved3; +struct JNINativeInterface +{ + void *_Null_unspecified reserved0; + void *_Null_unspecified reserved1; + void *_Null_unspecified reserved2; + void *_Null_unspecified reserved3; - jint (*GetVersion)(JNIEnv *); + jint (*_Nonnull GetVersion)(JNIEnv *_Nonnull); - jclass (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*, - jsize); - jclass (*FindClass)(JNIEnv*, const char*); + jclass (*_Nonnull DefineClass)(JNIEnv *_Nonnull, const char *_Nonnull, jobject, const jbyte *_Nonnull, jsize) SWIFT_UNAVAILABLE(Not implemented on Android); + jclass (*_Nonnull FindClass)(JNIEnv *_Nonnull, const char *_Nonnull); - jmethodID (*FromReflectedMethod)(JNIEnv*, jobject); - jfieldID (*FromReflectedField)(JNIEnv*, jobject); + jmethodID (*_Nonnull FromReflectedMethod)(JNIEnv *_Nonnull, jobject); + jfieldID (*_Nonnull FromReflectedField)(JNIEnv *_Nonnull, jobject); /* spec doesn't show jboolean parameter */ - jobject (*ToReflectedMethod)(JNIEnv*, jclass, jmethodID, jboolean); + jobject (*_Nonnull ToReflectedMethod)(JNIEnv *_Nonnull, jclass, jmethodID, jboolean); - jclass (*GetSuperclass)(JNIEnv*, jclass); - jboolean (*IsAssignableFrom)(JNIEnv*, jclass, jclass); + jclass (*_Nonnull GetSuperclass)(JNIEnv *_Nonnull, jclass); + jboolean (*_Nonnull IsAssignableFrom)(JNIEnv *_Nonnull, jclass, jclass); /* spec doesn't show jboolean parameter */ - jobject (*ToReflectedField)(JNIEnv*, jclass, jfieldID, jboolean); - - jint (*Throw)(JNIEnv*, jthrowable); - jint (*ThrowNew)(JNIEnv *, jclass, const char *); - jthrowable (*ExceptionOccurred)(JNIEnv*); - void (*ExceptionDescribe)(JNIEnv*); - void (*ExceptionClear)(JNIEnv*); - void (*FatalError)(JNIEnv*, const char*); - - jint (*PushLocalFrame)(JNIEnv*, jint); - jobject (*PopLocalFrame)(JNIEnv*, jobject); - - jobject (*NewGlobalRef)(JNIEnv*, jobject); - void (*DeleteGlobalRef)(JNIEnv*, jobject); - void (*DeleteLocalRef)(JNIEnv*, jobject); - jboolean (*IsSameObject)(JNIEnv*, jobject, jobject); - - jobject (*NewLocalRef)(JNIEnv*, jobject); - jint (*EnsureLocalCapacity)(JNIEnv*, jint); - - jobject (*AllocObject)(JNIEnv*, jclass); - jobject (*NewObject)(JNIEnv*, jclass, jmethodID, ...); - jobject (*NewObjectV)(JNIEnv*, jclass, jmethodID, va_list); - jobject (*NewObjectA)(JNIEnv*, jclass, jmethodID, jvalue*); - - jclass (*GetObjectClass)(JNIEnv*, jobject); - jboolean (*IsInstanceOf)(JNIEnv*, jobject, jclass); - jmethodID (*GetMethodID)(JNIEnv*, jclass, const char*, const char*); - - jobject (*CallObjectMethod)(JNIEnv*, jobject, jmethodID, ...); - jobject (*CallObjectMethodV)(JNIEnv*, jobject, jmethodID, va_list); - jobject (*CallObjectMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - jboolean (*CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...); - jboolean (*CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list); - jboolean (*CallBooleanMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - jbyte (*CallByteMethod)(JNIEnv*, jobject, jmethodID, ...); - jbyte (*CallByteMethodV)(JNIEnv*, jobject, jmethodID, va_list); - jbyte (*CallByteMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - jchar (*CallCharMethod)(JNIEnv*, jobject, jmethodID, ...); - jchar (*CallCharMethodV)(JNIEnv*, jobject, jmethodID, va_list); - jchar (*CallCharMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - jshort (*CallShortMethod)(JNIEnv*, jobject, jmethodID, ...); - jshort (*CallShortMethodV)(JNIEnv*, jobject, jmethodID, va_list); - jshort (*CallShortMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - jint (*CallIntMethod)(JNIEnv*, jobject, jmethodID, ...); - jint (*CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list); - jint (*CallIntMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - jlong (*CallLongMethod)(JNIEnv*, jobject, jmethodID, ...); - jlong (*CallLongMethodV)(JNIEnv*, jobject, jmethodID, va_list); - jlong (*CallLongMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - jfloat (*CallFloatMethod)(JNIEnv*, jobject, jmethodID, ...); - jfloat (*CallFloatMethodV)(JNIEnv*, jobject, jmethodID, va_list); - jfloat (*CallFloatMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - jdouble (*CallDoubleMethod)(JNIEnv*, jobject, jmethodID, ...); - jdouble (*CallDoubleMethodV)(JNIEnv*, jobject, jmethodID, va_list); - jdouble (*CallDoubleMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - void (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...); - void (*CallVoidMethodV)(JNIEnv*, jobject, jmethodID, va_list); - void (*CallVoidMethodA)(JNIEnv*, jobject, jmethodID, jvalue*); - - jobject (*CallNonvirtualObjectMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - jobject (*CallNonvirtualObjectMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - jobject (*CallNonvirtualObjectMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - jboolean (*CallNonvirtualBooleanMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - jboolean (*CallNonvirtualBooleanMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - jboolean (*CallNonvirtualBooleanMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - jbyte (*CallNonvirtualByteMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - jbyte (*CallNonvirtualByteMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - jbyte (*CallNonvirtualByteMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - jchar (*CallNonvirtualCharMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - jchar (*CallNonvirtualCharMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - jchar (*CallNonvirtualCharMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - jshort (*CallNonvirtualShortMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - jshort (*CallNonvirtualShortMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - jshort (*CallNonvirtualShortMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - jint (*CallNonvirtualIntMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - jint (*CallNonvirtualIntMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - jint (*CallNonvirtualIntMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - jlong (*CallNonvirtualLongMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - jlong (*CallNonvirtualLongMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - jlong (*CallNonvirtualLongMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - jfloat (*CallNonvirtualFloatMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - jfloat (*CallNonvirtualFloatMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - jfloat (*CallNonvirtualFloatMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - jdouble (*CallNonvirtualDoubleMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - jdouble (*CallNonvirtualDoubleMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - jdouble (*CallNonvirtualDoubleMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - void (*CallNonvirtualVoidMethod)(JNIEnv*, jobject, jclass, - jmethodID, ...); - void (*CallNonvirtualVoidMethodV)(JNIEnv*, jobject, jclass, - jmethodID, va_list); - void (*CallNonvirtualVoidMethodA)(JNIEnv*, jobject, jclass, - jmethodID, jvalue*); - - jfieldID (*GetFieldID)(JNIEnv*, jclass, const char*, const char*); - - jobject (*GetObjectField)(JNIEnv*, jobject, jfieldID); - jboolean (*GetBooleanField)(JNIEnv*, jobject, jfieldID); - jbyte (*GetByteField)(JNIEnv*, jobject, jfieldID); - jchar (*GetCharField)(JNIEnv*, jobject, jfieldID); - jshort (*GetShortField)(JNIEnv*, jobject, jfieldID); - jint (*GetIntField)(JNIEnv*, jobject, jfieldID); - jlong (*GetLongField)(JNIEnv*, jobject, jfieldID); - jfloat (*GetFloatField)(JNIEnv*, jobject, jfieldID); - jdouble (*GetDoubleField)(JNIEnv*, jobject, jfieldID); - - void (*SetObjectField)(JNIEnv*, jobject, jfieldID, jobject); - void (*SetBooleanField)(JNIEnv*, jobject, jfieldID, jboolean); - void (*SetByteField)(JNIEnv*, jobject, jfieldID, jbyte); - void (*SetCharField)(JNIEnv*, jobject, jfieldID, jchar); - void (*SetShortField)(JNIEnv*, jobject, jfieldID, jshort); - void (*SetIntField)(JNIEnv*, jobject, jfieldID, jint); - void (*SetLongField)(JNIEnv*, jobject, jfieldID, jlong); - void (*SetFloatField)(JNIEnv*, jobject, jfieldID, jfloat); - void (*SetDoubleField)(JNIEnv*, jobject, jfieldID, jdouble); - - jmethodID (*GetStaticMethodID)(JNIEnv*, jclass, const char*, const char*); - - jobject (*CallStaticObjectMethod)(JNIEnv*, jclass, jmethodID, ...); - jobject (*CallStaticObjectMethodV)(JNIEnv*, jclass, jmethodID, va_list); - jobject (*CallStaticObjectMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); - jboolean (*CallStaticBooleanMethod)(JNIEnv*, jclass, jmethodID, ...); - jboolean (*CallStaticBooleanMethodV)(JNIEnv*, jclass, jmethodID, - va_list); - jboolean (*CallStaticBooleanMethodA)(JNIEnv*, jclass, jmethodID, - jvalue*); - jbyte (*CallStaticByteMethod)(JNIEnv*, jclass, jmethodID, ...); - jbyte (*CallStaticByteMethodV)(JNIEnv*, jclass, jmethodID, va_list); - jbyte (*CallStaticByteMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); - jchar (*CallStaticCharMethod)(JNIEnv*, jclass, jmethodID, ...); - jchar (*CallStaticCharMethodV)(JNIEnv*, jclass, jmethodID, va_list); - jchar (*CallStaticCharMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); - jshort (*CallStaticShortMethod)(JNIEnv*, jclass, jmethodID, ...); - jshort (*CallStaticShortMethodV)(JNIEnv*, jclass, jmethodID, va_list); - jshort (*CallStaticShortMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); - jint (*CallStaticIntMethod)(JNIEnv*, jclass, jmethodID, ...); - jint (*CallStaticIntMethodV)(JNIEnv*, jclass, jmethodID, va_list); - jint (*CallStaticIntMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); - jlong (*CallStaticLongMethod)(JNIEnv*, jclass, jmethodID, ...); - jlong (*CallStaticLongMethodV)(JNIEnv*, jclass, jmethodID, va_list); - jlong (*CallStaticLongMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); - jfloat (*CallStaticFloatMethod)(JNIEnv*, jclass, jmethodID, ...); - jfloat (*CallStaticFloatMethodV)(JNIEnv*, jclass, jmethodID, va_list); - jfloat (*CallStaticFloatMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); - jdouble (*CallStaticDoubleMethod)(JNIEnv*, jclass, jmethodID, ...); - jdouble (*CallStaticDoubleMethodV)(JNIEnv*, jclass, jmethodID, va_list); - jdouble (*CallStaticDoubleMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); - void (*CallStaticVoidMethod)(JNIEnv*, jclass, jmethodID, ...); - void (*CallStaticVoidMethodV)(JNIEnv*, jclass, jmethodID, va_list); - void (*CallStaticVoidMethodA)(JNIEnv*, jclass, jmethodID, jvalue*); - - jfieldID (*GetStaticFieldID)(JNIEnv*, jclass, const char*, - const char*); - - jobject (*GetStaticObjectField)(JNIEnv*, jclass, jfieldID); - jboolean (*GetStaticBooleanField)(JNIEnv*, jclass, jfieldID); - jbyte (*GetStaticByteField)(JNIEnv*, jclass, jfieldID); - jchar (*GetStaticCharField)(JNIEnv*, jclass, jfieldID); - jshort (*GetStaticShortField)(JNIEnv*, jclass, jfieldID); - jint (*GetStaticIntField)(JNIEnv*, jclass, jfieldID); - jlong (*GetStaticLongField)(JNIEnv*, jclass, jfieldID); - jfloat (*GetStaticFloatField)(JNIEnv*, jclass, jfieldID); - jdouble (*GetStaticDoubleField)(JNIEnv*, jclass, jfieldID); - - void (*SetStaticObjectField)(JNIEnv*, jclass, jfieldID, jobject); - void (*SetStaticBooleanField)(JNIEnv*, jclass, jfieldID, jboolean); - void (*SetStaticByteField)(JNIEnv*, jclass, jfieldID, jbyte); - void (*SetStaticCharField)(JNIEnv*, jclass, jfieldID, jchar); - void (*SetStaticShortField)(JNIEnv*, jclass, jfieldID, jshort); - void (*SetStaticIntField)(JNIEnv*, jclass, jfieldID, jint); - void (*SetStaticLongField)(JNIEnv*, jclass, jfieldID, jlong); - void (*SetStaticFloatField)(JNIEnv*, jclass, jfieldID, jfloat); - void (*SetStaticDoubleField)(JNIEnv*, jclass, jfieldID, jdouble); - - jstring (*NewString)(JNIEnv*, const jchar*, jsize); - jsize (*GetStringLength)(JNIEnv*, jstring); - const jchar* (*GetStringChars)(JNIEnv*, jstring, jboolean*); - void (*ReleaseStringChars)(JNIEnv*, jstring, const jchar*); - jstring (*NewStringUTF)(JNIEnv*, const char*); - jsize (*GetStringUTFLength)(JNIEnv*, jstring); + jobject (*_Nonnull ToReflectedField)(JNIEnv *_Nonnull, jclass, jfieldID, jboolean); + + jint (*_Nonnull Throw)(JNIEnv *_Nonnull, jthrowable); + jint (*_Nonnull ThrowNew)(JNIEnv *, jclass, const char *_Nonnull); + jthrowable (*_Nonnull ExceptionOccurred)(JNIEnv *_Nonnull); + void (*_Nonnull ExceptionDescribe)(JNIEnv *_Nonnull); + void (*_Nonnull ExceptionClear)(JNIEnv *_Nonnull); + void (*_Nonnull FatalError)(JNIEnv *_Nonnull, const char *_Nonnull); + + jint (*_Nonnull PushLocalFrame)(JNIEnv *_Nonnull, jint); + jobject (*_Nonnull PopLocalFrame)(JNIEnv *_Nonnull, jobject); + + jobject (*_Nonnull NewGlobalRef)(JNIEnv *_Nonnull, jobject); + void (*_Nonnull DeleteGlobalRef)(JNIEnv *_Nonnull, jobject); + void (*_Nonnull DeleteLocalRef)(JNIEnv *_Nonnull, jobject); + jboolean (*_Nonnull IsSameObject)(JNIEnv *_Nonnull, jobject, jobject); + + jobject (*_Nonnull NewLocalRef)(JNIEnv *_Nonnull, jobject); + jint (*_Nonnull EnsureLocalCapacity)(JNIEnv *_Nonnull, jint); + + jobject (*_Nonnull AllocObject)(JNIEnv *_Nonnull, jclass); + jobject (*_Nonnull NewObject)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'newObject' instead); + jobject (*_Nonnull NewObjectV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'newObject' instead); + jobject (*_Nonnull NewObjectA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(newObject); + + jclass (*_Nonnull GetObjectClass)(JNIEnv *_Nonnull, jobject); + jboolean (*_Nonnull IsInstanceOf)(JNIEnv *_Nonnull, jobject, jclass); + jmethodID (*_Nonnull GetMethodID)(JNIEnv *_Nonnull, jclass, const char *_Nonnull, const char *_Nonnull); + + jobject (*_Nonnull CallObjectMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + jobject (*_Nonnull CallObjectMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + jobject (*_Nonnull CallObjectMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + jboolean (*_Nonnull CallBooleanMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + jboolean (*_Nonnull CallBooleanMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + jboolean (*_Nonnull CallBooleanMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + jbyte (*_Nonnull CallByteMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + jbyte (*_Nonnull CallByteMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + jbyte (*_Nonnull CallByteMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + jchar (*_Nonnull CallCharMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + jchar (*_Nonnull CallCharMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + jchar (*_Nonnull CallCharMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + jshort (*_Nonnull CallShortMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + jshort (*_Nonnull CallShortMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + jshort (*_Nonnull CallShortMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + jint (*_Nonnull CallIntMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + jint (*_Nonnull CallIntMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + jint (*_Nonnull CallIntMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + jlong (*_Nonnull CallLongMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + jlong (*_Nonnull CallLongMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + jlong (*_Nonnull CallLongMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + jfloat (*_Nonnull CallFloatMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + jfloat (*_Nonnull CallFloatMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + jfloat (*_Nonnull CallFloatMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + jdouble (*_Nonnull CallDoubleMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + jdouble (*_Nonnull CallDoubleMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + jdouble (*_Nonnull CallDoubleMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + void (*_Nonnull CallVoidMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); + void (*_Nonnull CallVoidMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); + void (*_Nonnull CallVoidMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); + + jobject (*_Nonnull CallNonvirtualObjectMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jobject (*_Nonnull CallNonvirtualObjectMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jobject (*_Nonnull CallNonvirtualObjectMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + jboolean (*_Nonnull CallNonvirtualBooleanMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jboolean (*_Nonnull CallNonvirtualBooleanMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jboolean (*_Nonnull CallNonvirtualBooleanMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + jbyte (*_Nonnull CallNonvirtualByteMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jbyte (*_Nonnull CallNonvirtualByteMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jbyte (*_Nonnull CallNonvirtualByteMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + jchar (*_Nonnull CallNonvirtualCharMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jchar (*_Nonnull CallNonvirtualCharMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jchar (*_Nonnull CallNonvirtualCharMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + jshort (*_Nonnull CallNonvirtualShortMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jshort (*_Nonnull CallNonvirtualShortMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jshort (*_Nonnull CallNonvirtualShortMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + jint (*_Nonnull CallNonvirtualIntMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jint (*_Nonnull CallNonvirtualIntMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jint (*_Nonnull CallNonvirtualIntMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + jlong (*_Nonnull CallNonvirtualLongMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jlong (*_Nonnull CallNonvirtualLongMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jlong (*_Nonnull CallNonvirtualLongMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + jfloat (*_Nonnull CallNonvirtualFloatMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jfloat (*_Nonnull CallNonvirtualFloatMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jfloat (*_Nonnull CallNonvirtualFloatMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + jdouble (*_Nonnull CallNonvirtualDoubleMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jdouble (*_Nonnull CallNonvirtualDoubleMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jdouble (*_Nonnull CallNonvirtualDoubleMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + void (*_Nonnull CallNonvirtualVoidMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + void (*_Nonnull CallNonvirtualVoidMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + void (*_Nonnull CallNonvirtualVoidMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); + + jfieldID (*_Nonnull GetFieldID)(JNIEnv *_Nonnull, jclass, const char *_Nonnull, const char *_Nonnull); + + jobject (*_Nonnull GetObjectField)(JNIEnv *_Nonnull, jobject, jfieldID); + jboolean (*_Nonnull GetBooleanField)(JNIEnv *_Nonnull, jobject, jfieldID); + jbyte (*_Nonnull GetByteField)(JNIEnv *_Nonnull, jobject, jfieldID); + jchar (*_Nonnull GetCharField)(JNIEnv *_Nonnull, jobject, jfieldID); + jshort (*_Nonnull GetShortField)(JNIEnv *_Nonnull, jobject, jfieldID); + jint (*_Nonnull GetIntField)(JNIEnv *_Nonnull, jobject, jfieldID); + jlong (*_Nonnull GetLongField)(JNIEnv *_Nonnull, jobject, jfieldID); + jfloat (*_Nonnull GetFloatField)(JNIEnv *_Nonnull, jobject, jfieldID); + jdouble (*_Nonnull GetDoubleField)(JNIEnv *_Nonnull, jobject, jfieldID); + + void (*_Nonnull SetObjectField)(JNIEnv *_Nonnull, jobject, jfieldID, jobject); + void (*_Nonnull SetBooleanField)(JNIEnv *_Nonnull, jobject, jfieldID, jboolean); + void (*_Nonnull SetByteField)(JNIEnv *_Nonnull, jobject, jfieldID, jbyte); + void (*_Nonnull SetCharField)(JNIEnv *_Nonnull, jobject, jfieldID, jchar); + void (*_Nonnull SetShortField)(JNIEnv *_Nonnull, jobject, jfieldID, jshort); + void (*_Nonnull SetIntField)(JNIEnv *_Nonnull, jobject, jfieldID, jint); + void (*_Nonnull SetLongField)(JNIEnv *_Nonnull, jobject, jfieldID, jlong); + void (*_Nonnull SetFloatField)(JNIEnv *_Nonnull, jobject, jfieldID, jfloat); + void (*_Nonnull SetDoubleField)(JNIEnv *_Nonnull, jobject, jfieldID, jdouble); + + jmethodID (*_Nonnull GetStaticMethodID)(JNIEnv *_Nonnull, jclass, const char *_Nonnull, const char *_Nonnull); + + jobject (*_Nonnull CallStaticObjectMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jobject (*_Nonnull CallStaticObjectMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jobject (*_Nonnull CallStaticObjectMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + jboolean (*_Nonnull CallStaticBooleanMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jboolean (*_Nonnull CallStaticBooleanMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jboolean (*_Nonnull CallStaticBooleanMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + jbyte (*_Nonnull CallStaticByteMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jbyte (*_Nonnull CallStaticByteMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jbyte (*_Nonnull CallStaticByteMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + jchar (*_Nonnull CallStaticCharMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jchar (*_Nonnull CallStaticCharMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jchar (*_Nonnull CallStaticCharMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + jshort (*_Nonnull CallStaticShortMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jshort (*_Nonnull CallStaticShortMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jshort (*_Nonnull CallStaticShortMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + jint (*_Nonnull CallStaticIntMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jint (*_Nonnull CallStaticIntMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jint (*_Nonnull CallStaticIntMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + jlong (*_Nonnull CallStaticLongMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jlong (*_Nonnull CallStaticLongMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jlong (*_Nonnull CallStaticLongMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + jfloat (*_Nonnull CallStaticFloatMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jfloat (*_Nonnull CallStaticFloatMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jfloat (*_Nonnull CallStaticFloatMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + jdouble (*_Nonnull CallStaticDoubleMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jdouble (*_Nonnull CallStaticDoubleMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jdouble (*_Nonnull CallStaticDoubleMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + void (*_Nonnull CallStaticVoidMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + void (*_Nonnull CallStaticVoidMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + void (*_Nonnull CallStaticVoidMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); + + jfieldID (*_Nonnull GetStaticFieldID)(JNIEnv *_Nonnull, jclass, const char *_Nonnull, const char *_Nonnull); + + jobject (*_Nonnull GetStaticObjectField)(JNIEnv *_Nonnull, jclass, jfieldID); + jboolean (*_Nonnull GetStaticBooleanField)(JNIEnv *_Nonnull, jclass, jfieldID); + jbyte (*_Nonnull GetStaticByteField)(JNIEnv *_Nonnull, jclass, jfieldID); + jchar (*_Nonnull GetStaticCharField)(JNIEnv *_Nonnull, jclass, jfieldID); + jshort (*_Nonnull GetStaticShortField)(JNIEnv *_Nonnull, jclass, jfieldID); + jint (*_Nonnull GetStaticIntField)(JNIEnv *_Nonnull, jclass, jfieldID); + jlong (*_Nonnull GetStaticLongField)(JNIEnv *_Nonnull, jclass, jfieldID); + jfloat (*_Nonnull GetStaticFloatField)(JNIEnv *_Nonnull, jclass, jfieldID); + jdouble (*_Nonnull GetStaticDoubleField)(JNIEnv *_Nonnull, jclass, jfieldID); + + void (*_Nonnull SetStaticObjectField)(JNIEnv *_Nonnull, jclass, jfieldID, jobject); + void (*_Nonnull SetStaticBooleanField)(JNIEnv *_Nonnull, jclass, jfieldID, jboolean); + void (*_Nonnull SetStaticByteField)(JNIEnv *_Nonnull, jclass, jfieldID, jbyte); + void (*_Nonnull SetStaticCharField)(JNIEnv *_Nonnull, jclass, jfieldID, jchar); + void (*_Nonnull SetStaticShortField)(JNIEnv *_Nonnull, jclass, jfieldID, jshort); + void (*_Nonnull SetStaticIntField)(JNIEnv *_Nonnull, jclass, jfieldID, jint); + void (*_Nonnull SetStaticLongField)(JNIEnv *_Nonnull, jclass, jfieldID, jlong); + void (*_Nonnull SetStaticFloatField)(JNIEnv *_Nonnull, jclass, jfieldID, jfloat); + void (*_Nonnull SetStaticDoubleField)(JNIEnv *_Nonnull, jclass, jfieldID, jdouble); + + jstring (*_Nonnull NewString)(JNIEnv *_Nonnull, const jchar *, jsize); + jsize (*_Nonnull GetStringLength)(JNIEnv *_Nonnull, jstring); + const jchar *(*_Nonnull GetStringChars)(JNIEnv *_Nonnull, jstring, jboolean *_Nonnull); + void (*_Nonnull ReleaseStringChars)(JNIEnv *_Nonnull, jstring, const jchar *_Nonnull); + jstring (*_Nonnull NewStringUTF)(JNIEnv *_Nonnull, const char *_Nonnull); + jsize (*_Nonnull GetStringUTFLength)(JNIEnv *_Nonnull, jstring); /* JNI spec says this returns const jbyte*, but that's inconsistent */ - const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*); - void (*ReleaseStringUTFChars)(JNIEnv*, jstring, const char*); - jsize (*GetArrayLength)(JNIEnv*, jarray); - jobjectArray (*NewObjectArray)(JNIEnv*, jsize, jclass, jobject); - jobject (*GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize); - void (*SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject); - - jbooleanArray (*NewBooleanArray)(JNIEnv*, jsize); - jbyteArray (*NewByteArray)(JNIEnv*, jsize); - jcharArray (*NewCharArray)(JNIEnv*, jsize); - jshortArray (*NewShortArray)(JNIEnv*, jsize); - jintArray (*NewIntArray)(JNIEnv*, jsize); - jlongArray (*NewLongArray)(JNIEnv*, jsize); - jfloatArray (*NewFloatArray)(JNIEnv*, jsize); - jdoubleArray (*NewDoubleArray)(JNIEnv*, jsize); - - jboolean* (*GetBooleanArrayElements)(JNIEnv*, jbooleanArray, jboolean*); - jbyte* (*GetByteArrayElements)(JNIEnv*, jbyteArray, jboolean*); - jchar* (*GetCharArrayElements)(JNIEnv*, jcharArray, jboolean*); - jshort* (*GetShortArrayElements)(JNIEnv*, jshortArray, jboolean*); - jint* (*GetIntArrayElements)(JNIEnv*, jintArray, jboolean*); - jlong* (*GetLongArrayElements)(JNIEnv*, jlongArray, jboolean*); - jfloat* (*GetFloatArrayElements)(JNIEnv*, jfloatArray, jboolean*); - jdouble* (*GetDoubleArrayElements)(JNIEnv*, jdoubleArray, jboolean*); - - void (*ReleaseBooleanArrayElements)(JNIEnv*, jbooleanArray, - jboolean*, jint); - void (*ReleaseByteArrayElements)(JNIEnv*, jbyteArray, - jbyte*, jint); - void (*ReleaseCharArrayElements)(JNIEnv*, jcharArray, - jchar*, jint); - void (*ReleaseShortArrayElements)(JNIEnv*, jshortArray, - jshort*, jint); - void (*ReleaseIntArrayElements)(JNIEnv*, jintArray, - jint*, jint); - void (*ReleaseLongArrayElements)(JNIEnv*, jlongArray, - jlong*, jint); - void (*ReleaseFloatArrayElements)(JNIEnv*, jfloatArray, - jfloat*, jint); - void (*ReleaseDoubleArrayElements)(JNIEnv*, jdoubleArray, - jdouble*, jint); - - void (*GetBooleanArrayRegion)(JNIEnv*, jbooleanArray, - jsize, jsize, jboolean*); - void (*GetByteArrayRegion)(JNIEnv*, jbyteArray, - jsize, jsize, jbyte*); - void (*GetCharArrayRegion)(JNIEnv*, jcharArray, - jsize, jsize, jchar*); - void (*GetShortArrayRegion)(JNIEnv*, jshortArray, - jsize, jsize, jshort*); - void (*GetIntArrayRegion)(JNIEnv*, jintArray, - jsize, jsize, jint*); - void (*GetLongArrayRegion)(JNIEnv*, jlongArray, - jsize, jsize, jlong*); - void (*GetFloatArrayRegion)(JNIEnv*, jfloatArray, - jsize, jsize, jfloat*); - void (*GetDoubleArrayRegion)(JNIEnv*, jdoubleArray, - jsize, jsize, jdouble*); + const char *(*_Nonnull GetStringUTFChars)(JNIEnv *_Nonnull, jstring, jboolean *_Nonnull); + void (*_Nonnull ReleaseStringUTFChars)(JNIEnv *_Nonnull, jstring, const char *_Nonnull); + jsize (*_Nonnull GetArrayLength)(JNIEnv *_Nonnull, jarray); + jobjectArray (*_Nonnull NewObjectArray)(JNIEnv *_Nonnull, jsize, jclass, jobject); + jobject (*_Nonnull GetObjectArrayElement)(JNIEnv *_Nonnull, jobjectArray, jsize); + void (*_Nonnull SetObjectArrayElement)(JNIEnv *_Nonnull, jobjectArray, jsize, jobject); + + jbooleanArray (*_Nonnull NewBooleanArray)(JNIEnv *_Nonnull, jsize); + jbyteArray (*_Nonnull NewByteArray)(JNIEnv *_Nonnull, jsize); + jcharArray (*_Nonnull NewCharArray)(JNIEnv *_Nonnull, jsize); + jshortArray (*_Nonnull NewShortArray)(JNIEnv *_Nonnull, jsize); + jintArray (*_Nonnull NewIntArray)(JNIEnv *_Nonnull, jsize); + jlongArray (*_Nonnull NewLongArray)(JNIEnv *_Nonnull, jsize); + jfloatArray (*_Nonnull NewFloatArray)(JNIEnv *_Nonnull, jsize); + jdoubleArray (*_Nonnull NewDoubleArray)(JNIEnv *_Nonnull, jsize); + + jboolean *_Nullable (*_Nonnull GetBooleanArrayElements)(JNIEnv *_Nonnull, jbooleanArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); + jbyte *_Nullable (*_Nonnull GetByteArrayElements)(JNIEnv *_Nonnull, jbyteArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); + jchar *_Nullable (*_Nonnull GetCharArrayElements)(JNIEnv *_Nonnull, jcharArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); + jshort *_Nullable (*_Nonnull GetShortArrayElements)(JNIEnv *_Nonnull, jshortArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); + jint *_Nullable (*_Nonnull GetIntArrayElements)(JNIEnv *_Nonnull, jintArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); + jlong *_Nullable (*_Nonnull GetLongArrayElements)(JNIEnv *_Nonnull, jlongArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); + jfloat *_Nullable (*_Nonnull GetFloatArrayElements)(JNIEnv *_Nonnull, jfloatArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); + jdouble *_Nullable (*_Nonnull GetDoubleArrayElements)(JNIEnv *_Nonnull, jdoubleArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); + + void (*_Nonnull ReleaseBooleanArrayElements)(JNIEnv *_Nonnull, jbooleanArray, jboolean *, jint) CF_SWIFT_NAME(releaseArrayElements); + void (*_Nonnull ReleaseByteArrayElements)(JNIEnv *_Nonnull, jbyteArray, jbyte *, jint) CF_SWIFT_NAME(releaseArrayElements); + void (*_Nonnull ReleaseCharArrayElements)(JNIEnv *_Nonnull, jcharArray, jchar *, jint) CF_SWIFT_NAME(releaseArrayElements); + void (*_Nonnull ReleaseShortArrayElements)(JNIEnv *_Nonnull, jshortArray, jshort *, jint) CF_SWIFT_NAME(releaseArrayElements); + void (*_Nonnull ReleaseIntArrayElements)(JNIEnv *_Nonnull, jintArray, jint *, jint) CF_SWIFT_NAME(releaseArrayElements); + void (*_Nonnull ReleaseLongArrayElements)(JNIEnv *_Nonnull, jlongArray, jlong *, jint) CF_SWIFT_NAME(releaseArrayElements); + void (*_Nonnull ReleaseFloatArrayElements)(JNIEnv *_Nonnull, jfloatArray, jfloat *, jint) CF_SWIFT_NAME(releaseArrayElements); + void (*_Nonnull ReleaseDoubleArrayElements)(JNIEnv *_Nonnull, jdoubleArray, jdouble *, jint) CF_SWIFT_NAME(releaseArrayElements); + + void (*_Nonnull GetBooleanArrayRegion)(JNIEnv *_Nonnull, jbooleanArray, jsize, jsize, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayRegion); + void (*_Nonnull GetByteArrayRegion)(JNIEnv *_Nonnull, jbyteArray, jsize, jsize, jbyte *_Nonnull) CF_SWIFT_NAME(getArrayRegion); + void (*_Nonnull GetCharArrayRegion)(JNIEnv *_Nonnull, jcharArray, jsize, jsize, jchar *_Nonnull) CF_SWIFT_NAME(getArrayRegion); + void (*_Nonnull GetShortArrayRegion)(JNIEnv *_Nonnull, jshortArray, jsize, jsize, jshort *_Nonnull) CF_SWIFT_NAME(getArrayRegion); + void (*_Nonnull GetIntArrayRegion)(JNIEnv *_Nonnull, jintArray, jsize, jsize, jint *_Nonnull) CF_SWIFT_NAME(getArrayRegion); + void (*_Nonnull GetLongArrayRegion)(JNIEnv *_Nonnull, jlongArray, jsize, jsize, jlong *_Nonnull) CF_SWIFT_NAME(getArrayRegion); + void (*_Nonnull GetFloatArrayRegion)(JNIEnv *_Nonnull, jfloatArray, jsize, jsize, jfloat *_Nonnull) CF_SWIFT_NAME(getArrayRegion); + void (*_Nonnull GetDoubleArrayRegion)(JNIEnv *_Nonnull, jdoubleArray, jsize, jsize, jdouble *_Nonnull) CF_SWIFT_NAME(getArrayRegion); /* spec shows these without const; some jni.h do, some don't */ - void (*SetBooleanArrayRegion)(JNIEnv*, jbooleanArray, - jsize, jsize, const jboolean*); - void (*SetByteArrayRegion)(JNIEnv*, jbyteArray, - jsize, jsize, const jbyte*); - void (*SetCharArrayRegion)(JNIEnv*, jcharArray, - jsize, jsize, const jchar*); - void (*SetShortArrayRegion)(JNIEnv*, jshortArray, - jsize, jsize, const jshort*); - void (*SetIntArrayRegion)(JNIEnv*, jintArray, - jsize, jsize, const jint*); - void (*SetLongArrayRegion)(JNIEnv*, jlongArray, - jsize, jsize, const jlong*); - void (*SetFloatArrayRegion)(JNIEnv*, jfloatArray, - jsize, jsize, const jfloat*); - void (*SetDoubleArrayRegion)(JNIEnv*, jdoubleArray, - jsize, jsize, const jdouble*); - - jint (*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*, - jint); - jint (*UnregisterNatives)(JNIEnv*, jclass); - jint (*MonitorEnter)(JNIEnv*, jobject); - jint (*MonitorExit)(JNIEnv*, jobject); - jint (*GetJavaVM)(JNIEnv*, JavaVM**); - - void (*GetStringRegion)(JNIEnv*, jstring, jsize, jsize, jchar*); - void (*GetStringUTFRegion)(JNIEnv*, jstring, jsize, jsize, char*); - - void* (*GetPrimitiveArrayCritical)(JNIEnv*, jarray, jboolean*); - void (*ReleasePrimitiveArrayCritical)(JNIEnv*, jarray, void*, jint); - - const jchar* (*GetStringCritical)(JNIEnv*, jstring, jboolean*); - void (*ReleaseStringCritical)(JNIEnv*, jstring, const jchar*); - - jweak (*NewWeakGlobalRef)(JNIEnv*, jobject); - void (*DeleteWeakGlobalRef)(JNIEnv*, jweak); - - jboolean (*ExceptionCheck)(JNIEnv*); - - jobject (*NewDirectByteBuffer)(JNIEnv*, void*, jlong); - void* (*GetDirectBufferAddress)(JNIEnv*, jobject); - jlong (*GetDirectBufferCapacity)(JNIEnv*, jobject); + void (*_Nonnull SetBooleanArrayRegion)(JNIEnv *_Nonnull, jbooleanArray, jsize, jsize, const jboolean *_Nonnull) CF_SWIFT_NAME(setArrayRegion); + void (*_Nonnull SetByteArrayRegion)(JNIEnv *_Nonnull, jbyteArray, jsize, jsize, const jbyte *_Nonnull) CF_SWIFT_NAME(setArrayRegion); + void (*_Nonnull SetCharArrayRegion)(JNIEnv *_Nonnull, jcharArray, jsize, jsize, const jchar *_Nonnull) CF_SWIFT_NAME(setArrayRegion); + void (*_Nonnull SetShortArrayRegion)(JNIEnv *_Nonnull, jshortArray, jsize, jsize, const jshort *_Nonnull) CF_SWIFT_NAME(setArrayRegion); + void (*_Nonnull SetIntArrayRegion)(JNIEnv *_Nonnull, jintArray, jsize, jsize, const jint *_Nonnull) CF_SWIFT_NAME(setArrayRegion); + void (*_Nonnull SetLongArrayRegion)(JNIEnv *_Nonnull, jlongArray, jsize, jsize, const jlong *_Nonnull) CF_SWIFT_NAME(setArrayRegion); + void (*_Nonnull SetFloatArrayRegion)(JNIEnv *_Nonnull, jfloatArray, jsize, jsize, const jfloat *_Nonnull) CF_SWIFT_NAME(setArrayRegion); + void (*_Nonnull SetDoubleArrayRegion)(JNIEnv *_Nonnull, jdoubleArray, jsize, jsize, const jdouble *_Nonnull) CF_SWIFT_NAME(setArrayRegion); + + jint (*_Nonnull RegisterNatives)(JNIEnv *_Nonnull, jclass, const JNINativeMethod *, jint); + jint (*_Nonnull UnregisterNatives)(JNIEnv *_Nonnull, jclass); + jint (*_Nonnull MonitorEnter)(JNIEnv *_Nonnull, jobject); + jint (*_Nonnull MonitorExit)(JNIEnv *_Nonnull, jobject); + jint (*_Nonnull GetJavaVM)(JNIEnv *_Nonnull, JavaVM **_Nonnull); + + void (*_Nonnull GetStringRegion)(JNIEnv *_Nonnull, jstring, jsize, jsize, jchar *_Nonnull); + void (*_Nonnull GetStringUTFRegion)(JNIEnv *_Nonnull, jstring, jsize, jsize, char *_Nonnull); + + void *(*_Nonnull GetPrimitiveArrayCritical)(JNIEnv *_Nonnull, jarray, jboolean *_Nonnull); + void (*_Nonnull ReleasePrimitiveArrayCritical)(JNIEnv *_Nonnull, jarray, void *, jint); + + const jchar *(*_Nonnull GetStringCritical)(JNIEnv *_Nonnull, jstring, jboolean *_Nonnull); + void (*_Nonnull ReleaseStringCritical)(JNIEnv *_Nonnull, jstring, const jchar *_Nonnull); + + jweak (*_Nonnull NewWeakGlobalRef)(JNIEnv *_Nonnull, jobject); + void (*_Nonnull DeleteWeakGlobalRef)(JNIEnv *_Nonnull, jweak); + + jboolean (*_Nonnull ExceptionCheck)(JNIEnv *_Nonnull); + + jobject (*_Nonnull NewDirectByteBuffer)(JNIEnv *_Nonnull, void *_Nonnull, jlong); + void *_Nullable (*_Nonnull GetDirectBufferAddress)(JNIEnv *_Nonnull, jobject); + jlong (*_Nonnull GetDirectBufferCapacity)(JNIEnv *_Nonnull, jobject); /* added in JNI 1.6 */ - jobjectRefType (*GetObjectRefType)(JNIEnv*, jobject); + jobjectRefType (*_Nonnull GetObjectRefType)(JNIEnv *_Nonnull, jobject); }; /* @@ -502,84 +475,133 @@ struct JNINativeInterface { * This is usually overlaid on a C struct whose first element is a * JNINativeInterface*. We rely somewhat on compiler behavior. */ -struct _JNIEnv { +struct _JNIEnv +{ /* do not rename this; it does not seem to be entirely opaque */ - const struct JNINativeInterface* functions; + const struct JNINativeInterface *_Nonnull functions; #if defined(__cplusplus) jint GetVersion() - { return functions->GetVersion(this); } + { + return functions->GetVersion(this); + } - jclass DefineClass(const char *name, jobject loader, const jbyte* buf, - jsize bufLen) - { return functions->DefineClass(this, name, loader, buf, bufLen); } + jclass DefineClass(const char *_Nonnullname, jobject loader, const jbyte *buf, + jsize bufLen) + { + return functions->DefineClass(this, name, loader, buf, bufLen); + } - jclass FindClass(const char* name) - { return functions->FindClass(this, name); } + jclass FindClass(const char *name) + { + return functions->FindClass(this, name); + } jmethodID FromReflectedMethod(jobject method) - { return functions->FromReflectedMethod(this, method); } + { + return functions->FromReflectedMethod(this, method); + } jfieldID FromReflectedField(jobject field) - { return functions->FromReflectedField(this, field); } + { + return functions->FromReflectedField(this, field); + } jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) - { return functions->ToReflectedMethod(this, cls, methodID, isStatic); } + { + return functions->ToReflectedMethod(this, cls, methodID, isStatic); + } jclass GetSuperclass(jclass clazz) - { return functions->GetSuperclass(this, clazz); } + { + return functions->GetSuperclass(this, clazz); + } jboolean IsAssignableFrom(jclass clazz1, jclass clazz2) - { return functions->IsAssignableFrom(this, clazz1, clazz2); } + { + return functions->IsAssignableFrom(this, clazz1, clazz2); + } jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) - { return functions->ToReflectedField(this, cls, fieldID, isStatic); } + { + return functions->ToReflectedField(this, cls, fieldID, isStatic); + } jint Throw(jthrowable obj) - { return functions->Throw(this, obj); } + { + return functions->Throw(this, obj); + } - jint ThrowNew(jclass clazz, const char* message) - { return functions->ThrowNew(this, clazz, message); } + jint ThrowNew(jclass clazz, const char *message) + { + return functions->ThrowNew(this, clazz, message); + } jthrowable ExceptionOccurred() - { return functions->ExceptionOccurred(this); } + { + return functions->ExceptionOccurred(this); + } void ExceptionDescribe() - { functions->ExceptionDescribe(this); } + { + functions->ExceptionDescribe(this); + } void ExceptionClear() - { functions->ExceptionClear(this); } + { + functions->ExceptionClear(this); + } - void FatalError(const char* msg) - { functions->FatalError(this, msg); } + void FatalError(const char *msg) + { + functions->FatalError(this, msg); + } jint PushLocalFrame(jint capacity) - { return functions->PushLocalFrame(this, capacity); } + { + return functions->PushLocalFrame(this, capacity); + } jobject PopLocalFrame(jobject result) - { return functions->PopLocalFrame(this, result); } + { + return functions->PopLocalFrame(this, result); + } jobject NewGlobalRef(jobject obj) - { return functions->NewGlobalRef(this, obj); } + { + return functions->NewGlobalRef(this, obj); + } void DeleteGlobalRef(jobject globalRef) - { functions->DeleteGlobalRef(this, globalRef); } + { + functions->DeleteGlobalRef(this, globalRef); + } void DeleteLocalRef(jobject localRef) - { functions->DeleteLocalRef(this, localRef); } + { + functions->DeleteLocalRef(this, localRef); + } jboolean IsSameObject(jobject ref1, jobject ref2) - { return functions->IsSameObject(this, ref1, ref2); } + { + return functions->IsSameObject(this, ref1, ref2); + } jobject NewLocalRef(jobject ref) - { return functions->NewLocalRef(this, ref); } + { + return functions->NewLocalRef(this, ref); + } jint EnsureLocalCapacity(jint capacity) - { return functions->EnsureLocalCapacity(this, capacity); } + { + return functions->EnsureLocalCapacity(this, capacity); + } jobject AllocObject(jclass clazz) - { return functions->AllocObject(this, clazz); } + { + return functions->AllocObject(this, clazz); + } jobject NewObject(jclass clazz, jmethodID methodID, ...) { @@ -591,46 +613,57 @@ struct _JNIEnv { } jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args) - { return functions->NewObjectV(this, clazz, methodID, args); } + { + return functions->NewObjectV(this, clazz, methodID, args); + } - jobject NewObjectA(jclass clazz, jmethodID methodID, jvalue* args) - { return functions->NewObjectA(this, clazz, methodID, args); } + jobject NewObjectA(jclass clazz, jmethodID methodID, const jvalue *_Nonnull args) + { + return functions->NewObjectA(this, clazz, methodID, args); + } jclass GetObjectClass(jobject obj) - { return functions->GetObjectClass(this, obj); } + { + return functions->GetObjectClass(this, obj); + } jboolean IsInstanceOf(jobject obj, jclass clazz) - { return functions->IsInstanceOf(this, obj, clazz); } + { + return functions->IsInstanceOf(this, obj, clazz); + } - jmethodID GetMethodID(jclass clazz, const char* name, const char* sig) - { return functions->GetMethodID(this, clazz, name, sig); } + jmethodID GetMethodID(jclass clazz, const char *name, const char *sig) + { + return functions->GetMethodID(this, clazz, name, sig); + } -#define CALL_TYPE_METHOD(_jtype, _jname) \ - \ - _jtype Call##_jname##Method(jobject obj, jmethodID methodID, ...) \ - { \ - _jtype result; \ - va_list args; \ - va_start(args, methodID); \ - result = functions->Call##_jname##MethodV(this, obj, methodID, \ - args); \ - va_end(args); \ - return result; \ +#define CALL_TYPE_METHOD(_jtype, _jname) \ + \ _jtype Call##_jname##Method(jobject obj, jmethodID methodID, ...) \ + { \ + _jtype result; \ + va_list args; \ + va_start(args, methodID); \ + result = functions->Call##_jname##MethodV(this, obj, methodID, \ + args); \ + va_end(args); \ + return result; \ } #define CALL_TYPE_METHODV(_jtype, _jname) \ - \ - _jtype Call##_jname##MethodV(jobject obj, jmethodID methodID, \ - va_list args) \ - { return functions->Call##_jname##MethodV(this, obj, methodID, args); } + \ _jtype Call##_jname##MethodV(jobject obj, jmethodID methodID, \ + va_list args) \ + { \ + return functions->Call##_jname##MethodV(this, obj, methodID, args); \ + } #define CALL_TYPE_METHODA(_jtype, _jname) \ - \ - _jtype Call##_jname##MethodA(jobject obj, jmethodID methodID, \ - jvalue* args) \ - { return functions->Call##_jname##MethodA(this, obj, methodID, args); } - -#define CALL_TYPE(_jtype, _jname) \ - CALL_TYPE_METHOD(_jtype, _jname) \ - CALL_TYPE_METHODV(_jtype, _jname) \ + \ _jtype Call##_jname##MethodA(jobject obj, jmethodID methodID, \ + const jvalue *_Nonnull args) \ + { \ + return functions->Call##_jname##MethodA(this, obj, methodID, args); \ + } + +#define CALL_TYPE(_jtype, _jname) \ + CALL_TYPE_METHOD(_jtype, _jname) \ + CALL_TYPE_METHODV(_jtype, _jname) \ CALL_TYPE_METHODA(_jtype, _jname) CALL_TYPE(jobject, Object) @@ -651,39 +684,44 @@ struct _JNIEnv { va_end(args); } void CallVoidMethodV(jobject obj, jmethodID methodID, va_list args) - { functions->CallVoidMethodV(this, obj, methodID, args); } - void CallVoidMethodA(jobject obj, jmethodID methodID, jvalue* args) - { functions->CallVoidMethodA(this, obj, methodID, args); } - -#define CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ - \ - _jtype CallNonvirtual##_jname##Method(jobject obj, jclass clazz, \ - jmethodID methodID, ...) \ - { \ - _jtype result; \ - va_list args; \ - va_start(args, methodID); \ - result = functions->CallNonvirtual##_jname##MethodV(this, obj, \ - clazz, methodID, args); \ - va_end(args); \ - return result; \ - } -#define CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ - \ - _jtype CallNonvirtual##_jname##MethodV(jobject obj, jclass clazz, \ - jmethodID methodID, va_list args) \ - { return functions->CallNonvirtual##_jname##MethodV(this, obj, clazz, \ - methodID, args); } -#define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) \ - \ - _jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz, \ - jmethodID methodID, jvalue* args) \ - { return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz, \ - methodID, args); } - -#define CALL_NONVIRT_TYPE(_jtype, _jname) \ - CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ - CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ + { + functions->CallVoidMethodV(this, obj, methodID, args); + } + void CallVoidMethodA(jobject obj, jmethodID methodID, const jvalue *_Nonnull args) + { + functions->CallVoidMethodA(this, obj, methodID, args); + } + +#define CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ + \ _jtype CallNonvirtual##_jname##Method(jobject obj, jclass clazz, \ + jmethodID methodID, ...) \ + { \ + _jtype result; \ + va_list args; \ + va_start(args, methodID); \ + result = functions->CallNonvirtual##_jname##MethodV(this, obj, \ + clazz, methodID, args); \ + va_end(args); \ + return result; \ + } +#define CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ + \ _jtype CallNonvirtual##_jname##MethodV(jobject obj, jclass clazz, \ + jmethodID methodID, va_list args) \ + { \ + return functions->CallNonvirtual##_jname##MethodV(this, obj, clazz, \ + methodID, args); \ + } +#define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) \ + \ _jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz, \ + jmethodID methodID, const jvalue *_Nonnull args) \ + { \ + return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz, \ + methodID, args); \ + } + +#define CALL_NONVIRT_TYPE(_jtype, _jname) \ + CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ + CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) CALL_NONVIRT_TYPE(jobject, Object) @@ -697,7 +735,7 @@ struct _JNIEnv { CALL_NONVIRT_TYPE(jdouble, Double) void CallNonvirtualVoidMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) + jmethodID methodID, ...) { va_list args; va_start(args, methodID); @@ -705,89 +743,134 @@ struct _JNIEnv { va_end(args); } void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, - jmethodID methodID, va_list args) - { functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); } + jmethodID methodID, va_list args) + { + functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); + } void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, - jmethodID methodID, jvalue* args) - { functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); } + jmethodID methodID, const jvalue *_Nonnull args) + { + functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); + } - jfieldID GetFieldID(jclass clazz, const char* name, const char* sig) - { return functions->GetFieldID(this, clazz, name, sig); } + jfieldID GetFieldID(jclass clazz, const char *name, const char *sig) + { + return functions->GetFieldID(this, clazz, name, sig); + } jobject GetObjectField(jobject obj, jfieldID fieldID) - { return functions->GetObjectField(this, obj, fieldID); } + { + return functions->GetObjectField(this, obj, fieldID); + } jboolean GetBooleanField(jobject obj, jfieldID fieldID) - { return functions->GetBooleanField(this, obj, fieldID); } + { + return functions->GetBooleanField(this, obj, fieldID); + } jbyte GetByteField(jobject obj, jfieldID fieldID) - { return functions->GetByteField(this, obj, fieldID); } + { + return functions->GetByteField(this, obj, fieldID); + } jchar GetCharField(jobject obj, jfieldID fieldID) - { return functions->GetCharField(this, obj, fieldID); } + { + return functions->GetCharField(this, obj, fieldID); + } jshort GetShortField(jobject obj, jfieldID fieldID) - { return functions->GetShortField(this, obj, fieldID); } + { + return functions->GetShortField(this, obj, fieldID); + } jint GetIntField(jobject obj, jfieldID fieldID) - { return functions->GetIntField(this, obj, fieldID); } + { + return functions->GetIntField(this, obj, fieldID); + } jlong GetLongField(jobject obj, jfieldID fieldID) - { return functions->GetLongField(this, obj, fieldID); } - + { + return functions->GetLongField(this, obj, fieldID); + } + jfloat GetFloatField(jobject obj, jfieldID fieldID) - { return functions->GetFloatField(this, obj, fieldID); } - + { + return functions->GetFloatField(this, obj, fieldID); + } + jdouble GetDoubleField(jobject obj, jfieldID fieldID) - { return functions->GetDoubleField(this, obj, fieldID); } + { + return functions->GetDoubleField(this, obj, fieldID); + } void SetObjectField(jobject obj, jfieldID fieldID, jobject value) - { functions->SetObjectField(this, obj, fieldID, value); } + { + functions->SetObjectField(this, obj, fieldID, value); + } void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value) - { functions->SetBooleanField(this, obj, fieldID, value); } + { + functions->SetBooleanField(this, obj, fieldID, value); + } void SetByteField(jobject obj, jfieldID fieldID, jbyte value) - { functions->SetByteField(this, obj, fieldID, value); } + { + functions->SetByteField(this, obj, fieldID, value); + } void SetCharField(jobject obj, jfieldID fieldID, jchar value) - { functions->SetCharField(this, obj, fieldID, value); } + { + functions->SetCharField(this, obj, fieldID, value); + } void SetShortField(jobject obj, jfieldID fieldID, jshort value) - { functions->SetShortField(this, obj, fieldID, value); } + { + functions->SetShortField(this, obj, fieldID, value); + } void SetIntField(jobject obj, jfieldID fieldID, jint value) - { functions->SetIntField(this, obj, fieldID, value); } + { + functions->SetIntField(this, obj, fieldID, value); + } void SetLongField(jobject obj, jfieldID fieldID, jlong value) - { functions->SetLongField(this, obj, fieldID, value); } - + { + functions->SetLongField(this, obj, fieldID, value); + } + void SetFloatField(jobject obj, jfieldID fieldID, jfloat value) - { functions->SetFloatField(this, obj, fieldID, value); } - + { + functions->SetFloatField(this, obj, fieldID, value); + } + void SetDoubleField(jobject obj, jfieldID fieldID, jdouble value) - { functions->SetDoubleField(this, obj, fieldID, value); } + { + functions->SetDoubleField(this, obj, fieldID, value); + } - jmethodID GetStaticMethodID(jclass clazz, const char* name, const char* sig) - { return functions->GetStaticMethodID(this, clazz, name, sig); } + jmethodID GetStaticMethodID(jclass clazz, const char *name, const char *sig) + { + return functions->GetStaticMethodID(this, clazz, name, sig); + } -#define CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ - \ - _jtype CallStatic##_jname##Method(jclass clazz, jmethodID methodID, \ - ...) \ - { \ - _jtype result; \ - va_list args; \ - va_start(args, methodID); \ - result = functions->CallStatic##_jname##MethodV(this, clazz, \ - methodID, args); \ - va_end(args); \ - return result; \ - } -#define CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ - \ - _jtype CallStatic##_jname##MethodV(jclass clazz, jmethodID methodID, \ - va_list args) \ - { return functions->CallStatic##_jname##MethodV(this, clazz, methodID, \ - args); } -#define CALL_STATIC_TYPE_METHODA(_jtype, _jname) \ - \ - _jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID, \ - jvalue* args) \ - { return functions->CallStatic##_jname##MethodA(this, clazz, methodID, \ - args); } - -#define CALL_STATIC_TYPE(_jtype, _jname) \ - CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ - CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ +#define CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ + \ _jtype CallStatic##_jname##Method(jclass clazz, jmethodID methodID, \ + ...) \ + { \ + _jtype result; \ + va_list args; \ + va_start(args, methodID); \ + result = functions->CallStatic##_jname##MethodV(this, clazz, \ + methodID, args); \ + va_end(args); \ + return result; \ + } +#define CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ + \ _jtype CallStatic##_jname##MethodV(jclass clazz, jmethodID methodID, \ + va_list args) \ + { \ + return functions->CallStatic##_jname##MethodV(this, clazz, methodID, \ + args); \ + } +#define CALL_STATIC_TYPE_METHODA(_jtype, _jname) \ + \ _jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID, \ + const jvalue *_Nonnull args) \ + { \ + return functions->CallStatic##_jname##MethodA(this, clazz, methodID, \ + args); \ + } + +#define CALL_STATIC_TYPE(_jtype, _jname) \ + CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ + CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ CALL_STATIC_TYPE_METHODA(_jtype, _jname) CALL_STATIC_TYPE(jobject, Object) @@ -808,300 +891,494 @@ struct _JNIEnv { va_end(args); } void CallStaticVoidMethodV(jclass clazz, jmethodID methodID, va_list args) - { functions->CallStaticVoidMethodV(this, clazz, methodID, args); } - void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, jvalue* args) - { functions->CallStaticVoidMethodA(this, clazz, methodID, args); } + { + functions->CallStaticVoidMethodV(this, clazz, methodID, args); + } + void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, const jvalue *_Nonnull args) + { + functions->CallStaticVoidMethodA(this, clazz, methodID, args); + } - jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig) - { return functions->GetStaticFieldID(this, clazz, name, sig); } + jfieldID GetStaticFieldID(jclass clazz, const char *name, const char *sig) + { + return functions->GetStaticFieldID(this, clazz, name, sig); + } jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) - { return functions->GetStaticObjectField(this, clazz, fieldID); } + { + return functions->GetStaticObjectField(this, clazz, fieldID); + } jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) - { return functions->GetStaticBooleanField(this, clazz, fieldID); } + { + return functions->GetStaticBooleanField(this, clazz, fieldID); + } jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) - { return functions->GetStaticByteField(this, clazz, fieldID); } + { + return functions->GetStaticByteField(this, clazz, fieldID); + } jchar GetStaticCharField(jclass clazz, jfieldID fieldID) - { return functions->GetStaticCharField(this, clazz, fieldID); } + { + return functions->GetStaticCharField(this, clazz, fieldID); + } jshort GetStaticShortField(jclass clazz, jfieldID fieldID) - { return functions->GetStaticShortField(this, clazz, fieldID); } + { + return functions->GetStaticShortField(this, clazz, fieldID); + } jint GetStaticIntField(jclass clazz, jfieldID fieldID) - { return functions->GetStaticIntField(this, clazz, fieldID); } + { + return functions->GetStaticIntField(this, clazz, fieldID); + } jlong GetStaticLongField(jclass clazz, jfieldID fieldID) - { return functions->GetStaticLongField(this, clazz, fieldID); } - + { + return functions->GetStaticLongField(this, clazz, fieldID); + } + jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) - { return functions->GetStaticFloatField(this, clazz, fieldID); } - + { + return functions->GetStaticFloatField(this, clazz, fieldID); + } + jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) - { return functions->GetStaticDoubleField(this, clazz, fieldID); } + { + return functions->GetStaticDoubleField(this, clazz, fieldID); + } void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value) - { functions->SetStaticObjectField(this, clazz, fieldID, value); } + { + functions->SetStaticObjectField(this, clazz, fieldID, value); + } void SetStaticBooleanField(jclass clazz, jfieldID fieldID, jboolean value) - { functions->SetStaticBooleanField(this, clazz, fieldID, value); } + { + functions->SetStaticBooleanField(this, clazz, fieldID, value); + } void SetStaticByteField(jclass clazz, jfieldID fieldID, jbyte value) - { functions->SetStaticByteField(this, clazz, fieldID, value); } + { + functions->SetStaticByteField(this, clazz, fieldID, value); + } void SetStaticCharField(jclass clazz, jfieldID fieldID, jchar value) - { functions->SetStaticCharField(this, clazz, fieldID, value); } + { + functions->SetStaticCharField(this, clazz, fieldID, value); + } void SetStaticShortField(jclass clazz, jfieldID fieldID, jshort value) - { functions->SetStaticShortField(this, clazz, fieldID, value); } + { + functions->SetStaticShortField(this, clazz, fieldID, value); + } void SetStaticIntField(jclass clazz, jfieldID fieldID, jint value) - { functions->SetStaticIntField(this, clazz, fieldID, value); } + { + functions->SetStaticIntField(this, clazz, fieldID, value); + } void SetStaticLongField(jclass clazz, jfieldID fieldID, jlong value) - { functions->SetStaticLongField(this, clazz, fieldID, value); } - + { + functions->SetStaticLongField(this, clazz, fieldID, value); + } + void SetStaticFloatField(jclass clazz, jfieldID fieldID, jfloat value) - { functions->SetStaticFloatField(this, clazz, fieldID, value); } - + { + functions->SetStaticFloatField(this, clazz, fieldID, value); + } + void SetStaticDoubleField(jclass clazz, jfieldID fieldID, jdouble value) - { functions->SetStaticDoubleField(this, clazz, fieldID, value); } + { + functions->SetStaticDoubleField(this, clazz, fieldID, value); + } - jstring NewString(const jchar* unicodeChars, jsize len) - { return functions->NewString(this, unicodeChars, len); } + jstring NewString(const jchar *unicodeChars, jsize len) + { + return functions->NewString(this, unicodeChars, len); + } jsize GetStringLength(jstring string) - { return functions->GetStringLength(this, string); } + { + return functions->GetStringLength(this, string); + } - const jchar* GetStringChars(jstring string, jboolean* isCopy) - { return functions->GetStringChars(this, string, isCopy); } + const jchar *GetStringChars(jstring string, jboolean *isCopy) + { + return functions->GetStringChars(this, string, isCopy); + } - void ReleaseStringChars(jstring string, const jchar* chars) - { functions->ReleaseStringChars(this, string, chars); } + void ReleaseStringChars(jstring string, const jchar *chars) + { + functions->ReleaseStringChars(this, string, chars); + } - jstring NewStringUTF(const char* bytes) - { return functions->NewStringUTF(this, bytes); } + jstring NewStringUTF(const char *bytes) + { + return functions->NewStringUTF(this, bytes); + } jsize GetStringUTFLength(jstring string) - { return functions->GetStringUTFLength(this, string); } + { + return functions->GetStringUTFLength(this, string); + } - const char* GetStringUTFChars(jstring string, jboolean* isCopy) - { return functions->GetStringUTFChars(this, string, isCopy); } + const char *GetStringUTFChars(jstring string, jboolean *isCopy) + { + return functions->GetStringUTFChars(this, string, isCopy); + } - void ReleaseStringUTFChars(jstring string, const char* utf) - { functions->ReleaseStringUTFChars(this, string, utf); } + void ReleaseStringUTFChars(jstring string, const char *utf) + { + functions->ReleaseStringUTFChars(this, string, utf); + } jsize GetArrayLength(jarray array) - { return functions->GetArrayLength(this, array); } + { + return functions->GetArrayLength(this, array); + } jobjectArray NewObjectArray(jsize length, jclass elementClass, - jobject initialElement) - { return functions->NewObjectArray(this, length, elementClass, - initialElement); } + jobject initialElement) + { + return functions->NewObjectArray(this, length, elementClass, + initialElement); + } jobject GetObjectArrayElement(jobjectArray array, jsize index) - { return functions->GetObjectArrayElement(this, array, index); } + { + return functions->GetObjectArrayElement(this, array, index); + } void SetObjectArrayElement(jobjectArray array, jsize index, jobject value) - { functions->SetObjectArrayElement(this, array, index, value); } + { + functions->SetObjectArrayElement(this, array, index, value); + } jbooleanArray NewBooleanArray(jsize length) - { return functions->NewBooleanArray(this, length); } + { + return functions->NewBooleanArray(this, length); + } jbyteArray NewByteArray(jsize length) - { return functions->NewByteArray(this, length); } + { + return functions->NewByteArray(this, length); + } jcharArray NewCharArray(jsize length) - { return functions->NewCharArray(this, length); } + { + return functions->NewCharArray(this, length); + } jshortArray NewShortArray(jsize length) - { return functions->NewShortArray(this, length); } + { + return functions->NewShortArray(this, length); + } jintArray NewIntArray(jsize length) - { return functions->NewIntArray(this, length); } + { + return functions->NewIntArray(this, length); + } jlongArray NewLongArray(jsize length) - { return functions->NewLongArray(this, length); } + { + return functions->NewLongArray(this, length); + } jfloatArray NewFloatArray(jsize length) - { return functions->NewFloatArray(this, length); } + { + return functions->NewFloatArray(this, length); + } jdoubleArray NewDoubleArray(jsize length) - { return functions->NewDoubleArray(this, length); } - - jboolean* GetBooleanArrayElements(jbooleanArray array, jboolean* isCopy) - { return functions->GetBooleanArrayElements(this, array, isCopy); } - jbyte* GetByteArrayElements(jbyteArray array, jboolean* isCopy) - { return functions->GetByteArrayElements(this, array, isCopy); } - jchar* GetCharArrayElements(jcharArray array, jboolean* isCopy) - { return functions->GetCharArrayElements(this, array, isCopy); } - jshort* GetShortArrayElements(jshortArray array, jboolean* isCopy) - { return functions->GetShortArrayElements(this, array, isCopy); } - jint* GetIntArrayElements(jintArray array, jboolean* isCopy) - { return functions->GetIntArrayElements(this, array, isCopy); } - jlong* GetLongArrayElements(jlongArray array, jboolean* isCopy) - { return functions->GetLongArrayElements(this, array, isCopy); } - jfloat* GetFloatArrayElements(jfloatArray array, jboolean* isCopy) - { return functions->GetFloatArrayElements(this, array, isCopy); } - jdouble* GetDoubleArrayElements(jdoubleArray array, jboolean* isCopy) - { return functions->GetDoubleArrayElements(this, array, isCopy); } - - void ReleaseBooleanArrayElements(jbooleanArray array, jboolean* elems, - jint mode) - { functions->ReleaseBooleanArrayElements(this, array, elems, mode); } - void ReleaseByteArrayElements(jbyteArray array, jbyte* elems, - jint mode) - { functions->ReleaseByteArrayElements(this, array, elems, mode); } - void ReleaseCharArrayElements(jcharArray array, jchar* elems, - jint mode) - { functions->ReleaseCharArrayElements(this, array, elems, mode); } - void ReleaseShortArrayElements(jshortArray array, jshort* elems, - jint mode) - { functions->ReleaseShortArrayElements(this, array, elems, mode); } - void ReleaseIntArrayElements(jintArray array, jint* elems, - jint mode) - { functions->ReleaseIntArrayElements(this, array, elems, mode); } - void ReleaseLongArrayElements(jlongArray array, jlong* elems, - jint mode) - { functions->ReleaseLongArrayElements(this, array, elems, mode); } - void ReleaseFloatArrayElements(jfloatArray array, jfloat* elems, - jint mode) - { functions->ReleaseFloatArrayElements(this, array, elems, mode); } - void ReleaseDoubleArrayElements(jdoubleArray array, jdouble* elems, - jint mode) - { functions->ReleaseDoubleArrayElements(this, array, elems, mode); } + { + return functions->NewDoubleArray(this, length); + } + + jboolean *GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) + { + return functions->GetBooleanArrayElements(this, array, isCopy); + } + jbyte *GetByteArrayElements(jbyteArray array, jboolean *isCopy) + { + return functions->GetByteArrayElements(this, array, isCopy); + } + jchar *GetCharArrayElements(jcharArray array, jboolean *isCopy) + { + return functions->GetCharArrayElements(this, array, isCopy); + } + jshort *GetShortArrayElements(jshortArray array, jboolean *isCopy) + { + return functions->GetShortArrayElements(this, array, isCopy); + } + jint *GetIntArrayElements(jintArray array, jboolean *isCopy) + { + return functions->GetIntArrayElements(this, array, isCopy); + } + jlong *GetLongArrayElements(jlongArray array, jboolean *isCopy) + { + return functions->GetLongArrayElements(this, array, isCopy); + } + jfloat *GetFloatArrayElements(jfloatArray array, jboolean *isCopy) + { + return functions->GetFloatArrayElements(this, array, isCopy); + } + jdouble *GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) + { + return functions->GetDoubleArrayElements(this, array, isCopy); + } + + void ReleaseBooleanArrayElements(jbooleanArray array, jboolean *elems, + jint mode) + { + functions->ReleaseBooleanArrayElements(this, array, elems, mode); + } + void ReleaseByteArrayElements(jbyteArray array, jbyte *elems, + jint mode) + { + functions->ReleaseByteArrayElements(this, array, elems, mode); + } + void ReleaseCharArrayElements(jcharArray array, jchar *elems, + jint mode) + { + functions->ReleaseCharArrayElements(this, array, elems, mode); + } + void ReleaseShortArrayElements(jshortArray array, jshort *elems, + jint mode) + { + functions->ReleaseShortArrayElements(this, array, elems, mode); + } + void ReleaseIntArrayElements(jintArray array, jint *elems, + jint mode) + { + functions->ReleaseIntArrayElements(this, array, elems, mode); + } + void ReleaseLongArrayElements(jlongArray array, jlong *elems, + jint mode) + { + functions->ReleaseLongArrayElements(this, array, elems, mode); + } + void ReleaseFloatArrayElements(jfloatArray array, jfloat *elems, + jint mode) + { + functions->ReleaseFloatArrayElements(this, array, elems, mode); + } + void ReleaseDoubleArrayElements(jdoubleArray array, jdouble *elems, + jint mode) + { + functions->ReleaseDoubleArrayElements(this, array, elems, mode); + } void GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, - jboolean* buf) - { functions->GetBooleanArrayRegion(this, array, start, len, buf); } + jboolean *buf) + { + functions->GetBooleanArrayRegion(this, array, start, len, buf); + } void GetByteArrayRegion(jbyteArray array, jsize start, jsize len, - jbyte* buf) - { functions->GetByteArrayRegion(this, array, start, len, buf); } + jbyte *buf) + { + functions->GetByteArrayRegion(this, array, start, len, buf); + } void GetCharArrayRegion(jcharArray array, jsize start, jsize len, - jchar* buf) - { functions->GetCharArrayRegion(this, array, start, len, buf); } + jchar *buf) + { + functions->GetCharArrayRegion(this, array, start, len, buf); + } void GetShortArrayRegion(jshortArray array, jsize start, jsize len, - jshort* buf) - { functions->GetShortArrayRegion(this, array, start, len, buf); } + jshort *buf) + { + functions->GetShortArrayRegion(this, array, start, len, buf); + } void GetIntArrayRegion(jintArray array, jsize start, jsize len, - jint* buf) - { functions->GetIntArrayRegion(this, array, start, len, buf); } + jint *buf) + { + functions->GetIntArrayRegion(this, array, start, len, buf); + } void GetLongArrayRegion(jlongArray array, jsize start, jsize len, - jlong* buf) - { functions->GetLongArrayRegion(this, array, start, len, buf); } + jlong *buf) + { + functions->GetLongArrayRegion(this, array, start, len, buf); + } void GetFloatArrayRegion(jfloatArray array, jsize start, jsize len, - jfloat* buf) - { functions->GetFloatArrayRegion(this, array, start, len, buf); } + jfloat *buf) + { + functions->GetFloatArrayRegion(this, array, start, len, buf); + } void GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, - jdouble* buf) - { functions->GetDoubleArrayRegion(this, array, start, len, buf); } + jdouble *buf) + { + functions->GetDoubleArrayRegion(this, array, start, len, buf); + } void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, - const jboolean* buf) - { functions->SetBooleanArrayRegion(this, array, start, len, buf); } + const jboolean *buf) + { + functions->SetBooleanArrayRegion(this, array, start, len, buf); + } void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, - const jbyte* buf) - { functions->SetByteArrayRegion(this, array, start, len, buf); } + const jbyte *buf) + { + functions->SetByteArrayRegion(this, array, start, len, buf); + } void SetCharArrayRegion(jcharArray array, jsize start, jsize len, - const jchar* buf) - { functions->SetCharArrayRegion(this, array, start, len, buf); } + const jchar *buf) + { + functions->SetCharArrayRegion(this, array, start, len, buf); + } void SetShortArrayRegion(jshortArray array, jsize start, jsize len, - const jshort* buf) - { functions->SetShortArrayRegion(this, array, start, len, buf); } + const jshort *buf) + { + functions->SetShortArrayRegion(this, array, start, len, buf); + } void SetIntArrayRegion(jintArray array, jsize start, jsize len, - const jint* buf) - { functions->SetIntArrayRegion(this, array, start, len, buf); } + const jint *buf) + { + functions->SetIntArrayRegion(this, array, start, len, buf); + } void SetLongArrayRegion(jlongArray array, jsize start, jsize len, - const jlong* buf) - { functions->SetLongArrayRegion(this, array, start, len, buf); } + const jlong *buf) + { + functions->SetLongArrayRegion(this, array, start, len, buf); + } void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, - const jfloat* buf) - { functions->SetFloatArrayRegion(this, array, start, len, buf); } + const jfloat *buf) + { + functions->SetFloatArrayRegion(this, array, start, len, buf); + } void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, - const jdouble* buf) - { functions->SetDoubleArrayRegion(this, array, start, len, buf); } + const jdouble *buf) + { + functions->SetDoubleArrayRegion(this, array, start, len, buf); + } - jint RegisterNatives(jclass clazz, const JNINativeMethod* methods, - jint nMethods) - { return functions->RegisterNatives(this, clazz, methods, nMethods); } + jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, + jint nMethods) + { + return functions->RegisterNatives(this, clazz, methods, nMethods); + } jint UnregisterNatives(jclass clazz) - { return functions->UnregisterNatives(this, clazz); } + { + return functions->UnregisterNatives(this, clazz); + } jint MonitorEnter(jobject obj) - { return functions->MonitorEnter(this, obj); } + { + return functions->MonitorEnter(this, obj); + } jint MonitorExit(jobject obj) - { return functions->MonitorExit(this, obj); } + { + return functions->MonitorExit(this, obj); + } - jint GetJavaVM(JavaVM** vm) - { return functions->GetJavaVM(this, vm); } + jint GetJavaVM(JavaVM **vm) + { + return functions->GetJavaVM(this, vm); + } - void GetStringRegion(jstring str, jsize start, jsize len, jchar* buf) - { functions->GetStringRegion(this, str, start, len, buf); } + void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) + { + functions->GetStringRegion(this, str, start, len, buf); + } - void GetStringUTFRegion(jstring str, jsize start, jsize len, char* buf) - { return functions->GetStringUTFRegion(this, str, start, len, buf); } + void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) + { + return functions->GetStringUTFRegion(this, str, start, len, buf); + } - void* GetPrimitiveArrayCritical(jarray array, jboolean* isCopy) - { return functions->GetPrimitiveArrayCritical(this, array, isCopy); } + void *GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) + { + return functions->GetPrimitiveArrayCritical(this, array, isCopy); + } - void ReleasePrimitiveArrayCritical(jarray array, void* carray, jint mode) - { functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); } + void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) + { + functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); + } - const jchar* GetStringCritical(jstring string, jboolean* isCopy) - { return functions->GetStringCritical(this, string, isCopy); } + const jchar *GetStringCritical(jstring string, jboolean *isCopy) + { + return functions->GetStringCritical(this, string, isCopy); + } - void ReleaseStringCritical(jstring string, const jchar* carray) - { functions->ReleaseStringCritical(this, string, carray); } + void ReleaseStringCritical(jstring string, const jchar *carray) + { + functions->ReleaseStringCritical(this, string, carray); + } jweak NewWeakGlobalRef(jobject obj) - { return functions->NewWeakGlobalRef(this, obj); } + { + return functions->NewWeakGlobalRef(this, obj); + } void DeleteWeakGlobalRef(jweak obj) - { functions->DeleteWeakGlobalRef(this, obj); } + { + functions->DeleteWeakGlobalRef(this, obj); + } jboolean ExceptionCheck() - { return functions->ExceptionCheck(this); } + { + return functions->ExceptionCheck(this); + } - jobject NewDirectByteBuffer(void* address, jlong capacity) - { return functions->NewDirectByteBuffer(this, address, capacity); } + jobject NewDirectByteBuffer(void *address, jlong capacity) + { + return functions->NewDirectByteBuffer(this, address, capacity); + } - void* GetDirectBufferAddress(jobject buf) - { return functions->GetDirectBufferAddress(this, buf); } + void *GetDirectBufferAddress(jobject buf) + { + return functions->GetDirectBufferAddress(this, buf); + } jlong GetDirectBufferCapacity(jobject buf) - { return functions->GetDirectBufferCapacity(this, buf); } + { + return functions->GetDirectBufferCapacity(this, buf); + } /* added in JNI 1.6 */ jobjectRefType GetObjectRefType(jobject obj) - { return functions->GetObjectRefType(this, obj); } + { + return functions->GetObjectRefType(this, obj); + } #endif /*__cplusplus*/ }; - /* * JNI invocation interface. */ -struct JNIInvokeInterface { - void* reserved0; - void* reserved1; - void* reserved2; - - jint (*DestroyJavaVM)(JavaVM*); - jint (*AttachCurrentThread)(JavaVM*, JNIEnv**, void*); - jint (*DetachCurrentThread)(JavaVM*); - jint (*GetEnv)(JavaVM*, void**, jint); - jint (*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*); +struct JNIInvokeInterface +{ + void *reserved0; + void *reserved1; + void *reserved2; + + jint (*_Nonnull DestroyJavaVM)(JavaVM *_Nonnull); + jint (*_Nonnull AttachCurrentThread)(JavaVM *, JNIEnv **, void *_Nonnull); + jint (*_Nonnull DetachCurrentThread)(JavaVM *_Nonnull); + jint (*_Nonnull GetEnv)(JavaVM *, void **, jint); + jint (*_Nonnull AttachCurrentThreadAsDaemon)(JavaVM *, JNIEnv **, void *_Nonnull); }; /* * C++ version. */ -struct _JavaVM { - const struct JNIInvokeInterface* functions; +struct _JavaVM +{ + const struct JNIInvokeInterface *functions; #if defined(__cplusplus) jint DestroyJavaVM() - { return functions->DestroyJavaVM(this); } - jint AttachCurrentThread(JNIEnv** p_env, void* thr_args) - { return functions->AttachCurrentThread(this, p_env, thr_args); } + { + return functions->DestroyJavaVM(this); + } + jint AttachCurrentThread(JNIEnv **p_env, void *thr_args) + { + return functions->AttachCurrentThread(this, p_env, thr_args); + } jint DetachCurrentThread() - { return functions->DetachCurrentThread(this); } - jint GetEnv(void** env, jint version) - { return functions->GetEnv(this, env, version); } - jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args) - { return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); } + { + return functions->DetachCurrentThread(this); + } + jint GetEnv(void **env, jint version) + { + return functions->GetEnv(this, env, version); + } + jint AttachCurrentThreadAsDaemon(JNIEnv **p_env, void *thr_args) + { + return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); + } #endif /*__cplusplus*/ }; -struct JavaVMAttachArgs { - jint version; /* must be >= JNI_VERSION_1_2 */ - const char* name; /* NULL or name of thread as modified UTF-8 str */ - jobject group; /* global ref of a ThreadGroup object, or NULL */ +struct JavaVMAttachArgs +{ + jint version; /* must be >= JNI_VERSION_1_2 */ + const char *name; /* NULL or name of thread as modified UTF-8 str */ + jobject group; /* global ref of a ThreadGroup object, or NULL */ }; typedef struct JavaVMAttachArgs JavaVMAttachArgs; @@ -1109,17 +1386,19 @@ typedef struct JavaVMAttachArgs JavaVMAttachArgs; * JNI 1.2+ initialization. (As of 1.6, the pre-1.2 structures are no * longer supported.) */ -typedef struct JavaVMOption { - const char* optionString; - void* extraInfo; +typedef struct JavaVMOption +{ + const char *optionString; + void *extraInfo; } JavaVMOption; -typedef struct JavaVMInitArgs { - jint version; /* use JNI_VERSION_1_2 or later */ +typedef struct JavaVMInitArgs +{ + jint version; /* use JNI_VERSION_1_2 or later */ - jint nOptions; - JavaVMOption* options; - jboolean ignoreUnrecognized; + jint nOptions; + JavaVMOption *options; + jboolean ignoreUnrecognized; } JavaVMInitArgs; #ifdef __cplusplus @@ -1130,46 +1409,44 @@ extern "C" { * * Note these are the only symbols exported for JNI by the VM. */ -#if 0 /* In practice, these are not exported by the NDK so don't declare them */ -jint JNI_GetDefaultJavaVMInitArgs(void*); -jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void*); -jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize*); +#if 0 /* In practice, these are not exported by the NDK so don't declare them */ +jint JNI_GetDefaultJavaVMInitArgs(void* _Nonnull); +jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void* _Nonnull); +jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize* _Nonnull); #endif #define JNIIMPORT -#define JNIEXPORT __attribute__ ((visibility ("default"))) +#define JNIEXPORT __attribute__((visibility("default"))) #define JNICALL /* * Prototypes for functions exported by loadable shared libs. These are * called by JNI, not provided by JNI. */ -JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved); -JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved); +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved); +JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved); #ifdef __cplusplus } #endif - /* * Manifest constants. */ -#define JNI_FALSE 0 -#define JNI_TRUE 1 +#define JNI_FALSE 0 +#define JNI_TRUE 1 #define JNI_VERSION_1_1 0x00010001 #define JNI_VERSION_1_2 0x00010002 #define JNI_VERSION_1_4 0x00010004 #define JNI_VERSION_1_6 0x00010006 -#define JNI_OK (0) /* no error */ -#define JNI_ERR (-1) /* generic error */ -#define JNI_EDETACHED (-2) /* thread detached from the VM */ -#define JNI_EVERSION (-3) /* JNI version error */ - -#define JNI_COMMIT 1 /* copy content, do not free buffer */ -#define JNI_ABORT 2 /* free buffer w/o copying back */ +#define JNI_OK (0) /* no error */ +#define JNI_ERR (-1) /* generic error */ +#define JNI_EDETACHED (-2) /* thread detached from the VM */ +#define JNI_EVERSION (-3) /* JNI version error */ -#endif /* JNI_H_ */ +#define JNI_COMMIT 1 /* copy content, do not free buffer */ +#define JNI_ABORT 2 /* free buffer w/o copying back */ +#endif /* JNI_H_ */ From ba7725e00b9a4dc471a67032b089fe3912cd8352 Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 14 Jul 2017 14:39:47 +0200 Subject: [PATCH 03/84] adjust code to new header wip --- JNISwift/JNISwift.xcodeproj/project.pbxproj | 261 ++++++++++++++++++ .../contents.xcworkspacedata | 7 + JNISwift/build.sh | 8 + Sources/CJNI/include/jni.h | 2 +- Sources/JNISwift/JNI.swift | 31 ++- Sources/JNISwift/JNIClassManipulation.swift | 36 +-- Sources/JNISwift/JNIExceptions.swift | 22 +- Sources/JNISwift/JNIMethods.swift | 57 ++++ Sources/JNISwift/JNIObjects.swift | 20 +- Sources/JNISwift/JNIRefs.swift | 50 ++-- Sources/JNISwift/JNIStrings.swift | 48 ++-- Sources/JNISwift/SwiftJNI.swift | 93 +++---- 12 files changed, 484 insertions(+), 151 deletions(-) create mode 100644 JNISwift/JNISwift.xcodeproj/project.pbxproj create mode 100644 JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata create mode 100644 JNISwift/build.sh create mode 100644 Sources/JNISwift/JNIMethods.swift diff --git a/JNISwift/JNISwift.xcodeproj/project.pbxproj b/JNISwift/JNISwift.xcodeproj/project.pbxproj new file mode 100644 index 0000000..98fa8a6 --- /dev/null +++ b/JNISwift/JNISwift.xcodeproj/project.pbxproj @@ -0,0 +1,261 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXFileReference section */ + 032F84951F18BC2300E24174 /* jni.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; + 032F84961F18BC2300E24174 /* module.modulemap */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = "sourcecode.module-map"; path = module.modulemap; sourceTree = ""; }; + 032F84971F18BC2300E24174 /* jni.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = jni.c; sourceTree = ""; }; + 032F84991F18BC2300E24174 /* JNI.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; + 032F849A1F18BC2300E24174 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; + 032F849B1F18BC2300E24174 /* JNIExceptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIExceptions.swift; sourceTree = ""; }; + 032F849C1F18BC2300E24174 /* JNIMethods.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIMethods.swift; sourceTree = ""; }; + 032F849D1F18BC2300E24174 /* JNIObjects.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIObjects.swift; sourceTree = ""; }; + 032F849E1F18BC2300E24174 /* JNIRefs.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIRefs.swift; sourceTree = ""; }; + 032F849F1F18BC2300E24174 /* JNIStrings.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIStrings.swift; sourceTree = ""; }; + 032F84A01F18BC2300E24174 /* SwiftJNI.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SwiftJNI.swift; sourceTree = ""; }; + 032F84A21F18BD1E00E24174 /* Package.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = Package.swift; path = ../Package.swift; sourceTree = ""; }; + 032F84A31F18BD1E00E24174 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = README.md; path = ../README.md; sourceTree = ""; }; + 032F84A41F18BDE000E24174 /* build.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = build.sh; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXGroup section */ + 032F84871F18BBF700E24174 = { + isa = PBXGroup; + children = ( + 032F84A41F18BDE000E24174 /* build.sh */, + 032F84A21F18BD1E00E24174 /* Package.swift */, + 032F84A31F18BD1E00E24174 /* README.md */, + 032F84921F18BC2300E24174 /* Sources */, + ); + sourceTree = ""; + }; + 032F84921F18BC2300E24174 /* Sources */ = { + isa = PBXGroup; + children = ( + 032F84931F18BC2300E24174 /* CJNI */, + 032F84981F18BC2300E24174 /* JNISwift */, + ); + name = Sources; + path = ../Sources; + sourceTree = ""; + }; + 032F84931F18BC2300E24174 /* CJNI */ = { + isa = PBXGroup; + children = ( + 032F84941F18BC2300E24174 /* include */, + 032F84971F18BC2300E24174 /* jni.c */, + ); + path = CJNI; + sourceTree = ""; + }; + 032F84941F18BC2300E24174 /* include */ = { + isa = PBXGroup; + children = ( + 032F84951F18BC2300E24174 /* jni.h */, + 032F84961F18BC2300E24174 /* module.modulemap */, + ); + path = include; + sourceTree = ""; + }; + 032F84981F18BC2300E24174 /* JNISwift */ = { + isa = PBXGroup; + children = ( + 032F84991F18BC2300E24174 /* JNI.swift */, + 032F849A1F18BC2300E24174 /* JNIClassManipulation.swift */, + 032F849B1F18BC2300E24174 /* JNIExceptions.swift */, + 032F849C1F18BC2300E24174 /* JNIMethods.swift */, + 032F849D1F18BC2300E24174 /* JNIObjects.swift */, + 032F849E1F18BC2300E24174 /* JNIRefs.swift */, + 032F849F1F18BC2300E24174 /* JNIStrings.swift */, + 032F84A01F18BC2300E24174 /* SwiftJNI.swift */, + ); + path = JNISwift; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXLegacyTarget section */ + 032F848C1F18BBF700E24174 /* JNISwift */ = { + isa = PBXLegacyTarget; + buildArgumentsString = build.sh; + buildConfigurationList = 032F848F1F18BBF700E24174 /* Build configuration list for PBXLegacyTarget "JNISwift" */; + buildPhases = ( + ); + buildToolPath = /bin/bash; + buildWorkingDirectory = ""; + dependencies = ( + ); + name = JNISwift; + passBuildSettingsInEnvironment = 1; + productName = JNISwift; + }; +/* End PBXLegacyTarget section */ + +/* Begin PBXProject section */ + 032F84881F18BBF700E24174 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 0830; + ORGANIZATIONNAME = flowkey; + TargetAttributes = { + 032F848C1F18BBF700E24174 = { + CreatedOnToolsVersion = 8.3.3; + DevelopmentTeam = FTSYMMN5B5; + ProvisioningStyle = Automatic; + }; + }; + }; + buildConfigurationList = 032F848B1F18BBF700E24174 /* Build configuration list for PBXProject "JNISwift" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + ); + mainGroup = 032F84871F18BBF700E24174; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 032F848C1F18BBF700E24174 /* JNISwift */, + ); + }; +/* End PBXProject section */ + +/* Begin XCBuildConfiguration section */ + 032F848D1F18BBF700E24174 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + }; + name = Debug; + }; + 032F848E1F18BBF700E24174 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MTL_ENABLE_DEBUG_INFO = NO; + }; + name = Release; + }; + 032F84901F18BBF700E24174 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEBUGGING_SYMBOLS = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + DEVELOPMENT_TEAM = FTSYMMN5B5; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 032F84911F18BBF700E24174 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + DEVELOPMENT_TEAM = FTSYMMN5B5; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 032F848B1F18BBF700E24174 /* Build configuration list for PBXProject "JNISwift" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 032F848D1F18BBF700E24174 /* Debug */, + 032F848E1F18BBF700E24174 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 032F848F1F18BBF700E24174 /* Build configuration list for PBXLegacyTarget "JNISwift" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 032F84901F18BBF700E24174 /* Debug */, + 032F84911F18BBF700E24174 /* Release */, + ); + defaultConfigurationIsVisible = 0; + }; +/* End XCConfigurationList section */ + }; + rootObject = 032F84881F18BBF700E24174 /* Project object */; +} diff --git a/JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..e6bd6f1 --- /dev/null +++ b/JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/JNISwift/build.sh b/JNISwift/build.sh new file mode 100644 index 0000000..14e21f3 --- /dev/null +++ b/JNISwift/build.sh @@ -0,0 +1,8 @@ +export PATH=$PATH:~/.swiftyrobot + +# ensure working dir is local to this script (when being called by another script) +cd "$(dirname "$0")" + +# build Swift Package with Swifty Robot +sr build | sed 's/\/root\/host_fs//g' +exit ${PIPESTATUS[0]} diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index fd2bfbd..475a018 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -163,7 +163,7 @@ typedef union CF_SWIFT_NAME(JavaParameter) jvalue { jobject l CF_SWIFT_NAME(object); } jvalue; -typedef enum jobjectRefType { +typedef enum CF_SWIFT_NAME(JavaObjectRefType) jobjectRefType { JNIInvalidRefType = 0, JNILocalRefType = 1, JNIGlobalRefType = 2, diff --git a/Sources/JNISwift/JNI.swift b/Sources/JNISwift/JNI.swift index adb3f5b..851b8e2 100644 --- a/Sources/JNISwift/JNI.swift +++ b/Sources/JNISwift/JNI.swift @@ -2,65 +2,66 @@ import CJNI public class JNI { /// Our reference to the Java Virtual Machine, to be set on init - let _jvm: UnsafeMutablePointer + let _jvm: UnsafeMutablePointer /// Ensure the _env pointer we have is always attached to the JVM - var _env: UnsafeMutablePointer { - let jvm = _jvm.pointee?.pointee + var _env: UnsafeMutablePointer { + let jvm = _jvm.pointee.pointee // The type `JNIEnv` is defined as a non-mutable pointer, // so use this mutable _tmpPointer as an intermediate: var _tmpPointer: UnsafeMutableRawPointer? - let threadStatus = jvm?.GetEnv(_jvm, &_tmpPointer, jint(JNI_VERSION_1_6)) - var _env = _tmpPointer?.bindMemory(to: JNIEnv?.self, capacity: 1) + let threadStatus = jvm.GetEnv(_jvm, &_tmpPointer, JavaInt(JNI_VERSION_1_6)) + var _env = _tmpPointer!.bindMemory(to: JNIEnv.self, capacity: 1) - switch threadStatus?.bigEndian ?? 0 { + switch threadStatus.bigEndian { case JNI_OK: break // if we're already attached, do nothing case JNI_EDETACHED: // We weren't attached to the Java UI thread - _ = jvm?.AttachCurrentThread(_jvm, &_env, nil) + _ = jvm.AttachCurrentThread(_jvm, &_env, nil) case JNI_EVERSION: fatalError("This version of JNI is not supported") default: break } - return _env! + return _env } + // Normally we init the jni global ourselves in JNI_OnLoad public init?(jvm: UnsafeMutablePointer) { - if jvm.pointee == nil { return nil } + if jvm == nil { return nil } self._jvm = jvm } } public extension JNI { - public func GetVersion() -> jint { + public func GetVersion() -> JavaInt { let env = self._env return env.pointee!.pointee.GetVersion(env) } - public func GetJavaVM(vm: UnsafeMutablePointer?>) -> jint { + public func GetJavaVM(vm: UnsafeMutablePointer?>) -> JavaInt { let env = self._env return env.pointee!.pointee.GetJavaVM(env, vm) } - public func RegisterNatives(targetClass: jclass, _ methods: UnsafePointer, _ nMethods: jint) -> jint { + public func RegisterNatives(targetClass: JavaClass, _ methods: UnsafePointer, _ nMethods: JavaInt) -> JavaInt { let env = self._env return env.pointee!.pointee.RegisterNatives(env, targetClass, methods, nMethods) } - public func UnregisterNatives(targetClass: jclass) -> jint { + public func UnregisterNatives(targetClass: JavaClass) -> JavaInt { let env = self._env return env.pointee!.pointee.UnregisterNatives(env, targetClass) } - public func MonitorEnter(obj: jobject) -> jint { + public func MonitorEnter(obj: JavaObject) -> JavaInt { let env = self._env return env.pointee!.pointee.MonitorEnter(env, obj) } - public func MonitorExit(obj: jobject) -> jint { + public func MonitorExit(obj: JavaObject) -> JavaInt { let env = self._env return env.pointee!.pointee.MonitorExit(env, obj) } diff --git a/Sources/JNISwift/JNIClassManipulation.swift b/Sources/JNISwift/JNIClassManipulation.swift index 177c4d6..9f52706 100644 --- a/Sources/JNISwift/JNIClassManipulation.swift +++ b/Sources/JNISwift/JNIClassManipulation.swift @@ -1,43 +1,43 @@ import CJNI public extension JNI { - public func DefineClass(name: String, _ loader: jobject, _ buffer: UnsafePointer, _ bufferLength: jsize) -> jclass { - let env = self._env - return env.pointee!.pointee.DefineClass(env, name, loader, buffer, bufferLength)! - } + // public func DefineClass(name: String, _ loader: JavaObject, _ buffer: UnsafePointer, _ bufferLength: jsize) -> JavaClass { + // let env = self._env + // return env.pointee.pointee.DefineClass(env, name, loader, buffer, bufferLength)! + // } - public func FindClass(name: String) -> jclass { + public func FindClass(name: String) -> JavaClass { let env = self._env - return env.pointee!.pointee.FindClass(env, name)! + return env.pointee.pointee.FindClass(env, name)! } - public func FromReflectedMethod(method: jobject) -> jmethodID { + public func FromReflectedMethod(method: JavaObject) -> JavaMethodID { let env = self._env - return env.pointee!.pointee.FromReflectedMethod(env, method)! + return env.pointee.pointee.FromReflectedMethod(env, method)! } - public func FromReflectedField(field: jobject) -> jfieldID { + public func FromReflectedField(field: JavaObject) -> jfieldID { let env = self._env - return env.pointee!.pointee.FromReflectedField(env, field)! + return env.pointee.pointee.FromReflectedField(env, field)! } - public func ToReflectedMethod(targetClass: jclass, _ methodID: jmethodID, _ isStatic: jboolean) -> jobject { + public func ToReflectedMethod(targetClass: JavaClass, _ methodID: JavaMethodID, _ isStatic: JavaBoolean) -> JavaObject { let env = self._env - return env.pointee!.pointee.ToReflectedMethod(env, targetClass, methodID, isStatic)! + return env.pointee.pointee.ToReflectedMethod(env, targetClass, methodID, isStatic)! } - public func GetSuperclass(targetClass: jclass) -> jclass { + public func GetSuperclass(targetClass: JavaClass) -> JavaClass { let env = self._env - return env.pointee!.pointee.GetSuperclass(env, targetClass)! + return env.pointee.pointee.GetSuperclass(env, targetClass)! } - public func IsAssignableFrom(classA: jclass, _ classB: jclass) -> jboolean { + public func IsAssignableFrom(classA: JavaClass, _ classB: JavaClass) -> JavaBoolean { let env = self._env - return env.pointee!.pointee.IsAssignableFrom(env, classA, classB) + return env.pointee.pointee.IsAssignableFrom(env, classA, classB) } - public func ToReflectedField(targetClass: jclass, _ fieldID: jfieldID, _ isStatic: jboolean) -> jobject { + public func ToReflectedField(targetClass: JavaClass, _ fieldID: jfieldID, _ isStatic: JavaBoolean) -> JavaObject { let env = self._env - return env.pointee!.pointee.ToReflectedField(env, targetClass, fieldID, isStatic)! + return env.pointee.pointee.ToReflectedField(env, targetClass, fieldID, isStatic)! } } diff --git a/Sources/JNISwift/JNIExceptions.swift b/Sources/JNISwift/JNIExceptions.swift index 972627e..b362859 100644 --- a/Sources/JNISwift/JNIExceptions.swift +++ b/Sources/JNISwift/JNIExceptions.swift @@ -1,38 +1,38 @@ import CJNI public extension JNI { - public func ExceptionCheck() -> jboolean { + public func ExceptionCheck() -> JavaBoolean { let env = self._env - return env.pointee!.pointee.ExceptionCheck(env) + return env.pointee.pointee.ExceptionCheck(env) } public func ExceptionDescribe() { let env = self._env - env.pointee!.pointee.ExceptionDescribe(env) + env.pointee.pointee.ExceptionDescribe(env) } public func ExceptionClear() { let env = self._env - env.pointee!.pointee.ExceptionClear(env) + env.pointee.pointee.ExceptionClear(env) } - public func ExceptionOccurred() -> jthrowable { + public func ExceptionOccurred() -> JavaThrowable { let env = self._env - return env.pointee!.pointee.ExceptionOccurred(env)! + return env.pointee.pointee.ExceptionOccurred(env)! } - public func Throw(obj: jthrowable) -> jint { + public func Throw(obj: JavaThrowable) -> JavaInt { let env = self._env - return env.pointee!.pointee.Throw(env, obj) + return env.pointee.pointee.Throw(env, obj) } - public func ThrowNew(targetClass: jclass, _ message: String) -> jint { + public func ThrowNew(targetClass: JavaClass, _ message: String) -> JavaInt { let env = self._env - return env.pointee!.pointee.ThrowNew(env, targetClass, message) + return env.pointee.pointee.ThrowNew(env, targetClass, message) } public func FatalError(msg: String) { let env = self._env - env.pointee!.pointee.FatalError(env, msg) + env.pointee.pointee.FatalError(env, msg) } } diff --git a/Sources/JNISwift/JNIMethods.swift b/Sources/JNISwift/JNIMethods.swift new file mode 100644 index 0000000..8e95fc7 --- /dev/null +++ b/Sources/JNISwift/JNIMethods.swift @@ -0,0 +1,57 @@ +// protocol JavaParameterConvertible { +// typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) +// static var asJNIParameterString: String { get } +// func toJavaParameter() -> JavaParameter +// static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Self +// } + +// extension Bool: JavaParameterConvertible { +// static var asJNIParameterString: String { return "z" } + +// func toJavaParameter() -> JavaParameter { +// return JavaParameter(bool: (self) ? 1 : 0) +// } + +// static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { +// return true // jni.CallStaticBooleanMethod(nil, nil, args) == 1 +// } +// } + +// struct InvalidParameters: Error {} + +// extension Array where Element == JavaParameterConvertible.Type { +// func methodSignature(returnType: JavaParameterConvertible.Type) -> String { +// let argumentTypes = self.reduce("", { (result, type) -> String in +// return result + type.asJNIParameterString +// }) + +// return "(" + argumentTypes + ")" + returnType.asJNIParameterString +// } +// } + +// func javaStaticMethod(_ method: String, on javaClass: JavaClass, parameterTypes: [JavaParameterConvertible.Type]) throws -> (T.JavaMethod) { + +// // guard let methodID = jni.GetStaticMethodID() else { throw Error } + +// return { (args: JavaParameterConvertible...) in +// if parameterTypes.count != args.count { +// throw InvalidParameters() +// } + +// try args.enumerated().forEach({ arg in +// let (i, element) = arg +// if type(of: element) != parameterTypes[i] { +// throw InvalidParameters() +// } +// }) + +// let javaParameters = args.map { $0.toJavaParameter() } +// return T.fromStaticMethod(calling: methodID, on: javaClass, args: args) +// } +// } + +// // func lol() throws -> Bool { +// // let obj = JavaObject.allocate(bytes: 1, alignedTo: 1) +// // let myFunc: Bool.JavaMethod = try javaStaticMethod("asd", on: obj, parameterTypes: [Bool.self]) +// // return try myFunc(true) +// // } diff --git a/Sources/JNISwift/JNIObjects.swift b/Sources/JNISwift/JNIObjects.swift index f9e1095..8dbde99 100644 --- a/Sources/JNISwift/JNIObjects.swift +++ b/Sources/JNISwift/JNIObjects.swift @@ -2,31 +2,31 @@ import CJNI public extension JNI { - public func AllocObject(targetClass: jclass) -> jobject { + public func AllocObject(targetClass: JavaClass) -> JavaObject { let env = self._env - return env.pointee!.pointee.AllocObject(env, targetClass)! + return env.pointee.pointee.AllocObject(env, targetClass)! } - public func NewObject(targetClass: jclass, _ methodID: jmethodID, _ args: jvalue...) -> jobject { + public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: JavaParameter...) -> JavaObject { return self.NewObjectA(targetClass: targetClass, methodID, args) } @available(*, unavailable, message:"CVaListPointer unavailable, use NewObject or NewObjectA") - public func NewObjectV(targetClass: jclass, _ methodID: jmethodID, _ args: CVaListPointer) -> jobject { + public func NewObjectV(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: CVaListPointer) -> JavaObject { let env = self._env - return env.pointee!.pointee.NewObjectV(env, targetClass, methodID, args)! + return env.pointee.pointee.NewObjectV(env, targetClass, methodID, args)! } - public func NewObjectA(targetClass: jclass, _ methodID: jmethodID, _ args: [jvalue]) -> jobject { + public func NewObjectA(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) -> JavaObject { let env = self._env var mutableArgs = args - return env.pointee!.pointee.NewObjectA(env, targetClass, methodID, &mutableArgs)! + return env.pointee.pointee.NewObjectA(env, targetClass, methodID, &mutableArgs)! } - public func GetObjectClass(obj: jobject) -> jclass? { + public func GetObjectClass(obj: JavaObject) -> JavaClass? { let env = self._env - let result = env.pointee!.pointee.GetObjectClass(env, obj) + let result = env.pointee.pointee.GetObjectClass(env, obj) return (result != nil) ? result : .none } - + } diff --git a/Sources/JNISwift/JNIRefs.swift b/Sources/JNISwift/JNIRefs.swift index 6706143..39e019c 100644 --- a/Sources/JNISwift/JNIRefs.swift +++ b/Sources/JNISwift/JNIRefs.swift @@ -1,64 +1,64 @@ import CJNI public extension JNI { - public func NewGlobalRef(obj: jobject) -> jobject { + public func NewGlobalRef(obj: JavaObject) -> JavaObject { let env = self._env - return env.pointee!.pointee.NewGlobalRef(env, obj)! + return env.pointee.pointee.NewGlobalRef(env, obj)! } - public func DeleteGlobalRef(globalRef: jobject) { + public func DeleteGlobalRef(globalRef: JavaObject) { let env = self._env - env.pointee!.pointee.DeleteGlobalRef(env, globalRef) + env.pointee.pointee.DeleteGlobalRef(env, globalRef) } - public func NewLocalRef(ref: jobject) -> jobject { + public func NewLocalRef(ref: JavaObject) -> JavaObject { let env = self._env - return env.pointee!.pointee.NewLocalRef(env, ref)! + return env.pointee.pointee.NewLocalRef(env, ref)! } - - public func DeleteLocalRef(localRef: jobject) { + + public func DeleteLocalRef(localRef: JavaObject) { let env = self._env - env.pointee!.pointee.DeleteLocalRef(env, localRef) + env.pointee.pointee.DeleteLocalRef(env, localRef) } - public func PushLocalFrame(capacity: jint) -> jint { + public func PushLocalFrame(capacity: JavaInt) -> JavaInt { let env = self._env - return env.pointee!.pointee.PushLocalFrame(env, capacity) + return env.pointee.pointee.PushLocalFrame(env, capacity) } - public func PopLocalFrame(result: jobject) -> jobject { + public func PopLocalFrame(result: JavaObject) -> JavaObject { let env = self._env - return env.pointee!.pointee.PopLocalFrame(env, result)! + return env.pointee.pointee.PopLocalFrame(env, result)! } - public func EnsureLocalCapacity(capacity: jint) -> jint { + public func EnsureLocalCapacity(capacity: JavaInt) -> JavaInt { let env = self._env - return env.pointee!.pointee.EnsureLocalCapacity(env, capacity) + return env.pointee.pointee.EnsureLocalCapacity(env, capacity) } - public func IsSameObject(ref1: jobject, _ ref2: jobject) -> jboolean { + public func IsSameObject(ref1: JavaObject, _ ref2: JavaObject) -> JavaBoolean { let env = self._env - return env.pointee!.pointee.IsSameObject(env, ref1, ref2) + return env.pointee.pointee.IsSameObject(env, ref1, ref2) } - public func IsInstanceOf(obj: jobject, _ targetClass: jclass) -> jboolean { + public func IsInstanceOf(obj: JavaObject, _ targetClass: JavaClass) -> JavaBoolean { let env = self._env - return env.pointee!.pointee.IsInstanceOf(env, obj, targetClass) + return env.pointee.pointee.IsInstanceOf(env, obj, targetClass) } - public func NewWeakGlobalRef(obj: jobject) -> jweak { + public func NewWeakGlobalRef(obj: JavaObject) -> JavaWeakReference { let env = self._env - return env.pointee!.pointee.NewWeakGlobalRef(env, obj)! + return env.pointee.pointee.NewWeakGlobalRef(env, obj)! } - public func DeleteWeakGlobalRef(obj: jweak) { + public func DeleteWeakGlobalRef(obj: JavaWeakReference) { let env = self._env - env.pointee!.pointee.DeleteWeakGlobalRef(env, obj) + env.pointee.pointee.DeleteWeakGlobalRef(env, obj) } /* added in 1: JNI.6 */ - public func GetObjectRefType(obj: jobject) -> jobjectRefType { + public func GetObjectRefType(obj: JavaObject) -> JavaObjectRefType { let env = self._env - return env.pointee!.pointee.GetObjectRefType(env, obj) + return env.pointee.pointee.GetObjectRefType(env, obj) } } diff --git a/Sources/JNISwift/JNIStrings.swift b/Sources/JNISwift/JNIStrings.swift index a494075..2017595 100644 --- a/Sources/JNISwift/JNIStrings.swift +++ b/Sources/JNISwift/JNIStrings.swift @@ -1,63 +1,63 @@ import CJNI public extension JNI { - public func NewString(unicodeChars: UnsafePointer, _ len: jsize) -> jstring { + public func NewString(unicodeChars: UnsafePointer, _ len: jsize) -> JavaString { let env = self._env - return env.pointee!.pointee.NewString(env, unicodeChars, len)! + return env.pointee.pointee.NewString(env, unicodeChars, len)! } - public func GetStringLength(string: jstring) -> jsize { + public func GetStringLength(string: JavaString) -> jsize { let env = self._env - return env.pointee!.pointee.GetStringLength(env, string) + return env.pointee.pointee.GetStringLength(env, string) } - public func GetStringChars(string: jstring, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { + public func GetStringChars(string: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env - return env.pointee!.pointee.GetStringChars(env, string, isCopy)! + return env.pointee.pointee.GetStringChars(env, string, isCopy)! } - public func ReleaseStringChars(string: jstring, _ chars: UnsafePointer) { + public func ReleaseStringChars(string: JavaString, _ chars: UnsafePointer) { let env = self._env - env.pointee!.pointee.ReleaseStringChars(env, string, chars) + env.pointee.pointee.ReleaseStringChars(env, string, chars) } - public func NewStringUTF(bytes: String) -> jstring { + public func NewStringUTF(bytes: String) -> JavaString { let env = self._env - return env.pointee!.pointee.NewStringUTF(env, bytes)! + return env.pointee.pointee.NewStringUTF(env, bytes)! } - public func GetStringUTFLength(string: jstring) -> jsize { + public func GetStringUTFLength(string: JavaString) -> jsize { let env = self._env - return env.pointee!.pointee.GetStringUTFLength(env, string) + return env.pointee.pointee.GetStringUTFLength(env, string) } - public func GetStringUTFChars(string: jstring, _ isCopy: UnsafeMutablePointer) -> String { + public func GetStringUTFChars(string: JavaString, _ isCopy: UnsafeMutablePointer) -> String { let env = self._env - return String(describing: env.pointee!.pointee.GetStringUTFChars(env, string, isCopy)) + return String(describing: env.pointee.pointee.GetStringUTFChars(env, string, isCopy)) } - public func ReleaseStringUTFChars(string: jstring, _ utf: String) { + public func ReleaseStringUTFChars(string: JavaString, _ utf: String) { let env = self._env - env.pointee!.pointee.ReleaseStringUTFChars(env, string, utf) + env.pointee.pointee.ReleaseStringUTFChars(env, string, utf) } - public func GetStringRegion(str: jstring, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer) { + public func GetStringRegion(str: JavaString, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer) { let env = self._env - env.pointee!.pointee.GetStringRegion(env, str, start, len, buf) + env.pointee.pointee.GetStringRegion(env, str, start, len, buf) } - public func GetStringUTFRegion(str: jstring, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer) { + public func GetStringUTFRegion(str: JavaString, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer) { let env = self._env - env.pointee!.pointee.GetStringUTFRegion(env, str, start, len, buf) + env.pointee.pointee.GetStringUTFRegion(env, str, start, len, buf) } - public func GetStringCritical(string: jstring, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { + public func GetStringCritical(string: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env - return env.pointee!.pointee.GetStringCritical(env, string, isCopy)! + return env.pointee.pointee.GetStringCritical(env, string, isCopy)! } - public func ReleaseStringCritical(string: jstring, _ carray: UnsafePointer) { + public func ReleaseStringCritical(string: JavaString, _ carray: UnsafePointer) { let env = self._env - env.pointee!.pointee.ReleaseStringCritical(env, string, carray) + env.pointee.pointee.ReleaseStringCritical(env, string, carray) } } diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index 1e58536..86dc3fe 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -4,7 +4,7 @@ import Dispatch public var jni: JNI! // this gets set "OnLoad" so should always exist @_silgen_name("JNI_OnLoad") -public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutablePointer) -> jint { +public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutablePointer) -> JavaInt { guard let localJNI = JNI(jvm: jvm) else { fatalError("Couldn't initialise JNI") @@ -24,90 +24,90 @@ public func JNI_DetachCurrentThread() { jni._jvm.pointee?.pointee.DetachCurrentThread(jni._jvm) } -extension jboolean : BooleanLiteralConvertible { +extension JavaBoolean : BooleanLiteralConvertible { public init(booleanLiteral value: Bool) { - self = value ? jboolean(JNI_TRUE) : jboolean(JNI_FALSE) + self = value ? JavaBoolean(JNI_TRUE) : JavaBoolean(JNI_FALSE) } } // SwiftJNI Public API extension JNI { - public func RegisterNatives(jClass: jclass, methods: [JNINativeMethod]) -> Bool { + public func RegisterNatives(javaClass: JavaClass, methods: [JNINativeMethod]) -> Bool { let _env = self._env - let env = _env.pointee!.pointee - let result = env.RegisterNatives(_env, jClass, methods, jint(methods.count)) + let env = _env.pointee.pointee + let result = env.RegisterNatives(_env, javaClass, methods, JavaInt(methods.count)) return (result == 0) } public func ThrowNew(message: String) { let _env = self._env - let env = _env.pointee!.pointee + let env = _env.pointee.pointee env.ThrowNew(_env, env.FindClass(_env, "java/lang/Exception"), message) } /// - Note: This shouldn't need to be cleaned up because we're not taking ownership of the reference - public func GetStringUTFChars(string: jstring) -> UnsafePointer { + public func GetStringUTFChars(string: JavaString) -> UnsafePointer { let _env = self._env - var didCopyStringChars = jboolean() // XXX: this gets set below, check it! - return _env.pointee!.pointee.GetStringUTFChars(_env, string, &didCopyStringChars)! + var didCopyStringChars = JavaBoolean() // XXX: this gets set below, check it! + return _env.pointee.pointee.GetStringUTFChars(_env, string, &didCopyStringChars)! } // MARK: References - public func NewGlobalRef(object: jobject) -> jobject? { + public func NewGlobalRef(object: JavaObject) -> JavaObject? { let _env = self._env - let result = _env.pointee!.pointee.NewGlobalRef(_env, object) + let result = _env.pointee.pointee.NewGlobalRef(_env, object) return (result != nil) ? result : .none } // MARK: Classes and Methods - public func FindClass(className: String) -> jclass? { + public func FindClass(className: String) -> JavaClass? { let _env = self._env - let result = _env.pointee!.pointee.FindClass(_env, className) + let result = _env.pointee.pointee.FindClass(_env, className) return (result != nil) ? result : .none } - public func GetMethodID(javaClass: jclass, methodName: UnsafePointer, methodSignature: UnsafePointer) -> jmethodID? { + public func GetMethodID(javaClass: JavaClass, methodName: UnsafePointer, methodSignature: UnsafePointer) -> JavaMethodID? { let _env = self._env - let result = _env.pointee!.pointee.GetMethodID(_env, javaClass, methodName, methodSignature) + let result = _env.pointee.pointee.GetMethodID(_env, javaClass, methodName, methodSignature) return (result != nil) ? result : .none } - public func GetStaticMethodID(javaClass: jclass, methodName: UnsafePointer, methodSignature: UnsafePointer) -> jmethodID? { + public func GetStaticMethodID(javaClass: JavaClass, methodName: UnsafePointer, methodSignature: UnsafePointer) -> JavaMethodID? { let _env = self._env - let result = _env.pointee!.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) + let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) return (result != nil) ? result : .none } - // TODO: make parameters take [JValue], being a swifty version of [jvalue] with reference counting etc. - public func CallVoidMethodA(object: jobject, methodID method: jmethodID, parameters: [jvalue]) { + // TODO: make parameters take [JavaParameter], being a swifty version of [JavaParameter] with reference counting etc. + public func CallVoidMethodA(object: JavaObject, methodID method: JavaMethodID, parameters: [JavaParameter]) { let _env = self._env var methodArgs = parameters - _env.pointee!.pointee.CallVoidMethodA(_env, object, method, &methodArgs) + _env.pointee.pointee.CallVoidMethodA(_env, object, method, &methodArgs) } - public func CallStaticIntMethodA(javaClass: jclass, method: jmethodID, parameters: [jvalue]) -> jint { + public func CallStaticIntMethodA(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) -> JavaInt { let _env = self._env var methodArgs = parameters - return _env.pointee!.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) + return _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) } // MARK: Arrays public func GetArrayLength(array: jarray) -> Int { let _env = self._env - let result = _env.pointee!.pointee.GetArrayLength(_env, array) + let result = _env.pointee.pointee.GetArrayLength(_env, array) return Int(result) } public func NewIntArray(count: Int) -> jarray? { let _env = self._env - let result = _env.pointee!.pointee.NewIntArray(_env, jsize(count)) + let result = _env.pointee.pointee.NewIntArray(_env, jsize(count)) return (result != nil) ? result : .none } - public func GetIntArrayRegion(array: jintArray, startIndex: Int = 0, numElements: Int = -1) -> [Int] { + public func GetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, numElements: Int = -1) -> [Int] { let _env = self._env var count = numElements @@ -115,24 +115,24 @@ extension JNI { count = GetArrayLength(array: array) } - var result = [jint](repeating: 0, count: count) - _env.pointee!.pointee.GetIntArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + var result = [JavaInt](repeating: 0, count: count) + _env.pointee.pointee.GetIntArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) return result.map { Int($0) } } - public func SetIntArrayRegion(array: jintArray, startIndex: Int = 0, from sourceElements: [Int]) { + public func SetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, from sourceElements: [Int]) { let _env = self._env - var newElements = sourceElements.map { jint($0) } // make mutable copy - _env.pointee!.pointee.SetIntArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + var newElements = sourceElements.map { JavaInt($0) } // make mutable copy + _env.pointee.pointee.SetIntArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } public func NewFloatArray(count: Int) -> jarray? { let _env = self._env - let result = _env.pointee!.pointee.NewFloatArray(_env, jsize(count)) + let result = _env.pointee.pointee.NewFloatArray(_env, jsize(count)) return (result != nil) ? result : .none } - public func GetFloatArrayRegion(array: jfloatArray, startIndex: Int = 0, numElements: Int = -1) -> [Float] { + public func GetFloatArrayRegion(array: JavaFloatArray, startIndex: Int = 0, numElements: Int = -1) -> [Float] { let _env = self._env var count = numElements @@ -140,27 +140,26 @@ extension JNI { count = GetArrayLength(array: array) } - var result = [jfloat](repeating: 0, count: count) - _env.pointee!.pointee.GetFloatArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + var result = [JavaFloat](repeating: 0, count: count) + _env.pointee.pointee.GetFloatArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) return result.map { Float($0) } } - public func SetFloatArrayRegion(array: jfloatArray, startIndex: Int = 0, from sourceElements: [Float]) { + public func SetFloatArrayRegion(array: JavaFloatArray, startIndex: Int = 0, from sourceElements: [Float]) { let _env = self._env - var newElements = sourceElements.map { jfloat($0) } // make mutable copy - _env.pointee!.pointee.SetFloatArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + var newElements = sourceElements.map { JavaFloat($0) } // make mutable copy + _env.pointee.pointee.SetFloatArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } } - /** - Allows a (Void) Java method to be called from Swift. Takes a global jobj (a class instance), a method name and its signature. The resulting callback can be called via javaCallback.call(param1, param2...), or javaCallback.apply([params]). Each param must be a jvalue. + Allows a (Void) Java method to be called from Swift. Takes a global jobj (a class instance), a method name and its signature. The resulting callback can be called via javaCallback.call(param1, param2...), or javaCallback.apply([params]). Each param must be a JavaParameter. Needs more error checking and handling. The basis is there, but from memory I had issues with either the optional or the throwing on Android. */ public struct JavaCallback { - private let jobj: jobject // must be a JNI Global Reference - private let methodID: jmethodID + private let jobj: JavaObject // must be a JNI Global Reference + private let methodID: JavaMethodID // Eventually we should check how many parameters are required by the method signature // And also which return type is expected (to allow calling non-Void methods) @@ -169,7 +168,7 @@ public struct JavaCallback { /// Errors describing the various things that can go wrong when calling a Java method via JNI. /// - __InvalidParameters__: One character per method parameter is required. For example, with a methodSignature of "(FF)V", you need to pass two floats as parameters. - /// - __InvalidMethod__: Couldn't get the requested method from the jobject provided (are you calling with the right jobject instance / calling on the correct class?) + /// - __InvalidMethod__: Couldn't get the requested method from the JavaObject provided (are you calling with the right JavaObject instance / calling on the correct class?) /// - __IncorrectMethodSignature__: The JNI is separated into Java method calls to functions with various return types. So if you perform `callJavaMethod`, you need to accept the return value with the corresponding type. *XXX: currently only Void methods are implemented*. enum JavaError: Error { @@ -198,10 +197,10 @@ public struct JavaCallback { - **[type** type[] - **(arg-types)ret-type** method type - e.g. **`"([I)V"`** would accept one array of Ints and return Void. - - parameters: Any number of jvalues (*must have the same number and type as the* `methodSignature` *you're trying to call*) + - parameters: Any number of JavaParameters (*must have the same number and type as the* `methodSignature` *you're trying to call*) - Throws: `JavaCallback.Error` */ - public init (_ globalJobj: jobject, methodName: String, methodSignature: String) { + public init (_ globalJobj: JavaObject, methodName: String, methodSignature: String) { // At the moment we can only call Void methods, fail if user tries to return something else guard let returnType = methodSignature.characters.last, returnType == "V"/*oid*/ else { // LOG JavaMethodCallError.IncorrectMethodSignature @@ -226,12 +225,12 @@ public struct JavaCallback { self.methodID = methodID } - public func apply(args: [jvalue]) { + public func apply(args: [JavaParameter]) { jni.CallVoidMethodA(object: jobj, methodID: methodID, parameters: args) } /// Send variadic parameters to the func that takes an array - public func call(args: jvalue...) { + public func call(args: JavaParameter...) { self.apply(args: args) } } From 4b39e7048184aae86b0000c598e363ae1d18d447 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Fri, 14 Jul 2017 17:54:28 +0200 Subject: [PATCH 04/84] Update for new header --- README.md | 2 +- Sources/CJNI/include/jni.h | 546 +++++++++++++++--------------- Sources/JNISwift/JNI.swift | 21 +- Sources/JNISwift/JNIObjects.swift | 12 +- Sources/JNISwift/SwiftJNI.swift | 30 +- 5 files changed, 302 insertions(+), 309 deletions(-) diff --git a/README.md b/README.md index 0877500..6e091e6 100644 --- a/README.md +++ b/README.md @@ -10,6 +10,6 @@ The naming has been kept as close to the C-functions as possible, including omit Internally the module uses JNI_OnLoad (which could be problematic if the user wants to use their own) to initialise an implicitly unwrapped global, `jni`. -This global can be then used from Swift code (from any thread) to run standard JNI functions like jni.GetIntArrayRegion(jarray), to return an array of Swift `Int`s +This global can be then used from Swift code (from any thread) to run standard JNI functions like jni.GetIntArrayRegion(JavaArray), to return an array of Swift `Int`s See the article here for why (and a bit of how) this project came to be: https://medium.com/@ephemer/using-jni-in-swift-to-put-an-app-into-the-android-play-store-732e542a99dd#.rtviqfdlu diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index 475a018..4dcb2ff 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -125,7 +125,7 @@ typedef _jobject *jweak; /* * Reference types, in C. */ -typedef void *_Nullable jobject CF_SWIFT_NAME(JavaObject); +typedef void * _Nullable jobject CF_SWIFT_NAME(JavaObject); typedef jobject jclass CF_SWIFT_NAME(JavaClass); typedef jobject jstring CF_SWIFT_NAME(JavaString); typedef jobject jarray CF_SWIFT_NAME(JavaArray); @@ -144,10 +144,10 @@ typedef jobject jweak CF_SWIFT_NAME(JavaWeakReference); #endif /* not __cplusplus */ struct _jfieldID; /* opaque structure */ -typedef struct _jfieldID *_Nullable jfieldID; /* field IDs */ +typedef struct _jfieldID * _Nullable jfieldID; /* field IDs */ struct _jmethodID; /* opaque structure */ -typedef struct _jmethodID *_Nullable jmethodID CF_SWIFT_NAME(JavaMethodID); /* method IDs */ +typedef struct _jmethodID * _Nullable jmethodID CF_SWIFT_NAME(JavaMethodID); /* method IDs */ struct JNIInvokeInterface; @@ -172,21 +172,21 @@ typedef enum CF_SWIFT_NAME(JavaObjectRefType) jobjectRefType { typedef struct { - const char *_Nonnull name; - const char *_Nonnull signature; - void *_Nonnull fnPtr; + const char * _Nonnull name; + const char * _Nonnull signature; + void * _Nonnull fnPtr; } JNINativeMethod; struct _JNIEnv; struct _JavaVM; -typedef const struct JNINativeInterface *_Nonnull C_JNIEnv; +typedef const struct JNINativeInterface * _Nonnull C_JNIEnv; #if defined(__cplusplus) typedef _JNIEnv JNIEnv; typedef _JavaVM JavaVM; #else -typedef const struct JNINativeInterface *_Nonnull JNIEnv; -typedef const struct JNIInvokeInterface *_Nonnull JavaVM; +typedef const struct JNINativeInterface * _Nonnull JNIEnv; +typedef const struct JNIInvokeInterface * _Nonnull JavaVM; #endif /* @@ -199,274 +199,274 @@ struct JNINativeInterface void *_Null_unspecified reserved2; void *_Null_unspecified reserved3; - jint (*_Nonnull GetVersion)(JNIEnv *_Nonnull); + jint (* _Nonnull GetVersion)(JNIEnv * _Nonnull); - jclass (*_Nonnull DefineClass)(JNIEnv *_Nonnull, const char *_Nonnull, jobject, const jbyte *_Nonnull, jsize) SWIFT_UNAVAILABLE(Not implemented on Android); - jclass (*_Nonnull FindClass)(JNIEnv *_Nonnull, const char *_Nonnull); + jclass (* _Nonnull DefineClass)(JNIEnv * _Nonnull, const char * _Nonnull, jobject, const jbyte * _Nonnull, jsize) SWIFT_UNAVAILABLE(Not implemented on Android); + jclass (* _Nonnull FindClass)(JNIEnv * _Nonnull, const char * _Nonnull); - jmethodID (*_Nonnull FromReflectedMethod)(JNIEnv *_Nonnull, jobject); - jfieldID (*_Nonnull FromReflectedField)(JNIEnv *_Nonnull, jobject); + jmethodID (* _Nonnull FromReflectedMethod)(JNIEnv * _Nonnull, jobject); + jfieldID (* _Nonnull FromReflectedField)(JNIEnv * _Nonnull, jobject); /* spec doesn't show jboolean parameter */ - jobject (*_Nonnull ToReflectedMethod)(JNIEnv *_Nonnull, jclass, jmethodID, jboolean); + jobject (* _Nonnull ToReflectedMethod)(JNIEnv * _Nonnull, jclass, jmethodID, jboolean); - jclass (*_Nonnull GetSuperclass)(JNIEnv *_Nonnull, jclass); - jboolean (*_Nonnull IsAssignableFrom)(JNIEnv *_Nonnull, jclass, jclass); + jclass (* _Nonnull GetSuperclass)(JNIEnv * _Nonnull, jclass); + jboolean (* _Nonnull IsAssignableFrom)(JNIEnv * _Nonnull, jclass, jclass); /* spec doesn't show jboolean parameter */ - jobject (*_Nonnull ToReflectedField)(JNIEnv *_Nonnull, jclass, jfieldID, jboolean); - - jint (*_Nonnull Throw)(JNIEnv *_Nonnull, jthrowable); - jint (*_Nonnull ThrowNew)(JNIEnv *, jclass, const char *_Nonnull); - jthrowable (*_Nonnull ExceptionOccurred)(JNIEnv *_Nonnull); - void (*_Nonnull ExceptionDescribe)(JNIEnv *_Nonnull); - void (*_Nonnull ExceptionClear)(JNIEnv *_Nonnull); - void (*_Nonnull FatalError)(JNIEnv *_Nonnull, const char *_Nonnull); - - jint (*_Nonnull PushLocalFrame)(JNIEnv *_Nonnull, jint); - jobject (*_Nonnull PopLocalFrame)(JNIEnv *_Nonnull, jobject); - - jobject (*_Nonnull NewGlobalRef)(JNIEnv *_Nonnull, jobject); - void (*_Nonnull DeleteGlobalRef)(JNIEnv *_Nonnull, jobject); - void (*_Nonnull DeleteLocalRef)(JNIEnv *_Nonnull, jobject); - jboolean (*_Nonnull IsSameObject)(JNIEnv *_Nonnull, jobject, jobject); - - jobject (*_Nonnull NewLocalRef)(JNIEnv *_Nonnull, jobject); - jint (*_Nonnull EnsureLocalCapacity)(JNIEnv *_Nonnull, jint); - - jobject (*_Nonnull AllocObject)(JNIEnv *_Nonnull, jclass); - jobject (*_Nonnull NewObject)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'newObject' instead); - jobject (*_Nonnull NewObjectV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'newObject' instead); - jobject (*_Nonnull NewObjectA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(newObject); - - jclass (*_Nonnull GetObjectClass)(JNIEnv *_Nonnull, jobject); - jboolean (*_Nonnull IsInstanceOf)(JNIEnv *_Nonnull, jobject, jclass); - jmethodID (*_Nonnull GetMethodID)(JNIEnv *_Nonnull, jclass, const char *_Nonnull, const char *_Nonnull); - - jobject (*_Nonnull CallObjectMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - jobject (*_Nonnull CallObjectMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - jobject (*_Nonnull CallObjectMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - jboolean (*_Nonnull CallBooleanMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - jboolean (*_Nonnull CallBooleanMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - jboolean (*_Nonnull CallBooleanMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - jbyte (*_Nonnull CallByteMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - jbyte (*_Nonnull CallByteMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - jbyte (*_Nonnull CallByteMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - jchar (*_Nonnull CallCharMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - jchar (*_Nonnull CallCharMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - jchar (*_Nonnull CallCharMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - jshort (*_Nonnull CallShortMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - jshort (*_Nonnull CallShortMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - jshort (*_Nonnull CallShortMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - jint (*_Nonnull CallIntMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - jint (*_Nonnull CallIntMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - jint (*_Nonnull CallIntMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - jlong (*_Nonnull CallLongMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - jlong (*_Nonnull CallLongMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - jlong (*_Nonnull CallLongMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - jfloat (*_Nonnull CallFloatMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - jfloat (*_Nonnull CallFloatMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - jfloat (*_Nonnull CallFloatMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - jdouble (*_Nonnull CallDoubleMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - jdouble (*_Nonnull CallDoubleMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - jdouble (*_Nonnull CallDoubleMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - void (*_Nonnull CallVoidMethod)(JNIEnv *_Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(use 'call' instead); - void (*_Nonnull CallVoidMethodV)(JNIEnv *_Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'call' instead); - void (*_Nonnull CallVoidMethodA)(JNIEnv *_Nonnull, jobject, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(call); - - jobject (*_Nonnull CallNonvirtualObjectMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jobject (*_Nonnull CallNonvirtualObjectMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jobject (*_Nonnull CallNonvirtualObjectMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - jboolean (*_Nonnull CallNonvirtualBooleanMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jboolean (*_Nonnull CallNonvirtualBooleanMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jboolean (*_Nonnull CallNonvirtualBooleanMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - jbyte (*_Nonnull CallNonvirtualByteMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jbyte (*_Nonnull CallNonvirtualByteMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jbyte (*_Nonnull CallNonvirtualByteMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - jchar (*_Nonnull CallNonvirtualCharMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jchar (*_Nonnull CallNonvirtualCharMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jchar (*_Nonnull CallNonvirtualCharMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - jshort (*_Nonnull CallNonvirtualShortMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jshort (*_Nonnull CallNonvirtualShortMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jshort (*_Nonnull CallNonvirtualShortMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - jint (*_Nonnull CallNonvirtualIntMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jint (*_Nonnull CallNonvirtualIntMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jint (*_Nonnull CallNonvirtualIntMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - jlong (*_Nonnull CallNonvirtualLongMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jlong (*_Nonnull CallNonvirtualLongMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jlong (*_Nonnull CallNonvirtualLongMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - jfloat (*_Nonnull CallNonvirtualFloatMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jfloat (*_Nonnull CallNonvirtualFloatMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jfloat (*_Nonnull CallNonvirtualFloatMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - jdouble (*_Nonnull CallNonvirtualDoubleMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jdouble (*_Nonnull CallNonvirtualDoubleMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jdouble (*_Nonnull CallNonvirtualDoubleMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - void (*_Nonnull CallNonvirtualVoidMethod)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - void (*_Nonnull CallNonvirtualVoidMethodV)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - void (*_Nonnull CallNonvirtualVoidMethodA)(JNIEnv *_Nonnull, jobject, jclass, jmethodID, const jvalue *_Nonnull) CF_SWIFT_NAME(callNonvirtual); - - jfieldID (*_Nonnull GetFieldID)(JNIEnv *_Nonnull, jclass, const char *_Nonnull, const char *_Nonnull); - - jobject (*_Nonnull GetObjectField)(JNIEnv *_Nonnull, jobject, jfieldID); - jboolean (*_Nonnull GetBooleanField)(JNIEnv *_Nonnull, jobject, jfieldID); - jbyte (*_Nonnull GetByteField)(JNIEnv *_Nonnull, jobject, jfieldID); - jchar (*_Nonnull GetCharField)(JNIEnv *_Nonnull, jobject, jfieldID); - jshort (*_Nonnull GetShortField)(JNIEnv *_Nonnull, jobject, jfieldID); - jint (*_Nonnull GetIntField)(JNIEnv *_Nonnull, jobject, jfieldID); - jlong (*_Nonnull GetLongField)(JNIEnv *_Nonnull, jobject, jfieldID); - jfloat (*_Nonnull GetFloatField)(JNIEnv *_Nonnull, jobject, jfieldID); - jdouble (*_Nonnull GetDoubleField)(JNIEnv *_Nonnull, jobject, jfieldID); - - void (*_Nonnull SetObjectField)(JNIEnv *_Nonnull, jobject, jfieldID, jobject); - void (*_Nonnull SetBooleanField)(JNIEnv *_Nonnull, jobject, jfieldID, jboolean); - void (*_Nonnull SetByteField)(JNIEnv *_Nonnull, jobject, jfieldID, jbyte); - void (*_Nonnull SetCharField)(JNIEnv *_Nonnull, jobject, jfieldID, jchar); - void (*_Nonnull SetShortField)(JNIEnv *_Nonnull, jobject, jfieldID, jshort); - void (*_Nonnull SetIntField)(JNIEnv *_Nonnull, jobject, jfieldID, jint); - void (*_Nonnull SetLongField)(JNIEnv *_Nonnull, jobject, jfieldID, jlong); - void (*_Nonnull SetFloatField)(JNIEnv *_Nonnull, jobject, jfieldID, jfloat); - void (*_Nonnull SetDoubleField)(JNIEnv *_Nonnull, jobject, jfieldID, jdouble); - - jmethodID (*_Nonnull GetStaticMethodID)(JNIEnv *_Nonnull, jclass, const char *_Nonnull, const char *_Nonnull); - - jobject (*_Nonnull CallStaticObjectMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jobject (*_Nonnull CallStaticObjectMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jobject (*_Nonnull CallStaticObjectMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - jboolean (*_Nonnull CallStaticBooleanMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jboolean (*_Nonnull CallStaticBooleanMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jboolean (*_Nonnull CallStaticBooleanMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - jbyte (*_Nonnull CallStaticByteMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jbyte (*_Nonnull CallStaticByteMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jbyte (*_Nonnull CallStaticByteMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - jchar (*_Nonnull CallStaticCharMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jchar (*_Nonnull CallStaticCharMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jchar (*_Nonnull CallStaticCharMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - jshort (*_Nonnull CallStaticShortMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jshort (*_Nonnull CallStaticShortMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jshort (*_Nonnull CallStaticShortMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - jint (*_Nonnull CallStaticIntMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jint (*_Nonnull CallStaticIntMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jint (*_Nonnull CallStaticIntMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - jlong (*_Nonnull CallStaticLongMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jlong (*_Nonnull CallStaticLongMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jlong (*_Nonnull CallStaticLongMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - jfloat (*_Nonnull CallStaticFloatMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jfloat (*_Nonnull CallStaticFloatMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jfloat (*_Nonnull CallStaticFloatMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - jdouble (*_Nonnull CallStaticDoubleMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jdouble (*_Nonnull CallStaticDoubleMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jdouble (*_Nonnull CallStaticDoubleMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - void (*_Nonnull CallStaticVoidMethod)(JNIEnv *_Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - void (*_Nonnull CallStaticVoidMethodV)(JNIEnv *_Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - void (*_Nonnull CallStaticVoidMethodA)(JNIEnv *_Nonnull, jclass, jmethodID, const jvalue *_Nonnull); - - jfieldID (*_Nonnull GetStaticFieldID)(JNIEnv *_Nonnull, jclass, const char *_Nonnull, const char *_Nonnull); - - jobject (*_Nonnull GetStaticObjectField)(JNIEnv *_Nonnull, jclass, jfieldID); - jboolean (*_Nonnull GetStaticBooleanField)(JNIEnv *_Nonnull, jclass, jfieldID); - jbyte (*_Nonnull GetStaticByteField)(JNIEnv *_Nonnull, jclass, jfieldID); - jchar (*_Nonnull GetStaticCharField)(JNIEnv *_Nonnull, jclass, jfieldID); - jshort (*_Nonnull GetStaticShortField)(JNIEnv *_Nonnull, jclass, jfieldID); - jint (*_Nonnull GetStaticIntField)(JNIEnv *_Nonnull, jclass, jfieldID); - jlong (*_Nonnull GetStaticLongField)(JNIEnv *_Nonnull, jclass, jfieldID); - jfloat (*_Nonnull GetStaticFloatField)(JNIEnv *_Nonnull, jclass, jfieldID); - jdouble (*_Nonnull GetStaticDoubleField)(JNIEnv *_Nonnull, jclass, jfieldID); - - void (*_Nonnull SetStaticObjectField)(JNIEnv *_Nonnull, jclass, jfieldID, jobject); - void (*_Nonnull SetStaticBooleanField)(JNIEnv *_Nonnull, jclass, jfieldID, jboolean); - void (*_Nonnull SetStaticByteField)(JNIEnv *_Nonnull, jclass, jfieldID, jbyte); - void (*_Nonnull SetStaticCharField)(JNIEnv *_Nonnull, jclass, jfieldID, jchar); - void (*_Nonnull SetStaticShortField)(JNIEnv *_Nonnull, jclass, jfieldID, jshort); - void (*_Nonnull SetStaticIntField)(JNIEnv *_Nonnull, jclass, jfieldID, jint); - void (*_Nonnull SetStaticLongField)(JNIEnv *_Nonnull, jclass, jfieldID, jlong); - void (*_Nonnull SetStaticFloatField)(JNIEnv *_Nonnull, jclass, jfieldID, jfloat); - void (*_Nonnull SetStaticDoubleField)(JNIEnv *_Nonnull, jclass, jfieldID, jdouble); - - jstring (*_Nonnull NewString)(JNIEnv *_Nonnull, const jchar *, jsize); - jsize (*_Nonnull GetStringLength)(JNIEnv *_Nonnull, jstring); - const jchar *(*_Nonnull GetStringChars)(JNIEnv *_Nonnull, jstring, jboolean *_Nonnull); - void (*_Nonnull ReleaseStringChars)(JNIEnv *_Nonnull, jstring, const jchar *_Nonnull); - jstring (*_Nonnull NewStringUTF)(JNIEnv *_Nonnull, const char *_Nonnull); - jsize (*_Nonnull GetStringUTFLength)(JNIEnv *_Nonnull, jstring); + jobject (* _Nonnull ToReflectedField)(JNIEnv * _Nonnull, jclass, jfieldID, jboolean); + + jint (* _Nonnull Throw)(JNIEnv * _Nonnull, jthrowable); + jint (* _Nonnull ThrowNew)(JNIEnv * _Nonnull, jclass, const char * _Nonnull); + jthrowable (* _Nonnull ExceptionOccurred)(JNIEnv * _Nonnull); + void (* _Nonnull ExceptionDescribe)(JNIEnv * _Nonnull); + void (* _Nonnull ExceptionClear)(JNIEnv * _Nonnull); + void (* _Nonnull FatalError)(JNIEnv * _Nonnull, const char * _Nonnull); + + jint (* _Nonnull PushLocalFrame)(JNIEnv * _Nonnull, jint); + jobject (* _Nonnull PopLocalFrame)(JNIEnv * _Nonnull, jobject); + + jobject (* _Nonnull NewGlobalRef)(JNIEnv * _Nonnull, jobject); + void (* _Nonnull DeleteGlobalRef)(JNIEnv * _Nonnull, jobject); + void (* _Nonnull DeleteLocalRef)(JNIEnv * _Nonnull, jobject); + jboolean (* _Nonnull IsSameObject)(JNIEnv * _Nonnull, jobject, jobject); + + jobject (* _Nonnull NewLocalRef)(JNIEnv * _Nonnull, jobject); + jint (* _Nonnull EnsureLocalCapacity)(JNIEnv * _Nonnull, jint); + + jobject (* _Nonnull AllocObject)(JNIEnv * _Nonnull, jclass); + jobject (* _Nonnull NewObject)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'newObject' instead); + jobject (* _Nonnull NewObjectV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'newObject' instead); + jobject (* _Nonnull NewObjectA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(NewObject); + + jclass (* _Nonnull GetObjectClass)(JNIEnv * _Nonnull, jobject); + jboolean (* _Nonnull IsInstanceOf)(JNIEnv * _Nonnull, jobject, jclass); + jmethodID (* _Nonnull GetMethodID)(JNIEnv * _Nonnull, jclass, const char * _Nonnull, const char * _Nonnull); + + jobject (* _Nonnull CallObjectMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + jobject (* _Nonnull CallObjectMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jobject (* _Nonnull CallObjectMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallObjectMethod); + jboolean (* _Nonnull CallBooleanMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + jboolean (* _Nonnull CallBooleanMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jboolean (* _Nonnull CallBooleanMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallBooleanMethod); + jbyte (* _Nonnull CallByteMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + jbyte (* _Nonnull CallByteMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jbyte (* _Nonnull CallByteMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallByteMethod); + jchar (* _Nonnull CallCharMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + jchar (* _Nonnull CallCharMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jchar (* _Nonnull CallCharMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallCharMethod); + jshort (* _Nonnull CallShortMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + jshort (* _Nonnull CallShortMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jshort (* _Nonnull CallShortMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallShortMethod); + jint (* _Nonnull CallIntMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + jint (* _Nonnull CallIntMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jint (* _Nonnull CallIntMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallIntMethod); + jlong (* _Nonnull CallLongMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + jlong (* _Nonnull CallLongMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jlong (* _Nonnull CallLongMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallLongMethod); + jfloat (* _Nonnull CallFloatMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + jfloat (* _Nonnull CallFloatMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jfloat (* _Nonnull CallFloatMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallFloatMethod); + jdouble (* _Nonnull CallDoubleMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + jdouble (* _Nonnull CallDoubleMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jdouble (* _Nonnull CallDoubleMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallDoubleMethod); + void (* _Nonnull CallVoidMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); + void (* _Nonnull CallVoidMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); + void (* _Nonnull CallVoidMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallVoidMethod); + + jobject (* _Nonnull CallNonvirtualObjectMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jobject (* _Nonnull CallNonvirtualObjectMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jobject (* _Nonnull CallNonvirtualObjectMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + jboolean (* _Nonnull CallNonvirtualBooleanMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jboolean (* _Nonnull CallNonvirtualBooleanMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jboolean (* _Nonnull CallNonvirtualBooleanMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + jbyte (* _Nonnull CallNonvirtualByteMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jbyte (* _Nonnull CallNonvirtualByteMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jbyte (* _Nonnull CallNonvirtualByteMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + jchar (* _Nonnull CallNonvirtualCharMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jchar (* _Nonnull CallNonvirtualCharMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jchar (* _Nonnull CallNonvirtualCharMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + jshort (* _Nonnull CallNonvirtualShortMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jshort (* _Nonnull CallNonvirtualShortMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jshort (* _Nonnull CallNonvirtualShortMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + jint (* _Nonnull CallNonvirtualIntMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jint (* _Nonnull CallNonvirtualIntMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jint (* _Nonnull CallNonvirtualIntMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + jlong (* _Nonnull CallNonvirtualLongMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jlong (* _Nonnull CallNonvirtualLongMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jlong (* _Nonnull CallNonvirtualLongMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + jfloat (* _Nonnull CallNonvirtualFloatMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jfloat (* _Nonnull CallNonvirtualFloatMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jfloat (* _Nonnull CallNonvirtualFloatMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + jdouble (* _Nonnull CallNonvirtualDoubleMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jdouble (* _Nonnull CallNonvirtualDoubleMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + jdouble (* _Nonnull CallNonvirtualDoubleMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + void (* _Nonnull CallNonvirtualVoidMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + void (* _Nonnull CallNonvirtualVoidMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); + void (* _Nonnull CallNonvirtualVoidMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); + + jfieldID (* _Nonnull GetFieldID)(JNIEnv * _Nonnull, jclass, const char * _Nonnull, const char * _Nonnull); + + jobject (* _Nonnull GetObjectField)(JNIEnv * _Nonnull, jobject, jfieldID); + jboolean (* _Nonnull GetBooleanField)(JNIEnv * _Nonnull, jobject, jfieldID); + jbyte (* _Nonnull GetByteField)(JNIEnv * _Nonnull, jobject, jfieldID); + jchar (* _Nonnull GetCharField)(JNIEnv * _Nonnull, jobject, jfieldID); + jshort (* _Nonnull GetShortField)(JNIEnv * _Nonnull, jobject, jfieldID); + jint (* _Nonnull GetIntField)(JNIEnv * _Nonnull, jobject, jfieldID); + jlong (* _Nonnull GetLongField)(JNIEnv * _Nonnull, jobject, jfieldID); + jfloat (* _Nonnull GetFloatField)(JNIEnv * _Nonnull, jobject, jfieldID); + jdouble (* _Nonnull GetDoubleField)(JNIEnv * _Nonnull, jobject, jfieldID); + + void (* _Nonnull SetObjectField)(JNIEnv * _Nonnull, jobject, jfieldID, jobject); + void (* _Nonnull SetBooleanField)(JNIEnv * _Nonnull, jobject, jfieldID, jboolean); + void (* _Nonnull SetByteField)(JNIEnv * _Nonnull, jobject, jfieldID, jbyte); + void (* _Nonnull SetCharField)(JNIEnv * _Nonnull, jobject, jfieldID, jchar); + void (* _Nonnull SetShortField)(JNIEnv * _Nonnull, jobject, jfieldID, jshort); + void (* _Nonnull SetIntField)(JNIEnv * _Nonnull, jobject, jfieldID, jint); + void (* _Nonnull SetLongField)(JNIEnv * _Nonnull, jobject, jfieldID, jlong); + void (* _Nonnull SetFloatField)(JNIEnv * _Nonnull, jobject, jfieldID, jfloat); + void (* _Nonnull SetDoubleField)(JNIEnv * _Nonnull, jobject, jfieldID, jdouble); + + jmethodID (* _Nonnull GetStaticMethodID)(JNIEnv * _Nonnull, jclass, const char * _Nonnull, const char * _Nonnull); + + jobject (* _Nonnull CallStaticObjectMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jobject (* _Nonnull CallStaticObjectMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jobject (* _Nonnull CallStaticObjectMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + jboolean (* _Nonnull CallStaticBooleanMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jboolean (* _Nonnull CallStaticBooleanMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jboolean (* _Nonnull CallStaticBooleanMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + jbyte (* _Nonnull CallStaticByteMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jbyte (* _Nonnull CallStaticByteMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jbyte (* _Nonnull CallStaticByteMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + jchar (* _Nonnull CallStaticCharMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jchar (* _Nonnull CallStaticCharMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jchar (* _Nonnull CallStaticCharMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + jshort (* _Nonnull CallStaticShortMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jshort (* _Nonnull CallStaticShortMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jshort (* _Nonnull CallStaticShortMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + jint (* _Nonnull CallStaticIntMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jint (* _Nonnull CallStaticIntMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jint (* _Nonnull CallStaticIntMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + jlong (* _Nonnull CallStaticLongMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jlong (* _Nonnull CallStaticLongMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jlong (* _Nonnull CallStaticLongMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + jfloat (* _Nonnull CallStaticFloatMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jfloat (* _Nonnull CallStaticFloatMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jfloat (* _Nonnull CallStaticFloatMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + jdouble (* _Nonnull CallStaticDoubleMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + jdouble (* _Nonnull CallStaticDoubleMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + jdouble (* _Nonnull CallStaticDoubleMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + void (* _Nonnull CallStaticVoidMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); + void (* _Nonnull CallStaticVoidMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); + void (* _Nonnull CallStaticVoidMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); + + jfieldID (* _Nonnull GetStaticFieldID)(JNIEnv * _Nonnull, jclass, const char * _Nonnull, const char * _Nonnull); + + jobject (* _Nonnull GetStaticObjectField)(JNIEnv * _Nonnull, jclass, jfieldID); + jboolean (* _Nonnull GetStaticBooleanField)(JNIEnv * _Nonnull, jclass, jfieldID); + jbyte (* _Nonnull GetStaticByteField)(JNIEnv * _Nonnull, jclass, jfieldID); + jchar (* _Nonnull GetStaticCharField)(JNIEnv * _Nonnull, jclass, jfieldID); + jshort (* _Nonnull GetStaticShortField)(JNIEnv * _Nonnull, jclass, jfieldID); + jint (* _Nonnull GetStaticIntField)(JNIEnv * _Nonnull, jclass, jfieldID); + jlong (* _Nonnull GetStaticLongField)(JNIEnv * _Nonnull, jclass, jfieldID); + jfloat (* _Nonnull GetStaticFloatField)(JNIEnv * _Nonnull, jclass, jfieldID); + jdouble (* _Nonnull GetStaticDoubleField)(JNIEnv * _Nonnull, jclass, jfieldID); + + void (* _Nonnull SetStaticObjectField)(JNIEnv * _Nonnull, jclass, jfieldID, jobject); + void (* _Nonnull SetStaticBooleanField)(JNIEnv * _Nonnull, jclass, jfieldID, jboolean); + void (* _Nonnull SetStaticByteField)(JNIEnv * _Nonnull, jclass, jfieldID, jbyte); + void (* _Nonnull SetStaticCharField)(JNIEnv * _Nonnull, jclass, jfieldID, jchar); + void (* _Nonnull SetStaticShortField)(JNIEnv * _Nonnull, jclass, jfieldID, jshort); + void (* _Nonnull SetStaticIntField)(JNIEnv * _Nonnull, jclass, jfieldID, jint); + void (* _Nonnull SetStaticLongField)(JNIEnv * _Nonnull, jclass, jfieldID, jlong); + void (* _Nonnull SetStaticFloatField)(JNIEnv * _Nonnull, jclass, jfieldID, jfloat); + void (* _Nonnull SetStaticDoubleField)(JNIEnv * _Nonnull, jclass, jfieldID, jdouble); + + jstring (* _Nonnull NewString)(JNIEnv * _Nonnull, const jchar * _Nonnull, jsize); + jsize (* _Nonnull GetStringLength)(JNIEnv * _Nonnull, jstring); + const jchar *(* _Nonnull GetStringChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nonnull); + void (* _Nonnull ReleaseStringChars)(JNIEnv * _Nonnull, jstring, const jchar * _Nonnull); + jstring (* _Nonnull NewStringUTF)(JNIEnv * _Nonnull, const char * _Nonnull); + jsize (* _Nonnull GetStringUTFLength)(JNIEnv * _Nonnull, jstring); /* JNI spec says this returns const jbyte*, but that's inconsistent */ - const char *(*_Nonnull GetStringUTFChars)(JNIEnv *_Nonnull, jstring, jboolean *_Nonnull); - void (*_Nonnull ReleaseStringUTFChars)(JNIEnv *_Nonnull, jstring, const char *_Nonnull); - jsize (*_Nonnull GetArrayLength)(JNIEnv *_Nonnull, jarray); - jobjectArray (*_Nonnull NewObjectArray)(JNIEnv *_Nonnull, jsize, jclass, jobject); - jobject (*_Nonnull GetObjectArrayElement)(JNIEnv *_Nonnull, jobjectArray, jsize); - void (*_Nonnull SetObjectArrayElement)(JNIEnv *_Nonnull, jobjectArray, jsize, jobject); - - jbooleanArray (*_Nonnull NewBooleanArray)(JNIEnv *_Nonnull, jsize); - jbyteArray (*_Nonnull NewByteArray)(JNIEnv *_Nonnull, jsize); - jcharArray (*_Nonnull NewCharArray)(JNIEnv *_Nonnull, jsize); - jshortArray (*_Nonnull NewShortArray)(JNIEnv *_Nonnull, jsize); - jintArray (*_Nonnull NewIntArray)(JNIEnv *_Nonnull, jsize); - jlongArray (*_Nonnull NewLongArray)(JNIEnv *_Nonnull, jsize); - jfloatArray (*_Nonnull NewFloatArray)(JNIEnv *_Nonnull, jsize); - jdoubleArray (*_Nonnull NewDoubleArray)(JNIEnv *_Nonnull, jsize); - - jboolean *_Nullable (*_Nonnull GetBooleanArrayElements)(JNIEnv *_Nonnull, jbooleanArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); - jbyte *_Nullable (*_Nonnull GetByteArrayElements)(JNIEnv *_Nonnull, jbyteArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); - jchar *_Nullable (*_Nonnull GetCharArrayElements)(JNIEnv *_Nonnull, jcharArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); - jshort *_Nullable (*_Nonnull GetShortArrayElements)(JNIEnv *_Nonnull, jshortArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); - jint *_Nullable (*_Nonnull GetIntArrayElements)(JNIEnv *_Nonnull, jintArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); - jlong *_Nullable (*_Nonnull GetLongArrayElements)(JNIEnv *_Nonnull, jlongArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); - jfloat *_Nullable (*_Nonnull GetFloatArrayElements)(JNIEnv *_Nonnull, jfloatArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); - jdouble *_Nullable (*_Nonnull GetDoubleArrayElements)(JNIEnv *_Nonnull, jdoubleArray, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayElements); - - void (*_Nonnull ReleaseBooleanArrayElements)(JNIEnv *_Nonnull, jbooleanArray, jboolean *, jint) CF_SWIFT_NAME(releaseArrayElements); - void (*_Nonnull ReleaseByteArrayElements)(JNIEnv *_Nonnull, jbyteArray, jbyte *, jint) CF_SWIFT_NAME(releaseArrayElements); - void (*_Nonnull ReleaseCharArrayElements)(JNIEnv *_Nonnull, jcharArray, jchar *, jint) CF_SWIFT_NAME(releaseArrayElements); - void (*_Nonnull ReleaseShortArrayElements)(JNIEnv *_Nonnull, jshortArray, jshort *, jint) CF_SWIFT_NAME(releaseArrayElements); - void (*_Nonnull ReleaseIntArrayElements)(JNIEnv *_Nonnull, jintArray, jint *, jint) CF_SWIFT_NAME(releaseArrayElements); - void (*_Nonnull ReleaseLongArrayElements)(JNIEnv *_Nonnull, jlongArray, jlong *, jint) CF_SWIFT_NAME(releaseArrayElements); - void (*_Nonnull ReleaseFloatArrayElements)(JNIEnv *_Nonnull, jfloatArray, jfloat *, jint) CF_SWIFT_NAME(releaseArrayElements); - void (*_Nonnull ReleaseDoubleArrayElements)(JNIEnv *_Nonnull, jdoubleArray, jdouble *, jint) CF_SWIFT_NAME(releaseArrayElements); - - void (*_Nonnull GetBooleanArrayRegion)(JNIEnv *_Nonnull, jbooleanArray, jsize, jsize, jboolean *_Nonnull) CF_SWIFT_NAME(getArrayRegion); - void (*_Nonnull GetByteArrayRegion)(JNIEnv *_Nonnull, jbyteArray, jsize, jsize, jbyte *_Nonnull) CF_SWIFT_NAME(getArrayRegion); - void (*_Nonnull GetCharArrayRegion)(JNIEnv *_Nonnull, jcharArray, jsize, jsize, jchar *_Nonnull) CF_SWIFT_NAME(getArrayRegion); - void (*_Nonnull GetShortArrayRegion)(JNIEnv *_Nonnull, jshortArray, jsize, jsize, jshort *_Nonnull) CF_SWIFT_NAME(getArrayRegion); - void (*_Nonnull GetIntArrayRegion)(JNIEnv *_Nonnull, jintArray, jsize, jsize, jint *_Nonnull) CF_SWIFT_NAME(getArrayRegion); - void (*_Nonnull GetLongArrayRegion)(JNIEnv *_Nonnull, jlongArray, jsize, jsize, jlong *_Nonnull) CF_SWIFT_NAME(getArrayRegion); - void (*_Nonnull GetFloatArrayRegion)(JNIEnv *_Nonnull, jfloatArray, jsize, jsize, jfloat *_Nonnull) CF_SWIFT_NAME(getArrayRegion); - void (*_Nonnull GetDoubleArrayRegion)(JNIEnv *_Nonnull, jdoubleArray, jsize, jsize, jdouble *_Nonnull) CF_SWIFT_NAME(getArrayRegion); + const char *(* _Nonnull GetStringUTFChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nonnull); + void (* _Nonnull ReleaseStringUTFChars)(JNIEnv * _Nonnull, jstring, const char * _Nonnull); + jsize (* _Nonnull GetArrayLength)(JNIEnv * _Nonnull, jarray); + jobjectArray (* _Nonnull NewObjectArray)(JNIEnv * _Nonnull, jsize, jclass, jobject); + jobject (* _Nonnull GetObjectArrayElement)(JNIEnv * _Nonnull, jobjectArray, jsize); + void (* _Nonnull SetObjectArrayElement)(JNIEnv * _Nonnull, jobjectArray, jsize, jobject); + + jbooleanArray (* _Nonnull NewBooleanArray)(JNIEnv * _Nonnull, jsize); + jbyteArray (* _Nonnull NewByteArray)(JNIEnv * _Nonnull, jsize); + jcharArray (* _Nonnull NewCharArray)(JNIEnv * _Nonnull, jsize); + jshortArray (* _Nonnull NewShortArray)(JNIEnv * _Nonnull, jsize); + jintArray (* _Nonnull NewIntArray)(JNIEnv * _Nonnull, jsize); + jlongArray (* _Nonnull NewLongArray)(JNIEnv * _Nonnull, jsize); + jfloatArray (* _Nonnull NewFloatArray)(JNIEnv * _Nonnull, jsize); + jdoubleArray (* _Nonnull NewDoubleArray)(JNIEnv * _Nonnull, jsize); + + jboolean * _Nullable (* _Nonnull GetBooleanArrayElements)(JNIEnv * _Nonnull, jbooleanArray, jboolean * _Nonnull); + jbyte * _Nullable (* _Nonnull GetByteArrayElements)(JNIEnv * _Nonnull, jbyteArray, jboolean * _Nonnull); + jchar * _Nullable (* _Nonnull GetCharArrayElements)(JNIEnv * _Nonnull, jcharArray, jboolean * _Nonnull); + jshort * _Nullable (* _Nonnull GetShortArrayElements)(JNIEnv * _Nonnull, jshortArray, jboolean * _Nonnull); + jint * _Nullable (* _Nonnull GetIntArrayElements)(JNIEnv * _Nonnull, jintArray, jboolean * _Nonnull); + jlong * _Nullable (* _Nonnull GetLongArrayElements)(JNIEnv * _Nonnull, jlongArray, jboolean * _Nonnull); + jfloat * _Nullable (* _Nonnull GetFloatArrayElements)(JNIEnv * _Nonnull, jfloatArray, jboolean * _Nonnull); + jdouble * _Nullable (* _Nonnull GetDoubleArrayElements)(JNIEnv * _Nonnull, jdoubleArray, jboolean * _Nonnull); + + void (* _Nonnull ReleaseBooleanArrayElements)(JNIEnv * _Nonnull, jbooleanArray, jboolean *, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseByteArrayElements)(JNIEnv * _Nonnull, jbyteArray, jbyte *, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseCharArrayElements)(JNIEnv * _Nonnull, jcharArray, jchar *, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseShortArrayElements)(JNIEnv * _Nonnull, jshortArray, jshort *, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseIntArrayElements)(JNIEnv * _Nonnull, jintArray, jint *, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseLongArrayElements)(JNIEnv * _Nonnull, jlongArray, jlong *, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseFloatArrayElements)(JNIEnv * _Nonnull, jfloatArray, jfloat *, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseDoubleArrayElements)(JNIEnv * _Nonnull, jdoubleArray, jdouble *, jint) CF_SWIFT_NAME(ReleaseArrayElements); + + void (* _Nonnull GetBooleanArrayRegion)(JNIEnv * _Nonnull, jbooleanArray, jsize, jsize, jboolean * _Nonnull); + void (* _Nonnull GetByteArrayRegion)(JNIEnv * _Nonnull, jbyteArray, jsize, jsize, jbyte * _Nonnull); + void (* _Nonnull GetCharArrayRegion)(JNIEnv * _Nonnull, jcharArray, jsize, jsize, jchar * _Nonnull); + void (* _Nonnull GetShortArrayRegion)(JNIEnv * _Nonnull, jshortArray, jsize, jsize, jshort * _Nonnull); + void (* _Nonnull GetIntArrayRegion)(JNIEnv * _Nonnull, jintArray, jsize, jsize, jint * _Nonnull); + void (* _Nonnull GetLongArrayRegion)(JNIEnv * _Nonnull, jlongArray, jsize, jsize, jlong * _Nonnull); + void (* _Nonnull GetFloatArrayRegion)(JNIEnv * _Nonnull, jfloatArray, jsize, jsize, jfloat * _Nonnull); + void (* _Nonnull GetDoubleArrayRegion)(JNIEnv * _Nonnull, jdoubleArray, jsize, jsize, jdouble * _Nonnull); /* spec shows these without const; some jni.h do, some don't */ - void (*_Nonnull SetBooleanArrayRegion)(JNIEnv *_Nonnull, jbooleanArray, jsize, jsize, const jboolean *_Nonnull) CF_SWIFT_NAME(setArrayRegion); - void (*_Nonnull SetByteArrayRegion)(JNIEnv *_Nonnull, jbyteArray, jsize, jsize, const jbyte *_Nonnull) CF_SWIFT_NAME(setArrayRegion); - void (*_Nonnull SetCharArrayRegion)(JNIEnv *_Nonnull, jcharArray, jsize, jsize, const jchar *_Nonnull) CF_SWIFT_NAME(setArrayRegion); - void (*_Nonnull SetShortArrayRegion)(JNIEnv *_Nonnull, jshortArray, jsize, jsize, const jshort *_Nonnull) CF_SWIFT_NAME(setArrayRegion); - void (*_Nonnull SetIntArrayRegion)(JNIEnv *_Nonnull, jintArray, jsize, jsize, const jint *_Nonnull) CF_SWIFT_NAME(setArrayRegion); - void (*_Nonnull SetLongArrayRegion)(JNIEnv *_Nonnull, jlongArray, jsize, jsize, const jlong *_Nonnull) CF_SWIFT_NAME(setArrayRegion); - void (*_Nonnull SetFloatArrayRegion)(JNIEnv *_Nonnull, jfloatArray, jsize, jsize, const jfloat *_Nonnull) CF_SWIFT_NAME(setArrayRegion); - void (*_Nonnull SetDoubleArrayRegion)(JNIEnv *_Nonnull, jdoubleArray, jsize, jsize, const jdouble *_Nonnull) CF_SWIFT_NAME(setArrayRegion); + void (* _Nonnull SetBooleanArrayRegion)(JNIEnv * _Nonnull, jbooleanArray, jsize, jsize, const jboolean * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); + void (* _Nonnull SetByteArrayRegion)(JNIEnv * _Nonnull, jbyteArray, jsize, jsize, const jbyte * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); + void (* _Nonnull SetCharArrayRegion)(JNIEnv * _Nonnull, jcharArray, jsize, jsize, const jchar * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); + void (* _Nonnull SetShortArrayRegion)(JNIEnv * _Nonnull, jshortArray, jsize, jsize, const jshort * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); + void (* _Nonnull SetIntArrayRegion)(JNIEnv * _Nonnull, jintArray, jsize, jsize, const jint * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); + void (* _Nonnull SetLongArrayRegion)(JNIEnv * _Nonnull, jlongArray, jsize, jsize, const jlong * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); + void (* _Nonnull SetFloatArrayRegion)(JNIEnv * _Nonnull, jfloatArray, jsize, jsize, const jfloat * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); + void (* _Nonnull SetDoubleArrayRegion)(JNIEnv * _Nonnull, jdoubleArray, jsize, jsize, const jdouble * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - jint (*_Nonnull RegisterNatives)(JNIEnv *_Nonnull, jclass, const JNINativeMethod *, jint); - jint (*_Nonnull UnregisterNatives)(JNIEnv *_Nonnull, jclass); - jint (*_Nonnull MonitorEnter)(JNIEnv *_Nonnull, jobject); - jint (*_Nonnull MonitorExit)(JNIEnv *_Nonnull, jobject); - jint (*_Nonnull GetJavaVM)(JNIEnv *_Nonnull, JavaVM **_Nonnull); + jint (* _Nonnull RegisterNatives)(JNIEnv * _Nonnull, jclass, const JNINativeMethod *, jint); + jint (* _Nonnull UnregisterNatives)(JNIEnv * _Nonnull, jclass); + jint (* _Nonnull MonitorEnter)(JNIEnv * _Nonnull, jobject); + jint (* _Nonnull MonitorExit)(JNIEnv * _Nonnull, jobject); + jint (* _Nonnull GetJavaVM)(JNIEnv * _Nonnull, JavaVM * _Nonnull* _Nonnull); - void (*_Nonnull GetStringRegion)(JNIEnv *_Nonnull, jstring, jsize, jsize, jchar *_Nonnull); - void (*_Nonnull GetStringUTFRegion)(JNIEnv *_Nonnull, jstring, jsize, jsize, char *_Nonnull); + void (* _Nonnull GetStringRegion)(JNIEnv * _Nonnull, jstring, jsize, jsize, jchar * _Nonnull); + void (* _Nonnull GetStringUTFRegion)(JNIEnv * _Nonnull, jstring, jsize, jsize, char * _Nonnull); - void *(*_Nonnull GetPrimitiveArrayCritical)(JNIEnv *_Nonnull, jarray, jboolean *_Nonnull); - void (*_Nonnull ReleasePrimitiveArrayCritical)(JNIEnv *_Nonnull, jarray, void *, jint); + void *(* _Nonnull GetPrimitiveArrayCritical)(JNIEnv * _Nonnull, jarray, jboolean * _Nonnull); + void (* _Nonnull ReleasePrimitiveArrayCritical)(JNIEnv * _Nonnull, jarray, void *, jint); - const jchar *(*_Nonnull GetStringCritical)(JNIEnv *_Nonnull, jstring, jboolean *_Nonnull); - void (*_Nonnull ReleaseStringCritical)(JNIEnv *_Nonnull, jstring, const jchar *_Nonnull); + const jchar *(* _Nonnull GetStringCritical)(JNIEnv * _Nonnull, jstring, jboolean * _Nonnull); + void (* _Nonnull ReleaseStringCritical)(JNIEnv * _Nonnull, jstring, const jchar * _Nonnull); - jweak (*_Nonnull NewWeakGlobalRef)(JNIEnv *_Nonnull, jobject); - void (*_Nonnull DeleteWeakGlobalRef)(JNIEnv *_Nonnull, jweak); + jweak (* _Nonnull NewWeakGlobalRef)(JNIEnv * _Nonnull, jobject); + void (* _Nonnull DeleteWeakGlobalRef)(JNIEnv * _Nonnull, jweak); - jboolean (*_Nonnull ExceptionCheck)(JNIEnv *_Nonnull); + jboolean (* _Nonnull ExceptionCheck)(JNIEnv * _Nonnull); - jobject (*_Nonnull NewDirectByteBuffer)(JNIEnv *_Nonnull, void *_Nonnull, jlong); - void *_Nullable (*_Nonnull GetDirectBufferAddress)(JNIEnv *_Nonnull, jobject); - jlong (*_Nonnull GetDirectBufferCapacity)(JNIEnv *_Nonnull, jobject); + jobject (* _Nonnull NewDirectByteBuffer)(JNIEnv * _Nonnull, void * _Nonnull, jlong); + void * _Nullable (* _Nonnull GetDirectBufferAddress)(JNIEnv * _Nonnull, jobject); + jlong (* _Nonnull GetDirectBufferCapacity)(JNIEnv * _Nonnull, jobject); /* added in JNI 1.6 */ - jobjectRefType (*_Nonnull GetObjectRefType)(JNIEnv *_Nonnull, jobject); + jobjectRefType (* _Nonnull GetObjectRefType)(JNIEnv * _Nonnull, jobject); }; /* @@ -478,7 +478,7 @@ struct JNINativeInterface struct _JNIEnv { /* do not rename this; it does not seem to be entirely opaque */ - const struct JNINativeInterface *_Nonnull functions; + const struct JNINativeInterface * _Nonnull functions; #if defined(__cplusplus) @@ -487,7 +487,7 @@ struct _JNIEnv return functions->GetVersion(this); } - jclass DefineClass(const char *_Nonnullname, jobject loader, const jbyte *buf, + jclass DefineClass(const char * _Nonnullname, jobject loader, const jbyte *buf, jsize bufLen) { return functions->DefineClass(this, name, loader, buf, bufLen); @@ -617,7 +617,7 @@ struct _JNIEnv return functions->NewObjectV(this, clazz, methodID, args); } - jobject NewObjectA(jclass clazz, jmethodID methodID, const jvalue *_Nonnull args) + jobject NewObjectA(jclass clazz, jmethodID methodID, const jvalue * _Nonnull args) { return functions->NewObjectA(this, clazz, methodID, args); } @@ -656,7 +656,7 @@ struct _JNIEnv } #define CALL_TYPE_METHODA(_jtype, _jname) \ \ _jtype Call##_jname##MethodA(jobject obj, jmethodID methodID, \ - const jvalue *_Nonnull args) \ + const jvalue * _Nonnull args) \ { \ return functions->Call##_jname##MethodA(this, obj, methodID, args); \ } @@ -687,7 +687,7 @@ struct _JNIEnv { functions->CallVoidMethodV(this, obj, methodID, args); } - void CallVoidMethodA(jobject obj, jmethodID methodID, const jvalue *_Nonnull args) + void CallVoidMethodA(jobject obj, jmethodID methodID, const jvalue * _Nonnull args) { functions->CallVoidMethodA(this, obj, methodID, args); } @@ -713,7 +713,7 @@ struct _JNIEnv } #define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) \ \ _jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz, \ - jmethodID methodID, const jvalue *_Nonnull args) \ + jmethodID methodID, const jvalue * _Nonnull args) \ { \ return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz, \ methodID, args); \ @@ -748,7 +748,7 @@ struct _JNIEnv functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); } void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, - jmethodID methodID, const jvalue *_Nonnull args) + jmethodID methodID, const jvalue * _Nonnull args) { functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); } @@ -862,7 +862,7 @@ struct _JNIEnv } #define CALL_STATIC_TYPE_METHODA(_jtype, _jname) \ \ _jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID, \ - const jvalue *_Nonnull args) \ + const jvalue * _Nonnull args) \ { \ return functions->CallStatic##_jname##MethodA(this, clazz, methodID, \ args); \ @@ -894,7 +894,7 @@ struct _JNIEnv { functions->CallStaticVoidMethodV(this, clazz, methodID, args); } - void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, const jvalue *_Nonnull args) + void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, const jvalue * _Nonnull args) { functions->CallStaticVoidMethodA(this, clazz, methodID, args); } @@ -1336,11 +1336,11 @@ struct JNIInvokeInterface void *reserved1; void *reserved2; - jint (*_Nonnull DestroyJavaVM)(JavaVM *_Nonnull); - jint (*_Nonnull AttachCurrentThread)(JavaVM *, JNIEnv **, void *_Nonnull); - jint (*_Nonnull DetachCurrentThread)(JavaVM *_Nonnull); - jint (*_Nonnull GetEnv)(JavaVM *, void **, jint); - jint (*_Nonnull AttachCurrentThreadAsDaemon)(JavaVM *, JNIEnv **, void *_Nonnull); + jint (* _Nonnull DestroyJavaVM)(JavaVM * _Nonnull); + jint (* _Nonnull AttachCurrentThread)(JavaVM *, JNIEnv **, void * _Nullable); + jint (* _Nonnull DetachCurrentThread)(JavaVM * _Nonnull); + jint (* _Nonnull GetEnv)(JavaVM *, void **, jint); + jint (* _Nonnull AttachCurrentThreadAsDaemon)(JavaVM *, JNIEnv **, void * _Nonnull); }; /* diff --git a/Sources/JNISwift/JNI.swift b/Sources/JNISwift/JNI.swift index 851b8e2..3101980 100644 --- a/Sources/JNISwift/JNI.swift +++ b/Sources/JNISwift/JNI.swift @@ -12,7 +12,7 @@ public class JNI { // so use this mutable _tmpPointer as an intermediate: var _tmpPointer: UnsafeMutableRawPointer? let threadStatus = jvm.GetEnv(_jvm, &_tmpPointer, JavaInt(JNI_VERSION_1_6)) - var _env = _tmpPointer!.bindMemory(to: JNIEnv.self, capacity: 1) + var _env = _tmpPointer?.bindMemory(to: JNIEnv.self, capacity: 1) switch threadStatus.bigEndian { case JNI_OK: break // if we're already attached, do nothing @@ -24,13 +24,12 @@ public class JNI { default: break } - return _env + return _env! } // Normally we init the jni global ourselves in JNI_OnLoad - public init?(jvm: UnsafeMutablePointer) { - if jvm == nil { return nil } + public init?(jvm: UnsafeMutablePointer) { self._jvm = jvm } } @@ -38,31 +37,31 @@ public class JNI { public extension JNI { public func GetVersion() -> JavaInt { let env = self._env - return env.pointee!.pointee.GetVersion(env) + return env.pointee.pointee.GetVersion(env) } - public func GetJavaVM(vm: UnsafeMutablePointer?>) -> JavaInt { + public func GetJavaVM(vm: UnsafeMutablePointer>) -> JavaInt { let env = self._env - return env.pointee!.pointee.GetJavaVM(env, vm) + return env.pointee.pointee.GetJavaVM(env, vm) } public func RegisterNatives(targetClass: JavaClass, _ methods: UnsafePointer, _ nMethods: JavaInt) -> JavaInt { let env = self._env - return env.pointee!.pointee.RegisterNatives(env, targetClass, methods, nMethods) + return env.pointee.pointee.RegisterNatives(env, targetClass, methods, nMethods) } public func UnregisterNatives(targetClass: JavaClass) -> JavaInt { let env = self._env - return env.pointee!.pointee.UnregisterNatives(env, targetClass) + return env.pointee.pointee.UnregisterNatives(env, targetClass) } public func MonitorEnter(obj: JavaObject) -> JavaInt { let env = self._env - return env.pointee!.pointee.MonitorEnter(env, obj) + return env.pointee.pointee.MonitorEnter(env, obj) } public func MonitorExit(obj: JavaObject) -> JavaInt { let env = self._env - return env.pointee!.pointee.MonitorExit(env, obj) + return env.pointee.pointee.MonitorExit(env, obj) } } diff --git a/Sources/JNISwift/JNIObjects.swift b/Sources/JNISwift/JNIObjects.swift index 8dbde99..029d398 100644 --- a/Sources/JNISwift/JNIObjects.swift +++ b/Sources/JNISwift/JNIObjects.swift @@ -8,19 +8,13 @@ public extension JNI { } public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: JavaParameter...) -> JavaObject { - return self.NewObjectA(targetClass: targetClass, methodID, args) + return self.NewObject(targetClass: targetClass, methodID, args) } - @available(*, unavailable, message:"CVaListPointer unavailable, use NewObject or NewObjectA") - public func NewObjectV(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: CVaListPointer) -> JavaObject { - let env = self._env - return env.pointee.pointee.NewObjectV(env, targetClass, methodID, args)! - } - - public func NewObjectA(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) -> JavaObject { + public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) -> JavaObject { let env = self._env var mutableArgs = args - return env.pointee.pointee.NewObjectA(env, targetClass, methodID, &mutableArgs)! + return env.pointee.pointee.NewObject(env, targetClass, methodID, &mutableArgs)! } public func GetObjectClass(obj: JavaObject) -> JavaClass? { diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index 86dc3fe..02b4f2c 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -4,7 +4,7 @@ import Dispatch public var jni: JNI! // this gets set "OnLoad" so should always exist @_silgen_name("JNI_OnLoad") -public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutablePointer) -> JavaInt { +public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutableRawPointer) -> JavaInt { guard let localJNI = JNI(jvm: jvm) else { fatalError("Couldn't initialise JNI") @@ -12,19 +12,19 @@ public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutab jni = localJNI // set the global for use elsewhere - #if os(Android) + #if os(Android) && swift(>=4) // FIXME: Only available in Swift 4.0 - // DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) + DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) #endif return JNI_VERSION_1_6 } public func JNI_DetachCurrentThread() { - jni._jvm.pointee?.pointee.DetachCurrentThread(jni._jvm) + _ = jni._jvm.pointee.pointee.DetachCurrentThread(jni._jvm) } -extension JavaBoolean : BooleanLiteralConvertible { +extension JavaBoolean : ExpressibleByBooleanLiteral { public init(booleanLiteral value: Bool) { self = value ? JavaBoolean(JNI_TRUE) : JavaBoolean(JNI_FALSE) } @@ -42,7 +42,7 @@ extension JNI { public func ThrowNew(message: String) { let _env = self._env let env = _env.pointee.pointee - env.ThrowNew(_env, env.FindClass(_env, "java/lang/Exception"), message) + _ = env.ThrowNew(_env, env.FindClass(_env, "java/lang/Exception"), message) } /// - Note: This shouldn't need to be cleaned up because we're not taking ownership of the reference @@ -81,13 +81,13 @@ extension JNI { } // TODO: make parameters take [JavaParameter], being a swifty version of [JavaParameter] with reference counting etc. - public func CallVoidMethodA(object: JavaObject, methodID method: JavaMethodID, parameters: [JavaParameter]) { + public func CallVoidMethod(object: JavaObject, methodID method: JavaMethodID, parameters: [JavaParameter]) { let _env = self._env var methodArgs = parameters - _env.pointee.pointee.CallVoidMethodA(_env, object, method, &methodArgs) + _env.pointee.pointee.CallVoidMethod(_env, object, method, &methodArgs) } - public func CallStaticIntMethodA(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) -> JavaInt { + public func CallStaticIntMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) -> JavaInt { let _env = self._env var methodArgs = parameters return _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) @@ -95,13 +95,13 @@ extension JNI { // MARK: Arrays - public func GetArrayLength(array: jarray) -> Int { + public func GetArrayLength(array: JavaArray) -> Int { let _env = self._env let result = _env.pointee.pointee.GetArrayLength(_env, array) return Int(result) } - public func NewIntArray(count: Int) -> jarray? { + public func NewIntArray(count: Int) -> JavaArray? { let _env = self._env let result = _env.pointee.pointee.NewIntArray(_env, jsize(count)) return (result != nil) ? result : .none @@ -123,10 +123,10 @@ extension JNI { public func SetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, from sourceElements: [Int]) { let _env = self._env var newElements = sourceElements.map { JavaInt($0) } // make mutable copy - _env.pointee.pointee.SetIntArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } - public func NewFloatArray(count: Int) -> jarray? { + public func NewFloatArray(count: Int) -> JavaArray? { let _env = self._env let result = _env.pointee.pointee.NewFloatArray(_env, jsize(count)) return (result != nil) ? result : .none @@ -148,7 +148,7 @@ extension JNI { public func SetFloatArrayRegion(array: JavaFloatArray, startIndex: Int = 0, from sourceElements: [Float]) { let _env = self._env var newElements = sourceElements.map { JavaFloat($0) } // make mutable copy - _env.pointee.pointee.SetFloatArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } } @@ -226,7 +226,7 @@ public struct JavaCallback { } public func apply(args: [JavaParameter]) { - jni.CallVoidMethodA(object: jobj, methodID: methodID, parameters: args) + jni.CallVoidMethod(object: jobj, methodID: methodID, parameters: args) } /// Send variadic parameters to the func that takes an array From 9482fb8e4fa9aad9510588cd02df92f3a0aaeb21 Mon Sep 17 00:00:00 2001 From: rikner Date: Mon, 17 Jul 2017 12:34:06 +0200 Subject: [PATCH 05/84] jni methods --- Sources/JNISwift/JNIMethods.swift | 143 ++++++++++++++++++------------ 1 file changed, 86 insertions(+), 57 deletions(-) diff --git a/Sources/JNISwift/JNIMethods.swift b/Sources/JNISwift/JNIMethods.swift index 8e95fc7..a459ee0 100644 --- a/Sources/JNISwift/JNIMethods.swift +++ b/Sources/JNISwift/JNIMethods.swift @@ -1,57 +1,86 @@ -// protocol JavaParameterConvertible { -// typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) -// static var asJNIParameterString: String { get } -// func toJavaParameter() -> JavaParameter -// static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Self -// } - -// extension Bool: JavaParameterConvertible { -// static var asJNIParameterString: String { return "z" } - -// func toJavaParameter() -> JavaParameter { -// return JavaParameter(bool: (self) ? 1 : 0) -// } - -// static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { -// return true // jni.CallStaticBooleanMethod(nil, nil, args) == 1 -// } -// } - -// struct InvalidParameters: Error {} - -// extension Array where Element == JavaParameterConvertible.Type { -// func methodSignature(returnType: JavaParameterConvertible.Type) -> String { -// let argumentTypes = self.reduce("", { (result, type) -> String in -// return result + type.asJNIParameterString -// }) - -// return "(" + argumentTypes + ")" + returnType.asJNIParameterString -// } -// } - -// func javaStaticMethod(_ method: String, on javaClass: JavaClass, parameterTypes: [JavaParameterConvertible.Type]) throws -> (T.JavaMethod) { - -// // guard let methodID = jni.GetStaticMethodID() else { throw Error } - -// return { (args: JavaParameterConvertible...) in -// if parameterTypes.count != args.count { -// throw InvalidParameters() -// } - -// try args.enumerated().forEach({ arg in -// let (i, element) = arg -// if type(of: element) != parameterTypes[i] { -// throw InvalidParameters() -// } -// }) - -// let javaParameters = args.map { $0.toJavaParameter() } -// return T.fromStaticMethod(calling: methodID, on: javaClass, args: args) -// } -// } - -// // func lol() throws -> Bool { -// // let obj = JavaObject.allocate(bytes: 1, alignedTo: 1) -// // let myFunc: Bool.JavaMethod = try javaStaticMethod("asd", on: obj, parameterTypes: [Bool.self]) -// // return try myFunc(true) -// // } +import CJNI + +protocol JavaParameterConvertible { + typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) + static var asJNIParameterString: String { get } + func toJavaParameter() -> JavaParameter + static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Self +} + +extension Bool: JavaParameterConvertible { + static var asJNIParameterString: String { return "z" } + + func toJavaParameter() -> JavaParameter { + return JavaParameter(bool: (self) ? 1 : 0) + } + + static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { + return true // jni.CallStaticBooleanMethod(nil, nil, args) == 1 + } +} + +struct InvalidParameters: Error {} + +extension Array where Element == JavaParameterConvertible { + func methodSignature(returnType: JavaParameterConvertible.Type) -> String { + let argumentTypes = self.reduce("", { (result, argument) -> String in + return result + type(of: argument).asJNIParameterString + }) + + return "(" + argumentTypes + ")" + returnType.asJNIParameterString + } +} + +func javaStaticMethod(_ method: String, on javaClass: JavaClass, arguments: JavaParameterConvertible...) throws -> T { + + let methodSignature = arguments.methodSignature(returnType: T.self) + guard let methodID = jni.GetStaticMethodID(javaClass: javaClass, methodName: method, methodSignature: methodSignature) else { throw InvalidParameters() } + + let javaParameters = arguments.map { $0.toJavaParameter() } + return T.fromStaticMethod(calling: methodID, on: javaClass, args: javaParameters) +} + + +func callMyJavaStaticMethod() throws -> Bool { + let obj = JavaObject.allocate(bytes: 1, alignedTo: 1) + return try javaStaticMethod("asd", on: obj, arguments: true) +} + + +extension Array where Element == JavaParameterConvertible.Type { + func methodSignature(returnType: JavaParameterConvertible.Type) -> String { + let argumentTypes = self.reduce("", { (result, type) -> String in + return result + type.asJNIParameterString + }) + + return "(" + argumentTypes + ")" + returnType.asJNIParameterString + } +} + +func javaStaticMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameterTypes: [JavaParameterConvertible.Type]) throws -> (T.JavaMethod) { + + // guard let methodID = jni.GetStaticMethodID() else { throw Error } + + return { (args: JavaParameterConvertible...) in + if parameterTypes.count != args.count { + throw InvalidParameters() + } + + try args.enumerated().forEach({ arg in + let (i, element) = arg + if type(of: element) != parameterTypes[i] { + throw InvalidParameters() + } + }) + + let javaParameters = args.map { $0.toJavaParameter() } + + return T.fromStaticMethod(calling: method, on: javaClass, args: javaParameters) + } +} + + // func lol() throws -> Bool { + // let obj = JavaObject.allocate(bytes: 1, alignedTo: 1) + // let myFunc: Bool.JavaMethod = try javaStaticMethod("asd", on: obj, parameterTypes: [Bool.self]) + // return try myFunc(true) + // } From 0b07b80ca784c003257c616e1f257fa1fa6afe32 Mon Sep 17 00:00:00 2001 From: rikner Date: Tue, 18 Jul 2017 11:03:04 +0200 Subject: [PATCH 06/84] add CallStaticVoidMethod, GetObjectArrayElement --- Sources/JNISwift/SwiftJNI.swift | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index 02b4f2c..7ea8cf3 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -93,6 +93,12 @@ extension JNI { return _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) } + public func CallStaticVoidMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) { + let _env = self._env + var methodArgs = parameters + _env.pointee.pointee.CallStaticVoidMethodA(_env, javaClass, method, &methodArgs) + } + // MARK: Arrays public func GetArrayLength(array: JavaArray) -> Int { @@ -101,6 +107,14 @@ extension JNI { return Int(result) } + public func GetObjectArrayElement(array: JavaArray, index: Int) -> JavaObject { + let _env = self._env + let result = _env.pointee.pointee.GetObjectArrayElement(_env, array, jsize(index)) + + if result == nil { FatalError(msg: "could not get object array element") } + return result! + } + public func NewIntArray(count: Int) -> JavaArray? { let _env = self._env let result = _env.pointee.pointee.NewIntArray(_env, jsize(count)) From 51195a5184b3800d1054c417891a8c298aa5fdb6 Mon Sep 17 00:00:00 2001 From: rikner Date: Tue, 18 Jul 2017 11:05:21 +0200 Subject: [PATCH 07/84] wip on JNIMethods, public JavaParameterConvertible, javaStaticMethod, --- Sources/JNISwift/JNIMethods.swift | 36 +++++++++++++++++++++++-------- 1 file changed, 27 insertions(+), 9 deletions(-) diff --git a/Sources/JNISwift/JNIMethods.swift b/Sources/JNISwift/JNIMethods.swift index a459ee0..254c8e5 100644 --- a/Sources/JNISwift/JNIMethods.swift +++ b/Sources/JNISwift/JNIMethods.swift @@ -1,6 +1,6 @@ import CJNI -protocol JavaParameterConvertible { +public protocol JavaParameterConvertible { typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) static var asJNIParameterString: String { get } func toJavaParameter() -> JavaParameter @@ -8,17 +8,29 @@ protocol JavaParameterConvertible { } extension Bool: JavaParameterConvertible { - static var asJNIParameterString: String { return "z" } + public static var asJNIParameterString: String { return "z" } - func toJavaParameter() -> JavaParameter { + public func toJavaParameter() -> JavaParameter { return JavaParameter(bool: (self) ? 1 : 0) } - static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { + public static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { return true // jni.CallStaticBooleanMethod(nil, nil, args) == 1 } } +//extension Void: JavaParameterConvertible { +// public static var asJNIParameterString: String { return "V" } +// +// public func toJavaParameter() -> JavaParameter { +// return JavaParameter.init(object: nil) +// } +// +// public static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { +// jni.CallStaticVoidMethod(javaClass: javaClass, method: calling, parameters: args) +// } +//} + struct InvalidParameters: Error {} extension Array where Element == JavaParameterConvertible { @@ -31,7 +43,13 @@ extension Array where Element == JavaParameterConvertible { } } -func javaStaticMethod(_ method: String, on javaClass: JavaClass, arguments: JavaParameterConvertible...) throws -> T { + +// +//public func javaStaticMethod(_ method: String, on javaClass: JavaClass) throws -> T { +// javaStaticMethod(method, on: javaClass, arguments: JavaParameterConvertible...) +//} + +public func javaStaticMethod(_ method: String, on javaClass: JavaClass, arguments: JavaParameterConvertible...) throws -> T { let methodSignature = arguments.methodSignature(returnType: T.self) guard let methodID = jni.GetStaticMethodID(javaClass: javaClass, methodName: method, methodSignature: methodSignature) else { throw InvalidParameters() } @@ -41,10 +59,10 @@ func javaStaticMethod(_ method: String, on javaClas } -func callMyJavaStaticMethod() throws -> Bool { - let obj = JavaObject.allocate(bytes: 1, alignedTo: 1) - return try javaStaticMethod("asd", on: obj, arguments: true) -} +//func callMyJavaStaticMethod() throws -> Bool { +// let class = JavaObject.allocate(bytes: 1, alignedTo: 1) +// return try javaStaticMethod("asd", on: obj, arguments: true) +//} extension Array where Element == JavaParameterConvertible.Type { From 703f9efbef4de0fa86689c8712d9aa622588fe0a Mon Sep 17 00:00:00 2001 From: rikner Date: Tue, 18 Jul 2017 11:06:05 +0200 Subject: [PATCH 08/84] move build.sh --- JNISwift/build.sh => build.sh | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename JNISwift/build.sh => build.sh (100%) diff --git a/JNISwift/build.sh b/build.sh similarity index 100% rename from JNISwift/build.sh rename to build.sh From fdd435e08f14a654d5278c589ff7e37664e2fc8a Mon Sep 17 00:00:00 2001 From: rikner Date: Tue, 18 Jul 2017 11:07:00 +0200 Subject: [PATCH 09/84] update xcodeproj files --- JNISwift.xcodeproj/CJNI_Info.plist | 25 + JNISwift.xcodeproj/JNISwift_Info.plist | 25 + JNISwift.xcodeproj/project.pbxproj | 549 ++++++++++++++++++ .../contents.xcworkspacedata | 2 +- .../xcshareddata/xcschemes/JNISwift.xcscheme | 86 +++ .../xcschemes/xcschememanagement.plist | 12 + JNISwift/JNISwift.xcodeproj/project.pbxproj | 261 --------- 7 files changed, 698 insertions(+), 262 deletions(-) create mode 100644 JNISwift.xcodeproj/CJNI_Info.plist create mode 100644 JNISwift.xcodeproj/JNISwift_Info.plist create mode 100644 JNISwift.xcodeproj/project.pbxproj rename {JNISwift/JNISwift.xcodeproj => JNISwift.xcodeproj}/project.xcworkspace/contents.xcworkspacedata (71%) create mode 100644 JNISwift.xcodeproj/xcshareddata/xcschemes/JNISwift.xcscheme create mode 100644 JNISwift.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist delete mode 100644 JNISwift/JNISwift.xcodeproj/project.pbxproj diff --git a/JNISwift.xcodeproj/CJNI_Info.plist b/JNISwift.xcodeproj/CJNI_Info.plist new file mode 100644 index 0000000..57ada9f --- /dev/null +++ b/JNISwift.xcodeproj/CJNI_Info.plist @@ -0,0 +1,25 @@ + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + $(CURRENT_PROJECT_VERSION) + NSPrincipalClass + + + diff --git a/JNISwift.xcodeproj/JNISwift_Info.plist b/JNISwift.xcodeproj/JNISwift_Info.plist new file mode 100644 index 0000000..57ada9f --- /dev/null +++ b/JNISwift.xcodeproj/JNISwift_Info.plist @@ -0,0 +1,25 @@ + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + $(CURRENT_PROJECT_VERSION) + NSPrincipalClass + + + diff --git a/JNISwift.xcodeproj/project.pbxproj b/JNISwift.xcodeproj/project.pbxproj new file mode 100644 index 0000000..d7f14fd --- /dev/null +++ b/JNISwift.xcodeproj/project.pbxproj @@ -0,0 +1,549 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + OBJ_32 /* JNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_9 /* JNI.swift */; }; + OBJ_33 /* JNIClassManipulation.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_10 /* JNIClassManipulation.swift */; }; + OBJ_34 /* JNIExceptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_11 /* JNIExceptions.swift */; }; + OBJ_35 /* JNIMethods.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_12 /* JNIMethods.swift */; }; + OBJ_36 /* JNIObjects.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_13 /* JNIObjects.swift */; }; + OBJ_37 /* JNIRefs.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_14 /* JNIRefs.swift */; }; + OBJ_38 /* JNIStrings.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_15 /* JNIStrings.swift */; }; + OBJ_39 /* SwiftJNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_16 /* SwiftJNI.swift */; }; + OBJ_41 /* CJNI.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = OBJ_26 /* CJNI.framework */; }; + OBJ_49 /* jni.c in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_18 /* jni.c */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 03A0C4AD1F1CD7FC004358A6 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = OBJ_1 /* Project object */; + proxyType = 1; + remoteGlobalIDString = OBJ_43; + remoteInfo = CJNI; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXFileReference section */ + 030CBFD31F1CD84200352724 /* build.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = build.sh; sourceTree = ""; }; + OBJ_10 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; + OBJ_11 /* JNIExceptions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIExceptions.swift; sourceTree = ""; }; + OBJ_12 /* JNIMethods.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIMethods.swift; sourceTree = ""; }; + OBJ_13 /* JNIObjects.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIObjects.swift; sourceTree = ""; }; + OBJ_14 /* JNIRefs.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIRefs.swift; sourceTree = ""; }; + OBJ_15 /* JNIStrings.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIStrings.swift; sourceTree = ""; }; + OBJ_16 /* SwiftJNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SwiftJNI.swift; sourceTree = ""; }; + OBJ_18 /* jni.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = jni.c; sourceTree = ""; }; + OBJ_20 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; + OBJ_21 /* module.modulemap */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.module-map"; name = module.modulemap; path = "/Users/erik/flowDev/swiftDev/swift-jni/Sources/CJNI/include/module.modulemap"; sourceTree = ""; }; + OBJ_25 /* JNISwift.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = JNISwift.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + OBJ_26 /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + OBJ_6 /* Package.swift */ = {isa = PBXFileReference; explicitFileType = sourcecode.swift; path = Package.swift; sourceTree = ""; }; + OBJ_9 /* JNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + OBJ_40 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 0; + files = ( + OBJ_41 /* CJNI.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + OBJ_50 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 0; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + OBJ_17 /* CJNI */ = { + isa = PBXGroup; + children = ( + OBJ_18 /* jni.c */, + OBJ_19 /* include */, + ); + name = CJNI; + path = Sources/CJNI; + sourceTree = SOURCE_ROOT; + }; + OBJ_19 /* include */ = { + isa = PBXGroup; + children = ( + OBJ_20 /* jni.h */, + OBJ_21 /* module.modulemap */, + ); + path = include; + sourceTree = ""; + }; + OBJ_22 /* Tests */ = { + isa = PBXGroup; + children = ( + ); + name = Tests; + sourceTree = SOURCE_ROOT; + }; + OBJ_24 /* Products */ = { + isa = PBXGroup; + children = ( + OBJ_25 /* JNISwift.framework */, + OBJ_26 /* CJNI.framework */, + ); + name = Products; + sourceTree = BUILT_PRODUCTS_DIR; + }; + OBJ_5 = { + isa = PBXGroup; + children = ( + 030CBFD31F1CD84200352724 /* build.sh */, + OBJ_6 /* Package.swift */, + OBJ_7 /* Sources */, + OBJ_22 /* Tests */, + OBJ_24 /* Products */, + ); + sourceTree = ""; + }; + OBJ_7 /* Sources */ = { + isa = PBXGroup; + children = ( + OBJ_8 /* JNISwift */, + OBJ_17 /* CJNI */, + ); + name = Sources; + sourceTree = SOURCE_ROOT; + }; + OBJ_8 /* JNISwift */ = { + isa = PBXGroup; + children = ( + OBJ_9 /* JNI.swift */, + OBJ_10 /* JNIClassManipulation.swift */, + OBJ_11 /* JNIExceptions.swift */, + OBJ_12 /* JNIMethods.swift */, + OBJ_13 /* JNIObjects.swift */, + OBJ_14 /* JNIRefs.swift */, + OBJ_15 /* JNIStrings.swift */, + OBJ_16 /* SwiftJNI.swift */, + ); + name = JNISwift; + path = Sources/JNISwift; + sourceTree = SOURCE_ROOT; + }; +/* End PBXGroup section */ + +/* Begin PBXLegacyTarget section */ + 030CBFD41F1CD93C00352724 /* JNISwift_SR */ = { + isa = PBXLegacyTarget; + buildArgumentsString = build.sh; + buildConfigurationList = 030CBFD51F1CD93C00352724 /* Build configuration list for PBXLegacyTarget "JNISwift_SR" */; + buildPhases = ( + ); + buildToolPath = /bin/bash; + buildWorkingDirectory = ""; + dependencies = ( + ); + name = JNISwift_SR; + passBuildSettingsInEnvironment = 1; + productName = JNISwift_SR; + }; +/* End PBXLegacyTarget section */ + +/* Begin PBXNativeTarget section */ + OBJ_27 /* JNISwift */ = { + isa = PBXNativeTarget; + buildConfigurationList = OBJ_28 /* Build configuration list for PBXNativeTarget "JNISwift" */; + buildPhases = ( + OBJ_31 /* Sources */, + OBJ_40 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + OBJ_42 /* PBXTargetDependency */, + ); + name = JNISwift; + productName = JNISwift; + productReference = OBJ_25 /* JNISwift.framework */; + productType = "com.apple.product-type.framework"; + }; + OBJ_43 /* CJNI */ = { + isa = PBXNativeTarget; + buildConfigurationList = OBJ_44 /* Build configuration list for PBXNativeTarget "CJNI" */; + buildPhases = ( + OBJ_47 /* ShellScript */, + OBJ_48 /* Sources */, + OBJ_50 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = CJNI; + productName = CJNI; + productReference = OBJ_26 /* CJNI.framework */; + productType = "com.apple.product-type.framework"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + OBJ_1 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 9999; + TargetAttributes = { + 030CBFD41F1CD93C00352724 = { + CreatedOnToolsVersion = 8.3.3; + DevelopmentTeam = FTSYMMN5B5; + ProvisioningStyle = Automatic; + }; + }; + }; + buildConfigurationList = OBJ_2 /* Build configuration list for PBXProject "JNISwift" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + ); + mainGroup = OBJ_5; + productRefGroup = OBJ_24 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + OBJ_27 /* JNISwift */, + OBJ_43 /* CJNI */, + 030CBFD41F1CD93C00352724 /* JNISwift_SR */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXShellScriptBuildPhase section */ + OBJ_47 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 0; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "mkdir -p \"${PROJECT_TEMP_DIR}/SymlinkLibs\"\nln -sf \"${BUILT_PRODUCTS_DIR}/${EXECUTABLE_PATH}\" \"${PROJECT_TEMP_DIR}/SymlinkLibs/lib${EXECUTABLE_NAME}.dylib\"\n"; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + OBJ_31 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 0; + files = ( + OBJ_32 /* JNI.swift in Sources */, + OBJ_33 /* JNIClassManipulation.swift in Sources */, + OBJ_34 /* JNIExceptions.swift in Sources */, + OBJ_35 /* JNIMethods.swift in Sources */, + OBJ_36 /* JNIObjects.swift in Sources */, + OBJ_37 /* JNIRefs.swift in Sources */, + OBJ_38 /* JNIStrings.swift in Sources */, + OBJ_39 /* SwiftJNI.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + OBJ_48 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 0; + files = ( + OBJ_49 /* jni.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + OBJ_42 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = OBJ_43 /* CJNI */; + targetProxy = 03A0C4AD1F1CD7FC004358A6 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin XCBuildConfiguration section */ + 030CBFD61F1CD93C00352724 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + DEBUGGING_SYMBOLS = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + DEVELOPMENT_TEAM = FTSYMMN5B5; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MTL_ENABLE_DEBUG_INFO = YES; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 030CBFD71F1CD93C00352724 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + DEVELOPMENT_TEAM = FTSYMMN5B5; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MTL_ENABLE_DEBUG_INFO = NO; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; + OBJ_29 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNISwift.xcodeproj/JNISwift_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + LIBRARY_SEARCH_PATHS = "$(PROJECT_TEMP_DIR)/SymlinkLibs/"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; + PRODUCT_BUNDLE_IDENTIFIER = JNISwift; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + TARGET_NAME = JNISwift; + }; + name = Debug; + }; + OBJ_3 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_OBJC_ARC = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + ENABLE_NS_ASSERTIONS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + MACOSX_DEPLOYMENT_TARGET = 10.10; + ONLY_ACTIVE_ARCH = YES; + OTHER_SWIFT_FLAGS = "-DXcode"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 3.0; + USE_HEADERMAP = NO; + }; + name = Debug; + }; + OBJ_30 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNISwift.xcodeproj/JNISwift_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + LIBRARY_SEARCH_PATHS = "$(PROJECT_TEMP_DIR)/SymlinkLibs/"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; + PRODUCT_BUNDLE_IDENTIFIER = JNISwift; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + TARGET_NAME = JNISwift; + }; + name = Release; + }; + OBJ_4 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_OBJC_ARC = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + GCC_OPTIMIZATION_LEVEL = s; + MACOSX_DEPLOYMENT_TARGET = 10.10; + OTHER_SWIFT_FLAGS = "-DXcode"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; + SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; + SWIFT_VERSION = 3.0; + USE_HEADERMAP = NO; + }; + name = Release; + }; + OBJ_45 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEFINES_MODULE = NO; + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNISwift.xcodeproj/CJNI_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited)"; + PRODUCT_BUNDLE_IDENTIFIER = CJNI; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + TARGET_NAME = CJNI; + }; + name = Debug; + }; + OBJ_46 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEFINES_MODULE = NO; + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNISwift.xcodeproj/CJNI_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited)"; + PRODUCT_BUNDLE_IDENTIFIER = CJNI; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + TARGET_NAME = CJNI; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 030CBFD51F1CD93C00352724 /* Build configuration list for PBXLegacyTarget "JNISwift_SR" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 030CBFD61F1CD93C00352724 /* Debug */, + 030CBFD71F1CD93C00352724 /* Release */, + ); + defaultConfigurationIsVisible = 0; + }; + OBJ_2 /* Build configuration list for PBXProject "JNISwift" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + OBJ_3 /* Debug */, + OBJ_4 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + OBJ_28 /* Build configuration list for PBXNativeTarget "JNISwift" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + OBJ_29 /* Debug */, + OBJ_30 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + OBJ_44 /* Build configuration list for PBXNativeTarget "CJNI" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + OBJ_45 /* Debug */, + OBJ_46 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; +/* End XCConfigurationList section */ + }; + rootObject = OBJ_1 /* Project object */; +} diff --git a/JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata similarity index 71% rename from JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata rename to JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata index e6bd6f1..919434a 100644 --- a/JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata +++ b/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -2,6 +2,6 @@ + location = "self:"> diff --git a/JNISwift.xcodeproj/xcshareddata/xcschemes/JNISwift.xcscheme b/JNISwift.xcodeproj/xcshareddata/xcschemes/JNISwift.xcscheme new file mode 100644 index 0000000..1dfd20b --- /dev/null +++ b/JNISwift.xcodeproj/xcshareddata/xcschemes/JNISwift.xcscheme @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/JNISwift.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist b/JNISwift.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist new file mode 100644 index 0000000..a2facce --- /dev/null +++ b/JNISwift.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist @@ -0,0 +1,12 @@ + + + + SchemeUserState + + JNISwift.xcscheme + + + SuppressBuildableAutocreation + + + diff --git a/JNISwift/JNISwift.xcodeproj/project.pbxproj b/JNISwift/JNISwift.xcodeproj/project.pbxproj deleted file mode 100644 index 98fa8a6..0000000 --- a/JNISwift/JNISwift.xcodeproj/project.pbxproj +++ /dev/null @@ -1,261 +0,0 @@ -// !$*UTF8*$! -{ - archiveVersion = 1; - classes = { - }; - objectVersion = 46; - objects = { - -/* Begin PBXFileReference section */ - 032F84951F18BC2300E24174 /* jni.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; - 032F84961F18BC2300E24174 /* module.modulemap */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = "sourcecode.module-map"; path = module.modulemap; sourceTree = ""; }; - 032F84971F18BC2300E24174 /* jni.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = jni.c; sourceTree = ""; }; - 032F84991F18BC2300E24174 /* JNI.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; - 032F849A1F18BC2300E24174 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; - 032F849B1F18BC2300E24174 /* JNIExceptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIExceptions.swift; sourceTree = ""; }; - 032F849C1F18BC2300E24174 /* JNIMethods.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIMethods.swift; sourceTree = ""; }; - 032F849D1F18BC2300E24174 /* JNIObjects.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIObjects.swift; sourceTree = ""; }; - 032F849E1F18BC2300E24174 /* JNIRefs.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIRefs.swift; sourceTree = ""; }; - 032F849F1F18BC2300E24174 /* JNIStrings.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIStrings.swift; sourceTree = ""; }; - 032F84A01F18BC2300E24174 /* SwiftJNI.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SwiftJNI.swift; sourceTree = ""; }; - 032F84A21F18BD1E00E24174 /* Package.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = Package.swift; path = ../Package.swift; sourceTree = ""; }; - 032F84A31F18BD1E00E24174 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = README.md; path = ../README.md; sourceTree = ""; }; - 032F84A41F18BDE000E24174 /* build.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = build.sh; sourceTree = ""; }; -/* End PBXFileReference section */ - -/* Begin PBXGroup section */ - 032F84871F18BBF700E24174 = { - isa = PBXGroup; - children = ( - 032F84A41F18BDE000E24174 /* build.sh */, - 032F84A21F18BD1E00E24174 /* Package.swift */, - 032F84A31F18BD1E00E24174 /* README.md */, - 032F84921F18BC2300E24174 /* Sources */, - ); - sourceTree = ""; - }; - 032F84921F18BC2300E24174 /* Sources */ = { - isa = PBXGroup; - children = ( - 032F84931F18BC2300E24174 /* CJNI */, - 032F84981F18BC2300E24174 /* JNISwift */, - ); - name = Sources; - path = ../Sources; - sourceTree = ""; - }; - 032F84931F18BC2300E24174 /* CJNI */ = { - isa = PBXGroup; - children = ( - 032F84941F18BC2300E24174 /* include */, - 032F84971F18BC2300E24174 /* jni.c */, - ); - path = CJNI; - sourceTree = ""; - }; - 032F84941F18BC2300E24174 /* include */ = { - isa = PBXGroup; - children = ( - 032F84951F18BC2300E24174 /* jni.h */, - 032F84961F18BC2300E24174 /* module.modulemap */, - ); - path = include; - sourceTree = ""; - }; - 032F84981F18BC2300E24174 /* JNISwift */ = { - isa = PBXGroup; - children = ( - 032F84991F18BC2300E24174 /* JNI.swift */, - 032F849A1F18BC2300E24174 /* JNIClassManipulation.swift */, - 032F849B1F18BC2300E24174 /* JNIExceptions.swift */, - 032F849C1F18BC2300E24174 /* JNIMethods.swift */, - 032F849D1F18BC2300E24174 /* JNIObjects.swift */, - 032F849E1F18BC2300E24174 /* JNIRefs.swift */, - 032F849F1F18BC2300E24174 /* JNIStrings.swift */, - 032F84A01F18BC2300E24174 /* SwiftJNI.swift */, - ); - path = JNISwift; - sourceTree = ""; - }; -/* End PBXGroup section */ - -/* Begin PBXLegacyTarget section */ - 032F848C1F18BBF700E24174 /* JNISwift */ = { - isa = PBXLegacyTarget; - buildArgumentsString = build.sh; - buildConfigurationList = 032F848F1F18BBF700E24174 /* Build configuration list for PBXLegacyTarget "JNISwift" */; - buildPhases = ( - ); - buildToolPath = /bin/bash; - buildWorkingDirectory = ""; - dependencies = ( - ); - name = JNISwift; - passBuildSettingsInEnvironment = 1; - productName = JNISwift; - }; -/* End PBXLegacyTarget section */ - -/* Begin PBXProject section */ - 032F84881F18BBF700E24174 /* Project object */ = { - isa = PBXProject; - attributes = { - LastUpgradeCheck = 0830; - ORGANIZATIONNAME = flowkey; - TargetAttributes = { - 032F848C1F18BBF700E24174 = { - CreatedOnToolsVersion = 8.3.3; - DevelopmentTeam = FTSYMMN5B5; - ProvisioningStyle = Automatic; - }; - }; - }; - buildConfigurationList = 032F848B1F18BBF700E24174 /* Build configuration list for PBXProject "JNISwift" */; - compatibilityVersion = "Xcode 3.2"; - developmentRegion = English; - hasScannedForEncodings = 0; - knownRegions = ( - en, - ); - mainGroup = 032F84871F18BBF700E24174; - projectDirPath = ""; - projectRoot = ""; - targets = ( - 032F848C1F18BBF700E24174 /* JNISwift */, - ); - }; -/* End PBXProject section */ - -/* Begin XCBuildConfiguration section */ - 032F848D1F18BBF700E24174 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - ALWAYS_SEARCH_USER_PATHS = NO; - CLANG_ANALYZER_NONNULL = YES; - CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; - CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; - CLANG_CXX_LIBRARY = "libc++"; - CLANG_ENABLE_MODULES = YES; - CLANG_ENABLE_OBJC_ARC = YES; - CLANG_WARN_BOOL_CONVERSION = YES; - CLANG_WARN_CONSTANT_CONVERSION = YES; - CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; - CLANG_WARN_DOCUMENTATION_COMMENTS = YES; - CLANG_WARN_EMPTY_BODY = YES; - CLANG_WARN_ENUM_CONVERSION = YES; - CLANG_WARN_INFINITE_RECURSION = YES; - CLANG_WARN_INT_CONVERSION = YES; - CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; - CLANG_WARN_SUSPICIOUS_MOVE = YES; - CLANG_WARN_UNREACHABLE_CODE = YES; - CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; - COPY_PHASE_STRIP = NO; - DEBUG_INFORMATION_FORMAT = dwarf; - ENABLE_STRICT_OBJC_MSGSEND = YES; - ENABLE_TESTABILITY = YES; - GCC_C_LANGUAGE_STANDARD = gnu99; - GCC_DYNAMIC_NO_PIC = NO; - GCC_NO_COMMON_BLOCKS = YES; - GCC_OPTIMIZATION_LEVEL = 0; - GCC_PREPROCESSOR_DEFINITIONS = ( - "DEBUG=1", - "$(inherited)", - ); - GCC_WARN_64_TO_32_BIT_CONVERSION = YES; - GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; - GCC_WARN_UNDECLARED_SELECTOR = YES; - GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; - GCC_WARN_UNUSED_FUNCTION = YES; - GCC_WARN_UNUSED_VARIABLE = YES; - MTL_ENABLE_DEBUG_INFO = YES; - ONLY_ACTIVE_ARCH = YES; - }; - name = Debug; - }; - 032F848E1F18BBF700E24174 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - ALWAYS_SEARCH_USER_PATHS = NO; - CLANG_ANALYZER_NONNULL = YES; - CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; - CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; - CLANG_CXX_LIBRARY = "libc++"; - CLANG_ENABLE_MODULES = YES; - CLANG_ENABLE_OBJC_ARC = YES; - CLANG_WARN_BOOL_CONVERSION = YES; - CLANG_WARN_CONSTANT_CONVERSION = YES; - CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; - CLANG_WARN_DOCUMENTATION_COMMENTS = YES; - CLANG_WARN_EMPTY_BODY = YES; - CLANG_WARN_ENUM_CONVERSION = YES; - CLANG_WARN_INFINITE_RECURSION = YES; - CLANG_WARN_INT_CONVERSION = YES; - CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; - CLANG_WARN_SUSPICIOUS_MOVE = YES; - CLANG_WARN_UNREACHABLE_CODE = YES; - CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; - COPY_PHASE_STRIP = NO; - DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; - ENABLE_NS_ASSERTIONS = NO; - ENABLE_STRICT_OBJC_MSGSEND = YES; - GCC_C_LANGUAGE_STANDARD = gnu99; - GCC_NO_COMMON_BLOCKS = YES; - GCC_WARN_64_TO_32_BIT_CONVERSION = YES; - GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; - GCC_WARN_UNDECLARED_SELECTOR = YES; - GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; - GCC_WARN_UNUSED_FUNCTION = YES; - GCC_WARN_UNUSED_VARIABLE = YES; - MTL_ENABLE_DEBUG_INFO = NO; - }; - name = Release; - }; - 032F84901F18BBF700E24174 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - DEBUGGING_SYMBOLS = YES; - DEBUG_INFORMATION_FORMAT = dwarf; - DEVELOPMENT_TEAM = FTSYMMN5B5; - GCC_GENERATE_DEBUGGING_SYMBOLS = YES; - GCC_OPTIMIZATION_LEVEL = 0; - OTHER_CFLAGS = ""; - OTHER_LDFLAGS = ""; - PRODUCT_NAME = "$(TARGET_NAME)"; - }; - name = Debug; - }; - 032F84911F18BBF700E24174 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; - DEVELOPMENT_TEAM = FTSYMMN5B5; - OTHER_CFLAGS = ""; - OTHER_LDFLAGS = ""; - PRODUCT_NAME = "$(TARGET_NAME)"; - }; - name = Release; - }; -/* End XCBuildConfiguration section */ - -/* Begin XCConfigurationList section */ - 032F848B1F18BBF700E24174 /* Build configuration list for PBXProject "JNISwift" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - 032F848D1F18BBF700E24174 /* Debug */, - 032F848E1F18BBF700E24174 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - 032F848F1F18BBF700E24174 /* Build configuration list for PBXLegacyTarget "JNISwift" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - 032F84901F18BBF700E24174 /* Debug */, - 032F84911F18BBF700E24174 /* Release */, - ); - defaultConfigurationIsVisible = 0; - }; -/* End XCConfigurationList section */ - }; - rootObject = 032F84881F18BBF700E24174 /* Project object */; -} From 9cbb896b6a8a3b8266f5110b14aaf290302dc35e Mon Sep 17 00:00:00 2001 From: Geordie J Date: Tue, 18 Jul 2017 17:29:50 +0200 Subject: [PATCH 10/84] Add a bunch of stuff for JNI method calling --- JNISwift.xcodeproj/CJNI_Info.plist | 25 ++ JNISwift.xcodeproj/JNISwift_Info.plist | 25 ++ JNISwift.xcodeproj/project.pbxproj | 413 ++++++++++++++++++ .../xcschemes/JNISwift-Package.xcscheme | 87 ++++ .../xcschemes/xcschememanagement.plist | 12 + Sources/CJNI/include/jni.h | 6 +- Sources/JNISwift/JNIExceptions.swift | 4 +- Sources/JNISwift/JNIMethods.swift | 182 +++++--- Sources/JNISwift/JNIStrings.swift | 4 +- Sources/JNISwift/SwiftJNI.swift | 124 ++++-- 10 files changed, 791 insertions(+), 91 deletions(-) create mode 100644 JNISwift.xcodeproj/CJNI_Info.plist create mode 100644 JNISwift.xcodeproj/JNISwift_Info.plist create mode 100644 JNISwift.xcodeproj/project.pbxproj create mode 100644 JNISwift.xcodeproj/xcshareddata/xcschemes/JNISwift-Package.xcscheme create mode 100644 JNISwift.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist diff --git a/JNISwift.xcodeproj/CJNI_Info.plist b/JNISwift.xcodeproj/CJNI_Info.plist new file mode 100644 index 0000000..57ada9f --- /dev/null +++ b/JNISwift.xcodeproj/CJNI_Info.plist @@ -0,0 +1,25 @@ + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + $(CURRENT_PROJECT_VERSION) + NSPrincipalClass + + + diff --git a/JNISwift.xcodeproj/JNISwift_Info.plist b/JNISwift.xcodeproj/JNISwift_Info.plist new file mode 100644 index 0000000..57ada9f --- /dev/null +++ b/JNISwift.xcodeproj/JNISwift_Info.plist @@ -0,0 +1,25 @@ + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + $(CURRENT_PROJECT_VERSION) + NSPrincipalClass + + + diff --git a/JNISwift.xcodeproj/project.pbxproj b/JNISwift.xcodeproj/project.pbxproj new file mode 100644 index 0000000..7ef22c8 --- /dev/null +++ b/JNISwift.xcodeproj/project.pbxproj @@ -0,0 +1,413 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + OBJ_32 /* JNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_14 /* JNI.swift */; }; + OBJ_33 /* JNIClassManipulation.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_15 /* JNIClassManipulation.swift */; }; + OBJ_34 /* JNIExceptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_16 /* JNIExceptions.swift */; }; + OBJ_35 /* JNIMethods.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_17 /* JNIMethods.swift */; }; + OBJ_36 /* JNIObjects.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_18 /* JNIObjects.swift */; }; + OBJ_37 /* JNIRefs.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_19 /* JNIRefs.swift */; }; + OBJ_38 /* JNIStrings.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_20 /* JNIStrings.swift */; }; + OBJ_39 /* SwiftJNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_21 /* SwiftJNI.swift */; }; + OBJ_41 /* CJNI.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = "JNISwift::CJNI::Product" /* CJNI.framework */; }; + OBJ_48 /* jni.c in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_9 /* jni.c */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 5C1D2F2E1F1E277B0006682E /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = OBJ_1 /* Project object */; + proxyType = 1; + remoteGlobalIDString = "JNISwift::CJNI"; + remoteInfo = CJNI; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXFileReference section */ + "JNISwift::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + "JNISwift::JNISwift::Product" /* JNISwift.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = JNISwift.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + OBJ_11 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; + OBJ_12 /* module.modulemap */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.module-map"; name = module.modulemap; path = "/Users/geordiejay/dev/flowkey/smartphone/RNPlayerComponent/NativePlayerIOS/FlowkeyPlayerSDL/Packages/UIKit/Packages/swift-jni/Sources/CJNI/include/module.modulemap"; sourceTree = ""; }; + OBJ_14 /* JNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; + OBJ_15 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; + OBJ_16 /* JNIExceptions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIExceptions.swift; sourceTree = ""; }; + OBJ_17 /* JNIMethods.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIMethods.swift; sourceTree = ""; }; + OBJ_18 /* JNIObjects.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIObjects.swift; sourceTree = ""; }; + OBJ_19 /* JNIRefs.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIRefs.swift; sourceTree = ""; }; + OBJ_20 /* JNIStrings.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIStrings.swift; sourceTree = ""; }; + OBJ_21 /* SwiftJNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SwiftJNI.swift; sourceTree = ""; }; + OBJ_23 /* JNISwift */ = {isa = PBXFileReference; lastKnownFileType = folder; path = JNISwift; sourceTree = SOURCE_ROOT; }; + OBJ_6 /* Package.swift */ = {isa = PBXFileReference; explicitFileType = sourcecode.swift; path = Package.swift; sourceTree = ""; }; + OBJ_9 /* jni.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = jni.c; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + OBJ_40 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 0; + files = ( + OBJ_41 /* CJNI.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + OBJ_49 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 0; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + OBJ_10 /* include */ = { + isa = PBXGroup; + children = ( + OBJ_11 /* jni.h */, + OBJ_12 /* module.modulemap */, + ); + path = include; + sourceTree = ""; + }; + OBJ_13 /* JNISwift */ = { + isa = PBXGroup; + children = ( + OBJ_14 /* JNI.swift */, + OBJ_15 /* JNIClassManipulation.swift */, + OBJ_16 /* JNIExceptions.swift */, + OBJ_17 /* JNIMethods.swift */, + OBJ_18 /* JNIObjects.swift */, + OBJ_19 /* JNIRefs.swift */, + OBJ_20 /* JNIStrings.swift */, + OBJ_21 /* SwiftJNI.swift */, + ); + name = JNISwift; + path = Sources/JNISwift; + sourceTree = SOURCE_ROOT; + }; + OBJ_22 /* Tests */ = { + isa = PBXGroup; + children = ( + ); + name = Tests; + sourceTree = SOURCE_ROOT; + }; + OBJ_24 /* Products */ = { + isa = PBXGroup; + children = ( + "JNISwift::JNISwift::Product" /* JNISwift.framework */, + "JNISwift::CJNI::Product" /* CJNI.framework */, + ); + name = Products; + sourceTree = BUILT_PRODUCTS_DIR; + }; + OBJ_5 /* */ = { + isa = PBXGroup; + children = ( + OBJ_6 /* Package.swift */, + OBJ_7 /* Sources */, + OBJ_22 /* Tests */, + OBJ_23 /* JNISwift */, + OBJ_24 /* Products */, + ); + name = ""; + sourceTree = ""; + }; + OBJ_7 /* Sources */ = { + isa = PBXGroup; + children = ( + OBJ_8 /* CJNI */, + OBJ_13 /* JNISwift */, + ); + name = Sources; + sourceTree = SOURCE_ROOT; + }; + OBJ_8 /* CJNI */ = { + isa = PBXGroup; + children = ( + OBJ_9 /* jni.c */, + OBJ_10 /* include */, + ); + name = CJNI; + path = Sources/CJNI; + sourceTree = SOURCE_ROOT; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + "JNISwift::CJNI" /* CJNI */ = { + isa = PBXNativeTarget; + buildConfigurationList = OBJ_44 /* Build configuration list for PBXNativeTarget "CJNI" */; + buildPhases = ( + OBJ_47 /* Sources */, + OBJ_49 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = CJNI; + productName = CJNI; + productReference = "JNISwift::CJNI::Product" /* CJNI.framework */; + productType = "com.apple.product-type.framework"; + }; + "JNISwift::JNISwift" /* JNISwift */ = { + isa = PBXNativeTarget; + buildConfigurationList = OBJ_28 /* Build configuration list for PBXNativeTarget "JNISwift" */; + buildPhases = ( + OBJ_31 /* Sources */, + OBJ_40 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + OBJ_42 /* PBXTargetDependency */, + ); + name = JNISwift; + productName = JNISwift; + productReference = "JNISwift::JNISwift::Product" /* JNISwift.framework */; + productType = "com.apple.product-type.framework"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + OBJ_1 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 9999; + }; + buildConfigurationList = OBJ_2 /* Build configuration list for PBXProject "JNISwift" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + ); + mainGroup = OBJ_5 /* */; + productRefGroup = OBJ_24 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + "JNISwift::JNISwift" /* JNISwift */, + "JNISwift::CJNI" /* CJNI */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + OBJ_31 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 0; + files = ( + OBJ_32 /* JNI.swift in Sources */, + OBJ_33 /* JNIClassManipulation.swift in Sources */, + OBJ_34 /* JNIExceptions.swift in Sources */, + OBJ_35 /* JNIMethods.swift in Sources */, + OBJ_36 /* JNIObjects.swift in Sources */, + OBJ_37 /* JNIRefs.swift in Sources */, + OBJ_38 /* JNIStrings.swift in Sources */, + OBJ_39 /* SwiftJNI.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + OBJ_47 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 0; + files = ( + OBJ_48 /* jni.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + OBJ_42 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = "JNISwift::CJNI" /* CJNI */; + targetProxy = 5C1D2F2E1F1E277B0006682E /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin XCBuildConfiguration section */ + OBJ_29 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNISwift.xcodeproj/JNISwift_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; + PRODUCT_BUNDLE_IDENTIFIER = JNISwift; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + SWIFT_VERSION = 3.0; + TARGET_NAME = JNISwift; + }; + name = Debug; + }; + OBJ_3 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_OBJC_ARC = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + ENABLE_NS_ASSERTIONS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + MACOSX_DEPLOYMENT_TARGET = 10.10; + ONLY_ACTIVE_ARCH = YES; + OTHER_SWIFT_FLAGS = "-DXcode"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + USE_HEADERMAP = NO; + }; + name = Debug; + }; + OBJ_30 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNISwift.xcodeproj/JNISwift_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; + PRODUCT_BUNDLE_IDENTIFIER = JNISwift; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + SWIFT_VERSION = 3.0; + TARGET_NAME = JNISwift; + }; + name = Release; + }; + OBJ_4 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_OBJC_ARC = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + GCC_OPTIMIZATION_LEVEL = s; + MACOSX_DEPLOYMENT_TARGET = 10.10; + OTHER_SWIFT_FLAGS = "-DXcode"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; + SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; + USE_HEADERMAP = NO; + }; + name = Release; + }; + OBJ_45 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEFINES_MODULE = NO; + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNISwift.xcodeproj/CJNI_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited)"; + PRODUCT_BUNDLE_IDENTIFIER = CJNI; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + TARGET_NAME = CJNI; + }; + name = Debug; + }; + OBJ_46 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEFINES_MODULE = NO; + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNISwift.xcodeproj/CJNI_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited)"; + PRODUCT_BUNDLE_IDENTIFIER = CJNI; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + TARGET_NAME = CJNI; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + OBJ_2 /* Build configuration list for PBXProject "JNISwift" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + OBJ_3 /* Debug */, + OBJ_4 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + OBJ_28 /* Build configuration list for PBXNativeTarget "JNISwift" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + OBJ_29 /* Debug */, + OBJ_30 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + OBJ_44 /* Build configuration list for PBXNativeTarget "CJNI" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + OBJ_45 /* Debug */, + OBJ_46 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; +/* End XCConfigurationList section */ + }; + rootObject = OBJ_1 /* Project object */; +} diff --git a/JNISwift.xcodeproj/xcshareddata/xcschemes/JNISwift-Package.xcscheme b/JNISwift.xcodeproj/xcshareddata/xcschemes/JNISwift-Package.xcscheme new file mode 100644 index 0000000..55091cd --- /dev/null +++ b/JNISwift.xcodeproj/xcshareddata/xcschemes/JNISwift-Package.xcscheme @@ -0,0 +1,87 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/JNISwift.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist b/JNISwift.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist new file mode 100644 index 0000000..6566254 --- /dev/null +++ b/JNISwift.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist @@ -0,0 +1,12 @@ + + + + SchemeUserState + + JNISwift-Package.xcscheme + + + SuppressBuildableAutocreation + + + diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index 4dcb2ff..47dc543 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -383,13 +383,13 @@ struct JNINativeInterface jstring (* _Nonnull NewString)(JNIEnv * _Nonnull, const jchar * _Nonnull, jsize); jsize (* _Nonnull GetStringLength)(JNIEnv * _Nonnull, jstring); - const jchar *(* _Nonnull GetStringChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nonnull); + const jchar *(* _Nonnull GetStringChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nullable); void (* _Nonnull ReleaseStringChars)(JNIEnv * _Nonnull, jstring, const jchar * _Nonnull); jstring (* _Nonnull NewStringUTF)(JNIEnv * _Nonnull, const char * _Nonnull); jsize (* _Nonnull GetStringUTFLength)(JNIEnv * _Nonnull, jstring); /* JNI spec says this returns const jbyte*, but that's inconsistent */ - const char *(* _Nonnull GetStringUTFChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nonnull); - void (* _Nonnull ReleaseStringUTFChars)(JNIEnv * _Nonnull, jstring, const char * _Nonnull); + const char * _Nonnull(* _Nonnull GetStringUTFChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nullable); + void (* _Nonnull ReleaseStringUTFChars)(JNIEnv * _Nonnull, jstring, const char * _Nullable); jsize (* _Nonnull GetArrayLength)(JNIEnv * _Nonnull, jarray); jobjectArray (* _Nonnull NewObjectArray)(JNIEnv * _Nonnull, jsize, jclass, jobject); jobject (* _Nonnull GetObjectArrayElement)(JNIEnv * _Nonnull, jobjectArray, jsize); diff --git a/Sources/JNISwift/JNIExceptions.swift b/Sources/JNISwift/JNIExceptions.swift index b362859..3762194 100644 --- a/Sources/JNISwift/JNIExceptions.swift +++ b/Sources/JNISwift/JNIExceptions.swift @@ -1,9 +1,9 @@ import CJNI public extension JNI { - public func ExceptionCheck() -> JavaBoolean { + public func ExceptionCheck() -> Bool { let env = self._env - return env.pointee.pointee.ExceptionCheck(env) + return env.pointee.pointee.ExceptionCheck(env) == true } public func ExceptionDescribe() { diff --git a/Sources/JNISwift/JNIMethods.swift b/Sources/JNISwift/JNIMethods.swift index 8e95fc7..b50f5a5 100644 --- a/Sources/JNISwift/JNIMethods.swift +++ b/Sources/JNISwift/JNIMethods.swift @@ -1,57 +1,125 @@ -// protocol JavaParameterConvertible { -// typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) -// static var asJNIParameterString: String { get } -// func toJavaParameter() -> JavaParameter -// static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Self -// } - -// extension Bool: JavaParameterConvertible { -// static var asJNIParameterString: String { return "z" } - -// func toJavaParameter() -> JavaParameter { -// return JavaParameter(bool: (self) ? 1 : 0) -// } - -// static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { -// return true // jni.CallStaticBooleanMethod(nil, nil, args) == 1 -// } -// } - -// struct InvalidParameters: Error {} - -// extension Array where Element == JavaParameterConvertible.Type { -// func methodSignature(returnType: JavaParameterConvertible.Type) -> String { -// let argumentTypes = self.reduce("", { (result, type) -> String in -// return result + type.asJNIParameterString -// }) - -// return "(" + argumentTypes + ")" + returnType.asJNIParameterString -// } -// } - -// func javaStaticMethod(_ method: String, on javaClass: JavaClass, parameterTypes: [JavaParameterConvertible.Type]) throws -> (T.JavaMethod) { - -// // guard let methodID = jni.GetStaticMethodID() else { throw Error } - -// return { (args: JavaParameterConvertible...) in -// if parameterTypes.count != args.count { -// throw InvalidParameters() -// } - -// try args.enumerated().forEach({ arg in -// let (i, element) = arg -// if type(of: element) != parameterTypes[i] { -// throw InvalidParameters() -// } -// }) - -// let javaParameters = args.map { $0.toJavaParameter() } -// return T.fromStaticMethod(calling: methodID, on: javaClass, args: args) -// } -// } - -// // func lol() throws -> Bool { -// // let obj = JavaObject.allocate(bytes: 1, alignedTo: 1) -// // let myFunc: Bool.JavaMethod = try javaStaticMethod("asd", on: obj, parameterTypes: [Bool.self]) -// // return try myFunc(true) -// // } +import CJNI + +@discardableResult +@_silgen_name("__android_log_write") +public func androidPrint(_ prio: Int32, _ tag: UnsafePointer, _ text: UnsafePointer) -> Int32 + +func print(_ string: String) { + androidPrint(5, "SwiftJNI", string) +} + +struct InvalidParameters: Error {} + +public protocol JavaParameterConvertible { + typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) + static var asJNIParameterString: String { get } + func toJavaParameter() -> JavaParameter + static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self +} + +extension Bool: JavaParameterConvertible { + public static var asJNIParameterString: String { return "z" } + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(bool: (self) ? 1 : 0) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Bool { + return try jni.CallStaticBooleanMethod(methodID, on: javaClass, parameters: args) + } +} + +extension String: JavaParameterConvertible { + public static var asJNIParameterString: String { return "Ljava/lang/String;" } + + public func toJavaParameter() -> JavaParameter { + let stringAsObject = jni.NewStringUTF(self) + return JavaParameter(object: stringAsObject) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> String { + let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) + return jni.GetString(from: jObject) + } +} + +extension Array where Element == JavaParameterConvertible.Type { + func methodSignature(returnType: JavaParameterConvertible.Type) -> String { + let argumentTypes = self.reduce("", { (result, type) -> String in + return result + type.asJNIParameterString + }) + + return "(" + argumentTypes + ")" + returnType.asJNIParameterString + } +} + +extension Array where Element == JavaParameterConvertible { + func methodSignature(returnType: JavaParameterConvertible.Type) -> String { + let argumentTypes = self.reduce("", { (result, argument) -> String in + return result + type(of: argument).asJNIParameterString + }) + + return "(" + argumentTypes + ")" + returnType.asJNIParameterString + } +} + +extension String { + func replacingFullstopsWithSlashes() -> String { + let replacedCharacters = self.characters.map { ($0 == ".") ? "/" : $0 } + return String(String.CharacterView(replacedCharacters)) + } +} + +public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: JavaParameterConvertible...) throws -> T { + + let methodSignature = arguments.methodSignature(returnType: T.self) + guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) else { throw InvalidParameters() } + + let javaParameters = arguments.map { $0.toJavaParameter() } + return try T.fromStaticMethod(calling: methodID, on: javaClass, args: javaParameters) +} + + +public func callStatic(_ methodName: String, on javaClass: JavaClass, returningObjectType objectType: String) throws -> JavaObject { + print("Preparing to call static method \(methodName)") + let methodSignature = "()L\(objectType.replacingFullstopsWithSlashes());" + + print("Getting ID of \(methodName) with signature \(methodSignature)") + guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) else { + throw InvalidParameters() + } + + print("Calling static method \(methodName)") + return try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: []) +} + + +public func call(_ methodName: String, on object: JavaObject, returningObjectType objectType: String) throws -> JavaObject { + print("Preparing to call \(methodName)") + let methodSignature = "()L\(objectType.replacingFullstopsWithSlashes());" + + print("Getting ID of \(methodName) with signature \(methodSignature)") + guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { + throw InvalidParameters() + } + + print("Calling \(methodName)") + return try jni.CallObjectMethod(methodID, on: object, parameters: []) +} + + +public func call(_ methodName: String, on object: JavaObject, with arguments: [JavaParameterConvertible]) throws -> [String] { + print("Preparing to call \(methodName)") + let argumentsSignature = arguments.reduce("", { $0 + type(of: $1).asJNIParameterString }) + let methodSignature = "(" + argumentsSignature + ")" + "[" + String.asJNIParameterString + + print("Getting ID of \(methodName) with signature \(methodSignature)") + guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { throw InvalidParameters() } + + let javaParameters = arguments.map { $0.toJavaParameter() } + let returnedArray = try jni.CallObjectMethod(methodID, on: object, parameters: javaParameters) + print("Got JavaArray") + + print("Getting strings from JavaArray") + return try jni.GetStrings(from: returnedArray) +} diff --git a/Sources/JNISwift/JNIStrings.swift b/Sources/JNISwift/JNIStrings.swift index 2017595..435fef7 100644 --- a/Sources/JNISwift/JNIStrings.swift +++ b/Sources/JNISwift/JNIStrings.swift @@ -21,9 +21,9 @@ public extension JNI { env.pointee.pointee.ReleaseStringChars(env, string, chars) } - public func NewStringUTF(bytes: String) -> JavaString { + public func NewStringUTF(_ string: String) -> JavaString { let env = self._env - return env.pointee.pointee.NewStringUTF(env, bytes)! + return env.pointee.pointee.NewStringUTF(env, string)! } public func GetStringUTFLength(string: JavaString) -> jsize { diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index 02b4f2c..95266f2 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -1,18 +1,17 @@ import CJNI -import Dispatch +//import Dispatch public var jni: JNI! // this gets set "OnLoad" so should always exist @_silgen_name("JNI_OnLoad") public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutableRawPointer) -> JavaInt { - guard let localJNI = JNI(jvm: jvm) else { fatalError("Couldn't initialise JNI") } jni = localJNI // set the global for use elsewhere - #if os(Android) && swift(>=4) + #if !os(Android) && swift(>=4) // FIXME: Only available in Swift 4.0 DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) #endif @@ -45,11 +44,12 @@ extension JNI { _ = env.ThrowNew(_env, env.FindClass(_env, "java/lang/Exception"), message) } - /// - Note: This shouldn't need to be cleaned up because we're not taking ownership of the reference - public func GetStringUTFChars(string: JavaString) -> UnsafePointer { + public func GetString(from javaString: JavaString) -> String { let _env = self._env - var didCopyStringChars = JavaBoolean() // XXX: this gets set below, check it! - return _env.pointee.pointee.GetStringUTFChars(_env, string, &didCopyStringChars)! + let chars = _env.pointee.pointee.GetStringUTFChars(_env, javaString, nil) + let string = String(cString: chars) + _env.pointee.pointee.ReleaseStringUTFChars(_env, javaString, chars) + return string } // MARK: References @@ -57,7 +57,7 @@ extension JNI { public func NewGlobalRef(object: JavaObject) -> JavaObject? { let _env = self._env let result = _env.pointee.pointee.NewGlobalRef(_env, object) - return (result != nil) ? result : .none + return result } // MARK: Classes and Methods @@ -65,46 +65,85 @@ extension JNI { public func FindClass(className: String) -> JavaClass? { let _env = self._env let result = _env.pointee.pointee.FindClass(_env, className) - return (result != nil) ? result : .none + return result } - public func GetMethodID(javaClass: JavaClass, methodName: UnsafePointer, methodSignature: UnsafePointer) -> JavaMethodID? { + public func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID? { let _env = self._env - let result = _env.pointee.pointee.GetMethodID(_env, javaClass, methodName, methodSignature) - return (result != nil) ? result : .none + print("\(object)") + + print("Getting class of given object") + let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) + try checkAndThrowOnJNIError() + + print("About to do JNI call for '\(methodName)\' with signature '\(methodSignature)'") + let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) + print("Got MethodID result for '\(methodName)' with signature '\(methodSignature)'") + try checkAndThrowOnJNIError() + return result } - public func GetStaticMethodID(javaClass: JavaClass, methodName: UnsafePointer, methodSignature: UnsafePointer) -> JavaMethodID? { + public func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID? { let _env = self._env + print("\(javaClass)") + print("About to do JNI call for '\(methodName)\' with signature '\(methodSignature)'") let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) - return (result != nil) ? result : .none + print("Got MethodID result for '\(methodName)' with signature '\(methodSignature)'") + try checkAndThrowOnJNIError() + return result } - // TODO: make parameters take [JavaParameter], being a swifty version of [JavaParameter] with reference counting etc. - public func CallVoidMethod(object: JavaObject, methodID method: JavaMethodID, parameters: [JavaParameter]) { + public func CallVoidMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) { let _env = self._env var methodArgs = parameters _env.pointee.pointee.CallVoidMethod(_env, object, method, &methodArgs) } - public func CallStaticIntMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) -> JavaInt { + public func CallObjectMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaObject { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallObjectMethod(_env, object, method, &methodArgs)! + try checkAndThrowOnJNIError() + return result + } + + public func CallStaticObjectMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaObject { let _env = self._env var methodArgs = parameters - return _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) + let result = _env.pointee.pointee.CallStaticObjectMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result! // we checked for error in the line above + } + + public func CallStaticBooleanMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> Bool { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result == true + } + + public func CallStaticIntMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaInt { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result } // MARK: Arrays - public func GetArrayLength(array: JavaArray) -> Int { + public func GetLength(_ array: JavaArray) -> Int { let _env = self._env let result = _env.pointee.pointee.GetArrayLength(_env, array) return Int(result) } - public func NewIntArray(count: Int) -> JavaArray? { + public func NewIntArray(count: Int) throws -> JavaArray? { let _env = self._env let result = _env.pointee.pointee.NewIntArray(_env, jsize(count)) - return (result != nil) ? result : .none + try checkAndThrowOnJNIError() + return result } public func GetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, numElements: Int = -1) -> [Int] { @@ -112,7 +151,7 @@ extension JNI { var count = numElements if numElements < 0 { - count = GetArrayLength(array: array) + count = GetLength(array) } var result = [JavaInt](repeating: 0, count: count) @@ -126,10 +165,11 @@ extension JNI { _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } - public func NewFloatArray(count: Int) -> JavaArray? { + public func NewFloatArray(count: Int) throws -> JavaArray? { let _env = self._env let result = _env.pointee.pointee.NewFloatArray(_env, jsize(count)) - return (result != nil) ? result : .none + try checkAndThrowOnJNIError() + return result } public func GetFloatArrayRegion(array: JavaFloatArray, startIndex: Int = 0, numElements: Int = -1) -> [Float] { @@ -137,7 +177,7 @@ extension JNI { var count = numElements if numElements < 0 { - count = GetArrayLength(array: array) + count = GetLength(array) } var result = [JavaFloat](repeating: 0, count: count) @@ -150,6 +190,35 @@ extension JNI { var newElements = sourceElements.map { JavaFloat($0) } // make mutable copy _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } + + public func GetStrings(from array: JavaObjectArray) throws -> [String] { + let _env = self._env + let count = jni.GetLength(array) + print("Array contains \(count) strings") + + let strings: [String] = try (0 ..< count).map { i in + let jString: JavaString? = _env.pointee.pointee.GetObjectArrayElement(_env, array, jsize(i)) + let chars = _env.pointee.pointee.GetStringUTFChars(_env, jString, nil) + try checkAndThrowOnJNIError() + defer { _env.pointee.pointee.ReleaseStringUTFChars(_env, jString, chars) } + + return String(cString: chars) + } + + return strings + } +} + +func checkAndThrowOnJNIError() throws { + if jni.ExceptionCheck() { throw JNIError() } +} + +/// Prints information about the error to the console and clears the pending exception so we can continue making JNI calls +struct JNIError: Error { + init() { + jni.ExceptionDescribe() + jni.ExceptionClear() + } } /** @@ -215,7 +284,8 @@ public struct JavaCallback { guard let javaClass = jni.GetObjectClass(obj: globalJobj), - let methodID = jni.GetMethodID(javaClass: javaClass, methodName: methodName, methodSignature: methodSignature) + let methodIDwithoutError = try? jni.GetMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature), + let methodID = methodIDwithoutError else { // XXX: We should throw here and keep throwing til it gets back to Java fatalError("Failed to make JavaCallback") @@ -226,7 +296,7 @@ public struct JavaCallback { } public func apply(args: [JavaParameter]) { - jni.CallVoidMethod(object: jobj, methodID: methodID, parameters: args) + jni.CallVoidMethod(methodID, on: jobj, parameters: args) } /// Send variadic parameters to the func that takes an array From 9f4a9f6adfd40185394c9965df7b204dc1e9bfa7 Mon Sep 17 00:00:00 2001 From: rikner Date: Tue, 18 Jul 2017 19:14:56 +0200 Subject: [PATCH 11/84] do not import Dispatch in SwiftJNI --- Sources/JNISwift/SwiftJNI.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index 7ea8cf3..6bc3b3a 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -1,5 +1,5 @@ import CJNI -import Dispatch +// import Dispatch public var jni: JNI! // this gets set "OnLoad" so should always exist From c0820abf23bbd4969bccb0306cbf9606d2800eb1 Mon Sep 17 00:00:00 2001 From: cshg Date: Wed, 19 Jul 2017 13:37:00 +0200 Subject: [PATCH 12/84] Remove debugging prints --- Sources/JNISwift/JNIMethods.swift | 10 ---------- Sources/JNISwift/SwiftJNI.swift | 9 --------- 2 files changed, 19 deletions(-) diff --git a/Sources/JNISwift/JNIMethods.swift b/Sources/JNISwift/JNIMethods.swift index b50f5a5..884ecd2 100644 --- a/Sources/JNISwift/JNIMethods.swift +++ b/Sources/JNISwift/JNIMethods.swift @@ -81,45 +81,35 @@ public func callStatic(_ methodName: String, on jav public func callStatic(_ methodName: String, on javaClass: JavaClass, returningObjectType objectType: String) throws -> JavaObject { - print("Preparing to call static method \(methodName)") let methodSignature = "()L\(objectType.replacingFullstopsWithSlashes());" - print("Getting ID of \(methodName) with signature \(methodSignature)") guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) else { throw InvalidParameters() } - print("Calling static method \(methodName)") return try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: []) } public func call(_ methodName: String, on object: JavaObject, returningObjectType objectType: String) throws -> JavaObject { - print("Preparing to call \(methodName)") let methodSignature = "()L\(objectType.replacingFullstopsWithSlashes());" - print("Getting ID of \(methodName) with signature \(methodSignature)") guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { throw InvalidParameters() } - print("Calling \(methodName)") return try jni.CallObjectMethod(methodID, on: object, parameters: []) } public func call(_ methodName: String, on object: JavaObject, with arguments: [JavaParameterConvertible]) throws -> [String] { - print("Preparing to call \(methodName)") let argumentsSignature = arguments.reduce("", { $0 + type(of: $1).asJNIParameterString }) let methodSignature = "(" + argumentsSignature + ")" + "[" + String.asJNIParameterString - print("Getting ID of \(methodName) with signature \(methodSignature)") guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { throw InvalidParameters() } let javaParameters = arguments.map { $0.toJavaParameter() } let returnedArray = try jni.CallObjectMethod(methodID, on: object, parameters: javaParameters) - print("Got JavaArray") - print("Getting strings from JavaArray") return try jni.GetStrings(from: returnedArray) } diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index 95266f2..cad396a 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -70,25 +70,17 @@ extension JNI { public func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID? { let _env = self._env - print("\(object)") - - print("Getting class of given object") let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) try checkAndThrowOnJNIError() - print("About to do JNI call for '\(methodName)\' with signature '\(methodSignature)'") let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) - print("Got MethodID result for '\(methodName)' with signature '\(methodSignature)'") try checkAndThrowOnJNIError() return result } public func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID? { let _env = self._env - print("\(javaClass)") - print("About to do JNI call for '\(methodName)\' with signature '\(methodSignature)'") let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) - print("Got MethodID result for '\(methodName)' with signature '\(methodSignature)'") try checkAndThrowOnJNIError() return result } @@ -194,7 +186,6 @@ extension JNI { public func GetStrings(from array: JavaObjectArray) throws -> [String] { let _env = self._env let count = jni.GetLength(array) - print("Array contains \(count) strings") let strings: [String] = try (0 ..< count).map { i in let jString: JavaString? = _env.pointee.pointee.GetObjectArrayElement(_env, array, jsize(i)) From d76490bcdfad25fbd8ba88923ffd21daff3bbee2 Mon Sep 17 00:00:00 2001 From: cshg Date: Wed, 19 Jul 2017 14:06:11 +0200 Subject: [PATCH 13/84] Add if os android to print code --- Sources/JNISwift/JNIMethods.swift | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Sources/JNISwift/JNIMethods.swift b/Sources/JNISwift/JNIMethods.swift index 884ecd2..71cfc7c 100644 --- a/Sources/JNISwift/JNIMethods.swift +++ b/Sources/JNISwift/JNIMethods.swift @@ -1,5 +1,6 @@ import CJNI +#if os(Android) @discardableResult @_silgen_name("__android_log_write") public func androidPrint(_ prio: Int32, _ tag: UnsafePointer, _ text: UnsafePointer) -> Int32 @@ -7,6 +8,7 @@ public func androidPrint(_ prio: Int32, _ tag: UnsafePointer, _ text: Uns func print(_ string: String) { androidPrint(5, "SwiftJNI", string) } +#endif struct InvalidParameters: Error {} From b377926c9e95bc6c152b2ea592727817dfb5b882 Mon Sep 17 00:00:00 2001 From: rikner Date: Wed, 19 Jul 2017 15:53:11 +0200 Subject: [PATCH 14/84] add CallStaticBooleanMethod --- Sources/JNISwift/SwiftJNI.swift | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index 6bc3b3a..21fe581 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -93,6 +93,12 @@ extension JNI { return _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) } + public func CallStaticBooleanMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) -> JavaBoolean { + let _env = self._env + var methodArgs = parameters + return _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) + } + public func CallStaticVoidMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) { let _env = self._env var methodArgs = parameters From 8337f38e105a7739ebbc98491d90c8c4d136374b Mon Sep 17 00:00:00 2001 From: rikner Date: Wed, 19 Jul 2017 15:54:26 +0200 Subject: [PATCH 15/84] split and cleanup code JNIMethods code --- JNISwift.xcodeproj/project.pbxproj | 9 ++ .../Array+JavaParameterConvertible.swift | 39 ++++++ Sources/JNISwift/JNIMethods.swift | 111 ++++-------------- .../JNISwift/JavaParameterConvertible.swift | 39 ++++++ 4 files changed, 113 insertions(+), 85 deletions(-) create mode 100644 Sources/JNISwift/Array+JavaParameterConvertible.swift create mode 100644 Sources/JNISwift/JavaParameterConvertible.swift diff --git a/JNISwift.xcodeproj/project.pbxproj b/JNISwift.xcodeproj/project.pbxproj index d7f14fd..8fa37ef 100644 --- a/JNISwift.xcodeproj/project.pbxproj +++ b/JNISwift.xcodeproj/project.pbxproj @@ -7,6 +7,8 @@ objects = { /* Begin PBXBuildFile section */ + 03A41FFF1F1F6385005DFF60 /* JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = 03A41FFE1F1F6385005DFF60 /* JavaParameterConvertible.swift */; }; + 03A420011F1F8022005DFF60 /* Array+JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = 03A420001F1F8022005DFF60 /* Array+JavaParameterConvertible.swift */; }; OBJ_32 /* JNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_9 /* JNI.swift */; }; OBJ_33 /* JNIClassManipulation.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_10 /* JNIClassManipulation.swift */; }; OBJ_34 /* JNIExceptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_11 /* JNIExceptions.swift */; }; @@ -31,6 +33,8 @@ /* Begin PBXFileReference section */ 030CBFD31F1CD84200352724 /* build.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = build.sh; sourceTree = ""; }; + 03A41FFE1F1F6385005DFF60 /* JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JavaParameterConvertible.swift; sourceTree = ""; }; + 03A420001F1F8022005DFF60 /* Array+JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Array+JavaParameterConvertible.swift"; sourceTree = ""; }; OBJ_10 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; OBJ_11 /* JNIExceptions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIExceptions.swift; sourceTree = ""; }; OBJ_12 /* JNIMethods.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIMethods.swift; sourceTree = ""; }; @@ -132,6 +136,8 @@ OBJ_14 /* JNIRefs.swift */, OBJ_15 /* JNIStrings.swift */, OBJ_16 /* SwiftJNI.swift */, + 03A41FFE1F1F6385005DFF60 /* JavaParameterConvertible.swift */, + 03A420001F1F8022005DFF60 /* Array+JavaParameterConvertible.swift */, ); name = JNISwift; path = Sources/JNISwift; @@ -245,8 +251,10 @@ OBJ_32 /* JNI.swift in Sources */, OBJ_33 /* JNIClassManipulation.swift in Sources */, OBJ_34 /* JNIExceptions.swift in Sources */, + 03A420011F1F8022005DFF60 /* Array+JavaParameterConvertible.swift in Sources */, OBJ_35 /* JNIMethods.swift in Sources */, OBJ_36 /* JNIObjects.swift in Sources */, + 03A41FFF1F1F6385005DFF60 /* JavaParameterConvertible.swift in Sources */, OBJ_37 /* JNIRefs.swift in Sources */, OBJ_38 /* JNIStrings.swift in Sources */, OBJ_39 /* SwiftJNI.swift in Sources */, @@ -515,6 +523,7 @@ 030CBFD71F1CD93C00352724 /* Release */, ); defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; }; OBJ_2 /* Build configuration list for PBXProject "JNISwift" */ = { isa = XCConfigurationList; diff --git a/Sources/JNISwift/Array+JavaParameterConvertible.swift b/Sources/JNISwift/Array+JavaParameterConvertible.swift new file mode 100644 index 0000000..815756f --- /dev/null +++ b/Sources/JNISwift/Array+JavaParameterConvertible.swift @@ -0,0 +1,39 @@ +// +// Array+JavaParameterConvertible.swift +// JNISwift +// +// Created by flowing erik on 19.07.17. +// + +extension Array where Element == JavaParameterConvertible { + func methodSignature(returnType: JavaParameterConvertible.Type) -> String { + let argumentTypes = String.from(parameters: self) + return argumentTypes.asJNIParameterString(with: returnType) + } +} + +extension Array where Element == JavaParameterConvertible.Type { + func methodSignature(returnType: JavaParameterConvertible.Type) -> String { + let argumentTypes = String.from(types: self) + return argumentTypes.asJNIParameterString(with: returnType) + } +} + +private extension String { + static func from(parameters: [JavaParameterConvertible]) -> String { + return parameters.reduce("", { (result, parameter) -> String in + return result + type(of: parameter).asJNIParameterString + }) + } + + static func from(types: [JavaParameterConvertible.Type]) -> String { + return types.reduce("", { (result, type) -> String in + return result + type.asJNIParameterString + }) + } + + func asJNIParameterString(with returnType: JavaParameterConvertible.Type) -> String { + return "(" + self + ")" + returnType.asJNIParameterString + } +} + diff --git a/Sources/JNISwift/JNIMethods.swift b/Sources/JNISwift/JNIMethods.swift index 254c8e5..a98643c 100644 --- a/Sources/JNISwift/JNIMethods.swift +++ b/Sources/JNISwift/JNIMethods.swift @@ -1,104 +1,45 @@ import CJNI -public protocol JavaParameterConvertible { - typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) - static var asJNIParameterString: String { get } - func toJavaParameter() -> JavaParameter - static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Self -} - -extension Bool: JavaParameterConvertible { - public static var asJNIParameterString: String { return "z" } - - public func toJavaParameter() -> JavaParameter { - return JavaParameter(bool: (self) ? 1 : 0) - } - - public static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { - return true // jni.CallStaticBooleanMethod(nil, nil, args) == 1 - } -} - -//extension Void: JavaParameterConvertible { -// public static var asJNIParameterString: String { return "V" } -// -// public func toJavaParameter() -> JavaParameter { -// return JavaParameter.init(object: nil) -// } -// -// public static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { -// jni.CallStaticVoidMethod(javaClass: javaClass, method: calling, parameters: args) -// } -//} - struct InvalidParameters: Error {} -extension Array where Element == JavaParameterConvertible { - func methodSignature(returnType: JavaParameterConvertible.Type) -> String { - let argumentTypes = self.reduce("", { (result, argument) -> String in - return result + type(of: argument).asJNIParameterString - }) - - return "(" + argumentTypes + ")" + returnType.asJNIParameterString - } -} - - -// -//public func javaStaticMethod(_ method: String, on javaClass: JavaClass) throws -> T { -// javaStaticMethod(method, on: javaClass, arguments: JavaParameterConvertible...) -//} - -public func javaStaticMethod(_ method: String, on javaClass: JavaClass, arguments: JavaParameterConvertible...) throws -> T { - - let methodSignature = arguments.methodSignature(returnType: T.self) - guard let methodID = jni.GetStaticMethodID(javaClass: javaClass, methodName: method, methodSignature: methodSignature) else { throw InvalidParameters() } - - let javaParameters = arguments.map { $0.toJavaParameter() } - return T.fromStaticMethod(calling: methodID, on: javaClass, args: javaParameters) -} - - -//func callMyJavaStaticMethod() throws -> Bool { -// let class = JavaObject.allocate(bytes: 1, alignedTo: 1) -// return try javaStaticMethod("asd", on: obj, arguments: true) -//} +public extension JNI { + public func callStaticJavaMethod + (_ method: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible]) throws -> T { + guard let methodID = jni.GetStaticMethodID( + javaClass: javaClass, + methodName: method, + methodSignature: arguments.methodSignature(returnType: T.self) + ) else { + throw InvalidParameters() + } -extension Array where Element == JavaParameterConvertible.Type { - func methodSignature(returnType: JavaParameterConvertible.Type) -> String { - let argumentTypes = self.reduce("", { (result, type) -> String in - return result + type.asJNIParameterString - }) + let javaParameters = arguments.map { $0.toJavaParameter() } - return "(" + argumentTypes + ")" + returnType.asJNIParameterString + return T.fromStaticMethod(calling: methodID, on: javaClass, args: javaParameters) } -} -func javaStaticMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameterTypes: [JavaParameterConvertible.Type]) throws -> (T.JavaMethod) { - // guard let methodID = jni.GetStaticMethodID() else { throw Error } + public func getStaticJavaMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameterTypes: [JavaParameterConvertible.Type]) throws -> (T.JavaMethod) { - return { (args: JavaParameterConvertible...) in - if parameterTypes.count != args.count { - throw InvalidParameters() - } + // guard let methodID = jni.GetStaticMethodID() else { throw Error } - try args.enumerated().forEach({ arg in - let (i, element) = arg - if type(of: element) != parameterTypes[i] { + return { (args: JavaParameterConvertible...) in + if parameterTypes.count != args.count { throw InvalidParameters() } - }) - let javaParameters = args.map { $0.toJavaParameter() } + try args.enumerated().forEach({ arg in + let (i, element) = arg + if type(of: element) != parameterTypes[i] { + throw InvalidParameters() + } + }) + + let javaParameters = args.map { $0.toJavaParameter() } - return T.fromStaticMethod(calling: method, on: javaClass, args: javaParameters) + return T.fromStaticMethod(calling: method, on: javaClass, args: javaParameters) + } } } - // func lol() throws -> Bool { - // let obj = JavaObject.allocate(bytes: 1, alignedTo: 1) - // let myFunc: Bool.JavaMethod = try javaStaticMethod("asd", on: obj, parameterTypes: [Bool.self]) - // return try myFunc(true) - // } diff --git a/Sources/JNISwift/JavaParameterConvertible.swift b/Sources/JNISwift/JavaParameterConvertible.swift new file mode 100644 index 0000000..a1a8ffc --- /dev/null +++ b/Sources/JNISwift/JavaParameterConvertible.swift @@ -0,0 +1,39 @@ +// +// JavaParameterConvertible.swift +// JNISwift +// +// Created by flowing erik on 19.07.17. +// + +import CJNI + +public protocol JavaParameterConvertible { + typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) + static var asJNIParameterString: String { get } + func toJavaParameter() -> JavaParameter + static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Self +} + +extension Bool: JavaParameterConvertible { + public static var asJNIParameterString: String { return "Z" } + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(bool: (self) ? 1 : 0) + } + + public static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Bool { + return jni.CallStaticBooleanMethod(javaClass: javaClass, method: calling, parameters: args) == 1 + } +} + +extension Int: JavaParameterConvertible { + public static var asJNIParameterString: String { return "I" } + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(int: JavaInt(self)) + } + + public static func fromStaticMethod(calling: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) -> Int { + return Int(jni.CallStaticIntMethod(javaClass: javaClass, method: calling, parameters: args)) + } +} From 4fb07aabb9090df203f7909c2319fd8cfdcdf7fd Mon Sep 17 00:00:00 2001 From: rikner Date: Wed, 19 Jul 2017 16:09:28 +0200 Subject: [PATCH 16/84] add build script --- build.sh | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 build.sh diff --git a/build.sh b/build.sh old mode 100644 new mode 100755 From f804d5b63f2d93eeccc0c1eb64f81ca5a831016d Mon Sep 17 00:00:00 2001 From: rikner Date: Wed, 19 Jul 2017 18:38:24 +0200 Subject: [PATCH 17/84] add GetStrings --- Sources/CJNI/include/jni.h | 2 +- .../Array+JavaParameterConvertible.swift | 21 ++++------- Sources/JNISwift/JNIExceptions.swift | 4 +-- Sources/JNISwift/SwiftJNI.swift | 36 ++++++++++++++++--- 4 files changed, 41 insertions(+), 22 deletions(-) diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index 4dcb2ff..834651a 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -388,7 +388,7 @@ struct JNINativeInterface jstring (* _Nonnull NewStringUTF)(JNIEnv * _Nonnull, const char * _Nonnull); jsize (* _Nonnull GetStringUTFLength)(JNIEnv * _Nonnull, jstring); /* JNI spec says this returns const jbyte*, but that's inconsistent */ - const char *(* _Nonnull GetStringUTFChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nonnull); + const char * _Nonnull(* _Nonnull GetStringUTFChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nullable); void (* _Nonnull ReleaseStringUTFChars)(JNIEnv * _Nonnull, jstring, const char * _Nonnull); jsize (* _Nonnull GetArrayLength)(JNIEnv * _Nonnull, jarray); jobjectArray (* _Nonnull NewObjectArray)(JNIEnv * _Nonnull, jsize, jclass, jobject); diff --git a/Sources/JNISwift/Array+JavaParameterConvertible.swift b/Sources/JNISwift/Array+JavaParameterConvertible.swift index 815756f..9640b43 100644 --- a/Sources/JNISwift/Array+JavaParameterConvertible.swift +++ b/Sources/JNISwift/Array+JavaParameterConvertible.swift @@ -7,33 +7,24 @@ extension Array where Element == JavaParameterConvertible { func methodSignature(returnType: JavaParameterConvertible.Type) -> String { - let argumentTypes = String.from(parameters: self) + let argumentTypes = self.reduce("", { (result, parameter) -> String in + return result + type(of: parameter).asJNIParameterString + }) return argumentTypes.asJNIParameterString(with: returnType) } } extension Array where Element == JavaParameterConvertible.Type { func methodSignature(returnType: JavaParameterConvertible.Type) -> String { - let argumentTypes = String.from(types: self) + let argumentTypes = self.reduce("", { (result, type) -> String in + return result + type.asJNIParameterString + }) return argumentTypes.asJNIParameterString(with: returnType) } } private extension String { - static func from(parameters: [JavaParameterConvertible]) -> String { - return parameters.reduce("", { (result, parameter) -> String in - return result + type(of: parameter).asJNIParameterString - }) - } - - static func from(types: [JavaParameterConvertible.Type]) -> String { - return types.reduce("", { (result, type) -> String in - return result + type.asJNIParameterString - }) - } - func asJNIParameterString(with returnType: JavaParameterConvertible.Type) -> String { return "(" + self + ")" + returnType.asJNIParameterString } } - diff --git a/Sources/JNISwift/JNIExceptions.swift b/Sources/JNISwift/JNIExceptions.swift index b362859..3762194 100644 --- a/Sources/JNISwift/JNIExceptions.swift +++ b/Sources/JNISwift/JNIExceptions.swift @@ -1,9 +1,9 @@ import CJNI public extension JNI { - public func ExceptionCheck() -> JavaBoolean { + public func ExceptionCheck() -> Bool { let env = self._env - return env.pointee.pointee.ExceptionCheck(env) + return env.pointee.pointee.ExceptionCheck(env) == true } public func ExceptionDescribe() { diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index 21fe581..c72887d 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -49,7 +49,7 @@ extension JNI { public func GetStringUTFChars(string: JavaString) -> UnsafePointer { let _env = self._env var didCopyStringChars = JavaBoolean() // XXX: this gets set below, check it! - return _env.pointee.pointee.GetStringUTFChars(_env, string, &didCopyStringChars)! + return _env.pointee.pointee.GetStringUTFChars(_env, string, &didCopyStringChars) } // MARK: References @@ -107,7 +107,7 @@ extension JNI { // MARK: Arrays - public func GetArrayLength(array: JavaArray) -> Int { + public func GetLength(_ array: JavaArray) -> Int { let _env = self._env let result = _env.pointee.pointee.GetArrayLength(_env, array) return Int(result) @@ -132,7 +132,7 @@ extension JNI { var count = numElements if numElements < 0 { - count = GetArrayLength(array: array) + count = GetLength(array) } var result = [JavaInt](repeating: 0, count: count) @@ -157,7 +157,7 @@ extension JNI { var count = numElements if numElements < 0 { - count = GetArrayLength(array: array) + count = GetLength(array) } var result = [JavaFloat](repeating: 0, count: count) @@ -170,6 +170,34 @@ extension JNI { var newElements = sourceElements.map { JavaFloat($0) } // make mutable copy _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } + + public func GetStrings(from array: JavaObjectArray) throws -> [String] { + let _env = self._env + let count = jni.GetLength(array) + + let strings: [String] = try (0 ..< count).map { i in + let jString: JavaString? = _env.pointee.pointee.GetObjectArrayElement(_env, array, jsize(i)) + let chars = _env.pointee.pointee.GetStringUTFChars(_env, jString, nil) + try checkAndThrowOnJNIError() + defer { _env.pointee.pointee.ReleaseStringUTFChars(_env, jString, chars) } + + return String(cString: chars) + } + + return strings + } +} + +func checkAndThrowOnJNIError() throws { + if jni.ExceptionCheck() { throw JNIError() } +} + +/// Prints information about the error to the console and clears the pending exception so we can continue making JNI calls +struct JNIError: Error { + init() { + jni.ExceptionDescribe() + jni.ExceptionClear() + } } /** From 9227b253d739438942f26201d88d5b6f629939a1 Mon Sep 17 00:00:00 2001 From: rikner Date: Thu, 20 Jul 2017 16:02:04 +0200 Subject: [PATCH 18/84] overload callStatic to call void method, make returnType parameter in methodSignature() optional --- .../Array+JavaParameterConvertible.swift | 28 +++-- Sources/JNISwift/JNIMethods.swift | 114 ++++++------------ 2 files changed, 55 insertions(+), 87 deletions(-) diff --git a/Sources/JNISwift/Array+JavaParameterConvertible.swift b/Sources/JNISwift/Array+JavaParameterConvertible.swift index 9640b43..7c28f6d 100644 --- a/Sources/JNISwift/Array+JavaParameterConvertible.swift +++ b/Sources/JNISwift/Array+JavaParameterConvertible.swift @@ -6,25 +6,29 @@ // extension Array where Element == JavaParameterConvertible { - func methodSignature(returnType: JavaParameterConvertible.Type) -> String { - let argumentTypes = self.reduce("", { (result, parameter) -> String in - return result + type(of: parameter).asJNIParameterString - }) - return argumentTypes.asJNIParameterString(with: returnType) + func methodSignature(returnType: JavaParameterConvertible.Type? = nil) -> String { + return getMethodSignature(from: self, reducer: { + return $0 + type(of: $1).asJNIParameterString + }, returnType: returnType) } } extension Array where Element == JavaParameterConvertible.Type { - func methodSignature(returnType: JavaParameterConvertible.Type) -> String { - let argumentTypes = self.reduce("", { (result, type) -> String in - return result + type.asJNIParameterString - }) - return argumentTypes.asJNIParameterString(with: returnType) + func methodSignature(returnType: JavaParameterConvertible.Type? = nil) -> String { + return getMethodSignature(from: self, reducer: { + return $0 + $1.asJNIParameterString + }, returnType: returnType) } } +private func getMethodSignature(from arr: [T], reducer: (String, T) -> String, returnType: JavaParameterConvertible.Type?) -> String { + let argumentTypes = arr.reduce("", reducer) + return argumentTypes.asJNIParameterString(with: returnType) +} + private extension String { - func asJNIParameterString(with returnType: JavaParameterConvertible.Type) -> String { - return "(" + self + ")" + returnType.asJNIParameterString + func asJNIParameterString(with returnType: JavaParameterConvertible.Type?) -> String { + let returnTypeString = returnType?.asJNIParameterString ?? "V" + return "(" + self + ")" + returnTypeString } } diff --git a/Sources/JNISwift/JNIMethods.swift b/Sources/JNISwift/JNIMethods.swift index fe32cc4..0322a90 100644 --- a/Sources/JNISwift/JNIMethods.swift +++ b/Sources/JNISwift/JNIMethods.swift @@ -2,107 +2,71 @@ import CJNI struct InvalidParameters: Error {} - -#if os(Android) -@discardableResult -@_silgen_name("__android_log_write") -public func androidPrint(_ prio: Int32, _ tag: UnsafePointer, _ text: UnsafePointer) -> Int32 - -func print(_ string: String) { - androidPrint(5, "SwiftJNI", string) +extension String { + func replacingFullstopsWithSlashes() -> String { + let replacedCharacters = self.characters.map { ($0 == ".") ? "/" : $0 } + return String(String.CharacterView(replacedCharacters)) + } } -#endif +extension JNI { -public extension JNI { - public func callStaticJavaMethod - (_ method: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible]) throws -> T { + // MARK: Static Methods - guard let methodID = try jni.GetStaticMethodID( - for: javaClass, - methodName: method, - methodSignature: arguments.methodSignature(returnType: T.self) - ) else { - throw InvalidParameters() - } + public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible]) throws { + let methodSignature = arguments.methodSignature() - let javaParameters = arguments.map { $0.toJavaParameter() } + guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) + else { throw InvalidParameters() } - return try T.fromStaticMethod(calling: methodID, on: javaClass, args: javaParameters) + jni.CallStaticVoidMethod(javaClass: javaClass, method: methodID, parameters: arguments.map { $0.toJavaParameter() }) } + public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible]) throws -> T { + let methodSignature = arguments.methodSignature(returnType: T.self) - public func getStaticJavaMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameterTypes: [JavaParameterConvertible.Type]) throws -> (T.JavaMethod) { - - // guard let methodID = jni.GetStaticMethodID() else { throw Error } + guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) + else { throw InvalidParameters() } - return { (args: JavaParameterConvertible...) in - if parameterTypes.count != args.count { - throw InvalidParameters() - } + let javaParameters = arguments.map { $0.toJavaParameter() } + return try T.fromStaticMethod(calling: methodID, on: javaClass, args: javaParameters) + } - try args.enumerated().forEach({ arg in - let (i, element) = arg - if type(of: element) != parameterTypes[i] { - throw InvalidParameters() - } - }) - let javaParameters = args.map { $0.toJavaParameter() } + public func callStatic(_ methodName: String, on javaClass: JavaClass, returningObjectType objectType: String) throws -> JavaObject { + let methodSignature = "()L\(objectType.replacingFullstopsWithSlashes());" - return try T.fromStaticMethod(calling: method, on: javaClass, args: javaParameters) + guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) else { + throw InvalidParameters() } - } -} -extension String { - func replacingFullstopsWithSlashes() -> String { - let replacedCharacters = self.characters.map { ($0 == ".") ? "/" : $0 } - return String(String.CharacterView(replacedCharacters)) + return try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: []) } -} - -public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: JavaParameterConvertible...) throws -> T { - - let methodSignature = arguments.methodSignature(returnType: T.self) - guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) else { throw InvalidParameters() } - - let javaParameters = arguments.map { $0.toJavaParameter() } - return try T.fromStaticMethod(calling: methodID, on: javaClass, args: javaParameters) -} - -public func callStatic(_ methodName: String, on javaClass: JavaClass, returningObjectType objectType: String) throws -> JavaObject { - let methodSignature = "()L\(objectType.replacingFullstopsWithSlashes());" - guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) else { - throw InvalidParameters() - } - - return try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: []) -} + // MARK: Non-Static Methods + public func call(_ methodName: String, on object: JavaObject, returningObjectType objectType: String) throws -> JavaObject { + let methodSignature = "()L\(objectType.replacingFullstopsWithSlashes());" -public func call(_ methodName: String, on object: JavaObject, returningObjectType objectType: String) throws -> JavaObject { - let methodSignature = "()L\(objectType.replacingFullstopsWithSlashes());" + guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { + throw InvalidParameters() + } - guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { - throw InvalidParameters() + return try jni.CallObjectMethod(methodID, on: object, parameters: []) } - return try jni.CallObjectMethod(methodID, on: object, parameters: []) -} + public func call(_ methodName: String, on object: JavaObject, with arguments: [JavaParameterConvertible]) throws -> [String] { + let argumentsSignature = arguments.reduce("", { $0 + type(of: $1).asJNIParameterString }) + let methodSignature = "(" + argumentsSignature + ")" + "[" + String.asJNIParameterString -public func call(_ methodName: String, on object: JavaObject, with arguments: [JavaParameterConvertible]) throws -> [String] { - let argumentsSignature = arguments.reduce("", { $0 + type(of: $1).asJNIParameterString }) - let methodSignature = "(" + argumentsSignature + ")" + "[" + String.asJNIParameterString + guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { throw InvalidParameters() } - guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { throw InvalidParameters() } + let javaParameters = arguments.map { $0.toJavaParameter() } + let returnedArray = try jni.CallObjectMethod(methodID, on: object, parameters: javaParameters) - let javaParameters = arguments.map { $0.toJavaParameter() } - let returnedArray = try jni.CallObjectMethod(methodID, on: object, parameters: javaParameters) + return try jni.GetStrings(from: returnedArray) + } - return try jni.GetStrings(from: returnedArray) } - From 566be2de8248cbc7a1a3838758c5e55407e6e91c Mon Sep 17 00:00:00 2001 From: Geordie J Date: Mon, 24 Jul 2017 20:13:25 +0200 Subject: [PATCH 19/84] Clean up --- JNISwift/JNISwift.xcodeproj/project.pbxproj | 261 ------------------ .../contents.xcworkspacedata | 7 - JNISwift/build.sh | 8 - Package.swift | 11 +- Sources/JNISwift/JNIMethods.swift | 10 - Sources/JNISwift/SwiftJNI.swift | 7 +- 6 files changed, 9 insertions(+), 295 deletions(-) delete mode 100644 JNISwift/JNISwift.xcodeproj/project.pbxproj delete mode 100644 JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata delete mode 100644 JNISwift/build.sh diff --git a/JNISwift/JNISwift.xcodeproj/project.pbxproj b/JNISwift/JNISwift.xcodeproj/project.pbxproj deleted file mode 100644 index 98fa8a6..0000000 --- a/JNISwift/JNISwift.xcodeproj/project.pbxproj +++ /dev/null @@ -1,261 +0,0 @@ -// !$*UTF8*$! -{ - archiveVersion = 1; - classes = { - }; - objectVersion = 46; - objects = { - -/* Begin PBXFileReference section */ - 032F84951F18BC2300E24174 /* jni.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; - 032F84961F18BC2300E24174 /* module.modulemap */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = "sourcecode.module-map"; path = module.modulemap; sourceTree = ""; }; - 032F84971F18BC2300E24174 /* jni.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = jni.c; sourceTree = ""; }; - 032F84991F18BC2300E24174 /* JNI.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; - 032F849A1F18BC2300E24174 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; - 032F849B1F18BC2300E24174 /* JNIExceptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIExceptions.swift; sourceTree = ""; }; - 032F849C1F18BC2300E24174 /* JNIMethods.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIMethods.swift; sourceTree = ""; }; - 032F849D1F18BC2300E24174 /* JNIObjects.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIObjects.swift; sourceTree = ""; }; - 032F849E1F18BC2300E24174 /* JNIRefs.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIRefs.swift; sourceTree = ""; }; - 032F849F1F18BC2300E24174 /* JNIStrings.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JNIStrings.swift; sourceTree = ""; }; - 032F84A01F18BC2300E24174 /* SwiftJNI.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SwiftJNI.swift; sourceTree = ""; }; - 032F84A21F18BD1E00E24174 /* Package.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = Package.swift; path = ../Package.swift; sourceTree = ""; }; - 032F84A31F18BD1E00E24174 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = README.md; path = ../README.md; sourceTree = ""; }; - 032F84A41F18BDE000E24174 /* build.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = build.sh; sourceTree = ""; }; -/* End PBXFileReference section */ - -/* Begin PBXGroup section */ - 032F84871F18BBF700E24174 = { - isa = PBXGroup; - children = ( - 032F84A41F18BDE000E24174 /* build.sh */, - 032F84A21F18BD1E00E24174 /* Package.swift */, - 032F84A31F18BD1E00E24174 /* README.md */, - 032F84921F18BC2300E24174 /* Sources */, - ); - sourceTree = ""; - }; - 032F84921F18BC2300E24174 /* Sources */ = { - isa = PBXGroup; - children = ( - 032F84931F18BC2300E24174 /* CJNI */, - 032F84981F18BC2300E24174 /* JNISwift */, - ); - name = Sources; - path = ../Sources; - sourceTree = ""; - }; - 032F84931F18BC2300E24174 /* CJNI */ = { - isa = PBXGroup; - children = ( - 032F84941F18BC2300E24174 /* include */, - 032F84971F18BC2300E24174 /* jni.c */, - ); - path = CJNI; - sourceTree = ""; - }; - 032F84941F18BC2300E24174 /* include */ = { - isa = PBXGroup; - children = ( - 032F84951F18BC2300E24174 /* jni.h */, - 032F84961F18BC2300E24174 /* module.modulemap */, - ); - path = include; - sourceTree = ""; - }; - 032F84981F18BC2300E24174 /* JNISwift */ = { - isa = PBXGroup; - children = ( - 032F84991F18BC2300E24174 /* JNI.swift */, - 032F849A1F18BC2300E24174 /* JNIClassManipulation.swift */, - 032F849B1F18BC2300E24174 /* JNIExceptions.swift */, - 032F849C1F18BC2300E24174 /* JNIMethods.swift */, - 032F849D1F18BC2300E24174 /* JNIObjects.swift */, - 032F849E1F18BC2300E24174 /* JNIRefs.swift */, - 032F849F1F18BC2300E24174 /* JNIStrings.swift */, - 032F84A01F18BC2300E24174 /* SwiftJNI.swift */, - ); - path = JNISwift; - sourceTree = ""; - }; -/* End PBXGroup section */ - -/* Begin PBXLegacyTarget section */ - 032F848C1F18BBF700E24174 /* JNISwift */ = { - isa = PBXLegacyTarget; - buildArgumentsString = build.sh; - buildConfigurationList = 032F848F1F18BBF700E24174 /* Build configuration list for PBXLegacyTarget "JNISwift" */; - buildPhases = ( - ); - buildToolPath = /bin/bash; - buildWorkingDirectory = ""; - dependencies = ( - ); - name = JNISwift; - passBuildSettingsInEnvironment = 1; - productName = JNISwift; - }; -/* End PBXLegacyTarget section */ - -/* Begin PBXProject section */ - 032F84881F18BBF700E24174 /* Project object */ = { - isa = PBXProject; - attributes = { - LastUpgradeCheck = 0830; - ORGANIZATIONNAME = flowkey; - TargetAttributes = { - 032F848C1F18BBF700E24174 = { - CreatedOnToolsVersion = 8.3.3; - DevelopmentTeam = FTSYMMN5B5; - ProvisioningStyle = Automatic; - }; - }; - }; - buildConfigurationList = 032F848B1F18BBF700E24174 /* Build configuration list for PBXProject "JNISwift" */; - compatibilityVersion = "Xcode 3.2"; - developmentRegion = English; - hasScannedForEncodings = 0; - knownRegions = ( - en, - ); - mainGroup = 032F84871F18BBF700E24174; - projectDirPath = ""; - projectRoot = ""; - targets = ( - 032F848C1F18BBF700E24174 /* JNISwift */, - ); - }; -/* End PBXProject section */ - -/* Begin XCBuildConfiguration section */ - 032F848D1F18BBF700E24174 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - ALWAYS_SEARCH_USER_PATHS = NO; - CLANG_ANALYZER_NONNULL = YES; - CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; - CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; - CLANG_CXX_LIBRARY = "libc++"; - CLANG_ENABLE_MODULES = YES; - CLANG_ENABLE_OBJC_ARC = YES; - CLANG_WARN_BOOL_CONVERSION = YES; - CLANG_WARN_CONSTANT_CONVERSION = YES; - CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; - CLANG_WARN_DOCUMENTATION_COMMENTS = YES; - CLANG_WARN_EMPTY_BODY = YES; - CLANG_WARN_ENUM_CONVERSION = YES; - CLANG_WARN_INFINITE_RECURSION = YES; - CLANG_WARN_INT_CONVERSION = YES; - CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; - CLANG_WARN_SUSPICIOUS_MOVE = YES; - CLANG_WARN_UNREACHABLE_CODE = YES; - CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; - COPY_PHASE_STRIP = NO; - DEBUG_INFORMATION_FORMAT = dwarf; - ENABLE_STRICT_OBJC_MSGSEND = YES; - ENABLE_TESTABILITY = YES; - GCC_C_LANGUAGE_STANDARD = gnu99; - GCC_DYNAMIC_NO_PIC = NO; - GCC_NO_COMMON_BLOCKS = YES; - GCC_OPTIMIZATION_LEVEL = 0; - GCC_PREPROCESSOR_DEFINITIONS = ( - "DEBUG=1", - "$(inherited)", - ); - GCC_WARN_64_TO_32_BIT_CONVERSION = YES; - GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; - GCC_WARN_UNDECLARED_SELECTOR = YES; - GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; - GCC_WARN_UNUSED_FUNCTION = YES; - GCC_WARN_UNUSED_VARIABLE = YES; - MTL_ENABLE_DEBUG_INFO = YES; - ONLY_ACTIVE_ARCH = YES; - }; - name = Debug; - }; - 032F848E1F18BBF700E24174 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - ALWAYS_SEARCH_USER_PATHS = NO; - CLANG_ANALYZER_NONNULL = YES; - CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; - CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; - CLANG_CXX_LIBRARY = "libc++"; - CLANG_ENABLE_MODULES = YES; - CLANG_ENABLE_OBJC_ARC = YES; - CLANG_WARN_BOOL_CONVERSION = YES; - CLANG_WARN_CONSTANT_CONVERSION = YES; - CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; - CLANG_WARN_DOCUMENTATION_COMMENTS = YES; - CLANG_WARN_EMPTY_BODY = YES; - CLANG_WARN_ENUM_CONVERSION = YES; - CLANG_WARN_INFINITE_RECURSION = YES; - CLANG_WARN_INT_CONVERSION = YES; - CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; - CLANG_WARN_SUSPICIOUS_MOVE = YES; - CLANG_WARN_UNREACHABLE_CODE = YES; - CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; - COPY_PHASE_STRIP = NO; - DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; - ENABLE_NS_ASSERTIONS = NO; - ENABLE_STRICT_OBJC_MSGSEND = YES; - GCC_C_LANGUAGE_STANDARD = gnu99; - GCC_NO_COMMON_BLOCKS = YES; - GCC_WARN_64_TO_32_BIT_CONVERSION = YES; - GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; - GCC_WARN_UNDECLARED_SELECTOR = YES; - GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; - GCC_WARN_UNUSED_FUNCTION = YES; - GCC_WARN_UNUSED_VARIABLE = YES; - MTL_ENABLE_DEBUG_INFO = NO; - }; - name = Release; - }; - 032F84901F18BBF700E24174 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - DEBUGGING_SYMBOLS = YES; - DEBUG_INFORMATION_FORMAT = dwarf; - DEVELOPMENT_TEAM = FTSYMMN5B5; - GCC_GENERATE_DEBUGGING_SYMBOLS = YES; - GCC_OPTIMIZATION_LEVEL = 0; - OTHER_CFLAGS = ""; - OTHER_LDFLAGS = ""; - PRODUCT_NAME = "$(TARGET_NAME)"; - }; - name = Debug; - }; - 032F84911F18BBF700E24174 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; - DEVELOPMENT_TEAM = FTSYMMN5B5; - OTHER_CFLAGS = ""; - OTHER_LDFLAGS = ""; - PRODUCT_NAME = "$(TARGET_NAME)"; - }; - name = Release; - }; -/* End XCBuildConfiguration section */ - -/* Begin XCConfigurationList section */ - 032F848B1F18BBF700E24174 /* Build configuration list for PBXProject "JNISwift" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - 032F848D1F18BBF700E24174 /* Debug */, - 032F848E1F18BBF700E24174 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - 032F848F1F18BBF700E24174 /* Build configuration list for PBXLegacyTarget "JNISwift" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - 032F84901F18BBF700E24174 /* Debug */, - 032F84911F18BBF700E24174 /* Release */, - ); - defaultConfigurationIsVisible = 0; - }; -/* End XCConfigurationList section */ - }; - rootObject = 032F84881F18BBF700E24174 /* Project object */; -} diff --git a/JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata deleted file mode 100644 index e6bd6f1..0000000 --- a/JNISwift/JNISwift.xcodeproj/project.xcworkspace/contents.xcworkspacedata +++ /dev/null @@ -1,7 +0,0 @@ - - - - - diff --git a/JNISwift/build.sh b/JNISwift/build.sh deleted file mode 100644 index 14e21f3..0000000 --- a/JNISwift/build.sh +++ /dev/null @@ -1,8 +0,0 @@ -export PATH=$PATH:~/.swiftyrobot - -# ensure working dir is local to this script (when being called by another script) -cd "$(dirname "$0")" - -# build Swift Package with Swifty Robot -sr build | sed 's/\/root\/host_fs//g' -exit ${PIPESTATUS[0]} diff --git a/Package.swift b/Package.swift index a0a0192..b6e22ba 100644 --- a/Package.swift +++ b/Package.swift @@ -1,13 +1,14 @@ -// swift-tools-version:3.1 +// swift-tools-version:4.0 import PackageDescription let package = Package( name: "JNISwift", + products: [ + .library(name: "JNISwift", type: .dynamic, targets: ["JNISwift"]) + ], targets: [ - Target(name: "JNISwift", dependencies: ["CJNI"]), - Target(name: "CJNI", dependencies: []) + .target(name: "JNISwift", dependencies: ["CJNI"]), + .target(name: "CJNI", dependencies: []) ] ) - -products.append(Product(name: "JNISwift", type: .Library(.Dynamic), modules: ["JNISwift"])) diff --git a/Sources/JNISwift/JNIMethods.swift b/Sources/JNISwift/JNIMethods.swift index 71cfc7c..0cc1fe0 100644 --- a/Sources/JNISwift/JNIMethods.swift +++ b/Sources/JNISwift/JNIMethods.swift @@ -1,15 +1,5 @@ import CJNI -#if os(Android) -@discardableResult -@_silgen_name("__android_log_write") -public func androidPrint(_ prio: Int32, _ tag: UnsafePointer, _ text: UnsafePointer) -> Int32 - -func print(_ string: String) { - androidPrint(5, "SwiftJNI", string) -} -#endif - struct InvalidParameters: Error {} public protocol JavaParameterConvertible { diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index cad396a..ceac581 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -11,10 +11,9 @@ public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutabl jni = localJNI // set the global for use elsewhere - #if !os(Android) && swift(>=4) - // FIXME: Only available in Swift 4.0 - DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) - #endif + // #if !os(Android) && swift(>=4) + // DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) + // #endif return JNI_VERSION_1_6 } From dcd231182a70153d2f552e2050fa6b99d57bda76 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Tue, 25 Jul 2017 17:42:04 +0200 Subject: [PATCH 20/84] Add / correct the last header annotations in jni.h --- JNISwift.xcodeproj/project.pbxproj | 7 ++-- Sources/CJNI/include/jni.h | 58 +++++++++++++++--------------- Sources/JNISwift/SwiftJNI.swift | 2 -- 3 files changed, 31 insertions(+), 36 deletions(-) diff --git a/JNISwift.xcodeproj/project.pbxproj b/JNISwift.xcodeproj/project.pbxproj index 7ef22c8..938e0a3 100644 --- a/JNISwift.xcodeproj/project.pbxproj +++ b/JNISwift.xcodeproj/project.pbxproj @@ -42,7 +42,6 @@ OBJ_19 /* JNIRefs.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIRefs.swift; sourceTree = ""; }; OBJ_20 /* JNIStrings.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIStrings.swift; sourceTree = ""; }; OBJ_21 /* SwiftJNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SwiftJNI.swift; sourceTree = ""; }; - OBJ_23 /* JNISwift */ = {isa = PBXFileReference; lastKnownFileType = folder; path = JNISwift; sourceTree = SOURCE_ROOT; }; OBJ_6 /* Package.swift */ = {isa = PBXFileReference; explicitFileType = sourcecode.swift; path = Package.swift; sourceTree = ""; }; OBJ_9 /* jni.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = jni.c; sourceTree = ""; }; /* End PBXFileReference section */ @@ -107,16 +106,14 @@ name = Products; sourceTree = BUILT_PRODUCTS_DIR; }; - OBJ_5 /* */ = { + OBJ_5 = { isa = PBXGroup; children = ( OBJ_6 /* Package.swift */, OBJ_7 /* Sources */, OBJ_22 /* Tests */, - OBJ_23 /* JNISwift */, OBJ_24 /* Products */, ); - name = ""; sourceTree = ""; }; OBJ_7 /* Sources */ = { @@ -189,7 +186,7 @@ knownRegions = ( en, ); - mainGroup = OBJ_5 /* */; + mainGroup = OBJ_5; productRefGroup = OBJ_24 /* Products */; projectDirPath = ""; projectRoot = ""; diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index 47dc543..8390d1d 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -383,7 +383,7 @@ struct JNINativeInterface jstring (* _Nonnull NewString)(JNIEnv * _Nonnull, const jchar * _Nonnull, jsize); jsize (* _Nonnull GetStringLength)(JNIEnv * _Nonnull, jstring); - const jchar *(* _Nonnull GetStringChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nullable); + const jchar * _Nullable(* _Nonnull GetStringChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nullable); void (* _Nonnull ReleaseStringChars)(JNIEnv * _Nonnull, jstring, const jchar * _Nonnull); jstring (* _Nonnull NewStringUTF)(JNIEnv * _Nonnull, const char * _Nonnull); jsize (* _Nonnull GetStringUTFLength)(JNIEnv * _Nonnull, jstring); @@ -413,14 +413,14 @@ struct JNINativeInterface jfloat * _Nullable (* _Nonnull GetFloatArrayElements)(JNIEnv * _Nonnull, jfloatArray, jboolean * _Nonnull); jdouble * _Nullable (* _Nonnull GetDoubleArrayElements)(JNIEnv * _Nonnull, jdoubleArray, jboolean * _Nonnull); - void (* _Nonnull ReleaseBooleanArrayElements)(JNIEnv * _Nonnull, jbooleanArray, jboolean *, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseByteArrayElements)(JNIEnv * _Nonnull, jbyteArray, jbyte *, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseCharArrayElements)(JNIEnv * _Nonnull, jcharArray, jchar *, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseShortArrayElements)(JNIEnv * _Nonnull, jshortArray, jshort *, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseIntArrayElements)(JNIEnv * _Nonnull, jintArray, jint *, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseLongArrayElements)(JNIEnv * _Nonnull, jlongArray, jlong *, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseFloatArrayElements)(JNIEnv * _Nonnull, jfloatArray, jfloat *, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseDoubleArrayElements)(JNIEnv * _Nonnull, jdoubleArray, jdouble *, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseBooleanArrayElements)(JNIEnv * _Nonnull, jbooleanArray, jboolean * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseByteArrayElements)(JNIEnv * _Nonnull, jbyteArray, jbyte * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseCharArrayElements)(JNIEnv * _Nonnull, jcharArray, jchar * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseShortArrayElements)(JNIEnv * _Nonnull, jshortArray, jshort * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseIntArrayElements)(JNIEnv * _Nonnull, jintArray, jint * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseLongArrayElements)(JNIEnv * _Nonnull, jlongArray, jlong * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseFloatArrayElements)(JNIEnv * _Nonnull, jfloatArray, jfloat * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); + void (* _Nonnull ReleaseDoubleArrayElements)(JNIEnv * _Nonnull, jdoubleArray, jdouble * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); void (* _Nonnull GetBooleanArrayRegion)(JNIEnv * _Nonnull, jbooleanArray, jsize, jsize, jboolean * _Nonnull); void (* _Nonnull GetByteArrayRegion)(JNIEnv * _Nonnull, jbyteArray, jsize, jsize, jbyte * _Nonnull); @@ -441,7 +441,7 @@ struct JNINativeInterface void (* _Nonnull SetFloatArrayRegion)(JNIEnv * _Nonnull, jfloatArray, jsize, jsize, const jfloat * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); void (* _Nonnull SetDoubleArrayRegion)(JNIEnv * _Nonnull, jdoubleArray, jsize, jsize, const jdouble * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - jint (* _Nonnull RegisterNatives)(JNIEnv * _Nonnull, jclass, const JNINativeMethod *, jint); + jint (* _Nonnull RegisterNatives)(JNIEnv * _Nonnull, jclass, const JNINativeMethod * _Nonnull, jint); jint (* _Nonnull UnregisterNatives)(JNIEnv * _Nonnull, jclass); jint (* _Nonnull MonitorEnter)(JNIEnv * _Nonnull, jobject); jint (* _Nonnull MonitorExit)(JNIEnv * _Nonnull, jobject); @@ -450,11 +450,11 @@ struct JNINativeInterface void (* _Nonnull GetStringRegion)(JNIEnv * _Nonnull, jstring, jsize, jsize, jchar * _Nonnull); void (* _Nonnull GetStringUTFRegion)(JNIEnv * _Nonnull, jstring, jsize, jsize, char * _Nonnull); - void *(* _Nonnull GetPrimitiveArrayCritical)(JNIEnv * _Nonnull, jarray, jboolean * _Nonnull); - void (* _Nonnull ReleasePrimitiveArrayCritical)(JNIEnv * _Nonnull, jarray, void *, jint); + void * _Nullable(* _Nonnull GetPrimitiveArrayCritical)(JNIEnv * _Nonnull, jarray, jboolean * _Nonnull); + void (* _Nonnull ReleasePrimitiveArrayCritical)(JNIEnv * _Nonnull, jarray, void * _Nullable, jint); - const jchar *(* _Nonnull GetStringCritical)(JNIEnv * _Nonnull, jstring, jboolean * _Nonnull); - void (* _Nonnull ReleaseStringCritical)(JNIEnv * _Nonnull, jstring, const jchar * _Nonnull); + const jchar * _Nullable(* _Nonnull GetStringCritical)(JNIEnv * _Nonnull, jstring, jboolean * _Nonnull); + void (* _Nonnull ReleaseStringCritical)(JNIEnv * _Nonnull, jstring, const jchar * _Nullable); jweak (* _Nonnull NewWeakGlobalRef)(JNIEnv * _Nonnull, jobject); void (* _Nonnull DeleteWeakGlobalRef)(JNIEnv * _Nonnull, jweak); @@ -1332,15 +1332,15 @@ struct _JNIEnv */ struct JNIInvokeInterface { - void *reserved0; - void *reserved1; - void *reserved2; + void * _Null_unspecified reserved0; + void * _Null_unspecified reserved1; + void * _Null_unspecified reserved2; jint (* _Nonnull DestroyJavaVM)(JavaVM * _Nonnull); - jint (* _Nonnull AttachCurrentThread)(JavaVM *, JNIEnv **, void * _Nullable); + jint (* _Nonnull AttachCurrentThread)(JavaVM * _Nonnull, JNIEnv * _Nullable * _Nullable, void * _Nullable); jint (* _Nonnull DetachCurrentThread)(JavaVM * _Nonnull); - jint (* _Nonnull GetEnv)(JavaVM *, void **, jint); - jint (* _Nonnull AttachCurrentThreadAsDaemon)(JavaVM *, JNIEnv **, void * _Nonnull); + jint (* _Nonnull GetEnv)(JavaVM * _Nonnull, void * _Nullable * _Nullable, jint); + jint (* _Nonnull AttachCurrentThreadAsDaemon)(JavaVM * _Nonnull, JNIEnv * _Nullable * _Nullable, void * _Nullable); }; /* @@ -1348,7 +1348,7 @@ struct JNIInvokeInterface */ struct _JavaVM { - const struct JNIInvokeInterface *functions; + const struct JNIInvokeInterface * _Nonnull functions; #if defined(__cplusplus) jint DestroyJavaVM() @@ -1376,9 +1376,9 @@ struct _JavaVM struct JavaVMAttachArgs { - jint version; /* must be >= JNI_VERSION_1_2 */ - const char *name; /* NULL or name of thread as modified UTF-8 str */ - jobject group; /* global ref of a ThreadGroup object, or NULL */ + jint version; /** must be >= JNI_VERSION_1_2 */ + const char * _Nullable name; /** NULL or name of thread as modified UTF-8 str */ + jobject group; /** global ref of a ThreadGroup object, or NULL */ }; typedef struct JavaVMAttachArgs JavaVMAttachArgs; @@ -1388,8 +1388,8 @@ typedef struct JavaVMAttachArgs JavaVMAttachArgs; */ typedef struct JavaVMOption { - const char *optionString; - void *extraInfo; + const char * _Nullable optionString; + void * _Nullable extraInfo; } JavaVMOption; typedef struct JavaVMInitArgs @@ -1397,7 +1397,7 @@ typedef struct JavaVMInitArgs jint version; /* use JNI_VERSION_1_2 or later */ jint nOptions; - JavaVMOption *options; + JavaVMOption * _Nonnull options; jboolean ignoreUnrecognized; } JavaVMInitArgs; @@ -1423,8 +1423,8 @@ jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize* _Nonnull); * Prototypes for functions exported by loadable shared libs. These are * called by JNI, not provided by JNI. */ -JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved); -JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved); +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM * _Nonnull vm, void * _Null_unspecified reserved); +JNIEXPORT void JNICALL JNI_OnUnload(JavaVM * _Nonnull vm, void * _Null_unspecified reserved); #ifdef __cplusplus } diff --git a/Sources/JNISwift/SwiftJNI.swift b/Sources/JNISwift/SwiftJNI.swift index ceac581..a227edd 100644 --- a/Sources/JNISwift/SwiftJNI.swift +++ b/Sources/JNISwift/SwiftJNI.swift @@ -11,9 +11,7 @@ public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutabl jni = localJNI // set the global for use elsewhere - // #if !os(Android) && swift(>=4) // DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) - // #endif return JNI_VERSION_1_6 } From 64a2600acb34cbc7daddd603422065317acf8685 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Fri, 28 Jul 2017 14:54:48 +0200 Subject: [PATCH 21/84] Rename to JNI --- JNI.xcodeproj/project.pbxproj | 929 ++++++++++-------- .../xcschemes/JNI-Package.xcscheme | 20 +- .../xcshareddata/xcschemes/JNI.xcscheme | 86 -- .../xcschemes/xcschememanagement.plist | 2 +- Package.swift | 6 +- Sources/CJNI/cjni.c | 1 + Sources/CJNI/jni.c | 4 - Sources/JNI/JNI.swift | 2 +- 8 files changed, 530 insertions(+), 520 deletions(-) delete mode 100644 JNI.xcodeproj/xcshareddata/xcschemes/JNI.xcscheme create mode 100644 Sources/CJNI/cjni.c delete mode 100644 Sources/CJNI/jni.c diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index bf35349..ed4024e 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -1,418 +1,517 @@ // !$*UTF8*$! { - archiveVersion = 1; - classes = { - }; - objectVersion = 46; - objects = { - -/* Begin PBXBuildFile section */ - 03B38DF51F1FCA9B00B9CDA9 /* Array+JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = 03B38DF41F1FC98800B9CDA9 /* Array+JavaParameterConvertible.swift */; }; - 03B38DF61F1FCA9F00B9CDA9 /* JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = 03B38DF31F1FC98800B9CDA9 /* JavaParameterConvertible.swift */; }; - OBJ_32 /* JNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_14 /* JNI.swift */; }; - OBJ_33 /* JNIClassManipulation.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_15 /* JNIClassManipulation.swift */; }; - OBJ_34 /* JNIExceptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_16 /* JNIExceptions.swift */; }; - OBJ_35 /* JNIMethods.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_17 /* JNIMethods.swift */; }; - OBJ_36 /* JNIObjects.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_18 /* JNIObjects.swift */; }; - OBJ_37 /* JNIRefs.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_19 /* JNIRefs.swift */; }; - OBJ_38 /* JNIStrings.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_20 /* JNIStrings.swift */; }; - OBJ_39 /* SwiftJNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_21 /* SwiftJNI.swift */; }; - OBJ_41 /* CJNI.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = "JNISwift::CJNI::Product" /* CJNI.framework */; }; - OBJ_48 /* jni.c in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_9 /* jni.c */; }; -/* End PBXBuildFile section */ - -/* Begin PBXContainerItemProxy section */ - 5C1D2F2E1F1E277B0006682E /* PBXContainerItemProxy */ = { - isa = PBXContainerItemProxy; - containerPortal = OBJ_1 /* Project object */; - proxyType = 1; - remoteGlobalIDString = "JNISwift::CJNI"; - remoteInfo = CJNI; - }; -/* End PBXContainerItemProxy section */ - -/* Begin PBXFileReference section */ - 03B38DF31F1FC98800B9CDA9 /* JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JavaParameterConvertible.swift; sourceTree = ""; }; - 03B38DF41F1FC98800B9CDA9 /* Array+JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Array+JavaParameterConvertible.swift"; sourceTree = ""; }; - "JNISwift::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; - "JNISwift::JNISwift::Product" /* JNISwift.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = JNISwift.framework; sourceTree = BUILT_PRODUCTS_DIR; }; - OBJ_11 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; - OBJ_12 /* module.modulemap */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.module-map"; name = module.modulemap; path = "/Users/geordiejay/dev/flowkey/smartphone/RNPlayerComponent/NativePlayerIOS/FlowkeyPlayerSDL/Packages/UIKit/Packages/swift-jni/Sources/CJNI/include/module.modulemap"; sourceTree = ""; }; - OBJ_14 /* JNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; - OBJ_15 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; - OBJ_16 /* JNIExceptions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIExceptions.swift; sourceTree = ""; }; - OBJ_17 /* JNIMethods.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIMethods.swift; sourceTree = ""; }; - OBJ_18 /* JNIObjects.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIObjects.swift; sourceTree = ""; }; - OBJ_19 /* JNIRefs.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIRefs.swift; sourceTree = ""; }; - OBJ_20 /* JNIStrings.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIStrings.swift; sourceTree = ""; }; - OBJ_21 /* SwiftJNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SwiftJNI.swift; sourceTree = ""; }; - OBJ_6 /* Package.swift */ = {isa = PBXFileReference; explicitFileType = sourcecode.swift; path = Package.swift; sourceTree = ""; }; - OBJ_9 /* jni.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = jni.c; sourceTree = ""; }; -/* End PBXFileReference section */ - -/* Begin PBXFrameworksBuildPhase section */ - OBJ_40 /* Frameworks */ = { - isa = PBXFrameworksBuildPhase; - buildActionMask = 0; - files = ( - OBJ_41 /* CJNI.framework in Frameworks */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - OBJ_49 /* Frameworks */ = { - isa = PBXFrameworksBuildPhase; - buildActionMask = 0; - files = ( - ); - runOnlyForDeploymentPostprocessing = 0; - }; -/* End PBXFrameworksBuildPhase section */ - -/* Begin PBXGroup section */ - OBJ_10 /* include */ = { - isa = PBXGroup; - children = ( - OBJ_11 /* jni.h */, - OBJ_12 /* module.modulemap */, - ); - path = include; - sourceTree = ""; - }; - OBJ_13 /* JNI */ = { - isa = PBXGroup; - children = ( - 03B38DF41F1FC98800B9CDA9 /* Array+JavaParameterConvertible.swift */, - 03B38DF31F1FC98800B9CDA9 /* JavaParameterConvertible.swift */, - OBJ_14 /* JNI.swift */, - OBJ_15 /* JNIClassManipulation.swift */, - OBJ_16 /* JNIExceptions.swift */, - OBJ_17 /* JNIMethods.swift */, - OBJ_18 /* JNIObjects.swift */, - OBJ_19 /* JNIRefs.swift */, - OBJ_20 /* JNIStrings.swift */, - OBJ_21 /* SwiftJNI.swift */, - ); - name = JNI; - path = Sources/JNI; - sourceTree = SOURCE_ROOT; - }; - OBJ_22 /* Tests */ = { - isa = PBXGroup; - children = ( - ); - name = Tests; - sourceTree = SOURCE_ROOT; - }; - OBJ_24 /* Products */ = { - isa = PBXGroup; - children = ( - "JNISwift::JNISwift::Product" /* JNISwift.framework */, - "JNISwift::CJNI::Product" /* CJNI.framework */, - ); - name = Products; - sourceTree = BUILT_PRODUCTS_DIR; - }; - OBJ_5 = { - isa = PBXGroup; - children = ( - OBJ_6 /* Package.swift */, - OBJ_7 /* Sources */, - OBJ_22 /* Tests */, - OBJ_24 /* Products */, - ); - sourceTree = ""; - }; - OBJ_7 /* Sources */ = { - isa = PBXGroup; - children = ( - OBJ_8 /* CJNI */, - OBJ_13 /* JNI */, - ); - name = Sources; - sourceTree = SOURCE_ROOT; - }; - OBJ_8 /* CJNI */ = { - isa = PBXGroup; - children = ( - OBJ_9 /* jni.c */, - OBJ_10 /* include */, - ); - name = CJNI; - path = Sources/CJNI; - sourceTree = SOURCE_ROOT; - }; -/* End PBXGroup section */ - -/* Begin PBXNativeTarget section */ - "JNISwift::CJNI" /* CJNI */ = { - isa = PBXNativeTarget; - buildConfigurationList = OBJ_44 /* Build configuration list for PBXNativeTarget "CJNI" */; - buildPhases = ( - OBJ_47 /* Sources */, - OBJ_49 /* Frameworks */, - ); - buildRules = ( - ); - dependencies = ( - ); - name = CJNI; - productName = CJNI; - productReference = "JNISwift::CJNI::Product" /* CJNI.framework */; - productType = "com.apple.product-type.framework"; - }; - "JNISwift::JNISwift" /* JNI */ = { - isa = PBXNativeTarget; - buildConfigurationList = OBJ_28 /* Build configuration list for PBXNativeTarget "JNI" */; - buildPhases = ( - OBJ_31 /* Sources */, - OBJ_40 /* Frameworks */, - ); - buildRules = ( - ); - dependencies = ( - OBJ_42 /* PBXTargetDependency */, - ); - name = JNI; - productName = JNISwift; - productReference = "JNISwift::JNISwift::Product" /* JNISwift.framework */; - productType = "com.apple.product-type.framework"; - }; -/* End PBXNativeTarget section */ - -/* Begin PBXProject section */ - OBJ_1 /* Project object */ = { - isa = PBXProject; - attributes = { - LastUpgradeCheck = 9999; - }; - buildConfigurationList = OBJ_2 /* Build configuration list for PBXProject "JNI" */; - compatibilityVersion = "Xcode 3.2"; - developmentRegion = English; - hasScannedForEncodings = 0; - knownRegions = ( - en, - ); - mainGroup = OBJ_5; - productRefGroup = OBJ_24 /* Products */; - projectDirPath = ""; - projectRoot = ""; - targets = ( - "JNISwift::JNISwift" /* JNI */, - "JNISwift::CJNI" /* CJNI */, - ); - }; -/* End PBXProject section */ - -/* Begin PBXSourcesBuildPhase section */ - OBJ_31 /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 0; - files = ( - OBJ_32 /* JNI.swift in Sources */, - 03B38DF51F1FCA9B00B9CDA9 /* Array+JavaParameterConvertible.swift in Sources */, - OBJ_33 /* JNIClassManipulation.swift in Sources */, - OBJ_34 /* JNIExceptions.swift in Sources */, - OBJ_35 /* JNIMethods.swift in Sources */, - OBJ_36 /* JNIObjects.swift in Sources */, - OBJ_37 /* JNIRefs.swift in Sources */, - OBJ_38 /* JNIStrings.swift in Sources */, - OBJ_39 /* SwiftJNI.swift in Sources */, - 03B38DF61F1FCA9F00B9CDA9 /* JavaParameterConvertible.swift in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - OBJ_47 /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 0; - files = ( - OBJ_48 /* jni.c in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; -/* End PBXSourcesBuildPhase section */ - -/* Begin PBXTargetDependency section */ - OBJ_42 /* PBXTargetDependency */ = { - isa = PBXTargetDependency; - target = "JNISwift::CJNI" /* CJNI */; - targetProxy = 5C1D2F2E1F1E277B0006682E /* PBXContainerItemProxy */; - }; -/* End PBXTargetDependency section */ - -/* Begin XCBuildConfiguration section */ - OBJ_29 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - ENABLE_TESTABILITY = YES; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = JNISwift.xcodeproj/JNISwift_Info.plist; - LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; - OTHER_LDFLAGS = "$(inherited)"; - OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; - PRODUCT_BUNDLE_IDENTIFIER = JNISwift; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = YES; - SWIFT_VERSION = 3.0; - TARGET_NAME = JNISwift; - }; - name = Debug; - }; - OBJ_3 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - CLANG_ENABLE_OBJC_ARC = YES; - COMBINE_HIDPI_IMAGES = YES; - COPY_PHASE_STRIP = NO; - DEBUG_INFORMATION_FORMAT = dwarf; - DYLIB_INSTALL_NAME_BASE = "@rpath"; - ENABLE_NS_ASSERTIONS = YES; - GCC_OPTIMIZATION_LEVEL = 0; - MACOSX_DEPLOYMENT_TARGET = 10.10; - ONLY_ACTIVE_ARCH = YES; - OTHER_SWIFT_FLAGS = "-DXcode"; - PRODUCT_NAME = "$(TARGET_NAME)"; - SDKROOT = macosx; - SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; - SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; - SWIFT_OPTIMIZATION_LEVEL = "-Onone"; - USE_HEADERMAP = NO; - }; - name = Debug; - }; - OBJ_30 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - ENABLE_TESTABILITY = YES; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = JNISwift.xcodeproj/JNISwift_Info.plist; - LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; - OTHER_LDFLAGS = "$(inherited)"; - OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; - PRODUCT_BUNDLE_IDENTIFIER = JNISwift; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = YES; - SWIFT_VERSION = 3.0; - TARGET_NAME = JNISwift; - }; - name = Release; - }; - OBJ_4 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - CLANG_ENABLE_OBJC_ARC = YES; - COMBINE_HIDPI_IMAGES = YES; - COPY_PHASE_STRIP = YES; - DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; - DYLIB_INSTALL_NAME_BASE = "@rpath"; - GCC_OPTIMIZATION_LEVEL = s; - MACOSX_DEPLOYMENT_TARGET = 10.10; - OTHER_SWIFT_FLAGS = "-DXcode"; - PRODUCT_NAME = "$(TARGET_NAME)"; - SDKROOT = macosx; - SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; - SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; - SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; - USE_HEADERMAP = NO; - }; - name = Release; - }; - OBJ_45 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - DEFINES_MODULE = NO; - ENABLE_TESTABILITY = YES; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = JNISwift.xcodeproj/CJNI_Info.plist; - LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; - OTHER_LDFLAGS = "$(inherited)"; - OTHER_SWIFT_FLAGS = "$(inherited)"; - PRODUCT_BUNDLE_IDENTIFIER = CJNI; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = YES; - TARGET_NAME = CJNI; - }; - name = Debug; - }; - OBJ_46 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - DEFINES_MODULE = NO; - ENABLE_TESTABILITY = YES; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = JNISwift.xcodeproj/CJNI_Info.plist; - LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; - OTHER_LDFLAGS = "$(inherited)"; - OTHER_SWIFT_FLAGS = "$(inherited)"; - PRODUCT_BUNDLE_IDENTIFIER = CJNI; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = YES; - TARGET_NAME = CJNI; - }; - name = Release; - }; -/* End XCBuildConfiguration section */ - -/* Begin XCConfigurationList section */ - OBJ_2 /* Build configuration list for PBXProject "JNI" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - OBJ_3 /* Debug */, - OBJ_4 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Debug; - }; - OBJ_28 /* Build configuration list for PBXNativeTarget "JNI" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - OBJ_29 /* Debug */, - OBJ_30 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Debug; - }; - OBJ_44 /* Build configuration list for PBXNativeTarget "CJNI" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - OBJ_45 /* Debug */, - OBJ_46 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Debug; - }; -/* End XCConfigurationList section */ - }; - rootObject = OBJ_1 /* Project object */; + archiveVersion = "1"; + objectVersion = "46"; + objects = { + "JNI::CJNI" = { + isa = "PBXNativeTarget"; + buildConfigurationList = "OBJ_47"; + buildPhases = ( + "OBJ_50", + "OBJ_52", + ); + dependencies = ( + ); + name = "CJNI"; + productName = "CJNI"; + productReference = "JNI::CJNI::Product"; + productType = "com.apple.product-type.framework"; + }; + "JNI::CJNI::Product" = { + isa = "PBXFileReference"; + path = "CJNI.framework"; + sourceTree = "BUILT_PRODUCTS_DIR"; + }; + "JNI::JNI" = { + isa = "PBXNativeTarget"; + buildConfigurationList = "OBJ_29"; + buildPhases = ( + "OBJ_32", + "OBJ_43", + ); + dependencies = ( + "OBJ_45", + ); + name = "JNI"; + productName = "JNI"; + productReference = "JNI::JNI::Product"; + productType = "com.apple.product-type.framework"; + }; + "JNI::JNI::Product" = { + isa = "PBXFileReference"; + path = "JNI.framework"; + sourceTree = "BUILT_PRODUCTS_DIR"; + }; + "OBJ_1" = { + isa = "PBXProject"; + attributes = { + LastUpgradeCheck = "9999"; + }; + buildConfigurationList = "OBJ_2"; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = "English"; + hasScannedForEncodings = "0"; + knownRegions = ( + "en", + ); + mainGroup = "OBJ_5"; + productRefGroup = "OBJ_25"; + projectDirPath = "."; + targets = ( + "JNI::JNI", + "JNI::CJNI", + ); + }; + "OBJ_10" = { + isa = "PBXGroup"; + children = ( + "OBJ_11", + "OBJ_12", + ); + name = "include"; + path = "include"; + sourceTree = ""; + }; + "OBJ_11" = { + isa = "PBXFileReference"; + path = "jni.h"; + sourceTree = ""; + }; + "OBJ_12" = { + isa = "PBXFileReference"; + name = "module.modulemap"; + path = "/Users/geordiejay/dev/flowkey/smartphone/RNPlayerComponent/NativePlayerIOS/FlowkeyPlayerSDL/UIKit/swift-jni/Sources/CJNI/include/module.modulemap"; + sourceTree = ""; + }; + "OBJ_13" = { + isa = "PBXGroup"; + children = ( + "OBJ_14", + "OBJ_15", + "OBJ_16", + "OBJ_17", + "OBJ_18", + "OBJ_19", + "OBJ_20", + "OBJ_21", + "OBJ_22", + "OBJ_23", + ); + name = "JNI"; + path = "Sources/JNI"; + sourceTree = "SOURCE_ROOT"; + }; + "OBJ_14" = { + isa = "PBXFileReference"; + path = "Array+JavaParameterConvertible.swift"; + sourceTree = ""; + }; + "OBJ_15" = { + isa = "PBXFileReference"; + path = "JNI.swift"; + sourceTree = ""; + }; + "OBJ_16" = { + isa = "PBXFileReference"; + path = "JNIClassManipulation.swift"; + sourceTree = ""; + }; + "OBJ_17" = { + isa = "PBXFileReference"; + path = "JNIExceptions.swift"; + sourceTree = ""; + }; + "OBJ_18" = { + isa = "PBXFileReference"; + path = "JNIMethods.swift"; + sourceTree = ""; + }; + "OBJ_19" = { + isa = "PBXFileReference"; + path = "JNIObjects.swift"; + sourceTree = ""; + }; + "OBJ_2" = { + isa = "XCConfigurationList"; + buildConfigurations = ( + "OBJ_3", + "OBJ_4", + ); + defaultConfigurationIsVisible = "0"; + defaultConfigurationName = "Debug"; + }; + "OBJ_20" = { + isa = "PBXFileReference"; + path = "JNIRefs.swift"; + sourceTree = ""; + }; + "OBJ_21" = { + isa = "PBXFileReference"; + path = "JNIStrings.swift"; + sourceTree = ""; + }; + "OBJ_22" = { + isa = "PBXFileReference"; + path = "JavaParameterConvertible.swift"; + sourceTree = ""; + }; + "OBJ_23" = { + isa = "PBXFileReference"; + path = "SwiftJNI.swift"; + sourceTree = ""; + }; + "OBJ_24" = { + isa = "PBXGroup"; + children = ( + ); + name = "Tests"; + path = ""; + sourceTree = "SOURCE_ROOT"; + }; + "OBJ_25" = { + isa = "PBXGroup"; + children = ( + "JNI::JNI::Product", + "JNI::CJNI::Product", + ); + name = "Products"; + path = ""; + sourceTree = "BUILT_PRODUCTS_DIR"; + }; + "OBJ_29" = { + isa = "XCConfigurationList"; + buildConfigurations = ( + "OBJ_30", + "OBJ_31", + ); + defaultConfigurationIsVisible = "0"; + defaultConfigurationName = "Debug"; + }; + "OBJ_3" = { + isa = "XCBuildConfiguration"; + buildSettings = { + CLANG_ENABLE_OBJC_ARC = "YES"; + COMBINE_HIDPI_IMAGES = "YES"; + COPY_PHASE_STRIP = "NO"; + DEBUG_INFORMATION_FORMAT = "dwarf"; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + ENABLE_NS_ASSERTIONS = "YES"; + GCC_OPTIMIZATION_LEVEL = "0"; + MACOSX_DEPLOYMENT_TARGET = "10.10"; + ONLY_ACTIVE_ARCH = "YES"; + OTHER_SWIFT_FLAGS = ( + "-DXcode", + ); + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = "macosx"; + SUPPORTED_PLATFORMS = ( + "macosx", + "iphoneos", + "iphonesimulator", + "appletvos", + "appletvsimulator", + "watchos", + "watchsimulator", + ); + SWIFT_ACTIVE_COMPILATION_CONDITIONS = "SWIFT_PACKAGE"; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + USE_HEADERMAP = "NO"; + }; + name = "Debug"; + }; + "OBJ_30" = { + isa = "XCBuildConfiguration"; + buildSettings = { + ENABLE_TESTABILITY = "YES"; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = "JNI.xcodeproj/JNI_Info.plist"; + LD_RUNPATH_SEARCH_PATHS = ( + "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx", + ); + OTHER_LDFLAGS = ( + "$(inherited)", + ); + OTHER_SWIFT_FLAGS = ( + "$(inherited)", + "-Xcc", + "-fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap", + ); + PRODUCT_BUNDLE_IDENTIFIER = "JNI"; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = "YES"; + SWIFT_VERSION = "4.0"; + TARGET_NAME = "JNI"; + }; + name = "Debug"; + }; + "OBJ_31" = { + isa = "XCBuildConfiguration"; + buildSettings = { + ENABLE_TESTABILITY = "YES"; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = "JNI.xcodeproj/JNI_Info.plist"; + LD_RUNPATH_SEARCH_PATHS = ( + "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx", + ); + OTHER_LDFLAGS = ( + "$(inherited)", + ); + OTHER_SWIFT_FLAGS = ( + "$(inherited)", + "-Xcc", + "-fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap", + ); + PRODUCT_BUNDLE_IDENTIFIER = "JNI"; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = "YES"; + SWIFT_VERSION = "4.0"; + TARGET_NAME = "JNI"; + }; + name = "Release"; + }; + "OBJ_32" = { + isa = "PBXSourcesBuildPhase"; + files = ( + "OBJ_33", + "OBJ_34", + "OBJ_35", + "OBJ_36", + "OBJ_37", + "OBJ_38", + "OBJ_39", + "OBJ_40", + "OBJ_41", + "OBJ_42", + ); + }; + "OBJ_33" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_14"; + }; + "OBJ_34" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_15"; + }; + "OBJ_35" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_16"; + }; + "OBJ_36" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_17"; + }; + "OBJ_37" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_18"; + }; + "OBJ_38" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_19"; + }; + "OBJ_39" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_20"; + }; + "OBJ_4" = { + isa = "XCBuildConfiguration"; + buildSettings = { + CLANG_ENABLE_OBJC_ARC = "YES"; + COMBINE_HIDPI_IMAGES = "YES"; + COPY_PHASE_STRIP = "YES"; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + GCC_OPTIMIZATION_LEVEL = "s"; + MACOSX_DEPLOYMENT_TARGET = "10.10"; + OTHER_SWIFT_FLAGS = ( + "-DXcode", + ); + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = "macosx"; + SUPPORTED_PLATFORMS = ( + "macosx", + "iphoneos", + "iphonesimulator", + "appletvos", + "appletvsimulator", + "watchos", + "watchsimulator", + ); + SWIFT_ACTIVE_COMPILATION_CONDITIONS = "SWIFT_PACKAGE"; + SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; + USE_HEADERMAP = "NO"; + }; + name = "Release"; + }; + "OBJ_40" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_21"; + }; + "OBJ_41" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_22"; + }; + "OBJ_42" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_23"; + }; + "OBJ_43" = { + isa = "PBXFrameworksBuildPhase"; + files = ( + "OBJ_44", + ); + }; + "OBJ_44" = { + isa = "PBXBuildFile"; + fileRef = "JNI::CJNI::Product"; + }; + "OBJ_45" = { + isa = "PBXTargetDependency"; + target = "JNI::CJNI"; + }; + "OBJ_47" = { + isa = "XCConfigurationList"; + buildConfigurations = ( + "OBJ_48", + "OBJ_49", + ); + defaultConfigurationIsVisible = "0"; + defaultConfigurationName = "Debug"; + }; + "OBJ_48" = { + isa = "XCBuildConfiguration"; + buildSettings = { + DEFINES_MODULE = "NO"; + ENABLE_TESTABILITY = "YES"; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = "JNI.xcodeproj/CJNI_Info.plist"; + LD_RUNPATH_SEARCH_PATHS = ( + "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx", + ); + OTHER_LDFLAGS = ( + "$(inherited)", + ); + OTHER_SWIFT_FLAGS = ( + "$(inherited)", + ); + PRODUCT_BUNDLE_IDENTIFIER = "CJNI"; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = "YES"; + TARGET_NAME = "CJNI"; + }; + name = "Debug"; + }; + "OBJ_49" = { + isa = "XCBuildConfiguration"; + buildSettings = { + DEFINES_MODULE = "NO"; + ENABLE_TESTABILITY = "YES"; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = "JNI.xcodeproj/CJNI_Info.plist"; + LD_RUNPATH_SEARCH_PATHS = ( + "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx", + ); + OTHER_LDFLAGS = ( + "$(inherited)", + ); + OTHER_SWIFT_FLAGS = ( + "$(inherited)", + ); + PRODUCT_BUNDLE_IDENTIFIER = "CJNI"; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = "YES"; + TARGET_NAME = "CJNI"; + }; + name = "Release"; + }; + "OBJ_5" = { + isa = "PBXGroup"; + children = ( + "OBJ_6", + "OBJ_7", + "OBJ_24", + "OBJ_25", + ); + path = ""; + sourceTree = ""; + }; + "OBJ_50" = { + isa = "PBXSourcesBuildPhase"; + files = ( + "OBJ_51", + ); + }; + "OBJ_51" = { + isa = "PBXBuildFile"; + fileRef = "OBJ_9"; + }; + "OBJ_52" = { + isa = "PBXFrameworksBuildPhase"; + files = ( + ); + }; + "OBJ_6" = { + isa = "PBXFileReference"; + explicitFileType = "sourcecode.swift"; + path = "Package.swift"; + sourceTree = ""; + }; + "OBJ_7" = { + isa = "PBXGroup"; + children = ( + "OBJ_8", + "OBJ_13", + ); + name = "Sources"; + path = ""; + sourceTree = "SOURCE_ROOT"; + }; + "OBJ_8" = { + isa = "PBXGroup"; + children = ( + "OBJ_9", + "OBJ_10", + ); + name = "CJNI"; + path = "Sources/CJNI"; + sourceTree = "SOURCE_ROOT"; + }; + "OBJ_9" = { + isa = "PBXFileReference"; + path = "cjni.c"; + sourceTree = ""; + }; + }; + rootObject = "OBJ_1"; } diff --git a/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme b/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme index 55091cd..f067174 100644 --- a/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme +++ b/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme @@ -14,10 +14,10 @@ buildForAnalyzing = "YES"> + BlueprintIdentifier = "JNI::JNI" + BuildableName = "JNI.framework" + BlueprintName = "JNI" + ReferencedContainer = "container:JNI.xcodeproj"> + ReferencedContainer = "container:JNI.xcodeproj"> @@ -61,10 +61,10 @@ + BlueprintIdentifier = "JNI::JNI" + BuildableName = "JNI.framework" + BlueprintName = "JNI" + ReferencedContainer = "container:JNI.xcodeproj"> diff --git a/JNI.xcodeproj/xcshareddata/xcschemes/JNI.xcscheme b/JNI.xcodeproj/xcshareddata/xcschemes/JNI.xcscheme deleted file mode 100644 index 1dfd20b..0000000 --- a/JNI.xcodeproj/xcshareddata/xcschemes/JNI.xcscheme +++ /dev/null @@ -1,86 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/JNI.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist b/JNI.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist index 6566254..f212055 100644 --- a/JNI.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist +++ b/JNI.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist @@ -3,7 +3,7 @@ SchemeUserState - JNISwift-Package.xcscheme + JNI-Package.xcscheme SuppressBuildableAutocreation diff --git a/Package.swift b/Package.swift index 710d861..80d2aaf 100644 --- a/Package.swift +++ b/Package.swift @@ -5,10 +5,10 @@ import PackageDescription let package = Package( name: "JNI", products: [ - .library(name: "JNI", type: .dynamic, targets: ["CJNI", "JNI"]) + .library(name: "JNI", type: .dynamic, targets: ["JNI", "CJNI"]) ], targets: [ - .target(name: "JNI", dependencies: ["CJNI"]), - .target(name: "CJNI") + .target(name: "CJNI"), + .target(name: "JNI", dependencies: ["CJNI"]) ] ) diff --git a/Sources/CJNI/cjni.c b/Sources/CJNI/cjni.c new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/Sources/CJNI/cjni.c @@ -0,0 +1 @@ + diff --git a/Sources/CJNI/jni.c b/Sources/CJNI/jni.c deleted file mode 100644 index 82acb49..0000000 --- a/Sources/CJNI/jni.c +++ /dev/null @@ -1,4 +0,0 @@ -// Stub method to avoid no debug symbol warning from compiler. -int swiftpm_cjni_anchor() { - return 0; -} diff --git a/Sources/JNI/JNI.swift b/Sources/JNI/JNI.swift index 3101980..2b704c1 100644 --- a/Sources/JNI/JNI.swift +++ b/Sources/JNI/JNI.swift @@ -1,4 +1,4 @@ -import CJNI +@_exported import CJNI // "_exported" so we don't have to import both CJNI and JNI all the time public class JNI { /// Our reference to the Java Virtual Machine, to be set on init From 8996ab603098b056de13964ee94fc2475af776ab Mon Sep 17 00:00:00 2001 From: Geordie J Date: Fri, 28 Jul 2017 15:18:30 +0200 Subject: [PATCH 22/84] Clean up JNIMethods --- JNI.xcodeproj/project.pbxproj | 930 ++++++++---------- .../JNI/Array+JavaParameterConvertible.swift | 5 + Sources/JNI/JNIMethods.swift | 37 +- Sources/JNI/JavaParameterConvertible.swift | 3 +- Sources/JNI/SwiftJNI.swift | 17 +- 5 files changed, 442 insertions(+), 550 deletions(-) diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index ed4024e..5d912cf 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -1,517 +1,419 @@ // !$*UTF8*$! { - archiveVersion = "1"; - objectVersion = "46"; - objects = { - "JNI::CJNI" = { - isa = "PBXNativeTarget"; - buildConfigurationList = "OBJ_47"; - buildPhases = ( - "OBJ_50", - "OBJ_52", - ); - dependencies = ( - ); - name = "CJNI"; - productName = "CJNI"; - productReference = "JNI::CJNI::Product"; - productType = "com.apple.product-type.framework"; - }; - "JNI::CJNI::Product" = { - isa = "PBXFileReference"; - path = "CJNI.framework"; - sourceTree = "BUILT_PRODUCTS_DIR"; - }; - "JNI::JNI" = { - isa = "PBXNativeTarget"; - buildConfigurationList = "OBJ_29"; - buildPhases = ( - "OBJ_32", - "OBJ_43", - ); - dependencies = ( - "OBJ_45", - ); - name = "JNI"; - productName = "JNI"; - productReference = "JNI::JNI::Product"; - productType = "com.apple.product-type.framework"; - }; - "JNI::JNI::Product" = { - isa = "PBXFileReference"; - path = "JNI.framework"; - sourceTree = "BUILT_PRODUCTS_DIR"; - }; - "OBJ_1" = { - isa = "PBXProject"; - attributes = { - LastUpgradeCheck = "9999"; - }; - buildConfigurationList = "OBJ_2"; - compatibilityVersion = "Xcode 3.2"; - developmentRegion = "English"; - hasScannedForEncodings = "0"; - knownRegions = ( - "en", - ); - mainGroup = "OBJ_5"; - productRefGroup = "OBJ_25"; - projectDirPath = "."; - targets = ( - "JNI::JNI", - "JNI::CJNI", - ); - }; - "OBJ_10" = { - isa = "PBXGroup"; - children = ( - "OBJ_11", - "OBJ_12", - ); - name = "include"; - path = "include"; - sourceTree = ""; - }; - "OBJ_11" = { - isa = "PBXFileReference"; - path = "jni.h"; - sourceTree = ""; - }; - "OBJ_12" = { - isa = "PBXFileReference"; - name = "module.modulemap"; - path = "/Users/geordiejay/dev/flowkey/smartphone/RNPlayerComponent/NativePlayerIOS/FlowkeyPlayerSDL/UIKit/swift-jni/Sources/CJNI/include/module.modulemap"; - sourceTree = ""; - }; - "OBJ_13" = { - isa = "PBXGroup"; - children = ( - "OBJ_14", - "OBJ_15", - "OBJ_16", - "OBJ_17", - "OBJ_18", - "OBJ_19", - "OBJ_20", - "OBJ_21", - "OBJ_22", - "OBJ_23", - ); - name = "JNI"; - path = "Sources/JNI"; - sourceTree = "SOURCE_ROOT"; - }; - "OBJ_14" = { - isa = "PBXFileReference"; - path = "Array+JavaParameterConvertible.swift"; - sourceTree = ""; - }; - "OBJ_15" = { - isa = "PBXFileReference"; - path = "JNI.swift"; - sourceTree = ""; - }; - "OBJ_16" = { - isa = "PBXFileReference"; - path = "JNIClassManipulation.swift"; - sourceTree = ""; - }; - "OBJ_17" = { - isa = "PBXFileReference"; - path = "JNIExceptions.swift"; - sourceTree = ""; - }; - "OBJ_18" = { - isa = "PBXFileReference"; - path = "JNIMethods.swift"; - sourceTree = ""; - }; - "OBJ_19" = { - isa = "PBXFileReference"; - path = "JNIObjects.swift"; - sourceTree = ""; - }; - "OBJ_2" = { - isa = "XCConfigurationList"; - buildConfigurations = ( - "OBJ_3", - "OBJ_4", - ); - defaultConfigurationIsVisible = "0"; - defaultConfigurationName = "Debug"; - }; - "OBJ_20" = { - isa = "PBXFileReference"; - path = "JNIRefs.swift"; - sourceTree = ""; - }; - "OBJ_21" = { - isa = "PBXFileReference"; - path = "JNIStrings.swift"; - sourceTree = ""; - }; - "OBJ_22" = { - isa = "PBXFileReference"; - path = "JavaParameterConvertible.swift"; - sourceTree = ""; - }; - "OBJ_23" = { - isa = "PBXFileReference"; - path = "SwiftJNI.swift"; - sourceTree = ""; - }; - "OBJ_24" = { - isa = "PBXGroup"; - children = ( - ); - name = "Tests"; - path = ""; - sourceTree = "SOURCE_ROOT"; - }; - "OBJ_25" = { - isa = "PBXGroup"; - children = ( - "JNI::JNI::Product", - "JNI::CJNI::Product", - ); - name = "Products"; - path = ""; - sourceTree = "BUILT_PRODUCTS_DIR"; - }; - "OBJ_29" = { - isa = "XCConfigurationList"; - buildConfigurations = ( - "OBJ_30", - "OBJ_31", - ); - defaultConfigurationIsVisible = "0"; - defaultConfigurationName = "Debug"; - }; - "OBJ_3" = { - isa = "XCBuildConfiguration"; - buildSettings = { - CLANG_ENABLE_OBJC_ARC = "YES"; - COMBINE_HIDPI_IMAGES = "YES"; - COPY_PHASE_STRIP = "NO"; - DEBUG_INFORMATION_FORMAT = "dwarf"; - DYLIB_INSTALL_NAME_BASE = "@rpath"; - ENABLE_NS_ASSERTIONS = "YES"; - GCC_OPTIMIZATION_LEVEL = "0"; - MACOSX_DEPLOYMENT_TARGET = "10.10"; - ONLY_ACTIVE_ARCH = "YES"; - OTHER_SWIFT_FLAGS = ( - "-DXcode", - ); - PRODUCT_NAME = "$(TARGET_NAME)"; - SDKROOT = "macosx"; - SUPPORTED_PLATFORMS = ( - "macosx", - "iphoneos", - "iphonesimulator", - "appletvos", - "appletvsimulator", - "watchos", - "watchsimulator", - ); - SWIFT_ACTIVE_COMPILATION_CONDITIONS = "SWIFT_PACKAGE"; - SWIFT_OPTIMIZATION_LEVEL = "-Onone"; - USE_HEADERMAP = "NO"; - }; - name = "Debug"; - }; - "OBJ_30" = { - isa = "XCBuildConfiguration"; - buildSettings = { - ENABLE_TESTABILITY = "YES"; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = "JNI.xcodeproj/JNI_Info.plist"; - LD_RUNPATH_SEARCH_PATHS = ( - "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx", - ); - OTHER_LDFLAGS = ( - "$(inherited)", - ); - OTHER_SWIFT_FLAGS = ( - "$(inherited)", - "-Xcc", - "-fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap", - ); - PRODUCT_BUNDLE_IDENTIFIER = "JNI"; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = "YES"; - SWIFT_VERSION = "4.0"; - TARGET_NAME = "JNI"; - }; - name = "Debug"; - }; - "OBJ_31" = { - isa = "XCBuildConfiguration"; - buildSettings = { - ENABLE_TESTABILITY = "YES"; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = "JNI.xcodeproj/JNI_Info.plist"; - LD_RUNPATH_SEARCH_PATHS = ( - "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx", - ); - OTHER_LDFLAGS = ( - "$(inherited)", - ); - OTHER_SWIFT_FLAGS = ( - "$(inherited)", - "-Xcc", - "-fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap", - ); - PRODUCT_BUNDLE_IDENTIFIER = "JNI"; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = "YES"; - SWIFT_VERSION = "4.0"; - TARGET_NAME = "JNI"; - }; - name = "Release"; - }; - "OBJ_32" = { - isa = "PBXSourcesBuildPhase"; - files = ( - "OBJ_33", - "OBJ_34", - "OBJ_35", - "OBJ_36", - "OBJ_37", - "OBJ_38", - "OBJ_39", - "OBJ_40", - "OBJ_41", - "OBJ_42", - ); - }; - "OBJ_33" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_14"; - }; - "OBJ_34" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_15"; - }; - "OBJ_35" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_16"; - }; - "OBJ_36" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_17"; - }; - "OBJ_37" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_18"; - }; - "OBJ_38" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_19"; - }; - "OBJ_39" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_20"; - }; - "OBJ_4" = { - isa = "XCBuildConfiguration"; - buildSettings = { - CLANG_ENABLE_OBJC_ARC = "YES"; - COMBINE_HIDPI_IMAGES = "YES"; - COPY_PHASE_STRIP = "YES"; - DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; - DYLIB_INSTALL_NAME_BASE = "@rpath"; - GCC_OPTIMIZATION_LEVEL = "s"; - MACOSX_DEPLOYMENT_TARGET = "10.10"; - OTHER_SWIFT_FLAGS = ( - "-DXcode", - ); - PRODUCT_NAME = "$(TARGET_NAME)"; - SDKROOT = "macosx"; - SUPPORTED_PLATFORMS = ( - "macosx", - "iphoneos", - "iphonesimulator", - "appletvos", - "appletvsimulator", - "watchos", - "watchsimulator", - ); - SWIFT_ACTIVE_COMPILATION_CONDITIONS = "SWIFT_PACKAGE"; - SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; - USE_HEADERMAP = "NO"; - }; - name = "Release"; - }; - "OBJ_40" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_21"; - }; - "OBJ_41" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_22"; - }; - "OBJ_42" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_23"; - }; - "OBJ_43" = { - isa = "PBXFrameworksBuildPhase"; - files = ( - "OBJ_44", - ); - }; - "OBJ_44" = { - isa = "PBXBuildFile"; - fileRef = "JNI::CJNI::Product"; - }; - "OBJ_45" = { - isa = "PBXTargetDependency"; - target = "JNI::CJNI"; - }; - "OBJ_47" = { - isa = "XCConfigurationList"; - buildConfigurations = ( - "OBJ_48", - "OBJ_49", - ); - defaultConfigurationIsVisible = "0"; - defaultConfigurationName = "Debug"; - }; - "OBJ_48" = { - isa = "XCBuildConfiguration"; - buildSettings = { - DEFINES_MODULE = "NO"; - ENABLE_TESTABILITY = "YES"; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = "JNI.xcodeproj/CJNI_Info.plist"; - LD_RUNPATH_SEARCH_PATHS = ( - "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx", - ); - OTHER_LDFLAGS = ( - "$(inherited)", - ); - OTHER_SWIFT_FLAGS = ( - "$(inherited)", - ); - PRODUCT_BUNDLE_IDENTIFIER = "CJNI"; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = "YES"; - TARGET_NAME = "CJNI"; - }; - name = "Debug"; - }; - "OBJ_49" = { - isa = "XCBuildConfiguration"; - buildSettings = { - DEFINES_MODULE = "NO"; - ENABLE_TESTABILITY = "YES"; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = "JNI.xcodeproj/CJNI_Info.plist"; - LD_RUNPATH_SEARCH_PATHS = ( - "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx", - ); - OTHER_LDFLAGS = ( - "$(inherited)", - ); - OTHER_SWIFT_FLAGS = ( - "$(inherited)", - ); - PRODUCT_BUNDLE_IDENTIFIER = "CJNI"; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = "YES"; - TARGET_NAME = "CJNI"; - }; - name = "Release"; - }; - "OBJ_5" = { - isa = "PBXGroup"; - children = ( - "OBJ_6", - "OBJ_7", - "OBJ_24", - "OBJ_25", - ); - path = ""; - sourceTree = ""; - }; - "OBJ_50" = { - isa = "PBXSourcesBuildPhase"; - files = ( - "OBJ_51", - ); - }; - "OBJ_51" = { - isa = "PBXBuildFile"; - fileRef = "OBJ_9"; - }; - "OBJ_52" = { - isa = "PBXFrameworksBuildPhase"; - files = ( - ); - }; - "OBJ_6" = { - isa = "PBXFileReference"; - explicitFileType = "sourcecode.swift"; - path = "Package.swift"; - sourceTree = ""; - }; - "OBJ_7" = { - isa = "PBXGroup"; - children = ( - "OBJ_8", - "OBJ_13", - ); - name = "Sources"; - path = ""; - sourceTree = "SOURCE_ROOT"; - }; - "OBJ_8" = { - isa = "PBXGroup"; - children = ( - "OBJ_9", - "OBJ_10", - ); - name = "CJNI"; - path = "Sources/CJNI"; - sourceTree = "SOURCE_ROOT"; - }; - "OBJ_9" = { - isa = "PBXFileReference"; - path = "cjni.c"; - sourceTree = ""; - }; - }; - rootObject = "OBJ_1"; + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + OBJ_33 /* Array+JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_14 /* Array+JavaParameterConvertible.swift */; }; + OBJ_34 /* JNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_15 /* JNI.swift */; }; + OBJ_35 /* JNIClassManipulation.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_16 /* JNIClassManipulation.swift */; }; + OBJ_36 /* JNIExceptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_17 /* JNIExceptions.swift */; }; + OBJ_37 /* JNIMethods.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_18 /* JNIMethods.swift */; }; + OBJ_38 /* JNIObjects.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_19 /* JNIObjects.swift */; }; + OBJ_39 /* JNIRefs.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_20 /* JNIRefs.swift */; }; + OBJ_40 /* JNIStrings.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_21 /* JNIStrings.swift */; }; + OBJ_41 /* JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_22 /* JavaParameterConvertible.swift */; }; + OBJ_42 /* SwiftJNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_23 /* SwiftJNI.swift */; }; + OBJ_44 /* CJNI.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = "JNI::CJNI::Product" /* CJNI.framework */; }; + OBJ_51 /* cjni.c in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_9 /* cjni.c */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 5C2714A61F2B6DC70026BBA9 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = OBJ_1 /* Project object */; + proxyType = 1; + remoteGlobalIDString = "JNI::CJNI"; + remoteInfo = CJNI; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXFileReference section */ + "JNI::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + "JNI::JNI::Product" /* JNI.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = JNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + OBJ_11 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; + OBJ_12 /* module.modulemap */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.module-map"; name = module.modulemap; path = "/Users/geordiejay/dev/flowkey/smartphone/RNPlayerComponent/NativePlayerIOS/FlowkeyPlayerSDL/UIKit/swift-jni/Sources/CJNI/include/module.modulemap"; sourceTree = ""; }; + OBJ_14 /* Array+JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Array+JavaParameterConvertible.swift"; sourceTree = ""; }; + OBJ_15 /* JNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; + OBJ_16 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; + OBJ_17 /* JNIExceptions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIExceptions.swift; sourceTree = ""; }; + OBJ_18 /* JNIMethods.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIMethods.swift; sourceTree = ""; }; + OBJ_19 /* JNIObjects.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIObjects.swift; sourceTree = ""; }; + OBJ_20 /* JNIRefs.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIRefs.swift; sourceTree = ""; }; + OBJ_21 /* JNIStrings.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIStrings.swift; sourceTree = ""; }; + OBJ_22 /* JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JavaParameterConvertible.swift; sourceTree = ""; }; + OBJ_23 /* SwiftJNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SwiftJNI.swift; sourceTree = ""; }; + OBJ_6 /* Package.swift */ = {isa = PBXFileReference; explicitFileType = sourcecode.swift; path = Package.swift; sourceTree = ""; }; + OBJ_9 /* cjni.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = cjni.c; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + OBJ_43 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 0; + files = ( + OBJ_44 /* CJNI.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + OBJ_52 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 0; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + OBJ_10 /* include */ = { + isa = PBXGroup; + children = ( + OBJ_11 /* jni.h */, + OBJ_12 /* module.modulemap */, + ); + path = include; + sourceTree = ""; + }; + OBJ_13 /* JNI */ = { + isa = PBXGroup; + children = ( + OBJ_14 /* Array+JavaParameterConvertible.swift */, + OBJ_15 /* JNI.swift */, + OBJ_16 /* JNIClassManipulation.swift */, + OBJ_17 /* JNIExceptions.swift */, + OBJ_18 /* JNIMethods.swift */, + OBJ_19 /* JNIObjects.swift */, + OBJ_20 /* JNIRefs.swift */, + OBJ_21 /* JNIStrings.swift */, + OBJ_22 /* JavaParameterConvertible.swift */, + OBJ_23 /* SwiftJNI.swift */, + ); + name = JNI; + path = Sources/JNI; + sourceTree = SOURCE_ROOT; + }; + OBJ_24 /* Tests */ = { + isa = PBXGroup; + children = ( + ); + name = Tests; + sourceTree = SOURCE_ROOT; + }; + OBJ_25 /* Products */ = { + isa = PBXGroup; + children = ( + "JNI::JNI::Product" /* JNI.framework */, + "JNI::CJNI::Product" /* CJNI.framework */, + ); + name = Products; + sourceTree = BUILT_PRODUCTS_DIR; + }; + OBJ_5 /* */ = { + isa = PBXGroup; + children = ( + OBJ_6 /* Package.swift */, + OBJ_7 /* Sources */, + OBJ_24 /* Tests */, + OBJ_25 /* Products */, + ); + name = ""; + sourceTree = ""; + }; + OBJ_7 /* Sources */ = { + isa = PBXGroup; + children = ( + OBJ_8 /* CJNI */, + OBJ_13 /* JNI */, + ); + name = Sources; + sourceTree = SOURCE_ROOT; + }; + OBJ_8 /* CJNI */ = { + isa = PBXGroup; + children = ( + OBJ_9 /* cjni.c */, + OBJ_10 /* include */, + ); + name = CJNI; + path = Sources/CJNI; + sourceTree = SOURCE_ROOT; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + "JNI::CJNI" /* CJNI */ = { + isa = PBXNativeTarget; + buildConfigurationList = OBJ_47 /* Build configuration list for PBXNativeTarget "CJNI" */; + buildPhases = ( + OBJ_50 /* Sources */, + OBJ_52 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = CJNI; + productName = CJNI; + productReference = "JNI::CJNI::Product" /* CJNI.framework */; + productType = "com.apple.product-type.framework"; + }; + "JNI::JNI" /* JNI */ = { + isa = PBXNativeTarget; + buildConfigurationList = OBJ_29 /* Build configuration list for PBXNativeTarget "JNI" */; + buildPhases = ( + OBJ_32 /* Sources */, + OBJ_43 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + OBJ_45 /* PBXTargetDependency */, + ); + name = JNI; + productName = JNI; + productReference = "JNI::JNI::Product" /* JNI.framework */; + productType = "com.apple.product-type.framework"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + OBJ_1 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 9999; + }; + buildConfigurationList = OBJ_2 /* Build configuration list for PBXProject "JNI" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + ); + mainGroup = OBJ_5 /* */; + productRefGroup = OBJ_25 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + "JNI::JNI" /* JNI */, + "JNI::CJNI" /* CJNI */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + OBJ_32 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 0; + files = ( + OBJ_33 /* Array+JavaParameterConvertible.swift in Sources */, + OBJ_34 /* JNI.swift in Sources */, + OBJ_35 /* JNIClassManipulation.swift in Sources */, + OBJ_36 /* JNIExceptions.swift in Sources */, + OBJ_37 /* JNIMethods.swift in Sources */, + OBJ_38 /* JNIObjects.swift in Sources */, + OBJ_39 /* JNIRefs.swift in Sources */, + OBJ_40 /* JNIStrings.swift in Sources */, + OBJ_41 /* JavaParameterConvertible.swift in Sources */, + OBJ_42 /* SwiftJNI.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + OBJ_50 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 0; + files = ( + OBJ_51 /* cjni.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + OBJ_45 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = "JNI::CJNI" /* CJNI */; + targetProxy = 5C2714A61F2B6DC70026BBA9 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin XCBuildConfiguration section */ + OBJ_3 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_OBJC_ARC = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + ENABLE_NS_ASSERTIONS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + MACOSX_DEPLOYMENT_TARGET = 10.10; + ONLY_ACTIVE_ARCH = YES; + OTHER_SWIFT_FLAGS = "-DXcode"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + USE_HEADERMAP = NO; + }; + name = Debug; + }; + OBJ_30 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNI.xcodeproj/JNI_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; + PRODUCT_BUNDLE_IDENTIFIER = JNI; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + SWIFT_VERSION = 4.0; + TARGET_NAME = JNI; + }; + name = Debug; + }; + OBJ_31 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNI.xcodeproj/JNI_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; + PRODUCT_BUNDLE_IDENTIFIER = JNI; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + SWIFT_VERSION = 4.0; + TARGET_NAME = JNI; + }; + name = Release; + }; + OBJ_4 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_OBJC_ARC = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + GCC_OPTIMIZATION_LEVEL = s; + MACOSX_DEPLOYMENT_TARGET = 10.10; + OTHER_SWIFT_FLAGS = "-DXcode"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; + SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; + USE_HEADERMAP = NO; + }; + name = Release; + }; + OBJ_48 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEFINES_MODULE = NO; + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNI.xcodeproj/CJNI_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited)"; + PRODUCT_BUNDLE_IDENTIFIER = CJNI; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + TARGET_NAME = CJNI; + }; + name = Debug; + }; + OBJ_49 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEFINES_MODULE = NO; + ENABLE_TESTABILITY = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/Sources/CJNI/include", + ); + INFOPLIST_FILE = JNI.xcodeproj/CJNI_Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; + OTHER_LDFLAGS = "$(inherited)"; + OTHER_SWIFT_FLAGS = "$(inherited)"; + PRODUCT_BUNDLE_IDENTIFIER = CJNI; + PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; + PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; + SKIP_INSTALL = YES; + TARGET_NAME = CJNI; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + OBJ_2 /* Build configuration list for PBXProject "JNI" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + OBJ_3 /* Debug */, + OBJ_4 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + OBJ_29 /* Build configuration list for PBXNativeTarget "JNI" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + OBJ_30 /* Debug */, + OBJ_31 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + OBJ_47 /* Build configuration list for PBXNativeTarget "CJNI" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + OBJ_48 /* Debug */, + OBJ_49 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; +/* End XCConfigurationList section */ + }; + rootObject = OBJ_1 /* Project object */; } diff --git a/Sources/JNI/Array+JavaParameterConvertible.swift b/Sources/JNI/Array+JavaParameterConvertible.swift index a703c89..119ebbe 100644 --- a/Sources/JNI/Array+JavaParameterConvertible.swift +++ b/Sources/JNI/Array+JavaParameterConvertible.swift @@ -38,4 +38,9 @@ extension Array where Element == JavaParameterConvertible { let returnTypeString = "L" + returnType.replacingFullstopsWithSlashes() + ";" return "(" + self.argumentSignature() + ")" + returnTypeString } + + func methodSignature(customReturnType: String) -> String { + let returnTypeString = customReturnType.replacingFullstopsWithSlashes() + return "(" + self.argumentSignature() + ")" + returnTypeString + } } diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 0fe28d4..a7e5837 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -1,73 +1,52 @@ import CJNI -struct InvalidParameters: Error {} +struct InvalidMethodID: Error {} extension JNI { - // MARK: Static Methods public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws { let methodSignature = arguments.methodSignature(returnType: nil) - - guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) - else { throw InvalidParameters() } + let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) jni.CallStaticVoidMethod(javaClass: javaClass, method: methodID, parameters: arguments.asJavaParameters()) } public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> T { let methodSignature = arguments.methodSignature(returnType: T.self) - - guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) - else { throw InvalidParameters() } + let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) return try T.fromStaticMethod(calling: methodID, on: javaClass, args: arguments.asJavaParameters()) } - public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = [], returningObjectType objectType: String) throws -> JavaObject { - let methodSignature = arguments.methodSignature(returnType: objectType) - guard let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) else { - throw InvalidParameters() - } + let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) return try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: arguments.asJavaParameters()) } - // MARK: Instance/Object Methods public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = []) throws { let methodSignature = arguments.methodSignature(returnType: nil) - - guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { - throw InvalidParameters() - } + let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) return try jni.CallVoidMethod(methodID, on: object, parameters: arguments.asJavaParameters()) } - public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = [], returningObjectType objectType: String) throws -> JavaObject { - let methodSignature = arguments.methodSignature(returnType: objectType) - guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { - throw InvalidParameters() - } + let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) return try jni.CallObjectMethod(methodID, on: object, parameters: arguments.asJavaParameters()) } - public func call(_ methodName: String, on object: JavaObject, with arguments: [JavaParameterConvertible]) throws -> [String] { - let argumentsSignature = arguments.reduce("", { $0 + type(of: $1).asJNIParameterString }) - let methodSignature = "(" + argumentsSignature + ")" + "[" + String.asJNIParameterString - - guard let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) else { throw InvalidParameters() } + let methodSignature = arguments.methodSignature(customReturnType: "[" + String.asJNIParameterString) + let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) let returnedArray = try jni.CallObjectMethod(methodID, on: object, parameters: arguments.asJavaParameters()) return try jni.GetStrings(from: returnedArray) } - } diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index a99c174..9e4e837 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -39,7 +39,8 @@ extension Int: JavaParameterConvertible { } extension String: JavaParameterConvertible { - public static var asJNIParameterString: String { return "Ljava/lang/String;" } + private static let javaClassname = "java/lang/String" + public static let asJNIParameterString = "L\(javaClassname);" public func toJavaParameter() -> JavaParameter { let stringAsObject = jni.NewStringUTF(self) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 5eb2239..6955252 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -65,19 +65,25 @@ extension JNI { return result } - public func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID? { + public func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID { let _env = self._env let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) try checkAndThrowOnJNIError() - let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) + guard let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) else { + throw InvalidMethodID() + } + try checkAndThrowOnJNIError() return result } - public func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID? { + public func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID { let _env = self._env - let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) + guard let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) else { + throw InvalidMethodID() + } + try checkAndThrowOnJNIError() return result } @@ -285,8 +291,7 @@ public struct JavaCallback { guard let javaClass = jni.GetObjectClass(obj: globalJobj), - let methodIDwithoutError = try? jni.GetMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature), - let methodID = methodIDwithoutError + let methodID = try? jni.GetMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) else { // XXX: We should throw here and keep throwing til it gets back to Java fatalError("Failed to make JavaCallback") From 4ed9f9b7612fb8472c9a27769cd314229ebc451b Mon Sep 17 00:00:00 2001 From: Geordie J Date: Fri, 28 Jul 2017 15:20:54 +0200 Subject: [PATCH 23/84] Remove methodSignature(returnType: JavaObjectClassName) --- Sources/JNI/Array+JavaParameterConvertible.swift | 5 ----- Sources/JNI/JNIMethods.swift | 4 ++-- 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/Sources/JNI/Array+JavaParameterConvertible.swift b/Sources/JNI/Array+JavaParameterConvertible.swift index 119ebbe..f389183 100644 --- a/Sources/JNI/Array+JavaParameterConvertible.swift +++ b/Sources/JNI/Array+JavaParameterConvertible.swift @@ -34,11 +34,6 @@ extension Array where Element == JavaParameterConvertible { return "(" + self.argumentSignature() + ")" + returnTypeString } - func methodSignature(returnType: JavaObjectClassName) -> String { - let returnTypeString = "L" + returnType.replacingFullstopsWithSlashes() + ";" - return "(" + self.argumentSignature() + ")" + returnTypeString - } - func methodSignature(customReturnType: String) -> String { let returnTypeString = customReturnType.replacingFullstopsWithSlashes() return "(" + self.argumentSignature() + ")" + returnTypeString diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index a7e5837..14d060e 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -20,7 +20,7 @@ extension JNI { } public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = [], returningObjectType objectType: String) throws -> JavaObject { - let methodSignature = arguments.methodSignature(returnType: objectType) + let methodSignature = arguments.methodSignature(customReturnType: "L" + objectType + ";") let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) return try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: arguments.asJavaParameters()) @@ -36,7 +36,7 @@ extension JNI { } public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = [], returningObjectType objectType: String) throws -> JavaObject { - let methodSignature = arguments.methodSignature(returnType: objectType) + let methodSignature = arguments.methodSignature(customReturnType: "L" + objectType + ";") let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) return try jni.CallObjectMethod(methodID, on: object, parameters: arguments.asJavaParameters()) From 5314ceea6ca8a33725cfb807894223909f0c174f Mon Sep 17 00:00:00 2001 From: Geordie J Date: Fri, 28 Jul 2017 16:26:28 +0200 Subject: [PATCH 24/84] Remove JavaObjectClassName --- Sources/JNI/Array+JavaParameterConvertible.swift | 2 -- 1 file changed, 2 deletions(-) diff --git a/Sources/JNI/Array+JavaParameterConvertible.swift b/Sources/JNI/Array+JavaParameterConvertible.swift index f389183..6f571da 100644 --- a/Sources/JNI/Array+JavaParameterConvertible.swift +++ b/Sources/JNI/Array+JavaParameterConvertible.swift @@ -7,8 +7,6 @@ import CJNI -typealias JavaObjectClassName = String - private extension String { func replacingFullstopsWithSlashes() -> String { let replacedCharacters = self.characters.map { ($0 == ".") ? "/" : $0 } From fa12416fc8b12813cf1649ccd6d9bb5fa58d3120 Mon Sep 17 00:00:00 2001 From: rikner Date: Tue, 1 Aug 2017 18:40:34 +0200 Subject: [PATCH 25/84] implemented generic GetStaticField method --- JNI.xcodeproj/project.pbxproj | 9 ++++++--- Sources/JNI/JNIFields.swift | 22 ++++++++++++++++++++++ Sources/JNI/JavaParameterConvertible.swift | 16 ++++++++++++++++ Sources/JNI/SwiftJNI.swift | 17 +++++++++++++++++ 4 files changed, 61 insertions(+), 3 deletions(-) create mode 100644 Sources/JNI/JNIFields.swift diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index 5d912cf..01e2637 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -7,6 +7,7 @@ objects = { /* Begin PBXBuildFile section */ + 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */ = {isa = PBXBuildFile; fileRef = 034A7B8D1F30D18A0071A850 /* JNIFields.swift */; }; OBJ_33 /* Array+JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_14 /* Array+JavaParameterConvertible.swift */; }; OBJ_34 /* JNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_15 /* JNI.swift */; }; OBJ_35 /* JNIClassManipulation.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_16 /* JNIClassManipulation.swift */; }; @@ -32,6 +33,7 @@ /* End PBXContainerItemProxy section */ /* Begin PBXFileReference section */ + 034A7B8D1F30D18A0071A850 /* JNIFields.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIFields.swift; sourceTree = ""; }; "JNI::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; "JNI::JNI::Product" /* JNI.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = JNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; OBJ_11 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; @@ -85,6 +87,7 @@ OBJ_15 /* JNI.swift */, OBJ_16 /* JNIClassManipulation.swift */, OBJ_17 /* JNIExceptions.swift */, + 034A7B8D1F30D18A0071A850 /* JNIFields.swift */, OBJ_18 /* JNIMethods.swift */, OBJ_19 /* JNIObjects.swift */, OBJ_20 /* JNIRefs.swift */, @@ -112,7 +115,7 @@ name = Products; sourceTree = BUILT_PRODUCTS_DIR; }; - OBJ_5 /* */ = { + OBJ_5 = { isa = PBXGroup; children = ( OBJ_6 /* Package.swift */, @@ -120,7 +123,6 @@ OBJ_24 /* Tests */, OBJ_25 /* Products */, ); - name = ""; sourceTree = ""; }; OBJ_7 /* Sources */ = { @@ -193,7 +195,7 @@ knownRegions = ( en, ); - mainGroup = OBJ_5 /* */; + mainGroup = OBJ_5; productRefGroup = OBJ_25 /* Products */; projectDirPath = ""; projectRoot = ""; @@ -214,6 +216,7 @@ OBJ_35 /* JNIClassManipulation.swift in Sources */, OBJ_36 /* JNIExceptions.swift in Sources */, OBJ_37 /* JNIMethods.swift in Sources */, + 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */, OBJ_38 /* JNIObjects.swift in Sources */, OBJ_39 /* JNIRefs.swift in Sources */, OBJ_40 /* JNIStrings.swift in Sources */, diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift new file mode 100644 index 0000000..7fdfcb5 --- /dev/null +++ b/Sources/JNI/JNIFields.swift @@ -0,0 +1,22 @@ +// +// JNIFields.swift +// JNI +// +// Created by flowing erik on 01.08.17. +// + +import CJNI + +enum StaticFieldError: Error { + case InvalidParameters +} + +public extension JNI { + public func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { + let env = self._env + guard let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) else { + throw StaticFieldError.InvalidParameters + } + return try T.fromStaticField(of: javaClass, id: fieldID) + } +} diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 9e4e837..a97b6c0 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -11,6 +11,7 @@ public protocol JavaParameterConvertible { static var asJNIParameterString: String { get } func toJavaParameter() -> JavaParameter static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self + static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Self } extension Bool: JavaParameterConvertible { @@ -20,6 +21,10 @@ extension Bool: JavaParameterConvertible { return JavaParameter(bool: (self) ? 1 : 0) } + public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Bool { + return jni.GetStaticBooleanField(of: javaClass, id: id) == 1 + } + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Bool { return jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == 1 } @@ -32,6 +37,10 @@ extension Int: JavaParameterConvertible { return JavaParameter(int: JavaInt(self)) } + public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Int { + return Int(jni.GetStaticIntField(of: javaClass, id: id)) + } + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Int { let result = try jni.CallStaticIntMethod(methodID, on: javaClass, parameters: args) return Int(result) @@ -47,6 +56,13 @@ extension String: JavaParameterConvertible { return JavaParameter(object: stringAsObject) } + public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> String { + guard let javaObject = jni.GetStaticObjectField(of: javaClass, id: id) else { + throw StaticFieldError.InvalidParameters + } + return jni.GetString(from: javaObject as JavaString) + } + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> String { let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) return jni.GetString(from: jObject) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 6955252..485204e 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -139,6 +139,23 @@ extension JNI { _env.pointee.pointee.CallStaticVoidMethodA(_env, javaClass, method, &methodArgs) } + // MARK: Fields + + public func GetStaticBooleanField(of javaClass: JavaClass, id: jfieldID) -> JavaBoolean { + let _env = self._env + return _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) + } + + public func GetStaticIntField(of javaClass: JavaClass, id: jfieldID) -> JavaInt { + let _env = self._env + return _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) + } + + public func GetStaticObjectField(of javaClass: JavaClass, id: jfieldID) -> JavaObject? { + let _env = self._env + return _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) + } + // MARK: Arrays public func GetLength(_ array: JavaArray) -> Int { From 4b18b6c9b45dcfd5e8c4c7165044daff6d2d648b Mon Sep 17 00:00:00 2001 From: Geordie J Date: Wed, 2 Aug 2017 19:28:57 +0200 Subject: [PATCH 26/84] Add more type conformances (Double, Int) to JavaParameterConvertible - add JavaParameterConvertible.fromMethod() to complement .fromStaticMethod() - add JNIObject type to help constructing java objects from Swift and calling their methods --- .../JNI/Array+JavaParameterConvertible.swift | 2 +- Sources/JNI/JNIClassManipulation.swift | 4 +- Sources/JNI/JNIMethods.swift | 9 ++- Sources/JNI/JNIObjects.swift | 65 ++++++++++++++++--- Sources/JNI/JNIRefs.swift | 8 +-- Sources/JNI/JavaParameterConvertible.swift | 35 +++++++++- Sources/JNI/SwiftJNI.swift | 57 +++++++++++----- 7 files changed, 145 insertions(+), 35 deletions(-) diff --git a/Sources/JNI/Array+JavaParameterConvertible.swift b/Sources/JNI/Array+JavaParameterConvertible.swift index 6f571da..1e0318a 100644 --- a/Sources/JNI/Array+JavaParameterConvertible.swift +++ b/Sources/JNI/Array+JavaParameterConvertible.swift @@ -7,7 +7,7 @@ import CJNI -private extension String { +extension String { func replacingFullstopsWithSlashes() -> String { let replacedCharacters = self.characters.map { ($0 == ".") ? "/" : $0 } return String(String.CharacterView(replacedCharacters)) diff --git a/Sources/JNI/JNIClassManipulation.swift b/Sources/JNI/JNIClassManipulation.swift index 9f52706..e6bba2d 100644 --- a/Sources/JNI/JNIClassManipulation.swift +++ b/Sources/JNI/JNIClassManipulation.swift @@ -6,9 +6,9 @@ public extension JNI { // return env.pointee.pointee.DefineClass(env, name, loader, buffer, bufferLength)! // } - public func FindClass(name: String) -> JavaClass { + public func FindClass(name: String) -> JavaClass? { let env = self._env - return env.pointee.pointee.FindClass(env, name)! + return env.pointee.pointee.FindClass(env, name) } public func FromReflectedMethod(method: JavaObject) -> JavaMethodID { diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 14d060e..3661719 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -9,7 +9,7 @@ extension JNI { let methodSignature = arguments.methodSignature(returnType: nil) let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) - jni.CallStaticVoidMethod(javaClass: javaClass, method: methodID, parameters: arguments.asJavaParameters()) + try jni.CallStaticVoidMethod(javaClass: javaClass, method: methodID, parameters: arguments.asJavaParameters()) } public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> T { @@ -35,6 +35,13 @@ extension JNI { return try jni.CallVoidMethod(methodID, on: object, parameters: arguments.asJavaParameters()) } + public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = []) throws -> T { + let methodSignature = arguments.methodSignature(returnType: T.self) + let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) + + return try T.fromMethod(calling: methodID, on: object, args: arguments.asJavaParameters()) + } + public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = [], returningObjectType objectType: String) throws -> JavaObject { let methodSignature = arguments.methodSignature(customReturnType: "L" + objectType + ";") let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 029d398..0063f0c 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,20 +1,67 @@ import CJNI -public extension JNI { +/// Designed to simplify calling a constructor and methods on a JavaClass +/// Subclass this and add the methods appropriate to the object you are constructing. +open class JNIObject { + public let javaClass: JavaClass + public let instance: JavaObject - public func AllocObject(targetClass: JavaClass) -> JavaObject { - let env = self._env - return env.pointee.pointee.AllocObject(env, targetClass)! - } + public init?(_ className: String, arguments: [JavaParameterConvertible] = []) { + let className = className.replacingFullstopsWithSlashes() + + guard + let javaClassLocalRef = jni.FindClass(name: className), + let javaClass = jni.NewGlobalRef(javaClassLocalRef) + else { + assertionFailure("Couldn't find class named \(className)") + return nil + } + + self.javaClass = javaClass + + guard + let instanceLocalRef = try? jni.callConstructor(on: javaClass, arguments: arguments), + let instance = jni.NewGlobalRef(instanceLocalRef) + else { + assertionFailure("Couldn't call constructor of \(className)") + return nil + } + + self.instance = instance + } + + public func call(methodName: String, arguments: [JavaParameterConvertible] = []) throws { + try jni.call(methodName, on: self.instance, arguments: arguments) + } - public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: JavaParameter...) -> JavaObject { - return self.NewObject(targetClass: targetClass, methodID, args) + public func call(methodName: String, arguments: [JavaParameterConvertible] = []) throws -> T { + return try jni.call(methodName, on: self.instance, arguments: arguments) + } + + public func callStatic(methodName: String, arguments: [JavaParameterConvertible] = []) throws { + try jni.callStatic(methodName, on: self.javaClass, arguments: arguments) + } +} + +extension JNI { + func callConstructor(on targetClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> JavaObject { + let methodID = try jni.GetMethodID(for: targetClass, methodName: "", methodSignature: arguments.methodSignature(returnType: nil)) + + // There's no reason for this to fail if the methodID was correct: + return jni.NewObject(targetClass: targetClass, methodID, arguments.asJavaParameters())! + } +} + +public extension JNI { + public func AllocObject(targetClass: JavaClass) -> JavaObject? { + let env = self._env + return env.pointee.pointee.AllocObject(env, targetClass) } - public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) -> JavaObject { + public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) -> JavaObject? { let env = self._env var mutableArgs = args - return env.pointee.pointee.NewObject(env, targetClass, methodID, &mutableArgs)! + return env.pointee.pointee.NewObject(env, targetClass, methodID, &mutableArgs) } public func GetObjectClass(obj: JavaObject) -> JavaClass? { diff --git a/Sources/JNI/JNIRefs.swift b/Sources/JNI/JNIRefs.swift index 39e019c..b434b6c 100644 --- a/Sources/JNI/JNIRefs.swift +++ b/Sources/JNI/JNIRefs.swift @@ -1,9 +1,9 @@ import CJNI public extension JNI { - public func NewGlobalRef(obj: JavaObject) -> JavaObject { + public func NewGlobalRef(_ object: JavaObject) -> JavaObject? { let env = self._env - return env.pointee.pointee.NewGlobalRef(env, obj)! + return env.pointee.pointee.NewGlobalRef(env, object) } public func DeleteGlobalRef(globalRef: JavaObject) { @@ -11,9 +11,9 @@ public extension JNI { env.pointee.pointee.DeleteGlobalRef(env, globalRef) } - public func NewLocalRef(ref: JavaObject) -> JavaObject { + public func NewLocalRef(ref: JavaObject) -> JavaObject? { let env = self._env - return env.pointee.pointee.NewLocalRef(env, ref)! + return env.pointee.pointee.NewLocalRef(env, ref) } public func DeleteLocalRef(localRef: JavaObject) { diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 9e4e837..e08018c 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -6,10 +6,13 @@ // import CJNI + public protocol JavaParameterConvertible { typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) static var asJNIParameterString: String { get } func toJavaParameter() -> JavaParameter + + static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Self static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self } @@ -20,8 +23,12 @@ extension Bool: JavaParameterConvertible { return JavaParameter(bool: (self) ? 1 : 0) } + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Bool { + return try jni.CallBooleanMethod(methodID, on: object, parameters: args) == JNI_TRUE + } + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Bool { - return jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == 1 + return try jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == JNI_TRUE } } @@ -32,12 +39,33 @@ extension Int: JavaParameterConvertible { return JavaParameter(int: JavaInt(self)) } + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Int { + let result = try jni.CallIntMethod(methodID, on: object, parameters: args) + return Int(result) + } + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Int { let result = try jni.CallStaticIntMethod(methodID, on: javaClass, parameters: args) return Int(result) } } +extension Double: JavaParameterConvertible { + public static var asJNIParameterString: String { return "D" } + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(double: JavaDouble(self)) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Double { + return try jni.CallDoubleMethod(methodID, on: object, parameters: args) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Double { + return try jni.CallStaticDoubleMethod(methodID, on: javaClass, parameters: args) + } +} + extension String: JavaParameterConvertible { private static let javaClassname = "java/lang/String" public static let asJNIParameterString = "L\(javaClassname);" @@ -47,6 +75,11 @@ extension String: JavaParameterConvertible { return JavaParameter(object: stringAsObject) } + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> String { + let jObject = try jni.CallObjectMethod(methodID, on: object, parameters: args) + return jni.GetString(from: jObject) + } + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> String { let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) return jni.GetString(from: jObject) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 6955252..108b0da 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -49,22 +49,8 @@ extension JNI { return string } - // MARK: References - - public func NewGlobalRef(object: JavaObject) -> JavaObject? { - let _env = self._env - let result = _env.pointee.pointee.NewGlobalRef(_env, object) - return result - } - // MARK: Classes and Methods - public func FindClass(className: String) -> JavaClass? { - let _env = self._env - let result = _env.pointee.pointee.FindClass(_env, className) - return result - } - public func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID { let _env = self._env let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) @@ -95,6 +81,30 @@ extension JNI { try checkAndThrowOnJNIError() } + public func CallBooleanMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaBoolean { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallBooleanMethod(_env, object, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallIntMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaInt { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallIntMethod(_env, object, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallDoubleMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaDouble { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallDoubleMethod(_env, object, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + public func CallObjectMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaObject { let _env = self._env var methodArgs = parameters @@ -103,6 +113,8 @@ extension JNI { return result } + // MARK: Static methods + public func CallStaticObjectMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaObject { let _env = self._env var methodArgs = parameters @@ -127,16 +139,27 @@ extension JNI { return result } - public func CallStaticBooleanMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) -> JavaBoolean { + public func CallStaticDoubleMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaDouble { let _env = self._env var methodArgs = parameters - return _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) + let result = _env.pointee.pointee.CallStaticDoubleMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result } - public func CallStaticVoidMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) { + public func CallStaticBooleanMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws -> JavaBoolean { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallStaticVoidMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws { let _env = self._env var methodArgs = parameters _env.pointee.pointee.CallStaticVoidMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() } // MARK: Arrays From d4bb403dce8aabf5eb8b7c7a26b458b80b1c72fb Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 4 Aug 2017 13:57:04 +0200 Subject: [PATCH 27/84] add GetByteArrayRegion and SetByteArrayRegion --- JNI.xcodeproj/project.pbxproj | 2 -- .../contents.xcworkspacedata | 7 +++++++ Sources/JNI/SwiftJNI.swift | 19 +++++++++++++++++++ 3 files changed, 26 insertions(+), 2 deletions(-) create mode 100644 JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index 01e2637..4a79348 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -37,7 +37,6 @@ "JNI::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; "JNI::JNI::Product" /* JNI.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = JNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; OBJ_11 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; - OBJ_12 /* module.modulemap */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.module-map"; name = module.modulemap; path = "/Users/geordiejay/dev/flowkey/smartphone/RNPlayerComponent/NativePlayerIOS/FlowkeyPlayerSDL/UIKit/swift-jni/Sources/CJNI/include/module.modulemap"; sourceTree = ""; }; OBJ_14 /* Array+JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Array+JavaParameterConvertible.swift"; sourceTree = ""; }; OBJ_15 /* JNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; OBJ_16 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; @@ -75,7 +74,6 @@ isa = PBXGroup; children = ( OBJ_11 /* jni.h */, - OBJ_12 /* module.modulemap */, ); path = include; sourceTree = ""; diff --git a/JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..919434a --- /dev/null +++ b/JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 4eea221..0e8ada1 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -199,6 +199,25 @@ extension JNI { return result } + public func GetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, numElements: Int = -1) -> [UInt8] { + let _env = self._env + var count = numElements + + if numElements < 0 { + count = GetLength(array) + } + + var result = [JavaByte](repeating: 0, count: count) + _env.pointee.pointee.GetByteArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + return result.map { UInt8($0) } + } + + public func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: [Int]) { + let _env = self._env + var newElements = sourceElements.map { JavaByte($0) } // make mutable copy + _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + } + public func GetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, numElements: Int = -1) -> [Int] { let _env = self._env var count = numElements From b8a4ca41e219e2e54cf794439a02fe1d6b255921 Mon Sep 17 00:00:00 2001 From: Christian Haug Date: Fri, 4 Aug 2017 16:00:46 +0200 Subject: [PATCH 28/84] Use original GetMethodID with Class in JNIObject constructor --- Sources/JNI/JNIMethods.swift | 1 + Sources/JNI/JNIObjects.swift | 16 +++++++++++----- Sources/JNI/SwiftJNI.swift | 8 +++----- 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 3661719..25b4c94 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -1,6 +1,7 @@ import CJNI struct InvalidMethodID: Error {} +struct ClassForObjectNotFound: Error {} extension JNI { // MARK: Static Methods diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 0063f0c..9ad3af2 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,5 +1,7 @@ import CJNI +struct CreateNewObjectForConstructorError: Error {} + /// Designed to simplify calling a constructor and methods on a JavaClass /// Subclass this and add the methods appropriate to the object you are constructing. open class JNIObject { @@ -45,10 +47,10 @@ open class JNIObject { extension JNI { func callConstructor(on targetClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> JavaObject { - let methodID = try jni.GetMethodID(for: targetClass, methodName: "", methodSignature: arguments.methodSignature(returnType: nil)) + let methodID = _env.pointee.pointee.GetMethodID(_env, targetClass, "", arguments.methodSignature(returnType: nil)) + try checkAndThrowOnJNIError() - // There's no reason for this to fail if the methodID was correct: - return jni.NewObject(targetClass: targetClass, methodID, arguments.asJavaParameters())! + return try jni.NewObject(targetClass: targetClass, methodID!, arguments.asJavaParameters()) } } @@ -58,10 +60,14 @@ public extension JNI { return env.pointee.pointee.AllocObject(env, targetClass) } - public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) -> JavaObject? { + public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) throws -> JavaObject { let env = self._env var mutableArgs = args - return env.pointee.pointee.NewObject(env, targetClass, methodID, &mutableArgs) + guard let newObject = env.pointee.pointee.NewObject(env, targetClass, methodID, &mutableArgs) else { + throw CreateNewObjectForConstructorError() + } + try checkAndThrowOnJNIError() + return newObject } public func GetObjectClass(obj: JavaObject) -> JavaClass? { diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 108b0da..6f1766a 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -56,12 +56,10 @@ extension JNI { let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) try checkAndThrowOnJNIError() - guard let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) else { - throw InvalidMethodID() - } - + let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) try checkAndThrowOnJNIError() - return result + + return result! } public func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID { From 25c407cd549e6bdcd9d45d686dfd11e519cc6d3d Mon Sep 17 00:00:00 2001 From: rikner Date: Tue, 1 Aug 2017 18:40:34 +0200 Subject: [PATCH 29/84] implemented generic GetStaticField method --- JNI.xcodeproj/project.pbxproj | 9 ++++++--- Sources/JNI/JNIFields.swift | 22 ++++++++++++++++++++++ Sources/JNI/JavaParameterConvertible.swift | 16 ++++++++++++++++ Sources/JNI/SwiftJNI.swift | 17 +++++++++++++++++ 4 files changed, 61 insertions(+), 3 deletions(-) create mode 100644 Sources/JNI/JNIFields.swift diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index 5d912cf..01e2637 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -7,6 +7,7 @@ objects = { /* Begin PBXBuildFile section */ + 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */ = {isa = PBXBuildFile; fileRef = 034A7B8D1F30D18A0071A850 /* JNIFields.swift */; }; OBJ_33 /* Array+JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_14 /* Array+JavaParameterConvertible.swift */; }; OBJ_34 /* JNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_15 /* JNI.swift */; }; OBJ_35 /* JNIClassManipulation.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_16 /* JNIClassManipulation.swift */; }; @@ -32,6 +33,7 @@ /* End PBXContainerItemProxy section */ /* Begin PBXFileReference section */ + 034A7B8D1F30D18A0071A850 /* JNIFields.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIFields.swift; sourceTree = ""; }; "JNI::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; "JNI::JNI::Product" /* JNI.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = JNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; OBJ_11 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; @@ -85,6 +87,7 @@ OBJ_15 /* JNI.swift */, OBJ_16 /* JNIClassManipulation.swift */, OBJ_17 /* JNIExceptions.swift */, + 034A7B8D1F30D18A0071A850 /* JNIFields.swift */, OBJ_18 /* JNIMethods.swift */, OBJ_19 /* JNIObjects.swift */, OBJ_20 /* JNIRefs.swift */, @@ -112,7 +115,7 @@ name = Products; sourceTree = BUILT_PRODUCTS_DIR; }; - OBJ_5 /* */ = { + OBJ_5 = { isa = PBXGroup; children = ( OBJ_6 /* Package.swift */, @@ -120,7 +123,6 @@ OBJ_24 /* Tests */, OBJ_25 /* Products */, ); - name = ""; sourceTree = ""; }; OBJ_7 /* Sources */ = { @@ -193,7 +195,7 @@ knownRegions = ( en, ); - mainGroup = OBJ_5 /* */; + mainGroup = OBJ_5; productRefGroup = OBJ_25 /* Products */; projectDirPath = ""; projectRoot = ""; @@ -214,6 +216,7 @@ OBJ_35 /* JNIClassManipulation.swift in Sources */, OBJ_36 /* JNIExceptions.swift in Sources */, OBJ_37 /* JNIMethods.swift in Sources */, + 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */, OBJ_38 /* JNIObjects.swift in Sources */, OBJ_39 /* JNIRefs.swift in Sources */, OBJ_40 /* JNIStrings.swift in Sources */, diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift new file mode 100644 index 0000000..7fdfcb5 --- /dev/null +++ b/Sources/JNI/JNIFields.swift @@ -0,0 +1,22 @@ +// +// JNIFields.swift +// JNI +// +// Created by flowing erik on 01.08.17. +// + +import CJNI + +enum StaticFieldError: Error { + case InvalidParameters +} + +public extension JNI { + public func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { + let env = self._env + guard let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) else { + throw StaticFieldError.InvalidParameters + } + return try T.fromStaticField(of: javaClass, id: fieldID) + } +} diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index e08018c..bfc6c61 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -14,6 +14,7 @@ public protocol JavaParameterConvertible { static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Self static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self + static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Self } extension Bool: JavaParameterConvertible { @@ -23,6 +24,10 @@ extension Bool: JavaParameterConvertible { return JavaParameter(bool: (self) ? 1 : 0) } + public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Bool { + return jni.GetStaticBooleanField(of: javaClass, id: id) == 1 + } + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Bool { return try jni.CallBooleanMethod(methodID, on: object, parameters: args) == JNI_TRUE } @@ -39,6 +44,10 @@ extension Int: JavaParameterConvertible { return JavaParameter(int: JavaInt(self)) } + public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Int { + return Int(jni.GetStaticIntField(of: javaClass, id: id)) + } + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Int { let result = try jni.CallIntMethod(methodID, on: object, parameters: args) return Int(result) @@ -75,6 +84,13 @@ extension String: JavaParameterConvertible { return JavaParameter(object: stringAsObject) } + public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> String { + guard let javaObject = jni.GetStaticObjectField(of: javaClass, id: id) else { + throw StaticFieldError.InvalidParameters + } + return jni.GetString(from: javaObject as JavaString) + } + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> String { let jObject = try jni.CallObjectMethod(methodID, on: object, parameters: args) return jni.GetString(from: jObject) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 6f1766a..c29450f 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -160,6 +160,23 @@ extension JNI { try checkAndThrowOnJNIError() } + // MARK: Fields + + public func GetStaticBooleanField(of javaClass: JavaClass, id: jfieldID) -> JavaBoolean { + let _env = self._env + return _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) + } + + public func GetStaticIntField(of javaClass: JavaClass, id: jfieldID) -> JavaInt { + let _env = self._env + return _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) + } + + public func GetStaticObjectField(of javaClass: JavaClass, id: jfieldID) -> JavaObject? { + let _env = self._env + return _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) + } + // MARK: Arrays public func GetLength(_ array: JavaArray) -> Int { From 79eaf049dfbd8f86aa7d40508b8787c8e473835b Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 4 Aug 2017 13:57:04 +0200 Subject: [PATCH 30/84] add GetByteArrayRegion and SetByteArrayRegion --- JNI.xcodeproj/project.pbxproj | 2 -- .../contents.xcworkspacedata | 7 +++++++ Sources/JNI/SwiftJNI.swift | 19 +++++++++++++++++++ 3 files changed, 26 insertions(+), 2 deletions(-) create mode 100644 JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index 01e2637..4a79348 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -37,7 +37,6 @@ "JNI::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; "JNI::JNI::Product" /* JNI.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = JNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; OBJ_11 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; - OBJ_12 /* module.modulemap */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.module-map"; name = module.modulemap; path = "/Users/geordiejay/dev/flowkey/smartphone/RNPlayerComponent/NativePlayerIOS/FlowkeyPlayerSDL/UIKit/swift-jni/Sources/CJNI/include/module.modulemap"; sourceTree = ""; }; OBJ_14 /* Array+JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Array+JavaParameterConvertible.swift"; sourceTree = ""; }; OBJ_15 /* JNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; OBJ_16 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; @@ -75,7 +74,6 @@ isa = PBXGroup; children = ( OBJ_11 /* jni.h */, - OBJ_12 /* module.modulemap */, ); path = include; sourceTree = ""; diff --git a/JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..919434a --- /dev/null +++ b/JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index c29450f..27aec1c 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -192,6 +192,25 @@ extension JNI { return result } + public func GetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, numElements: Int = -1) -> [UInt8] { + let _env = self._env + var count = numElements + + if numElements < 0 { + count = GetLength(array) + } + + var result = [JavaByte](repeating: 0, count: count) + _env.pointee.pointee.GetByteArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + return result.map { UInt8($0) } + } + + public func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: [Int]) { + let _env = self._env + var newElements = sourceElements.map { JavaByte($0) } // make mutable copy + _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + } + public func GetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, numElements: Int = -1) -> [Int] { let _env = self._env var count = numElements From 05e4d2f921cc97fa2674b9f2b358cf83d1931e4a Mon Sep 17 00:00:00 2001 From: rikner Date: Thu, 10 Aug 2017 16:59:24 +0200 Subject: [PATCH 31/84] implement GetField and GetObjectArrayElement --- Sources/JNI/JNIFields.swift | 13 +++++++-- Sources/JNI/JavaParameterConvertible.swift | 22 ++++++++++++++- Sources/JNI/SwiftJNI.swift | 33 ++++++++++++++++++++++ 3 files changed, 65 insertions(+), 3 deletions(-) diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index 7fdfcb5..c52b420 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -7,7 +7,7 @@ import CJNI -enum StaticFieldError: Error { +enum GetFieldError: Error { case InvalidParameters } @@ -15,8 +15,17 @@ public extension JNI { public func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { let env = self._env guard let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) else { - throw StaticFieldError.InvalidParameters + throw GetFieldError.InvalidParameters } return try T.fromStaticField(of: javaClass, id: fieldID) } + + public func GetField(_ fieldName: String, from javaObject: JavaObject) throws -> T { + let env = self._env + guard let javaClass = GetObjectClass(obj: javaObject), + let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) else { + throw GetFieldError.InvalidParameters + } + return try T.fromField(of: javaObject, id: fieldID) + } } diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 2e5638e..020afee 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -15,6 +15,7 @@ public protocol JavaParameterConvertible { static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Self static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Self + static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Self } extension Bool: JavaParameterConvertible { @@ -35,6 +36,10 @@ extension Bool: JavaParameterConvertible { public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Bool { return try jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == JNI_TRUE } + + public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Bool { + return jni.GetBooleanField(of: javaObject, id: id) == 1 + } } extension Int: JavaParameterConvertible { @@ -57,6 +62,10 @@ extension Int: JavaParameterConvertible { let result = try jni.CallStaticIntMethod(methodID, on: javaClass, parameters: args) return Int(result) } + + public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Int { + return Int(jni.GetIntField(of: javaObject, id: id)) + } } extension Double: JavaParameterConvertible { @@ -77,6 +86,10 @@ extension Double: JavaParameterConvertible { public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Double { return try jni.CallStaticDoubleMethod(methodID, on: javaClass, parameters: args) } + + public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Double { + return Double(jni.GetDoubleField(of: javaObject, id: id)) + } } extension String: JavaParameterConvertible { @@ -90,7 +103,7 @@ extension String: JavaParameterConvertible { public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> String { guard let javaObject = jni.GetStaticObjectField(of: javaClass, id: id) else { - throw StaticFieldError.InvalidParameters + throw GetFieldError.InvalidParameters } return jni.GetString(from: javaObject as JavaString) } @@ -104,4 +117,11 @@ extension String: JavaParameterConvertible { let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) return jni.GetString(from: jObject) } + + public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> String { + guard let javaStringObject = jni.GetObjectField(of: javaObject, id: id) else { + throw GetFieldError.InvalidParameters + } + return jni.GetString(from: javaStringObject) + } } diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 0e8ada1..25607e6 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -164,6 +164,28 @@ extension JNI { // MARK: Fields + public func GetBooleanField(of javaObject: JavaObject, id: jfieldID) -> JavaBoolean { + let _env = self._env + return _env.pointee.pointee.GetBooleanField(_env, javaObject, id) + } + + public func GetIntField(of javaObject: JavaObject, id: jfieldID) -> JavaInt { + let _env = self._env + return _env.pointee.pointee.GetIntField(_env, javaObject, id) + } + + public func GetDoubleField(of javaObject: JavaObject, id: jfieldID) -> JavaDouble { + let _env = self._env + return _env.pointee.pointee.GetDoubleField(_env, javaObject, id) + } + + public func GetObjectField(of javaObject: JavaObject, id: jfieldID) -> JavaObject? { + let _env = self._env + return _env.pointee.pointee.GetObjectField(_env, javaObject, id) + } + + // MARK: Static Fields + public func GetStaticBooleanField(of javaClass: JavaClass, id: jfieldID) -> JavaBoolean { let _env = self._env return _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) @@ -278,6 +300,17 @@ extension JNI { return strings } + + public func GetObjectArrayElement(in array: JavaObjectArray, at index: Int) throws -> JavaObject { + let _env = self._env + let count = jni.GetLength(array) + if (index >= count) { + throw JNIError() + } + let jObj = _env.pointee.pointee.GetObjectArrayElement(_env, array, jsize(index))! + try checkAndThrowOnJNIError() + return jObj + } } func checkAndThrowOnJNIError() throws { From d34ec93f41c538541d77ab1ac0434d70b2c740cd Mon Sep 17 00:00:00 2001 From: rikner Date: Thu, 10 Aug 2017 17:01:15 +0200 Subject: [PATCH 32/84] add fromStaticField to Double --- Sources/JNI/JavaParameterConvertible.swift | 4 ++++ Sources/JNI/SwiftJNI.swift | 7 ++++++- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index bfc6c61..2e5638e 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -66,6 +66,10 @@ extension Double: JavaParameterConvertible { return JavaParameter(double: JavaDouble(self)) } + public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Double { + return Double(jni.GetStaticDoubleField(of: javaClass, id: id)) + } + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Double { return try jni.CallDoubleMethod(methodID, on: object, parameters: args) } diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 27aec1c..3ac401e 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -172,6 +172,11 @@ extension JNI { return _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) } + public func GetStaticDoubleField(of javaClass: JavaClass, id: jfieldID) -> JavaDouble { + let _env = self._env + return _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) + } + public func GetStaticObjectField(of javaClass: JavaClass, id: jfieldID) -> JavaObject? { let _env = self._env return _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) @@ -202,7 +207,7 @@ extension JNI { var result = [JavaByte](repeating: 0, count: count) _env.pointee.pointee.GetByteArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) - return result.map { UInt8($0) } + return result.map { UInt8(bitPattern: $0) } // may not have the same numeric value, but } public func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: [Int]) { From 572cfb23779ee9afac85e68efe96a6b40b6fdb62 Mon Sep 17 00:00:00 2001 From: rikner Date: Thu, 10 Aug 2017 17:47:30 +0200 Subject: [PATCH 33/84] use bitPattern to construct UInt8 from JavaByte --- Sources/JNI/SwiftJNI.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 25607e6..0286ac3 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -231,7 +231,7 @@ extension JNI { var result = [JavaByte](repeating: 0, count: count) _env.pointee.pointee.GetByteArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) - return result.map { UInt8($0) } + return result.map { UInt8(bitPattern: $0) } } public func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: [Int]) { From ba97ba3dde8685da7fe451f178d4661daf52bcb1 Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 11 Aug 2017 10:44:57 +0200 Subject: [PATCH 34/84] GetStaticField methods throw, use JNI_TRUE --- Sources/JNI/JavaParameterConvertible.swift | 14 ++++++------- Sources/JNI/SwiftJNI.swift | 24 ++++++++++++++-------- 2 files changed, 23 insertions(+), 15 deletions(-) diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 2e5638e..2fcc50c 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -25,7 +25,7 @@ extension Bool: JavaParameterConvertible { } public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Bool { - return jni.GetStaticBooleanField(of: javaClass, id: id) == 1 + return try jni.GetStaticBooleanField(of: javaClass, id: id) == JNI_TRUE } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Bool { @@ -45,7 +45,8 @@ extension Int: JavaParameterConvertible { } public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Int { - return Int(jni.GetStaticIntField(of: javaClass, id: id)) + let result = try jni.GetStaticIntField(of: javaClass, id: id) + return Int(result) } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Int { @@ -67,7 +68,8 @@ extension Double: JavaParameterConvertible { } public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Double { - return Double(jni.GetStaticDoubleField(of: javaClass, id: id)) + let result = try jni.GetStaticDoubleField(of: javaClass, id: id) + return Double(result) } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Double { @@ -89,10 +91,8 @@ extension String: JavaParameterConvertible { } public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> String { - guard let javaObject = jni.GetStaticObjectField(of: javaClass, id: id) else { - throw StaticFieldError.InvalidParameters - } - return jni.GetString(from: javaObject as JavaString) + let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: id) + return jni.GetString(from: jobject) } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> String { diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 3ac401e..4ad4c9b 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -162,24 +162,32 @@ extension JNI { // MARK: Fields - public func GetStaticBooleanField(of javaClass: JavaClass, id: jfieldID) -> JavaBoolean { + public func GetStaticBooleanField(of javaClass: JavaClass, id: jfieldID) throws -> JavaBoolean { let _env = self._env - return _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) + let result = _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result } - public func GetStaticIntField(of javaClass: JavaClass, id: jfieldID) -> JavaInt { + public func GetStaticIntField(of javaClass: JavaClass, id: jfieldID) throws -> JavaInt { let _env = self._env - return _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) + let result = _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result } - public func GetStaticDoubleField(of javaClass: JavaClass, id: jfieldID) -> JavaDouble { + public func GetStaticDoubleField(of javaClass: JavaClass, id: jfieldID) throws -> JavaDouble { let _env = self._env - return _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) + let result = _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result } - public func GetStaticObjectField(of javaClass: JavaClass, id: jfieldID) -> JavaObject? { + public func GetStaticObjectField(of javaClass: JavaClass, id: jfieldID) throws -> JavaObject { let _env = self._env - return _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) + guard let result = _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) else { throw JNIError() } + try checkAndThrowOnJNIError() + return result } // MARK: Arrays From abe8af8c5c2a94f47f2161ea0518524e82f9a3b1 Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 11 Aug 2017 10:56:32 +0200 Subject: [PATCH 35/84] replace StaticFieldError.InvalidParameters with FieldIDNotFound --- Sources/JNI/JNIFields.swift | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index 7fdfcb5..adddcbd 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -7,15 +7,13 @@ import CJNI -enum StaticFieldError: Error { - case InvalidParameters -} +struct FieldIDNotFound: Error {} public extension JNI { public func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { let env = self._env guard let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) else { - throw StaticFieldError.InvalidParameters + throw FieldIDNotFound() } return try T.fromStaticField(of: javaClass, id: fieldID) } From 7388d548045c708f4a60b427962b145f3695d4be Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 11 Aug 2017 11:12:37 +0200 Subject: [PATCH 36/84] cleanup not used error; change message of assertionFailure in JavaObject.init --- Sources/JNI/JNIMethods.swift | 1 - Sources/JNI/JNIObjects.swift | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 25b4c94..3661719 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -1,7 +1,6 @@ import CJNI struct InvalidMethodID: Error {} -struct ClassForObjectNotFound: Error {} extension JNI { // MARK: Static Methods diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 9ad3af2..3aa095a 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -25,7 +25,7 @@ open class JNIObject { let instanceLocalRef = try? jni.callConstructor(on: javaClass, arguments: arguments), let instance = jni.NewGlobalRef(instanceLocalRef) else { - assertionFailure("Couldn't call constructor of \(className)") + assertionFailure("Error during call to constructor of \(className)") return nil } From 156fb782abbcf79f2792b7e0eb88b9eef647bb12 Mon Sep 17 00:00:00 2001 From: rikner Date: Sat, 19 Aug 2017 16:21:52 +0200 Subject: [PATCH 37/84] Merge branch 'devel' into GetField --- Sources/JNI/JNIFields.swift | 8 +++----- Sources/JNI/JNIMethods.swift | 1 - Sources/JNI/JNIObjects.swift | 2 +- Sources/JNI/JavaParameterConvertible.swift | 16 +++++++-------- Sources/JNI/SwiftJNI.swift | 24 ++++++++++++++-------- 5 files changed, 28 insertions(+), 23 deletions(-) diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index c52b420..8b18be6 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -7,15 +7,13 @@ import CJNI -enum GetFieldError: Error { - case InvalidParameters -} +struct FieldIDNotFound: Error {} public extension JNI { public func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { let env = self._env guard let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) else { - throw GetFieldError.InvalidParameters + throw FieldIDNotFound() } return try T.fromStaticField(of: javaClass, id: fieldID) } @@ -24,7 +22,7 @@ public extension JNI { let env = self._env guard let javaClass = GetObjectClass(obj: javaObject), let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) else { - throw GetFieldError.InvalidParameters + throw FieldIDNotFound() } return try T.fromField(of: javaObject, id: fieldID) } diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 25b4c94..3661719 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -1,7 +1,6 @@ import CJNI struct InvalidMethodID: Error {} -struct ClassForObjectNotFound: Error {} extension JNI { // MARK: Static Methods diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 9ad3af2..3aa095a 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -25,7 +25,7 @@ open class JNIObject { let instanceLocalRef = try? jni.callConstructor(on: javaClass, arguments: arguments), let instance = jni.NewGlobalRef(instanceLocalRef) else { - assertionFailure("Couldn't call constructor of \(className)") + assertionFailure("Error during call to constructor of \(className)") return nil } diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 020afee..570d627 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -26,7 +26,7 @@ extension Bool: JavaParameterConvertible { } public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Bool { - return jni.GetStaticBooleanField(of: javaClass, id: id) == 1 + return try jni.GetStaticBooleanField(of: javaClass, id: id) == JNI_TRUE } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Bool { @@ -50,7 +50,8 @@ extension Int: JavaParameterConvertible { } public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Int { - return Int(jni.GetStaticIntField(of: javaClass, id: id)) + let result = try jni.GetStaticIntField(of: javaClass, id: id) + return Int(result) } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Int { @@ -76,7 +77,8 @@ extension Double: JavaParameterConvertible { } public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Double { - return Double(jni.GetStaticDoubleField(of: javaClass, id: id)) + let result = try jni.GetStaticDoubleField(of: javaClass, id: id) + return Double(result) } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Double { @@ -102,10 +104,8 @@ extension String: JavaParameterConvertible { } public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> String { - guard let javaObject = jni.GetStaticObjectField(of: javaClass, id: id) else { - throw GetFieldError.InvalidParameters - } - return jni.GetString(from: javaObject as JavaString) + let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: id) + return jni.GetString(from: jobject) } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> String { @@ -120,7 +120,7 @@ extension String: JavaParameterConvertible { public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> String { guard let javaStringObject = jni.GetObjectField(of: javaObject, id: id) else { - throw GetFieldError.InvalidParameters + throw FieldIDNotFound() } return jni.GetString(from: javaStringObject) } diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 0286ac3..3781126 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -186,24 +186,32 @@ extension JNI { // MARK: Static Fields - public func GetStaticBooleanField(of javaClass: JavaClass, id: jfieldID) -> JavaBoolean { + public func GetStaticBooleanField(of javaClass: JavaClass, id: jfieldID) throws -> JavaBoolean { let _env = self._env - return _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) + let result = _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result } - public func GetStaticIntField(of javaClass: JavaClass, id: jfieldID) -> JavaInt { + public func GetStaticIntField(of javaClass: JavaClass, id: jfieldID) throws -> JavaInt { let _env = self._env - return _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) + let result = _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result } - public func GetStaticDoubleField(of javaClass: JavaClass, id: jfieldID) -> JavaDouble { + public func GetStaticDoubleField(of javaClass: JavaClass, id: jfieldID) throws -> JavaDouble { let _env = self._env - return _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) + let result = _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result } - public func GetStaticObjectField(of javaClass: JavaClass, id: jfieldID) -> JavaObject? { + public func GetStaticObjectField(of javaClass: JavaClass, id: jfieldID) throws -> JavaObject { let _env = self._env - return _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) + guard let result = _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) else { throw JNIError() } + try checkAndThrowOnJNIError() + return result } // MARK: Arrays From 1b58781ac72494e152c0baa165e8e9a180e6df9c Mon Sep 17 00:00:00 2001 From: rikner Date: Sun, 20 Aug 2017 21:27:50 +0200 Subject: [PATCH 38/84] JNIObject init throws --- Sources/JNI/JNIObjects.swift | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 3aa095a..3556dec 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,6 +1,8 @@ import CJNI struct CreateNewObjectForConstructorError: Error {} +struct ClassNotFound: Error {} +struct ConstructorError: Error {} /// Designed to simplify calling a constructor and methods on a JavaClass /// Subclass this and add the methods appropriate to the object you are constructing. @@ -8,7 +10,7 @@ open class JNIObject { public let javaClass: JavaClass public let instance: JavaObject - public init?(_ className: String, arguments: [JavaParameterConvertible] = []) { + public init(_ className: String, arguments: [JavaParameterConvertible] = []) throws { let className = className.replacingFullstopsWithSlashes() guard @@ -16,7 +18,7 @@ open class JNIObject { let javaClass = jni.NewGlobalRef(javaClassLocalRef) else { assertionFailure("Couldn't find class named \(className)") - return nil + throw ClassNotFound() } self.javaClass = javaClass @@ -26,7 +28,7 @@ open class JNIObject { let instance = jni.NewGlobalRef(instanceLocalRef) else { assertionFailure("Error during call to constructor of \(className)") - return nil + throw ConstructorError() } self.instance = instance From e97246e7cf8d6480bea74533bd2e40df76a9e6b5 Mon Sep 17 00:00:00 2001 From: Christian Haug Date: Tue, 22 Aug 2017 16:03:32 +0200 Subject: [PATCH 39/84] Delete local objectClass ref in GetMethodID for object --- Sources/JNI/SwiftJNI.swift | 1 + 1 file changed, 1 insertion(+) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 4ad4c9b..4d3edd8 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -57,6 +57,7 @@ extension JNI { try checkAndThrowOnJNIError() let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) + _env.pointee.pointee.DeleteLocalRef(_env, objectClass) try checkAndThrowOnJNIError() return result! From 2babba9b315ce425858228858334ed4067553c2d Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 25 Aug 2017 11:30:55 +0200 Subject: [PATCH 40/84] implement Feedback --- Sources/JNI/JNIFields.swift | 18 ++++----- Sources/JNI/JNIObjects.swift | 22 +++++------ Sources/JNI/JavaParameterConvertible.swift | 13 +++---- Sources/JNI/SwiftJNI.swift | 44 ++++++++++++---------- 4 files changed, 46 insertions(+), 51 deletions(-) diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index 8b18be6..dda0f27 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -7,23 +7,19 @@ import CJNI -struct FieldIDNotFound: Error {} - public extension JNI { public func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { let env = self._env - guard let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) else { - throw FieldIDNotFound() - } - return try T.fromStaticField(of: javaClass, id: fieldID) + let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) + try checkAndThrowOnJNIError() + return try T.fromStaticField(of: javaClass, id: fieldID!) } public func GetField(_ fieldName: String, from javaObject: JavaObject) throws -> T { let env = self._env - guard let javaClass = GetObjectClass(obj: javaObject), - let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) else { - throw FieldIDNotFound() - } - return try T.fromField(of: javaObject, id: fieldID) + let javaClass = try GetObjectClass(obj: javaObject) + let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) + try checkAndThrowOnJNIError() + return try T.fromField(of: javaObject, id: fieldID!) } } diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 3556dec..a74106e 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,7 +1,6 @@ import CJNI struct CreateNewObjectForConstructorError: Error {} -struct ClassNotFound: Error {} struct ConstructorError: Error {} /// Designed to simplify calling a constructor and methods on a JavaClass @@ -13,18 +12,16 @@ open class JNIObject { public init(_ className: String, arguments: [JavaParameterConvertible] = []) throws { let className = className.replacingFullstopsWithSlashes() - guard - let javaClassLocalRef = jni.FindClass(name: className), - let javaClass = jni.NewGlobalRef(javaClassLocalRef) - else { - assertionFailure("Couldn't find class named \(className)") - throw ClassNotFound() - } + let javaClassLocalRef = jni.FindClass(name: className) + try checkAndThrowOnJNIError() - self.javaClass = javaClass + let javaClass = jni.NewGlobalRef(javaClassLocalRef!) + try checkAndThrowOnJNIError() + + self.javaClass = javaClass! guard - let instanceLocalRef = try? jni.callConstructor(on: javaClass, arguments: arguments), + let instanceLocalRef = try? jni.callConstructor(on: self.javaClass, arguments: arguments), let instance = jni.NewGlobalRef(instanceLocalRef) else { assertionFailure("Error during call to constructor of \(className)") @@ -72,10 +69,11 @@ public extension JNI { return newObject } - public func GetObjectClass(obj: JavaObject) -> JavaClass? { + public func GetObjectClass(obj: JavaObject) throws -> JavaClass { let env = self._env let result = env.pointee.pointee.GetObjectClass(env, obj) - return (result != nil) ? result : .none + try checkAndThrowOnJNIError() + return result! } } diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 570d627..3a793fd 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -38,7 +38,7 @@ extension Bool: JavaParameterConvertible { } public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Bool { - return jni.GetBooleanField(of: javaObject, id: id) == 1 + return try jni.GetBooleanField(of: javaObject, id: id) == JNI_TRUE } } @@ -65,7 +65,7 @@ extension Int: JavaParameterConvertible { } public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Int { - return Int(jni.GetIntField(of: javaObject, id: id)) + return try Int(jni.GetIntField(of: javaObject, id: id)) } } @@ -77,8 +77,7 @@ extension Double: JavaParameterConvertible { } public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Double { - let result = try jni.GetStaticDoubleField(of: javaClass, id: id) - return Double(result) + return try Double(jni.GetStaticDoubleField(of: javaClass, id: id)) } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Double { @@ -90,7 +89,7 @@ extension Double: JavaParameterConvertible { } public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Double { - return Double(jni.GetDoubleField(of: javaObject, id: id)) + return try jni.GetDoubleField(of: javaObject, id: id) } } @@ -119,9 +118,7 @@ extension String: JavaParameterConvertible { } public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> String { - guard let javaStringObject = jni.GetObjectField(of: javaObject, id: id) else { - throw FieldIDNotFound() - } + let javaStringObject = try jni.GetObjectField(of: javaObject, id: id) return jni.GetString(from: javaStringObject) } } diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index bde9f48..056f014 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -56,12 +56,10 @@ extension JNI { let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) try checkAndThrowOnJNIError() - guard let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) else { - throw InvalidMethodID() - } - + let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) try checkAndThrowOnJNIError() - return result + + return result! } public func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID { @@ -164,24 +162,32 @@ extension JNI { // MARK: Fields - public func GetBooleanField(of javaObject: JavaObject, id: jfieldID) -> JavaBoolean { + public func GetBooleanField(of javaObject: JavaObject, id: jfieldID) throws -> JavaBoolean { let _env = self._env - return _env.pointee.pointee.GetBooleanField(_env, javaObject, id) + let result = _env.pointee.pointee.GetBooleanField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result } - public func GetIntField(of javaObject: JavaObject, id: jfieldID) -> JavaInt { + public func GetIntField(of javaObject: JavaObject, id: jfieldID) throws -> JavaInt { let _env = self._env - return _env.pointee.pointee.GetIntField(_env, javaObject, id) + let result = _env.pointee.pointee.GetIntField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result } - public func GetDoubleField(of javaObject: JavaObject, id: jfieldID) -> JavaDouble { + public func GetDoubleField(of javaObject: JavaObject, id: jfieldID) throws -> JavaDouble { let _env = self._env - return _env.pointee.pointee.GetDoubleField(_env, javaObject, id) + let result = _env.pointee.pointee.GetDoubleField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result } - public func GetObjectField(of javaObject: JavaObject, id: jfieldID) -> JavaObject? { + public func GetObjectField(of javaObject: JavaObject, id: jfieldID) throws -> JavaObject { let _env = self._env - return _env.pointee.pointee.GetObjectField(_env, javaObject, id) + let result = _env.pointee.pointee.GetObjectField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result! } // MARK: Static Fields @@ -315,9 +321,9 @@ extension JNI { if (index >= count) { throw JNIError() } - let jObj = _env.pointee.pointee.GetObjectArrayElement(_env, array, jsize(index))! + let jObj = _env.pointee.pointee.GetObjectArrayElement(_env, array, jsize(index)) try checkAndThrowOnJNIError() - return jObj + return jObj! } } @@ -381,7 +387,7 @@ public struct JavaCallback { - parameters: Any number of JavaParameters (*must have the same number and type as the* `methodSignature` *you're trying to call*) - Throws: `JavaCallback.Error` */ - public init (_ globalJobj: JavaObject, methodName: String, methodSignature: String) { + public init (_ globalJobj: JavaObject, methodName: String, methodSignature: String) throws { // At the moment we can only call Void methods, fail if user tries to return something else guard let returnType = methodSignature.characters.last, returnType == "V"/*oid*/ else { // LOG JavaMethodCallError.IncorrectMethodSignature @@ -393,10 +399,8 @@ public struct JavaCallback { // Doesn't work with more complex object types, arrays etc. we should determine the signature based on parameters. // TODO: Check methodSignature here and determine expectedParameterCount - - guard - let javaClass = jni.GetObjectClass(obj: globalJobj), - let methodID = try? jni.GetMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) + let javaClass = try jni.GetObjectClass(obj: globalJobj) + guard let methodID = try? jni.GetMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) else { // XXX: We should throw here and keep throwing til it gets back to Java fatalError("Failed to make JavaCallback") From 1acd061c2c9154d39ef826717d17154b93276be2 Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 25 Aug 2017 11:51:18 +0200 Subject: [PATCH 41/84] correct order of parameters for fromField() --- Sources/JNI/JNIFields.swift | 2 +- Sources/JNI/JavaParameterConvertible.swift | 18 +++++++++--------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index dda0f27..ad90bc4 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -20,6 +20,6 @@ public extension JNI { let javaClass = try GetObjectClass(obj: javaObject) let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) try checkAndThrowOnJNIError() - return try T.fromField(of: javaObject, id: fieldID!) + return try T.fromField(fieldID!, on: javaObject) } } diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 3a793fd..528c98b 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -15,7 +15,7 @@ public protocol JavaParameterConvertible { static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Self static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Self - static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Self + static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> Self } extension Bool: JavaParameterConvertible { @@ -37,8 +37,8 @@ extension Bool: JavaParameterConvertible { return try jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == JNI_TRUE } - public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Bool { - return try jni.GetBooleanField(of: javaObject, id: id) == JNI_TRUE + public static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> Bool { + return try jni.GetBooleanField(of: javaObject, id: fieldID) == JNI_TRUE } } @@ -64,8 +64,8 @@ extension Int: JavaParameterConvertible { return Int(result) } - public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Int { - return try Int(jni.GetIntField(of: javaObject, id: id)) + public static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> Int { + return try Int(jni.GetIntField(of: javaObject, id: fieldID)) } } @@ -88,8 +88,8 @@ extension Double: JavaParameterConvertible { return try jni.CallStaticDoubleMethod(methodID, on: javaClass, parameters: args) } - public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> Double { - return try jni.GetDoubleField(of: javaObject, id: id) + public static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> Double { + return try jni.GetDoubleField(of: javaObject, id: fieldID) } } @@ -117,8 +117,8 @@ extension String: JavaParameterConvertible { return jni.GetString(from: jObject) } - public static func fromField(of javaObject: JavaObject, id: jfieldID) throws -> String { - let javaStringObject = try jni.GetObjectField(of: javaObject, id: id) + public static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> String { + let javaStringObject = try jni.GetObjectField(of: javaObject, id: fieldID) return jni.GetString(from: javaStringObject) } } From c1f7009403df5bd632e43edaaef9b58e1118c0e9 Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 25 Aug 2017 11:55:01 +0200 Subject: [PATCH 42/84] correct order of parameters for fromStaticField --- Sources/JNI/JNIFields.swift | 2 +- Sources/JNI/JavaParameterConvertible.swift | 18 +++++++++--------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index ad90bc4..79e2b95 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -12,7 +12,7 @@ public extension JNI { let env = self._env let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) try checkAndThrowOnJNIError() - return try T.fromStaticField(of: javaClass, id: fieldID!) + return try T.fromStaticField(fieldID!, of: javaClass) } public func GetField(_ fieldName: String, from javaObject: JavaObject) throws -> T { diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 528c98b..3d03862 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -14,7 +14,7 @@ public protocol JavaParameterConvertible { static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Self static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self - static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Self + static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> Self static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> Self } @@ -25,8 +25,8 @@ extension Bool: JavaParameterConvertible { return JavaParameter(bool: (self) ? 1 : 0) } - public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Bool { - return try jni.GetStaticBooleanField(of: javaClass, id: id) == JNI_TRUE + public static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> Bool { + return try jni.GetStaticBooleanField(of: javaClass, id: fieldID) == JNI_TRUE } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Bool { @@ -49,8 +49,8 @@ extension Int: JavaParameterConvertible { return JavaParameter(int: JavaInt(self)) } - public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Int { - let result = try jni.GetStaticIntField(of: javaClass, id: id) + public static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> Int { + let result = try jni.GetStaticIntField(of: javaClass, id: fieldID) return Int(result) } @@ -76,8 +76,8 @@ extension Double: JavaParameterConvertible { return JavaParameter(double: JavaDouble(self)) } - public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> Double { - return try Double(jni.GetStaticDoubleField(of: javaClass, id: id)) + public static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> Double { + return try Double(jni.GetStaticDoubleField(of: javaClass, id: fieldID)) } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Double { @@ -102,8 +102,8 @@ extension String: JavaParameterConvertible { return JavaParameter(object: stringAsObject) } - public static func fromStaticField(of javaClass: JavaClass, id: jfieldID) throws -> String { - let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: id) + public static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> String { + let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: fieldID) return jni.GetString(from: jobject) } From 1d2e7821e3a4dccaeaafb75ff0fa8104125bfe69 Mon Sep 17 00:00:00 2001 From: Erik Date: Fri, 25 Aug 2017 12:27:33 +0200 Subject: [PATCH 43/84] rename jfieldID to JavaFieldID (#8) --- Sources/CJNI/include/jni.h | 2 +- Sources/JNI/JNIClassManipulation.swift | 4 ++-- Sources/JNI/JavaParameterConvertible.swift | 20 ++++++++++---------- Sources/JNI/SwiftJNI.swift | 16 ++++++++-------- 4 files changed, 21 insertions(+), 21 deletions(-) diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index 8390d1d..cdf2211 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -144,7 +144,7 @@ typedef jobject jweak CF_SWIFT_NAME(JavaWeakReference); #endif /* not __cplusplus */ struct _jfieldID; /* opaque structure */ -typedef struct _jfieldID * _Nullable jfieldID; /* field IDs */ +typedef struct _jfieldID * _Nullable jfieldID CF_SWIFT_NAME(JavaFieldID); /* field IDs */ struct _jmethodID; /* opaque structure */ typedef struct _jmethodID * _Nullable jmethodID CF_SWIFT_NAME(JavaMethodID); /* method IDs */ diff --git a/Sources/JNI/JNIClassManipulation.swift b/Sources/JNI/JNIClassManipulation.swift index e6bba2d..fbff1ea 100644 --- a/Sources/JNI/JNIClassManipulation.swift +++ b/Sources/JNI/JNIClassManipulation.swift @@ -16,7 +16,7 @@ public extension JNI { return env.pointee.pointee.FromReflectedMethod(env, method)! } - public func FromReflectedField(field: JavaObject) -> jfieldID { + public func FromReflectedField(field: JavaObject) -> JavaFieldID { let env = self._env return env.pointee.pointee.FromReflectedField(env, field)! } @@ -36,7 +36,7 @@ public extension JNI { return env.pointee.pointee.IsAssignableFrom(env, classA, classB) } - public func ToReflectedField(targetClass: JavaClass, _ fieldID: jfieldID, _ isStatic: JavaBoolean) -> JavaObject { + public func ToReflectedField(targetClass: JavaClass, _ fieldID: JavaFieldID, _ isStatic: JavaBoolean) -> JavaObject { let env = self._env return env.pointee.pointee.ToReflectedField(env, targetClass, fieldID, isStatic)! } diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 3d03862..380d743 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -14,8 +14,8 @@ public protocol JavaParameterConvertible { static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Self static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self - static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> Self - static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> Self + static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Self + static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Self } extension Bool: JavaParameterConvertible { @@ -25,7 +25,7 @@ extension Bool: JavaParameterConvertible { return JavaParameter(bool: (self) ? 1 : 0) } - public static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> Bool { + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Bool { return try jni.GetStaticBooleanField(of: javaClass, id: fieldID) == JNI_TRUE } @@ -37,7 +37,7 @@ extension Bool: JavaParameterConvertible { return try jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == JNI_TRUE } - public static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> Bool { + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Bool { return try jni.GetBooleanField(of: javaObject, id: fieldID) == JNI_TRUE } } @@ -49,7 +49,7 @@ extension Int: JavaParameterConvertible { return JavaParameter(int: JavaInt(self)) } - public static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> Int { + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Int { let result = try jni.GetStaticIntField(of: javaClass, id: fieldID) return Int(result) } @@ -64,7 +64,7 @@ extension Int: JavaParameterConvertible { return Int(result) } - public static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> Int { + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Int { return try Int(jni.GetIntField(of: javaObject, id: fieldID)) } } @@ -76,7 +76,7 @@ extension Double: JavaParameterConvertible { return JavaParameter(double: JavaDouble(self)) } - public static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> Double { + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Double { return try Double(jni.GetStaticDoubleField(of: javaClass, id: fieldID)) } @@ -88,7 +88,7 @@ extension Double: JavaParameterConvertible { return try jni.CallStaticDoubleMethod(methodID, on: javaClass, parameters: args) } - public static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> Double { + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Double { return try jni.GetDoubleField(of: javaObject, id: fieldID) } } @@ -102,7 +102,7 @@ extension String: JavaParameterConvertible { return JavaParameter(object: stringAsObject) } - public static func fromStaticField(_ fieldID: jfieldID, of javaClass: JavaClass) throws -> String { + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> String { let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: fieldID) return jni.GetString(from: jobject) } @@ -117,7 +117,7 @@ extension String: JavaParameterConvertible { return jni.GetString(from: jObject) } - public static func fromField(_ fieldID: jfieldID, on javaObject: JavaObject) throws -> String { + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> String { let javaStringObject = try jni.GetObjectField(of: javaObject, id: fieldID) return jni.GetString(from: javaStringObject) } diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 056f014..daba851 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -162,28 +162,28 @@ extension JNI { // MARK: Fields - public func GetBooleanField(of javaObject: JavaObject, id: jfieldID) throws -> JavaBoolean { + public func GetBooleanField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaBoolean { let _env = self._env let result = _env.pointee.pointee.GetBooleanField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } - public func GetIntField(of javaObject: JavaObject, id: jfieldID) throws -> JavaInt { + public func GetIntField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaInt { let _env = self._env let result = _env.pointee.pointee.GetIntField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } - public func GetDoubleField(of javaObject: JavaObject, id: jfieldID) throws -> JavaDouble { + public func GetDoubleField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaDouble { let _env = self._env let result = _env.pointee.pointee.GetDoubleField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } - public func GetObjectField(of javaObject: JavaObject, id: jfieldID) throws -> JavaObject { + public func GetObjectField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaObject { let _env = self._env let result = _env.pointee.pointee.GetObjectField(_env, javaObject, id) try checkAndThrowOnJNIError() @@ -192,28 +192,28 @@ extension JNI { // MARK: Static Fields - public func GetStaticBooleanField(of javaClass: JavaClass, id: jfieldID) throws -> JavaBoolean { + public func GetStaticBooleanField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaBoolean { let _env = self._env let result = _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } - public func GetStaticIntField(of javaClass: JavaClass, id: jfieldID) throws -> JavaInt { + public func GetStaticIntField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaInt { let _env = self._env let result = _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } - public func GetStaticDoubleField(of javaClass: JavaClass, id: jfieldID) throws -> JavaDouble { + public func GetStaticDoubleField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaDouble { let _env = self._env let result = _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } - public func GetStaticObjectField(of javaClass: JavaClass, id: jfieldID) throws -> JavaObject { + public func GetStaticObjectField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaObject { let _env = self._env guard let result = _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) else { throw JNIError() } try checkAndThrowOnJNIError() From 548d23b631c22710c3065ebe2c3f50c8762bcd83 Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 25 Aug 2017 13:37:54 +0200 Subject: [PATCH 44/84] FindClass throws --- Sources/JNI/JNIClassManipulation.swift | 6 ++++-- Sources/JNI/JNIObjects.swift | 5 ++--- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/Sources/JNI/JNIClassManipulation.swift b/Sources/JNI/JNIClassManipulation.swift index fbff1ea..4eb36b2 100644 --- a/Sources/JNI/JNIClassManipulation.swift +++ b/Sources/JNI/JNIClassManipulation.swift @@ -6,9 +6,11 @@ public extension JNI { // return env.pointee.pointee.DefineClass(env, name, loader, buffer, bufferLength)! // } - public func FindClass(name: String) -> JavaClass? { + public func FindClass(name: String) throws -> JavaClass { let env = self._env - return env.pointee.pointee.FindClass(env, name) + let result = env.pointee.pointee.FindClass(env, name) + try checkAndThrowOnJNIError() + return result! } public func FromReflectedMethod(method: JavaObject) -> JavaMethodID { diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index a74106e..69b3ae0 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -12,10 +12,9 @@ open class JNIObject { public init(_ className: String, arguments: [JavaParameterConvertible] = []) throws { let className = className.replacingFullstopsWithSlashes() - let javaClassLocalRef = jni.FindClass(name: className) - try checkAndThrowOnJNIError() + let javaClassLocalRef = try jni.FindClass(name: className) - let javaClass = jni.NewGlobalRef(javaClassLocalRef!) + let javaClass = jni.NewGlobalRef(javaClassLocalRef) try checkAndThrowOnJNIError() self.javaClass = javaClass! From 60ed9cbef29a2d29493fb68aa16ac7f84154cd32 Mon Sep 17 00:00:00 2001 From: rikner Date: Tue, 19 Sep 2017 15:29:18 +0200 Subject: [PATCH 45/84] update comment about bitPattern constructor in GetByteArrayRegion --- Sources/JNI/SwiftJNI.swift | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index daba851..ec664f0 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -245,7 +245,10 @@ extension JNI { var result = [JavaByte](repeating: 0, count: count) _env.pointee.pointee.GetByteArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) - return result.map { UInt8(bitPattern: $0) } // numeric value may change here because of the bitPattern constructor + + // Conversion from Int8 (JavaByte) to UInt8: bitPattern-constructor ensures + // that negative Int8 values do not cause a crash when trying convert them to UInt8 + return result.map { UInt8(bitPattern: $0) } } public func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: [Int]) { From d4032fe3396a1a4e7995de67fd0527882a1f56ac Mon Sep 17 00:00:00 2001 From: rikner Date: Wed, 8 Nov 2017 12:58:51 +0100 Subject: [PATCH 46/84] check for threadStatus instead of threadStatus.bigEndian --- Sources/JNI/JNI.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/JNI/JNI.swift b/Sources/JNI/JNI.swift index 2b704c1..810d227 100644 --- a/Sources/JNI/JNI.swift +++ b/Sources/JNI/JNI.swift @@ -14,7 +14,7 @@ public class JNI { let threadStatus = jvm.GetEnv(_jvm, &_tmpPointer, JavaInt(JNI_VERSION_1_6)) var _env = _tmpPointer?.bindMemory(to: JNIEnv.self, capacity: 1) - switch threadStatus.bigEndian { + switch threadStatus { case JNI_OK: break // if we're already attached, do nothing case JNI_EDETACHED: // We weren't attached to the Java UI thread From ca6ba6fdb13b3c6bf78ef99b1c41c8c276676481 Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 24 Nov 2017 17:16:14 +0100 Subject: [PATCH 47/84] conform JavaObject to JavaParameterConvertible --- Sources/JNI/JavaParameterConvertible.swift | 24 ++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 380d743..5aee859 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -122,3 +122,27 @@ extension String: JavaParameterConvertible { return jni.GetString(from: javaStringObject) } } + +extension JavaObject: JavaParameterConvertible { + public static var asJNIParameterString: String { return "L" } + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(object: JavaObject(self)) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaObject { + return try jni.GetStaticObjectField(of: javaClass, id: fieldID) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> JavaObject { + return try jni.CallObjectMethod(methodID, on: object, parameters: args) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> JavaObject { + return try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> JavaObject { + return try jni.GetObjectField(of: javaObject, id: fieldID) + } +} From a19b3e202ee7dfc15830b41a5817a8ad19247ffe Mon Sep 17 00:00:00 2001 From: rikner Date: Mon, 27 Nov 2017 19:39:08 +0100 Subject: [PATCH 48/84] fix JavaObject.asJNIParameterString --- Sources/JNI/JavaParameterConvertible.swift | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 5aee859..12c4778 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -124,7 +124,8 @@ extension String: JavaParameterConvertible { } extension JavaObject: JavaParameterConvertible { - public static var asJNIParameterString: String { return "L" } + private static let javaClassname = "java/lang/Object" + public static var asJNIParameterString = "L\(javaClassname);" public func toJavaParameter() -> JavaParameter { return JavaParameter(object: JavaObject(self)) From 51125545f26b9d6e6e69dff4df32803cd4158ed8 Mon Sep 17 00:00:00 2001 From: rikner Date: Wed, 6 Dec 2017 13:21:02 +0100 Subject: [PATCH 49/84] asJNIParameterString always as let --- Sources/JNI/JavaParameterConvertible.swift | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 12c4778..ce40dec 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -19,7 +19,7 @@ public protocol JavaParameterConvertible { } extension Bool: JavaParameterConvertible { - public static var asJNIParameterString: String { return "Z" } + public static let asJNIParameterString = "Z" public func toJavaParameter() -> JavaParameter { return JavaParameter(bool: (self) ? 1 : 0) @@ -43,7 +43,7 @@ extension Bool: JavaParameterConvertible { } extension Int: JavaParameterConvertible { - public static var asJNIParameterString: String { return "I" } + public static var asJNIParameterString = "I" public func toJavaParameter() -> JavaParameter { return JavaParameter(int: JavaInt(self)) @@ -70,7 +70,7 @@ extension Int: JavaParameterConvertible { } extension Double: JavaParameterConvertible { - public static var asJNIParameterString: String { return "D" } + public static let asJNIParameterString = "D" public func toJavaParameter() -> JavaParameter { return JavaParameter(double: JavaDouble(self)) @@ -125,10 +125,10 @@ extension String: JavaParameterConvertible { extension JavaObject: JavaParameterConvertible { private static let javaClassname = "java/lang/Object" - public static var asJNIParameterString = "L\(javaClassname);" + public static let asJNIParameterString = "L\(javaClassname);" public func toJavaParameter() -> JavaParameter { - return JavaParameter(object: JavaObject(self)) + return JavaParameter(object: self) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaObject { From 574fe6a51e362d214a2a8927862ea5516dd3f49b Mon Sep 17 00:00:00 2001 From: Geordie J Date: Thu, 14 Dec 2017 17:56:45 +0100 Subject: [PATCH 50/84] Don't use deprecated Swift.String APIs --- .../JNI/Array+JavaParameterConvertible.swift | 4 +- Sources/JNI/JNIClassManipulation.swift | 2 +- Sources/JNI/SwiftJNI.swift | 160 +++++++++--------- 3 files changed, 83 insertions(+), 83 deletions(-) diff --git a/Sources/JNI/Array+JavaParameterConvertible.swift b/Sources/JNI/Array+JavaParameterConvertible.swift index 1e0318a..32e888e 100644 --- a/Sources/JNI/Array+JavaParameterConvertible.swift +++ b/Sources/JNI/Array+JavaParameterConvertible.swift @@ -9,8 +9,8 @@ import CJNI extension String { func replacingFullstopsWithSlashes() -> String { - let replacedCharacters = self.characters.map { ($0 == ".") ? "/" : $0 } - return String(String.CharacterView(replacedCharacters)) + let replacedCharacters = self.map { ($0 == ".") ? "/" : $0 } + return String(replacedCharacters) } } diff --git a/Sources/JNI/JNIClassManipulation.swift b/Sources/JNI/JNIClassManipulation.swift index 4eb36b2..32d1f93 100644 --- a/Sources/JNI/JNIClassManipulation.swift +++ b/Sources/JNI/JNIClassManipulation.swift @@ -8,7 +8,7 @@ public extension JNI { public func FindClass(name: String) throws -> JavaClass { let env = self._env - let result = env.pointee.pointee.FindClass(env, name) + let result = env.pointee.pointee.FindClass(env, name.replacingFullstopsWithSlashes()) try checkAndThrowOnJNIError() return result! } diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 4409a1b..eab822b 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -343,83 +343,83 @@ struct JNIError: Error { } } -/** - Allows a (Void) Java method to be called from Swift. Takes a global jobj (a class instance), a method name and its signature. The resulting callback can be called via javaCallback.call(param1, param2...), or javaCallback.apply([params]). Each param must be a JavaParameter. - - Needs more error checking and handling. The basis is there, but from memory I had issues with either the optional or the throwing on Android. -*/ -public struct JavaCallback { - private let jobj: JavaObject // must be a JNI Global Reference - private let methodID: JavaMethodID - - // Eventually we should check how many parameters are required by the method signature - // And also which return type is expected (to allow calling non-Void methods) - // For now this implementation remains unsafe - //let expectedParameterCount: Int - - /// Errors describing the various things that can go wrong when calling a Java method via JNI. - /// - __InvalidParameters__: One character per method parameter is required. For example, with a methodSignature of "(FF)V", you need to pass two floats as parameters. - /// - __InvalidMethod__: Couldn't get the requested method from the JavaObject provided (are you calling with the right JavaObject instance / calling on the correct class?) - /// - __IncorrectMethodSignature__: The JNI is separated into Java method calls to functions with various return types. So if you perform `callJavaMethod`, you need to accept the return value with the corresponding type. *XXX: currently only Void methods are implemented*. - - enum JavaError: Error { - case JNINotReady - case InvalidParameters - case IncorrectMethodSignature - case InvalidClass - case InvalidMethod - } - - /** - - Parameters: - - globalJobj: The class instance you want to perform the method on. Note this must be a jni GlobalRef, otherwise your callback will either crash or just silently not work. - - methodName: A `String` with the name of the Java method to call - - methodSignature: A `String` containing the method's exact signature. Although it is possible to call non-Void Java methods via the JNI, that is not yet implemented in the the current Swift binding. This means that, for now, `methodSignature` must end with `"V"` i.e., return `Void` - - **`"(F)V"`** would reference a method that accepts one Float and returns Void. - - **Z** boolean - - **B** byte - - **C** char - - **S** short - - **I** int - - **J** long - - **F** float - - **D** double - - **Lfully-qualified-class;** fully-qualified-class - - **[type** type[] - - **(arg-types)ret-type** method type - - e.g. **`"([I)V"`** would accept one array of Ints and return Void. - - parameters: Any number of JavaParameters (*must have the same number and type as the* `methodSignature` *you're trying to call*) - - Throws: `JavaCallback.Error` - */ - public init (_ globalJobj: JavaObject, methodName: String, methodSignature: String) throws { - // At the moment we can only call Void methods, fail if user tries to return something else - guard let returnType = methodSignature.characters.last, returnType == "V"/*oid*/ else { - // LOG JavaMethodCallError.IncorrectMethodSignature - fatalError("JavaMethodCallError.IncorrectMethodSignature") - } - - // With signature "(FF)V", parameters count should be 2, ignoring the two brackets and the V - // XXX: This test isn't robust, but it will prevent simple user errors - // Doesn't work with more complex object types, arrays etc. we should determine the signature based on parameters. - - // TODO: Check methodSignature here and determine expectedParameterCount - let javaClass = try jni.GetObjectClass(obj: globalJobj) - guard let methodID = try? jni.GetMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) - else { - // XXX: We should throw here and keep throwing til it gets back to Java - fatalError("Failed to make JavaCallback") - } - - self.jobj = globalJobj - self.methodID = methodID - } - - public func apply(args: [JavaParameter]) { - try? jni.CallVoidMethod(methodID, on: jobj, parameters: args) - } - - /// Send variadic parameters to the func that takes an array - public func call(args: JavaParameter...) { - self.apply(args: args) - } -} +// /** +// Allows a (Void) Java method to be called from Swift. Takes a global jobj (a class instance), a method name and its signature. The resulting callback can be called via javaCallback.call(param1, param2...), or javaCallback.apply([params]). Each param must be a JavaParameter. + +// Needs more error checking and handling. The basis is there, but from memory I had issues with either the optional or the throwing on Android. +// */ +// public struct JavaCallback { +// private let jobj: JavaObject // must be a JNI Global Reference +// private let methodID: JavaMethodID + +// // Eventually we should check how many parameters are required by the method signature +// // And also which return type is expected (to allow calling non-Void methods) +// // For now this implementation remains unsafe +// //let expectedParameterCount: Int + +// /// Errors describing the various things that can go wrong when calling a Java method via JNI. +// /// - __InvalidParameters__: One character per method parameter is required. For example, with a methodSignature of "(FF)V", you need to pass two floats as parameters. +// /// - __InvalidMethod__: Couldn't get the requested method from the JavaObject provided (are you calling with the right JavaObject instance / calling on the correct class?) +// /// - __IncorrectMethodSignature__: The JNI is separated into Java method calls to functions with various return types. So if you perform `callJavaMethod`, you need to accept the return value with the corresponding type. *XXX: currently only Void methods are implemented*. + +// enum JavaError: Error { +// case JNINotReady +// case InvalidParameters +// case IncorrectMethodSignature +// case InvalidClass +// case InvalidMethod +// } + +// * +// - Parameters: +// - globalJobj: The class instance you want to perform the method on. Note this must be a jni GlobalRef, otherwise your callback will either crash or just silently not work. +// - methodName: A `String` with the name of the Java method to call +// - methodSignature: A `String` containing the method's exact signature. Although it is possible to call non-Void Java methods via the JNI, that is not yet implemented in the the current Swift binding. This means that, for now, `methodSignature` must end with `"V"` i.e., return `Void` +// - **`"(F)V"`** would reference a method that accepts one Float and returns Void. +// - **Z** boolean +// - **B** byte +// - **C** char +// - **S** short +// - **I** int +// - **J** long +// - **F** float +// - **D** double +// - **Lfully-qualified-class;** fully-qualified-class +// - **[type** type[] +// - **(arg-types)ret-type** method type +// - e.g. **`"([I)V"`** would accept one array of Ints and return Void. +// - parameters: Any number of JavaParameters (*must have the same number and type as the* `methodSignature` *you're trying to call*) +// - Throws: `JavaCallback.Error` + +// public init (_ globalJobj: JavaObject, methodName: String, methodSignature: String) throws { +// // At the moment we can only call Void methods, fail if user tries to return something else +// guard let returnType = methodSignature.last, returnType == "V"/*oid*/ else { +// // LOG JavaMethodCallError.IncorrectMethodSignature +// fatalError("JavaMethodCallError.IncorrectMethodSignature") +// } + +// // With signature "(FF)V", parameters count should be 2, ignoring the two brackets and the V +// // XXX: This test isn't robust, but it will prevent simple user errors +// // Doesn't work with more complex object types, arrays etc. we should determine the signature based on parameters. + +// // TODO: Check methodSignature here and determine expectedParameterCount +// let javaClass = try jni.GetObjectClass(obj: globalJobj) +// guard let methodID = try? jni.GetMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) +// else { +// // XXX: We should throw here and keep throwing til it gets back to Java +// fatalError("Failed to make JavaCallback") +// } + +// self.jobj = globalJobj +// self.methodID = methodID +// } + +// public func apply(args: [JavaParameter]) { +// try? jni.CallVoidMethod(methodID, on: jobj, parameters: args) +// } + +// /// Send variadic parameters to the func that takes an array +// public func call(args: JavaParameter...) { +// self.apply(args: args) +// } +// } From fb1cc567f8c2b4cb9a90c1345ca5916fe7dbfeca Mon Sep 17 00:00:00 2001 From: Geordie J Date: Thu, 21 Dec 2017 14:27:06 +0100 Subject: [PATCH 51/84] Add JavaContext struct --- Sources/JNI/JavaParameterConvertible.swift | 35 ++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index ce40dec..7f3c2f9 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -147,3 +147,38 @@ extension JavaObject: JavaParameterConvertible { return try jni.GetObjectField(of: javaObject, id: fieldID) } } + + +public struct JavaContext: JavaParameterConvertible { + private let object: JavaObject + public init(_ object: JavaObject) { + self.object = object + } + + private static let javaClassname = "android/content/Context" + public static let asJNIParameterString = "L\(javaClassname);" + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(object: self.object) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaContext { + let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: fieldID) + return self.init(jobject) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> JavaContext { + let jObject = try jni.CallObjectMethod(methodID, on: object, parameters: args) + return self.init(jObject) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> JavaContext { + let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) + return self.init(jObject) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> JavaContext { + let javaStringObject = try jni.GetObjectField(of: javaObject, id: fieldID) + return self.init(javaStringObject) + } +} \ No newline at end of file From edbba2fce7c6da945c4c87ac3f6112d3a89f5173 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Thu, 21 Dec 2017 14:27:40 +0100 Subject: [PATCH 52/84] Use Foundation to do string replacement --- Sources/JNI/Array+JavaParameterConvertible.swift | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Sources/JNI/Array+JavaParameterConvertible.swift b/Sources/JNI/Array+JavaParameterConvertible.swift index 32e888e..be25390 100644 --- a/Sources/JNI/Array+JavaParameterConvertible.swift +++ b/Sources/JNI/Array+JavaParameterConvertible.swift @@ -6,11 +6,11 @@ // import CJNI +import Foundation extension String { func replacingFullstopsWithSlashes() -> String { - let replacedCharacters = self.map { ($0 == ".") ? "/" : $0 } - return String(replacedCharacters) + return self.replacingOccurrences(of: ".", with: "/") } } From 49b4390ec66a5b2347ca8b4c39fcd3c98e038280 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Tue, 9 Jan 2018 17:16:51 +0100 Subject: [PATCH 53/84] Restructure splitting many methods into separate files --- Sources/JNI/JNIFields.swift | 77 ++++++++ Sources/JNI/JNIMethods.swift | 142 ++++++++++++++ Sources/JNI/JNIObjects.swift | 28 ++- .../JavaParameterConvertible+Objects.swift | 96 ++++++++++ .../JavaParameterConvertible+Primitives.swift | 109 +++++++++++ Sources/JNI/JavaParameterConvertible.swift | 165 ----------------- Sources/JNI/SwiftJNI.swift | 174 +----------------- 7 files changed, 439 insertions(+), 352 deletions(-) create mode 100644 Sources/JNI/JavaParameterConvertible+Objects.swift create mode 100644 Sources/JNI/JavaParameterConvertible+Primitives.swift diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index 79e2b95..736c6fe 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -23,3 +23,80 @@ public extension JNI { return try T.fromField(fieldID!, on: javaObject) } } + + +public extension JNI { + // MARK: Fields + + public func GetBooleanField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaBoolean { + let _env = self._env + let result = _env.pointee.pointee.GetBooleanField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result + } + + public func GetIntField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaInt { + let _env = self._env + let result = _env.pointee.pointee.GetIntField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result + } + + public func GetFloatField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaFloat { + let _env = self._env + let result = _env.pointee.pointee.GetFloatField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result + } + + public func GetDoubleField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaDouble { + let _env = self._env + let result = _env.pointee.pointee.GetDoubleField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result + } + + public func GetObjectField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaObject { + let _env = self._env + let result = _env.pointee.pointee.GetObjectField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result! + } + + // MARK: Static Fields + + public func GetStaticBooleanField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaBoolean { + let _env = self._env + let result = _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result + } + + public func GetStaticIntField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaInt { + let _env = self._env + let result = _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result + } + + public func GetStaticFloatField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaFloat { + let _env = self._env + let result = _env.pointee.pointee.GetStaticFloatField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result + } + + public func GetStaticDoubleField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaDouble { + let _env = self._env + let result = _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result + } + + public func GetStaticObjectField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaObject { + let _env = self._env + guard let result = _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) else { throw JNIError() } + try checkAndThrowOnJNIError() + return result + } +} \ No newline at end of file diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 3661719..634aef5 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -57,3 +57,145 @@ extension JNI { return try jni.GetStrings(from: returnedArray) } } + +// -------------------------------------------------------------------------------------------------------------------- +// Lower-level implementations +// -------------------------------------------------------------------------------------------------------------------- + + +// MARK: Getting Method IDs + +extension JNI { + public func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID { + let _env = self._env + let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) + try checkAndThrowOnJNIError() + + let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) + _env.pointee.pointee.DeleteLocalRef(_env, objectClass) + try checkAndThrowOnJNIError() + + return result! + } + + public func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID { + let _env = self._env + guard let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) else { + throw InvalidMethodID() + } + + try checkAndThrowOnJNIError() + return result + } +} + +// MARK: Call instance methods + +extension JNI { + public func CallVoidMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws { + let _env = self._env + var methodArgs = parameters + _env.pointee.pointee.CallVoidMethod(_env, object, method, &methodArgs) + try checkAndThrowOnJNIError() + } + + public func CallBooleanMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaBoolean { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallBooleanMethod(_env, object, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallIntMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaInt { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallIntMethod(_env, object, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallFloatMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaFloat { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallFloatMethod(_env, object, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallDoubleMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaDouble { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallDoubleMethod(_env, object, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallObjectMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaObject { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallObjectMethod(_env, object, method, &methodArgs)! + try checkAndThrowOnJNIError() + return result + } +} + + +// MARK: Static methods + +extension JNI { + public func CallStaticObjectMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaObject { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticObjectMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result! // we checked for error in the line above + } + + public func CallStaticBooleanMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> Bool { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result == true + } + + public func CallStaticIntMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaInt { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallStaticFloatMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaFloat { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticFloatMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallStaticDoubleMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaDouble { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticDoubleMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallStaticBooleanMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws -> JavaBoolean { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + + public func CallStaticVoidMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws { + let _env = self._env + var methodArgs = parameters + _env.pointee.pointee.CallStaticVoidMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + } +} \ No newline at end of file diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 69b3ae0..2a9bb1d 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,7 +1,7 @@ import CJNI -struct CreateNewObjectForConstructorError: Error {} -struct ConstructorError: Error {} +public struct CreateNewObjectForConstructorError: Error {} +public struct ConstructorError: Error {} /// Designed to simplify calling a constructor and methods on a JavaClass /// Subclass this and add the methods appropriate to the object you are constructing. @@ -20,10 +20,9 @@ open class JNIObject { self.javaClass = javaClass! guard - let instanceLocalRef = try? jni.callConstructor(on: self.javaClass, arguments: arguments), + let instanceLocalRef = try jni.callConstructor(on: self.javaClass, arguments: arguments), let instance = jni.NewGlobalRef(instanceLocalRef) else { - assertionFailure("Error during call to constructor of \(className)") throw ConstructorError() } @@ -43,8 +42,14 @@ open class JNIObject { } } +extension JNIObject { + enum Error: Swift.Error { + case couldntCallConstructor + } +} + extension JNI { - func callConstructor(on targetClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> JavaObject { + func callConstructor(on targetClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> JavaObject? { let methodID = _env.pointee.pointee.GetMethodID(_env, targetClass, "", arguments.methodSignature(returnType: nil)) try checkAndThrowOnJNIError() @@ -53,18 +58,12 @@ extension JNI { } public extension JNI { - public func AllocObject(targetClass: JavaClass) -> JavaObject? { - let env = self._env - return env.pointee.pointee.AllocObject(env, targetClass) - } - - public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) throws -> JavaObject { + public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) throws -> JavaObject? { let env = self._env var mutableArgs = args - guard let newObject = env.pointee.pointee.NewObject(env, targetClass, methodID, &mutableArgs) else { - throw CreateNewObjectForConstructorError() - } + let newObject = env.pointee.pointee.NewObject(env, targetClass, methodID, &mutableArgs) try checkAndThrowOnJNIError() + return newObject } @@ -74,5 +73,4 @@ public extension JNI { try checkAndThrowOnJNIError() return result! } - } diff --git a/Sources/JNI/JavaParameterConvertible+Objects.swift b/Sources/JNI/JavaParameterConvertible+Objects.swift new file mode 100644 index 0000000..4ff8bda --- /dev/null +++ b/Sources/JNI/JavaParameterConvertible+Objects.swift @@ -0,0 +1,96 @@ +// JavaObject + +extension JavaObject: JavaParameterConvertible { + private static let javaClassname = "java/lang/Object" + public static let asJNIParameterString = "L\(javaClassname);" + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(object: self) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaObject { + return try jni.GetStaticObjectField(of: javaClass, id: fieldID) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> JavaObject { + return try jni.CallObjectMethod(methodID, on: object, parameters: args) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> JavaObject { + return try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> JavaObject { + return try jni.GetObjectField(of: javaObject, id: fieldID) + } +} + + +// String + +extension String: JavaParameterConvertible { + private static let javaClassname = "java/lang/String" + public static let asJNIParameterString = "L\(javaClassname);" + + public func toJavaParameter() -> JavaParameter { + let stringAsObject = jni.NewStringUTF(self) + return JavaParameter(object: stringAsObject) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> String { + let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: fieldID) + return jni.GetString(from: jobject) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> String { + let jObject = try jni.CallObjectMethod(methodID, on: object, parameters: args) + return jni.GetString(from: jObject) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> String { + let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) + return jni.GetString(from: jObject) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> String { + let javaStringObject = try jni.GetObjectField(of: javaObject, id: fieldID) + return jni.GetString(from: javaStringObject) + } +} + + +// Context + +public struct JavaContext: JavaParameterConvertible { + private let object: JavaObject + public init(_ object: JavaObject) { + self.object = object + } + + private static let javaClassname = "android/content/Context" + public static let asJNIParameterString = "L\(javaClassname);" + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(object: self.object) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaContext { + let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: fieldID) + return self.init(jobject) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> JavaContext { + let jObject = try jni.CallObjectMethod(methodID, on: object, parameters: args) + return self.init(jObject) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> JavaContext { + let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) + return self.init(jObject) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> JavaContext { + let javaStringObject = try jni.GetObjectField(of: javaObject, id: fieldID) + return self.init(javaStringObject) + } +} diff --git a/Sources/JNI/JavaParameterConvertible+Primitives.swift b/Sources/JNI/JavaParameterConvertible+Primitives.swift new file mode 100644 index 0000000..64c672e --- /dev/null +++ b/Sources/JNI/JavaParameterConvertible+Primitives.swift @@ -0,0 +1,109 @@ +// Bool + +extension Bool: JavaParameterConvertible { + public static let asJNIParameterString = "Z" + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(bool: (self) ? 1 : 0) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Bool { + return try jni.GetStaticBooleanField(of: javaClass, id: fieldID) == JNI_TRUE + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Bool { + return try jni.CallBooleanMethod(methodID, on: object, parameters: args) == JNI_TRUE + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Bool { + return try jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == JNI_TRUE + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Bool { + return try jni.GetBooleanField(of: javaObject, id: fieldID) == JNI_TRUE + } +} + + +// Int + +extension Int: JavaParameterConvertible { + public static var asJNIParameterString = "I" + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(int: JavaInt(self)) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Int { + let result = try jni.GetStaticIntField(of: javaClass, id: fieldID) + return Int(result) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Int { + let result = try jni.CallIntMethod(methodID, on: object, parameters: args) + return Int(result) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Int { + let result = try jni.CallStaticIntMethod(methodID, on: javaClass, parameters: args) + return Int(result) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Int { + return try Int(jni.GetIntField(of: javaObject, id: fieldID)) + } +} + + +// Double + +extension Double: JavaParameterConvertible { + public static let asJNIParameterString = "D" + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(double: JavaDouble(self)) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Double { + return try Double(jni.GetStaticDoubleField(of: javaClass, id: fieldID)) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Double { + return try jni.CallDoubleMethod(methodID, on: object, parameters: args) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Double { + return try jni.CallStaticDoubleMethod(methodID, on: javaClass, parameters: args) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Double { + return try jni.GetDoubleField(of: javaObject, id: fieldID) + } +} + + +// Float + +extension Float: JavaParameterConvertible { + public static let asJNIParameterString = "F" + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(float: JavaFloat(self)) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Float { + return try Float(jni.GetStaticFloatField(of: javaClass, id: fieldID)) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Float { + return try jni.CallFloatMethod(methodID, on: object, parameters: args) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Float { + return try jni.CallStaticFloatMethod(methodID, on: javaClass, parameters: args) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Float { + return try jni.GetFloatField(of: javaObject, id: fieldID) + } +} diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 7f3c2f9..4a99090 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -17,168 +17,3 @@ public protocol JavaParameterConvertible { static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Self static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Self } - -extension Bool: JavaParameterConvertible { - public static let asJNIParameterString = "Z" - - public func toJavaParameter() -> JavaParameter { - return JavaParameter(bool: (self) ? 1 : 0) - } - - public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Bool { - return try jni.GetStaticBooleanField(of: javaClass, id: fieldID) == JNI_TRUE - } - - public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Bool { - return try jni.CallBooleanMethod(methodID, on: object, parameters: args) == JNI_TRUE - } - - public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Bool { - return try jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == JNI_TRUE - } - - public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Bool { - return try jni.GetBooleanField(of: javaObject, id: fieldID) == JNI_TRUE - } -} - -extension Int: JavaParameterConvertible { - public static var asJNIParameterString = "I" - - public func toJavaParameter() -> JavaParameter { - return JavaParameter(int: JavaInt(self)) - } - - public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Int { - let result = try jni.GetStaticIntField(of: javaClass, id: fieldID) - return Int(result) - } - - public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Int { - let result = try jni.CallIntMethod(methodID, on: object, parameters: args) - return Int(result) - } - - public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Int { - let result = try jni.CallStaticIntMethod(methodID, on: javaClass, parameters: args) - return Int(result) - } - - public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Int { - return try Int(jni.GetIntField(of: javaObject, id: fieldID)) - } -} - -extension Double: JavaParameterConvertible { - public static let asJNIParameterString = "D" - - public func toJavaParameter() -> JavaParameter { - return JavaParameter(double: JavaDouble(self)) - } - - public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Double { - return try Double(jni.GetStaticDoubleField(of: javaClass, id: fieldID)) - } - - public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Double { - return try jni.CallDoubleMethod(methodID, on: object, parameters: args) - } - - public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Double { - return try jni.CallStaticDoubleMethod(methodID, on: javaClass, parameters: args) - } - - public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Double { - return try jni.GetDoubleField(of: javaObject, id: fieldID) - } -} - -extension String: JavaParameterConvertible { - private static let javaClassname = "java/lang/String" - public static let asJNIParameterString = "L\(javaClassname);" - - public func toJavaParameter() -> JavaParameter { - let stringAsObject = jni.NewStringUTF(self) - return JavaParameter(object: stringAsObject) - } - - public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> String { - let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: fieldID) - return jni.GetString(from: jobject) - } - - public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> String { - let jObject = try jni.CallObjectMethod(methodID, on: object, parameters: args) - return jni.GetString(from: jObject) - } - - public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> String { - let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) - return jni.GetString(from: jObject) - } - - public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> String { - let javaStringObject = try jni.GetObjectField(of: javaObject, id: fieldID) - return jni.GetString(from: javaStringObject) - } -} - -extension JavaObject: JavaParameterConvertible { - private static let javaClassname = "java/lang/Object" - public static let asJNIParameterString = "L\(javaClassname);" - - public func toJavaParameter() -> JavaParameter { - return JavaParameter(object: self) - } - - public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaObject { - return try jni.GetStaticObjectField(of: javaClass, id: fieldID) - } - - public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> JavaObject { - return try jni.CallObjectMethod(methodID, on: object, parameters: args) - } - - public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> JavaObject { - return try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) - } - - public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> JavaObject { - return try jni.GetObjectField(of: javaObject, id: fieldID) - } -} - - -public struct JavaContext: JavaParameterConvertible { - private let object: JavaObject - public init(_ object: JavaObject) { - self.object = object - } - - private static let javaClassname = "android/content/Context" - public static let asJNIParameterString = "L\(javaClassname);" - - public func toJavaParameter() -> JavaParameter { - return JavaParameter(object: self.object) - } - - public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaContext { - let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: fieldID) - return self.init(jobject) - } - - public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> JavaContext { - let jObject = try jni.CallObjectMethod(methodID, on: object, parameters: args) - return self.init(jObject) - } - - public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> JavaContext { - let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) - return self.init(jObject) - } - - public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> JavaContext { - let javaStringObject = try jni.GetObjectField(of: javaObject, id: fieldID) - return self.init(javaStringObject) - } -} \ No newline at end of file diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index eab822b..6fdec8c 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -1,5 +1,5 @@ import CJNI -// import Dispatch +import Dispatch public var jni: JNI! // this gets set "OnLoad" so should always exist @@ -11,7 +11,7 @@ public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutabl jni = localJNI // set the global for use elsewhere - // DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) + DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) return JNI_VERSION_1_6 } @@ -49,177 +49,7 @@ extension JNI { return string } - // MARK: Classes and Methods - public func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID { - let _env = self._env - let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) - try checkAndThrowOnJNIError() - - let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) - _env.pointee.pointee.DeleteLocalRef(_env, objectClass) - try checkAndThrowOnJNIError() - - return result! - } - - public func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID { - let _env = self._env - guard let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) else { - throw InvalidMethodID() - } - - try checkAndThrowOnJNIError() - return result - } - - public func CallVoidMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws { - let _env = self._env - var methodArgs = parameters - _env.pointee.pointee.CallVoidMethod(_env, object, method, &methodArgs) - try checkAndThrowOnJNIError() - } - - public func CallBooleanMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaBoolean { - let _env = self._env - var methodArgs = parameters - let result = _env.pointee.pointee.CallBooleanMethod(_env, object, method, &methodArgs) - try checkAndThrowOnJNIError() - return result - } - - public func CallIntMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaInt { - let _env = self._env - var methodArgs = parameters - let result = _env.pointee.pointee.CallIntMethod(_env, object, method, &methodArgs) - try checkAndThrowOnJNIError() - return result - } - - public func CallDoubleMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaDouble { - let _env = self._env - var methodArgs = parameters - let result = _env.pointee.pointee.CallDoubleMethod(_env, object, method, &methodArgs) - try checkAndThrowOnJNIError() - return result - } - - public func CallObjectMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaObject { - let _env = self._env - var methodArgs = parameters - let result = _env.pointee.pointee.CallObjectMethod(_env, object, method, &methodArgs)! - try checkAndThrowOnJNIError() - return result - } - - // MARK: Static methods - - public func CallStaticObjectMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaObject { - let _env = self._env - var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticObjectMethodA(_env, javaClass, method, &methodArgs) - try checkAndThrowOnJNIError() - return result! // we checked for error in the line above - } - - public func CallStaticBooleanMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> Bool { - let _env = self._env - var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) - try checkAndThrowOnJNIError() - return result == true - } - - public func CallStaticIntMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaInt { - let _env = self._env - var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) - try checkAndThrowOnJNIError() - return result - } - - public func CallStaticDoubleMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaDouble { - let _env = self._env - var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticDoubleMethodA(_env, javaClass, method, &methodArgs) - try checkAndThrowOnJNIError() - return result - } - - public func CallStaticBooleanMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws -> JavaBoolean { - let _env = self._env - var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) - try checkAndThrowOnJNIError() - return result - } - - public func CallStaticVoidMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws { - let _env = self._env - var methodArgs = parameters - _env.pointee.pointee.CallStaticVoidMethodA(_env, javaClass, method, &methodArgs) - try checkAndThrowOnJNIError() - } - - // MARK: Fields - - public func GetBooleanField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaBoolean { - let _env = self._env - let result = _env.pointee.pointee.GetBooleanField(_env, javaObject, id) - try checkAndThrowOnJNIError() - return result - } - - public func GetIntField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaInt { - let _env = self._env - let result = _env.pointee.pointee.GetIntField(_env, javaObject, id) - try checkAndThrowOnJNIError() - return result - } - - public func GetDoubleField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaDouble { - let _env = self._env - let result = _env.pointee.pointee.GetDoubleField(_env, javaObject, id) - try checkAndThrowOnJNIError() - return result - } - - public func GetObjectField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaObject { - let _env = self._env - let result = _env.pointee.pointee.GetObjectField(_env, javaObject, id) - try checkAndThrowOnJNIError() - return result! - } - - // MARK: Static Fields - - public func GetStaticBooleanField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaBoolean { - let _env = self._env - let result = _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) - try checkAndThrowOnJNIError() - return result - } - - public func GetStaticIntField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaInt { - let _env = self._env - let result = _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) - try checkAndThrowOnJNIError() - return result - } - - public func GetStaticDoubleField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaDouble { - let _env = self._env - let result = _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) - try checkAndThrowOnJNIError() - return result - } - - public func GetStaticObjectField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaObject { - let _env = self._env - guard let result = _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) else { throw JNIError() } - try checkAndThrowOnJNIError() - return result - } // MARK: Arrays From 7ca8143ef34dfb6a86b62a40d62323c0876d7553 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Mon, 15 Jan 2018 16:09:12 +0100 Subject: [PATCH 54/84] Update JNI String functions --- Sources/CJNI/include/jni.h | 2 +- Sources/JNI/JNIObjects.swift | 6 +- Sources/JNI/JNIRefs.swift | 22 +++--- Sources/JNI/JNIStrings.swift | 74 +++++++++++++------ .../JavaParameterConvertible+Objects.swift | 8 +- Sources/JNI/SwiftJNI.swift | 12 +-- 6 files changed, 74 insertions(+), 50 deletions(-) diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index cdf2211..168ac8e 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -388,7 +388,7 @@ struct JNINativeInterface jstring (* _Nonnull NewStringUTF)(JNIEnv * _Nonnull, const char * _Nonnull); jsize (* _Nonnull GetStringUTFLength)(JNIEnv * _Nonnull, jstring); /* JNI spec says this returns const jbyte*, but that's inconsistent */ - const char * _Nonnull(* _Nonnull GetStringUTFChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nullable); + const char * _Nullable(* _Nonnull GetStringUTFChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nullable); void (* _Nonnull ReleaseStringUTFChars)(JNIEnv * _Nonnull, jstring, const char * _Nullable); jsize (* _Nonnull GetArrayLength)(JNIEnv * _Nonnull, jarray); jobjectArray (* _Nonnull NewObjectArray)(JNIEnv * _Nonnull, jsize, jclass, jobject); diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 2a9bb1d..7a9134d 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -16,7 +16,6 @@ open class JNIObject { let javaClass = jni.NewGlobalRef(javaClassLocalRef) try checkAndThrowOnJNIError() - self.javaClass = javaClass! guard @@ -29,6 +28,11 @@ open class JNIObject { self.instance = instance } + deinit { + jni.DeleteGlobalRef(instance) + jni.DeleteGlobalRef(javaClass) + } + public func call(methodName: String, arguments: [JavaParameterConvertible] = []) throws { try jni.call(methodName, on: self.instance, arguments: arguments) } diff --git a/Sources/JNI/JNIRefs.swift b/Sources/JNI/JNIRefs.swift index b434b6c..e15de76 100644 --- a/Sources/JNI/JNIRefs.swift +++ b/Sources/JNI/JNIRefs.swift @@ -6,58 +6,58 @@ public extension JNI { return env.pointee.pointee.NewGlobalRef(env, object) } - public func DeleteGlobalRef(globalRef: JavaObject) { + public func DeleteGlobalRef(_ globalRef: JavaObject) { let env = self._env env.pointee.pointee.DeleteGlobalRef(env, globalRef) } - public func NewLocalRef(ref: JavaObject) -> JavaObject? { + public func NewLocalRef(_ ref: JavaObject) -> JavaObject? { let env = self._env return env.pointee.pointee.NewLocalRef(env, ref) } - public func DeleteLocalRef(localRef: JavaObject) { + public func DeleteLocalRef(_ localRef: JavaObject) { let env = self._env env.pointee.pointee.DeleteLocalRef(env, localRef) } - public func PushLocalFrame(capacity: JavaInt) -> JavaInt { + public func PushLocalFrame(_ capacity: JavaInt) -> JavaInt { let env = self._env return env.pointee.pointee.PushLocalFrame(env, capacity) } - public func PopLocalFrame(result: JavaObject) -> JavaObject { + public func PopLocalFrame(_ result: JavaObject) -> JavaObject { let env = self._env return env.pointee.pointee.PopLocalFrame(env, result)! } - public func EnsureLocalCapacity(capacity: JavaInt) -> JavaInt { + public func EnsureLocalCapacity(_ capacity: JavaInt) -> JavaInt { let env = self._env return env.pointee.pointee.EnsureLocalCapacity(env, capacity) } - public func IsSameObject(ref1: JavaObject, _ ref2: JavaObject) -> JavaBoolean { + public func IsSameObject(_ ref1: JavaObject, _ ref2: JavaObject) -> JavaBoolean { let env = self._env return env.pointee.pointee.IsSameObject(env, ref1, ref2) } - public func IsInstanceOf(obj: JavaObject, _ targetClass: JavaClass) -> JavaBoolean { + public func IsInstanceOf(_ obj: JavaObject, _ targetClass: JavaClass) -> JavaBoolean { let env = self._env return env.pointee.pointee.IsInstanceOf(env, obj, targetClass) } - public func NewWeakGlobalRef(obj: JavaObject) -> JavaWeakReference { + public func NewWeakGlobalRef(_ obj: JavaObject) -> JavaWeakReference { let env = self._env return env.pointee.pointee.NewWeakGlobalRef(env, obj)! } - public func DeleteWeakGlobalRef(obj: JavaWeakReference) { + public func DeleteWeakGlobalRef(_ obj: JavaWeakReference) { let env = self._env env.pointee.pointee.DeleteWeakGlobalRef(env, obj) } /* added in 1: JNI.6 */ - public func GetObjectRefType(obj: JavaObject) -> JavaObjectRefType { + public func GetObjectRefType(_ obj: JavaObject) -> JavaObjectRefType { let env = self._env return env.pointee.pointee.GetObjectRefType(env, obj) } diff --git a/Sources/JNI/JNIStrings.swift b/Sources/JNI/JNIStrings.swift index 435fef7..a733a9f 100644 --- a/Sources/JNI/JNIStrings.swift +++ b/Sources/JNI/JNIStrings.swift @@ -1,24 +1,54 @@ import CJNI +import struct Foundation.Data + +public extension Data { + init?(javaString: JavaString) { + let env = jni._env + guard let chars = env.pointee.pointee.GetStringUTFChars(env, javaString, nil) else { return nil } + defer { env.pointee.pointee.ReleaseStringUTFChars(env, javaString, chars) } + + let stringLength = env.pointee.pointee.GetStringUTFLength(env, javaString) + self.init(bytes: chars, count: Int(stringLength)) + } + + /// We extend Data instead of making an initializer for JavaString because the latter is + /// just a Void pointer, which would cause confusion. + func toJavaString() -> JavaString? { + let env = jni._env + return withUnsafeBytes { env.pointee.pointee.NewStringUTF(env, $0) } + } +} + +public extension String { + init(javaString: JavaString) throws { + let env = jni._env + let chars = env.pointee.pointee.GetStringUTFChars(env, javaString, nil) + defer { env.pointee.pointee.ReleaseStringUTFChars(env, javaString, chars) } + try checkAndThrowOnJNIError() + + self.init(cString: chars!) + } +} public extension JNI { - public func NewString(unicodeChars: UnsafePointer, _ len: jsize) -> JavaString { + public func NewString(unicodeChars: UnsafePointer, _ length: jsize) -> JavaString { let env = self._env - return env.pointee.pointee.NewString(env, unicodeChars, len)! + return env.pointee.pointee.NewString(env, unicodeChars, length)! } - public func GetStringLength(string: JavaString) -> jsize { + public func GetStringLength(_ jString: JavaString) -> jsize { let env = self._env - return env.pointee.pointee.GetStringLength(env, string) + return env.pointee.pointee.GetStringLength(env, jString) } - public func GetStringChars(string: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { + public func GetStringChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env - return env.pointee.pointee.GetStringChars(env, string, isCopy)! + return env.pointee.pointee.GetStringChars(env, jString, isCopy)! } - public func ReleaseStringChars(string: JavaString, _ chars: UnsafePointer) { + public func ReleaseStringChars(_ jString: JavaString, _ chars: UnsafePointer) { let env = self._env - env.pointee.pointee.ReleaseStringChars(env, string, chars) + env.pointee.pointee.ReleaseStringChars(env, jString, chars) } public func NewStringUTF(_ string: String) -> JavaString { @@ -26,38 +56,38 @@ public extension JNI { return env.pointee.pointee.NewStringUTF(env, string)! } - public func GetStringUTFLength(string: JavaString) -> jsize { + public func GetStringUTFLength(_ jString: JavaString) -> jsize { let env = self._env - return env.pointee.pointee.GetStringUTFLength(env, string) + return env.pointee.pointee.GetStringUTFLength(env, jString) } - public func GetStringUTFChars(string: JavaString, _ isCopy: UnsafeMutablePointer) -> String { + public func GetStringUTFChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> String { let env = self._env - return String(describing: env.pointee.pointee.GetStringUTFChars(env, string, isCopy)) + return String(describing: env.pointee.pointee.GetStringUTFChars(env, jString, isCopy)) } - public func ReleaseStringUTFChars(string: JavaString, _ utf: String) { + public func ReleaseStringUTFChars(_ jString: JavaString, _ utf: String) { let env = self._env - env.pointee.pointee.ReleaseStringUTFChars(env, string, utf) + env.pointee.pointee.ReleaseStringUTFChars(env, jString, utf) } - public func GetStringRegion(str: JavaString, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer) { + public func GetStringRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { let env = self._env - env.pointee.pointee.GetStringRegion(env, str, start, len, buf) + env.pointee.pointee.GetStringRegion(env, jString, start, length, buf) } - public func GetStringUTFRegion(str: JavaString, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer) { + public func GetStringUTFRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { let env = self._env - env.pointee.pointee.GetStringUTFRegion(env, str, start, len, buf) + env.pointee.pointee.GetStringUTFRegion(env, jString, start, length, buf) } - public func GetStringCritical(string: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { + public func GetStringCritical(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env - return env.pointee.pointee.GetStringCritical(env, string, isCopy)! + return env.pointee.pointee.GetStringCritical(env, jString, isCopy)! } - public func ReleaseStringCritical(string: JavaString, _ carray: UnsafePointer) { + public func ReleaseStringCritical(_ jString: JavaString, _ cArray: UnsafePointer) { let env = self._env - env.pointee.pointee.ReleaseStringCritical(env, string, carray) + env.pointee.pointee.ReleaseStringCritical(env, jString, cArray) } } diff --git a/Sources/JNI/JavaParameterConvertible+Objects.swift b/Sources/JNI/JavaParameterConvertible+Objects.swift index 4ff8bda..afca27f 100644 --- a/Sources/JNI/JavaParameterConvertible+Objects.swift +++ b/Sources/JNI/JavaParameterConvertible+Objects.swift @@ -39,22 +39,22 @@ extension String: JavaParameterConvertible { public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> String { let jobject: JavaObject = try jni.GetStaticObjectField(of: javaClass, id: fieldID) - return jni.GetString(from: jobject) + return try String(javaString: jobject) } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> String { let jObject = try jni.CallObjectMethod(methodID, on: object, parameters: args) - return jni.GetString(from: jObject) + return try String(javaString: jObject) } public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> String { let jObject = try jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args) - return jni.GetString(from: jObject) + return try String(javaString: jObject) } public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> String { let javaStringObject = try jni.GetObjectField(of: javaObject, id: fieldID) - return jni.GetString(from: javaStringObject) + return try String(javaString: javaStringObject) } } diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 6fdec8c..153f0e7 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -41,16 +41,6 @@ extension JNI { _ = env.ThrowNew(_env, env.FindClass(_env, "java/lang/Exception"), message) } - public func GetString(from javaString: JavaString) -> String { - let _env = self._env - let chars = _env.pointee.pointee.GetStringUTFChars(_env, javaString, nil) - let string = String(cString: chars) - _env.pointee.pointee.ReleaseStringUTFChars(_env, javaString, chars) - return string - } - - - // MARK: Arrays public func GetLength(_ array: JavaArray) -> Int { @@ -143,7 +133,7 @@ extension JNI { try checkAndThrowOnJNIError() defer { _env.pointee.pointee.ReleaseStringUTFChars(_env, jString, chars) } - return String(cString: chars) + return String(cString: chars!) } return strings From 9bc4afd9f75984e3a1d97c36b13d63929b705365 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Tue, 23 Jan 2018 16:28:02 +0100 Subject: [PATCH 55/84] Add missing files to Xcode project --- JNI.xcodeproj/project.pbxproj | 8 ++++++++ JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme | 2 +- Sources/JNI/SwiftJNI.swift | 2 ++ 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index 4a79348..5e02d92 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -8,6 +8,8 @@ /* Begin PBXBuildFile section */ 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */ = {isa = PBXBuildFile; fileRef = 034A7B8D1F30D18A0071A850 /* JNIFields.swift */; }; + 5CFFF4352016125500D989BC /* JavaParameterConvertible+Objects.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CFFF4332016125400D989BC /* JavaParameterConvertible+Objects.swift */; }; + 5CFFF4362016125500D989BC /* JavaParameterConvertible+Primitives.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CFFF4342016125500D989BC /* JavaParameterConvertible+Primitives.swift */; }; OBJ_33 /* Array+JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_14 /* Array+JavaParameterConvertible.swift */; }; OBJ_34 /* JNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_15 /* JNI.swift */; }; OBJ_35 /* JNIClassManipulation.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_16 /* JNIClassManipulation.swift */; }; @@ -34,6 +36,8 @@ /* Begin PBXFileReference section */ 034A7B8D1F30D18A0071A850 /* JNIFields.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIFields.swift; sourceTree = ""; }; + 5CFFF4332016125400D989BC /* JavaParameterConvertible+Objects.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "JavaParameterConvertible+Objects.swift"; sourceTree = ""; }; + 5CFFF4342016125500D989BC /* JavaParameterConvertible+Primitives.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "JavaParameterConvertible+Primitives.swift"; sourceTree = ""; }; "JNI::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; "JNI::JNI::Product" /* JNI.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = JNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; OBJ_11 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; @@ -91,6 +95,8 @@ OBJ_20 /* JNIRefs.swift */, OBJ_21 /* JNIStrings.swift */, OBJ_22 /* JavaParameterConvertible.swift */, + 5CFFF4332016125400D989BC /* JavaParameterConvertible+Objects.swift */, + 5CFFF4342016125500D989BC /* JavaParameterConvertible+Primitives.swift */, OBJ_23 /* SwiftJNI.swift */, ); name = JNI; @@ -211,11 +217,13 @@ files = ( OBJ_33 /* Array+JavaParameterConvertible.swift in Sources */, OBJ_34 /* JNI.swift in Sources */, + 5CFFF4352016125500D989BC /* JavaParameterConvertible+Objects.swift in Sources */, OBJ_35 /* JNIClassManipulation.swift in Sources */, OBJ_36 /* JNIExceptions.swift in Sources */, OBJ_37 /* JNIMethods.swift in Sources */, 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */, OBJ_38 /* JNIObjects.swift in Sources */, + 5CFFF4362016125500D989BC /* JavaParameterConvertible+Primitives.swift in Sources */, OBJ_39 /* JNIRefs.swift in Sources */, OBJ_40 /* JNIStrings.swift in Sources */, OBJ_41 /* JavaParameterConvertible.swift in Sources */, diff --git a/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme b/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme index f067174..34ef7ae 100644 --- a/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme +++ b/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme @@ -1,6 +1,6 @@ , reserved: UnsafeMutabl jni = localJNI // set the global for use elsewhere + #if os(Android) DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) + #endif return JNI_VERSION_1_6 } From d92a27a0b5151883261368de250f20f9c4d7e756 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Tue, 6 Mar 2018 16:18:26 +0100 Subject: [PATCH 56/84] Split up conformances for JavaParameterConvertible --- Sources/JNI/JNIFields.swift | 6 ++-- Sources/JNI/JNIMethods.swift | 6 ++-- Sources/JNI/JNIObjects.swift | 30 ++++++++++--------- .../JavaParameterConvertible+Objects.swift | 6 ++-- .../JavaParameterConvertible+Primitives.swift | 8 ++--- Sources/JNI/JavaParameterConvertible.swift | 5 ++++ 6 files changed, 34 insertions(+), 27 deletions(-) diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index 736c6fe..8e86fb9 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -8,14 +8,14 @@ import CJNI public extension JNI { - public func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { + public func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { let env = self._env let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) try checkAndThrowOnJNIError() return try T.fromStaticField(fieldID!, of: javaClass) } - public func GetField(_ fieldName: String, from javaObject: JavaObject) throws -> T { + public func GetField(_ fieldName: String, from javaObject: JavaObject) throws -> T { let env = self._env let javaClass = try GetObjectClass(obj: javaObject) let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) @@ -99,4 +99,4 @@ public extension JNI { try checkAndThrowOnJNIError() return result } -} \ No newline at end of file +} diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 634aef5..4a9c5a1 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -12,7 +12,7 @@ extension JNI { try jni.CallStaticVoidMethod(javaClass: javaClass, method: methodID, parameters: arguments.asJavaParameters()) } - public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> T { + public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> T { let methodSignature = arguments.methodSignature(returnType: T.self) let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) @@ -35,7 +35,7 @@ extension JNI { return try jni.CallVoidMethod(methodID, on: object, parameters: arguments.asJavaParameters()) } - public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = []) throws -> T { + public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = []) throws -> T { let methodSignature = arguments.methodSignature(returnType: T.self) let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) @@ -198,4 +198,4 @@ extension JNI { _env.pointee.pointee.CallStaticVoidMethodA(_env, javaClass, method, &methodArgs) try checkAndThrowOnJNIError() } -} \ No newline at end of file +} diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 7a9134d..b8a9f53 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,31 +1,32 @@ import CJNI -public struct CreateNewObjectForConstructorError: Error {} -public struct ConstructorError: Error {} - /// Designed to simplify calling a constructor and methods on a JavaClass /// Subclass this and add the methods appropriate to the object you are constructing. open class JNIObject { public let javaClass: JavaClass public let instance: JavaObject - public init(_ className: String, arguments: [JavaParameterConvertible] = []) throws { - let className = className.replacingFullstopsWithSlashes() - - let javaClassLocalRef = try jni.FindClass(name: className) + required public init(_ instance: JavaObject) throws { + guard let globalInstanceRef = jni.NewGlobalRef(instance) else { + throw Error.couldntCreateGlobalRef + } + let javaClassLocalRef = try jni.GetObjectClass(obj: instance) let javaClass = jni.NewGlobalRef(javaClassLocalRef) try checkAndThrowOnJNIError() self.javaClass = javaClass! + self.instance = globalInstanceRef + } + + convenience public init(_ className: String, arguments: [JavaParameterConvertible] = []) throws { + let className = className.replacingFullstopsWithSlashes() + let javaClassLocalRef = try jni.FindClass(name: className) - guard - let instanceLocalRef = try jni.callConstructor(on: self.javaClass, arguments: arguments), - let instance = jni.NewGlobalRef(instanceLocalRef) - else { - throw ConstructorError() + guard let instanceLocalRef = try jni.callConstructor(on: javaClassLocalRef, arguments: arguments) else { + throw Error.couldntCallConstructor } - self.instance = instance + try self.init(instanceLocalRef) } deinit { @@ -37,7 +38,7 @@ open class JNIObject { try jni.call(methodName, on: self.instance, arguments: arguments) } - public func call(methodName: String, arguments: [JavaParameterConvertible] = []) throws -> T { + public func call(methodName: String, arguments: [JavaParameterConvertible] = []) throws -> T { return try jni.call(methodName, on: self.instance, arguments: arguments) } @@ -48,6 +49,7 @@ open class JNIObject { extension JNIObject { enum Error: Swift.Error { + case couldntCreateGlobalRef case couldntCallConstructor } } diff --git a/Sources/JNI/JavaParameterConvertible+Objects.swift b/Sources/JNI/JavaParameterConvertible+Objects.swift index afca27f..aec9317 100644 --- a/Sources/JNI/JavaParameterConvertible+Objects.swift +++ b/Sources/JNI/JavaParameterConvertible+Objects.swift @@ -1,6 +1,6 @@ // JavaObject -extension JavaObject: JavaParameterConvertible { +extension JavaObject: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { private static let javaClassname = "java/lang/Object" public static let asJNIParameterString = "L\(javaClassname);" @@ -28,7 +28,7 @@ extension JavaObject: JavaParameterConvertible { // String -extension String: JavaParameterConvertible { +extension String: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { private static let javaClassname = "java/lang/String" public static let asJNIParameterString = "L\(javaClassname);" @@ -61,7 +61,7 @@ extension String: JavaParameterConvertible { // Context -public struct JavaContext: JavaParameterConvertible { +public struct JavaContext: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { private let object: JavaObject public init(_ object: JavaObject) { self.object = object diff --git a/Sources/JNI/JavaParameterConvertible+Primitives.swift b/Sources/JNI/JavaParameterConvertible+Primitives.swift index 64c672e..c324e32 100644 --- a/Sources/JNI/JavaParameterConvertible+Primitives.swift +++ b/Sources/JNI/JavaParameterConvertible+Primitives.swift @@ -1,6 +1,6 @@ // Bool -extension Bool: JavaParameterConvertible { +extension Bool: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { public static let asJNIParameterString = "Z" public func toJavaParameter() -> JavaParameter { @@ -27,7 +27,7 @@ extension Bool: JavaParameterConvertible { // Int -extension Int: JavaParameterConvertible { +extension Int: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { public static var asJNIParameterString = "I" public func toJavaParameter() -> JavaParameter { @@ -57,7 +57,7 @@ extension Int: JavaParameterConvertible { // Double -extension Double: JavaParameterConvertible { +extension Double: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { public static let asJNIParameterString = "D" public func toJavaParameter() -> JavaParameter { @@ -84,7 +84,7 @@ extension Double: JavaParameterConvertible { // Float -extension Float: JavaParameterConvertible { +extension Float: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { public static let asJNIParameterString = "F" public func toJavaParameter() -> JavaParameter { diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 4a99090..83bc4e8 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -11,9 +11,14 @@ public protocol JavaParameterConvertible { typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) static var asJNIParameterString: String { get } func toJavaParameter() -> JavaParameter +} +public protocol JavaInitializableFromMethod { static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Self static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self +} + +public protocol JavaInitializableFromField { static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Self static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Self } From 0cee5781936e8b8d1b28c93f6b85204719329633 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Tue, 15 May 2018 17:33:46 +0200 Subject: [PATCH 57/84] [Breaking Change] Use the real main queue with Johnno's toolchain This should be temporary until we get the libdispatch build working again. --- Sources/JNI/SwiftJNI.swift | 1 + 1 file changed, 1 insertion(+) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 64d2889..fad70fa 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -12,6 +12,7 @@ public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutabl jni = localJNI // set the global for use elsewhere #if os(Android) + DispatchQueue.drainingMainQueue = true DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) #endif From 25a514092e39cd8acb5f71cb8ceee3ef261c772f Mon Sep 17 00:00:00 2001 From: Michael Knoch Date: Fri, 25 May 2018 13:27:00 +0200 Subject: [PATCH 58/84] make JavaLong aka Int64 conform to JavaParameterConvertible (#11) * allow passing Int64 aka JavaFloat through JNI * fix function signature and cleanup --- Sources/JNI/JNIFields.swift | 14 ++++++++++ Sources/JNI/JNIMethods.swift | 16 ++++++++++++ .../JavaParameterConvertible+Primitives.swift | 26 +++++++++++++++++++ 3 files changed, 56 insertions(+) diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index 8e86fb9..d823477 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -49,6 +49,13 @@ public extension JNI { return result } + public func GetLongField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaLong { + let _env = self._env + let result = _env.pointee.pointee.GetLongField(_env, javaObject, id) + try checkAndThrowOnJNIError() + return result + } + public func GetDoubleField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaDouble { let _env = self._env let result = _env.pointee.pointee.GetDoubleField(_env, javaObject, id) @@ -86,6 +93,13 @@ public extension JNI { return result } + public func GetStaticLongField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaLong { + let _env = self._env + let result = _env.pointee.pointee.GetStaticLongField(_env, javaClass, id) + try checkAndThrowOnJNIError() + return result + } + public func GetStaticDoubleField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaDouble { let _env = self._env let result = _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 4a9c5a1..37414c4 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -123,6 +123,14 @@ extension JNI { return result } + public func CallLongMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaLong { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallLongMethod(_env, object, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + public func CallDoubleMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaDouble { let _env = self._env var methodArgs = parameters @@ -168,6 +176,14 @@ extension JNI { return result } + public func CallStaticLongMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaLong { + let _env = self._env + var methodArgs = parameters + let result = _env.pointee.pointee.CallStaticLongMethodA(_env, javaClass, method, &methodArgs) + try checkAndThrowOnJNIError() + return result + } + public func CallStaticFloatMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaFloat { let _env = self._env var methodArgs = parameters diff --git a/Sources/JNI/JavaParameterConvertible+Primitives.swift b/Sources/JNI/JavaParameterConvertible+Primitives.swift index c324e32..033f456 100644 --- a/Sources/JNI/JavaParameterConvertible+Primitives.swift +++ b/Sources/JNI/JavaParameterConvertible+Primitives.swift @@ -107,3 +107,29 @@ extension Float: JavaParameterConvertible, JavaInitializableFromMethod, JavaInit return try jni.GetFloatField(of: javaObject, id: fieldID) } } + +// JavaLong aka Int64 + +extension JavaLong: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { + public static let asJNIParameterString = "J" + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(long: self) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaLong { + return try JavaLong(jni.GetStaticLongField(of: javaClass, id: fieldID)) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> JavaLong { + return try jni.CallLongMethod(methodID, on: object, parameters: args) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> JavaLong { + return try jni.CallStaticLongMethod(methodID, on: javaClass, parameters: args) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> JavaLong { + return try jni.GetLongField(of: javaObject, id: fieldID) + } +} From 7053cb092a006661867bfb045fecb44c2bf1158e Mon Sep 17 00:00:00 2001 From: Geordie J Date: Wed, 13 Jun 2018 16:51:07 +1000 Subject: [PATCH 59/84] "Build" JNI for Mac only (testing) --- JNI.xcodeproj/project.pbxproj | 8 +- .../xcschemes/JNI-Package.xcscheme | 87 ------------------- Sources/CJNI/include/jni.h | 4 +- 3 files changed, 5 insertions(+), 94 deletions(-) delete mode 100644 JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index 5e02d92..3f5cdb3 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -265,7 +265,6 @@ OTHER_SWIFT_FLAGS = "-DXcode"; PRODUCT_NAME = "$(TARGET_NAME)"; SDKROOT = macosx; - SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; SWIFT_OPTIMIZATION_LEVEL = "-Onone"; USE_HEADERMAP = NO; @@ -335,7 +334,6 @@ OTHER_SWIFT_FLAGS = "-DXcode"; PRODUCT_NAME = "$(TARGET_NAME)"; SDKROOT = macosx; - SUPPORTED_PLATFORMS = "macosx iphoneos iphonesimulator appletvos appletvsimulator watchos watchsimulator"; SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; USE_HEADERMAP = NO; @@ -402,7 +400,7 @@ OBJ_4 /* Release */, ); defaultConfigurationIsVisible = 0; - defaultConfigurationName = Debug; + defaultConfigurationName = Release; }; OBJ_29 /* Build configuration list for PBXNativeTarget "JNI" */ = { isa = XCConfigurationList; @@ -411,7 +409,7 @@ OBJ_31 /* Release */, ); defaultConfigurationIsVisible = 0; - defaultConfigurationName = Debug; + defaultConfigurationName = Release; }; OBJ_47 /* Build configuration list for PBXNativeTarget "CJNI" */ = { isa = XCConfigurationList; @@ -420,7 +418,7 @@ OBJ_49 /* Release */, ); defaultConfigurationIsVisible = 0; - defaultConfigurationName = Debug; + defaultConfigurationName = Release; }; /* End XCConfigurationList section */ }; diff --git a/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme b/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme deleted file mode 100644 index 34ef7ae..0000000 --- a/JNI.xcodeproj/xcshareddata/xcschemes/JNI-Package.xcscheme +++ /dev/null @@ -1,87 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index 168ac8e..be415dd 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -1423,8 +1423,8 @@ jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize* _Nonnull); * Prototypes for functions exported by loadable shared libs. These are * called by JNI, not provided by JNI. */ -JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM * _Nonnull vm, void * _Null_unspecified reserved); -JNIEXPORT void JNICALL JNI_OnUnload(JavaVM * _Nonnull vm, void * _Null_unspecified reserved); +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM * _Nonnull vm, void * _Nullable reserved); +JNIEXPORT void JNICALL JNI_OnUnload(JavaVM * _Nonnull vm, void * _Nullable reserved); #ifdef __cplusplus } From a2b9c15b7f9d66b5e4533ffe29231b40f0c620a0 Mon Sep 17 00:00:00 2001 From: Michael Knoch Date: Thu, 16 Aug 2018 13:52:40 +0200 Subject: [PATCH 60/84] implement JavaInt conformance to JavaParameterConvertible (#12) * breaking change: Int does no longer conform to JavaParameterConvertible, use JavaInt instead * cleanup --- .../JavaParameterConvertible+Primitives.swift | 25 ++++++++----------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/Sources/JNI/JavaParameterConvertible+Primitives.swift b/Sources/JNI/JavaParameterConvertible+Primitives.swift index 033f456..ef02671 100644 --- a/Sources/JNI/JavaParameterConvertible+Primitives.swift +++ b/Sources/JNI/JavaParameterConvertible+Primitives.swift @@ -25,32 +25,29 @@ extension Bool: JavaParameterConvertible, JavaInitializableFromMethod, JavaIniti } -// Int +// JavaInt -extension Int: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { +extension JavaInt: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { public static var asJNIParameterString = "I" public func toJavaParameter() -> JavaParameter { - return JavaParameter(int: JavaInt(self)) + return JavaParameter(int: self) } - public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Int { - let result = try jni.GetStaticIntField(of: javaClass, id: fieldID) - return Int(result) + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaInt { + return try jni.GetStaticIntField(of: javaClass, id: fieldID) } - public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Int { - let result = try jni.CallIntMethod(methodID, on: object, parameters: args) - return Int(result) + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> JavaInt { + return try jni.CallIntMethod(methodID, on: object, parameters: args) } - public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Int { - let result = try jni.CallStaticIntMethod(methodID, on: javaClass, parameters: args) - return Int(result) + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> JavaInt { + return try jni.CallStaticIntMethod(methodID, on: javaClass, parameters: args) } - public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Int { - return try Int(jni.GetIntField(of: javaObject, id: fieldID)) + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> JavaInt { + return try jni.GetIntField(of: javaObject, id: fieldID) } } From 128c15566002d9db0b09720bb339877d87d9a251 Mon Sep 17 00:00:00 2001 From: michaelknoch Date: Fri, 12 Oct 2018 18:56:09 +0200 Subject: [PATCH 61/84] make GetIntArrayRegion return array of Int32 --- Sources/JNI/SwiftJNI.swift | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index fad70fa..6284a77 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -81,7 +81,7 @@ extension JNI { _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } - public func GetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, numElements: Int = -1) -> [Int] { + public func GetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, numElements: Int = -1) -> [JavaInt] { let _env = self._env var count = numElements @@ -91,7 +91,7 @@ extension JNI { var result = [JavaInt](repeating: 0, count: count) _env.pointee.pointee.GetIntArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) - return result.map { Int($0) } + return result } public func SetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, from sourceElements: [Int]) { From dc2d8ff3943b86e1a31f14752b7d35b83058fb35 Mon Sep 17 00:00:00 2001 From: Geordie J Date: Fri, 26 Oct 2018 16:11:08 +0200 Subject: [PATCH 62/84] Use c calling convention --- Sources/JNI/SwiftJNI.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 6284a77..8ffbece 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -3,7 +3,7 @@ import Dispatch public var jni: JNI! // this gets set "OnLoad" so should always exist -@_silgen_name("JNI_OnLoad") +@_cdecl("JNI_OnLoad") public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutableRawPointer) -> JavaInt { guard let localJNI = JNI(jvm: jvm) else { fatalError("Couldn't initialise JNI") From 41ee4643542f2a95b7087d8144b379f035ea201b Mon Sep 17 00:00:00 2001 From: michaelknoch Date: Mon, 29 Oct 2018 11:27:46 +0100 Subject: [PATCH 63/84] workaround SwiftPM bug --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 89d806e..821a0c9 100644 --- a/.gitignore +++ b/.gitignore @@ -33,6 +33,9 @@ xcuserdata # Packages/ .build/ +# temporary workaround for swift pm bug +Package.resolved + # CocoaPods # # We recommend against adding the Pods directory to your .gitignore. However From 83c985944f623dabdfdf625a643a0fe38d732a2d Mon Sep 17 00:00:00 2001 From: Michael Knoch Date: Thu, 22 Aug 2019 08:50:19 +0200 Subject: [PATCH 64/84] allows static method calls on `JNIObject` (#14) * allow calling static methods on JNIObjects * reindent * deprecate init with explicit className * implement private classInstances cache * use static getter for classinstances --- Sources/JNI/JNIObjects.swift | 67 ++++++++++++++++++++++++++++-------- 1 file changed, 53 insertions(+), 14 deletions(-) diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index b8a9f53..92ec789 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,9 +1,30 @@ import CJNI +import Dispatch /// Designed to simplify calling a constructor and methods on a JavaClass /// Subclass this and add the methods appropriate to the object you are constructing. open class JNIObject { - public let javaClass: JavaClass + open class var className: String { + return "java.lang.object" + } + + private static var classInstances = [String: JavaClass]() + + public static var javaClass: JavaClass { + return DispatchQueue.main.sync { + if let classInstance = classInstances[className] { + return classInstance + } + + let javaClassLocalRef = try! jni.FindClass(name: className.replacingFullstopsWithSlashes()) + try! checkAndThrowOnJNIError() + let classInstance = jni.NewGlobalRef(javaClassLocalRef)! + classInstances[className] = classInstance + + return classInstance + } + } + public let instance: JavaObject required public init(_ instance: JavaObject) throws { @@ -11,13 +32,11 @@ open class JNIObject { throw Error.couldntCreateGlobalRef } - let javaClassLocalRef = try jni.GetObjectClass(obj: instance) - let javaClass = jni.NewGlobalRef(javaClassLocalRef) try checkAndThrowOnJNIError() - self.javaClass = javaClass! self.instance = globalInstanceRef } + @available(*, deprecated, message: "Override Self.className instead and use the initializers that don't take className as an argument") convenience public init(_ className: String, arguments: [JavaParameterConvertible] = []) throws { let className = className.replacingFullstopsWithSlashes() let javaClassLocalRef = try jni.FindClass(name: className) @@ -29,22 +48,39 @@ open class JNIObject { try self.init(instanceLocalRef) } + convenience public init(arguments: JavaParameterConvertible...) throws { + guard let instanceLocalRef = try jni.callConstructor(on: type(of: self).javaClass, arguments: arguments) else { + throw Error.couldntCallConstructor + } + + try self.init(instanceLocalRef) + } + deinit { jni.DeleteGlobalRef(instance) - jni.DeleteGlobalRef(javaClass) } public func call(methodName: String, arguments: [JavaParameterConvertible] = []) throws { try jni.call(methodName, on: self.instance, arguments: arguments) } - public func call(methodName: String, arguments: [JavaParameterConvertible] = []) throws -> T { + public func call( + methodName: String, + arguments: [JavaParameterConvertible] = [] + ) throws -> T { return try jni.call(methodName, on: self.instance, arguments: arguments) } - public func callStatic(methodName: String, arguments: [JavaParameterConvertible] = []) throws { + public static func callStatic(methodName: String, arguments: [JavaParameterConvertible] = []) throws { try jni.callStatic(methodName, on: self.javaClass, arguments: arguments) } + + public static func callStatic( + methodName: String, + arguments: [JavaParameterConvertible] = [] + ) throws -> T { + return try jni.callStatic(methodName, on: self.javaClass, arguments: arguments) + } } extension JNIObject { @@ -55,7 +91,10 @@ extension JNIObject { } extension JNI { - func callConstructor(on targetClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> JavaObject? { + func callConstructor( + on targetClass: JavaClass, + arguments: [JavaParameterConvertible] = [] + ) throws -> JavaObject? { let methodID = _env.pointee.pointee.GetMethodID(_env, targetClass, "", arguments.methodSignature(returnType: nil)) try checkAndThrowOnJNIError() @@ -64,19 +103,19 @@ extension JNI { } public extension JNI { - public func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) throws -> JavaObject? { - let env = self._env + func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) throws -> JavaObject? { + let env = self._env var mutableArgs = args let newObject = env.pointee.pointee.NewObject(env, targetClass, methodID, &mutableArgs) try checkAndThrowOnJNIError() return newObject - } + } - public func GetObjectClass(obj: JavaObject) throws -> JavaClass { - let env = self._env + func GetObjectClass(obj: JavaObject) throws -> JavaClass { + let env = self._env let result = env.pointee.pointee.GetObjectClass(env, obj) try checkAndThrowOnJNIError() return result! - } + } } From 1a4cf547facd2878d1c98835523e318a7a8a77f8 Mon Sep 17 00:00:00 2001 From: Michael Knoch Date: Thu, 22 Aug 2019 14:23:38 +0200 Subject: [PATCH 65/84] prevent CallObjectMethod from crashing (#15) --- Sources/JNI/JNIMethods.swift | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 37414c4..635e910 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -142,9 +142,9 @@ extension JNI { public func CallObjectMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaObject { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallObjectMethod(_env, object, method, &methodArgs)! + let result = _env.pointee.pointee.CallObjectMethod(_env, object, method, &methodArgs) try checkAndThrowOnJNIError() - return result + return result! } } From a765442965fa367b2c12505b3811a5531d7f7ef4 Mon Sep 17 00:00:00 2001 From: Michael Knoch Date: Tue, 14 Jan 2020 16:33:49 +0100 Subject: [PATCH 66/84] Swift5 (#16) * Update for Swift5 * Comment out johnno hack (fixes crash at runtime) * Remove unneeded soname * set CMAKE_Swift_MODULE_DIRECTORY Co-authored-by: Geordie J --- CMakeLists.txt | 3 + Sources/JNI/CMakeLists.txt | 26 +++++++++ Sources/JNI/JNI.swift | 12 ++-- Sources/JNI/JNIClassManipulation.swift | 16 +++--- Sources/JNI/JNIExceptions.swift | 14 ++--- Sources/JNI/JNIFields.swift | 28 +++++----- Sources/JNI/JNIMethods.swift | 56 +++++++++---------- Sources/JNI/JNIRefs.swift | 24 ++++---- Sources/JNI/JNIStrings.swift | 24 ++++---- .../JavaParameterConvertible+Primitives.swift | 2 +- Sources/JNI/SwiftJNI.swift | 32 +++++------ 11 files changed, 133 insertions(+), 104 deletions(-) create mode 100644 CMakeLists.txt create mode 100644 Sources/JNI/CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..ad3af33 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,3 @@ +project(SwiftJNI LANGUAGES C Swift) + +add_subdirectory(Sources/JNI) diff --git a/Sources/JNI/CMakeLists.txt b/Sources/JNI/CMakeLists.txt new file mode 100644 index 0000000..629454b --- /dev/null +++ b/Sources/JNI/CMakeLists.txt @@ -0,0 +1,26 @@ +set(CMAKE_Swift_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/swift) + +add_library(JNI SHARED + Array+JavaParameterConvertible.swift + JavaParameterConvertible+Objects.swift + JavaParameterConvertible+Primitives.swift + JavaParameterConvertible.swift + JNI.swift + JNIClassManipulation.swift + JNIExceptions.swift + JNIFields.swift + JNIMethods.swift + JNIObjects.swift + JNIRefs.swift + JNIStrings.swift + SwiftJNI.swift +) + +set_target_properties(JNI PROPERTIES + INTERFACE_LINK_DIRECTORIES $ + INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY}) + +target_compile_options(JNI PUBLIC + SHELL: -I ${SwiftJNI_SOURCE_DIR}/Sources/CJNI) + +# TODO Add ${SwiftJNI_SOURCE_DIR}/Sources/CJNI to interface include dirs? diff --git a/Sources/JNI/JNI.swift b/Sources/JNI/JNI.swift index 810d227..4dba25a 100644 --- a/Sources/JNI/JNI.swift +++ b/Sources/JNI/JNI.swift @@ -35,32 +35,32 @@ public class JNI { } public extension JNI { - public func GetVersion() -> JavaInt { + func GetVersion() -> JavaInt { let env = self._env return env.pointee.pointee.GetVersion(env) } - public func GetJavaVM(vm: UnsafeMutablePointer>) -> JavaInt { + func GetJavaVM(vm: UnsafeMutablePointer>) -> JavaInt { let env = self._env return env.pointee.pointee.GetJavaVM(env, vm) } - public func RegisterNatives(targetClass: JavaClass, _ methods: UnsafePointer, _ nMethods: JavaInt) -> JavaInt { + func RegisterNatives(targetClass: JavaClass, _ methods: UnsafePointer, _ nMethods: JavaInt) -> JavaInt { let env = self._env return env.pointee.pointee.RegisterNatives(env, targetClass, methods, nMethods) } - public func UnregisterNatives(targetClass: JavaClass) -> JavaInt { + func UnregisterNatives(targetClass: JavaClass) -> JavaInt { let env = self._env return env.pointee.pointee.UnregisterNatives(env, targetClass) } - public func MonitorEnter(obj: JavaObject) -> JavaInt { + func MonitorEnter(obj: JavaObject) -> JavaInt { let env = self._env return env.pointee.pointee.MonitorEnter(env, obj) } - public func MonitorExit(obj: JavaObject) -> JavaInt { + func MonitorExit(obj: JavaObject) -> JavaInt { let env = self._env return env.pointee.pointee.MonitorExit(env, obj) } diff --git a/Sources/JNI/JNIClassManipulation.swift b/Sources/JNI/JNIClassManipulation.swift index 32d1f93..f07eafc 100644 --- a/Sources/JNI/JNIClassManipulation.swift +++ b/Sources/JNI/JNIClassManipulation.swift @@ -1,44 +1,44 @@ import CJNI public extension JNI { - // public func DefineClass(name: String, _ loader: JavaObject, _ buffer: UnsafePointer, _ bufferLength: jsize) -> JavaClass { + // func DefineClass(name: String, _ loader: JavaObject, _ buffer: UnsafePointer, _ bufferLength: jsize) -> JavaClass { // let env = self._env // return env.pointee.pointee.DefineClass(env, name, loader, buffer, bufferLength)! // } - public func FindClass(name: String) throws -> JavaClass { + func FindClass(name: String) throws -> JavaClass { let env = self._env let result = env.pointee.pointee.FindClass(env, name.replacingFullstopsWithSlashes()) try checkAndThrowOnJNIError() return result! } - public func FromReflectedMethod(method: JavaObject) -> JavaMethodID { + func FromReflectedMethod(method: JavaObject) -> JavaMethodID { let env = self._env return env.pointee.pointee.FromReflectedMethod(env, method)! } - public func FromReflectedField(field: JavaObject) -> JavaFieldID { + func FromReflectedField(field: JavaObject) -> JavaFieldID { let env = self._env return env.pointee.pointee.FromReflectedField(env, field)! } - public func ToReflectedMethod(targetClass: JavaClass, _ methodID: JavaMethodID, _ isStatic: JavaBoolean) -> JavaObject { + func ToReflectedMethod(targetClass: JavaClass, _ methodID: JavaMethodID, _ isStatic: JavaBoolean) -> JavaObject { let env = self._env return env.pointee.pointee.ToReflectedMethod(env, targetClass, methodID, isStatic)! } - public func GetSuperclass(targetClass: JavaClass) -> JavaClass { + func GetSuperclass(targetClass: JavaClass) -> JavaClass { let env = self._env return env.pointee.pointee.GetSuperclass(env, targetClass)! } - public func IsAssignableFrom(classA: JavaClass, _ classB: JavaClass) -> JavaBoolean { + func IsAssignableFrom(classA: JavaClass, _ classB: JavaClass) -> JavaBoolean { let env = self._env return env.pointee.pointee.IsAssignableFrom(env, classA, classB) } - public func ToReflectedField(targetClass: JavaClass, _ fieldID: JavaFieldID, _ isStatic: JavaBoolean) -> JavaObject { + func ToReflectedField(targetClass: JavaClass, _ fieldID: JavaFieldID, _ isStatic: JavaBoolean) -> JavaObject { let env = self._env return env.pointee.pointee.ToReflectedField(env, targetClass, fieldID, isStatic)! } diff --git a/Sources/JNI/JNIExceptions.swift b/Sources/JNI/JNIExceptions.swift index 3762194..38541ba 100644 --- a/Sources/JNI/JNIExceptions.swift +++ b/Sources/JNI/JNIExceptions.swift @@ -1,37 +1,37 @@ import CJNI public extension JNI { - public func ExceptionCheck() -> Bool { + func ExceptionCheck() -> Bool { let env = self._env return env.pointee.pointee.ExceptionCheck(env) == true } - public func ExceptionDescribe() { + func ExceptionDescribe() { let env = self._env env.pointee.pointee.ExceptionDescribe(env) } - public func ExceptionClear() { + func ExceptionClear() { let env = self._env env.pointee.pointee.ExceptionClear(env) } - public func ExceptionOccurred() -> JavaThrowable { + func ExceptionOccurred() -> JavaThrowable { let env = self._env return env.pointee.pointee.ExceptionOccurred(env)! } - public func Throw(obj: JavaThrowable) -> JavaInt { + func Throw(obj: JavaThrowable) -> JavaInt { let env = self._env return env.pointee.pointee.Throw(env, obj) } - public func ThrowNew(targetClass: JavaClass, _ message: String) -> JavaInt { + func ThrowNew(targetClass: JavaClass, _ message: String) -> JavaInt { let env = self._env return env.pointee.pointee.ThrowNew(env, targetClass, message) } - public func FatalError(msg: String) { + func FatalError(msg: String) { let env = self._env env.pointee.pointee.FatalError(env, msg) } diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index d823477..59570d6 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -8,14 +8,14 @@ import CJNI public extension JNI { - public func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { + func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { let env = self._env let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) try checkAndThrowOnJNIError() return try T.fromStaticField(fieldID!, of: javaClass) } - public func GetField(_ fieldName: String, from javaObject: JavaObject) throws -> T { + func GetField(_ fieldName: String, from javaObject: JavaObject) throws -> T { let env = self._env let javaClass = try GetObjectClass(obj: javaObject) let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) @@ -28,42 +28,42 @@ public extension JNI { public extension JNI { // MARK: Fields - public func GetBooleanField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaBoolean { + func GetBooleanField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaBoolean { let _env = self._env let result = _env.pointee.pointee.GetBooleanField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } - public func GetIntField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaInt { + func GetIntField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaInt { let _env = self._env let result = _env.pointee.pointee.GetIntField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } - public func GetFloatField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaFloat { + func GetFloatField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaFloat { let _env = self._env let result = _env.pointee.pointee.GetFloatField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } - public func GetLongField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaLong { + func GetLongField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaLong { let _env = self._env let result = _env.pointee.pointee.GetLongField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } - public func GetDoubleField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaDouble { + func GetDoubleField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaDouble { let _env = self._env let result = _env.pointee.pointee.GetDoubleField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } - public func GetObjectField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaObject { + func GetObjectField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaObject { let _env = self._env let result = _env.pointee.pointee.GetObjectField(_env, javaObject, id) try checkAndThrowOnJNIError() @@ -72,42 +72,42 @@ public extension JNI { // MARK: Static Fields - public func GetStaticBooleanField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaBoolean { + func GetStaticBooleanField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaBoolean { let _env = self._env let result = _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } - public func GetStaticIntField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaInt { + func GetStaticIntField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaInt { let _env = self._env let result = _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } - public func GetStaticFloatField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaFloat { + func GetStaticFloatField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaFloat { let _env = self._env let result = _env.pointee.pointee.GetStaticFloatField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } - public func GetStaticLongField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaLong { + func GetStaticLongField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaLong { let _env = self._env let result = _env.pointee.pointee.GetStaticLongField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } - public func GetStaticDoubleField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaDouble { + func GetStaticDoubleField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaDouble { let _env = self._env let result = _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } - public func GetStaticObjectField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaObject { + func GetStaticObjectField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaObject { let _env = self._env guard let result = _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) else { throw JNIError() } try checkAndThrowOnJNIError() diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 635e910..2ba9926 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -2,24 +2,24 @@ import CJNI struct InvalidMethodID: Error {} -extension JNI { +public extension JNI { // MARK: Static Methods - public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws { + func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws { let methodSignature = arguments.methodSignature(returnType: nil) let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) try jni.CallStaticVoidMethod(javaClass: javaClass, method: methodID, parameters: arguments.asJavaParameters()) } - public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> T { + func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> T { let methodSignature = arguments.methodSignature(returnType: T.self) let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) return try T.fromStaticMethod(calling: methodID, on: javaClass, args: arguments.asJavaParameters()) } - public func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = [], returningObjectType objectType: String) throws -> JavaObject { + func callStatic(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = [], returningObjectType objectType: String) throws -> JavaObject { let methodSignature = arguments.methodSignature(customReturnType: "L" + objectType + ";") let methodID = try jni.GetStaticMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) @@ -28,28 +28,28 @@ extension JNI { // MARK: Instance/Object Methods - public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = []) throws { + func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = []) throws { let methodSignature = arguments.methodSignature(returnType: nil) let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) return try jni.CallVoidMethod(methodID, on: object, parameters: arguments.asJavaParameters()) } - public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = []) throws -> T { + func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = []) throws -> T { let methodSignature = arguments.methodSignature(returnType: T.self) let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) return try T.fromMethod(calling: methodID, on: object, args: arguments.asJavaParameters()) } - public func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = [], returningObjectType objectType: String) throws -> JavaObject { + func call(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = [], returningObjectType objectType: String) throws -> JavaObject { let methodSignature = arguments.methodSignature(customReturnType: "L" + objectType + ";") let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) return try jni.CallObjectMethod(methodID, on: object, parameters: arguments.asJavaParameters()) } - public func call(_ methodName: String, on object: JavaObject, with arguments: [JavaParameterConvertible]) throws -> [String] { + func call(_ methodName: String, on object: JavaObject, with arguments: [JavaParameterConvertible]) throws -> [String] { let methodSignature = arguments.methodSignature(customReturnType: "[" + String.asJNIParameterString) let methodID = try jni.GetMethodID(for: object, methodName: methodName, methodSignature: methodSignature) let returnedArray = try jni.CallObjectMethod(methodID, on: object, parameters: arguments.asJavaParameters()) @@ -65,8 +65,8 @@ extension JNI { // MARK: Getting Method IDs -extension JNI { - public func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID { +public extension JNI { + func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID { let _env = self._env let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) try checkAndThrowOnJNIError() @@ -78,7 +78,7 @@ extension JNI { return result! } - public func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID { + func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID { let _env = self._env guard let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) else { throw InvalidMethodID() @@ -91,15 +91,15 @@ extension JNI { // MARK: Call instance methods -extension JNI { - public func CallVoidMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws { +public extension JNI { + func CallVoidMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws { let _env = self._env var methodArgs = parameters _env.pointee.pointee.CallVoidMethod(_env, object, method, &methodArgs) try checkAndThrowOnJNIError() } - public func CallBooleanMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaBoolean { + func CallBooleanMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaBoolean { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallBooleanMethod(_env, object, method, &methodArgs) @@ -107,7 +107,7 @@ extension JNI { return result } - public func CallIntMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaInt { + func CallIntMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaInt { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallIntMethod(_env, object, method, &methodArgs) @@ -115,7 +115,7 @@ extension JNI { return result } - public func CallFloatMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaFloat { + func CallFloatMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaFloat { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallFloatMethod(_env, object, method, &methodArgs) @@ -123,7 +123,7 @@ extension JNI { return result } - public func CallLongMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaLong { + func CallLongMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaLong { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallLongMethod(_env, object, method, &methodArgs) @@ -131,7 +131,7 @@ extension JNI { return result } - public func CallDoubleMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaDouble { + func CallDoubleMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaDouble { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallDoubleMethod(_env, object, method, &methodArgs) @@ -139,7 +139,7 @@ extension JNI { return result } - public func CallObjectMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaObject { + func CallObjectMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaObject { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallObjectMethod(_env, object, method, &methodArgs) @@ -151,8 +151,8 @@ extension JNI { // MARK: Static methods -extension JNI { - public func CallStaticObjectMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaObject { +public extension JNI { + func CallStaticObjectMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaObject { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallStaticObjectMethodA(_env, javaClass, method, &methodArgs) @@ -160,7 +160,7 @@ extension JNI { return result! // we checked for error in the line above } - public func CallStaticBooleanMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> Bool { + func CallStaticBooleanMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> Bool { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) @@ -168,7 +168,7 @@ extension JNI { return result == true } - public func CallStaticIntMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaInt { + func CallStaticIntMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaInt { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) @@ -176,7 +176,7 @@ extension JNI { return result } - public func CallStaticLongMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaLong { + func CallStaticLongMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaLong { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallStaticLongMethodA(_env, javaClass, method, &methodArgs) @@ -184,7 +184,7 @@ extension JNI { return result } - public func CallStaticFloatMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaFloat { + func CallStaticFloatMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaFloat { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallStaticFloatMethodA(_env, javaClass, method, &methodArgs) @@ -192,7 +192,7 @@ extension JNI { return result } - public func CallStaticDoubleMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaDouble { + func CallStaticDoubleMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaDouble { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallStaticDoubleMethodA(_env, javaClass, method, &methodArgs) @@ -200,7 +200,7 @@ extension JNI { return result } - public func CallStaticBooleanMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws -> JavaBoolean { + func CallStaticBooleanMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws -> JavaBoolean { let _env = self._env var methodArgs = parameters let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) @@ -208,7 +208,7 @@ extension JNI { return result } - public func CallStaticVoidMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws { + func CallStaticVoidMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws { let _env = self._env var methodArgs = parameters _env.pointee.pointee.CallStaticVoidMethodA(_env, javaClass, method, &methodArgs) diff --git a/Sources/JNI/JNIRefs.swift b/Sources/JNI/JNIRefs.swift index e15de76..fe2e738 100644 --- a/Sources/JNI/JNIRefs.swift +++ b/Sources/JNI/JNIRefs.swift @@ -1,63 +1,63 @@ import CJNI public extension JNI { - public func NewGlobalRef(_ object: JavaObject) -> JavaObject? { + func NewGlobalRef(_ object: JavaObject) -> JavaObject? { let env = self._env return env.pointee.pointee.NewGlobalRef(env, object) } - public func DeleteGlobalRef(_ globalRef: JavaObject) { + func DeleteGlobalRef(_ globalRef: JavaObject) { let env = self._env env.pointee.pointee.DeleteGlobalRef(env, globalRef) } - public func NewLocalRef(_ ref: JavaObject) -> JavaObject? { + func NewLocalRef(_ ref: JavaObject) -> JavaObject? { let env = self._env return env.pointee.pointee.NewLocalRef(env, ref) } - public func DeleteLocalRef(_ localRef: JavaObject) { + func DeleteLocalRef(_ localRef: JavaObject) { let env = self._env env.pointee.pointee.DeleteLocalRef(env, localRef) } - public func PushLocalFrame(_ capacity: JavaInt) -> JavaInt { + func PushLocalFrame(_ capacity: JavaInt) -> JavaInt { let env = self._env return env.pointee.pointee.PushLocalFrame(env, capacity) } - public func PopLocalFrame(_ result: JavaObject) -> JavaObject { + func PopLocalFrame(_ result: JavaObject) -> JavaObject { let env = self._env return env.pointee.pointee.PopLocalFrame(env, result)! } - public func EnsureLocalCapacity(_ capacity: JavaInt) -> JavaInt { + func EnsureLocalCapacity(_ capacity: JavaInt) -> JavaInt { let env = self._env return env.pointee.pointee.EnsureLocalCapacity(env, capacity) } - public func IsSameObject(_ ref1: JavaObject, _ ref2: JavaObject) -> JavaBoolean { + func IsSameObject(_ ref1: JavaObject, _ ref2: JavaObject) -> JavaBoolean { let env = self._env return env.pointee.pointee.IsSameObject(env, ref1, ref2) } - public func IsInstanceOf(_ obj: JavaObject, _ targetClass: JavaClass) -> JavaBoolean { + func IsInstanceOf(_ obj: JavaObject, _ targetClass: JavaClass) -> JavaBoolean { let env = self._env return env.pointee.pointee.IsInstanceOf(env, obj, targetClass) } - public func NewWeakGlobalRef(_ obj: JavaObject) -> JavaWeakReference { + func NewWeakGlobalRef(_ obj: JavaObject) -> JavaWeakReference { let env = self._env return env.pointee.pointee.NewWeakGlobalRef(env, obj)! } - public func DeleteWeakGlobalRef(_ obj: JavaWeakReference) { + func DeleteWeakGlobalRef(_ obj: JavaWeakReference) { let env = self._env env.pointee.pointee.DeleteWeakGlobalRef(env, obj) } /* added in 1: JNI.6 */ - public func GetObjectRefType(_ obj: JavaObject) -> JavaObjectRefType { + func GetObjectRefType(_ obj: JavaObject) -> JavaObjectRefType { let env = self._env return env.pointee.pointee.GetObjectRefType(env, obj) } diff --git a/Sources/JNI/JNIStrings.swift b/Sources/JNI/JNIStrings.swift index a733a9f..68d1c47 100644 --- a/Sources/JNI/JNIStrings.swift +++ b/Sources/JNI/JNIStrings.swift @@ -31,62 +31,62 @@ public extension String { } public extension JNI { - public func NewString(unicodeChars: UnsafePointer, _ length: jsize) -> JavaString { + func NewString(unicodeChars: UnsafePointer, _ length: jsize) -> JavaString { let env = self._env return env.pointee.pointee.NewString(env, unicodeChars, length)! } - public func GetStringLength(_ jString: JavaString) -> jsize { + func GetStringLength(_ jString: JavaString) -> jsize { let env = self._env return env.pointee.pointee.GetStringLength(env, jString) } - public func GetStringChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { + func GetStringChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env return env.pointee.pointee.GetStringChars(env, jString, isCopy)! } - public func ReleaseStringChars(_ jString: JavaString, _ chars: UnsafePointer) { + func ReleaseStringChars(_ jString: JavaString, _ chars: UnsafePointer) { let env = self._env env.pointee.pointee.ReleaseStringChars(env, jString, chars) } - public func NewStringUTF(_ string: String) -> JavaString { + func NewStringUTF(_ string: String) -> JavaString { let env = self._env return env.pointee.pointee.NewStringUTF(env, string)! } - public func GetStringUTFLength(_ jString: JavaString) -> jsize { + func GetStringUTFLength(_ jString: JavaString) -> jsize { let env = self._env return env.pointee.pointee.GetStringUTFLength(env, jString) } - public func GetStringUTFChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> String { + func GetStringUTFChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> String { let env = self._env return String(describing: env.pointee.pointee.GetStringUTFChars(env, jString, isCopy)) } - public func ReleaseStringUTFChars(_ jString: JavaString, _ utf: String) { + func ReleaseStringUTFChars(_ jString: JavaString, _ utf: String) { let env = self._env env.pointee.pointee.ReleaseStringUTFChars(env, jString, utf) } - public func GetStringRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { + func GetStringRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { let env = self._env env.pointee.pointee.GetStringRegion(env, jString, start, length, buf) } - public func GetStringUTFRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { + func GetStringUTFRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { let env = self._env env.pointee.pointee.GetStringUTFRegion(env, jString, start, length, buf) } - public func GetStringCritical(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { + func GetStringCritical(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env return env.pointee.pointee.GetStringCritical(env, jString, isCopy)! } - public func ReleaseStringCritical(_ jString: JavaString, _ cArray: UnsafePointer) { + func ReleaseStringCritical(_ jString: JavaString, _ cArray: UnsafePointer) { let env = self._env env.pointee.pointee.ReleaseStringCritical(env, jString, cArray) } diff --git a/Sources/JNI/JavaParameterConvertible+Primitives.swift b/Sources/JNI/JavaParameterConvertible+Primitives.swift index ef02671..2799cbb 100644 --- a/Sources/JNI/JavaParameterConvertible+Primitives.swift +++ b/Sources/JNI/JavaParameterConvertible+Primitives.swift @@ -28,7 +28,7 @@ extension Bool: JavaParameterConvertible, JavaInitializableFromMethod, JavaIniti // JavaInt extension JavaInt: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { - public static var asJNIParameterString = "I" + public static let asJNIParameterString = "I" public func toJavaParameter() -> JavaParameter { return JavaParameter(int: self) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 8ffbece..0b4e155 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -12,8 +12,8 @@ public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutabl jni = localJNI // set the global for use elsewhere #if os(Android) - DispatchQueue.drainingMainQueue = true - DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) + // DispatchQueue.drainingMainQueue = true + // DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) #endif return JNI_VERSION_1_6 @@ -30,15 +30,15 @@ extension JavaBoolean : ExpressibleByBooleanLiteral { } // SwiftJNI Public API -extension JNI { - public func RegisterNatives(javaClass: JavaClass, methods: [JNINativeMethod]) -> Bool { +public extension JNI { + func RegisterNatives(javaClass: JavaClass, methods: [JNINativeMethod]) -> Bool { let _env = self._env let env = _env.pointee.pointee let result = env.RegisterNatives(_env, javaClass, methods, JavaInt(methods.count)) return (result == 0) } - public func ThrowNew(message: String) { + func ThrowNew(message: String) { let _env = self._env let env = _env.pointee.pointee _ = env.ThrowNew(_env, env.FindClass(_env, "java/lang/Exception"), message) @@ -46,20 +46,20 @@ extension JNI { // MARK: Arrays - public func GetLength(_ array: JavaArray) -> Int { + func GetLength(_ array: JavaArray) -> Int { let _env = self._env let result = _env.pointee.pointee.GetArrayLength(_env, array) return Int(result) } - public func NewIntArray(count: Int) throws -> JavaArray? { + func NewIntArray(count: Int) throws -> JavaArray? { let _env = self._env let result = _env.pointee.pointee.NewIntArray(_env, jsize(count)) try checkAndThrowOnJNIError() return result } - public func GetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, numElements: Int = -1) -> [UInt8] { + func GetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, numElements: Int = -1) -> [UInt8] { let _env = self._env var count = numElements @@ -75,13 +75,13 @@ extension JNI { return result.map { UInt8(bitPattern: $0) } } - public func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: [Int]) { + func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: [Int]) { let _env = self._env var newElements = sourceElements.map { JavaByte($0) } // make mutable copy _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } - public func GetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, numElements: Int = -1) -> [JavaInt] { + func GetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, numElements: Int = -1) -> [JavaInt] { let _env = self._env var count = numElements @@ -94,20 +94,20 @@ extension JNI { return result } - public func SetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, from sourceElements: [Int]) { + func SetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, from sourceElements: [Int]) { let _env = self._env var newElements = sourceElements.map { JavaInt($0) } // make mutable copy _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } - public func NewFloatArray(count: Int) throws -> JavaArray? { + func NewFloatArray(count: Int) throws -> JavaArray? { let _env = self._env let result = _env.pointee.pointee.NewFloatArray(_env, jsize(count)) try checkAndThrowOnJNIError() return result } - public func GetFloatArrayRegion(array: JavaFloatArray, startIndex: Int = 0, numElements: Int = -1) -> [Float] { + func GetFloatArrayRegion(array: JavaFloatArray, startIndex: Int = 0, numElements: Int = -1) -> [Float] { let _env = self._env var count = numElements @@ -120,13 +120,13 @@ extension JNI { return result.map { Float($0) } } - public func SetFloatArrayRegion(array: JavaFloatArray, startIndex: Int = 0, from sourceElements: [Float]) { + func SetFloatArrayRegion(array: JavaFloatArray, startIndex: Int = 0, from sourceElements: [Float]) { let _env = self._env var newElements = sourceElements.map { JavaFloat($0) } // make mutable copy _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } - public func GetStrings(from array: JavaObjectArray) throws -> [String] { + func GetStrings(from array: JavaObjectArray) throws -> [String] { let _env = self._env let count = jni.GetLength(array) @@ -142,7 +142,7 @@ extension JNI { return strings } - public func GetObjectArrayElement(in array: JavaObjectArray, at index: Int) throws -> JavaObject { + func GetObjectArrayElement(in array: JavaObjectArray, at index: Int) throws -> JavaObject { let _env = self._env let count = jni.GetLength(array) if (index >= count) { From 33d2997355dfb782755373ae5eec8a59bc19b3f3 Mon Sep 17 00:00:00 2001 From: Erik Werner Date: Thu, 15 Oct 2020 12:20:43 +0200 Subject: [PATCH 67/84] implement JNIObject.getField(), fix threading bug (#17) implement JNIObject.getField() make methodSignature() and asJavaParameters() public fix threading bug in JNIObject.javaClass --- .../JNI/Array+JavaParameterConvertible.swift | 6 +++--- Sources/JNI/JNIFields.swift | 3 +++ Sources/JNI/JNIObjects.swift | 18 +++++++++++++++++- 3 files changed, 23 insertions(+), 4 deletions(-) diff --git a/Sources/JNI/Array+JavaParameterConvertible.swift b/Sources/JNI/Array+JavaParameterConvertible.swift index be25390..7d06482 100644 --- a/Sources/JNI/Array+JavaParameterConvertible.swift +++ b/Sources/JNI/Array+JavaParameterConvertible.swift @@ -15,7 +15,7 @@ extension String { } extension Array where Element == JavaParameterConvertible { - func asJavaParameters() -> [JavaParameter] { + public func asJavaParameters() -> [JavaParameter] { return self.map { $0.toJavaParameter() } } @@ -27,12 +27,12 @@ extension Array where Element == JavaParameterConvertible { /// Returns the String of ordered arguments enclosed in brackets, followed by the `returnType`'s type string, or 'V' /// (Void) if nil is provided. e.g. Returns "(II)V" for `[JavaInt(1), JavaInt(99)].methodSignature(returnType: nil)` - func methodSignature(returnType: JavaParameterConvertible.Type?) -> String { + public func methodSignature(returnType: JavaParameterConvertible.Type?) -> String { let returnTypeString = returnType?.asJNIParameterString ?? "V" return "(" + self.argumentSignature() + ")" + returnTypeString } - func methodSignature(customReturnType: String) -> String { + public func methodSignature(customReturnType: String) -> String { let returnTypeString = customReturnType.replacingFullstopsWithSlashes() return "(" + self.argumentSignature() + ")" + returnTypeString } diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index 59570d6..c470bec 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -18,6 +18,9 @@ public extension JNI { func GetField(_ fieldName: String, from javaObject: JavaObject) throws -> T { let env = self._env let javaClass = try GetObjectClass(obj: javaObject) + defer { + jni.DeleteLocalRef(javaClass) + } let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) try checkAndThrowOnJNIError() return try T.fromField(fieldID!, on: javaObject) diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 92ec789..476c9c8 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,5 +1,6 @@ import CJNI import Dispatch +import Foundation /// Designed to simplify calling a constructor and methods on a JavaClass /// Subclass this and add the methods appropriate to the object you are constructing. @@ -11,7 +12,7 @@ open class JNIObject { private static var classInstances = [String: JavaClass]() public static var javaClass: JavaClass { - return DispatchQueue.main.sync { + func getClassInstance() -> JavaClass { if let classInstance = classInstances[className] { return classInstance } @@ -23,6 +24,15 @@ open class JNIObject { return classInstance } + + if Thread.isMainThread { + return getClassInstance() + } else { + return DispatchQueue.main.sync { + return getClassInstance() + } + } + } public let instance: JavaObject @@ -71,6 +81,12 @@ open class JNIObject { return try jni.call(methodName, on: self.instance, arguments: arguments) } + public func getField( + _ fieldName: String + ) throws -> T { + return try jni.GetField(fieldName, from: self.instance) + } + public static func callStatic(methodName: String, arguments: [JavaParameterConvertible] = []) throws { try jni.callStatic(methodName, on: self.javaClass, arguments: arguments) } From bf6249d18b362e0f08250bebd742ebb9a3627aff Mon Sep 17 00:00:00 2001 From: Erik Werner Date: Mon, 15 Mar 2021 12:22:15 +0100 Subject: [PATCH 68/84] API Enhancements: JNI.GetDirectBufferAddress() and JNIObject.getField() (#18) --- Sources/JNI/JNI.swift | 5 +++++ Sources/JNI/JNIFields.swift | 11 +++++++++++ Sources/JNI/JNIObjects.swift | 4 ++++ 3 files changed, 20 insertions(+) diff --git a/Sources/JNI/JNI.swift b/Sources/JNI/JNI.swift index 4dba25a..b954f27 100644 --- a/Sources/JNI/JNI.swift +++ b/Sources/JNI/JNI.swift @@ -64,4 +64,9 @@ public extension JNI { let env = self._env return env.pointee.pointee.MonitorExit(env, obj) } + + func GetDirectBufferAddress(buffer: JavaObject) -> UnsafeMutableRawPointer? { + let env = self._env + return env.pointee.pointee.GetDirectBufferAddress(env, buffer) + } } diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index c470bec..c52425f 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -25,6 +25,17 @@ public extension JNI { try checkAndThrowOnJNIError() return try T.fromField(fieldID!, on: javaObject) } + + func GetField(_ fieldName: String, fieldJavaClassName: String, from javaObject: JavaObject) throws -> JavaObject { + let env = self._env + let javaClass = try GetObjectClass(obj: javaObject) + defer { + jni.DeleteLocalRef(javaClass) + } + let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, "L\(fieldJavaClassName);") + try checkAndThrowOnJNIError() + return try JavaObject.fromField(fieldID!, on: javaObject) + } } diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 476c9c8..8242333 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -87,6 +87,10 @@ open class JNIObject { return try jni.GetField(fieldName, from: self.instance) } + public func getField(_ fieldName: String, fieldJavaClassName: String) throws -> JavaObject { + return try jni.GetField(fieldName, fieldJavaClassName: fieldJavaClassName, from: self.instance) + } + public static func callStatic(methodName: String, arguments: [JavaParameterConvertible] = []) throws { try jni.callStatic(methodName, on: self.javaClass, arguments: arguments) } From 450e0bab795211875b6e7c0e7551a0a3ddda2716 Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Wed, 10 Nov 2021 19:36:21 +0000 Subject: [PATCH 69/84] Remove dependency on Foundation / CoreFoundation --- JNI.xcodeproj/project.pbxproj | 5 + Sources/CJNI/cjni.c | 1 - Sources/CJNI/include/cjni.h | 2 + Sources/CJNI/include/is-main-thread.h | 1 + Sources/CJNI/include/jni.h | 7 +- Sources/CJNI/include/module.modulemap | 2 +- Sources/CJNI/is-main-thread.c | 11 ++ .../JNI/Array+JavaParameterConvertible.swift | 3 +- Sources/JNI/CMakeLists.txt | 1 + Sources/JNI/JNIObjects.swift | 3 +- Sources/JNI/JNIStrings.swift | 121 ++++++++---------- Sources/JNI/isMainThread.swift | 3 + 12 files changed, 82 insertions(+), 78 deletions(-) delete mode 100644 Sources/CJNI/cjni.c create mode 100644 Sources/CJNI/include/cjni.h create mode 100644 Sources/CJNI/include/is-main-thread.h create mode 100644 Sources/CJNI/is-main-thread.c create mode 100644 Sources/JNI/isMainThread.swift diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index 3f5cdb3..ee032f0 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -8,6 +8,7 @@ /* Begin PBXBuildFile section */ 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */ = {isa = PBXBuildFile; fileRef = 034A7B8D1F30D18A0071A850 /* JNIFields.swift */; }; + 5C1AD870273C494F00195C8A /* isMainThread.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5C1AD86F273C494F00195C8A /* isMainThread.swift */; }; 5CFFF4352016125500D989BC /* JavaParameterConvertible+Objects.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CFFF4332016125400D989BC /* JavaParameterConvertible+Objects.swift */; }; 5CFFF4362016125500D989BC /* JavaParameterConvertible+Primitives.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CFFF4342016125500D989BC /* JavaParameterConvertible+Primitives.swift */; }; OBJ_33 /* Array+JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_14 /* Array+JavaParameterConvertible.swift */; }; @@ -36,6 +37,7 @@ /* Begin PBXFileReference section */ 034A7B8D1F30D18A0071A850 /* JNIFields.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIFields.swift; sourceTree = ""; }; + 5C1AD86F273C494F00195C8A /* isMainThread.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = isMainThread.swift; sourceTree = ""; }; 5CFFF4332016125400D989BC /* JavaParameterConvertible+Objects.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "JavaParameterConvertible+Objects.swift"; sourceTree = ""; }; 5CFFF4342016125500D989BC /* JavaParameterConvertible+Primitives.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "JavaParameterConvertible+Primitives.swift"; sourceTree = ""; }; "JNI::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; @@ -98,6 +100,7 @@ 5CFFF4332016125400D989BC /* JavaParameterConvertible+Objects.swift */, 5CFFF4342016125500D989BC /* JavaParameterConvertible+Primitives.swift */, OBJ_23 /* SwiftJNI.swift */, + 5C1AD86F273C494F00195C8A /* isMainThread.swift */, ); name = JNI; path = Sources/JNI; @@ -197,6 +200,7 @@ developmentRegion = English; hasScannedForEncodings = 0; knownRegions = ( + English, en, ); mainGroup = OBJ_5; @@ -223,6 +227,7 @@ OBJ_37 /* JNIMethods.swift in Sources */, 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */, OBJ_38 /* JNIObjects.swift in Sources */, + 5C1AD870273C494F00195C8A /* isMainThread.swift in Sources */, 5CFFF4362016125500D989BC /* JavaParameterConvertible+Primitives.swift in Sources */, OBJ_39 /* JNIRefs.swift in Sources */, OBJ_40 /* JNIStrings.swift in Sources */, diff --git a/Sources/CJNI/cjni.c b/Sources/CJNI/cjni.c deleted file mode 100644 index 8b13789..0000000 --- a/Sources/CJNI/cjni.c +++ /dev/null @@ -1 +0,0 @@ - diff --git a/Sources/CJNI/include/cjni.h b/Sources/CJNI/include/cjni.h new file mode 100644 index 0000000..38a0d05 --- /dev/null +++ b/Sources/CJNI/include/cjni.h @@ -0,0 +1,2 @@ +#include "is-main-thread.h" +#include "jni.h" \ No newline at end of file diff --git a/Sources/CJNI/include/is-main-thread.h b/Sources/CJNI/include/is-main-thread.h new file mode 100644 index 0000000..4d9e204 --- /dev/null +++ b/Sources/CJNI/include/is-main-thread.h @@ -0,0 +1 @@ +int _isMainThread(void); \ No newline at end of file diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index be415dd..22f6a37 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -21,12 +21,15 @@ * Everything here is expected to be VM-neutral. */ -#define SWIFT_UNAVAILABLE(reason) __attribute__((unavailable(#reason))) -#define CF_SWIFT_NAME(x) __attribute__((swift_name(#x))) #ifndef JNI_H_ #define JNI_H_ +#define SWIFT_UNAVAILABLE(reason) __attribute__((unavailable(#reason))) +#define CF_SWIFT_NAME(x) __attribute__((swift_name(#x))) + +int _CFIsMainThread(void); // introduces implicit dependency on CoreFoundation + #include #include diff --git a/Sources/CJNI/include/module.modulemap b/Sources/CJNI/include/module.modulemap index da22ce8..86fca51 100644 --- a/Sources/CJNI/include/module.modulemap +++ b/Sources/CJNI/include/module.modulemap @@ -1,4 +1,4 @@ module CJNI { - header "jni.h" + header "cjni.h" export * } diff --git a/Sources/CJNI/is-main-thread.c b/Sources/CJNI/is-main-thread.c new file mode 100644 index 0000000..74e18a6 --- /dev/null +++ b/Sources/CJNI/is-main-thread.c @@ -0,0 +1,11 @@ +#include +#if __has_include() +#include +#else +#include +#endif // __has_include() + +// Linux / Android only: +int __isMainThread(void) { + return syscall(SYS_gettid) == getpid(); +} diff --git a/Sources/JNI/Array+JavaParameterConvertible.swift b/Sources/JNI/Array+JavaParameterConvertible.swift index 7d06482..12b44c5 100644 --- a/Sources/JNI/Array+JavaParameterConvertible.swift +++ b/Sources/JNI/Array+JavaParameterConvertible.swift @@ -6,11 +6,10 @@ // import CJNI -import Foundation extension String { func replacingFullstopsWithSlashes() -> String { - return self.replacingOccurrences(of: ".", with: "/") + return String(self.map { $0 == "." ? "/" : $0 }) } } diff --git a/Sources/JNI/CMakeLists.txt b/Sources/JNI/CMakeLists.txt index 629454b..9c23b91 100644 --- a/Sources/JNI/CMakeLists.txt +++ b/Sources/JNI/CMakeLists.txt @@ -14,6 +14,7 @@ add_library(JNI SHARED JNIRefs.swift JNIStrings.swift SwiftJNI.swift + isMainThread.swift ) set_target_properties(JNI PROPERTIES diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 8242333..124b090 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,6 +1,5 @@ import CJNI import Dispatch -import Foundation /// Designed to simplify calling a constructor and methods on a JavaClass /// Subclass this and add the methods appropriate to the object you are constructing. @@ -25,7 +24,7 @@ open class JNIObject { return classInstance } - if Thread.isMainThread { + if isMainThread { return getClassInstance() } else { return DispatchQueue.main.sync { diff --git a/Sources/JNI/JNIStrings.swift b/Sources/JNI/JNIStrings.swift index 68d1c47..0a6cb9e 100644 --- a/Sources/JNI/JNIStrings.swift +++ b/Sources/JNI/JNIStrings.swift @@ -1,93 +1,74 @@ import CJNI -import struct Foundation.Data - -public extension Data { - init?(javaString: JavaString) { - let env = jni._env - guard let chars = env.pointee.pointee.GetStringUTFChars(env, javaString, nil) else { return nil } - defer { env.pointee.pointee.ReleaseStringUTFChars(env, javaString, chars) } - - let stringLength = env.pointee.pointee.GetStringUTFLength(env, javaString) - self.init(bytes: chars, count: Int(stringLength)) - } - - /// We extend Data instead of making an initializer for JavaString because the latter is - /// just a Void pointer, which would cause confusion. - func toJavaString() -> JavaString? { - let env = jni._env - return withUnsafeBytes { env.pointee.pointee.NewStringUTF(env, $0) } - } -} public extension String { - init(javaString: JavaString) throws { - let env = jni._env - let chars = env.pointee.pointee.GetStringUTFChars(env, javaString, nil) - defer { env.pointee.pointee.ReleaseStringUTFChars(env, javaString, chars) } - try checkAndThrowOnJNIError() - - self.init(cString: chars!) - } + init(javaString: JavaString) throws { + let env = jni._env + let chars = env.pointee.pointee.GetStringUTFChars(env, javaString, nil) + defer { env.pointee.pointee.ReleaseStringUTFChars(env, javaString, chars) } + try checkAndThrowOnJNIError() + + self.init(cString: chars!) + } } public extension JNI { - func NewString(unicodeChars: UnsafePointer, _ length: jsize) -> JavaString { - let env = self._env + func NewString(unicodeChars: UnsafePointer, _ length: jsize) -> JavaString { + let env = self._env return env.pointee.pointee.NewString(env, unicodeChars, length)! - } + } - func GetStringLength(_ jString: JavaString) -> jsize { - let env = self._env - return env.pointee.pointee.GetStringLength(env, jString) - } + func GetStringLength(_ jString: JavaString) -> jsize { + let env = self._env + return env.pointee.pointee.GetStringLength(env, jString) + } - func GetStringChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { - let env = self._env + func GetStringChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { + let env = self._env return env.pointee.pointee.GetStringChars(env, jString, isCopy)! - } + } - func ReleaseStringChars(_ jString: JavaString, _ chars: UnsafePointer) { - let env = self._env - env.pointee.pointee.ReleaseStringChars(env, jString, chars) - } + func ReleaseStringChars(_ jString: JavaString, _ chars: UnsafePointer) { + let env = self._env + env.pointee.pointee.ReleaseStringChars(env, jString, chars) + } - func NewStringUTF(_ string: String) -> JavaString { - let env = self._env + func NewStringUTF(_ string: String) -> JavaString { + let env = self._env return env.pointee.pointee.NewStringUTF(env, string)! - } + } - func GetStringUTFLength(_ jString: JavaString) -> jsize { - let env = self._env - return env.pointee.pointee.GetStringUTFLength(env, jString) - } + func GetStringUTFLength(_ jString: JavaString) -> jsize { + let env = self._env + return env.pointee.pointee.GetStringUTFLength(env, jString) + } - func GetStringUTFChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> String { - let env = self._env + func GetStringUTFChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> String { + let env = self._env return String(describing: env.pointee.pointee.GetStringUTFChars(env, jString, isCopy)) - } + } - func ReleaseStringUTFChars(_ jString: JavaString, _ utf: String) { - let env = self._env - env.pointee.pointee.ReleaseStringUTFChars(env, jString, utf) - } + func ReleaseStringUTFChars(_ jString: JavaString, _ utf: String) { + let env = self._env + env.pointee.pointee.ReleaseStringUTFChars(env, jString, utf) + } - func GetStringRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { - let env = self._env - env.pointee.pointee.GetStringRegion(env, jString, start, length, buf) - } + func GetStringRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { + let env = self._env + env.pointee.pointee.GetStringRegion(env, jString, start, length, buf) + } - func GetStringUTFRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { - let env = self._env - env.pointee.pointee.GetStringUTFRegion(env, jString, start, length, buf) - } + func GetStringUTFRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { + let env = self._env + env.pointee.pointee.GetStringUTFRegion(env, jString, start, length, buf) + } - func GetStringCritical(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { - let env = self._env + func GetStringCritical(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { + let env = self._env return env.pointee.pointee.GetStringCritical(env, jString, isCopy)! - } + } - func ReleaseStringCritical(_ jString: JavaString, _ cArray: UnsafePointer) { - let env = self._env - env.pointee.pointee.ReleaseStringCritical(env, jString, cArray) - } + func ReleaseStringCritical(_ jString: JavaString, _ cArray: UnsafePointer) { + let env = self._env + env.pointee.pointee.ReleaseStringCritical(env, jString, cArray) + } } diff --git a/Sources/JNI/isMainThread.swift b/Sources/JNI/isMainThread.swift new file mode 100644 index 0000000..68da1f3 --- /dev/null +++ b/Sources/JNI/isMainThread.swift @@ -0,0 +1,3 @@ +public var isMainThread: Bool { + return _isMainThread() == 1 +} From 73895cf390a2ddaaa68441a4f6863b5a610ddc63 Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Wed, 2 Nov 2022 15:02:22 +0100 Subject: [PATCH 70/84] Add JavaParameterConvertible conformance to JNIObject --- Sources/JNI/JNIMethods.swift | 6 ++++-- Sources/JNI/JNIObjects.swift | 28 +++++++++++++++++++++++++++- Sources/JNI/SwiftJNI.swift | 17 ++++++++++++++++- 3 files changed, 47 insertions(+), 4 deletions(-) diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 2ba9926..6f4cace 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -1,6 +1,8 @@ import CJNI -struct InvalidMethodID: Error {} +enum SwiftJNIError: Error { + case invalidMethodID(_ methodSignature: String) +} public extension JNI { // MARK: Static Methods @@ -81,7 +83,7 @@ public extension JNI { func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID { let _env = self._env guard let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) else { - throw InvalidMethodID() + throw SwiftJNIError.invalidMethodID(methodSignature) } try checkAndThrowOnJNIError() diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 124b090..8e41224 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -3,11 +3,19 @@ import Dispatch /// Designed to simplify calling a constructor and methods on a JavaClass /// Subclass this and add the methods appropriate to the object you are constructing. -open class JNIObject { +open class JNIObject: JavaParameterConvertible { open class var className: String { return "java.lang.object" } + public class var asJNIParameterString: String { + "L\(Self.className.replacingFullstopsWithSlashes());" + } + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(object: self.instance) + } + private static var classInstances = [String: JavaClass]() public static var javaClass: JavaClass { @@ -138,3 +146,21 @@ public extension JNI { return result! } } + +extension JNIObject: JavaInitializableFromMethod, JavaInitializableFromField { + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Self { + return try Self(jni.GetStaticObjectField(of: javaClass, id: fieldID)) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Self { + return try Self(jni.CallObjectMethod(methodID, on: object, parameters: args)) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Self { + return try Self(jni.CallStaticObjectMethod(methodID, on: javaClass, parameters: args)) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Self { + return try Self(jni.GetObjectField(of: javaObject, id: fieldID)) + } +} \ No newline at end of file diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 0b4e155..498221c 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -59,6 +59,13 @@ public extension JNI { return result } + func NewByteArray(count: Int) throws -> JavaArray? { + let _env = self._env + let result = _env.pointee.pointee.NewByteArray(_env, jsize(count)) + try checkAndThrowOnJNIError() + return result + } + func GetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, numElements: Int = -1) -> [UInt8] { let _env = self._env var count = numElements @@ -75,7 +82,7 @@ public extension JNI { return result.map { UInt8(bitPattern: $0) } } - func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: [Int]) { + func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: UnsafeBufferPointer) { let _env = self._env var newElements = sourceElements.map { JavaByte($0) } // make mutable copy _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) @@ -246,3 +253,11 @@ struct JNIError: Error { // self.apply(args: args) // } // } + +@discardableResult +@_silgen_name("__android_log_write") +public func androidPrint(_ prio: Int32, _ tag: UnsafePointer, _ text: UnsafePointer) -> Int32 + +func print(_ string: String) { + androidPrint(5, "SwiftJNI", string) +} From b94cd3101e6d7a9334a52ca741693be3d44c7be3 Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Wed, 2 Nov 2022 20:33:02 +0100 Subject: [PATCH 71/84] Define isMainThread in Swift due to issues with building C in CMake --- Sources/CJNI/cjni.c | 0 Sources/CJNI/include/cjni.h | 11 +++++++++-- Sources/CJNI/include/is-main-thread.h | 1 - Sources/CJNI/is-main-thread.c | 11 ----------- Sources/JNI/isMainThread.swift | 7 ++++++- 5 files changed, 15 insertions(+), 15 deletions(-) create mode 100644 Sources/CJNI/cjni.c delete mode 100644 Sources/CJNI/include/is-main-thread.h delete mode 100644 Sources/CJNI/is-main-thread.c diff --git a/Sources/CJNI/cjni.c b/Sources/CJNI/cjni.c new file mode 100644 index 0000000..e69de29 diff --git a/Sources/CJNI/include/cjni.h b/Sources/CJNI/include/cjni.h index 38a0d05..160c738 100644 --- a/Sources/CJNI/include/cjni.h +++ b/Sources/CJNI/include/cjni.h @@ -1,2 +1,9 @@ -#include "is-main-thread.h" -#include "jni.h" \ No newline at end of file +#include "jni.h" + +// Syscall numbers; used in `isMainThread` +// FIXME: This exports syscall.h in its entirety, which isn't ideal. +#if __has_include() +#include +#else +#include +#endif // __has_include() diff --git a/Sources/CJNI/include/is-main-thread.h b/Sources/CJNI/include/is-main-thread.h deleted file mode 100644 index 4d9e204..0000000 --- a/Sources/CJNI/include/is-main-thread.h +++ /dev/null @@ -1 +0,0 @@ -int _isMainThread(void); \ No newline at end of file diff --git a/Sources/CJNI/is-main-thread.c b/Sources/CJNI/is-main-thread.c deleted file mode 100644 index 74e18a6..0000000 --- a/Sources/CJNI/is-main-thread.c +++ /dev/null @@ -1,11 +0,0 @@ -#include -#if __has_include() -#include -#else -#include -#endif // __has_include() - -// Linux / Android only: -int __isMainThread(void) { - return syscall(SYS_gettid) == getpid(); -} diff --git a/Sources/JNI/isMainThread.swift b/Sources/JNI/isMainThread.swift index 68da1f3..d7e84f0 100644 --- a/Sources/JNI/isMainThread.swift +++ b/Sources/JNI/isMainThread.swift @@ -1,3 +1,8 @@ +import Glibc + +@_silgen_name("syscall") +public func syscallNonVariadic(_ number: Int) -> Int + public var isMainThread: Bool { - return _isMainThread() == 1 + syscallNonVariadic(Int(SYS_gettid)) == getpid() } From c11778fcf91af0e8bce24ceb543b356399f978fd Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Wed, 2 Nov 2022 20:42:40 +0100 Subject: [PATCH 72/84] Fix Mac build --- Sources/JNI/SwiftJNI.swift | 2 ++ Sources/JNI/isMainThread.swift | 4 ++++ 2 files changed, 6 insertions(+) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 498221c..7587712 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -254,6 +254,7 @@ struct JNIError: Error { // } // } +#if os(Android) @discardableResult @_silgen_name("__android_log_write") public func androidPrint(_ prio: Int32, _ tag: UnsafePointer, _ text: UnsafePointer) -> Int32 @@ -261,3 +262,4 @@ public func androidPrint(_ prio: Int32, _ tag: UnsafePointer, _ text: Uns func print(_ string: String) { androidPrint(5, "SwiftJNI", string) } +#endif diff --git a/Sources/JNI/isMainThread.swift b/Sources/JNI/isMainThread.swift index d7e84f0..65a203f 100644 --- a/Sources/JNI/isMainThread.swift +++ b/Sources/JNI/isMainThread.swift @@ -1,4 +1,8 @@ +#if canImport(Glibc) import Glibc +#elseif canImport(Darwin) +import Darwin +#endif @_silgen_name("syscall") public func syscallNonVariadic(_ number: Int) -> Int From 1ac9032a20d4b8d035d5014b80c373e01e7e7f2a Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Fri, 4 Nov 2022 15:28:36 +0100 Subject: [PATCH 73/84] Remove unused import of Dispatch and some commented-out code --- Sources/JNI/SwiftJNI.swift | 88 -------------------------------------- 1 file changed, 88 deletions(-) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 7587712..bb308c7 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -1,5 +1,4 @@ import CJNI -import Dispatch public var jni: JNI! // this gets set "OnLoad" so should always exist @@ -10,12 +9,6 @@ public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutabl } jni = localJNI // set the global for use elsewhere - - #if os(Android) - // DispatchQueue.drainingMainQueue = true - // DispatchQueue.setThreadDetachCallback(JNI_DetachCurrentThread) - #endif - return JNI_VERSION_1_6 } @@ -173,87 +166,6 @@ struct JNIError: Error { } } -// /** -// Allows a (Void) Java method to be called from Swift. Takes a global jobj (a class instance), a method name and its signature. The resulting callback can be called via javaCallback.call(param1, param2...), or javaCallback.apply([params]). Each param must be a JavaParameter. - -// Needs more error checking and handling. The basis is there, but from memory I had issues with either the optional or the throwing on Android. -// */ -// public struct JavaCallback { -// private let jobj: JavaObject // must be a JNI Global Reference -// private let methodID: JavaMethodID - -// // Eventually we should check how many parameters are required by the method signature -// // And also which return type is expected (to allow calling non-Void methods) -// // For now this implementation remains unsafe -// //let expectedParameterCount: Int - -// /// Errors describing the various things that can go wrong when calling a Java method via JNI. -// /// - __InvalidParameters__: One character per method parameter is required. For example, with a methodSignature of "(FF)V", you need to pass two floats as parameters. -// /// - __InvalidMethod__: Couldn't get the requested method from the JavaObject provided (are you calling with the right JavaObject instance / calling on the correct class?) -// /// - __IncorrectMethodSignature__: The JNI is separated into Java method calls to functions with various return types. So if you perform `callJavaMethod`, you need to accept the return value with the corresponding type. *XXX: currently only Void methods are implemented*. - -// enum JavaError: Error { -// case JNINotReady -// case InvalidParameters -// case IncorrectMethodSignature -// case InvalidClass -// case InvalidMethod -// } - -// * -// - Parameters: -// - globalJobj: The class instance you want to perform the method on. Note this must be a jni GlobalRef, otherwise your callback will either crash or just silently not work. -// - methodName: A `String` with the name of the Java method to call -// - methodSignature: A `String` containing the method's exact signature. Although it is possible to call non-Void Java methods via the JNI, that is not yet implemented in the the current Swift binding. This means that, for now, `methodSignature` must end with `"V"` i.e., return `Void` -// - **`"(F)V"`** would reference a method that accepts one Float and returns Void. -// - **Z** boolean -// - **B** byte -// - **C** char -// - **S** short -// - **I** int -// - **J** long -// - **F** float -// - **D** double -// - **Lfully-qualified-class;** fully-qualified-class -// - **[type** type[] -// - **(arg-types)ret-type** method type -// - e.g. **`"([I)V"`** would accept one array of Ints and return Void. -// - parameters: Any number of JavaParameters (*must have the same number and type as the* `methodSignature` *you're trying to call*) -// - Throws: `JavaCallback.Error` - -// public init (_ globalJobj: JavaObject, methodName: String, methodSignature: String) throws { -// // At the moment we can only call Void methods, fail if user tries to return something else -// guard let returnType = methodSignature.last, returnType == "V"/*oid*/ else { -// // LOG JavaMethodCallError.IncorrectMethodSignature -// fatalError("JavaMethodCallError.IncorrectMethodSignature") -// } - -// // With signature "(FF)V", parameters count should be 2, ignoring the two brackets and the V -// // XXX: This test isn't robust, but it will prevent simple user errors -// // Doesn't work with more complex object types, arrays etc. we should determine the signature based on parameters. - -// // TODO: Check methodSignature here and determine expectedParameterCount -// let javaClass = try jni.GetObjectClass(obj: globalJobj) -// guard let methodID = try? jni.GetMethodID(for: javaClass, methodName: methodName, methodSignature: methodSignature) -// else { -// // XXX: We should throw here and keep throwing til it gets back to Java -// fatalError("Failed to make JavaCallback") -// } - -// self.jobj = globalJobj -// self.methodID = methodID -// } - -// public func apply(args: [JavaParameter]) { -// try? jni.CallVoidMethod(methodID, on: jobj, parameters: args) -// } - -// /// Send variadic parameters to the func that takes an array -// public func call(args: JavaParameter...) { -// self.apply(args: args) -// } -// } - #if os(Android) @discardableResult @_silgen_name("__android_log_write") From 894237c1e1cb874c5b1e07a28c649be0cfb9e548 Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Wed, 23 Nov 2022 19:06:28 +0100 Subject: [PATCH 74/84] Fix isMainThread for Darwin --- Sources/JNI/isMainThread.swift | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/Sources/JNI/isMainThread.swift b/Sources/JNI/isMainThread.swift index 65a203f..44c40e0 100644 --- a/Sources/JNI/isMainThread.swift +++ b/Sources/JNI/isMainThread.swift @@ -1,12 +1,17 @@ #if canImport(Glibc) import Glibc -#elseif canImport(Darwin) -import Darwin -#endif @_silgen_name("syscall") public func syscallNonVariadic(_ number: Int) -> Int public var isMainThread: Bool { - syscallNonVariadic(Int(SYS_gettid)) == getpid() + return syscallNonVariadic(Int(SYS_gettid)) == getpid() } +#elseif canImport(Darwin) +import Darwin +import Foundation // free on Darwin, expensive elsewhere + +public var isMainThread: Bool { + return Thread.isMainThread +} +#endif From f03a5a15b9cf6d05f48ff8047999c7f0856bae46 Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Tue, 6 Dec 2022 11:40:42 +1000 Subject: [PATCH 75/84] Optionally allow building as a part of a static library that defines another JNI_OnLoad function Use -DSTATIC_SWIFT_STDLIB --- Package.swift | 6 +++--- Sources/JNI/SwiftJNI.swift | 12 ++++++++++-- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/Package.swift b/Package.swift index 80d2aaf..ed5c6c4 100644 --- a/Package.swift +++ b/Package.swift @@ -1,14 +1,14 @@ -// swift-tools-version:4.0 +// swift-tools-version:5.0 import PackageDescription let package = Package( name: "JNI", products: [ - .library(name: "JNI", type: .dynamic, targets: ["JNI", "CJNI"]) + .library(name: "JNI", targets: ["JNI", "CJNI"]) ], targets: [ + .target(name: "JNI", dependencies: ["CJNI"]), .target(name: "CJNI"), - .target(name: "JNI", dependencies: ["CJNI"]) ] ) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index bb308c7..895b5dd 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -2,9 +2,17 @@ import CJNI public var jni: JNI! // this gets set "OnLoad" so should always exist +#if !STATIC_SWIFT_STDLIB @_cdecl("JNI_OnLoad") -public func JNI_OnLoad(jvm: UnsafeMutablePointer, reserved: UnsafeMutableRawPointer) -> JavaInt { - guard let localJNI = JNI(jvm: jvm) else { +public func JNI_Onload(_ vm: UnsafeMutablePointer, _ reserved: UnsafeMutableRawPointer?) -> JavaInt { + return SwiftJNI_OnLoad(vm, reserved) +} +#endif + +// Can be called manually from another call to JNI_OnLoad +// e.g. from the user's JNI_OnLoad function defined in the same static library +public func SwiftJNI_OnLoad(_ vm: UnsafeMutablePointer, _ reserved: UnsafeMutableRawPointer?) -> JavaInt { + guard let localJNI = JNI(jvm: vm) else { fatalError("Couldn't initialise JNI") } From a9e8f3e550b48f2de91bc66951256424ff4298cb Mon Sep 17 00:00:00 2001 From: rikner Date: Fri, 17 Mar 2023 14:37:27 +0100 Subject: [PATCH 76/84] add Int to convertible primitives --- .../JavaParameterConvertible+Primitives.swift | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/Sources/JNI/JavaParameterConvertible+Primitives.swift b/Sources/JNI/JavaParameterConvertible+Primitives.swift index 2799cbb..1b583be 100644 --- a/Sources/JNI/JavaParameterConvertible+Primitives.swift +++ b/Sources/JNI/JavaParameterConvertible+Primitives.swift @@ -25,6 +25,32 @@ extension Bool: JavaParameterConvertible, JavaInitializableFromMethod, JavaIniti } +// Int +extension Int: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { + public static let asJNIParameterString = "I" + + public func toJavaParameter() -> JavaParameter { + return JavaParameter(int: JavaInt(self)) + } + + public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Int { + return try Int(jni.GetStaticIntField(of: javaClass, id: fieldID)) + } + + public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Int { + return try Int(jni.CallIntMethod(methodID, on: object, parameters: args)) + } + + public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Int { + return try Int(jni.CallStaticIntMethod(methodID, on: javaClass, parameters: args)) + } + + public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Int { + return try Int(jni.GetIntField(of: javaObject, id: fieldID)) + } +} + + // JavaInt extension JavaInt: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { From d977baae4bc2eceddc09991d8035d0358fd8994d Mon Sep 17 00:00:00 2001 From: Michael Knoch Date: Fri, 28 Apr 2023 12:19:33 +0200 Subject: [PATCH 77/84] update macos deployment target to 10.15 (#19) * update macos deployment target to 12.0 * downgrade to 10.15 --- JNI.xcodeproj/project.pbxproj | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj index ee032f0..d799f44 100644 --- a/JNI.xcodeproj/project.pbxproj +++ b/JNI.xcodeproj/project.pbxproj @@ -265,7 +265,7 @@ DYLIB_INSTALL_NAME_BASE = "@rpath"; ENABLE_NS_ASSERTIONS = YES; GCC_OPTIMIZATION_LEVEL = 0; - MACOSX_DEPLOYMENT_TARGET = 10.10; + MACOSX_DEPLOYMENT_TARGET = 10.15; ONLY_ACTIVE_ARCH = YES; OTHER_SWIFT_FLAGS = "-DXcode"; PRODUCT_NAME = "$(TARGET_NAME)"; @@ -335,7 +335,7 @@ DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; DYLIB_INSTALL_NAME_BASE = "@rpath"; GCC_OPTIMIZATION_LEVEL = s; - MACOSX_DEPLOYMENT_TARGET = 10.10; + MACOSX_DEPLOYMENT_TARGET = 10.15; OTHER_SWIFT_FLAGS = "-DXcode"; PRODUCT_NAME = "$(TARGET_NAME)"; SDKROOT = macosx; From 71ed24c5b785471698e6c340f728d80836ed771f Mon Sep 17 00:00:00 2001 From: rikner Date: Thu, 18 Jan 2024 13:59:03 +0100 Subject: [PATCH 78/84] SetByteArrayRegion: pass Array instead BufferPointer --- Sources/JNI/SwiftJNI.swift | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index 895b5dd..ae1801f 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -60,7 +60,7 @@ public extension JNI { return result } - func NewByteArray(count: Int) throws -> JavaArray? { + func NewByteArray(count: Int) throws -> JavaByteArray? { let _env = self._env let result = _env.pointee.pointee.NewByteArray(_env, jsize(count)) try checkAndThrowOnJNIError() @@ -83,9 +83,9 @@ public extension JNI { return result.map { UInt8(bitPattern: $0) } } - func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: UnsafeBufferPointer) { + func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: Array) { let _env = self._env - var newElements = sourceElements.map { JavaByte($0) } // make mutable copy + var newElements = sourceElements.map { JavaByte(bitPattern: $0) } // make mutable copy _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } From 796087147acc4b5e2f3c6a48e848a98d8afc87b4 Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Wed, 30 Oct 2024 18:57:06 +0100 Subject: [PATCH 79/84] Swift 6 compatibility --- CMakeLists.txt | 1 + Sources/CJNI/include/cjni.h | 2 + Sources/CJNI/include/jni.h | 170 +++++++----------- Sources/JNI/CMakeLists.txt | 2 +- .../JavaParameterConvertible+Objects.swift | 2 + Sources/JNI/isMainThread.swift | 4 +- 6 files changed, 72 insertions(+), 109 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index ad3af33..5f1caa5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,3 +1,4 @@ +cmake_minimum_required(VERSION 3.16) project(SwiftJNI LANGUAGES C Swift) add_subdirectory(Sources/JNI) diff --git a/Sources/CJNI/include/cjni.h b/Sources/CJNI/include/cjni.h index 160c738..a678b16 100644 --- a/Sources/CJNI/include/cjni.h +++ b/Sources/CJNI/include/cjni.h @@ -7,3 +7,5 @@ #else #include #endif // __has_include() + +#include \ No newline at end of file diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h index 22f6a37..0e69f2c 100644 --- a/Sources/CJNI/include/jni.h +++ b/Sources/CJNI/include/jni.h @@ -22,113 +22,69 @@ */ -#ifndef JNI_H_ -#define JNI_H_ +#pragma once #define SWIFT_UNAVAILABLE(reason) __attribute__((unavailable(#reason))) #define CF_SWIFT_NAME(x) __attribute__((swift_name(#x))) -int _CFIsMainThread(void); // introduces implicit dependency on CoreFoundation - -#include #include - -/* - * Primitive types that match up with Java equivalents. - */ -#ifdef HAVE_INTTYPES_H -#include /* C99 */ -typedef uint8_t jboolean; /* unsigned 8 bits */ -typedef int8_t jbyte; /* signed 8 bits */ -typedef uint16_t jchar; /* unsigned 16 bits */ -typedef int16_t jshort; /* signed 16 bits */ -typedef int32_t jint; /* signed 32 bits */ -typedef int64_t jlong; /* signed 64 bits */ -typedef float jfloat; /* 32-bit IEEE 754 */ -typedef double jdouble; /* 64-bit IEEE 754 */ -#else -typedef unsigned char jboolean CF_SWIFT_NAME(JavaBoolean); /* unsigned 8 bits */ -typedef signed char jbyte CF_SWIFT_NAME(JavaByte); /* signed 8 bits */ -typedef unsigned short jchar CF_SWIFT_NAME(JavaChar); /* unsigned 16 bits */ -typedef short jshort CF_SWIFT_NAME(JavaShort); /* signed 16 bits */ -typedef int jint CF_SWIFT_NAME(JavaInt); /* signed 32 bits */ -typedef long long jlong CF_SWIFT_NAME(JavaLong); /* signed 64 bits */ -typedef float jfloat CF_SWIFT_NAME(JavaFloat); /* 32-bit IEEE 754 */ -typedef double jdouble CF_SWIFT_NAME(JavaDouble); /* 64-bit IEEE 754 */ -#endif +#include + +/* Primitive types that match up with Java equivalents. */ +typedef uint8_t jboolean CF_SWIFT_NAME(JavaBoolean); /* unsigned 8 bits */ +typedef int8_t jbyte CF_SWIFT_NAME(JavaByte); /* signed 8 bits */ +typedef uint16_t jchar CF_SWIFT_NAME(JavaChar); /* unsigned 16 bits */ +typedef int16_t jshort CF_SWIFT_NAME(JavaShort); /* signed 16 bits */ +typedef int32_t jint CF_SWIFT_NAME(JavaInt); /* signed 32 bits */ +typedef int64_t jlong CF_SWIFT_NAME(JavaLong); /* signed 64 bits */ +typedef float jfloat CF_SWIFT_NAME(JavaFloat); /* 32-bit IEEE 754 */ +typedef double jdouble CF_SWIFT_NAME(JavaDouble); /* 64-bit IEEE 754 */ /* "cardinal indices and sizes" */ -typedef jint jsize; +typedef jint jsize; #ifdef __cplusplus /* * Reference types, in C++ */ -class _jobject -{ -}; -class _jclass : public _jobject -{ -}; -class _jstring : public _jobject -{ -}; -class _jarray : public _jobject -{ -}; -class _jobjectArray : public _jarray -{ -}; -class _jbooleanArray : public _jarray -{ -}; -class _jbyteArray : public _jarray -{ -}; -class _jcharArray : public _jarray -{ -}; -class _jshortArray : public _jarray -{ -}; -class _jintArray : public _jarray -{ -}; -class _jlongArray : public _jarray -{ -}; -class _jfloatArray : public _jarray -{ -}; -class _jdoubleArray : public _jarray -{ -}; -class _jthrowable : public _jobject -{ -}; +class _jobject {}; +class _jclass : public _jobject {}; +class _jstring : public _jobject {}; +class _jarray : public _jobject {}; +class _jobjectArray : public _jarray {}; +class _jbooleanArray : public _jarray {}; +class _jbyteArray : public _jarray {}; +class _jcharArray : public _jarray {}; +class _jshortArray : public _jarray {}; +class _jintArray : public _jarray {}; +class _jlongArray : public _jarray {}; +class _jfloatArray : public _jarray {}; +class _jdoubleArray : public _jarray {}; +class _jthrowable : public _jobject {}; + +typedef _jobject* jobject; +typedef _jclass* jclass; +typedef _jstring* jstring; +typedef _jarray* jarray; +typedef _jobjectArray* jobjectArray; +typedef _jbooleanArray* jbooleanArray; +typedef _jbyteArray* jbyteArray; +typedef _jcharArray* jcharArray; +typedef _jshortArray* jshortArray; +typedef _jintArray* jintArray; +typedef _jlongArray* jlongArray; +typedef _jfloatArray* jfloatArray; +typedef _jdoubleArray* jdoubleArray; +typedef _jthrowable* jthrowable; +typedef _jobject* jweak; -typedef _jobject *jobject; -typedef _jclass *jclass; -typedef _jstring *jstring; -typedef _jarray *jarray; -typedef _jobjectArray *jobjectArray; -typedef _jbooleanArray *jbooleanArray; -typedef _jbyteArray *jbyteArray; -typedef _jcharArray *jcharArray; -typedef _jshortArray *jshortArray; -typedef _jintArray *jintArray; -typedef _jlongArray *jlongArray; -typedef _jfloatArray *jfloatArray; -typedef _jdoubleArray *jdoubleArray; -typedef _jthrowable *jthrowable; -typedef _jobject *jweak; #else /* not __cplusplus */ /* * Reference types, in C. */ -typedef void * _Nullable jobject CF_SWIFT_NAME(JavaObject); +typedef void * jobject CF_SWIFT_NAME(JavaObject); typedef jobject jclass CF_SWIFT_NAME(JavaClass); typedef jobject jstring CF_SWIFT_NAME(JavaString); typedef jobject jarray CF_SWIFT_NAME(JavaArray); @@ -155,15 +111,15 @@ typedef struct _jmethodID * _Nullable jmethodID CF_SWIFT_NAME(JavaMethodID); /* struct JNIInvokeInterface; typedef union CF_SWIFT_NAME(JavaParameter) jvalue { - jboolean z CF_SWIFT_NAME(bool); - jbyte b CF_SWIFT_NAME(byte); - jchar c CF_SWIFT_NAME(char); - jshort s CF_SWIFT_NAME(short); - jint i CF_SWIFT_NAME(int); - jlong j CF_SWIFT_NAME(long); - jfloat f CF_SWIFT_NAME(float); - jdouble d CF_SWIFT_NAME(double); - jobject l CF_SWIFT_NAME(object); + jboolean z CF_SWIFT_NAME(bool); + jbyte b CF_SWIFT_NAME(byte); + jchar c CF_SWIFT_NAME(char); + jshort s CF_SWIFT_NAME(short); + jint i CF_SWIFT_NAME(int); + jlong j CF_SWIFT_NAME(long); + jfloat f CF_SWIFT_NAME(float); + jdouble d CF_SWIFT_NAME(double); + jobject l CF_SWIFT_NAME(object); } jvalue; typedef enum CF_SWIFT_NAME(JavaObjectRefType) jobjectRefType { @@ -1436,20 +1392,22 @@ JNIEXPORT void JNICALL JNI_OnUnload(JavaVM * _Nonnull vm, void * _Nullable reser /* * Manifest constants. */ -#define JNI_FALSE 0 -#define JNI_TRUE 1 +#define JNI_FALSE 0 +#define JNI_TRUE 1 #define JNI_VERSION_1_1 0x00010001 #define JNI_VERSION_1_2 0x00010002 #define JNI_VERSION_1_4 0x00010004 #define JNI_VERSION_1_6 0x00010006 -#define JNI_OK (0) /* no error */ -#define JNI_ERR (-1) /* generic error */ -#define JNI_EDETACHED (-2) /* thread detached from the VM */ -#define JNI_EVERSION (-3) /* JNI version error */ +#define JNI_OK (0) /* no error */ +#define JNI_ERR (-1) /* generic error */ +#define JNI_EDETACHED (-2) /* thread detached from the VM */ +#define JNI_EVERSION (-3) /* JNI version error */ +#define JNI_ENOMEM (-4) /* Out of memory */ +#define JNI_EEXIST (-5) /* VM already created */ +#define JNI_EINVAL (-6) /* Invalid argument */ -#define JNI_COMMIT 1 /* copy content, do not free buffer */ -#define JNI_ABORT 2 /* free buffer w/o copying back */ +#define JNI_COMMIT 1 /* copy content, do not free buffer */ +#define JNI_ABORT 2 /* free buffer w/o copying back */ -#endif /* JNI_H_ */ diff --git a/Sources/JNI/CMakeLists.txt b/Sources/JNI/CMakeLists.txt index 9c23b91..10c4447 100644 --- a/Sources/JNI/CMakeLists.txt +++ b/Sources/JNI/CMakeLists.txt @@ -1,6 +1,7 @@ set(CMAKE_Swift_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/swift) add_library(JNI SHARED + isMainThread.swift Array+JavaParameterConvertible.swift JavaParameterConvertible+Objects.swift JavaParameterConvertible+Primitives.swift @@ -14,7 +15,6 @@ add_library(JNI SHARED JNIRefs.swift JNIStrings.swift SwiftJNI.swift - isMainThread.swift ) set_target_properties(JNI PROPERTIES diff --git a/Sources/JNI/JavaParameterConvertible+Objects.swift b/Sources/JNI/JavaParameterConvertible+Objects.swift index aec9317..40de4fc 100644 --- a/Sources/JNI/JavaParameterConvertible+Objects.swift +++ b/Sources/JNI/JavaParameterConvertible+Objects.swift @@ -1,3 +1,5 @@ +import CJNI + // JavaObject extension JavaObject: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { diff --git a/Sources/JNI/isMainThread.swift b/Sources/JNI/isMainThread.swift index 44c40e0..ae774fc 100644 --- a/Sources/JNI/isMainThread.swift +++ b/Sources/JNI/isMainThread.swift @@ -1,5 +1,5 @@ -#if canImport(Glibc) -import Glibc +#if canImport(Bionic) +import Bionic @_silgen_name("syscall") public func syscallNonVariadic(_ number: Int) -> Int From 681af66339c3ee1f77a82ee4bb2c8b5e75cfbd2e Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Thu, 31 Oct 2024 18:01:06 +0100 Subject: [PATCH 80/84] Remove custom jni.h, use original from NDK --- Sources/CJNI/cjni.c | 0 Sources/CJNI/include/cjni.h | 11 - Sources/CJNI/include/jni.h | 1413 ----------------- Sources/CJNI/include/module.modulemap | 4 - .../JNI/Array+JavaParameterConvertible.swift | 2 - Sources/JNI/CMakeLists.txt | 3 - Sources/JNI/JNI.swift | 28 +- Sources/JNI/JNIClassManipulation.swift | 59 +- Sources/JNI/JNIExceptions.swift | 16 +- Sources/JNI/JNIFields.swift | 32 +- Sources/JNI/JNIMethods.swift | 42 +- Sources/JNI/JNIObjects.swift | 9 +- Sources/JNI/JNIRefs.swift | 26 +- Sources/JNI/JNIStrings.swift | 40 +- .../JavaParameterConvertible+Objects.swift | 8 +- .../JavaParameterConvertible+Primitives.swift | 20 +- Sources/JNI/JavaParameterConvertible.swift | 2 - Sources/JNI/SwiftJNI.swift | 78 +- Sources/JNI/isMainThread.swift | 4 +- 19 files changed, 186 insertions(+), 1611 deletions(-) delete mode 100644 Sources/CJNI/cjni.c delete mode 100644 Sources/CJNI/include/cjni.h delete mode 100644 Sources/CJNI/include/jni.h delete mode 100644 Sources/CJNI/include/module.modulemap diff --git a/Sources/CJNI/cjni.c b/Sources/CJNI/cjni.c deleted file mode 100644 index e69de29..0000000 diff --git a/Sources/CJNI/include/cjni.h b/Sources/CJNI/include/cjni.h deleted file mode 100644 index a678b16..0000000 --- a/Sources/CJNI/include/cjni.h +++ /dev/null @@ -1,11 +0,0 @@ -#include "jni.h" - -// Syscall numbers; used in `isMainThread` -// FIXME: This exports syscall.h in its entirety, which isn't ideal. -#if __has_include() -#include -#else -#include -#endif // __has_include() - -#include \ No newline at end of file diff --git a/Sources/CJNI/include/jni.h b/Sources/CJNI/include/jni.h deleted file mode 100644 index 0e69f2c..0000000 --- a/Sources/CJNI/include/jni.h +++ /dev/null @@ -1,1413 +0,0 @@ -/* - * Copyright (C) 2006 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* - * JNI specification, as defined by Sun: - * http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/jniTOC.html - * - * Everything here is expected to be VM-neutral. - */ - - -#pragma once - -#define SWIFT_UNAVAILABLE(reason) __attribute__((unavailable(#reason))) -#define CF_SWIFT_NAME(x) __attribute__((swift_name(#x))) - -#include -#include - -/* Primitive types that match up with Java equivalents. */ -typedef uint8_t jboolean CF_SWIFT_NAME(JavaBoolean); /* unsigned 8 bits */ -typedef int8_t jbyte CF_SWIFT_NAME(JavaByte); /* signed 8 bits */ -typedef uint16_t jchar CF_SWIFT_NAME(JavaChar); /* unsigned 16 bits */ -typedef int16_t jshort CF_SWIFT_NAME(JavaShort); /* signed 16 bits */ -typedef int32_t jint CF_SWIFT_NAME(JavaInt); /* signed 32 bits */ -typedef int64_t jlong CF_SWIFT_NAME(JavaLong); /* signed 64 bits */ -typedef float jfloat CF_SWIFT_NAME(JavaFloat); /* 32-bit IEEE 754 */ -typedef double jdouble CF_SWIFT_NAME(JavaDouble); /* 64-bit IEEE 754 */ - -/* "cardinal indices and sizes" */ -typedef jint jsize; - -#ifdef __cplusplus -/* - * Reference types, in C++ - */ -class _jobject {}; -class _jclass : public _jobject {}; -class _jstring : public _jobject {}; -class _jarray : public _jobject {}; -class _jobjectArray : public _jarray {}; -class _jbooleanArray : public _jarray {}; -class _jbyteArray : public _jarray {}; -class _jcharArray : public _jarray {}; -class _jshortArray : public _jarray {}; -class _jintArray : public _jarray {}; -class _jlongArray : public _jarray {}; -class _jfloatArray : public _jarray {}; -class _jdoubleArray : public _jarray {}; -class _jthrowable : public _jobject {}; - -typedef _jobject* jobject; -typedef _jclass* jclass; -typedef _jstring* jstring; -typedef _jarray* jarray; -typedef _jobjectArray* jobjectArray; -typedef _jbooleanArray* jbooleanArray; -typedef _jbyteArray* jbyteArray; -typedef _jcharArray* jcharArray; -typedef _jshortArray* jshortArray; -typedef _jintArray* jintArray; -typedef _jlongArray* jlongArray; -typedef _jfloatArray* jfloatArray; -typedef _jdoubleArray* jdoubleArray; -typedef _jthrowable* jthrowable; -typedef _jobject* jweak; - - -#else /* not __cplusplus */ - -/* - * Reference types, in C. - */ -typedef void * jobject CF_SWIFT_NAME(JavaObject); -typedef jobject jclass CF_SWIFT_NAME(JavaClass); -typedef jobject jstring CF_SWIFT_NAME(JavaString); -typedef jobject jarray CF_SWIFT_NAME(JavaArray); -typedef jarray jobjectArray CF_SWIFT_NAME(JavaObjectArray); -typedef jarray jbooleanArray CF_SWIFT_NAME(JavaBooleanArray); -typedef jarray jbyteArray CF_SWIFT_NAME(JavaByteArray); -typedef jarray jcharArray CF_SWIFT_NAME(JavaCharArray); -typedef jarray jshortArray CF_SWIFT_NAME(JavaShortArray); -typedef jarray jintArray CF_SWIFT_NAME(JavaIntArray); -typedef jarray jlongArray CF_SWIFT_NAME(JavaLongArray); -typedef jarray jfloatArray CF_SWIFT_NAME(JavaFloatArray); -typedef jarray jdoubleArray CF_SWIFT_NAME(JavaDoubleArray); -typedef jobject jthrowable CF_SWIFT_NAME(JavaThrowable); -typedef jobject jweak CF_SWIFT_NAME(JavaWeakReference); - -#endif /* not __cplusplus */ - -struct _jfieldID; /* opaque structure */ -typedef struct _jfieldID * _Nullable jfieldID CF_SWIFT_NAME(JavaFieldID); /* field IDs */ - -struct _jmethodID; /* opaque structure */ -typedef struct _jmethodID * _Nullable jmethodID CF_SWIFT_NAME(JavaMethodID); /* method IDs */ - -struct JNIInvokeInterface; - -typedef union CF_SWIFT_NAME(JavaParameter) jvalue { - jboolean z CF_SWIFT_NAME(bool); - jbyte b CF_SWIFT_NAME(byte); - jchar c CF_SWIFT_NAME(char); - jshort s CF_SWIFT_NAME(short); - jint i CF_SWIFT_NAME(int); - jlong j CF_SWIFT_NAME(long); - jfloat f CF_SWIFT_NAME(float); - jdouble d CF_SWIFT_NAME(double); - jobject l CF_SWIFT_NAME(object); -} jvalue; - -typedef enum CF_SWIFT_NAME(JavaObjectRefType) jobjectRefType { - JNIInvalidRefType = 0, - JNILocalRefType = 1, - JNIGlobalRefType = 2, - JNIWeakGlobalRefType = 3 -} jobjectRefType; - -typedef struct -{ - const char * _Nonnull name; - const char * _Nonnull signature; - void * _Nonnull fnPtr; -} JNINativeMethod; - -struct _JNIEnv; -struct _JavaVM; -typedef const struct JNINativeInterface * _Nonnull C_JNIEnv; - -#if defined(__cplusplus) -typedef _JNIEnv JNIEnv; -typedef _JavaVM JavaVM; -#else -typedef const struct JNINativeInterface * _Nonnull JNIEnv; -typedef const struct JNIInvokeInterface * _Nonnull JavaVM; -#endif - -/* - * Table of interface function pointers. - */ -struct JNINativeInterface -{ - void *_Null_unspecified reserved0; - void *_Null_unspecified reserved1; - void *_Null_unspecified reserved2; - void *_Null_unspecified reserved3; - - jint (* _Nonnull GetVersion)(JNIEnv * _Nonnull); - - jclass (* _Nonnull DefineClass)(JNIEnv * _Nonnull, const char * _Nonnull, jobject, const jbyte * _Nonnull, jsize) SWIFT_UNAVAILABLE(Not implemented on Android); - jclass (* _Nonnull FindClass)(JNIEnv * _Nonnull, const char * _Nonnull); - - jmethodID (* _Nonnull FromReflectedMethod)(JNIEnv * _Nonnull, jobject); - jfieldID (* _Nonnull FromReflectedField)(JNIEnv * _Nonnull, jobject); - /* spec doesn't show jboolean parameter */ - jobject (* _Nonnull ToReflectedMethod)(JNIEnv * _Nonnull, jclass, jmethodID, jboolean); - - jclass (* _Nonnull GetSuperclass)(JNIEnv * _Nonnull, jclass); - jboolean (* _Nonnull IsAssignableFrom)(JNIEnv * _Nonnull, jclass, jclass); - - /* spec doesn't show jboolean parameter */ - jobject (* _Nonnull ToReflectedField)(JNIEnv * _Nonnull, jclass, jfieldID, jboolean); - - jint (* _Nonnull Throw)(JNIEnv * _Nonnull, jthrowable); - jint (* _Nonnull ThrowNew)(JNIEnv * _Nonnull, jclass, const char * _Nonnull); - jthrowable (* _Nonnull ExceptionOccurred)(JNIEnv * _Nonnull); - void (* _Nonnull ExceptionDescribe)(JNIEnv * _Nonnull); - void (* _Nonnull ExceptionClear)(JNIEnv * _Nonnull); - void (* _Nonnull FatalError)(JNIEnv * _Nonnull, const char * _Nonnull); - - jint (* _Nonnull PushLocalFrame)(JNIEnv * _Nonnull, jint); - jobject (* _Nonnull PopLocalFrame)(JNIEnv * _Nonnull, jobject); - - jobject (* _Nonnull NewGlobalRef)(JNIEnv * _Nonnull, jobject); - void (* _Nonnull DeleteGlobalRef)(JNIEnv * _Nonnull, jobject); - void (* _Nonnull DeleteLocalRef)(JNIEnv * _Nonnull, jobject); - jboolean (* _Nonnull IsSameObject)(JNIEnv * _Nonnull, jobject, jobject); - - jobject (* _Nonnull NewLocalRef)(JNIEnv * _Nonnull, jobject); - jint (* _Nonnull EnsureLocalCapacity)(JNIEnv * _Nonnull, jint); - - jobject (* _Nonnull AllocObject)(JNIEnv * _Nonnull, jclass); - jobject (* _Nonnull NewObject)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'newObject' instead); - jobject (* _Nonnull NewObjectV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'newObject' instead); - jobject (* _Nonnull NewObjectA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(NewObject); - - jclass (* _Nonnull GetObjectClass)(JNIEnv * _Nonnull, jobject); - jboolean (* _Nonnull IsInstanceOf)(JNIEnv * _Nonnull, jobject, jclass); - jmethodID (* _Nonnull GetMethodID)(JNIEnv * _Nonnull, jclass, const char * _Nonnull, const char * _Nonnull); - - jobject (* _Nonnull CallObjectMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - jobject (* _Nonnull CallObjectMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jobject (* _Nonnull CallObjectMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallObjectMethod); - jboolean (* _Nonnull CallBooleanMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - jboolean (* _Nonnull CallBooleanMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jboolean (* _Nonnull CallBooleanMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallBooleanMethod); - jbyte (* _Nonnull CallByteMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - jbyte (* _Nonnull CallByteMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jbyte (* _Nonnull CallByteMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallByteMethod); - jchar (* _Nonnull CallCharMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - jchar (* _Nonnull CallCharMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jchar (* _Nonnull CallCharMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallCharMethod); - jshort (* _Nonnull CallShortMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - jshort (* _Nonnull CallShortMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jshort (* _Nonnull CallShortMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallShortMethod); - jint (* _Nonnull CallIntMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - jint (* _Nonnull CallIntMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jint (* _Nonnull CallIntMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallIntMethod); - jlong (* _Nonnull CallLongMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - jlong (* _Nonnull CallLongMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jlong (* _Nonnull CallLongMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallLongMethod); - jfloat (* _Nonnull CallFloatMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - jfloat (* _Nonnull CallFloatMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jfloat (* _Nonnull CallFloatMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallFloatMethod); - jdouble (* _Nonnull CallDoubleMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - jdouble (* _Nonnull CallDoubleMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jdouble (* _Nonnull CallDoubleMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallDoubleMethod); - void (* _Nonnull CallVoidMethod)(JNIEnv * _Nonnull, jobject, jmethodID, ...) SWIFT_UNAVAILABLE(); - void (* _Nonnull CallVoidMethodV)(JNIEnv * _Nonnull, jobject, jmethodID, va_list) SWIFT_UNAVAILABLE(); - void (* _Nonnull CallVoidMethodA)(JNIEnv * _Nonnull, jobject, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(CallVoidMethod); - - jobject (* _Nonnull CallNonvirtualObjectMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jobject (* _Nonnull CallNonvirtualObjectMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jobject (* _Nonnull CallNonvirtualObjectMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - jboolean (* _Nonnull CallNonvirtualBooleanMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jboolean (* _Nonnull CallNonvirtualBooleanMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jboolean (* _Nonnull CallNonvirtualBooleanMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - jbyte (* _Nonnull CallNonvirtualByteMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jbyte (* _Nonnull CallNonvirtualByteMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jbyte (* _Nonnull CallNonvirtualByteMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - jchar (* _Nonnull CallNonvirtualCharMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jchar (* _Nonnull CallNonvirtualCharMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jchar (* _Nonnull CallNonvirtualCharMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - jshort (* _Nonnull CallNonvirtualShortMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jshort (* _Nonnull CallNonvirtualShortMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jshort (* _Nonnull CallNonvirtualShortMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - jint (* _Nonnull CallNonvirtualIntMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jint (* _Nonnull CallNonvirtualIntMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jint (* _Nonnull CallNonvirtualIntMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - jlong (* _Nonnull CallNonvirtualLongMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jlong (* _Nonnull CallNonvirtualLongMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jlong (* _Nonnull CallNonvirtualLongMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - jfloat (* _Nonnull CallNonvirtualFloatMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jfloat (* _Nonnull CallNonvirtualFloatMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jfloat (* _Nonnull CallNonvirtualFloatMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - jdouble (* _Nonnull CallNonvirtualDoubleMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jdouble (* _Nonnull CallNonvirtualDoubleMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - jdouble (* _Nonnull CallNonvirtualDoubleMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - void (* _Nonnull CallNonvirtualVoidMethod)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - void (* _Nonnull CallNonvirtualVoidMethodV)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(use 'callNonvirtual' instead); - void (* _Nonnull CallNonvirtualVoidMethodA)(JNIEnv * _Nonnull, jobject, jclass, jmethodID, const jvalue * _Nonnull) CF_SWIFT_NAME(callNonvirtual); - - jfieldID (* _Nonnull GetFieldID)(JNIEnv * _Nonnull, jclass, const char * _Nonnull, const char * _Nonnull); - - jobject (* _Nonnull GetObjectField)(JNIEnv * _Nonnull, jobject, jfieldID); - jboolean (* _Nonnull GetBooleanField)(JNIEnv * _Nonnull, jobject, jfieldID); - jbyte (* _Nonnull GetByteField)(JNIEnv * _Nonnull, jobject, jfieldID); - jchar (* _Nonnull GetCharField)(JNIEnv * _Nonnull, jobject, jfieldID); - jshort (* _Nonnull GetShortField)(JNIEnv * _Nonnull, jobject, jfieldID); - jint (* _Nonnull GetIntField)(JNIEnv * _Nonnull, jobject, jfieldID); - jlong (* _Nonnull GetLongField)(JNIEnv * _Nonnull, jobject, jfieldID); - jfloat (* _Nonnull GetFloatField)(JNIEnv * _Nonnull, jobject, jfieldID); - jdouble (* _Nonnull GetDoubleField)(JNIEnv * _Nonnull, jobject, jfieldID); - - void (* _Nonnull SetObjectField)(JNIEnv * _Nonnull, jobject, jfieldID, jobject); - void (* _Nonnull SetBooleanField)(JNIEnv * _Nonnull, jobject, jfieldID, jboolean); - void (* _Nonnull SetByteField)(JNIEnv * _Nonnull, jobject, jfieldID, jbyte); - void (* _Nonnull SetCharField)(JNIEnv * _Nonnull, jobject, jfieldID, jchar); - void (* _Nonnull SetShortField)(JNIEnv * _Nonnull, jobject, jfieldID, jshort); - void (* _Nonnull SetIntField)(JNIEnv * _Nonnull, jobject, jfieldID, jint); - void (* _Nonnull SetLongField)(JNIEnv * _Nonnull, jobject, jfieldID, jlong); - void (* _Nonnull SetFloatField)(JNIEnv * _Nonnull, jobject, jfieldID, jfloat); - void (* _Nonnull SetDoubleField)(JNIEnv * _Nonnull, jobject, jfieldID, jdouble); - - jmethodID (* _Nonnull GetStaticMethodID)(JNIEnv * _Nonnull, jclass, const char * _Nonnull, const char * _Nonnull); - - jobject (* _Nonnull CallStaticObjectMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jobject (* _Nonnull CallStaticObjectMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jobject (* _Nonnull CallStaticObjectMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - jboolean (* _Nonnull CallStaticBooleanMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jboolean (* _Nonnull CallStaticBooleanMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jboolean (* _Nonnull CallStaticBooleanMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - jbyte (* _Nonnull CallStaticByteMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jbyte (* _Nonnull CallStaticByteMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jbyte (* _Nonnull CallStaticByteMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - jchar (* _Nonnull CallStaticCharMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jchar (* _Nonnull CallStaticCharMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jchar (* _Nonnull CallStaticCharMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - jshort (* _Nonnull CallStaticShortMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jshort (* _Nonnull CallStaticShortMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jshort (* _Nonnull CallStaticShortMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - jint (* _Nonnull CallStaticIntMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jint (* _Nonnull CallStaticIntMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jint (* _Nonnull CallStaticIntMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - jlong (* _Nonnull CallStaticLongMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jlong (* _Nonnull CallStaticLongMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jlong (* _Nonnull CallStaticLongMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - jfloat (* _Nonnull CallStaticFloatMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jfloat (* _Nonnull CallStaticFloatMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jfloat (* _Nonnull CallStaticFloatMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - jdouble (* _Nonnull CallStaticDoubleMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - jdouble (* _Nonnull CallStaticDoubleMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - jdouble (* _Nonnull CallStaticDoubleMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - void (* _Nonnull CallStaticVoidMethod)(JNIEnv * _Nonnull, jclass, jmethodID, ...) SWIFT_UNAVAILABLE(); - void (* _Nonnull CallStaticVoidMethodV)(JNIEnv * _Nonnull, jclass, jmethodID, va_list) SWIFT_UNAVAILABLE(); - void (* _Nonnull CallStaticVoidMethodA)(JNIEnv * _Nonnull, jclass, jmethodID, const jvalue * _Nonnull); - - jfieldID (* _Nonnull GetStaticFieldID)(JNIEnv * _Nonnull, jclass, const char * _Nonnull, const char * _Nonnull); - - jobject (* _Nonnull GetStaticObjectField)(JNIEnv * _Nonnull, jclass, jfieldID); - jboolean (* _Nonnull GetStaticBooleanField)(JNIEnv * _Nonnull, jclass, jfieldID); - jbyte (* _Nonnull GetStaticByteField)(JNIEnv * _Nonnull, jclass, jfieldID); - jchar (* _Nonnull GetStaticCharField)(JNIEnv * _Nonnull, jclass, jfieldID); - jshort (* _Nonnull GetStaticShortField)(JNIEnv * _Nonnull, jclass, jfieldID); - jint (* _Nonnull GetStaticIntField)(JNIEnv * _Nonnull, jclass, jfieldID); - jlong (* _Nonnull GetStaticLongField)(JNIEnv * _Nonnull, jclass, jfieldID); - jfloat (* _Nonnull GetStaticFloatField)(JNIEnv * _Nonnull, jclass, jfieldID); - jdouble (* _Nonnull GetStaticDoubleField)(JNIEnv * _Nonnull, jclass, jfieldID); - - void (* _Nonnull SetStaticObjectField)(JNIEnv * _Nonnull, jclass, jfieldID, jobject); - void (* _Nonnull SetStaticBooleanField)(JNIEnv * _Nonnull, jclass, jfieldID, jboolean); - void (* _Nonnull SetStaticByteField)(JNIEnv * _Nonnull, jclass, jfieldID, jbyte); - void (* _Nonnull SetStaticCharField)(JNIEnv * _Nonnull, jclass, jfieldID, jchar); - void (* _Nonnull SetStaticShortField)(JNIEnv * _Nonnull, jclass, jfieldID, jshort); - void (* _Nonnull SetStaticIntField)(JNIEnv * _Nonnull, jclass, jfieldID, jint); - void (* _Nonnull SetStaticLongField)(JNIEnv * _Nonnull, jclass, jfieldID, jlong); - void (* _Nonnull SetStaticFloatField)(JNIEnv * _Nonnull, jclass, jfieldID, jfloat); - void (* _Nonnull SetStaticDoubleField)(JNIEnv * _Nonnull, jclass, jfieldID, jdouble); - - jstring (* _Nonnull NewString)(JNIEnv * _Nonnull, const jchar * _Nonnull, jsize); - jsize (* _Nonnull GetStringLength)(JNIEnv * _Nonnull, jstring); - const jchar * _Nullable(* _Nonnull GetStringChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nullable); - void (* _Nonnull ReleaseStringChars)(JNIEnv * _Nonnull, jstring, const jchar * _Nonnull); - jstring (* _Nonnull NewStringUTF)(JNIEnv * _Nonnull, const char * _Nonnull); - jsize (* _Nonnull GetStringUTFLength)(JNIEnv * _Nonnull, jstring); - /* JNI spec says this returns const jbyte*, but that's inconsistent */ - const char * _Nullable(* _Nonnull GetStringUTFChars)(JNIEnv * _Nonnull, jstring, jboolean * _Nullable); - void (* _Nonnull ReleaseStringUTFChars)(JNIEnv * _Nonnull, jstring, const char * _Nullable); - jsize (* _Nonnull GetArrayLength)(JNIEnv * _Nonnull, jarray); - jobjectArray (* _Nonnull NewObjectArray)(JNIEnv * _Nonnull, jsize, jclass, jobject); - jobject (* _Nonnull GetObjectArrayElement)(JNIEnv * _Nonnull, jobjectArray, jsize); - void (* _Nonnull SetObjectArrayElement)(JNIEnv * _Nonnull, jobjectArray, jsize, jobject); - - jbooleanArray (* _Nonnull NewBooleanArray)(JNIEnv * _Nonnull, jsize); - jbyteArray (* _Nonnull NewByteArray)(JNIEnv * _Nonnull, jsize); - jcharArray (* _Nonnull NewCharArray)(JNIEnv * _Nonnull, jsize); - jshortArray (* _Nonnull NewShortArray)(JNIEnv * _Nonnull, jsize); - jintArray (* _Nonnull NewIntArray)(JNIEnv * _Nonnull, jsize); - jlongArray (* _Nonnull NewLongArray)(JNIEnv * _Nonnull, jsize); - jfloatArray (* _Nonnull NewFloatArray)(JNIEnv * _Nonnull, jsize); - jdoubleArray (* _Nonnull NewDoubleArray)(JNIEnv * _Nonnull, jsize); - - jboolean * _Nullable (* _Nonnull GetBooleanArrayElements)(JNIEnv * _Nonnull, jbooleanArray, jboolean * _Nonnull); - jbyte * _Nullable (* _Nonnull GetByteArrayElements)(JNIEnv * _Nonnull, jbyteArray, jboolean * _Nonnull); - jchar * _Nullable (* _Nonnull GetCharArrayElements)(JNIEnv * _Nonnull, jcharArray, jboolean * _Nonnull); - jshort * _Nullable (* _Nonnull GetShortArrayElements)(JNIEnv * _Nonnull, jshortArray, jboolean * _Nonnull); - jint * _Nullable (* _Nonnull GetIntArrayElements)(JNIEnv * _Nonnull, jintArray, jboolean * _Nonnull); - jlong * _Nullable (* _Nonnull GetLongArrayElements)(JNIEnv * _Nonnull, jlongArray, jboolean * _Nonnull); - jfloat * _Nullable (* _Nonnull GetFloatArrayElements)(JNIEnv * _Nonnull, jfloatArray, jboolean * _Nonnull); - jdouble * _Nullable (* _Nonnull GetDoubleArrayElements)(JNIEnv * _Nonnull, jdoubleArray, jboolean * _Nonnull); - - void (* _Nonnull ReleaseBooleanArrayElements)(JNIEnv * _Nonnull, jbooleanArray, jboolean * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseByteArrayElements)(JNIEnv * _Nonnull, jbyteArray, jbyte * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseCharArrayElements)(JNIEnv * _Nonnull, jcharArray, jchar * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseShortArrayElements)(JNIEnv * _Nonnull, jshortArray, jshort * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseIntArrayElements)(JNIEnv * _Nonnull, jintArray, jint * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseLongArrayElements)(JNIEnv * _Nonnull, jlongArray, jlong * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseFloatArrayElements)(JNIEnv * _Nonnull, jfloatArray, jfloat * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); - void (* _Nonnull ReleaseDoubleArrayElements)(JNIEnv * _Nonnull, jdoubleArray, jdouble * _Nullable, jint) CF_SWIFT_NAME(ReleaseArrayElements); - - void (* _Nonnull GetBooleanArrayRegion)(JNIEnv * _Nonnull, jbooleanArray, jsize, jsize, jboolean * _Nonnull); - void (* _Nonnull GetByteArrayRegion)(JNIEnv * _Nonnull, jbyteArray, jsize, jsize, jbyte * _Nonnull); - void (* _Nonnull GetCharArrayRegion)(JNIEnv * _Nonnull, jcharArray, jsize, jsize, jchar * _Nonnull); - void (* _Nonnull GetShortArrayRegion)(JNIEnv * _Nonnull, jshortArray, jsize, jsize, jshort * _Nonnull); - void (* _Nonnull GetIntArrayRegion)(JNIEnv * _Nonnull, jintArray, jsize, jsize, jint * _Nonnull); - void (* _Nonnull GetLongArrayRegion)(JNIEnv * _Nonnull, jlongArray, jsize, jsize, jlong * _Nonnull); - void (* _Nonnull GetFloatArrayRegion)(JNIEnv * _Nonnull, jfloatArray, jsize, jsize, jfloat * _Nonnull); - void (* _Nonnull GetDoubleArrayRegion)(JNIEnv * _Nonnull, jdoubleArray, jsize, jsize, jdouble * _Nonnull); - - /* spec shows these without const; some jni.h do, some don't */ - void (* _Nonnull SetBooleanArrayRegion)(JNIEnv * _Nonnull, jbooleanArray, jsize, jsize, const jboolean * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - void (* _Nonnull SetByteArrayRegion)(JNIEnv * _Nonnull, jbyteArray, jsize, jsize, const jbyte * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - void (* _Nonnull SetCharArrayRegion)(JNIEnv * _Nonnull, jcharArray, jsize, jsize, const jchar * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - void (* _Nonnull SetShortArrayRegion)(JNIEnv * _Nonnull, jshortArray, jsize, jsize, const jshort * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - void (* _Nonnull SetIntArrayRegion)(JNIEnv * _Nonnull, jintArray, jsize, jsize, const jint * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - void (* _Nonnull SetLongArrayRegion)(JNIEnv * _Nonnull, jlongArray, jsize, jsize, const jlong * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - void (* _Nonnull SetFloatArrayRegion)(JNIEnv * _Nonnull, jfloatArray, jsize, jsize, const jfloat * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - void (* _Nonnull SetDoubleArrayRegion)(JNIEnv * _Nonnull, jdoubleArray, jsize, jsize, const jdouble * _Nonnull) CF_SWIFT_NAME(SetArrayRegion); - - jint (* _Nonnull RegisterNatives)(JNIEnv * _Nonnull, jclass, const JNINativeMethod * _Nonnull, jint); - jint (* _Nonnull UnregisterNatives)(JNIEnv * _Nonnull, jclass); - jint (* _Nonnull MonitorEnter)(JNIEnv * _Nonnull, jobject); - jint (* _Nonnull MonitorExit)(JNIEnv * _Nonnull, jobject); - jint (* _Nonnull GetJavaVM)(JNIEnv * _Nonnull, JavaVM * _Nonnull* _Nonnull); - - void (* _Nonnull GetStringRegion)(JNIEnv * _Nonnull, jstring, jsize, jsize, jchar * _Nonnull); - void (* _Nonnull GetStringUTFRegion)(JNIEnv * _Nonnull, jstring, jsize, jsize, char * _Nonnull); - - void * _Nullable(* _Nonnull GetPrimitiveArrayCritical)(JNIEnv * _Nonnull, jarray, jboolean * _Nonnull); - void (* _Nonnull ReleasePrimitiveArrayCritical)(JNIEnv * _Nonnull, jarray, void * _Nullable, jint); - - const jchar * _Nullable(* _Nonnull GetStringCritical)(JNIEnv * _Nonnull, jstring, jboolean * _Nonnull); - void (* _Nonnull ReleaseStringCritical)(JNIEnv * _Nonnull, jstring, const jchar * _Nullable); - - jweak (* _Nonnull NewWeakGlobalRef)(JNIEnv * _Nonnull, jobject); - void (* _Nonnull DeleteWeakGlobalRef)(JNIEnv * _Nonnull, jweak); - - jboolean (* _Nonnull ExceptionCheck)(JNIEnv * _Nonnull); - - jobject (* _Nonnull NewDirectByteBuffer)(JNIEnv * _Nonnull, void * _Nonnull, jlong); - void * _Nullable (* _Nonnull GetDirectBufferAddress)(JNIEnv * _Nonnull, jobject); - jlong (* _Nonnull GetDirectBufferCapacity)(JNIEnv * _Nonnull, jobject); - - /* added in JNI 1.6 */ - jobjectRefType (* _Nonnull GetObjectRefType)(JNIEnv * _Nonnull, jobject); -}; - -/* - * C++ object wrapper. - * - * This is usually overlaid on a C struct whose first element is a - * JNINativeInterface*. We rely somewhat on compiler behavior. - */ -struct _JNIEnv -{ - /* do not rename this; it does not seem to be entirely opaque */ - const struct JNINativeInterface * _Nonnull functions; - -#if defined(__cplusplus) - - jint GetVersion() - { - return functions->GetVersion(this); - } - - jclass DefineClass(const char * _Nonnullname, jobject loader, const jbyte *buf, - jsize bufLen) - { - return functions->DefineClass(this, name, loader, buf, bufLen); - } - - jclass FindClass(const char *name) - { - return functions->FindClass(this, name); - } - - jmethodID FromReflectedMethod(jobject method) - { - return functions->FromReflectedMethod(this, method); - } - - jfieldID FromReflectedField(jobject field) - { - return functions->FromReflectedField(this, field); - } - - jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) - { - return functions->ToReflectedMethod(this, cls, methodID, isStatic); - } - - jclass GetSuperclass(jclass clazz) - { - return functions->GetSuperclass(this, clazz); - } - - jboolean IsAssignableFrom(jclass clazz1, jclass clazz2) - { - return functions->IsAssignableFrom(this, clazz1, clazz2); - } - - jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) - { - return functions->ToReflectedField(this, cls, fieldID, isStatic); - } - - jint Throw(jthrowable obj) - { - return functions->Throw(this, obj); - } - - jint ThrowNew(jclass clazz, const char *message) - { - return functions->ThrowNew(this, clazz, message); - } - - jthrowable ExceptionOccurred() - { - return functions->ExceptionOccurred(this); - } - - void ExceptionDescribe() - { - functions->ExceptionDescribe(this); - } - - void ExceptionClear() - { - functions->ExceptionClear(this); - } - - void FatalError(const char *msg) - { - functions->FatalError(this, msg); - } - - jint PushLocalFrame(jint capacity) - { - return functions->PushLocalFrame(this, capacity); - } - - jobject PopLocalFrame(jobject result) - { - return functions->PopLocalFrame(this, result); - } - - jobject NewGlobalRef(jobject obj) - { - return functions->NewGlobalRef(this, obj); - } - - void DeleteGlobalRef(jobject globalRef) - { - functions->DeleteGlobalRef(this, globalRef); - } - - void DeleteLocalRef(jobject localRef) - { - functions->DeleteLocalRef(this, localRef); - } - - jboolean IsSameObject(jobject ref1, jobject ref2) - { - return functions->IsSameObject(this, ref1, ref2); - } - - jobject NewLocalRef(jobject ref) - { - return functions->NewLocalRef(this, ref); - } - - jint EnsureLocalCapacity(jint capacity) - { - return functions->EnsureLocalCapacity(this, capacity); - } - - jobject AllocObject(jclass clazz) - { - return functions->AllocObject(this, clazz); - } - - jobject NewObject(jclass clazz, jmethodID methodID, ...) - { - va_list args; - va_start(args, methodID); - jobject result = functions->NewObjectV(this, clazz, methodID, args); - va_end(args); - return result; - } - - jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args) - { - return functions->NewObjectV(this, clazz, methodID, args); - } - - jobject NewObjectA(jclass clazz, jmethodID methodID, const jvalue * _Nonnull args) - { - return functions->NewObjectA(this, clazz, methodID, args); - } - - jclass GetObjectClass(jobject obj) - { - return functions->GetObjectClass(this, obj); - } - - jboolean IsInstanceOf(jobject obj, jclass clazz) - { - return functions->IsInstanceOf(this, obj, clazz); - } - - jmethodID GetMethodID(jclass clazz, const char *name, const char *sig) - { - return functions->GetMethodID(this, clazz, name, sig); - } - -#define CALL_TYPE_METHOD(_jtype, _jname) \ - \ _jtype Call##_jname##Method(jobject obj, jmethodID methodID, ...) \ - { \ - _jtype result; \ - va_list args; \ - va_start(args, methodID); \ - result = functions->Call##_jname##MethodV(this, obj, methodID, \ - args); \ - va_end(args); \ - return result; \ - } -#define CALL_TYPE_METHODV(_jtype, _jname) \ - \ _jtype Call##_jname##MethodV(jobject obj, jmethodID methodID, \ - va_list args) \ - { \ - return functions->Call##_jname##MethodV(this, obj, methodID, args); \ - } -#define CALL_TYPE_METHODA(_jtype, _jname) \ - \ _jtype Call##_jname##MethodA(jobject obj, jmethodID methodID, \ - const jvalue * _Nonnull args) \ - { \ - return functions->Call##_jname##MethodA(this, obj, methodID, args); \ - } - -#define CALL_TYPE(_jtype, _jname) \ - CALL_TYPE_METHOD(_jtype, _jname) \ - CALL_TYPE_METHODV(_jtype, _jname) \ - CALL_TYPE_METHODA(_jtype, _jname) - - CALL_TYPE(jobject, Object) - CALL_TYPE(jboolean, Boolean) - CALL_TYPE(jbyte, Byte) - CALL_TYPE(jchar, Char) - CALL_TYPE(jshort, Short) - CALL_TYPE(jint, Int) - CALL_TYPE(jlong, Long) - CALL_TYPE(jfloat, Float) - CALL_TYPE(jdouble, Double) - - void CallVoidMethod(jobject obj, jmethodID methodID, ...) - { - va_list args; - va_start(args, methodID); - functions->CallVoidMethodV(this, obj, methodID, args); - va_end(args); - } - void CallVoidMethodV(jobject obj, jmethodID methodID, va_list args) - { - functions->CallVoidMethodV(this, obj, methodID, args); - } - void CallVoidMethodA(jobject obj, jmethodID methodID, const jvalue * _Nonnull args) - { - functions->CallVoidMethodA(this, obj, methodID, args); - } - -#define CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ - \ _jtype CallNonvirtual##_jname##Method(jobject obj, jclass clazz, \ - jmethodID methodID, ...) \ - { \ - _jtype result; \ - va_list args; \ - va_start(args, methodID); \ - result = functions->CallNonvirtual##_jname##MethodV(this, obj, \ - clazz, methodID, args); \ - va_end(args); \ - return result; \ - } -#define CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ - \ _jtype CallNonvirtual##_jname##MethodV(jobject obj, jclass clazz, \ - jmethodID methodID, va_list args) \ - { \ - return functions->CallNonvirtual##_jname##MethodV(this, obj, clazz, \ - methodID, args); \ - } -#define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) \ - \ _jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz, \ - jmethodID methodID, const jvalue * _Nonnull args) \ - { \ - return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz, \ - methodID, args); \ - } - -#define CALL_NONVIRT_TYPE(_jtype, _jname) \ - CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \ - CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \ - CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) - - CALL_NONVIRT_TYPE(jobject, Object) - CALL_NONVIRT_TYPE(jboolean, Boolean) - CALL_NONVIRT_TYPE(jbyte, Byte) - CALL_NONVIRT_TYPE(jchar, Char) - CALL_NONVIRT_TYPE(jshort, Short) - CALL_NONVIRT_TYPE(jint, Int) - CALL_NONVIRT_TYPE(jlong, Long) - CALL_NONVIRT_TYPE(jfloat, Float) - CALL_NONVIRT_TYPE(jdouble, Double) - - void CallNonvirtualVoidMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) - { - va_list args; - va_start(args, methodID); - functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); - va_end(args); - } - void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, - jmethodID methodID, va_list args) - { - functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); - } - void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, - jmethodID methodID, const jvalue * _Nonnull args) - { - functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); - } - - jfieldID GetFieldID(jclass clazz, const char *name, const char *sig) - { - return functions->GetFieldID(this, clazz, name, sig); - } - - jobject GetObjectField(jobject obj, jfieldID fieldID) - { - return functions->GetObjectField(this, obj, fieldID); - } - jboolean GetBooleanField(jobject obj, jfieldID fieldID) - { - return functions->GetBooleanField(this, obj, fieldID); - } - jbyte GetByteField(jobject obj, jfieldID fieldID) - { - return functions->GetByteField(this, obj, fieldID); - } - jchar GetCharField(jobject obj, jfieldID fieldID) - { - return functions->GetCharField(this, obj, fieldID); - } - jshort GetShortField(jobject obj, jfieldID fieldID) - { - return functions->GetShortField(this, obj, fieldID); - } - jint GetIntField(jobject obj, jfieldID fieldID) - { - return functions->GetIntField(this, obj, fieldID); - } - jlong GetLongField(jobject obj, jfieldID fieldID) - { - return functions->GetLongField(this, obj, fieldID); - } - - jfloat GetFloatField(jobject obj, jfieldID fieldID) - { - return functions->GetFloatField(this, obj, fieldID); - } - - jdouble GetDoubleField(jobject obj, jfieldID fieldID) - { - return functions->GetDoubleField(this, obj, fieldID); - } - - void SetObjectField(jobject obj, jfieldID fieldID, jobject value) - { - functions->SetObjectField(this, obj, fieldID, value); - } - void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value) - { - functions->SetBooleanField(this, obj, fieldID, value); - } - void SetByteField(jobject obj, jfieldID fieldID, jbyte value) - { - functions->SetByteField(this, obj, fieldID, value); - } - void SetCharField(jobject obj, jfieldID fieldID, jchar value) - { - functions->SetCharField(this, obj, fieldID, value); - } - void SetShortField(jobject obj, jfieldID fieldID, jshort value) - { - functions->SetShortField(this, obj, fieldID, value); - } - void SetIntField(jobject obj, jfieldID fieldID, jint value) - { - functions->SetIntField(this, obj, fieldID, value); - } - void SetLongField(jobject obj, jfieldID fieldID, jlong value) - { - functions->SetLongField(this, obj, fieldID, value); - } - - void SetFloatField(jobject obj, jfieldID fieldID, jfloat value) - { - functions->SetFloatField(this, obj, fieldID, value); - } - - void SetDoubleField(jobject obj, jfieldID fieldID, jdouble value) - { - functions->SetDoubleField(this, obj, fieldID, value); - } - - jmethodID GetStaticMethodID(jclass clazz, const char *name, const char *sig) - { - return functions->GetStaticMethodID(this, clazz, name, sig); - } - -#define CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ - \ _jtype CallStatic##_jname##Method(jclass clazz, jmethodID methodID, \ - ...) \ - { \ - _jtype result; \ - va_list args; \ - va_start(args, methodID); \ - result = functions->CallStatic##_jname##MethodV(this, clazz, \ - methodID, args); \ - va_end(args); \ - return result; \ - } -#define CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ - \ _jtype CallStatic##_jname##MethodV(jclass clazz, jmethodID methodID, \ - va_list args) \ - { \ - return functions->CallStatic##_jname##MethodV(this, clazz, methodID, \ - args); \ - } -#define CALL_STATIC_TYPE_METHODA(_jtype, _jname) \ - \ _jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID, \ - const jvalue * _Nonnull args) \ - { \ - return functions->CallStatic##_jname##MethodA(this, clazz, methodID, \ - args); \ - } - -#define CALL_STATIC_TYPE(_jtype, _jname) \ - CALL_STATIC_TYPE_METHOD(_jtype, _jname) \ - CALL_STATIC_TYPE_METHODV(_jtype, _jname) \ - CALL_STATIC_TYPE_METHODA(_jtype, _jname) - - CALL_STATIC_TYPE(jobject, Object) - CALL_STATIC_TYPE(jboolean, Boolean) - CALL_STATIC_TYPE(jbyte, Byte) - CALL_STATIC_TYPE(jchar, Char) - CALL_STATIC_TYPE(jshort, Short) - CALL_STATIC_TYPE(jint, Int) - CALL_STATIC_TYPE(jlong, Long) - CALL_STATIC_TYPE(jfloat, Float) - CALL_STATIC_TYPE(jdouble, Double) - - void CallStaticVoidMethod(jclass clazz, jmethodID methodID, ...) - { - va_list args; - va_start(args, methodID); - functions->CallStaticVoidMethodV(this, clazz, methodID, args); - va_end(args); - } - void CallStaticVoidMethodV(jclass clazz, jmethodID methodID, va_list args) - { - functions->CallStaticVoidMethodV(this, clazz, methodID, args); - } - void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, const jvalue * _Nonnull args) - { - functions->CallStaticVoidMethodA(this, clazz, methodID, args); - } - - jfieldID GetStaticFieldID(jclass clazz, const char *name, const char *sig) - { - return functions->GetStaticFieldID(this, clazz, name, sig); - } - - jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) - { - return functions->GetStaticObjectField(this, clazz, fieldID); - } - jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) - { - return functions->GetStaticBooleanField(this, clazz, fieldID); - } - jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) - { - return functions->GetStaticByteField(this, clazz, fieldID); - } - jchar GetStaticCharField(jclass clazz, jfieldID fieldID) - { - return functions->GetStaticCharField(this, clazz, fieldID); - } - jshort GetStaticShortField(jclass clazz, jfieldID fieldID) - { - return functions->GetStaticShortField(this, clazz, fieldID); - } - jint GetStaticIntField(jclass clazz, jfieldID fieldID) - { - return functions->GetStaticIntField(this, clazz, fieldID); - } - jlong GetStaticLongField(jclass clazz, jfieldID fieldID) - { - return functions->GetStaticLongField(this, clazz, fieldID); - } - - jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) - { - return functions->GetStaticFloatField(this, clazz, fieldID); - } - - jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) - { - return functions->GetStaticDoubleField(this, clazz, fieldID); - } - - void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value) - { - functions->SetStaticObjectField(this, clazz, fieldID, value); - } - void SetStaticBooleanField(jclass clazz, jfieldID fieldID, jboolean value) - { - functions->SetStaticBooleanField(this, clazz, fieldID, value); - } - void SetStaticByteField(jclass clazz, jfieldID fieldID, jbyte value) - { - functions->SetStaticByteField(this, clazz, fieldID, value); - } - void SetStaticCharField(jclass clazz, jfieldID fieldID, jchar value) - { - functions->SetStaticCharField(this, clazz, fieldID, value); - } - void SetStaticShortField(jclass clazz, jfieldID fieldID, jshort value) - { - functions->SetStaticShortField(this, clazz, fieldID, value); - } - void SetStaticIntField(jclass clazz, jfieldID fieldID, jint value) - { - functions->SetStaticIntField(this, clazz, fieldID, value); - } - void SetStaticLongField(jclass clazz, jfieldID fieldID, jlong value) - { - functions->SetStaticLongField(this, clazz, fieldID, value); - } - - void SetStaticFloatField(jclass clazz, jfieldID fieldID, jfloat value) - { - functions->SetStaticFloatField(this, clazz, fieldID, value); - } - - void SetStaticDoubleField(jclass clazz, jfieldID fieldID, jdouble value) - { - functions->SetStaticDoubleField(this, clazz, fieldID, value); - } - - jstring NewString(const jchar *unicodeChars, jsize len) - { - return functions->NewString(this, unicodeChars, len); - } - - jsize GetStringLength(jstring string) - { - return functions->GetStringLength(this, string); - } - - const jchar *GetStringChars(jstring string, jboolean *isCopy) - { - return functions->GetStringChars(this, string, isCopy); - } - - void ReleaseStringChars(jstring string, const jchar *chars) - { - functions->ReleaseStringChars(this, string, chars); - } - - jstring NewStringUTF(const char *bytes) - { - return functions->NewStringUTF(this, bytes); - } - - jsize GetStringUTFLength(jstring string) - { - return functions->GetStringUTFLength(this, string); - } - - const char *GetStringUTFChars(jstring string, jboolean *isCopy) - { - return functions->GetStringUTFChars(this, string, isCopy); - } - - void ReleaseStringUTFChars(jstring string, const char *utf) - { - functions->ReleaseStringUTFChars(this, string, utf); - } - - jsize GetArrayLength(jarray array) - { - return functions->GetArrayLength(this, array); - } - - jobjectArray NewObjectArray(jsize length, jclass elementClass, - jobject initialElement) - { - return functions->NewObjectArray(this, length, elementClass, - initialElement); - } - - jobject GetObjectArrayElement(jobjectArray array, jsize index) - { - return functions->GetObjectArrayElement(this, array, index); - } - - void SetObjectArrayElement(jobjectArray array, jsize index, jobject value) - { - functions->SetObjectArrayElement(this, array, index, value); - } - - jbooleanArray NewBooleanArray(jsize length) - { - return functions->NewBooleanArray(this, length); - } - jbyteArray NewByteArray(jsize length) - { - return functions->NewByteArray(this, length); - } - jcharArray NewCharArray(jsize length) - { - return functions->NewCharArray(this, length); - } - jshortArray NewShortArray(jsize length) - { - return functions->NewShortArray(this, length); - } - jintArray NewIntArray(jsize length) - { - return functions->NewIntArray(this, length); - } - jlongArray NewLongArray(jsize length) - { - return functions->NewLongArray(this, length); - } - jfloatArray NewFloatArray(jsize length) - { - return functions->NewFloatArray(this, length); - } - jdoubleArray NewDoubleArray(jsize length) - { - return functions->NewDoubleArray(this, length); - } - - jboolean *GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) - { - return functions->GetBooleanArrayElements(this, array, isCopy); - } - jbyte *GetByteArrayElements(jbyteArray array, jboolean *isCopy) - { - return functions->GetByteArrayElements(this, array, isCopy); - } - jchar *GetCharArrayElements(jcharArray array, jboolean *isCopy) - { - return functions->GetCharArrayElements(this, array, isCopy); - } - jshort *GetShortArrayElements(jshortArray array, jboolean *isCopy) - { - return functions->GetShortArrayElements(this, array, isCopy); - } - jint *GetIntArrayElements(jintArray array, jboolean *isCopy) - { - return functions->GetIntArrayElements(this, array, isCopy); - } - jlong *GetLongArrayElements(jlongArray array, jboolean *isCopy) - { - return functions->GetLongArrayElements(this, array, isCopy); - } - jfloat *GetFloatArrayElements(jfloatArray array, jboolean *isCopy) - { - return functions->GetFloatArrayElements(this, array, isCopy); - } - jdouble *GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) - { - return functions->GetDoubleArrayElements(this, array, isCopy); - } - - void ReleaseBooleanArrayElements(jbooleanArray array, jboolean *elems, - jint mode) - { - functions->ReleaseBooleanArrayElements(this, array, elems, mode); - } - void ReleaseByteArrayElements(jbyteArray array, jbyte *elems, - jint mode) - { - functions->ReleaseByteArrayElements(this, array, elems, mode); - } - void ReleaseCharArrayElements(jcharArray array, jchar *elems, - jint mode) - { - functions->ReleaseCharArrayElements(this, array, elems, mode); - } - void ReleaseShortArrayElements(jshortArray array, jshort *elems, - jint mode) - { - functions->ReleaseShortArrayElements(this, array, elems, mode); - } - void ReleaseIntArrayElements(jintArray array, jint *elems, - jint mode) - { - functions->ReleaseIntArrayElements(this, array, elems, mode); - } - void ReleaseLongArrayElements(jlongArray array, jlong *elems, - jint mode) - { - functions->ReleaseLongArrayElements(this, array, elems, mode); - } - void ReleaseFloatArrayElements(jfloatArray array, jfloat *elems, - jint mode) - { - functions->ReleaseFloatArrayElements(this, array, elems, mode); - } - void ReleaseDoubleArrayElements(jdoubleArray array, jdouble *elems, - jint mode) - { - functions->ReleaseDoubleArrayElements(this, array, elems, mode); - } - - void GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, - jboolean *buf) - { - functions->GetBooleanArrayRegion(this, array, start, len, buf); - } - void GetByteArrayRegion(jbyteArray array, jsize start, jsize len, - jbyte *buf) - { - functions->GetByteArrayRegion(this, array, start, len, buf); - } - void GetCharArrayRegion(jcharArray array, jsize start, jsize len, - jchar *buf) - { - functions->GetCharArrayRegion(this, array, start, len, buf); - } - void GetShortArrayRegion(jshortArray array, jsize start, jsize len, - jshort *buf) - { - functions->GetShortArrayRegion(this, array, start, len, buf); - } - void GetIntArrayRegion(jintArray array, jsize start, jsize len, - jint *buf) - { - functions->GetIntArrayRegion(this, array, start, len, buf); - } - void GetLongArrayRegion(jlongArray array, jsize start, jsize len, - jlong *buf) - { - functions->GetLongArrayRegion(this, array, start, len, buf); - } - void GetFloatArrayRegion(jfloatArray array, jsize start, jsize len, - jfloat *buf) - { - functions->GetFloatArrayRegion(this, array, start, len, buf); - } - void GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, - jdouble *buf) - { - functions->GetDoubleArrayRegion(this, array, start, len, buf); - } - - void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, - const jboolean *buf) - { - functions->SetBooleanArrayRegion(this, array, start, len, buf); - } - void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, - const jbyte *buf) - { - functions->SetByteArrayRegion(this, array, start, len, buf); - } - void SetCharArrayRegion(jcharArray array, jsize start, jsize len, - const jchar *buf) - { - functions->SetCharArrayRegion(this, array, start, len, buf); - } - void SetShortArrayRegion(jshortArray array, jsize start, jsize len, - const jshort *buf) - { - functions->SetShortArrayRegion(this, array, start, len, buf); - } - void SetIntArrayRegion(jintArray array, jsize start, jsize len, - const jint *buf) - { - functions->SetIntArrayRegion(this, array, start, len, buf); - } - void SetLongArrayRegion(jlongArray array, jsize start, jsize len, - const jlong *buf) - { - functions->SetLongArrayRegion(this, array, start, len, buf); - } - void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, - const jfloat *buf) - { - functions->SetFloatArrayRegion(this, array, start, len, buf); - } - void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, - const jdouble *buf) - { - functions->SetDoubleArrayRegion(this, array, start, len, buf); - } - - jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, - jint nMethods) - { - return functions->RegisterNatives(this, clazz, methods, nMethods); - } - - jint UnregisterNatives(jclass clazz) - { - return functions->UnregisterNatives(this, clazz); - } - - jint MonitorEnter(jobject obj) - { - return functions->MonitorEnter(this, obj); - } - - jint MonitorExit(jobject obj) - { - return functions->MonitorExit(this, obj); - } - - jint GetJavaVM(JavaVM **vm) - { - return functions->GetJavaVM(this, vm); - } - - void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) - { - functions->GetStringRegion(this, str, start, len, buf); - } - - void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) - { - return functions->GetStringUTFRegion(this, str, start, len, buf); - } - - void *GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) - { - return functions->GetPrimitiveArrayCritical(this, array, isCopy); - } - - void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) - { - functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); - } - - const jchar *GetStringCritical(jstring string, jboolean *isCopy) - { - return functions->GetStringCritical(this, string, isCopy); - } - - void ReleaseStringCritical(jstring string, const jchar *carray) - { - functions->ReleaseStringCritical(this, string, carray); - } - - jweak NewWeakGlobalRef(jobject obj) - { - return functions->NewWeakGlobalRef(this, obj); - } - - void DeleteWeakGlobalRef(jweak obj) - { - functions->DeleteWeakGlobalRef(this, obj); - } - - jboolean ExceptionCheck() - { - return functions->ExceptionCheck(this); - } - - jobject NewDirectByteBuffer(void *address, jlong capacity) - { - return functions->NewDirectByteBuffer(this, address, capacity); - } - - void *GetDirectBufferAddress(jobject buf) - { - return functions->GetDirectBufferAddress(this, buf); - } - - jlong GetDirectBufferCapacity(jobject buf) - { - return functions->GetDirectBufferCapacity(this, buf); - } - - /* added in JNI 1.6 */ - jobjectRefType GetObjectRefType(jobject obj) - { - return functions->GetObjectRefType(this, obj); - } -#endif /*__cplusplus*/ -}; - -/* - * JNI invocation interface. - */ -struct JNIInvokeInterface -{ - void * _Null_unspecified reserved0; - void * _Null_unspecified reserved1; - void * _Null_unspecified reserved2; - - jint (* _Nonnull DestroyJavaVM)(JavaVM * _Nonnull); - jint (* _Nonnull AttachCurrentThread)(JavaVM * _Nonnull, JNIEnv * _Nullable * _Nullable, void * _Nullable); - jint (* _Nonnull DetachCurrentThread)(JavaVM * _Nonnull); - jint (* _Nonnull GetEnv)(JavaVM * _Nonnull, void * _Nullable * _Nullable, jint); - jint (* _Nonnull AttachCurrentThreadAsDaemon)(JavaVM * _Nonnull, JNIEnv * _Nullable * _Nullable, void * _Nullable); -}; - -/* - * C++ version. - */ -struct _JavaVM -{ - const struct JNIInvokeInterface * _Nonnull functions; - -#if defined(__cplusplus) - jint DestroyJavaVM() - { - return functions->DestroyJavaVM(this); - } - jint AttachCurrentThread(JNIEnv **p_env, void *thr_args) - { - return functions->AttachCurrentThread(this, p_env, thr_args); - } - jint DetachCurrentThread() - { - return functions->DetachCurrentThread(this); - } - jint GetEnv(void **env, jint version) - { - return functions->GetEnv(this, env, version); - } - jint AttachCurrentThreadAsDaemon(JNIEnv **p_env, void *thr_args) - { - return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); - } -#endif /*__cplusplus*/ -}; - -struct JavaVMAttachArgs -{ - jint version; /** must be >= JNI_VERSION_1_2 */ - const char * _Nullable name; /** NULL or name of thread as modified UTF-8 str */ - jobject group; /** global ref of a ThreadGroup object, or NULL */ -}; -typedef struct JavaVMAttachArgs JavaVMAttachArgs; - -/* - * JNI 1.2+ initialization. (As of 1.6, the pre-1.2 structures are no - * longer supported.) - */ -typedef struct JavaVMOption -{ - const char * _Nullable optionString; - void * _Nullable extraInfo; -} JavaVMOption; - -typedef struct JavaVMInitArgs -{ - jint version; /* use JNI_VERSION_1_2 or later */ - - jint nOptions; - JavaVMOption * _Nonnull options; - jboolean ignoreUnrecognized; -} JavaVMInitArgs; - -#ifdef __cplusplus -extern "C" { -#endif -/* - * VM initialization functions. - * - * Note these are the only symbols exported for JNI by the VM. - */ -#if 0 /* In practice, these are not exported by the NDK so don't declare them */ -jint JNI_GetDefaultJavaVMInitArgs(void* _Nonnull); -jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void* _Nonnull); -jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize* _Nonnull); -#endif - -#define JNIIMPORT -#define JNIEXPORT __attribute__((visibility("default"))) -#define JNICALL - -/* - * Prototypes for functions exported by loadable shared libs. These are - * called by JNI, not provided by JNI. - */ -JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM * _Nonnull vm, void * _Nullable reserved); -JNIEXPORT void JNICALL JNI_OnUnload(JavaVM * _Nonnull vm, void * _Nullable reserved); - -#ifdef __cplusplus -} -#endif - -/* - * Manifest constants. - */ -#define JNI_FALSE 0 -#define JNI_TRUE 1 - -#define JNI_VERSION_1_1 0x00010001 -#define JNI_VERSION_1_2 0x00010002 -#define JNI_VERSION_1_4 0x00010004 -#define JNI_VERSION_1_6 0x00010006 - -#define JNI_OK (0) /* no error */ -#define JNI_ERR (-1) /* generic error */ -#define JNI_EDETACHED (-2) /* thread detached from the VM */ -#define JNI_EVERSION (-3) /* JNI version error */ -#define JNI_ENOMEM (-4) /* Out of memory */ -#define JNI_EEXIST (-5) /* VM already created */ -#define JNI_EINVAL (-6) /* Invalid argument */ - -#define JNI_COMMIT 1 /* copy content, do not free buffer */ -#define JNI_ABORT 2 /* free buffer w/o copying back */ - diff --git a/Sources/CJNI/include/module.modulemap b/Sources/CJNI/include/module.modulemap deleted file mode 100644 index 86fca51..0000000 --- a/Sources/CJNI/include/module.modulemap +++ /dev/null @@ -1,4 +0,0 @@ -module CJNI { - header "cjni.h" - export * -} diff --git a/Sources/JNI/Array+JavaParameterConvertible.swift b/Sources/JNI/Array+JavaParameterConvertible.swift index 12b44c5..404eb38 100644 --- a/Sources/JNI/Array+JavaParameterConvertible.swift +++ b/Sources/JNI/Array+JavaParameterConvertible.swift @@ -5,8 +5,6 @@ // Created by flowing erik on 19.07.17. // -import CJNI - extension String { func replacingFullstopsWithSlashes() -> String { return String(self.map { $0 == "." ? "/" : $0 }) diff --git a/Sources/JNI/CMakeLists.txt b/Sources/JNI/CMakeLists.txt index 10c4447..1d0c283 100644 --- a/Sources/JNI/CMakeLists.txt +++ b/Sources/JNI/CMakeLists.txt @@ -21,7 +21,4 @@ set_target_properties(JNI PROPERTIES INTERFACE_LINK_DIRECTORIES $ INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY}) -target_compile_options(JNI PUBLIC - SHELL: -I ${SwiftJNI_SOURCE_DIR}/Sources/CJNI) - # TODO Add ${SwiftJNI_SOURCE_DIR}/Sources/CJNI to interface include dirs? diff --git a/Sources/JNI/JNI.swift b/Sources/JNI/JNI.swift index b954f27..a571d11 100644 --- a/Sources/JNI/JNI.swift +++ b/Sources/JNI/JNI.swift @@ -1,18 +1,18 @@ -@_exported import CJNI // "_exported" so we don't have to import both CJNI and JNI all the time +import Android public class JNI { /// Our reference to the Java Virtual Machine, to be set on init - let _jvm: UnsafeMutablePointer + let _jvm: UnsafeMutablePointer /// Ensure the _env pointer we have is always attached to the JVM - var _env: UnsafeMutablePointer { - let jvm = _jvm.pointee.pointee + var _env: UnsafeMutablePointer { + let jvm = _jvm.pointee!.pointee // The type `JNIEnv` is defined as a non-mutable pointer, // so use this mutable _tmpPointer as an intermediate: var _tmpPointer: UnsafeMutableRawPointer? let threadStatus = jvm.GetEnv(_jvm, &_tmpPointer, JavaInt(JNI_VERSION_1_6)) - var _env = _tmpPointer?.bindMemory(to: JNIEnv.self, capacity: 1) + var _env = _tmpPointer?.bindMemory(to: Optional.self, capacity: 1) switch threadStatus { case JNI_OK: break // if we're already attached, do nothing @@ -29,7 +29,7 @@ public class JNI { // Normally we init the jni global ourselves in JNI_OnLoad - public init?(jvm: UnsafeMutablePointer) { + public init?(jvm: UnsafeMutablePointer) { self._jvm = jvm } } @@ -37,36 +37,36 @@ public class JNI { public extension JNI { func GetVersion() -> JavaInt { let env = self._env - return env.pointee.pointee.GetVersion(env) + return env.pointee!.pointee.GetVersion(env) } - func GetJavaVM(vm: UnsafeMutablePointer>) -> JavaInt { + func GetJavaVM(vm: UnsafeMutablePointer?>) -> JavaInt { let env = self._env - return env.pointee.pointee.GetJavaVM(env, vm) + return env.pointee!.pointee.GetJavaVM(env, vm) } func RegisterNatives(targetClass: JavaClass, _ methods: UnsafePointer, _ nMethods: JavaInt) -> JavaInt { let env = self._env - return env.pointee.pointee.RegisterNatives(env, targetClass, methods, nMethods) + return env.pointee!.pointee.RegisterNatives(env, targetClass, methods, nMethods) } func UnregisterNatives(targetClass: JavaClass) -> JavaInt { let env = self._env - return env.pointee.pointee.UnregisterNatives(env, targetClass) + return env.pointee!.pointee.UnregisterNatives(env, targetClass) } func MonitorEnter(obj: JavaObject) -> JavaInt { let env = self._env - return env.pointee.pointee.MonitorEnter(env, obj) + return env.pointee!.pointee.MonitorEnter(env, obj) } func MonitorExit(obj: JavaObject) -> JavaInt { let env = self._env - return env.pointee.pointee.MonitorExit(env, obj) + return env.pointee!.pointee.MonitorExit(env, obj) } func GetDirectBufferAddress(buffer: JavaObject) -> UnsafeMutableRawPointer? { let env = self._env - return env.pointee.pointee.GetDirectBufferAddress(env, buffer) + return env.pointee!.pointee.GetDirectBufferAddress(env, buffer) } } diff --git a/Sources/JNI/JNIClassManipulation.swift b/Sources/JNI/JNIClassManipulation.swift index f07eafc..00dd77f 100644 --- a/Sources/JNI/JNIClassManipulation.swift +++ b/Sources/JNI/JNIClassManipulation.swift @@ -1,45 +1,38 @@ -import CJNI - public extension JNI { - // func DefineClass(name: String, _ loader: JavaObject, _ buffer: UnsafePointer, _ bufferLength: jsize) -> JavaClass { - // let env = self._env - // return env.pointee.pointee.DefineClass(env, name, loader, buffer, bufferLength)! - // } - - func FindClass(name: String) throws -> JavaClass { - let env = self._env - let result = env.pointee.pointee.FindClass(env, name.replacingFullstopsWithSlashes()) + func FindClass(name: String) throws -> JavaClass { + let env = self._env + let result = env.pointee!.pointee.FindClass(env, name.replacingFullstopsWithSlashes()) try checkAndThrowOnJNIError() return result! - } + } - func FromReflectedMethod(method: JavaObject) -> JavaMethodID { - let env = self._env - return env.pointee.pointee.FromReflectedMethod(env, method)! - } + func FromReflectedMethod(method: JavaObject) -> JavaMethodID { + let env = self._env + return env.pointee!.pointee.FromReflectedMethod(env, method)! + } func FromReflectedField(field: JavaObject) -> JavaFieldID { - let env = self._env - return env.pointee.pointee.FromReflectedField(env, field)! - } + let env = self._env + return env.pointee!.pointee.FromReflectedField(env, field)! + } - func ToReflectedMethod(targetClass: JavaClass, _ methodID: JavaMethodID, _ isStatic: JavaBoolean) -> JavaObject { - let env = self._env - return env.pointee.pointee.ToReflectedMethod(env, targetClass, methodID, isStatic)! - } + func ToReflectedMethod(targetClass: JavaClass, _ methodID: JavaMethodID, _ isStatic: JavaBoolean) -> JavaObject { + let env = self._env + return env.pointee!.pointee.ToReflectedMethod(env, targetClass, methodID, isStatic)! + } - func GetSuperclass(targetClass: JavaClass) -> JavaClass { - let env = self._env - return env.pointee.pointee.GetSuperclass(env, targetClass)! - } + func GetSuperclass(targetClass: JavaClass) -> JavaClass { + let env = self._env + return env.pointee!.pointee.GetSuperclass(env, targetClass)! + } - func IsAssignableFrom(classA: JavaClass, _ classB: JavaClass) -> JavaBoolean { - let env = self._env - return env.pointee.pointee.IsAssignableFrom(env, classA, classB) - } + func IsAssignableFrom(classA: JavaClass, _ classB: JavaClass) -> JavaBoolean { + let env = self._env + return env.pointee!.pointee.IsAssignableFrom(env, classA, classB) + } func ToReflectedField(targetClass: JavaClass, _ fieldID: JavaFieldID, _ isStatic: JavaBoolean) -> JavaObject { - let env = self._env - return env.pointee.pointee.ToReflectedField(env, targetClass, fieldID, isStatic)! - } + let env = self._env + return env.pointee!.pointee.ToReflectedField(env, targetClass, fieldID, isStatic)! + } } diff --git a/Sources/JNI/JNIExceptions.swift b/Sources/JNI/JNIExceptions.swift index 38541ba..7d5aba4 100644 --- a/Sources/JNI/JNIExceptions.swift +++ b/Sources/JNI/JNIExceptions.swift @@ -1,38 +1,36 @@ -import CJNI - public extension JNI { func ExceptionCheck() -> Bool { let env = self._env - return env.pointee.pointee.ExceptionCheck(env) == true + return env.pointee!.pointee.ExceptionCheck(env) == .true } func ExceptionDescribe() { let env = self._env - env.pointee.pointee.ExceptionDescribe(env) + env.pointee!.pointee.ExceptionDescribe(env) } func ExceptionClear() { let env = self._env - env.pointee.pointee.ExceptionClear(env) + env.pointee!.pointee.ExceptionClear(env) } func ExceptionOccurred() -> JavaThrowable { let env = self._env - return env.pointee.pointee.ExceptionOccurred(env)! + return env.pointee!.pointee.ExceptionOccurred(env)! } func Throw(obj: JavaThrowable) -> JavaInt { let env = self._env - return env.pointee.pointee.Throw(env, obj) + return env.pointee!.pointee.Throw(env, obj) } func ThrowNew(targetClass: JavaClass, _ message: String) -> JavaInt { let env = self._env - return env.pointee.pointee.ThrowNew(env, targetClass, message) + return env.pointee!.pointee.ThrowNew(env, targetClass, message) } func FatalError(msg: String) { let env = self._env - env.pointee.pointee.FatalError(env, msg) + env.pointee?.pointee.FatalError(env, msg) } } diff --git a/Sources/JNI/JNIFields.swift b/Sources/JNI/JNIFields.swift index c52425f..328926a 100644 --- a/Sources/JNI/JNIFields.swift +++ b/Sources/JNI/JNIFields.swift @@ -5,12 +5,10 @@ // Created by flowing erik on 01.08.17. // -import CJNI - public extension JNI { func GetStaticField(_ fieldName: String, on javaClass: JavaClass) throws -> T { let env = self._env - let fieldID = env.pointee.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) + let fieldID = env.pointee!.pointee.GetStaticFieldID(env, javaClass, fieldName, T.asJNIParameterString) try checkAndThrowOnJNIError() return try T.fromStaticField(fieldID!, of: javaClass) } @@ -21,7 +19,7 @@ public extension JNI { defer { jni.DeleteLocalRef(javaClass) } - let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) + let fieldID = env.pointee!.pointee.GetFieldID(env, javaClass, fieldName, T.asJNIParameterString) try checkAndThrowOnJNIError() return try T.fromField(fieldID!, on: javaObject) } @@ -32,7 +30,7 @@ public extension JNI { defer { jni.DeleteLocalRef(javaClass) } - let fieldID = env.pointee.pointee.GetFieldID(env, javaClass, fieldName, "L\(fieldJavaClassName);") + let fieldID = env.pointee!.pointee.GetFieldID(env, javaClass, fieldName, "L\(fieldJavaClassName);") try checkAndThrowOnJNIError() return try JavaObject.fromField(fieldID!, on: javaObject) } @@ -44,42 +42,42 @@ public extension JNI { func GetBooleanField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaBoolean { let _env = self._env - let result = _env.pointee.pointee.GetBooleanField(_env, javaObject, id) + let result = _env.pointee!.pointee.GetBooleanField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } func GetIntField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaInt { let _env = self._env - let result = _env.pointee.pointee.GetIntField(_env, javaObject, id) + let result = _env.pointee!.pointee.GetIntField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } func GetFloatField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaFloat { let _env = self._env - let result = _env.pointee.pointee.GetFloatField(_env, javaObject, id) + let result = _env.pointee!.pointee.GetFloatField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } func GetLongField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaLong { let _env = self._env - let result = _env.pointee.pointee.GetLongField(_env, javaObject, id) + let result = _env.pointee!.pointee.GetLongField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } func GetDoubleField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaDouble { let _env = self._env - let result = _env.pointee.pointee.GetDoubleField(_env, javaObject, id) + let result = _env.pointee!.pointee.GetDoubleField(_env, javaObject, id) try checkAndThrowOnJNIError() return result } func GetObjectField(of javaObject: JavaObject, id: JavaFieldID) throws -> JavaObject { let _env = self._env - let result = _env.pointee.pointee.GetObjectField(_env, javaObject, id) + let result = _env.pointee!.pointee.GetObjectField(_env, javaObject, id) try checkAndThrowOnJNIError() return result! } @@ -88,42 +86,42 @@ public extension JNI { func GetStaticBooleanField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaBoolean { let _env = self._env - let result = _env.pointee.pointee.GetStaticBooleanField(_env, javaClass, id) + let result = _env.pointee!.pointee.GetStaticBooleanField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } func GetStaticIntField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaInt { let _env = self._env - let result = _env.pointee.pointee.GetStaticIntField(_env, javaClass, id) + let result = _env.pointee!.pointee.GetStaticIntField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } func GetStaticFloatField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaFloat { let _env = self._env - let result = _env.pointee.pointee.GetStaticFloatField(_env, javaClass, id) + let result = _env.pointee!.pointee.GetStaticFloatField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } func GetStaticLongField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaLong { let _env = self._env - let result = _env.pointee.pointee.GetStaticLongField(_env, javaClass, id) + let result = _env.pointee!.pointee.GetStaticLongField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } func GetStaticDoubleField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaDouble { let _env = self._env - let result = _env.pointee.pointee.GetStaticDoubleField(_env, javaClass, id) + let result = _env.pointee!.pointee.GetStaticDoubleField(_env, javaClass, id) try checkAndThrowOnJNIError() return result } func GetStaticObjectField(of javaClass: JavaClass, id: JavaFieldID) throws -> JavaObject { let _env = self._env - guard let result = _env.pointee.pointee.GetStaticObjectField(_env, javaClass, id) else { throw JNIError() } + guard let result = _env.pointee!.pointee.GetStaticObjectField(_env, javaClass, id) else { throw JNIError() } try checkAndThrowOnJNIError() return result } diff --git a/Sources/JNI/JNIMethods.swift b/Sources/JNI/JNIMethods.swift index 6f4cace..38eb026 100644 --- a/Sources/JNI/JNIMethods.swift +++ b/Sources/JNI/JNIMethods.swift @@ -1,5 +1,3 @@ -import CJNI - enum SwiftJNIError: Error { case invalidMethodID(_ methodSignature: String) } @@ -70,11 +68,11 @@ public extension JNI { public extension JNI { func GetMethodID(for object: JavaObject, methodName: String, methodSignature: String) throws -> JavaMethodID { let _env = self._env - let objectClass = _env.pointee.pointee.GetObjectClass(_env, object) + let objectClass = _env.pointee!.pointee.GetObjectClass(_env, object) try checkAndThrowOnJNIError() - let result = _env.pointee.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) - _env.pointee.pointee.DeleteLocalRef(_env, objectClass) + let result = _env.pointee!.pointee.GetMethodID(_env, objectClass!, methodName, methodSignature) + _env.pointee!.pointee.DeleteLocalRef(_env, objectClass) try checkAndThrowOnJNIError() return result! @@ -82,7 +80,7 @@ public extension JNI { func GetStaticMethodID(for javaClass: JavaClass, methodName: String, methodSignature: String) throws -> JavaMethodID { let _env = self._env - guard let result = _env.pointee.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) else { + guard let result = _env.pointee!.pointee.GetStaticMethodID(_env, javaClass, methodName, methodSignature) else { throw SwiftJNIError.invalidMethodID(methodSignature) } @@ -97,14 +95,14 @@ public extension JNI { func CallVoidMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws { let _env = self._env var methodArgs = parameters - _env.pointee.pointee.CallVoidMethod(_env, object, method, &methodArgs) + _env.pointee!.pointee.CallVoidMethodA(_env, object, method, &methodArgs) try checkAndThrowOnJNIError() } func CallBooleanMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaBoolean { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallBooleanMethod(_env, object, method, &methodArgs) + let result = _env.pointee!.pointee.CallBooleanMethodA(_env, object, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -112,7 +110,7 @@ public extension JNI { func CallIntMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaInt { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallIntMethod(_env, object, method, &methodArgs) + let result = _env.pointee!.pointee.CallIntMethodA(_env, object, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -120,7 +118,7 @@ public extension JNI { func CallFloatMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaFloat { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallFloatMethod(_env, object, method, &methodArgs) + let result = _env.pointee!.pointee.CallFloatMethodA(_env, object, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -128,7 +126,7 @@ public extension JNI { func CallLongMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaLong { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallLongMethod(_env, object, method, &methodArgs) + let result = _env.pointee!.pointee.CallLongMethodA(_env, object, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -136,7 +134,7 @@ public extension JNI { func CallDoubleMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaDouble { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallDoubleMethod(_env, object, method, &methodArgs) + let result = _env.pointee!.pointee.CallDoubleMethodA(_env, object, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -144,7 +142,7 @@ public extension JNI { func CallObjectMethod(_ method: JavaMethodID, on object: JavaObject, parameters: [JavaParameter]) throws -> JavaObject { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallObjectMethod(_env, object, method, &methodArgs) + let result = _env.pointee!.pointee.CallObjectMethodA(_env, object, method, &methodArgs) try checkAndThrowOnJNIError() return result! } @@ -157,7 +155,7 @@ public extension JNI { func CallStaticObjectMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaObject { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticObjectMethodA(_env, javaClass, method, &methodArgs) + let result = _env.pointee!.pointee.CallStaticObjectMethodA(_env, javaClass, method, &methodArgs) try checkAndThrowOnJNIError() return result! // we checked for error in the line above } @@ -165,15 +163,15 @@ public extension JNI { func CallStaticBooleanMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> Bool { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) + let result = _env.pointee!.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) try checkAndThrowOnJNIError() - return result == true + return result == .true } func CallStaticIntMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaInt { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) + let result = _env.pointee!.pointee.CallStaticIntMethodA(_env, javaClass, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -181,7 +179,7 @@ public extension JNI { func CallStaticLongMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaLong { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticLongMethodA(_env, javaClass, method, &methodArgs) + let result = _env.pointee!.pointee.CallStaticLongMethodA(_env, javaClass, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -189,7 +187,7 @@ public extension JNI { func CallStaticFloatMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaFloat { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticFloatMethodA(_env, javaClass, method, &methodArgs) + let result = _env.pointee!.pointee.CallStaticFloatMethodA(_env, javaClass, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -197,7 +195,7 @@ public extension JNI { func CallStaticDoubleMethod(_ method: JavaMethodID, on javaClass: JavaClass, parameters: [JavaParameter]) throws -> JavaDouble { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticDoubleMethodA(_env, javaClass, method, &methodArgs) + let result = _env.pointee!.pointee.CallStaticDoubleMethodA(_env, javaClass, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -205,7 +203,7 @@ public extension JNI { func CallStaticBooleanMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws -> JavaBoolean { let _env = self._env var methodArgs = parameters - let result = _env.pointee.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) + let result = _env.pointee!.pointee.CallStaticBooleanMethodA(_env, javaClass, method, &methodArgs) try checkAndThrowOnJNIError() return result } @@ -213,7 +211,7 @@ public extension JNI { func CallStaticVoidMethod(javaClass: JavaClass, method: JavaMethodID, parameters: [JavaParameter]) throws { let _env = self._env var methodArgs = parameters - _env.pointee.pointee.CallStaticVoidMethodA(_env, javaClass, method, &methodArgs) + _env.pointee!.pointee.CallStaticVoidMethodA(_env, javaClass, method, &methodArgs) try checkAndThrowOnJNIError() } } diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 8e41224..bdacbc1 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -1,4 +1,3 @@ -import CJNI import Dispatch /// Designed to simplify calling a constructor and methods on a JavaClass @@ -13,7 +12,7 @@ open class JNIObject: JavaParameterConvertible { } public func toJavaParameter() -> JavaParameter { - return JavaParameter(object: self.instance) + return JavaParameter(l: self.instance) } private static var classInstances = [String: JavaClass]() @@ -122,7 +121,7 @@ extension JNI { on targetClass: JavaClass, arguments: [JavaParameterConvertible] = [] ) throws -> JavaObject? { - let methodID = _env.pointee.pointee.GetMethodID(_env, targetClass, "", arguments.methodSignature(returnType: nil)) + let methodID = _env.pointee!.pointee.GetMethodID(_env, targetClass, "", arguments.methodSignature(returnType: nil)) try checkAndThrowOnJNIError() return try jni.NewObject(targetClass: targetClass, methodID!, arguments.asJavaParameters()) @@ -133,7 +132,7 @@ public extension JNI { func NewObject(targetClass: JavaClass, _ methodID: JavaMethodID, _ args: [JavaParameter]) throws -> JavaObject? { let env = self._env var mutableArgs = args - let newObject = env.pointee.pointee.NewObject(env, targetClass, methodID, &mutableArgs) + let newObject = env.pointee!.pointee.NewObjectA(env, targetClass, methodID, &mutableArgs) try checkAndThrowOnJNIError() return newObject @@ -141,7 +140,7 @@ public extension JNI { func GetObjectClass(obj: JavaObject) throws -> JavaClass { let env = self._env - let result = env.pointee.pointee.GetObjectClass(env, obj) + let result = env.pointee!.pointee.GetObjectClass(env, obj) try checkAndThrowOnJNIError() return result! } diff --git a/Sources/JNI/JNIRefs.swift b/Sources/JNI/JNIRefs.swift index fe2e738..511ed4b 100644 --- a/Sources/JNI/JNIRefs.swift +++ b/Sources/JNI/JNIRefs.swift @@ -1,64 +1,62 @@ -import CJNI - public extension JNI { func NewGlobalRef(_ object: JavaObject) -> JavaObject? { let env = self._env - return env.pointee.pointee.NewGlobalRef(env, object) + return env.pointee!.pointee.NewGlobalRef(env, object) } func DeleteGlobalRef(_ globalRef: JavaObject) { let env = self._env - env.pointee.pointee.DeleteGlobalRef(env, globalRef) + env.pointee!.pointee.DeleteGlobalRef(env, globalRef) } func NewLocalRef(_ ref: JavaObject) -> JavaObject? { let env = self._env - return env.pointee.pointee.NewLocalRef(env, ref) + return env.pointee!.pointee.NewLocalRef(env, ref) } func DeleteLocalRef(_ localRef: JavaObject) { let env = self._env - env.pointee.pointee.DeleteLocalRef(env, localRef) + env.pointee!.pointee.DeleteLocalRef(env, localRef) } func PushLocalFrame(_ capacity: JavaInt) -> JavaInt { let env = self._env - return env.pointee.pointee.PushLocalFrame(env, capacity) + return env.pointee!.pointee.PushLocalFrame(env, capacity) } func PopLocalFrame(_ result: JavaObject) -> JavaObject { let env = self._env - return env.pointee.pointee.PopLocalFrame(env, result)! + return env.pointee!.pointee.PopLocalFrame(env, result)! } func EnsureLocalCapacity(_ capacity: JavaInt) -> JavaInt { let env = self._env - return env.pointee.pointee.EnsureLocalCapacity(env, capacity) + return env.pointee!.pointee.EnsureLocalCapacity(env, capacity) } func IsSameObject(_ ref1: JavaObject, _ ref2: JavaObject) -> JavaBoolean { let env = self._env - return env.pointee.pointee.IsSameObject(env, ref1, ref2) + return env.pointee!.pointee.IsSameObject(env, ref1, ref2) } func IsInstanceOf(_ obj: JavaObject, _ targetClass: JavaClass) -> JavaBoolean { let env = self._env - return env.pointee.pointee.IsInstanceOf(env, obj, targetClass) + return env.pointee!.pointee.IsInstanceOf(env, obj, targetClass) } func NewWeakGlobalRef(_ obj: JavaObject) -> JavaWeakReference { let env = self._env - return env.pointee.pointee.NewWeakGlobalRef(env, obj)! + return env.pointee!.pointee.NewWeakGlobalRef(env, obj)! } func DeleteWeakGlobalRef(_ obj: JavaWeakReference) { let env = self._env - env.pointee.pointee.DeleteWeakGlobalRef(env, obj) + env.pointee!.pointee.DeleteWeakGlobalRef(env, obj) } /* added in 1: JNI.6 */ func GetObjectRefType(_ obj: JavaObject) -> JavaObjectRefType { let env = self._env - return env.pointee.pointee.GetObjectRefType(env, obj) + return env.pointee!.pointee.GetObjectRefType(env, obj) } } diff --git a/Sources/JNI/JNIStrings.swift b/Sources/JNI/JNIStrings.swift index 0a6cb9e..8058977 100644 --- a/Sources/JNI/JNIStrings.swift +++ b/Sources/JNI/JNIStrings.swift @@ -1,10 +1,8 @@ -import CJNI - public extension String { init(javaString: JavaString) throws { let env = jni._env - let chars = env.pointee.pointee.GetStringUTFChars(env, javaString, nil) - defer { env.pointee.pointee.ReleaseStringUTFChars(env, javaString, chars) } + let chars = env.pointee!.pointee.GetStringUTFChars(env, javaString, nil) + defer { env.pointee!.pointee.ReleaseStringUTFChars(env, javaString, chars) } try checkAndThrowOnJNIError() self.init(cString: chars!) @@ -12,63 +10,63 @@ public extension String { } public extension JNI { - func NewString(unicodeChars: UnsafePointer, _ length: jsize) -> JavaString { + func NewString(unicodeChars: UnsafePointer, _ length: JavaSize) -> JavaString { let env = self._env - return env.pointee.pointee.NewString(env, unicodeChars, length)! + return env.pointee!.pointee.NewString(env, unicodeChars, length)! } - func GetStringLength(_ jString: JavaString) -> jsize { + func GetStringLength(_ jString: JavaString) -> JavaSize { let env = self._env - return env.pointee.pointee.GetStringLength(env, jString) + return env.pointee!.pointee.GetStringLength(env, jString) } func GetStringChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env - return env.pointee.pointee.GetStringChars(env, jString, isCopy)! + return env.pointee!.pointee.GetStringChars(env, jString, isCopy)! } func ReleaseStringChars(_ jString: JavaString, _ chars: UnsafePointer) { let env = self._env - env.pointee.pointee.ReleaseStringChars(env, jString, chars) + env.pointee!.pointee.ReleaseStringChars(env, jString, chars) } func NewStringUTF(_ string: String) -> JavaString { let env = self._env - return env.pointee.pointee.NewStringUTF(env, string)! + return env.pointee!.pointee.NewStringUTF(env, string)! } - func GetStringUTFLength(_ jString: JavaString) -> jsize { + func GetStringUTFLength(_ jString: JavaString) -> JavaSize { let env = self._env - return env.pointee.pointee.GetStringUTFLength(env, jString) + return env.pointee!.pointee.GetStringUTFLength(env, jString) } func GetStringUTFChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> String { let env = self._env - return String(describing: env.pointee.pointee.GetStringUTFChars(env, jString, isCopy)) + return String(describing: env.pointee!.pointee.GetStringUTFChars(env, jString, isCopy)) } func ReleaseStringUTFChars(_ jString: JavaString, _ utf: String) { let env = self._env - env.pointee.pointee.ReleaseStringUTFChars(env, jString, utf) + env.pointee!.pointee.ReleaseStringUTFChars(env, jString, utf) } - func GetStringRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { + func GetStringRegion(_ jString: JavaString, _ start: JavaSize, _ length: JavaSize, _ buf: UnsafeMutablePointer) { let env = self._env - env.pointee.pointee.GetStringRegion(env, jString, start, length, buf) + env.pointee!.pointee.GetStringRegion(env, jString, start, length, buf) } - func GetStringUTFRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer) { + func GetStringUTFRegion(_ jString: JavaString, _ start: JavaSize, _ length: JavaSize, _ buf: UnsafeMutablePointer) { let env = self._env - env.pointee.pointee.GetStringUTFRegion(env, jString, start, length, buf) + env.pointee!.pointee.GetStringUTFRegion(env, jString, start, length, buf) } func GetStringCritical(_ jString: JavaString, _ isCopy: UnsafeMutablePointer) -> UnsafePointer { let env = self._env - return env.pointee.pointee.GetStringCritical(env, jString, isCopy)! + return env.pointee!.pointee.GetStringCritical(env, jString, isCopy)! } func ReleaseStringCritical(_ jString: JavaString, _ cArray: UnsafePointer) { let env = self._env - env.pointee.pointee.ReleaseStringCritical(env, jString, cArray) + env.pointee!.pointee.ReleaseStringCritical(env, jString, cArray) } } diff --git a/Sources/JNI/JavaParameterConvertible+Objects.swift b/Sources/JNI/JavaParameterConvertible+Objects.swift index 40de4fc..bced34e 100644 --- a/Sources/JNI/JavaParameterConvertible+Objects.swift +++ b/Sources/JNI/JavaParameterConvertible+Objects.swift @@ -1,5 +1,3 @@ -import CJNI - // JavaObject extension JavaObject: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitializableFromField { @@ -7,7 +5,7 @@ extension JavaObject: JavaParameterConvertible, JavaInitializableFromMethod, Jav public static let asJNIParameterString = "L\(javaClassname);" public func toJavaParameter() -> JavaParameter { - return JavaParameter(object: self) + return JavaParameter(l: self) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaObject { @@ -36,7 +34,7 @@ extension String: JavaParameterConvertible, JavaInitializableFromMethod, JavaIni public func toJavaParameter() -> JavaParameter { let stringAsObject = jni.NewStringUTF(self) - return JavaParameter(object: stringAsObject) + return JavaParameter(l: stringAsObject) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> String { @@ -73,7 +71,7 @@ public struct JavaContext: JavaParameterConvertible, JavaInitializableFromMethod public static let asJNIParameterString = "L\(javaClassname);" public func toJavaParameter() -> JavaParameter { - return JavaParameter(object: self.object) + return JavaParameter(l: self.object) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaContext { diff --git a/Sources/JNI/JavaParameterConvertible+Primitives.swift b/Sources/JNI/JavaParameterConvertible+Primitives.swift index 1b583be..be701b2 100644 --- a/Sources/JNI/JavaParameterConvertible+Primitives.swift +++ b/Sources/JNI/JavaParameterConvertible+Primitives.swift @@ -4,23 +4,23 @@ extension Bool: JavaParameterConvertible, JavaInitializableFromMethod, JavaIniti public static let asJNIParameterString = "Z" public func toJavaParameter() -> JavaParameter { - return JavaParameter(bool: (self) ? 1 : 0) + return JavaParameter(z: (self) ? 1 : 0) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Bool { - return try jni.GetStaticBooleanField(of: javaClass, id: fieldID) == JNI_TRUE + return try jni.GetStaticBooleanField(of: javaClass, id: fieldID) == .true } public static func fromMethod(calling methodID: JavaMethodID, on object: JavaObject, args: [JavaParameter]) throws -> Bool { - return try jni.CallBooleanMethod(methodID, on: object, parameters: args) == JNI_TRUE + return try jni.CallBooleanMethod(methodID, on: object, parameters: args) == .true } public static func fromStaticMethod(calling methodID: JavaMethodID, on javaClass: JavaClass, args: [JavaParameter]) throws -> Bool { - return try jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == JNI_TRUE + return try jni.CallStaticBooleanMethod(javaClass: javaClass, method: methodID, parameters: args) == .true } public static func fromField(_ fieldID: JavaFieldID, on javaObject: JavaObject) throws -> Bool { - return try jni.GetBooleanField(of: javaObject, id: fieldID) == JNI_TRUE + return try jni.GetBooleanField(of: javaObject, id: fieldID) == .true } } @@ -30,7 +30,7 @@ extension Int: JavaParameterConvertible, JavaInitializableFromMethod, JavaInitia public static let asJNIParameterString = "I" public func toJavaParameter() -> JavaParameter { - return JavaParameter(int: JavaInt(self)) + return JavaParameter(i: JavaInt(self)) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Int { @@ -57,7 +57,7 @@ extension JavaInt: JavaParameterConvertible, JavaInitializableFromMethod, JavaIn public static let asJNIParameterString = "I" public func toJavaParameter() -> JavaParameter { - return JavaParameter(int: self) + return JavaParameter(i: self) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaInt { @@ -84,7 +84,7 @@ extension Double: JavaParameterConvertible, JavaInitializableFromMethod, JavaIni public static let asJNIParameterString = "D" public func toJavaParameter() -> JavaParameter { - return JavaParameter(double: JavaDouble(self)) + return JavaParameter(d: JavaDouble(self)) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Double { @@ -111,7 +111,7 @@ extension Float: JavaParameterConvertible, JavaInitializableFromMethod, JavaInit public static let asJNIParameterString = "F" public func toJavaParameter() -> JavaParameter { - return JavaParameter(float: JavaFloat(self)) + return JavaParameter(f: JavaFloat(self)) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> Float { @@ -137,7 +137,7 @@ extension JavaLong: JavaParameterConvertible, JavaInitializableFromMethod, JavaI public static let asJNIParameterString = "J" public func toJavaParameter() -> JavaParameter { - return JavaParameter(long: self) + return JavaParameter(j: self) } public static func fromStaticField(_ fieldID: JavaFieldID, of javaClass: JavaClass) throws -> JavaLong { diff --git a/Sources/JNI/JavaParameterConvertible.swift b/Sources/JNI/JavaParameterConvertible.swift index 83bc4e8..0f96d85 100644 --- a/Sources/JNI/JavaParameterConvertible.swift +++ b/Sources/JNI/JavaParameterConvertible.swift @@ -5,8 +5,6 @@ // Created by flowing erik on 19.07.17. // -import CJNI - public protocol JavaParameterConvertible { typealias JavaMethod = ((JavaParameterConvertible...) throws -> Self) static var asJNIParameterString: String { get } diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index ae1801f..c25657c 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -1,17 +1,17 @@ -import CJNI +@_exported import jni public var jni: JNI! // this gets set "OnLoad" so should always exist #if !STATIC_SWIFT_STDLIB @_cdecl("JNI_OnLoad") -public func JNI_Onload(_ vm: UnsafeMutablePointer, _ reserved: UnsafeMutableRawPointer?) -> JavaInt { +public func JNI_Onload(_ vm: UnsafeMutablePointer, _ reserved: UnsafeMutableRawPointer?) -> JavaInt { return SwiftJNI_OnLoad(vm, reserved) } #endif // Can be called manually from another call to JNI_OnLoad // e.g. from the user's JNI_OnLoad function defined in the same static library -public func SwiftJNI_OnLoad(_ vm: UnsafeMutablePointer, _ reserved: UnsafeMutableRawPointer?) -> JavaInt { +public func SwiftJNI_OnLoad(_ vm: UnsafeMutablePointer, _ reserved: UnsafeMutableRawPointer?) -> JavaInt { guard let localJNI = JNI(jvm: vm) else { fatalError("Couldn't initialise JNI") } @@ -21,27 +21,26 @@ public func SwiftJNI_OnLoad(_ vm: UnsafeMutablePointer, _ reserved: Unsa } public func JNI_DetachCurrentThread() { - _ = jni._jvm.pointee.pointee.DetachCurrentThread(jni._jvm) + _ = jni._jvm.pointee!.pointee.DetachCurrentThread(jni._jvm) } -extension JavaBoolean : ExpressibleByBooleanLiteral { - public init(booleanLiteral value: Bool) { - self = value ? JavaBoolean(JNI_TRUE) : JavaBoolean(JNI_FALSE) - } +extension JavaBoolean { + static let `true` = JavaBoolean(JNI_TRUE) + static let `false` = JavaBoolean(JNI_FALSE) } // SwiftJNI Public API public extension JNI { func RegisterNatives(javaClass: JavaClass, methods: [JNINativeMethod]) -> Bool { let _env = self._env - let env = _env.pointee.pointee + let env = _env.pointee!.pointee let result = env.RegisterNatives(_env, javaClass, methods, JavaInt(methods.count)) return (result == 0) } func ThrowNew(message: String) { let _env = self._env - let env = _env.pointee.pointee + let env = _env.pointee!.pointee _ = env.ThrowNew(_env, env.FindClass(_env, "java/lang/Exception"), message) } @@ -49,20 +48,20 @@ public extension JNI { func GetLength(_ array: JavaArray) -> Int { let _env = self._env - let result = _env.pointee.pointee.GetArrayLength(_env, array) + let result = _env.pointee!.pointee.GetArrayLength(_env, array) return Int(result) } func NewIntArray(count: Int) throws -> JavaArray? { let _env = self._env - let result = _env.pointee.pointee.NewIntArray(_env, jsize(count)) + let result = _env.pointee!.pointee.NewIntArray(_env, jsize(count)) try checkAndThrowOnJNIError() return result } func NewByteArray(count: Int) throws -> JavaByteArray? { let _env = self._env - let result = _env.pointee.pointee.NewByteArray(_env, jsize(count)) + let result = _env.pointee!.pointee.NewByteArray(_env, jsize(count)) try checkAndThrowOnJNIError() return result } @@ -76,7 +75,7 @@ public extension JNI { } var result = [JavaByte](repeating: 0, count: count) - _env.pointee.pointee.GetByteArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + _env.pointee!.pointee.GetByteArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) // Conversion from Int8 (JavaByte) to UInt8: bitPattern-constructor ensures // that negative Int8 values do not cause a crash when trying convert them to UInt8 @@ -86,7 +85,7 @@ public extension JNI { func SetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, from sourceElements: Array) { let _env = self._env var newElements = sourceElements.map { JavaByte(bitPattern: $0) } // make mutable copy - _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + _env.pointee!.pointee.SetByteArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } func GetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, numElements: Int = -1) -> [JavaInt] { @@ -98,19 +97,19 @@ public extension JNI { } var result = [JavaInt](repeating: 0, count: count) - _env.pointee.pointee.GetIntArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + _env.pointee!.pointee.GetIntArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) return result } func SetIntArrayRegion(array: JavaIntArray, startIndex: Int = 0, from sourceElements: [Int]) { let _env = self._env var newElements = sourceElements.map { JavaInt($0) } // make mutable copy - _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + _env.pointee!.pointee.SetIntArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } func NewFloatArray(count: Int) throws -> JavaArray? { let _env = self._env - let result = _env.pointee.pointee.NewFloatArray(_env, jsize(count)) + let result = _env.pointee!.pointee.NewFloatArray(_env, jsize(count)) try checkAndThrowOnJNIError() return result } @@ -124,14 +123,14 @@ public extension JNI { } var result = [JavaFloat](repeating: 0, count: count) - _env.pointee.pointee.GetFloatArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + _env.pointee!.pointee.GetFloatArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) return result.map { Float($0) } } func SetFloatArrayRegion(array: JavaFloatArray, startIndex: Int = 0, from sourceElements: [Float]) { let _env = self._env var newElements = sourceElements.map { JavaFloat($0) } // make mutable copy - _env.pointee.pointee.SetArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + _env.pointee!.pointee.SetFloatArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) } func GetStrings(from array: JavaObjectArray) throws -> [String] { @@ -139,10 +138,10 @@ public extension JNI { let count = jni.GetLength(array) let strings: [String] = try (0 ..< count).map { i in - let jString: JavaString? = _env.pointee.pointee.GetObjectArrayElement(_env, array, jsize(i)) - let chars = _env.pointee.pointee.GetStringUTFChars(_env, jString, nil) + let jString: JavaString? = _env.pointee!.pointee.GetObjectArrayElement(_env, array, jsize(i)) + let chars = _env.pointee!.pointee.GetStringUTFChars(_env, jString, nil) try checkAndThrowOnJNIError() - defer { _env.pointee.pointee.ReleaseStringUTFChars(_env, jString, chars) } + defer { _env.pointee!.pointee.ReleaseStringUTFChars(_env, jString, chars) } return String(cString: chars!) } @@ -156,7 +155,7 @@ public extension JNI { if (index >= count) { throw JNIError() } - let jObj = _env.pointee.pointee.GetObjectArrayElement(_env, array, jsize(index)) + let jObj = _env.pointee!.pointee.GetObjectArrayElement(_env, array, jsize(index)) try checkAndThrowOnJNIError() return jObj! } @@ -183,3 +182,34 @@ func print(_ string: String) { androidPrint(5, "SwiftJNI", string) } #endif + +public typealias JavaBoolean = jboolean +public typealias JavaByte = jbyte +public typealias JavaChar = jchar +public typealias JavaShort = jshort +public typealias JavaInt = jint +public typealias JavaLong = jlong +public typealias JavaFloat = jfloat +public typealias JavaDouble = jdouble +public typealias JavaSize = jint + +public typealias JavaParameter = jvalue +public typealias JavaObjectRefType = jobjectRefType +public typealias JavaFieldID = jfieldID +public typealias JavaMethodID = jmethodID + +public typealias JavaObject = UnsafeMutableRawPointer +public typealias JavaClass = JavaObject +public typealias JavaString = JavaObject +public typealias JavaArray = JavaObject +public typealias JavaObjectArray = JavaArray +public typealias JavaBooleanArray = JavaArray +public typealias JavaByteArray = JavaArray +public typealias JavaCharArray = JavaArray +public typealias JavaShortArray = JavaArray +public typealias JavaIntArray = JavaArray +public typealias JavaLongArray = JavaArray +public typealias JavaFloatArray = JavaArray +public typealias JavaDoubleArray = JavaArray +public typealias JavaThrowable = JavaObject +public typealias JavaWeakReference = JavaObject diff --git a/Sources/JNI/isMainThread.swift b/Sources/JNI/isMainThread.swift index ae774fc..d68a130 100644 --- a/Sources/JNI/isMainThread.swift +++ b/Sources/JNI/isMainThread.swift @@ -1,5 +1,5 @@ -#if canImport(Bionic) -import Bionic +#if canImport(Android) +import Android @_silgen_name("syscall") public func syscallNonVariadic(_ number: Int) -> Int From fb5255e690d4fc3761b4391bfb8b093b310c0ac7 Mon Sep 17 00:00:00 2001 From: Erik Werner Date: Wed, 6 Nov 2024 10:01:59 +0100 Subject: [PATCH 81/84] Cleanup Package.swift and remove Xcode proj (#20) * xcode project: remove CJNI target * remove xcode project and and CJNI target from Package.swift * unconditionally import Android * cleanup --- JNI.xcodeproj/CJNI_Info.plist | 25 - JNI.xcodeproj/JNI_Info.plist | 25 - JNI.xcodeproj/project.pbxproj | 431 ------------------ .../contents.xcworkspacedata | 7 - .../xcschemes/xcschememanagement.plist | 12 - Package.swift | 5 +- Sources/JNI/isMainThread.swift | 11 +- 7 files changed, 3 insertions(+), 513 deletions(-) delete mode 100644 JNI.xcodeproj/CJNI_Info.plist delete mode 100644 JNI.xcodeproj/JNI_Info.plist delete mode 100644 JNI.xcodeproj/project.pbxproj delete mode 100644 JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata delete mode 100644 JNI.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist diff --git a/JNI.xcodeproj/CJNI_Info.plist b/JNI.xcodeproj/CJNI_Info.plist deleted file mode 100644 index 57ada9f..0000000 --- a/JNI.xcodeproj/CJNI_Info.plist +++ /dev/null @@ -1,25 +0,0 @@ - - - - CFBundleDevelopmentRegion - en - CFBundleExecutable - $(EXECUTABLE_NAME) - CFBundleIdentifier - $(PRODUCT_BUNDLE_IDENTIFIER) - CFBundleInfoDictionaryVersion - 6.0 - CFBundleName - $(PRODUCT_NAME) - CFBundlePackageType - FMWK - CFBundleShortVersionString - 1.0 - CFBundleSignature - ???? - CFBundleVersion - $(CURRENT_PROJECT_VERSION) - NSPrincipalClass - - - diff --git a/JNI.xcodeproj/JNI_Info.plist b/JNI.xcodeproj/JNI_Info.plist deleted file mode 100644 index 57ada9f..0000000 --- a/JNI.xcodeproj/JNI_Info.plist +++ /dev/null @@ -1,25 +0,0 @@ - - - - CFBundleDevelopmentRegion - en - CFBundleExecutable - $(EXECUTABLE_NAME) - CFBundleIdentifier - $(PRODUCT_BUNDLE_IDENTIFIER) - CFBundleInfoDictionaryVersion - 6.0 - CFBundleName - $(PRODUCT_NAME) - CFBundlePackageType - FMWK - CFBundleShortVersionString - 1.0 - CFBundleSignature - ???? - CFBundleVersion - $(CURRENT_PROJECT_VERSION) - NSPrincipalClass - - - diff --git a/JNI.xcodeproj/project.pbxproj b/JNI.xcodeproj/project.pbxproj deleted file mode 100644 index d799f44..0000000 --- a/JNI.xcodeproj/project.pbxproj +++ /dev/null @@ -1,431 +0,0 @@ -// !$*UTF8*$! -{ - archiveVersion = 1; - classes = { - }; - objectVersion = 46; - objects = { - -/* Begin PBXBuildFile section */ - 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */ = {isa = PBXBuildFile; fileRef = 034A7B8D1F30D18A0071A850 /* JNIFields.swift */; }; - 5C1AD870273C494F00195C8A /* isMainThread.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5C1AD86F273C494F00195C8A /* isMainThread.swift */; }; - 5CFFF4352016125500D989BC /* JavaParameterConvertible+Objects.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CFFF4332016125400D989BC /* JavaParameterConvertible+Objects.swift */; }; - 5CFFF4362016125500D989BC /* JavaParameterConvertible+Primitives.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CFFF4342016125500D989BC /* JavaParameterConvertible+Primitives.swift */; }; - OBJ_33 /* Array+JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_14 /* Array+JavaParameterConvertible.swift */; }; - OBJ_34 /* JNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_15 /* JNI.swift */; }; - OBJ_35 /* JNIClassManipulation.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_16 /* JNIClassManipulation.swift */; }; - OBJ_36 /* JNIExceptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_17 /* JNIExceptions.swift */; }; - OBJ_37 /* JNIMethods.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_18 /* JNIMethods.swift */; }; - OBJ_38 /* JNIObjects.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_19 /* JNIObjects.swift */; }; - OBJ_39 /* JNIRefs.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_20 /* JNIRefs.swift */; }; - OBJ_40 /* JNIStrings.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_21 /* JNIStrings.swift */; }; - OBJ_41 /* JavaParameterConvertible.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_22 /* JavaParameterConvertible.swift */; }; - OBJ_42 /* SwiftJNI.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_23 /* SwiftJNI.swift */; }; - OBJ_44 /* CJNI.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = "JNI::CJNI::Product" /* CJNI.framework */; }; - OBJ_51 /* cjni.c in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_9 /* cjni.c */; }; -/* End PBXBuildFile section */ - -/* Begin PBXContainerItemProxy section */ - 5C2714A61F2B6DC70026BBA9 /* PBXContainerItemProxy */ = { - isa = PBXContainerItemProxy; - containerPortal = OBJ_1 /* Project object */; - proxyType = 1; - remoteGlobalIDString = "JNI::CJNI"; - remoteInfo = CJNI; - }; -/* End PBXContainerItemProxy section */ - -/* Begin PBXFileReference section */ - 034A7B8D1F30D18A0071A850 /* JNIFields.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIFields.swift; sourceTree = ""; }; - 5C1AD86F273C494F00195C8A /* isMainThread.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = isMainThread.swift; sourceTree = ""; }; - 5CFFF4332016125400D989BC /* JavaParameterConvertible+Objects.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "JavaParameterConvertible+Objects.swift"; sourceTree = ""; }; - 5CFFF4342016125500D989BC /* JavaParameterConvertible+Primitives.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "JavaParameterConvertible+Primitives.swift"; sourceTree = ""; }; - "JNI::CJNI::Product" /* CJNI.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = CJNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; - "JNI::JNI::Product" /* JNI.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = JNI.framework; sourceTree = BUILT_PRODUCTS_DIR; }; - OBJ_11 /* jni.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = jni.h; sourceTree = ""; }; - OBJ_14 /* Array+JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Array+JavaParameterConvertible.swift"; sourceTree = ""; }; - OBJ_15 /* JNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNI.swift; sourceTree = ""; }; - OBJ_16 /* JNIClassManipulation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIClassManipulation.swift; sourceTree = ""; }; - OBJ_17 /* JNIExceptions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIExceptions.swift; sourceTree = ""; }; - OBJ_18 /* JNIMethods.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIMethods.swift; sourceTree = ""; }; - OBJ_19 /* JNIObjects.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIObjects.swift; sourceTree = ""; }; - OBJ_20 /* JNIRefs.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIRefs.swift; sourceTree = ""; }; - OBJ_21 /* JNIStrings.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JNIStrings.swift; sourceTree = ""; }; - OBJ_22 /* JavaParameterConvertible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JavaParameterConvertible.swift; sourceTree = ""; }; - OBJ_23 /* SwiftJNI.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SwiftJNI.swift; sourceTree = ""; }; - OBJ_6 /* Package.swift */ = {isa = PBXFileReference; explicitFileType = sourcecode.swift; path = Package.swift; sourceTree = ""; }; - OBJ_9 /* cjni.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = cjni.c; sourceTree = ""; }; -/* End PBXFileReference section */ - -/* Begin PBXFrameworksBuildPhase section */ - OBJ_43 /* Frameworks */ = { - isa = PBXFrameworksBuildPhase; - buildActionMask = 0; - files = ( - OBJ_44 /* CJNI.framework in Frameworks */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - OBJ_52 /* Frameworks */ = { - isa = PBXFrameworksBuildPhase; - buildActionMask = 0; - files = ( - ); - runOnlyForDeploymentPostprocessing = 0; - }; -/* End PBXFrameworksBuildPhase section */ - -/* Begin PBXGroup section */ - OBJ_10 /* include */ = { - isa = PBXGroup; - children = ( - OBJ_11 /* jni.h */, - ); - path = include; - sourceTree = ""; - }; - OBJ_13 /* JNI */ = { - isa = PBXGroup; - children = ( - OBJ_14 /* Array+JavaParameterConvertible.swift */, - OBJ_15 /* JNI.swift */, - OBJ_16 /* JNIClassManipulation.swift */, - OBJ_17 /* JNIExceptions.swift */, - 034A7B8D1F30D18A0071A850 /* JNIFields.swift */, - OBJ_18 /* JNIMethods.swift */, - OBJ_19 /* JNIObjects.swift */, - OBJ_20 /* JNIRefs.swift */, - OBJ_21 /* JNIStrings.swift */, - OBJ_22 /* JavaParameterConvertible.swift */, - 5CFFF4332016125400D989BC /* JavaParameterConvertible+Objects.swift */, - 5CFFF4342016125500D989BC /* JavaParameterConvertible+Primitives.swift */, - OBJ_23 /* SwiftJNI.swift */, - 5C1AD86F273C494F00195C8A /* isMainThread.swift */, - ); - name = JNI; - path = Sources/JNI; - sourceTree = SOURCE_ROOT; - }; - OBJ_24 /* Tests */ = { - isa = PBXGroup; - children = ( - ); - name = Tests; - sourceTree = SOURCE_ROOT; - }; - OBJ_25 /* Products */ = { - isa = PBXGroup; - children = ( - "JNI::JNI::Product" /* JNI.framework */, - "JNI::CJNI::Product" /* CJNI.framework */, - ); - name = Products; - sourceTree = BUILT_PRODUCTS_DIR; - }; - OBJ_5 = { - isa = PBXGroup; - children = ( - OBJ_6 /* Package.swift */, - OBJ_7 /* Sources */, - OBJ_24 /* Tests */, - OBJ_25 /* Products */, - ); - sourceTree = ""; - }; - OBJ_7 /* Sources */ = { - isa = PBXGroup; - children = ( - OBJ_8 /* CJNI */, - OBJ_13 /* JNI */, - ); - name = Sources; - sourceTree = SOURCE_ROOT; - }; - OBJ_8 /* CJNI */ = { - isa = PBXGroup; - children = ( - OBJ_9 /* cjni.c */, - OBJ_10 /* include */, - ); - name = CJNI; - path = Sources/CJNI; - sourceTree = SOURCE_ROOT; - }; -/* End PBXGroup section */ - -/* Begin PBXNativeTarget section */ - "JNI::CJNI" /* CJNI */ = { - isa = PBXNativeTarget; - buildConfigurationList = OBJ_47 /* Build configuration list for PBXNativeTarget "CJNI" */; - buildPhases = ( - OBJ_50 /* Sources */, - OBJ_52 /* Frameworks */, - ); - buildRules = ( - ); - dependencies = ( - ); - name = CJNI; - productName = CJNI; - productReference = "JNI::CJNI::Product" /* CJNI.framework */; - productType = "com.apple.product-type.framework"; - }; - "JNI::JNI" /* JNI */ = { - isa = PBXNativeTarget; - buildConfigurationList = OBJ_29 /* Build configuration list for PBXNativeTarget "JNI" */; - buildPhases = ( - OBJ_32 /* Sources */, - OBJ_43 /* Frameworks */, - ); - buildRules = ( - ); - dependencies = ( - OBJ_45 /* PBXTargetDependency */, - ); - name = JNI; - productName = JNI; - productReference = "JNI::JNI::Product" /* JNI.framework */; - productType = "com.apple.product-type.framework"; - }; -/* End PBXNativeTarget section */ - -/* Begin PBXProject section */ - OBJ_1 /* Project object */ = { - isa = PBXProject; - attributes = { - LastUpgradeCheck = 9999; - }; - buildConfigurationList = OBJ_2 /* Build configuration list for PBXProject "JNI" */; - compatibilityVersion = "Xcode 3.2"; - developmentRegion = English; - hasScannedForEncodings = 0; - knownRegions = ( - English, - en, - ); - mainGroup = OBJ_5; - productRefGroup = OBJ_25 /* Products */; - projectDirPath = ""; - projectRoot = ""; - targets = ( - "JNI::JNI" /* JNI */, - "JNI::CJNI" /* CJNI */, - ); - }; -/* End PBXProject section */ - -/* Begin PBXSourcesBuildPhase section */ - OBJ_32 /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 0; - files = ( - OBJ_33 /* Array+JavaParameterConvertible.swift in Sources */, - OBJ_34 /* JNI.swift in Sources */, - 5CFFF4352016125500D989BC /* JavaParameterConvertible+Objects.swift in Sources */, - OBJ_35 /* JNIClassManipulation.swift in Sources */, - OBJ_36 /* JNIExceptions.swift in Sources */, - OBJ_37 /* JNIMethods.swift in Sources */, - 034A7B8E1F30D18A0071A850 /* JNIFields.swift in Sources */, - OBJ_38 /* JNIObjects.swift in Sources */, - 5C1AD870273C494F00195C8A /* isMainThread.swift in Sources */, - 5CFFF4362016125500D989BC /* JavaParameterConvertible+Primitives.swift in Sources */, - OBJ_39 /* JNIRefs.swift in Sources */, - OBJ_40 /* JNIStrings.swift in Sources */, - OBJ_41 /* JavaParameterConvertible.swift in Sources */, - OBJ_42 /* SwiftJNI.swift in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - OBJ_50 /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 0; - files = ( - OBJ_51 /* cjni.c in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; -/* End PBXSourcesBuildPhase section */ - -/* Begin PBXTargetDependency section */ - OBJ_45 /* PBXTargetDependency */ = { - isa = PBXTargetDependency; - target = "JNI::CJNI" /* CJNI */; - targetProxy = 5C2714A61F2B6DC70026BBA9 /* PBXContainerItemProxy */; - }; -/* End PBXTargetDependency section */ - -/* Begin XCBuildConfiguration section */ - OBJ_3 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - CLANG_ENABLE_OBJC_ARC = YES; - COMBINE_HIDPI_IMAGES = YES; - COPY_PHASE_STRIP = NO; - DEBUG_INFORMATION_FORMAT = dwarf; - DYLIB_INSTALL_NAME_BASE = "@rpath"; - ENABLE_NS_ASSERTIONS = YES; - GCC_OPTIMIZATION_LEVEL = 0; - MACOSX_DEPLOYMENT_TARGET = 10.15; - ONLY_ACTIVE_ARCH = YES; - OTHER_SWIFT_FLAGS = "-DXcode"; - PRODUCT_NAME = "$(TARGET_NAME)"; - SDKROOT = macosx; - SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; - SWIFT_OPTIMIZATION_LEVEL = "-Onone"; - USE_HEADERMAP = NO; - }; - name = Debug; - }; - OBJ_30 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - ENABLE_TESTABILITY = YES; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = JNI.xcodeproj/JNI_Info.plist; - LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; - OTHER_LDFLAGS = "$(inherited)"; - OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; - PRODUCT_BUNDLE_IDENTIFIER = JNI; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = YES; - SWIFT_VERSION = 4.0; - TARGET_NAME = JNI; - }; - name = Debug; - }; - OBJ_31 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - ENABLE_TESTABILITY = YES; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = JNI.xcodeproj/JNI_Info.plist; - LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; - OTHER_LDFLAGS = "$(inherited)"; - OTHER_SWIFT_FLAGS = "$(inherited) -Xcc -fmodule-map-file=$(SRCROOT)/Sources/CJNI/include/module.modulemap"; - PRODUCT_BUNDLE_IDENTIFIER = JNI; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = YES; - SWIFT_VERSION = 4.0; - TARGET_NAME = JNI; - }; - name = Release; - }; - OBJ_4 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - CLANG_ENABLE_OBJC_ARC = YES; - COMBINE_HIDPI_IMAGES = YES; - COPY_PHASE_STRIP = YES; - DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; - DYLIB_INSTALL_NAME_BASE = "@rpath"; - GCC_OPTIMIZATION_LEVEL = s; - MACOSX_DEPLOYMENT_TARGET = 10.15; - OTHER_SWIFT_FLAGS = "-DXcode"; - PRODUCT_NAME = "$(TARGET_NAME)"; - SDKROOT = macosx; - SWIFT_ACTIVE_COMPILATION_CONDITIONS = SWIFT_PACKAGE; - SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; - USE_HEADERMAP = NO; - }; - name = Release; - }; - OBJ_48 /* Debug */ = { - isa = XCBuildConfiguration; - buildSettings = { - DEFINES_MODULE = NO; - ENABLE_TESTABILITY = YES; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = JNI.xcodeproj/CJNI_Info.plist; - LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; - OTHER_LDFLAGS = "$(inherited)"; - OTHER_SWIFT_FLAGS = "$(inherited)"; - PRODUCT_BUNDLE_IDENTIFIER = CJNI; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = YES; - TARGET_NAME = CJNI; - }; - name = Debug; - }; - OBJ_49 /* Release */ = { - isa = XCBuildConfiguration; - buildSettings = { - DEFINES_MODULE = NO; - ENABLE_TESTABILITY = YES; - FRAMEWORK_SEARCH_PATHS = ( - "$(inherited)", - "$(PLATFORM_DIR)/Developer/Library/Frameworks", - ); - HEADER_SEARCH_PATHS = ( - "$(inherited)", - "$(SRCROOT)/Sources/CJNI/include", - ); - INFOPLIST_FILE = JNI.xcodeproj/CJNI_Info.plist; - LD_RUNPATH_SEARCH_PATHS = "$(TOOLCHAIN_DIR)/usr/lib/swift/macosx"; - OTHER_LDFLAGS = "$(inherited)"; - OTHER_SWIFT_FLAGS = "$(inherited)"; - PRODUCT_BUNDLE_IDENTIFIER = CJNI; - PRODUCT_MODULE_NAME = "$(TARGET_NAME:c99extidentifier)"; - PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)"; - SKIP_INSTALL = YES; - TARGET_NAME = CJNI; - }; - name = Release; - }; -/* End XCBuildConfiguration section */ - -/* Begin XCConfigurationList section */ - OBJ_2 /* Build configuration list for PBXProject "JNI" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - OBJ_3 /* Debug */, - OBJ_4 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - OBJ_29 /* Build configuration list for PBXNativeTarget "JNI" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - OBJ_30 /* Debug */, - OBJ_31 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - OBJ_47 /* Build configuration list for PBXNativeTarget "CJNI" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - OBJ_48 /* Debug */, - OBJ_49 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; -/* End XCConfigurationList section */ - }; - rootObject = OBJ_1 /* Project object */; -} diff --git a/JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata deleted file mode 100644 index 919434a..0000000 --- a/JNI.xcodeproj/project.xcworkspace/contents.xcworkspacedata +++ /dev/null @@ -1,7 +0,0 @@ - - - - - diff --git a/JNI.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist b/JNI.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist deleted file mode 100644 index f212055..0000000 --- a/JNI.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist +++ /dev/null @@ -1,12 +0,0 @@ - - - - SchemeUserState - - JNI-Package.xcscheme - - - SuppressBuildableAutocreation - - - diff --git a/Package.swift b/Package.swift index ed5c6c4..9524845 100644 --- a/Package.swift +++ b/Package.swift @@ -5,10 +5,9 @@ import PackageDescription let package = Package( name: "JNI", products: [ - .library(name: "JNI", targets: ["JNI", "CJNI"]) + .library(name: "JNI", targets: ["JNI"]) ], targets: [ - .target(name: "JNI", dependencies: ["CJNI"]), - .target(name: "CJNI"), + .target(name: "JNI"), ] ) diff --git a/Sources/JNI/isMainThread.swift b/Sources/JNI/isMainThread.swift index d68a130..2319620 100644 --- a/Sources/JNI/isMainThread.swift +++ b/Sources/JNI/isMainThread.swift @@ -1,4 +1,3 @@ -#if canImport(Android) import Android @_silgen_name("syscall") @@ -6,12 +5,4 @@ public func syscallNonVariadic(_ number: Int) -> Int public var isMainThread: Bool { return syscallNonVariadic(Int(SYS_gettid)) == getpid() -} -#elseif canImport(Darwin) -import Darwin -import Foundation // free on Darwin, expensive elsewhere - -public var isMainThread: Bool { - return Thread.isMainThread -} -#endif +} \ No newline at end of file From 5dd8f6c950ba48bc345461bcad72a3635edddbb6 Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Mon, 11 Nov 2024 19:28:56 +0100 Subject: [PATCH 82/84] Align JNIObject.call[Static] with jni.call[Static] method signatures --- Sources/JNI/JNIObjects.swift | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index bdacbc1..55a485d 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -76,12 +76,12 @@ open class JNIObject: JavaParameterConvertible { jni.DeleteGlobalRef(instance) } - public func call(methodName: String, arguments: [JavaParameterConvertible] = []) throws { + public func call(_ methodName: String, arguments: [JavaParameterConvertible] = []) throws { try jni.call(methodName, on: self.instance, arguments: arguments) } public func call( - methodName: String, + _ methodName: String, arguments: [JavaParameterConvertible] = [] ) throws -> T { return try jni.call(methodName, on: self.instance, arguments: arguments) @@ -97,12 +97,12 @@ open class JNIObject: JavaParameterConvertible { return try jni.GetField(fieldName, fieldJavaClassName: fieldJavaClassName, from: self.instance) } - public static func callStatic(methodName: String, arguments: [JavaParameterConvertible] = []) throws { + public static func callStatic(_ methodName: String, arguments: [JavaParameterConvertible] = []) throws { try jni.callStatic(methodName, on: self.javaClass, arguments: arguments) } public static func callStatic( - methodName: String, + _ methodName: String, arguments: [JavaParameterConvertible] = [] ) throws -> T { return try jni.callStatic(methodName, on: self.javaClass, arguments: arguments) From ac833a7b31b42ae0701c4a84494e2eb839aae56e Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Mon, 11 Nov 2024 19:29:38 +0100 Subject: [PATCH 83/84] Add public JavaBoolean.true/.false definitions. Add BooleanArray methods --- Sources/JNI/SwiftJNI.swift | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/Sources/JNI/SwiftJNI.swift b/Sources/JNI/SwiftJNI.swift index c25657c..2bea416 100644 --- a/Sources/JNI/SwiftJNI.swift +++ b/Sources/JNI/SwiftJNI.swift @@ -24,7 +24,7 @@ public func JNI_DetachCurrentThread() { _ = jni._jvm.pointee!.pointee.DetachCurrentThread(jni._jvm) } -extension JavaBoolean { +public extension JavaBoolean { static let `true` = JavaBoolean(JNI_TRUE) static let `false` = JavaBoolean(JNI_FALSE) } @@ -66,6 +66,33 @@ public extension JNI { return result } + func NewBooleanArray(count: Int) throws -> JavaBooleanArray? { + let _env = self._env + let result = _env.pointee!.pointee.NewBooleanArray(_env, jsize(count)) + try checkAndThrowOnJNIError() + return result + } + + func GetBooleanArrayRegion(array: JavaBooleanArray, startIndex: Int = 0, numElements: Int = -1) -> [Bool] { + let _env = self._env + var count = numElements + + if numElements < 0 { + count = GetLength(array) + } + + var result = [JavaBoolean](repeating: 0, count: count) + _env.pointee!.pointee.GetBooleanArrayRegion(_env, array, jsize(startIndex), jsize(count), &result) + + return result.map { $0 == .true } + } + + func SetBooleanArrayRegion(array: JavaBooleanArray, startIndex: Int = 0, from sourceElements: [Bool]) { + let _env = self._env + var newElements = sourceElements.map { $0 ? JavaBoolean.true : .false } // make mutable copy + _env.pointee!.pointee.SetBooleanArrayRegion(_env, array, jsize(startIndex), jsize(newElements.count), &newElements) + } + func GetByteArrayRegion(array: JavaByteArray, startIndex: Int = 0, numElements: Int = -1) -> [UInt8] { let _env = self._env var count = numElements From 3d0a1c686b602afaf5b9eb372de98b3232306a9a Mon Sep 17 00:00:00 2001 From: Geordie Jay Date: Tue, 12 Nov 2024 23:33:34 +0100 Subject: [PATCH 84/84] Add Sendable conformance (WIP) --- Sources/JNI/JNIObjects.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/JNI/JNIObjects.swift b/Sources/JNI/JNIObjects.swift index 55a485d..88a84b1 100644 --- a/Sources/JNI/JNIObjects.swift +++ b/Sources/JNI/JNIObjects.swift @@ -2,7 +2,7 @@ import Dispatch /// Designed to simplify calling a constructor and methods on a JavaClass /// Subclass this and add the methods appropriate to the object you are constructing. -open class JNIObject: JavaParameterConvertible { +open class JNIObject: JavaParameterConvertible, Sendable { open class var className: String { return "java.lang.object" }