Migrating from Windows Standalone to UWP

[marck_ozz]

Hello guys!!

I’m trying to migrate my Windows PC app from “Standalone” to “UWP” and it result to be more challenging that I thougth, assume that both are windows bulds and sould works the same was my first mistake.

I’m following the steps on this https://unity3d.com/partners/microsoft/porting-guides

I’m able to build my App and tested in Windows 10, but some functions are letting off of my build, in specific the ones that uses dlls like “System.Windows.Forms” and “user32.dll” wich I uses to Open file and resize the windows for example.
So, I’m trying to use this UWP specific APIs and methods to replace them like this:

Open files and folders with a picker - UWP applications

But I’m unable to use the “Window.Storage” API that supouse to be already on my project (Am I right?). I’m getting the classic “Error: are you missing a using directive or an assembly reference?” error.

In fact I’m unable to use any “Windows.Something” directive.

My Questions are:

1.- Is there an ACTUALIZED guide for UWP developing, build or recommended configuration?
2.- How to use the Windows APIs in unity? or better, how to add those APIs?

I have to add that my app for stand alone works pretty well, but now I have to take advantage of the Windows Store functionalities.

I think that an actualized guide “step by step” on develop for UWP could be more helping, all the information out there is out of date.

I’m using:
Unity 2019.15 LTS
Visual Studio 2019 community
Windows 10

My settings:

[Tautvydas-Zilys]

You need to wrap the access to those Windows.* APIs with #if ENABLE_WINMD_SUPPORT/#endif. It won’t work in the editor, but the code path will become active when you build your game for UWP.

[marck_ozz]

Thank you!

I have tried with something like this:

public void OpenFile()
    {
        FilePicker();
    }

    async void FilePicker()
    {

#if ENABLE_WINMD_SUPPORT
        var picker = new Windows.Storage.Pickers.FileOpenPicker();
        picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
        picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
        picker.FileTypeFilter.Add(".jpg");
        picker.FileTypeFilter.Add(".jpeg");
        picker.FileTypeFilter.Add(".png");

        Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
        if (file != null)
        { 
            Debug.Log(file.Name);
        }
        else
        {
            Debug.Log("Operation cancelled");
        }
#endif

    }

which remove the errors but as you say I can’t test that in editor, I have to build (that is a long process in UWP) and hope that code works, if not, I have to repeat the whole process again.

in some cases it gives me an error when I try to build due to some mistakes in that code. Plus, there some other more complex code like this (that also I try to implement):

Enable subscription add-ons for your app - Microsoft Store

In that case, I need this “prerequisites”:

• You have created an app submission in Partner Center and this app is published in the Store. You can optionally configure the app so it is not discoverable in the Store while you test it. For more information, see the testing guidance.
• You have created a subscription add-on for the app in Partner Center.

But I can’t even have app submission in the Parnet Center due to all those “bugs-erros”. There’s a long way from just an app builded in UWP and an app suibmited to Partnet Center (e.g I have to have a Windows Certified app via Certification kit) but firs I need a clean code.

Maybe is more complex than Platfrom Dependent compilation. Is that the only way?

[Tautvydas-Zilys]

If you use “Script Only” build checkbox in the build settings, the iteration time should be fairly quick.

You could also use “ExecutableOnly” build type, which eliminates the generated Visual Studio project and generates a built app directly (like the Windows Standalone player build). You can’t ship a build like that, but iterating on it should be much faster.

[marck_ozz]

Thanks for the responses

In order to use “Script Only” I have to check “Development Build” what I was already discarted because on the “Certification app” (Using the Windows App Certification Kit - Windows app development | Microsoft Learn) step on the “Windows stuff” side it gives me an error message saying tha the “UnityPlayer” was precisely on develompent build.

Now, when I select “script only” i get this error “Cached player destination differs from selected player destination. Please uncheck ‘Scripts Only Build’ and build again before attempting another scripts only build”

Those are the kind of “tips” or “steps” than should be in a new “Guide for UWP”, and I feel like I’m on the half on the way on this, on which I have arrived by taken information from here and there, even on the windows official pages.

Is there something like an example project out there from Unity or the Windows side with “Good Practices” for UWP?

[Tautvydas-Zilys]

Yes, you have to use development player for scripts only builds, and yes, it will fail certification. However, you’re not submitting these builds that you iterate on to the Windows Store, so failing certification while iterating is fine. Once you finish development, you can make a single final build as “non-development”. To use script only builds, you have to first make a full build with the same build settings and not modify your scenes. However, those builds will be way quicker than regular builds.

We had a couple example projects for using specific UWP features but I’m looking at it and seems that they were taken down (I’m trying to figure out why). Our UWP development documentation can be found here:

https://docs.unity3d.com/Manual/windowsstore-gettingstarted.html

[marck_ozz]

Ok, I’ll double check that info in case I missed something.

[marck_ozz]

Hello again,

This is what I got:

First according with this: Unity - Manual: Windows Runtime support, the WinRT suport suppuse to be already implemented in my project.

And according to this: Unity - Manual: WinRT API in C# scripts for UWP, “Because the same script code is also used by Unity Editor (which always uses Mono), all code that uses WinRT API must be under ENABLE_WINMD_SUPPORT define” which I already have in the example given before.

