Communicating with your iOS app over USB (C# and/or Xamarin)

Communicating with your iOS app over USB (C# and/or Xamarin)

So, you're writing an iOS app that needs to communicate with a desktop client. A quick google search would suggest that the only way to do this would be to create a small socket server on the desktop client that listens on a given port, and have the iOS app connect to the desktop client through your local network. This definitely works, and often times it's good enough. If you're familiar with socket programming, this is definitely straight forward. However, there are definitely some drawbacks. The app has to be on the same network as the client (which isn't always possible in enterprise environments where your computer is on some private wired network). The client opens a port to your computer that anyone on the network can access, which can be a security concern. Initial setup is also a bit more tedious as the app user must enter the IP Address and Port into the app in order to connect. Being able to achieve "iOS App to Desktop" communication via USB cable would solve all of these problems, and make (in my opinion) the app much more convenient. 

The problem with this approach is just how little documentation there is regarding how this can be achieved. Some forum posts say it's flat out not possible. Others will say that you need to sign up for Apple's MFi program (a long and tedious process). Well, after spending the last week scouring the internet, I'm here to tell you that it definitely is possible without MFi. And it's not even all that hard once you understand what's happening. So, here's everything I've learned.

A couple quick notes

I'm primarily a C#/.NET developer, and so I'm writing this assuming you are too. The concepts are pretty universal, but the examples will be in C#. I'm using Xamarin.iOS to build the iOS app, so even the iOS code will be in C#.

Also, I think it's good to note that for developers writing Swift/Objective-C code, there is a pretty awesome platform tool called Peertalk that does everything I'm going to talk about. Unfortunately, there's no Xamarin binding. I almost decided to switch off Xamarin to use this before I finally figured out how to do what Peertalk does very quickly and easily. 

How does Apple do it?

When you plug in your iOS device to your computer, you're able to sync your data via the USB cable. The way Apple achieves this is via a very handy program called usbmuxd. This is a program that's running on your computer, waiting for an iOS device to connect. If you've installed iTunes on your machine, you've also installed this program. On Windows, the service that hosts this program is named "Apple Mobile Device Service", and can be seen in services.msc. So, what does usbmuxd do?

usbmuxd

usbmuxd stands for USB Multiplexing Daemon. If you're anything like me, "USB" is the only really familiar term in that name. But what this program does is actually pretty simple (and extremely useful to us). It's a background process (daemon) that can tell your iOS device to map (multiplex) all the data received from the USB cable to a network port on the iOS device, and return a socket connection to that port. 

So, practically, what does this mean for us? This means that, if you do something like this on the iOS device

        
                   var socket = new Socket(AddressFamily.InterNetwork,
                       SocketType.Stream,
                       ProtocolType.Tcp);

                   socket.Bind(new IPEndPoint(IPAddress.Loopback, 5050));
                   socket.Listen(100);
                   socket.BeginAccept((ar) =>
                   {
                       var connectionAttempt = (Socket) ar.AsyncState;
                       var connectedSocket = connectionAttempt.EndAccept(ar);
                       // Do something with "connectedSocket"
                   }, socket);

The above code (which is running on your iOS device) is now listening for an incoming connection on port 5050 (which I chose completely arbitrarily). I know what you may be thinking. "I thought we weren't going to be using network connections. What gives!?"

This is where usbmuxd does its magic. From your desktop app, you can send a message to usbmuxd that informs the connected iOS device to receive all USB data on a network port. In our case, we'd want to have usbmuxd tell our iOS device to receive USB data on port 5050. usbmuxd will oblige, and give you a socket handle to send data on and receive data from. At this point, your iOS app will call the "BeginAccept" callback, and you'll have a network socket that's not really a "network" socket. This will work even if your computer and iOS device are on different networks, or no networks at all. All data is going through your USB cable!

So...how do I actually communicate with usbmuxd

Fortunately, there's a nuget package for that! The iMobileDevice.Net nuget page can be found here. It's not exactly the most well documented tool, but it works very well. It does assume that the usbmuxd service is running on your machine. Easiest way to do that is to just make sure you have iTunes installed. If you don't want to have a dependency on iTunes, you can do what the people at Duet Display did, and extract the appropriate msi from the iTunes installer, and just require that as a prerequisite of your application

The AppleApplicationSupport64.msi AppleMobileDeviceSupport6464.msi installer will install the service you need.

Once you know that usbmuxd is actually on your machine, you can start using the nuget package. This package is really just a wrapper around a C library, and it shows. There are a lot of IntPtr's and out parameters, so it's not very pretty. But it works.

Here's a snippet from a project I'm working on. The below code listens for an iOS device event (which usbmuxd calls for us). When the event is a "DeviceAdd" event, I attempt to connect to it. 

        
        public void BeginListening()
        {
            _iDeviceApi.idevice_event_subscribe(_eventCallback, new IntPtr());
        }

        private iDeviceEventCallBack EventCallback()
        {
            return (ref iDeviceEvent devEvent, IntPtr data) =>
            {
                switch (devEvent.@event)
                {
                    case iDeviceEventType.DeviceAdd:
                        Connect(devEvent.udidString);
                        break;
                    case iDeviceEventType.DeviceRemove:
                        break;
                    default:
                        return;
                }
            };
        }

The Connect method gets a "DeviceHandle" reference, using the udid of the connected device. Once it gets that handle, it calls the "ReceiveDataFromDevice" method.

        private void Connect(string newUdid)
        {
            _iDeviceApi.idevice_new(out iDeviceHandle deviceHandle, newUdid).ThrowOnError();
            var error =_iDeviceApi.idevice_connect(deviceHandle, 5050, out iDeviceConnectionHandle connection);
            if (error != iDeviceError.Success) return;
            ReceiveDataFromDevice(connection);
        }

        private void ReceiveDataFromDevice(iDeviceConnectionHandle connection)
        {
            Task.Run(() =>
            {
                while (true)
                {
                    uint receivedBytes = 0;
                    _iDeviceApi.idevice_connection_receive(connection, _inboxBuffer, (uint)_inboxBuffer.Length,
                        ref receivedBytes);
                    if (receivedBytes <= 0) continue;

                    // Do something with your received bytes
                }
            });
        }

And finally, the below line sends data to the iOS device.

  
        _iDeviceApi.idevice_connection_send(connection, bytesPending, (uint)bytesPending.Length, ref sentBytes);

There are a lot of other functions available to you, but these are some important ones. Using these, you can start sending data to your iOS device via USB. Your iOS app won't even know that it's a USB connection. To the app, it's just another TCP Network Connection. Hopefully this saves you some time, and feel free to comment or message me if you have any questions.

Happy Coding!