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 $<TARGET_LINKER_FILE_DIR:JNI>
+    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<UnsafeMutablePointer<JavaVM>>) -> JavaInt {
+    func GetJavaVM(vm: UnsafeMutablePointer<UnsafeMutablePointer<JavaVM>>) -> JavaInt {
         let env = self._env
         return env.pointee.pointee.GetJavaVM(env, vm)
     }
 
-    public func RegisterNatives(targetClass: JavaClass, _ methods: UnsafePointer<JNINativeMethod>, _ nMethods: JavaInt) -> JavaInt {
+    func RegisterNatives(targetClass: JavaClass, _ methods: UnsafePointer<JNINativeMethod>, _ 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<JavaByte>, _ bufferLength: jsize) -> JavaClass {
+	// func DefineClass(name: String, _ loader: JavaObject, _ buffer: UnsafePointer<JavaByte>, _ 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<T: JavaInitializableFromField & JavaParameterConvertible>(_ fieldName: String, on javaClass: JavaClass) throws -> T {
+     func GetStaticField<T: JavaInitializableFromField & JavaParameterConvertible>(_ 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<T: JavaInitializableFromField & JavaParameterConvertible>(_ fieldName: String, from javaObject: JavaObject) throws -> T {
+    func GetField<T: JavaInitializableFromField & JavaParameterConvertible>(_ 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<T: JavaInitializableFromMethod & JavaParameterConvertible>(_ methodName: String, on javaClass: JavaClass, arguments: [JavaParameterConvertible] = []) throws -> T {
+    func callStatic<T: JavaInitializableFromMethod & JavaParameterConvertible>(_ 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<T: JavaInitializableFromMethod & JavaParameterConvertible>(_ methodName: String, on object: JavaObject, arguments: [JavaParameterConvertible] = []) throws -> T {
+    func call<T: JavaInitializableFromMethod & JavaParameterConvertible>(_ 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<JavaChar>, _ length: jsize) -> JavaString {
+	func NewString(unicodeChars: UnsafePointer<JavaChar>, _ 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<JavaBoolean>) -> UnsafePointer<JavaChar> {
+	func GetStringChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer<JavaBoolean>) -> UnsafePointer<JavaChar> {
 	    let env = self._env
         return env.pointee.pointee.GetStringChars(env, jString, isCopy)!
 	}
 
-	public func ReleaseStringChars(_ jString: JavaString, _ chars: UnsafePointer<JavaChar>) {
+	func ReleaseStringChars(_ jString: JavaString, _ chars: UnsafePointer<JavaChar>) {
 	    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<JavaBoolean>) -> String {
+	func GetStringUTFChars(_ jString: JavaString, _ isCopy: UnsafeMutablePointer<JavaBoolean>) -> 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<JavaChar>) {
+	func GetStringRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer<JavaChar>) {
 	    let env = self._env
 	    env.pointee.pointee.GetStringRegion(env, jString, start, length, buf)
 	}
 
-	public func GetStringUTFRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer<CChar>) {
+	func GetStringUTFRegion(_ jString: JavaString, _ start: jsize, _ length: jsize, _ buf: UnsafeMutablePointer<CChar>) {
 	    let env = self._env
 	    env.pointee.pointee.GetStringUTFRegion(env, jString, start, length, buf)
 	}
 
-	public func GetStringCritical(_ jString: JavaString, _ isCopy: UnsafeMutablePointer<JavaBoolean>) -> UnsafePointer<JavaChar> {
+	func GetStringCritical(_ jString: JavaString, _ isCopy: UnsafeMutablePointer<JavaBoolean>) -> UnsafePointer<JavaChar> {
 	    let env = self._env
         return env.pointee.pointee.GetStringCritical(env, jString, isCopy)!
 	}
 
-	public func ReleaseStringCritical(_ jString: JavaString, _ cArray: UnsafePointer<JavaChar>) {
+	func ReleaseStringCritical(_ jString: JavaString, _ cArray: UnsafePointer<JavaChar>) {
 	    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<JavaVM>, 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) {