public static IEnumerator CopyFile(TimiSharedURI sourceFileURI, TimiSharedURI destinationDirectoryURI)
{
if (destinationDirectoryURI.BasePathType == FileBasePathType.LocalDataPath ||
destinationDirectoryURI.BasePathType == FileBasePathType.LocalPersistentDataPath ||
(destinationDirectoryURI.BasePathType == FileBasePathType.LocalStreamingAssetsPath && Application.isEditor))
{
FileLoadRequest fileLoadRequest = FileLoader.GetFileStreamAsync(sourceFileURI, FileMode.Open, FileAccess.Read);
if (fileLoadRequest != null)
{
fileLoadRequest.StartRequest();
yield return(fileLoadRequest);
string contents = FileUtils.GetStreamContents(fileLoadRequest.LoadedFileStream);
TimiSharedURI destinationFileURI = new TimiSharedURI(destinationDirectoryURI.BasePathType,
Path.Combine(destinationDirectoryURI.RelativePath, sourceFileURI.FileName));
using (Stream destinationFileStream = FileLoader.GetFileStreamSync(destinationFileURI, FileMode.Create, FileAccess.Write)) {
if (destinationFileStream != null)
{
FileUtils.PutStreamContents(destinationFileStream, contents);
}
destinationFileStream.Close();
}
}
yield break;
}
else
{
string errorMessage = "Not supported to write on base path type: " + destinationDirectoryURI.BasePathType;
DebugLog.LogErrorColor(errorMessage, LogColor.grey);
throw new NotImplementedException(errorMessage);
}
}
public static void WriteFile(TimiSharedURI fileURI, string contents)
{
using (Stream fileStream = FileLoader.GetFileStreamSync(fileURI, FileMode.Create, FileAccess.ReadWrite)) {
using (StreamWriter streamWriter = new StreamWriter(fileStream)) {
streamWriter.Write(contents);
fileStream.Flush();
streamWriter.Flush();
}
}
}
// Reads a CSV that is formatted as comma separated values per line
// The first line must contain the legend
public static CSVResult ReadCSVFile(TimiSharedURI fileURI)
{
CSVResult result = null;
using (Stream fileStream = FileLoader.GetFileStreamSync(fileURI, FileMode.Open, FileAccess.Read)) {
if (fileStream == null)
{
return(null);
}
StreamReader streamReader = new StreamReader(fileStream);
if (streamReader.Peek() < 0)
{
DebugLog.LogErrorColor("Empty file", LogColor.grey);
return(null);
}
result = new CSVResult();
// Read the legend from the first line
string legendLine = streamReader.ReadLine();
string[] legend = legendLine.Split(',');
for (int i = 0; i < legend.Length; ++i)
{
result.keysPerItem.Add(legend[i]);
}
int lineNumber = 0;
while (streamReader.Peek() >= 0)
{
++lineNumber;
string line = streamReader.ReadLine();
string[] words = line.Split(',');
if (result.keysPerItem.Count != words.Length)
{
DebugLog.LogWarningColor("Malformed item on line number: " + lineNumber, LogColor.grey);
continue;
}
CSVItem item = new CSVItem();
for (int i = 0; i < result.keysPerItem.Count; ++i)
{
item.values[result.keysPerItem[i]] = words[i];
}
result.items.Add(item);
}
fileStream.Close();
}
return(result);
}
public static List <TimiSharedURI> GetDirectoriesInDirectory(TimiSharedURI directoryUri)
{
string[] directoryPathNames = Directory.GetDirectories(directoryUri.GetFullPath());
List <TimiSharedURI> directoryURIs = new List <TimiSharedURI>();
for (int i = 0; i < directoryPathNames.Length; ++i)
{
string directoryName = Path.GetFileName(directoryPathNames[i]);
directoryURIs.Add(new TimiSharedURI(directoryUri.BasePathType, Path.Combine(directoryUri.RelativePath, directoryName)));
}
return(directoryURIs);
}
public static void CreateDirectory(TimiSharedURI uri)
{
if (uri.BasePathType == FileBasePathType.LocalDataPath ||
uri.BasePathType == FileBasePathType.LocalPersistentDataPath ||
(uri.BasePathType == FileBasePathType.LocalStreamingAssetsPath && Application.isEditor))
{
Directory.CreateDirectory(uri.GetFullPath());
}
else
{
string errorMessage = "Not supported to create directory on base path type: " + uri.BasePathType;
DebugLog.LogErrorColor(errorMessage, LogColor.grey);
throw new NotImplementedException(errorMessage);
}
}
public static bool DoesDirectoryExist(TimiSharedURI uri)
{
if (uri.BasePathType == FileBasePathType.LocalDataPath ||
uri.BasePathType == FileBasePathType.LocalPersistentDataPath ||
uri.BasePathType == FileBasePathType.LocalStreamingAssetsPath)
{
return(Directory.Exists(uri.GetFullPath()));
}
else
{
string errorMessage = "Not supported to check directory exists on base path type: " + uri.BasePathType;
DebugLog.LogErrorColor(errorMessage, LogColor.grey);
throw new NotImplementedException(errorMessage);
}
}
private IEnumerator CopyFirstLaunchTextAssets()
{
FileUtils.CreateDirectory(this.FirstLaunchDestinationURI);
var enumerator = this._bootstrapTextAssetInfos.GetEnumerator();
while (enumerator.MoveNext())
{
TextAsset textAsset = enumerator.Current.textAsset;
TimiSharedURI destinationURI = TimiSharedURI.Combine(this.FirstLaunchDestinationURI, new TimiSharedURI(FileBasePathType.LocalPersistentDataPath, enumerator.Current.fileName));
FileUtils.WriteFile(destinationURI, textAsset.text);
}
enumerator.Dispose();
yield break;
}
public static void SaveAppConfigData(AppConfigData appConfigData)
{
if (!Application.isEditor)
{
throw new NotImplementedException("Not yet supported to edit app config on device");
}
string appConfigDataJson = TimiSharedSerializer.Serialize(appConfigData);
if (!string.IsNullOrEmpty(appConfigDataJson))
{
TimiSharedURI appConfigFileUri = AppConfigHelper.AppConfigFileURI;
using (Stream appConfigFileStream = FileLoader.GetFileStreamSync(appConfigFileUri, FileMode.Create, FileAccess.Write)) {
FileUtils.PutStreamContents(appConfigFileStream, appConfigDataJson);
appConfigFileStream.Close();
}
}
}
public static List <TimiSharedURI> GetFilesInDirectory(TimiSharedURI directoryUri)
{
string[] filePathNames = Directory.GetFiles(directoryUri.GetFullPath());
List <TimiSharedURI> fileURIs = new List <TimiSharedURI>();
for (int i = 0; i < filePathNames.Length; ++i)
{
string fileName = Path.GetFileName(filePathNames[i]);
string extension = Path.GetExtension(fileName);
if (extension == ".meta" || extension == ".DS_Store")
{
// Skip Unity meta files and mac DS_Store files
continue;
}
fileURIs.Add(new TimiSharedURI(directoryUri.BasePathType, Path.Combine(directoryUri.RelativePath, fileName)));
}
return(fileURIs);
}
public static IEnumerator CopyDirectoryContents(TimiSharedURI sourceDirectory, TimiSharedURI destinationDirectory)
{
if (destinationDirectory.BasePathType == FileBasePathType.LocalDataPath ||
destinationDirectory.BasePathType == FileBasePathType.LocalPersistentDataPath ||
(destinationDirectory.BasePathType == FileBasePathType.LocalStreamingAssetsPath && Application.isEditor))
{
if (!FileUtils.DoesDirectoryExist(sourceDirectory))
{
DebugLog.LogWarningColor("Source directory does not exist: " + sourceDirectory.GetFullPath(), LogColor.grey);
yield break;
}
if (!FileUtils.DoesDirectoryExist(destinationDirectory))
{
FileUtils.CreateDirectory(destinationDirectory);
}
List <TimiSharedURI> fileURIs = FileUtils.GetFilesInDirectory(sourceDirectory);
List <TimiSharedURI> directoryURIs = FileUtils.GetDirectoriesInDirectory(sourceDirectory);
for (int i = 0; i < fileURIs.Count; ++i)
{
// TODO: Make this parallel for all the files
yield return(FileUtils.CopyFile(fileURIs[i], destinationDirectory));
}
for (int i = 0; i < directoryURIs.Count; ++i)
{
TimiSharedURI destination = new TimiSharedURI(destinationDirectory.BasePathType,
Path.Combine(destinationDirectory.RelativePath, directoryURIs[i].FileName));
// TODO: Make this parallel for all the files
yield return(FileUtils.CopyDirectoryContents(directoryURIs[i], destination));
}
yield break;
}
else
{
string errorMessage = "Not supported to write on base path type: " + destinationDirectory.BasePathType;
DebugLog.LogErrorColor(errorMessage, LogColor.grey);
throw new NotImplementedException(errorMessage);
}
}
