👀 Notes on this right here page 🤠

If you’re looking for a way to develop cross-platform desktop-oriented applications, Avalonia UI might just be the framework for you. However, the documentation and third-party libraries can still be a bit immature. In this post, I’ll be sharing my experience developing an application that required playing audio files on different platforms, and how I managed to get it to work.

Goal

Our goal is to play audio files from a local file or a URL. To achieve this, the cross-platform code calls a function pointer that is defined separately on each platform as Func<string, Task>, where the input is the path/URL to the audio file. You can set this up with interfaces and dependency injection, but I chose to keep it old school.

Windows

Avalonia’s default template comes with one single Desktop project. However, to make platform-specific calls, we’ll need to fork that into two separate projects for Windows and macOS. To get started with Windows, change the TargetFramework of your Windows project to net7.0-windows10.0.17763.0. Note that you can’t target Windows 7, and at a minimum, you’ll need to target Windows 10 to get access to the APIs we’ll be using. Your csproj should look like this:

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net7.0-windows10.0.17763.0</TargetFramework>
    <Nullable>enable</Nullable>
    <BuiltInComInteropSupport>true</BuiltInComInteropSupport>
  </PropertyGroup>

Once you’ve made this change and reloaded your project, you’ll gain access to the Windows.Media namespaces, which allow you to easily play media files using the Windows.Media.Playback.MediaPlayer class:

var player = new MediaPlayer();
player.Source = MediaSource.CreateFromUri(new Uri("file://c:/media.m4a"));
player.Play();

MediaSource supports loading local files using file:// Uris or remote files.

macOS

On macOS, we can use the afplay command-line utility to play audio files. To do this, we can simply write a function that runs a new process for afplay [path] to play the sound effect we want:

new Process()
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "/bin/bash",
        Arguments = $"-c \"afplay 'media.mp4'\"",
        RedirectStandardOutput = true,
        RedirectStandardInput = true,
        UseShellExecute = false,
        CreateNoWindow = true,
    }
}.Start();

This is exactly what the NetCoreAudio project does for its macOS implementation and in general on Unix.

If you want to download a remote file, you can use System.Net.Http.HttpClient to do that:

using var client = new HttpClient();
var bytes = await client.GetByteArrayAsync(url);
File.WriteAllBytes(localPath, bytes);

WebAssembly

Playing audio on the web can be done using an Audio object in JavaScript and calling the play() method on it. To call JavaScript functions from your C# code, you can use the JSImport attribute.

First, define a function in main.js that plays an audio file, for example:

globalThis.playSound = function (url) {
    var audio = new Audio(url);
    audio.play();
}

Then you can JSImport this as a C# method anywhere you want like this:

using System.Runtime.InteropServices.JavaScript;

...

[JSImport("globalThis.playSound")]
public static partial void PlaySound(string url);

Finally, call the PlaySound method in C# to run the globalThis.playSound JavaScript function:

PlaySound("http://sound.com/audio.mp4");

However, when dealing with a website, you might run into CORS (Cross-Origin Resource Sharing) issues. Make sure the remote host allows you to download the file you want. It’s always a good idea to look at your browser’s DevTools console for hints about any issues related to cross-site scripting errors.

Check out my submission for Toy Box Jam 3, This Is Neat-O!

Thirty years ago, Captain Neat-O lost his way home after entering a doomed trans-dimensional portal somewhere around Mars.

It’s up to you to help him find his way back home, before his parents find out…

Easy Mode: Collect all Neat Coins in each level to open the exit portal. Go to the portal to get to the next level.

Hard Mode: Collect all pickups in each level and then finish the level. It turns out Captain Neat-O doesn’t mind vegetables, but hates CHICKEN!

If you don’t feel like finishing the levels or get stuck, feel free to skip levels by pressing +. You can even skip to the end and see what happens. I don’t mind :)

Play in browser

While working on a 2D platformer on Unity, I decided to implement ladders with tile maps with a specific layer designated for ladders. I added a Tilemap Collider 2D component to it with Is Trigger set to true. The plan was to detect the overlap of player and a ladder tile using Unity’s OnTriggerEnter2D(Collider2D) and OnTriggerExit2D(Collider2D) methods.

The Collider2D object refer to the collider attached to the tilemap. I thought collider2D.transform or .bounds properties would return the position of the actual overlapping tile, but I was wrong.

In the end I solved the problem using a different approach:

1, Get the Tilemap object for the ladder,

2, Use the .WorldToCell(Vector3) method of the tilemap to get the discrete cell position of the tile that overlaps with the passed position, in this case player’s transform.position.

3, The center of the overlapping tile would be the world position of the tile map + the cell position + half of tileMap.cellSize.

