Fixed the mem::uninitialized warnings (#240)

* Fixed the `mem::uninitialized` errors by using `MaybeUninit` and added a few missing `dyn`s.

* Implemented error for `AssetError`

* Implemented error for `AssetError`

* Update lib.rs

* Fixes some more warnings about improper c types

Author: OptimisticPeach

cargo-apk/injected-glue/lib.rs

@@ -295,9 +295,10 @@ pub fn android_main2<F>(app: *mut ffi::android_app, main_function: F)
                 }
             }
 
-            let mut thread = mem::uninitialized();
-            let result = pthread_create(&mut thread, ptr::null(), logging_thread,
+            let mut thread = mem::MaybeUninit::uninit();
+            let result = pthread_create(thread.as_mut_ptr(), ptr::null(), logging_thread,
                                         pfd[0] as usize as *mut c_void);
+            let thread = thread.assume_init();
             assert_eq!(result, 0);
             let result = pthread_detach(thread);
             assert_eq!(result, 0);
@@ -344,14 +345,14 @@ pub fn android_main2<F>(app: *mut ffi::android_app, main_function: F)
                 break;
             }
 
-            let mut events = mem::uninitialized();
-            let mut source: *mut ffi::android_poll_source = mem::uninitialized();
+            let mut events = mem::MaybeUninit::uninit();
+            let mut source: mem::MaybeUninit<*mut ffi::android_poll_source> = mem::MaybeUninit::uninit();
 
             // A `-1` means to block forever, but any other positive value
             // specifies the number of milliseconds to block for, before
             // returning.
-            let code = ffi::ALooper_pollAll(-1, ptr::null_mut(), &mut events,
-                                            &mut source as *mut _ as *mut _);
+            let code = ffi::ALooper_pollAll(-1, ptr::null_mut(), events.as_mut_ptr(),
+                                            source.as_mut_ptr() as *mut _ as *mut _);
             if code == ffi::ALOOPER_POLL_WAKE {
                 send_event(Event::Wake)
             }
@@ -369,7 +370,7 @@ pub fn android_main2<F>(app: *mut ffi::android_app, main_function: F)
                 // the user will get a locked UI until the system terminates our
                 // process. So we continue processing events..
             }
-
+            let source = source.assume_init();
             // Processing the event
             if !source.is_null() {
                 ((*source).process)(ANDROID_APP, source);

glue/src/lib.rs

@@ -2,13 +2,13 @@
 
 extern {
     fn cargo_apk_injected_glue_get_native_window() -> *const c_void;
-    fn cargo_apk_injected_glue_add_sender(sender: *mut ());
-    fn cargo_apk_injected_glue_add_sender_missing(sender: *mut ());
-    fn cargo_apk_injected_glue_add_sync_event_handler(sender: *mut ());
-    fn cargo_apk_injected_glue_remove_sync_event_handler(sender: *mut ());
+    fn cargo_apk_injected_glue_add_sender(sender: *mut c_void);
+    fn cargo_apk_injected_glue_add_sender_missing(sender: *mut c_void);
+    fn cargo_apk_injected_glue_add_sync_event_handler(sender: *mut c_void);
+    fn cargo_apk_injected_glue_remove_sync_event_handler(sender: *mut c_void);
     fn cargo_apk_injected_glue_set_multitouch(multitouch: bool);
-    fn cargo_apk_injected_glue_write_log(ptr: *const (), len: usize);
-    fn cargo_apk_injected_glue_load_asset(ptr: *const (), len: usize) -> *mut c_void;
+    fn cargo_apk_injected_glue_write_log(ptr: *const c_void, len: usize);
+    fn cargo_apk_injected_glue_load_asset(ptr: *const c_void, len: usize) -> *mut c_void;
     fn cargo_apk_injected_glue_wake_event_loop();
 }
 
@@ -60,11 +60,20 @@ pub enum MotionAction {
     Cancel,
 }
 
+#[derive(Clone, Copy, Debug)]
 pub enum AssetError {
     AssetMissing,
     EmptyBuffer,
 }
 
+impl std::fmt::Display for AssetError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl std::error::Error for AssetError {}
+
 // Trait used to dispatch sync events from the polling loop thread.
 pub trait SyncEventHandler {
     fn handle(&mut self, event: &Event);
@@ -81,7 +90,7 @@ pub fn add_sender(sender: Sender<Event>) {
 
 /// Adds a SyncEventHandler which will receive sync events from the polling loop.
 #[inline]
-pub fn add_sync_event_handler(handler: Box<SyncEventHandler>) {
+pub fn add_sync_event_handler(handler: Box<dyn SyncEventHandler>) {
     unsafe {
         let handler = Box::into_raw(Box::new(handler)) as *mut _;
         cargo_apk_injected_glue_add_sync_event_handler(handler);
@@ -90,7 +99,7 @@ pub fn add_sync_event_handler(handler: Box<SyncEventHandler>) {
 
 /// Removes a SyncEventHandler.
 #[inline]
-pub fn remove_sync_event_handler(handler: *const SyncEventHandler) {
+pub fn remove_sync_event_handler(handler: *const dyn SyncEventHandler) {
     unsafe {
         let handler = Box::into_raw(Box::new(handler)) as *mut _;
         cargo_apk_injected_glue_remove_sync_event_handler(handler);
@@ -143,7 +152,7 @@ pub fn load_asset(filename: &str) -> Result<Vec<u8>, AssetError> {
     }
 }
 
-// Wakes the event poll asynchronously and sends a Event::Wake event to the senders. 
+// Wakes the event poll asynchronously and sends a Event::Wake event to the senders.
 // This method can be called on any thread. This method returns immediately.
 #[inline]
 pub fn wake_event_loop() {