Add WASM Support for Uno Platform

.editorconfig

@@ -9,7 +9,7 @@ indent_style = space
 # (Please don't specify an indent_size here; that has too many unintended consequences.)
 
 # Code files
-[*.{cs,csx,vb,vbx}]
+[*.{cs,csx,vb,vbx,ts}]
 indent_style = tab
 indent_size = 4
 insert_final_newline = true

README.md

@@ -20,6 +20,7 @@ SkiaSharp provides cross-platform bindings for:
  - Xamarin.Mac
  - Windows Classic Desktop (Windows.Forms / WPF)
  - Windows UWP (Desktop / Mobile / Xbox / HoloLens)
+ - Web Assembly (WASM)
 
 The [API Documentation](https://docs.microsoft.com/en-us/dotnet/api/SkiaSharp/) is
 available on the web to browse.

VERSIONS.txt

@@ -19,6 +19,7 @@ AtkSharp                                        release     3.22.24.37
 System.Memory                                   release     4.5.3
 System.IO.UnmanagedMemoryStream                 release     4.3.0
 SharpVk                                         release     0.4.2
+Uno.UI                                          release     2.0.532
 
 # additional references used by the tooling
 OpenTK.GLControl                                reference   1.1.2349.61993
@@ -50,8 +51,10 @@ SkiaSharp.Views.WPF                             nuget       2.80.0
 SkiaSharp.Views.Forms                           nuget       2.80.0
 SkiaSharp.Views.Forms.WPF                       nuget       2.80.0
 SkiaSharp.Views.Forms.GTK                       nuget       2.80.0
+SkiaSharp.Views.Uno                             nuget       2.80.0
 SkiaSharp.HarfBuzz                              nuget       2.80.0
 SkiaSharp.Vulkan.SharpVk                        nuget       2.80.0
+SkiaSharp.WebAssembly                           nuget       2.80.0
 HarfBuzzSharp                                   nuget       2.6.1.5
 HarfBuzzSharp.NativeAssets.Linux                nuget       2.6.1.5
 

binding/Binding/SKAbstractManagedStream.cs

@@ -1,5 +1,10 @@
 using System;
+#if __WASM__
+using System.Globalization;
+using System.Linq;
+#else
 using System.Runtime.InteropServices;
+#endif
 using System.Threading;
 
 namespace SkiaSharp
@@ -12,6 +17,49 @@ public unsafe abstract class SKAbstractManagedStream : SKStreamAsset
 
 		static SKAbstractManagedStream ()
 		{
+#if __WASM__
+			const string js =
+				"SkiaSharp.SkiaApi.bindMembers('[SkiaSharp] SkiaSharp.SKAbstractManagedStream', {" +
+				"  'ReadInternal': 'iiiii'," +
+				"  'PeekInternal': 'iiiii'," +
+				"  'IsAtEndInternal': 'iii'," +
+				"  'HasPositionInternal': 'iii'," +
+				"  'HasLengthInternal': 'iii'," +
+				"  'RewindInternal': 'iii'," +
+				"  'GetPositionInternal': 'iii'," +
+				"  'SeekInternal': 'iiii'," +
+				"  'MoveInternal': 'iiii'," +
+				"  'GetLengthInternal': 'iii'," +
+				"  'DuplicateInternal': 'iii'," +
+				"  'ForkInternal': 'iii'," +
+				"  'DestroyInternal': 'vii'," +
+				"});";
+			const int expected = 13;
+
+			var ret = WebAssembly.Runtime.InvokeJS (js);
+			var funcs = ret.Split (new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+				.Select (f => (IntPtr)int.Parse (f, CultureInfo.InvariantCulture))
+				.ToArray ();
+
+			if (funcs.Length != expected)
+				throw new InvalidOperationException ($"Mismatch when binding 'SkiaSharp.SKAbstractManagedStream' members. Returned {funcs.Length}, expected {expected}.");
+
+			// we can do magic with variables
+			var ReadInternal = funcs[0];
+			var PeekInternal = funcs[1];
+			var IsAtEndInternal = funcs[2];
+			var HasPositionInternal = funcs[3];
+			var HasLengthInternal = funcs[4];
+			var RewindInternal = funcs[5];
+			var GetPositionInternal = funcs[6];
+			var SeekInternal = funcs[7];
+			var MoveInternal = funcs[8];
+			var GetLengthInternal = funcs[9];
+			var DuplicateInternal = funcs[10];
+			var ForkInternal = funcs[11];
+			var DestroyInternal = funcs[12];
+#endif
+
 			delegates = new SKManagedStreamDelegates {
 				fRead = ReadInternal,
 				fPeek = PeekInternal,
@@ -83,91 +131,143 @@ protected virtual IntPtr OnFork ()
 		protected virtual IntPtr OnDuplicate () => OnCreateNew ();
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamReadProxyDelegate))]
+#if __WASM__
+		private static IntPtr ReadInternal (IntPtr s, IntPtr context, IntPtr buffer, IntPtr size)
+#else
 		private static IntPtr ReadInternal (IntPtr s, void* context, void* buffer, IntPtr size)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnRead ((IntPtr)buffer, size);
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamPeekProxyDelegate))]
+#if __WASM__
+		private static IntPtr PeekInternal (IntPtr s, IntPtr context, IntPtr buffer, IntPtr size)
+#else
 		private static IntPtr PeekInternal (IntPtr s, void* context, void* buffer, IntPtr size)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnPeek ((IntPtr)buffer, size);
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamIsAtEndProxyDelegate))]
+#if __WASM__
+		private static bool IsAtEndInternal (IntPtr s, IntPtr context)
+#else
 		private static bool IsAtEndInternal (IntPtr s, void* context)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnIsAtEnd ();
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamHasPositionProxyDelegate))]
+#if __WASM__
+		private static bool HasPositionInternal (IntPtr s, IntPtr context)
+#else
 		private static bool HasPositionInternal (IntPtr s, void* context)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnHasPosition ();
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamHasLengthProxyDelegate))]
+#if __WASM__
+		private static bool HasLengthInternal (IntPtr s, IntPtr context)
+#else
 		private static bool HasLengthInternal (IntPtr s, void* context)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnHasLength ();
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamRewindProxyDelegate))]
+#if __WASM__
+		private static bool RewindInternal (IntPtr s, IntPtr context)
+#else
 		private static bool RewindInternal (IntPtr s, void* context)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnRewind ();
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamGetPositionProxyDelegate))]
+#if __WASM__
+		private static IntPtr GetPositionInternal (IntPtr s, IntPtr context)
+#else
 		private static IntPtr GetPositionInternal (IntPtr s, void* context)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnGetPosition ();
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamSeekProxyDelegate))]
+#if __WASM__
+		private static bool SeekInternal (IntPtr s, IntPtr context, IntPtr position)
+#else
 		private static bool SeekInternal (IntPtr s, void* context, IntPtr position)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnSeek (position);
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamMoveProxyDelegate))]
+#if __WASM__
+		private static bool MoveInternal (IntPtr s, IntPtr context, int offset)
+#else
 		private static bool MoveInternal (IntPtr s, void* context, int offset)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnMove (offset);
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamGetLengthProxyDelegate))]
+#if __WASM__
+		private static IntPtr GetLengthInternal (IntPtr s, IntPtr context)
+#else
 		private static IntPtr GetLengthInternal (IntPtr s, void* context)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnGetLength ();
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamDuplicateProxyDelegate))]
+#if __WASM__
+		private static IntPtr DuplicateInternal (IntPtr s, IntPtr context)
+#else
 		private static IntPtr DuplicateInternal (IntPtr s, void* context)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnDuplicate ();
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamForkProxyDelegate))]
+#if __WASM__
+		private static IntPtr ForkInternal (IntPtr s, IntPtr context)
+#else
 		private static IntPtr ForkInternal (IntPtr s, void* context)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out _);
 			return stream.OnFork ();
 		}
 
 		[MonoPInvokeCallback (typeof (SKManagedStreamDestroyProxyDelegate))]
