Load specific native libraries on desktop/netfx

VERSIONS.txt

@@ -24,6 +24,13 @@ SharpVk                                         release     0.4.2
 OpenTK.GLControl                                reference   1.1.2349.61993
 Xamarin.Forms                                   reference   4.4.0.991757
 
+# native milestones
+# this is related to the API versions, not the library versions
+#  - milestone: the skia milestone determined by Google/Chromium
+#  - increment: the C API version increment caused by new APIs
+libSkiaSharp            milestone   80
+libSkiaSharp            increment   0
+
 # native sonames
 libSkiaSharp            soname      80.0.0
 HarfBuzz                soname      0.20601.0

binding/Binding.Shared/LibraryLoader.cs

@@ -0,0 +1,198 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+#if HARFBUZZ
+namespace HarfBuzzSharp
+#else
+namespace SkiaSharp
+#endif
+{
+#if USE_DELEGATES || USE_LIBRARY_LOADER
+	internal static class LibraryLoader
+	{
+		static LibraryLoader ()
+		{
+			if (PlatformConfiguration.IsWindows)
+				Extension = ".dll";
+			else if (PlatformConfiguration.IsMac)
+				Extension = ".dylib";
+			else
+				Extension = ".so";
+		}
+
+		public static string Extension { get; }
+
+		public static IntPtr LoadLocalLibrary<T> (string libraryName)
+		{
+			var libraryPath = GetLibraryPath (libraryName);
+
+			var handle = LoadLibrary (libraryPath);
+			if (handle == IntPtr.Zero)
+				throw new DllNotFoundException ($"Unable to load library '{libraryName}'.");
+
+			return handle;
+
+			static string GetLibraryPath (string libraryName)
+			{
+				var arch = IntPtr.Size == 8 ? "x64" : "x86";
+
+				var libWithExt = libraryName;
+				if (!libraryName.EndsWith (Extension, StringComparison.OrdinalIgnoreCase))
+					libWithExt += Extension;
+
+				// 1. try alongside managed assembly
+				var path = typeof (T).Assembly.Location;
+				if (!string.IsNullOrEmpty (path)) {
+					path = Path.GetDirectoryName (path);
+					// 1.1 in platform sub dir
+					var lib = Path.Combine (path, arch, libWithExt);
+					if (File.Exists (lib))
+						return lib;
+					// 1.2 in root
+					lib = Path.Combine (path, libWithExt);
+					if (File.Exists (lib))
+						return lib;
+				}
+
+				// 2. try current directory
+				path = Directory.GetCurrentDirectory ();
+				if (!string.IsNullOrEmpty (path)) {
+					// 2.1 in platform sub dir
+					var lib = Path.Combine (path, arch, libWithExt);
+					if (File.Exists (lib))
+						return lib;
+					// 2.2 in root
+					lib = Path.Combine (lib, libWithExt);
+					if (File.Exists (lib))
+						return lib;
+				}
+
+				// 3. use PATH or default loading mechanism
+				return libWithExt;
+			}
+		}
+
+		public static T GetSymbolDelegate<T> (IntPtr library, string name)
+			where T : Delegate
+		{
+			var symbol = GetSymbol (library, name);
+			if (symbol == IntPtr.Zero)
+				throw new EntryPointNotFoundException ($"Unable to load symbol '{name}'.");
+
+#if NET45
+			return (T)Marshal.GetDelegateForFunctionPointer (symbol, typeof (T));
+#else
+			return Marshal.GetDelegateForFunctionPointer<T> (symbol);
+#endif
+		}
+
+		public static IntPtr LoadLibrary (string libraryName)
+		{
+			if (string.IsNullOrEmpty (libraryName))
+				throw new ArgumentNullException (nameof (libraryName));
+
+			IntPtr handle;
+			if (PlatformConfiguration.IsWindows)
+				handle = Win32.LoadLibrary (libraryName);
+			else if (PlatformConfiguration.IsLinux)
+				handle = Linux.dlopen (libraryName);
+			else if (PlatformConfiguration.IsMac)
+				handle = Mac.dlopen (libraryName);
+			else
+				throw new PlatformNotSupportedException ($"Current platform is unknown, unable to load library '{libraryName}'.");
+
+			return handle;
+		}
+
+		public static IntPtr GetSymbol (IntPtr library, string symbolName)
+		{
+			if (string.IsNullOrEmpty (symbolName))
+				throw new ArgumentNullException (nameof (symbolName));
+
+			IntPtr handle;
+			if (PlatformConfiguration.IsWindows)
+				handle = Win32.GetProcAddress (library, symbolName);
+			else if (PlatformConfiguration.IsLinux)
+				handle = Linux.dlsym (library, symbolName);
+			else if (PlatformConfiguration.IsMac)
+				handle = Mac.dlsym (library, symbolName);
+			else
+				throw new PlatformNotSupportedException ($"Current platform is unknown, unable to load symbol '{symbolName}' from library {library}.");
+
+			return handle;
+		}
+
+		public static void FreeLibrary (IntPtr library)
+		{
+			if (library == IntPtr.Zero)
+				return;
+
+			if (PlatformConfiguration.IsWindows)
+				Win32.FreeLibrary (library);
+			else if (PlatformConfiguration.IsLinux)
+				Linux.dlclose (library);
+			else if (PlatformConfiguration.IsMac)
+				Mac.dlclose (library);
+			else
+				throw new PlatformNotSupportedException ($"Current platform is unknown, unable to close library '{library}'.");
+		}
+
+#pragma warning disable IDE1006 // Naming Styles
+		private static class Mac
+		{
+			private const string SystemLibrary = "/usr/lib/libSystem.dylib";
+
+			private const int RTLD_LAZY = 1;
+			private const int RTLD_NOW = 2;
+
+			public static IntPtr dlopen (string path, bool lazy = true) =>
+				dlopen (path, lazy ? RTLD_LAZY : RTLD_NOW);
+
+			[DllImport (SystemLibrary)]
+			public static extern IntPtr dlopen (string path, int mode);
+
+			[DllImport (SystemLibrary)]
+			public static extern IntPtr dlsym (IntPtr handle, string symbol);
+
+			[DllImport (SystemLibrary)]
+			public static extern void dlclose (IntPtr handle);
+		}
+
+		private static class Linux
+		{
+			private const string SystemLibrary = "libdl.so";
+
+			private const int RTLD_LAZY = 1;
+			private const int RTLD_NOW = 2;
+
+			public static IntPtr dlopen (string path, bool lazy = true) =>
+				dlopen (path, lazy ? RTLD_LAZY : RTLD_NOW);
+
+			[DllImport (SystemLibrary)]
+			public static extern IntPtr dlopen (string path, int mode);
+
+			[DllImport (SystemLibrary)]
+			public static extern IntPtr dlsym (IntPtr handle, string symbol);
+
+			[DllImport (SystemLibrary)]
+			public static extern void dlclose (IntPtr handle);
+		}
+
+		private static class Win32
+		{
+			private const string SystemLibrary = "Kernel32.dll";
+
+			[DllImport (SystemLibrary, SetLastError = true, CharSet = CharSet.Ansi)]
+			public static extern IntPtr LoadLibrary (string lpFileName);
+
+			[DllImport (SystemLibrary, SetLastError = true, CharSet = CharSet.Ansi)]
+			public static extern IntPtr GetProcAddress (IntPtr hModule, string lpProcName);
+
+			[DllImport (SystemLibrary, SetLastError = true, CharSet = CharSet.Ansi)]
+			public static extern void FreeLibrary (IntPtr hModule);
+		}
+#pragma warning restore IDE1006 // Naming Styles
+	}
+#endif
+}

