AndroidFileSystemStream.cs 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293
  1. //------------------------------------------------------------
  2. // Game Framework
  3. // Copyright © 2013-2021 loyalsoft. All rights reserved.
  4. // Homepage: http://www.game7000.com/
  5. // Feedback: http://www.game7000.com/
  6. //------------------------------------------------------------
  7. using GameFramework;
  8. using GameFramework.FileSystem;
  9. using System;
  10. using System.IO;
  11. using UnityEngine;
  12. namespace UnityGameFramework.Runtime
  13. {
  14. /// <summary>
  15. /// 安卓文件系统流。
  16. /// </summary>
  17. public sealed class AndroidFileSystemStream : FileSystemStream
  18. {
  19. private static readonly string SplitFlag = "!/assets/";
  20. private static readonly int SplitFlagLength = SplitFlag.Length;
  21. private static readonly AndroidJavaObject s_AssetManager = null;
  22. private static readonly IntPtr s_InternalReadMethodId = IntPtr.Zero;
  23. private static readonly jvalue[] s_InternalReadArgs = null;
  24. private readonly AndroidJavaObject m_FileStream;
  25. private readonly IntPtr m_FileStreamRawObject;
  26. static AndroidFileSystemStream()
  27. {
  28. AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
  29. if (unityPlayer == null)
  30. {
  31. throw new GameFrameworkException("Unity player is invalid.");
  32. }
  33. AndroidJavaObject currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
  34. if (currentActivity == null)
  35. {
  36. throw new GameFrameworkException("Current activity is invalid.");
  37. }
  38. AndroidJavaObject assetManager = currentActivity.Call<AndroidJavaObject>("getAssets");
  39. if (assetManager == null)
  40. {
  41. throw new GameFrameworkException("Asset manager is invalid.");
  42. }
  43. s_AssetManager = assetManager;
  44. IntPtr inputStreamClassPtr = AndroidJNI.FindClass("java/io/InputStream");
  45. s_InternalReadMethodId = AndroidJNIHelper.GetMethodID(inputStreamClassPtr, "read", "([BII)I");
  46. s_InternalReadArgs = new jvalue[3];
  47. AndroidJNI.DeleteLocalRef(inputStreamClassPtr);
  48. currentActivity.Dispose();
  49. unityPlayer.Dispose();
  50. }
  51. /// <summary>
  52. /// 初始化安卓文件系统流的新实例。
  53. /// </summary>
  54. /// <param name="fullPath">要加载的文件系统的完整路径。</param>
  55. /// <param name="access">要加载的文件系统的访问方式。</param>
  56. /// <param name="createNew">是否创建新的文件系统流。</param>
  57. public AndroidFileSystemStream(string fullPath, FileSystemAccess access, bool createNew)
  58. {
  59. if (string.IsNullOrEmpty(fullPath))
  60. {
  61. throw new GameFrameworkException("Full path is invalid.");
  62. }
  63. if (access != FileSystemAccess.Read)
  64. {
  65. throw new GameFrameworkException(Utility.Text.Format("'{0}' is not supported in AndroidFileSystemStream.", access.ToString()));
  66. }
  67. if (createNew)
  68. {
  69. throw new GameFrameworkException("Create new is not supported in AndroidFileSystemStream.");
  70. }
  71. int position = fullPath.LastIndexOf(SplitFlag, StringComparison.Ordinal);
  72. if (position < 0)
  73. {
  74. throw new GameFrameworkException("Can not find split flag in full path.");
  75. }
  76. string fileName = fullPath.Substring(position + SplitFlagLength);
  77. m_FileStream = InternalOpen(fileName);
  78. if (m_FileStream == null)
  79. {
  80. throw new GameFrameworkException(Utility.Text.Format("Open file '{0}' from Android asset manager failure.", fullPath));
  81. }
  82. m_FileStreamRawObject = m_FileStream.GetRawObject();
  83. }
  84. /// <summary>
  85. /// 获取或设置文件系统流位置。
  86. /// </summary>
  87. public override long Position
  88. {
  89. get
  90. {
  91. throw new GameFrameworkException("Get position is not supported in AndroidFileSystemStream.");
  92. }
  93. set
  94. {
  95. Seek(value, SeekOrigin.Begin);
  96. }
  97. }
  98. /// <summary>
  99. /// 获取文件系统流长度。
  100. /// </summary>
  101. public override long Length
  102. {
  103. get
  104. {
  105. return InternalAvailable();
  106. }
  107. }
  108. /// <summary>
  109. /// 设置文件系统流长度。
  110. /// </summary>
  111. /// <param name="length">要设置的文件系统流的长度。</param>
  112. public override void SetLength(long length)
  113. {
  114. throw new GameFrameworkException("SetLength is not supported in AndroidFileSystemStream.");
  115. }
  116. /// <summary>
  117. /// 定位文件系统流位置。
  118. /// </summary>
  119. /// <param name="offset">要定位的文件系统流位置的偏移。</param>
  120. /// <param name="origin">要定位的文件系统流位置的方式。</param>
  121. public override void Seek(long offset, SeekOrigin origin)
  122. {
  123. if (origin == SeekOrigin.End)
  124. {
  125. Seek(Length + offset, SeekOrigin.Begin);
  126. return;
  127. }
  128. if (origin == SeekOrigin.Begin)
  129. {
  130. InternalReset();
  131. }
  132. while (offset > 0)
  133. {
  134. long skip = InternalSkip(offset);
  135. if (skip < 0)
  136. {
  137. return;
  138. }
  139. offset -= skip;
  140. }
  141. }
  142. /// <summary>
  143. /// 从文件系统流中读取一个字节。
  144. /// </summary>
  145. /// <returns>读取的字节,若已经到达文件结尾,则返回 -1。</returns>
  146. public override int ReadByte()
  147. {
  148. return InternalRead();
  149. }
  150. /// <summary>
  151. /// 从文件系统流中读取二进制流。
  152. /// </summary>
  153. /// <param name="buffer">存储读取文件内容的二进制流。</param>
  154. /// <param name="startIndex">存储读取文件内容的二进制流的起始位置。</param>
  155. /// <param name="length">存储读取文件内容的二进制流的长度。</param>
  156. /// <returns>实际读取了多少字节。</returns>
  157. public override int Read(byte[] buffer, int startIndex, int length)
  158. {
  159. byte[] result = null;
  160. int bytesRead = InternalRead(length, out result);
  161. Array.Copy(result, 0, buffer, startIndex, bytesRead);
  162. return bytesRead;
  163. }
  164. /// <summary>
  165. /// 向文件系统流中写入一个字节。
  166. /// </summary>
  167. /// <param name="value">要写入的字节。</param>
  168. public override void WriteByte(byte value)
  169. {
  170. throw new GameFrameworkException("WriteByte is not supported in AndroidFileSystemStream.");
  171. }
  172. /// <summary>
  173. /// 向文件系统流中写入二进制流。
  174. /// </summary>
  175. /// <param name="buffer">存储写入文件内容的二进制流。</param>
  176. /// <param name="startIndex">存储写入文件内容的二进制流的起始位置。</param>
  177. /// <param name="length">存储写入文件内容的二进制流的长度。</param>
  178. public override void Write(byte[] buffer, int startIndex, int length)
  179. {
  180. throw new GameFrameworkException("Write is not supported in AndroidFileSystemStream.");
  181. }
  182. /// <summary>
  183. /// 将文件系统流立刻更新到存储介质中。
  184. /// </summary>
  185. public override void Flush()
  186. {
  187. throw new GameFrameworkException("Flush is not supported in AndroidFileSystemStream.");
  188. }
  189. /// <summary>
  190. /// 关闭文件系统流。
  191. /// </summary>
  192. public override void Close()
  193. {
  194. InternalClose();
  195. m_FileStream.Dispose();
  196. }
  197. private AndroidJavaObject InternalOpen(string fileName)
  198. {
  199. return s_AssetManager.Call<AndroidJavaObject>("open", fileName);
  200. }
  201. private int InternalAvailable()
  202. {
  203. return m_FileStream.Call<int>("available");
  204. }
  205. private void InternalClose()
  206. {
  207. m_FileStream.Call("close");
  208. }
  209. private int InternalRead()
  210. {
  211. return m_FileStream.Call<int>("read");
  212. }
  213. private int InternalRead(int length, out byte[] result)
  214. {
  215. #if UNITY_2019_2_OR_NEWER
  216. #pragma warning disable CS0618
  217. #endif
  218. IntPtr resultPtr = AndroidJNI.NewByteArray(length);
  219. #if UNITY_2019_2_OR_NEWER
  220. #pragma warning restore CS0618
  221. #endif
  222. int offset = 0;
  223. int bytesLeft = length;
  224. while (bytesLeft > 0)
  225. {
  226. s_InternalReadArgs[0] = new jvalue() { l = resultPtr };
  227. s_InternalReadArgs[1] = new jvalue() { i = offset };
  228. s_InternalReadArgs[2] = new jvalue() { i = bytesLeft };
  229. int bytesRead = AndroidJNI.CallIntMethod(m_FileStreamRawObject, s_InternalReadMethodId, s_InternalReadArgs);
  230. if (bytesRead <= 0)
  231. {
  232. break;
  233. }
  234. offset += bytesRead;
  235. bytesLeft -= bytesRead;
  236. }
  237. #if UNITY_2019_2_OR_NEWER
  238. #pragma warning disable CS0618
  239. #endif
  240. result = AndroidJNI.FromByteArray(resultPtr);
  241. #if UNITY_2019_2_OR_NEWER
  242. #pragma warning restore CS0618
  243. #endif
  244. AndroidJNI.DeleteLocalRef(resultPtr);
  245. return offset;
  246. }
  247. private void InternalReset()
  248. {
  249. m_FileStream.Call("reset");
  250. }
  251. private long InternalSkip(long offset)
  252. {
  253. return m_FileStream.Call<long>("skip", offset);
  254. }
  255. }
  256. }