LibTVRefCommonPortable/Utils/FileSystemUtils.cs

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using LibTVRefCommonPortable.Stubs;
  18 using System;
  19 using System.IO;
  20 using Xamarin.Forms;
  21
  22 namespace LibTVRefCommonPortable.Utils
  23 {
  24     /// <summary>
  25     /// A class for file system control function.
  26     /// </summary>
  27     class FileSystemUtils
  28     {
  29         /// <summary>
  30         /// A instance of file system port layer
  31         /// </summary>
  32         private static IFileSystemAPIs fileSystemAPIs;
  33
  34         /// <summary>
  35         /// A instance of file system watcher port layer
  36         /// </summary>
  37         private static IFileSystemWatcherAPIs fileSystemWatcherAPIs;
  38
  39         /// <summary>
  40         /// A instance of FileSystemUtils
  41         /// </summary>
  42         private static readonly FileSystemUtils instance = new FileSystemUtils();
  43
  44         /// <summary>
  45         /// A property of FileSystemUtils instance
  46         /// </summary>
  47         public static FileSystemUtils Instance
  48         {
  49             get
  50             {
  51                 return instance;
  52             }
  53         }
  54
  55         /// <summary>
  56         /// A property of file system watcher instance
  57         /// </summary>
  58         public IFileSystemWatcherAPIs FileSysteamWatcherInstance
  59         {
  60             get
  61             {
  62                 return fileSystemWatcherAPIs;
  63             }
  64         }
  65
  66         /// <summary>
  67         /// A constructor
  68         /// </summary>
  69         private FileSystemUtils()
  70         {
  71             fileSystemAPIs = new FileSystemAPITestStub();
  72             fileSystemWatcherAPIs = new FileWatcherAPITestStub();
  73
  74             try
  75             {
  76                 if (DependencyService.Get<IFileSystemAPIs>() != null)
  77                 {
  78                     fileSystemAPIs = DependencyService.Get<IFileSystemAPIs>();
  79                 }
  80
  81                 if (DependencyService.Get<IFileSystemWatcherAPIs>() != null)
  82                 {
  83                     fileSystemWatcherAPIs = DependencyService.Get<IFileSystemWatcherAPIs>();
  84                 }
  85             }
  86             catch (InvalidOperationException e)
  87             {
  88                 DebuggingUtils.Err(e.Message);
  89             }
  90         }
  91
  92         /// <summary>
  93         /// A directory path which should be used for app data storing.
  94         /// </summary>
  95         public string AppDataStorage
  96         {
  97             get
  98             {
  99                 return fileSystemAPIs.AppDataStorage;
 100             }
 101         }
 102
 103         /// <summary>
 104         /// A directory path which should be used for app resource storing.
 105         /// </summary>
 106         public string AppResourceStorage
 107         {
 108             get
 109             {
 110                 return fileSystemAPIs.AppResourceStorage;
 111             }
 112         }
 113
 114         /// <summary>
 115         /// A directory path which should be used for sharing between apps.
 116         /// </summary>
 117         public string PlatformShareStorage
 118         {
 119             get
 120             {
 121                 return fileSystemAPIs.PlatformShareStorage;
 122             }
 123         }
 124
 125         /// <summary>
 126         /// A method opens a file on the given mode.
 127         /// </summary>
 128         /// <param name="filePath">A file path</param>
 129         /// <param name="mode">An opening mode</param>
 130         /// <returns>A file descriptor</returns>
 131         public Stream OpenFile(string filePath, UtilFileMode mode)
 132         {
 133             return fileSystemAPIs.OpenFile(filePath, mode);
 134         }
 135
 136         /// <summary>
 137         /// A method flushing the stream to write remains.
 138         /// </summary>
 139         /// <param name="stream">A file descriptor</param>
 140         public void Flush(Stream stream)
 141         {
 142             fileSystemAPIs.Flush(stream);
 143         }
 144
 145         /// <summary>
 146         /// A method closes the file.
 147         /// </summary>
 148         /// <param name="stream">A file descriptor</param>
 149         public void CloseFile(Stream stream)
 150         {
 151             fileSystemAPIs.CloseFile(stream);
 152         }
 153
 154         /// <summary>
 155         /// A method checks if a file existence in the file system.
 156         /// </summary>
 157         /// <param name="filePath">A file path</param>
 158         /// <returns>An existence of the file</returns>
 159         public bool IsFileExist(String filePath)
 160         {
 161             return fileSystemAPIs.IsFileExist(filePath);
 162         }
 163
 164         /// <summary>
 165         /// A method checks if file is read to use.
 166         /// </summary>
 167         /// <param name="filePath">A file path</param>
 168         /// <returns>A status of ready</returns>
 169         public bool IsFileReady(String filePath)
 170         {
 171             return fileSystemAPIs.IsFileReady(filePath);
 172         }
 173
 174
 175     }
 176 }