DEV Community: Sofia Winters

joyshop, a small shortcut launcher for JoyCon

Sofia Winters — Mon, 01 Feb 2021 16:51:48 +0000

Release of joyshop

I've just released SofiaWinters/joyshop, a small shortcut launcher for JoyCon on Windows 10. With this app, I use JoyCon as a left-handed shortcut launcher for PhotoShop.

This is my first Rust project, and I met some obstacles and great crates.

Lack of GUI libraries

For Rust, some GUI libraries work on Windows, including Iced, Azul, native-windows-gui, and Conrod. They have a lot of functionality and flexibility. However, I'd like to make a transparent layered window as a tooltip, so I decided to call Win32API directly.

Thanks to the winapi crate, writing GUI code in Rust is very similar to C. (My code to create window is joyshop/window.rs)

This is just a tip; I needed to put #![windows_subsystem = "windows"] in main.rs to hide a command prompt window.

Building GUI with Win32API is unfamiliar to me. Everything was tough but worked. Next, I want to find a way to use a resource file to build GUI.

Issue of mpsc::channel

I got panic when I call mpsc::channel's recv method. It should relate to Panic in Receiver::recv() · Issue #39364 · rust-lang/rust.

I just switched to the crossbeam-rs/crossbeam because I couldn't find a solution or workaround.

Great KaiseiYokoyama/joycon-rs crate

joycon-rs is a crate that can get inputs from JoyCon and control lights and vibration.

I've tried to make the same application before with C#, but there are no stable libraries that meet my requirements. On the other hand, Rust has joycon-rs, which is stable and easy to use.

There is one pitfall to use. The example doesn't work correctly especially using multiple controllers.

All the examples have codes like this.

new_devices
    .into_iter()
    .flat_map(|dev| SimpleJoyConDriver::new(&dev))
    .for_each(...);

It looks like it works for multiple controllers, but doesn't. Because flat_map discards drivers that failed to be initialized. And often contiguous initialization for multiple controllers fails.

Thus, we have to handle the initialization error like this.

new_devices
    .into_iter()
    .for_each(|dev| {
        let driver = create_driver(&dev);
        ...
    });

fn create_driver(device: &Arc<Mutex<JoyConDevice>>) -> SimpleJoyConDriver {
    loop {
        match SimpleJoyConDriver::new(device) {
            Ok(d) => return d,
            Err(e) => {
                println!("JoyCon init error (will retry):{:?}", e);
                sleep(std::time::Duration::from_millis(100));
                continue;
            }
        }
    }
}

Small examples to use Rust from C#

Sofia Winters — Sun, 06 Dec 2020 07:40:35 +0000

When I make games with Unity, sometimes I need to write a native plugin. C is the most used language for native plugins, but it's not safe. So recently I use Rust. (Though Rust's safety is limited because native plugins use foreign function calls, I believe Rust is safer than C.)

Then, I made small examples that use Rust from C#, including basic function calls, passing/receiving string, callback, passing/receiving struct, and handle Rust's object through a pointer.

Repo: SofiaWinters/CSharpWithRust
Rust: csharp-with-rust/src/lib.rs
C#: CSharpWithRust/CSharpWithRust/RustTest.cs

You can build a DLL file by executing /csharp-with-rust/build.bat

Currently, the repo only has a .Net Core project, I'll add a Unity project.

Does Rust's no_mangle function conflict with OS APIs?

Sofia Winters — Thu, 03 Dec 2020 11:57:34 +0000

I faced an odd behavior today. I wrote a Rust function and a test like below and ran them on Windows.

// the crate socket2 is needed
use socket2::{Domain, Socket, Type};
use std::net::{IpAddr, Ipv4Addr, SocketAddr};

#[no_mangle]
extern "C" fn send() {
    let socket = Socket::new(Domain::ipv4(), Type::dgram(), None).unwrap();
    let local = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0);
    let remote = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 5678);

    socket.bind(&local.into()).unwrap();
    socket.connect(&remote.into()).unwrap();

    let buf = vec![0u8; 0];
    socket.send(&buf).unwrap();
}

fn main() {}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        super::send();
    }
}

The result was like this:

thread 'tests::it_works' has overflowed its stack
error: test failed, to rerun pass '-p function --bin function'

Caused by:
  process didn't exit successfully: `ab583070df1ffc3d.exe tests::it_works --exact -Z unstable-options --format=json --show-output` (exit code: 0xc00000fd, STATUS_STACK_OVERFLOW)

Process finished with exit code -1073741571 (0xC00000FD)

Why did the stack overflow!? I couldn't understand what happened but found 2 solutions.

Change the name of the function from send to the others like send2.
Remove #[no_mangle].

Then, I noticed the name of the function conflicted with OS's send because the name wasn't mangled. In other codes, I've also seen access violation, heap corruption errors, so this will cause undefined behavior.

Then, I've made the smallest reproduction code!

mod api {
    extern "system" {
        pub fn ntohl(netlong: u32) -> u32;
    }
}

#[no_mangle]
extern "C" fn ntohl() {
    unsafe { api::ntohl(0) };
}

fn main() {
    ntohl();
}

I'm not bright about C or system calls, so this will make sense for those who understand them. However, I wonder if the rust compiler can detect this conflict because this is extremely unsafe.

Use CGO in Windows 64bit

Sofia Winters — Tue, 01 Dec 2020 15:24:46 +0000

To use CGO in Windows 64bit, you have to install gcc. The easiest way to get gcc which is eligible for CGO is to install MinGW-w64.

The official documentation also refers mingw-w64 as a gcc compiler for CGO.

Windows
In order to use cgo on Windows, you'll also need to first install a gcc compiler (for instance, mingw-w64) and have gcc.exe (etc.) in your PATH environment variable before compiling with cgo will work.

The CGO page of the go official wiki

Download MINGW-W64

Download a MinGW-W64 installer from MinGW-W64-builds.

Install MINGW-W64

Execute the downloaded installer, then change Architecture to x86_64 and Threads to win32.

Add path to `mingw64/bin` to PATH

Add the path to mingw64/bin to your system PATH environment variable. The path may look like C:\Program Files\mingw-w64\x86_64******\mingw64\bin.

There you go!

This is a tiny go library source.

// main.go
package main

import "fmt"
import "C"

// no space before export!
//export hello
func hello() {
    fmt.Printf("Hello!")
}

// you have to define the main function
func main() {
}

To build:

go build -buildmode=c-shared -o hello.dll

To export a header file:

go tool cgo main.go

It generates c source and header files into the _obj directory.

If you use Visual Studio, you can inspect the dll by dumpbin.exe.

dumpbin /exports hello.dll | grep hello

It'll be like this:

> dumpbin.exe /exports hello.dll | grep hello
Dump of file hello.dll
  Section contains the following exports for hello.dll
         15    E 000A7760 _cgoexp_7cdc2f248ed0_hello
         96   5F 000A77C0 hello
        302  12D 000A76C0 main._cgoexpwrap_7cdc2f248ed0_hello

You can call the function from C#:

using System.Runtime.InteropServices;

namespace Main
{
    class Program
    {
        [DllImport("hello.dll", EntryPoint = "hello")]
        static extern void Hello();

        static void Main(string[] args)
        {
            Hello(); // => Hello!
        }
    }
}