foreach (var collision in Colliders.Where(x => x.gameObject.layer == LadderLayerId))
{
    IsLadder = true;
    var tileMap = collision.GetComponent<Tilemap>();
    var cellPos = tileMap.WorldToCell(transform.position);
    var tile = tileMap.GetTile(cellPos);
    if (tile != null)
        LadderCenter = tileMap.transform.position + cellPos + tileMap.cellSize * 0.5f;
}

I have an ELM327 OBD2 BLE dongle that shows up as IOS-Vlink. To communicate with it, the service ID is: E7810A71-73AE-499D-8C15-FAA9AEF0C3F2 and both read and write is done using the characteristic BEF8D6C9-9C21-4C9E-B632-BD58C1009F9F.

Once the car (ECU) is on and the Bluetooth is connected, we need to initialize the dongle, by sending:

AT E0\r
AT L0\r
AT SP 00\r
01 00\r

AT E0 is to turn echo off. AT SP 00 searches for the right protocol to use to communicate with the ECU.

Once initialized, we can run a loop to query for the values we want:

RPM is 01 0C\r
Speed is 01 0D\r
Throttle position is 01 11\r
and so on.

This Wikipedia article has a table of PIDs that can be queried from the car and how to translate the results to human readable values.

Generally when a PID is queried (e.g. 01 0C\r), the result is something like 41 0C 0B C0 where 0C is the PID for this response and 0B C0 are the actual returned values in hex.

I often get corrupt replies from the dongle such as 41 0C 0B C, where the message is not fully received, which I ignore.

Responses end with >, so that’s something to look for. Read until you get >, split by line breaks, parse the lines.

Some PIDs take longer to get a response for than the others, so make sure you query what you want, so you can get the desired values with the highest frequency. Also note that ECUs have different speeds, some return results faster, some slower, some need waits between commands.

These oximeters also continuously record oxygen, heart rate, motion and other values in their internal memory as files. Files are stored in a binary format that can be decoded as described in this note.

The first 40 bytes are the header:

00 int16   version (2 bytes)
02 int16   year
04 byte    month
05 byte    day
06 byte    hour
07 byte    minute
08 byte    second
09 int16   file size   
13 int16   duration in seconds
17 byte    average O2
18 byte    minimum O2
19 byte    3pct O2
20 byte    4pct O2
22 int16   O2 < 90% seconds
24 byte    events under 90%
25 byte    score

Take the total length of the file (number of bytes), remove 40 (i.e. the length of the header). Divide by 5 (i.e. the length of a record). You’ll get the total number of records in the file.

You can get the interval between each record by dividing the duration (bytes 13 and 14 of the header) by the number of records.

Reading Records

Skip 40 bytes (the header), you’ll arrive at the beginning of the first record. Take 5 bytes:

00 O2 %
01 Heart Rate bpm
02 ??
03 Motion
04 Vibration

As you already have the interval, you can estimate each record’s timestamp by multiplying record ID by interval, plus the start time (bytes 02 to 08 inclusive of the header).

I was playing around with a Viatom SleepU Pulse Oximeter the past few days. It’s a device with a ring-shaped sensor that you wear on your finger and it monitors and continuously records your blood oxygen percentage and heart rate.

To communicate with this device over BLE, you need to look for the service with UUID 14839ac4-7d7e-415c-9a42-167340cf2339. This service has two characteristics that interest us:

For Reading: 0734594a-a8e7-4b1a-a6b1-cd5243059a57
For Writing: 8b00ace7-eb0b-49b0-bbe9-9aee0a26e1a3

We write to the second characteristic and monitor the value update of the first characteristic for reading.

In this note I explain how to read device information, sensor values and files from the device.

But first, let’s discuss packet formats.

Write Packets

To send a message to the device, you have to create a packet with the following structure (byte array):

00 byte 0xAA
01 byte requested_command
02 byte requested_command XOR 0xFF
03 ushort (2B) file_block_id [when reading a file. set to 0 otherwise.]
05 ushort (2B) payload_length [when sending data. set to 0 otherwise.]
07 byte_array payload [optional]. This can be the name of a file to download for example. Use UTF-8 to convert text to byte array.
07+payload_length byte CRC of bytes [00 to 07)

To calculate the CRC, use the following algorithm:

static byte CRC(IEnumerable<byte> bytes)
{
    byte crc = 0;
    foreach (var b in bytes)
    {
        var chk = (byte)(crc ^ b);
        crc = 0;
        if ((chk & 0x01) != 0) crc = 0x07;
        if ((chk & 0x02) != 0) crc ^= 0x0e;
        if ((chk & 0x04) != 0) crc ^= 0x1c;
        if ((chk & 0x08) != 0) crc ^= 0x38;
        if ((chk & 0x10) != 0) crc ^= 0x70;
        if ((chk & 0x20) != 0) crc ^= 0xe0;
        if ((chk & 0x40) != 0) crc ^= 0xc7;
        if ((chk & 0x80) != 0) crc ^= 0x89;
    }
    return crc;
}