binding/Binding.Shared/PlatformConfiguration.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Runtime.InteropServices;
 
 #if HARFBUZZ
@@ -11,20 +10,62 @@ namespace SkiaSharp
 	internal static class PlatformConfiguration
 	{
 		public static bool IsUnix { get; }
+
 		public static bool IsWindows { get; }
 
+		public static bool IsMac { get; }
+
+		public static bool IsLinux { get; }
+
 		static PlatformConfiguration ()
 		{
 #if WINDOWS_UWP
+			IsMac = false;
+			IsLinux = false;
 			IsUnix = false;
 			IsWindows = true;
-#elif NET_STANDARD
-			IsUnix = RuntimeInformation.IsOSPlatform (OSPlatform.OSX) || RuntimeInformation.IsOSPlatform (OSPlatform.Linux);
-			IsWindows = RuntimeInformation.IsOSPlatform (OSPlatform.Windows);
-#else
+#elif NET45
 			IsUnix = Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix;
 			IsWindows = !IsUnix;
+			IsMac = IsUnix && MacPlatformDetector.IsMac.Value;
+			IsLinux = IsUnix && !IsMac;
+#else
+			IsMac = RuntimeInformation.IsOSPlatform (OSPlatform.OSX);
+			IsLinux = RuntimeInformation.IsOSPlatform (OSPlatform.Linux);
+			IsUnix = IsMac || IsLinux;
+			IsWindows = RuntimeInformation.IsOSPlatform (OSPlatform.Windows);
 #endif
 		}
+
+#if NET45
+#pragma warning disable IDE1006 // Naming Styles
+		private static class MacPlatformDetector
+		{
+			internal static readonly Lazy<bool> IsMac = new Lazy<bool> (IsRunningOnMac);
+
+			[DllImport ("libc")]
+			static extern int uname (IntPtr buf);
+
+			static bool IsRunningOnMac ()
+			{
+				IntPtr buf = IntPtr.Zero;
+				try {
+					buf = Marshal.AllocHGlobal (8192);
+					// This is a hacktastic way of getting sysname from uname ()
+					if (uname (buf) == 0) {
+						string os = Marshal.PtrToStringAnsi (buf);
+						if (os == "Darwin")
+							return true;
+					}
+				} catch {
+				} finally {
+					if (buf != IntPtr.Zero)
+						Marshal.FreeHGlobal (buf);
+				}
+				return false;
+			}
+		}
+#pragma warning restore IDE1006 // Naming Styles
+#endif
 	}
 }