+#if __WASM__
+		private static void DestroyInternal (IntPtr s, IntPtr context)
+#else
 		private static void DestroyInternal (IntPtr s, void* context)
+#endif
 		{
 			var stream = DelegateProxies.GetUserData<SKAbstractManagedStream> ((IntPtr)context, out var gch);
 			if (stream != null) {

binding/Binding/SkiaApi.cs

@@ -18,6 +18,8 @@ internal partial class SkiaApi
 		private const string SKIA = "libSkiaSharp.dll";
 #elif NET_STANDARD
 		private const string SKIA = "libSkiaSharp";
+#elif __WASM__
+		private const string SKIA = "libSkiaSharp";
 #else
 		private const string SKIA = "libSkiaSharp";
 #endif

binding/Binding/SkiaApi.generated.cs

@@ -5262,43 +5262,95 @@ public readonly override int GetHashCode ()
 	[StructLayout (LayoutKind.Sequential)]
 	internal unsafe partial struct SKManagedStreamDelegates : IEquatable<SKManagedStreamDelegates> {
 		// public sk_managedstream_read_proc fRead
+		#if __WASM__
+		public IntPtr fRead;
+		#else
 		public SKManagedStreamReadProxyDelegate fRead;
+		#endif
 
 		// public sk_managedstream_peek_proc fPeek
+		#if __WASM__
+		public IntPtr fPeek;
+		#else
 		public SKManagedStreamPeekProxyDelegate fPeek;
+		#endif
 
 		// public sk_managedstream_isAtEnd_proc fIsAtEnd
+		#if __WASM__
+		public IntPtr fIsAtEnd;
+		#else
 		public SKManagedStreamIsAtEndProxyDelegate fIsAtEnd;
+		#endif
 
 		// public sk_managedstream_hasPosition_proc fHasPosition
+		#if __WASM__
+		public IntPtr fHasPosition;
+		#else
 		public SKManagedStreamHasPositionProxyDelegate fHasPosition;
+		#endif
 
 		// public sk_managedstream_hasLength_proc fHasLength
+		#if __WASM__
+		public IntPtr fHasLength;
+		#else
 		public SKManagedStreamHasLengthProxyDelegate fHasLength;
+		#endif
 
 		// public sk_managedstream_rewind_proc fRewind
+		#if __WASM__
+		public IntPtr fRewind;
+		#else
 		public SKManagedStreamRewindProxyDelegate fRewind;
+		#endif
 
 		// public sk_managedstream_getPosition_proc fGetPosition
+		#if __WASM__
+		public IntPtr fGetPosition;
+		#else
 		public SKManagedStreamGetPositionProxyDelegate fGetPosition;
+		#endif
 
 		// public sk_managedstream_seek_proc fSeek
+		#if __WASM__
+		public IntPtr fSeek;
+		#else
 		public SKManagedStreamSeekProxyDelegate fSeek;
+		#endif
 
 		// public sk_managedstream_move_proc fMove
+		#if __WASM__
+		public IntPtr fMove;
+		#else
 		public SKManagedStreamMoveProxyDelegate fMove;
+		#endif
 
 		// public sk_managedstream_getLength_proc fGetLength
+		#if __WASM__
+		public IntPtr fGetLength;
+		#else
 		public SKManagedStreamGetLengthProxyDelegate fGetLength;
+		#endif
 
 		// public sk_managedstream_duplicate_proc fDuplicate
+		#if __WASM__
+		public IntPtr fDuplicate;
+		#else
 		public SKManagedStreamDuplicateProxyDelegate fDuplicate;
+		#endif
 
 		// public sk_managedstream_fork_proc fFork
+		#if __WASM__
+		public IntPtr fFork;
+		#else
 		public SKManagedStreamForkProxyDelegate fFork;
+		#endif
 
 		// public sk_managedstream_destroy_proc fDestroy
+		#if __WASM__
+		public IntPtr fDestroy;
+		#else
 		public SKManagedStreamDestroyProxyDelegate fDestroy;
+		#endif
 
 		public readonly bool Equals (SKManagedStreamDelegates obj) =>
 			fRead == obj.fRead && fPeek == obj.fPeek && fIsAtEnd == obj.fIsAtEnd && fHasPosition == obj.fHasPosition && fHasLength == obj.fHasLength && fRewind == obj.fRewind && fGetPosition == obj.fGetPosition && fSeek == obj.fSeek && fMove == obj.fMove && fGetLength == obj.fGetLength && fDuplicate == obj.fDuplicate && fFork == obj.fFork && fDestroy == obj.fDestroy;

binding/SkiaSharp.Wasm/LinkerDefinition.Wasm.xml

@@ -0,0 +1,3 @@
+<linker>
+  <assembly fullname="SkiaSharp" />
+</linker>

binding/SkiaSharp.Wasm/SkiaSharp.Wasm.csproj

@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <RootNamespace>SkiaSharp</RootNamespace>
+    <AssemblyName>SkiaSharp</AssemblyName>
+    <PackagingGroup>SkiaSharp.WebAssembly</PackagingGroup>
+    <DefineConstants>$(DefineConstants);__WASM__</DefineConstants>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Memory" Version="4.5.3" />
+    <PackageReference Include="Microsoft.TypeScript.Compiler" Version="3.1.5" />
+    <PackageReference Include="Microsoft.TypeScript.MSBuild" Version="3.9.5" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\output\native\wasm\libSkiaSharp.a" Link="nuget\build\$(PackagingPlatform)\libSkiaSharp.a" />
+    <None Include="nuget\build\wasm\SkiaSharp.props" Link="nuget\build\$(PackagingPlatform)\SkiaSharp.WebAssembly.props" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\Binding.Shared\**\*.cs" Link="%(RecursiveDir)%(Filename)%(Extension)" />
+    <Compile Include="..\Binding\**\*.cs" Link="%(RecursiveDir)%(Filename)%(Extension)" />
+    <Compile Include="WebAssembly.Runtime.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Remove="LinkerDefinition.Wasm.xml" />
+    <EmbeddedResource Include="LinkerDefinition.Wasm.xml" LogicalName="$(AssemblyName).xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <TypeScriptCompile Remove="WasmScripts\**\*" />
+    <TypeScriptCompile Include="ts\tsconfig.json" />
+    <TypeScriptCompile Include="..\..\externals\typescript\**\*.ts" Link="ts\%(RecursiveDir)%(Filename)%(Extension)" />
+    <TypeScriptCompile Include="ts\**\*.ts" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="WasmScripts\*.js" />
+  </ItemGroup>
+</Project>