There is a maximum message length limit of, I guess, 20 bytes. You can send your message in chunks if it’s larger than that:

async Task WriteAsync(byte[] bytes)
{
    if (bytes == null) return;
    while (bytes.Length > 0)
    {
        var chunk = bytes.Take(20).ToArray();
        await WriteAsyncFunc(chunk);
        bytes = bytes.Skip(20).ToArray();
    }
}

If you are using later versions of C#, you can optimize this code and not duplicate the array in every loop.

Read Packets

Incoming packets come in the following format. Note that a message can come in multiple packets and therefore we have to keep track of how many bytes we expect, so we can join subsequent packets that carry the same message together.

00 byte device ID, must be 0x55
01 byte 
02 byte. [01] must be equal to 0xFF XOR [02]
05 ushort (2B) + 8 = total bytes to expect

Keep reading until you have all the bytes you expect. Once you have enough bytes, take the last byte, that should be the CRC of everything except the last byte.

Calculate the CRC of everything except the last byte and make sure it is equal to this value.

Commands

0x14: Device Information

To request device information, send a packet with the command 0x14. Your bytes in hex should look like this: aa14eb00000000c6.

The response will be something like this:

5500ff000000027b22526567696f6e223a224345222c224d6f6
4656c223a2231363534222c224861726477617265566572223a224
141222c22536f667477617265566572223a22312e322e30222c224
26f6f746c6f61646572566572223a22302e312e302e30222c22466
96c65566572223a2233222c2253504350566572223a22312e34222
c22534e223a2232303131324232363237222c2243757254494d452
23a22323032312d30372d30332c31363a33373a3133222c2243757
2424154223a22363325222c224375724261745374617465223a223
0222c224375724f7869546872223a223837222c224375724d6f746
f72223a22313030222c22437572506564746172223a22393939393
9222c224375724d6f6465223a2230222c224375725374617465223
a2232222c224272616e6368436f6465223a2232313037303030302
22c2246696c654c697374223a22323032313037303331343035333
62c32303231303730333134343832312c323032313037303330313
13233352c227d00000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000
0000000000000007c

Looking closely at the hex, you can see the 7c in the end is the CRC. Ignoring that, you have an almost 512 bytes long message that ends at some point and is padded with 0s. The first few bytes in the beginning (5500ff00000002) are packet details.

The rest of the bytes (7b to 7d) contain a JSON string that has the device information.

0x17: Sensors

Send a packet with command 0x17 (aa17e8000000001b) and you will receive something like this:

5500ff00000d00615400000000004b000000000058

As explained above, the actual payload is this part:

615400000000004b0000000000

Data structure:

00: O2 level
01: Heart Rate (bpm)
07: Battery %

0x03: Open File

To download a file, you have to send a request to open it, a few requests to read it and a final request to close.

Send a request of:

Command: 0x03
Block: 0
File Name: filename\0

To open a file. The response’s first four bytes (uint) indicate the total size of the requested file in bytes. Remember this number.

0x04: Read File

You download the file in blocks (chunks). Send a request of:

Command: 0x04
Block: 0..i..n

To download the i-th block. Every time you receive a message, subtract the size of the message (not counting the header and CRC bytes) from the total expected bytes (obtained from the Open phase). Increase the block number by one every time and repeat the read request until you have all the bytes you need.

Save them to a file.

0x05: Close File

Send a request with command 0x05 to close the file.

People hear about a new EV company and say it’s a serious competitor for Tesla. But that can’t be further from the truth.

Electric motors are what move the vehicle, but just having a car with an electric motor doesn’t suddenly make it a Tesla competitor. The same goes with gas cars: a Ford F150, a VW Beetle and a McLaren super car all essentially move by burning similar fuel; but they are not the same and they are not competitors.

A quick electric car is also not necessarily a direct competitor to a Tesla. Acceleration is only one of the many features of it, but not everything.

Adaptive cruise control, lane keep and Autopilot are very important features, but other car companies will eventually catch up once an alternative open source algorithm becomes available online and they can steal.

But even that won’t make automotive giants like VW, BMW, Volvo, Nissan, Mazda and other big names to catch up to what a Tesla vehicle can be.

I remember when the first iPhone came, big (pun intended) phone manufacturers at the time like Nokia failed to understand what made it the killer phone. A shiny new gimmick of the first iPhone was changing the orientation of the screen and apps based on the Accelerometer and that was what Nokia thought they should steal and put it in their Symbian-based phones. That didn’t do it.

