Unity cannot build GRPC Project for UWP with IL2CPP Backend

Question

Here, or here for a complete version, you can find a sample GRPC "Hello World" project for Unity. Only the first version, that is built for Unity and wrapped in a DLL is working perfectly fine in Unity IDE and on Standalone build. The Raw Grpc.Core files are referencing everything correctly in IDE but they have Marshaling problem.

Unfortunately, it cannot get build for UWP with IL2CPP backend. Unity builds the project and creates a .sln project. But Visual Studio always gives LNK2001 for GRPC properties on the final compilation.

Here are first error codes:

LNK2001 unresolved external _grpccsharp_init@0
LNK2001 unresolved external _grpccsharp_shutdonw@0
LNK2001 unresolved external _grpccsharp_version_string@0
...

Ok, thanks to @Sunius, I digged into it a little bit more. There are some points, I am going to add to the question:

There are two methods regarding referencing extern methods in GRPC C# package. They are named static and shared libs.

internal class DllImportsFromStaticLib
{
    private const string ImportName = "__Internal";

    [DllImport(ImportName)]
    public static extern void grpcsharp_init();

    [DllImport(ImportName)]
    public static extern void grpcsharp_shutdown();

    ...
}

and

internal class DllImportsFromSharedLib
{
    private const string ImportName = "grpc_csharp_ext";

    [DllImport(ImportName)]
    public static extern void grpcsharp_init();

    [DllImport(ImportName)]
    public static extern void grpcsharp_shutdown();

    ...
}

I tried to test it with the shared one, I got another linking error file which is a little bit different.

LNK2001 unresolved external _dlopen@8
LNK2001 unresolved external _dlsym@8
...

In two separate methods, extern methods are getting connected to the internal interface:

public NativeMethods(DllImportsFromStaticLib unusedInstance) 
{
    this.grpccsharp_init = DllImportsFromStaticLib.grpccsharp_init; 
    this.grpccsharp_shutdown = DllImportsFromStaticLib.grpccsharp_shutdonw;
    ...
}

and

public NativeMethods(DllImportsFromSharedLib unusedInstance) 
{
    this.grpccsharp_init = DllImportsFromSharedLib.grpccsharp_init; 
    this.grpccsharp_shutdown = DllImportsFromSharedLib.grpccsharp_shutdonw;
    ...
}

And which method will get called is defined here:

private static NativMethods LoadNativeMethodsUnity()
{
    switch(PlatformApis.GetUnityRuntimePlatform())
    {
        case "IPhonePlayer":
            return new NativeMethods(new NativeMethods.DllImportsFromStaticLib());
        default:
            return new NativeMethods(new NativeMethods.DllImportsFromSharedLib());  
    }
}

Some updates:

Thanks to @jsmouret, there is Stub.c file in his Grpc Github with fake methods, so Linker does not complain about Grpc_init methods anymore.

Next Error: dlopen, dlsym, dlerror:

First, I tried to use the same, Stub technique, but it did not help in this case, or maybe I did it wrong.

Thanks to @Sunius, I commented out all of "__Internal" dll import codes. So I am not getting any dlopen, dlsym, and dlerror errors.

Next Error: It happens from inside application, not the visual studio debugger. It tells me: "exception: to marshal a managed method, please add an attribute named 'MonoPInvokeCallback' to the method definition."

exception: error loading the embedded resource "Grpc.Core.roots.pem"

and

exception: To marshal a managed method, please add an attribute named 'MonoPInvokeCallback' to the method definition.

After I googled it, I know my options, but the question it, for which method should I do that?!

Answer 1

Thanks to my colleague Alice, @Sunius and @jsmouret, at the end, grpc works on UWP on Unity Platform through this steps:

1. Download Grpc.Core folder from Google Grpc Github.
2. Download Grpc Unity plugin from their official site.
3. Copy the runtime folder to your Grpc.Core folder. Please remove Grpc.Core.dll that you get from Grpc Unity Plugin, since we are using their source code.
4. Grpc should be in a folder called, Plugins in Unity, otherwise it will not be recognized.
5. Include this file in your runtime folder.
6. Include the Stub also from the Unity Plugin Inspector for WSA.
7. Find runtime .dll for Windows and include them in WSA from Unity Plugin Inspector.

By now, you should be getting _dlopen error.

8. Search through your Unity Solution with an IDE for "__Internal". There are not so many places, but comment them out. Also some methods that are depended on "__Internal"s, like dlopen and dlsym.

By now, you are not getting anymore build error but you need to make Grpc work.

9. Search for something like "DefaultSslRootsOverride" and comment out like below:

   internal static class DefaultSslRootsOverride
   {
       const string RootsPemResourceName = "Grpc.Core.roots.pem";
       static object staticLock = new object();
   
       /// <summary>
       /// Overrides C core's default roots with roots.pem loaded as embedded resource.
       /// </summary>
       public static void Override(NativeMethods native)
       {
           lock (staticLock)
           {
               //var stream = typeof(DefaultSslRootsOverride).GetTypeInfo().Assembly.GetManifestResourceStream(RootsPemResourceName);
               //if (stream == null)
               //{
               //    throw new IOException(string.Format("Error loading the embedded resource \"{0}\"", RootsPemResourceName));   
               //}
               //using (var streamReader = new StreamReader(stream))
               //{
               //    var pemRootCerts = streamReader.ReadToEnd();
               //    native.grpcsharp_override_default_ssl_roots(pemRootCerts);
               //}
           }
       }
   }
   

10. Search for something like "static void HandWrite" and add an attribute like something in below:

    [MonoPInvokeCallback(typeof(GprLogDelegate))]
    private static void HandleWrite(IntPtr fileStringPtr, int line, ulong threadId, IntPtr severityStringPtr, IntPtr msgPtr)
    {
        try
        {
            var logger = GrpcEnvironment.Logger;
            string severityString = Marshal.PtrToStringAnsi(severityStringPtr);
            string message = string.Format("{0} {1}:{2}: {3}",
                threadId,
                Marshal.PtrToStringAnsi(fileStringPtr), 
                line, 
                Marshal.PtrToStringAnsi(msgPtr));
    
            switch (severityString)
            {
                case "D":
                    logger.Debug(message);
                    break;
                case "I":
                    logger.Info(message);
                    break;
                case "E":
                    logger.Error(message);
                    break;
                default:
                    // severity not recognized, default to error.
                    logger.Error(message);
                    break;
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("Caught exception in native callback " + e);
        }
    }
    

I guess, you are done. In case, it did not work for your UWP, let me know, maybe I can help. :)

Answer 2

It looks like your plugin uses "__Internal" P/Invoke to call those native functions:

https://github.com/grpc/grpc/blob/befc7220cadb963755de86763a04ab6f9dc14200/src/csharp/Grpc.Core/Internal/NativeMethods.Generated.cs#L542

However, the linker cannot locate those functions and thus fails. You should change that code to either specify the DLL file name where the functions are implemented, or drop the source files with definitions for those functions into your Unity project. Or, if that code path isn't actually invoked (since you said it works on the standalone player), #ifdef it out from UWP build.

You can find more information about "__Internal" P/Invoke here:

https://docs.unity3d.com/Manual/windowsstore-plugins-il2cpp.html