Unity 安卓平台读写

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using  UnityEngine.Networking;
using UnityEngine.Video;

public class Test : MonoBehaviour
{
    public Image image;
    public AudioSource audioSource;
    public Text text;
    public VideoPlayer videoPlayer;

    private string abSavePath;
    private string abPath;
    private string imagePath;
    private string audioPath;
    private string textPath;
    private string videoPath;
    void Start()
    {
        imagePath = PathUtils.StreamingAssets + "/Images/bg.png";
        audioPath = PathUtils.StreamingAssets + "/Audio/bg1.mp3";
        textPath = PathUtils.StreamingAssets + "/Json/json_config.txt";
        videoPath = PathUtils.StreamingAssets + "/Video/Test.mp4";
        abSavePath = "/AB/subjecttwo_zigong";
        abPath = PathUtils.StreamingAssets + "/AB/subjecttwo_zigong";

        LoadSprite();
        LoadAudioClip();
        LoadTxt();
        LoadVideo();
        DownloadAB();
    }

    void LoadSprite()
    {
        StartCoroutine(Utils.LoadImageByUrl(imagePath, t =>
        {
            Sprite sp = Utils.LoadSpriteFromTexture2D(t);
            image.overrideSprite = sp;
        }));
    }
    
    void LoadAudioClip()
    {
        StartCoroutine(Utils.LoadAudioByUrl(audioPath, audio =>
        {
            audioSource.clip = audio;
        }));
    }

    void LoadTxt()
    {
        StartCoroutine(Utils.LoadRTextByUrl(textPath, txt =>
        {
            text.text = txt;
        }));
    }

    void LoadVideo()
    {
        videoPlayer.url = videoPath;
    }

    void DownloadAB()
    {
        StartCoroutine(Utils.DownloadABASsets(abPath, abSavePath, delegate
        {
            Debug.Log("下载完成");            
        }));
    }
}

public class Utils
{
    public static IEnumerator LoadImageByUrl(string url,Action<Texture2D> action) 
    {
        UnityWebRequest request = new UnityWebRequest(url);
        DownloadHandlerTexture downloadHandler = new DownloadHandlerTexture(true);
        request.downloadHandler = downloadHandler;
        request.SendWebRequest();
        while (!request.isDone)
        {
            Debug.Log(request.downloadProgress);
            yield return 0;
        }
        Texture2D texture = null;
        if (!request.isNetworkError||request.isHttpError)
        {
            texture = downloadHandler.texture;
        }
        if (action!=null)
        {
            action(texture);
        }
    }

    public static Sprite LoadSpriteFromTexture2D(Texture2D texture)
    {
        Sprite sp = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), Vector2.zero);
        return sp;
    }
    
    public static IEnumerator LoadRTextByUrl(string url,Action<string>callback)
    {
        UnityWebRequest request = UnityWebRequest.Get(url);
        request.SendWebRequest();
        while (!request.isDone)
        {
            Debug.Log(request.downloadProgress);
            yield return 0;
        }
        string str = request.downloadHandler.text;
        callback?.Invoke(str);
    }

    public static IEnumerator LoadAudioByUrl(string url,Action<AudioClip>callback)
    {
        UnityWebRequest request = UnityWebRequestMultimedia.GetAudioClip(url,AudioType.UNKNOWN);
        request.SendWebRequest();
        while (!request.isDone)
        {
            Debug.Log(request.downloadProgress);
            yield return 0;
        }
        if (request.result== UnityWebRequest.Result.ConnectionError)
        {
            Debug.LogError("request.error");
            callback?.Invoke(null);
        }
        else
        {
            AudioClip clip = DownloadHandlerAudioClip.GetContent(request);
            callback?.Invoke(clip);
        }
    }

    public static IEnumerator LoadABAssets(string url,Action<AssetBundle>callback)
    {
        UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(url);
        request.SendWebRequest();
        while (!request.isDone)
        {
            Debug.Log(request.downloadProgress);
            yield return 0;
        }
        AssetBundle ab = DownloadHandlerAssetBundle.GetContent(request);
        callback?.Invoke(ab);
    }

    public static IEnumerator DownloadABASsets(string url,string savePath,Action callback)
    {
        if (!Directory.Exists(PathUtils.PersistentDataPath+"/AB"))
        {
            Directory.CreateDirectory(PathUtils.PersistentDataPath+"/AB");
        }
        if (File.Exists(PathUtils.PersistentDataPath+savePath))
        {
            callback?.Invoke();
            yield break;
        }
        UnityWebRequest request = UnityWebRequest.Get(url);
        request.SendWebRequest();
        while (!request.isDone)
        {
            Debug.Log(request.downloadProgress);
            yield return 0;
        }

        if (request.isDone)
        {
            Debug.Log("download finished");
        }

        byte[] data = request.downloadHandler.data;
        using (FileStream fs = new FileStream(PathUtils.PersistentDataPath+savePath,FileMode.Create))
        {
            fs.Write(data,0,data.Length);
        }
        callback?.Invoke();
    }
}

public class PathUtils
{
    public static string StreamingAssets
    {
        get
        {
            if (Application.platform== RuntimePlatform.Android)
            {
                return "jar:file://" + Application.dataPath + "!/assets";
            }else if (Application.platform== RuntimePlatform.IPhonePlayer)
            {
                return "file://"+Application.dataPath+"/Raw";
            }
            else
            {
                return Application.streamingAssetsPath;
            }
        }

    }

    public static string PersistentDataPath
    {
        get
        {
            return Application.persistentDataPath;
        }
    }
}

你可能感兴趣的