Nokia is gone now.

Accelerometer wasn’t iPhone’s killer feature.

I drove a high end VW car recently, the interface looked very high resolution and cool. It looked like they thought a good looking infotainment suite is something they should steal from Tesla to get cool and stay relevant and competitive. That’s a tiny bit true, but not entirely.

Mazda is the funny one, going completely backwards. They removed touch screens from their cars to make them safer. Hehe.

Just as everyone in the world of pre-iPhone smartphones tried to cut costs and used cheap processors and unflexible OSes that looked good enough for their bundled software, mainstream car companies are currently doing the same.

Tesla on the other hand, has over the air updates. It has an extremely fast and respectable processor. It runs AAA games. And that’s its killer feature.

An App Store, probably coming very soon.

History will write, that Tesla’s fart app was the beginning of the end for traditional car companies; just as traditional smartphone makers like Nokia slowly disappered in the mist created by original iPhone’s first fart apps.

Automotive giants are just not good enough at software. That’s a fact. And that’s what makes them fail eventually.

A phone was once mainly a device to make calls. Calling nowadays is just a fraction of what we do with our phones.

Don’t go invest in a new electric car company just because it makes electric cars.

I recently bought a Surface Book 3 and installed a VMWare virtual machine on it. It was running super slow. Some Googling around lead me to this discussion, and the solution worked for me. Leaving it here for future use.

1. Turn off Hyper-V.  Run the "Turn Windows features on or off" applet and uncheck the entire "Hyper-V" tree

2. Disable Credential Guard: Run the "Edit group policy" applet, and navigate to the Local Computer Policy > Computer Configuration > Administrative Templates > System > Device Guard group.  For the "Turn On Virtualization Based Security", set it to "Disabled"

3. Turn off hypervisor in the boot loader: in PowerShell as Administrator, type 

bcdedit /set hypervisorlaunchtype off

4. Disable DeviceGuard: run the "Registry Editor" applet and navigate to Computer > HKEY_LOCAL_MACHINE > SYSTEM > CurrentControlSet > Control > DeviceGuard group.  set the "EnableVirtualizationBasedSecurity" to 0, set "RequireMicrosoftSignedBootChain" to 0.  Then navigate further to ... Scenarios > HyperVisorEnforcedCodeIntegrity and set "Enabled" to 0

5. Disable Memory Integrity: in the Settings Applet, navigate to Update & Security > Windows Security > Device Security > Core Isolation.  Turn the Memory Integrity option "Off"

When you reboot, you should have "Virtualization Based Security: not enabled" and the Intel utility will show VT-x enabled.

Source: https://answers.microsoft.com/en-us/surface/forum/all/how-to-enable-vt-x-on-surface-book-3/b9057c59-eb8a-4221-85c4-90a3d44edd55

The following classes are renamed in RedCorners.Forms:

TitledContentView to TitledGroup
TabbedContentView to TabGroup
HiddenEntryView to HiddenEntry

Some unnecessary TwoWay bindings in TitledGroup, TitleBar and TabGroup have been changed to OneWay.

Demos are updated.

Android SDK version is changed to 10 from 9.

The following control templates are added to TitledGroup:

TitleViewTemplate: assigns the control template of TitleView.
BodyTemplate: assigns the control template of the body (Content).
TitleBarTemplate: assigns the control templates of the title bar.

Android zoom buttons are hidden by default.

Android SDK version is changed to 10.

Map objects are moved to the Neat.Map.Models namespace in the Neat.Map.Models NuGet. This package has to be installed in the projects that use RedCorners.Forms.GoogleMaps.

Sam Afshari's Notes - Contact me: sa at neat.lu

👀 Notes on this right here page 🤠

Playing Sound Effects in Avalonia UI - Mon, Apr 10, 2023

Goal

Windows

macOS

WebAssembly

This Is Neat-O! - Sun, Feb 13, 2022

Unity Tilemap Collision Detection - Tue, Jan 25, 2022

Talking to a Bluetooth (BLE) ELM327 Dongle - Tue, Sep 14, 2021

Talking to a Bluetooth (BLE) Pulse Oximeter - Part II - Thu, Jul 29, 2021

Reading Records

Talking to a Bluetooth (BLE) Pulse Oximeter - Sun, Jul 4, 2021

Write Packets

Read Packets

Commands

0x14: Device Information

0x17: Sensors

0x03: Open File

0x04: Read File

0x05: Close File

The Bullish Case for Tesla - Fri, Jun 11, 2021

Virtualization and Surface Book 3 - Mon, May 17, 2021

RedCorners.Forms Changes - Sat, Feb 20, 2021

RedCorners.Forms.GoogleMaps Breaking Changes - Sat, Feb 20, 2021