But still have this error when I try to build:

“Assets\Scripts\FileManagerUWP.cs(39,54): error CS1929: ‘IAsyncOperation<StorageFile>’ does not contain a definition for ‘GetAwaiter’ and the best extension method overload ‘AwaitExtensions.GetAwaiter(Process)’ requires a receiver of type ‘Process’”

This Windows docs, Call asynchronous APIs in C# or Visual Basic - UWP applications | Microsoft Learn, says that the “FileOpenPicker.PickSingleFileAsync” has an “StorageFile” result type, so for me it seems like “await” operator it’s not working as it should in an “UWP buid” but in an “Unity way”.

I also tryed something like this with the same result:

using System.Collections;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using UnityEngine;

public class FileManagerUWP : MonoBehaviour
{
    public GameObject button2;
  
    public void OpenFile()
    {
        FilePickerTask();
    }

    async void FilePickerTask()
    {
        await FilePickerAsync();
    }

    async Task FilePickerAsync()
    {

#if ENABLE_WINMD_SUPPORT
            var picker = new Windows.Storage.Pickers.FileOpenPicker();
            picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
            picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
            picker.FileTypeFilter.Add(".jpg");
            picker.FileTypeFilter.Add(".jpeg");
            picker.FileTypeFilter.Add(".png");

            Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
            if (file != null)
            { 
                Debug.Log(file.Name);
                //Do something
            }
            else
            {
                Debug.Log("Operation cancelled");
                //do something
            }
#endif
        await new WaitForSeconds(0.1f); // added to avoid the CS1998 warning since "await" is under platform dependant code
    }
}

even try this silly code to see if it works only in UWP build (it obviously works):

public GameObject button2;
  
    public void OpenFile()
    {
        //FilePickerTask();
#if ENABLE_WINMD_SUPPORT
        button2.SetActive(true);
#endif


    }

I thing I missing something if not in the project settings-configuration maybe in the code.

I will thank any help!!!.

[Tautvydas-Zilys]

“Assets\Scripts\FileManagerUWP.cs(39,54): error CS1929: ‘IAsyncOperation<StorageFile>’ does not contain a definition for ‘GetAwaiter’ and the best extension method overload ‘AwaitExtensions.GetAwaiter(Process)’ requires a receiver of type ‘Process’”

You’re just missing “using System;” at the top of the file. GetAwaiter is an extension method for IAsyncOperation interface and it’s defined in the System namespace. Compiler requires it to use the “await” operator.

[marck_ozz]

Thanks for your answers.

1.- [quote=“Tautvydas-Zilys, post:9, topic: 825946, username:Tautvydas-Zilys”]
You’re just missing “using System;”
[/quote]
that works, I I thought that was the job of “using System.Threading;” and “using System.Threading.Tasks;”.

2.- The iteration time beetwen build and build is still too long when I creating the packages with the .sln file (almost 40min) is that normal? I creating only for x64.

3.- I have to ask again if there’s no way to include those WinRT APIs directly in the project like “using Windows.Storage” instead of using “#if ENABLE_WINMD_SUPPORT”? that grayed out the code and no error are shown until I try to build, its like coding on Notepad and hope everything works fine, I’m not that good haha.

4.- After all that anoying things I still have errors in those functions that I try to use in the builded app (open file, folder).
I test another method that I found in here: Launcher.LaunchFolderAsync Method (Windows.System) - Windows UWP applications | Microsoft Learn

which shows a file explorer on UWP.

async void FolderLaunchAsync()
    {
        //C:\Users\Documents\UnityGames\Imagenes

#if ENABLE_WINMD_SUPPORT
            string sPath = @"C:\Users\Documents\UnityGames\Imagenes";
          

            Windows.Storage.StorageFolder folder = await Windows.Storage.StorageFolder.GetFolderFromPathAsync(sPath);

            await Windows.System.Launcher.LaunchFolderAsync(folder);
            if (folder != null)
            { 
                Debug.LogWarning("OK FOLDER");
                //Do something
            }
            else
            {
                Debug.LogWarning("NO FOLDER");
                //do something
            }
#endif
        await new WaitForSeconds(0.1f); // added to avoid the CS1998 warning since "await" is under platform dependant code
    }

The Unity player shows the next for the first code (openFile):

(Filename: C:\buildslave\unity\build\Runtime/Export/Debug/Debug.bindings.h Line: 35)

Exception: Exception of type 'System.Exception' was thrown.
  at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw () [0x00000] in <00000000000000000000000000000000>:0
  at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess (System.Threading.Tasks.Task task) [0x00000] in <00000000000000000000000000000000>:0
  at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification (System.Threading.Tasks.Task task) [0x00000] in <00000000000000000000000000000000>:0
  at System.Runtime.CompilerServices.TaskAwaiter.ValidateEnd (System.Threading.Tasks.Task task) [0x00000]...

and the next for the second (show file explorer):

(Filename: C:\buildslave\unity\build\Runtime/Export/Debug/Debug.bindings.h Line: 35)