binding/Binding/SKCanvas.cs

@@ -793,7 +793,7 @@ public void Flush ()
 
 		public void DrawAnnotation (SKRect rect, string key, SKData value)
 		{
-			var bytes = StringUtilities.GetEncodedText (key, SKTextEncoding.Utf8);
+			var bytes = StringUtilities.GetEncodedText (key, SKTextEncoding.Utf8, true);
 			fixed (byte* b = bytes) {
 				SkiaApi.sk_canvas_draw_annotation (base.Handle, &rect, b, value == null ? IntPtr.Zero : value.Handle);
 			}

binding/Binding/SKData.cs

@@ -87,7 +87,7 @@ public static SKData Create (string filename)
 			if (string.IsNullOrEmpty (filename))
 				throw new ArgumentException ("The filename cannot be empty.", nameof (filename));
 
-			var utf8path = StringUtilities.GetEncodedText (filename, SKTextEncoding.Utf8);
+			var utf8path = StringUtilities.GetEncodedText (filename, SKTextEncoding.Utf8, true);
 			fixed (byte* u = utf8path) {
 				return GetObject (SkiaApi.sk_data_new_from_file (u));
 			}

binding/Binding/SKFontManager.cs

@@ -91,7 +91,7 @@ public SKTypeface CreateTypeface (string path, int index = 0)
 			if (path == null)
 				throw new ArgumentNullException (nameof (path));
 
-			var utf8path = StringUtilities.GetEncodedText (path, SKTextEncoding.Utf8);
+			var utf8path = StringUtilities.GetEncodedText (path, SKTextEncoding.Utf8, true);
 			fixed (byte* u = utf8path) {
 				return SKTypeface.GetObject (SkiaApi.sk_fontmgr_create_from_file (Handle, u, index));
 			}

binding/Binding/SKObject.cs

@@ -36,6 +36,8 @@ internal ConcurrentDictionary<IntPtr, SKObject> KeepAliveObjects {
 
 		static SKObject ()
 		{
+			SkiaSharpVersion.CheckNativeLibraryCompatible (true);
+
 			SKColorSpace.EnsureStaticInstanceAreInitialized ();
 			SKData.EnsureStaticInstanceAreInitialized ();
 			SKFontManager.EnsureStaticInstanceAreInitialized ();

binding/Binding/SKStream.cs

@@ -274,7 +274,7 @@ public SKFileStream (string path)
 
 		private static IntPtr CreateNew (string path)
 		{
-			var bytes = StringUtilities.GetEncodedText (path, SKTextEncoding.Utf8);
+			var bytes = StringUtilities.GetEncodedText (path, SKTextEncoding.Utf8, true);
 			fixed (byte* p = bytes) {
 				return SkiaApi.sk_filestream_new (p);
 			}
@@ -487,7 +487,7 @@ public SKFileWStream (string path)
 
 		private static IntPtr CreateNew (string path)
 		{
-			var bytes = StringUtilities.GetEncodedText (path, SKTextEncoding.Utf8);
+			var bytes = StringUtilities.GetEncodedText (path, SKTextEncoding.Utf8, true);
 			fixed (byte* p = bytes) {
 				return SkiaApi.sk_filewstream_new (p);
 			}

binding/Binding/SKTypeface.cs

@@ -107,7 +107,7 @@ public static SKTypeface FromFile (string path, int index = 0)
 			if (path == null)
 				throw new ArgumentNullException (nameof (path));
 
-			var utf8path = StringUtilities.GetEncodedText (path, SKTextEncoding.Utf8);
+			var utf8path = StringUtilities.GetEncodedText (path, SKTextEncoding.Utf8, true);
 			fixed (byte* u = utf8path) {
 				return GetObject (SkiaApi.sk_typeface_create_from_file (u, index));
 			}

binding/Binding/SkiaApi.cs

@@ -1,4 +1,6 @@
-namespace SkiaSharp
+using System;
+
+namespace SkiaSharp
 {
 	internal partial class SkiaApi
 	{
@@ -12,14 +14,20 @@ internal partial class SkiaApi
 		private const string SKIA = "libSkiaSharp.so";
 #elif __MACOS__
 		private const string SKIA = "libSkiaSharp.dylib";
-#elif __DESKTOP__
-		private const string SKIA = "libSkiaSharp";
 #elif WINDOWS_UWP
 		private const string SKIA = "libSkiaSharp.dll";
-#elif NET_STANDARD
-		private const string SKIA = "libSkiaSharp";
+#elif __TIZEN__
+		private const string SKIA = "libSkiaSharp.so";
 #else
 		private const string SKIA = "libSkiaSharp";
 #endif
+
+#if USE_DELEGATES
+		private static readonly Lazy<IntPtr> libSkiaSharpHandle =
+			new Lazy<IntPtr> (() => LibraryLoader.LoadLocalLibrary<SkiaApi> (SKIA));
+
+		private static T GetSymbol<T> (string name) where T : Delegate =>
+			LibraryLoader.GetSymbolDelegate<T> (libSkiaSharpHandle.Value, name);
+#endif
 	}
 }