Brtdku

I need to load a file in my application and since it is big ( around 250MB) I need to perform this loading off the main thread. What is more, because assets on Android are not stored in a regular directory, but a jar file, I need to use WWW or UnityWebRequest class.

I ended up with helper method like that:

public static byte ReadAllBytes(string filePath)

{



    if (Application.platform == RuntimePlatform.Android)

    {

        var reader = new WWW(filePath);

        while (!reader.isDone) { }



        return reader.bytes;

    }

    else

    {

        return File.ReadAllBytes(filePath);

    }

}

The problem is I cannot use it on background thread - Unity won't allow me to create WWW object there. How can I create a method like this, which will read those bytes on current thread?

just put your while loop inside a CoRoutine and while your request is not done to a yield return. when it is done call a method where you want to use your data:

IEnumerator MyMethod()

{

    var reader = new WWW(filePath);

    while (!reader.isDone) 

    { 

        yield return; // <- use endofFrame or Wait For ore something else if u want

    }

    LoadingDoneDoData(reader.bytes);

}



void LoadingDoneDoData(bytes data)

{

    // your Code here

}

I think you can use something like

public static async void ReadAllBytes(string filePath, Action<byte> successCallback)

{

    byte result;

    using (FileStream stream = File.Open(filePath, FileMode.Open))

    {

        result = new byte[stream.Length];

        await stream.ReadAsync(result, 0, (int)stream.Length);

    }



    // Now pass the byte to the callback

    successCallback.Invoke();

}

(Source)

Than I guess you can use it like

TheClass.ReadAllBytes(

    "a/file/path/",



    // What shall be done as soon as you have the byte

    (bytes) =>

    {

        // What you want to use the bytes for

    }

);

I'm no multi-threading expert but here and also here you can find more examples and how to's for async - await with Unity3d.

Alternatively also the new Unity Jobsystem might be interesting for you.

I ended up with the following solution. I did not find a way to load raw file main thread, but I managed to load it in Coroutine and perform further (also heavy) operations on this file on a background Thread. I made a static method like this:

public static void ReadAllBytesInCoroutine(MonoBehaviour context, string filePath, Action<ReadBytesInCoroutineResult> onComplete)

{

    context.StartCoroutine(ReadFileBytesAndTakeAction(filePath, onComplete));

}



private static IEnumerator ReadFileBytesAndTakeAction(string filePath, Action<ReadBytesInCoroutineResult> followingAction)

{

    WWW reader = null;



    try

    {

        reader = new WWW(filePath);

    }

    catch(Exception exception)

    {

        followingAction.Invoke(ReadBytesInCoroutineResult.Failure(exception));

    }



    while (reader != null && !reader.isDone)

    {

        yield return null;

    }

    followingAction.Invoke(ReadBytesInCoroutineResult.Success(reader.bytes));

}

ReadBytesInCoroutineResult is my simple, custom data class:

public class ReadBytesInCoroutineResult

{

    public readonly bool successful;

    public readonly byte data;

    public readonly Exception reason;



    private ReadBytesInCoroutineResult(bool successful, byte data, Exception reason)

    {

        this.successful = successful;

        this.data = data;

        this.reason = reason;

    }



    public static ReadBytesInCoroutineResult Success(byte data)

    {

        return new ReadBytesInCoroutineResult(true, data, null);

    }



    public static ReadBytesInCoroutineResult Failure(Exception reason)

    {

        return new ReadBytesInCoroutineResult(true, null, reason);

    }



}

This way I have a mechanism to order to load a file in coroutine in any place (as long as it is on the main thread). A file is loaded synchronously, but it is not blocking main thread, because of the coroutine. Later I invoke this function and take acquired bytes on a separate thread, where I perform heavy computing on them.

    ResourcesUtils.ReadAllBytesInCoroutine(monoBehavior, filePath, (bytes) => {



        //here I run an async method which takes bytes as parameter



    });