UnauthorizedAccessException: Attempted to perform an unauthorized operation.
  at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw () [0x00000] in <00000000000000000000000000000000>:0
  at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess (System.Threading.Tasks.Task task) [0x00000] in <00000000000000000000000000000000>:0
  at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification (System.Threading.Tasks.Task task) [0x00000] in <00000000000000000000000000000000>:0
  at System.Runtime.CompilerServices.TaskAwaiter.ValidateEnd (System.Threading.Tasks.Task task) [0x00000] in <00000000000000000000000000000000>:0 ...

I’ll attach the complete log file.

Maybe depelop for UWP on Unity is not that easy (or posible) for those “more specific” functions.

6777494–783959–UnityPlayer.txt (22.8 KB)

[Tautvydas-Zilys]

@marck_ozz

2.- The iteration time beetwen build and build is still too long when I creating the packages with the .sln file (almost 40min) is that normal? I creating only for x64.

That is absolutely not normal. Can you share the build settings you use?

@marck_ozz

3.- I have to ask again if there’s no way to include those WinRT APIs directly in the project like “using Windows.Storage” instead of using “#if ENABLE_WINMD_SUPPORT”? that grayed out the code and no error are shown until I try to build, its like coding on Notepad and hope everything works fine, I’m not that good haha.

You can switch to “player” context in Visual Studio:

Once you do that, #if ENABLE_WINMD_SUPPORT define becomes active and you get full intellisense.

@marck_ozz

4.- After all that anoying things I still have errors in those functions that I try to use in the builded app (open file, folder).

Those functions might have to be called on the Windows UI thread. You can use UnityEngine.WSA.Application.InvokeOnUIThread() to move the execution to the UI thread, and UnityEngine.WSA.Application.InvokeOnAppthread() to move the execution to the App thread. I also believe you cannot give arbitrary path to GetFolderFromPathAsync: UWP applications by default only have access to very fews paths on the filesystem. If you want to supply an arbitrary folder, you’re going to have to pick it from a file/folder picker. In general, none of this is specific to Unity: it’d work the same way if you tried running this code in any UWP application (with the exception that Unity scripts don’t execute on the UI thread by default).

[marck_ozz]

@Tautvydas-Zilys

That is absolutely not normal. Can you share the build settings you use?

are the same tha I posted before, just added the Scrip only option:

[marck_ozz]

@Tautvydas-Zilys

You can switch to “player” context in Visual Studio:

How can I activate that:

[Tautvydas-Zilys]

Ah, you might need to enable player project generation in Unity preferences:

As for the build times: which step takes a long time - building from Unity or building generated Visual Studio project?

You should check the development build checkbox and switch build mode to “Executable Only” and uncheck scripts only builds. Then, build to an empty folder, and afterwards check the scripts only build (and have it checked for subsequent builds).

I suspect scripts only build doesn’t work for you because the development build checkbox isn’t checked.

[marck_ozz]

@Tautvydas-Zilys

Ah, you might need to enable player project generation in Unity preferences:

Thanks a lot!!! it’s so much easier now.

@Tautvydas-Zilys

UnityEngine.WSA.Application.InvokeOnUIThread() to move the execution to the UI thread, and UnityEngine.WSA.Application.InvokeOnAppthread()

This works too, I can select a file from my disk like in Standalone. Here is the code (as an example):

using System.Collections;
using System.Collections.Generic;
using System;
using UnityEngine.UI;
using UnityEngine;

public class FileManagerUWP : MonoBehaviour
{
    public Text thisTxt;
    private string path_;
    private bool done_;
  
  
    public void OpenFile()
    {
        FilePickerAsync();
    }


    async void FilePickerAsync()
    {

#if ENABLE_WINMD_SUPPORT
            UnityEngine.WSA.Application.InvokeOnUIThread(async () =>
        {
            var picker = new Windows.Storage.Pickers.FileOpenPicker();
            picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
            picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
            picker.FileTypeFilter.Add(".jpg");
            picker.FileTypeFilter.Add(".jpeg");
            picker.FileTypeFilter.Add(".png");

            Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
            if (file != null)
            { 
                Debug.Log(file.Name);
                path_ = file.Name;
                done_ = true;
            }
            else
            {
                Debug.Log("Operation cancelled");
                path_ = "No file selected";
                done_ = true;
            }
        }, true);
#endif
        await new WaitForSeconds(0.0f); // added to avoid the CS1998 warning since "await" is under platform dependant code

    }

    void Update()
    {
        if (done_)
        {
            thisTxt.text = path_;
            done_ = false;
        }
    }
}

@Tautvydas-Zilys

As for the build times: which step takes a long time - building from Unity or building generated Visual Studio project?

It was building the Visual Studio project because I was generating the packages every time, I didn’t explore the “Executable Only” option before, it just “make the work for me” and for developing and testing is OK and faster (like 5-8 min every buld).

Thanks a lot man!!!, I think (and hope) that with this I can replace the rest of standalone functions for the UWP ones.

[marck_ozz]

@Tautvydas-Zilys

We had a couple example projects for using specific UWP features but I’m looking at it and seems that they were taken down

anyways it would be great to have a look to those examples!

thanks again