src/Tizen.System.Storage/Storage/StorageManager.cs

   1 /*
   2 * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (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://www.apache.org/licenses/LICENSE-2.0
   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 System;
  18 using System.Collections.Generic;
  19
  20 namespace Tizen.System
  21 {
  22     /// <summary>
  23     /// The StorageManager provides the properties or methods to access storage in the device.
  24     /// </summary>
  25     /// <since_tizen> 3 </since_tizen>
  26     public static class StorageManager
  27     {
  28         private const string LogTag = "Tizen.System";
  29
  30         /// <summary>
  31         /// List of all storage in the device.
  32         /// </summary>
  33         /// <since_tizen> 3 </since_tizen>
  34         public static IEnumerable<Storage> Storages
  35         {
  36             get
  37             {
  38                 List<Storage> storageList = new List<Storage>();
  39                 Interop.Storage.StorageDeviceSupportedCallback cb = (int storageID, Interop.Storage.StorageArea type, Interop.Storage.StorageState state, string rootDirectory, IntPtr userData) =>
  40                 {
  41                     storageList.Add(new Storage(storageID, type, state, rootDirectory));
  42                     return true;
  43                 };
  44
  45                 Interop.Storage.ErrorCode err = Interop.Storage.StorageManagerGetForeachDeviceSupported(cb, IntPtr.Zero);
  46                 if (err != Interop.Storage.ErrorCode.None)
  47                 {
  48                     Log.Warn(LogTag, string.Format("Failed to get storage list. err = {0}", err));
  49                 }
  50                 return storageList;
  51             }
  52         }
  53
  54         private static EventHandler s_ExternalStorageChangedEventHandler;
  55         private static EventHandler s_ExtendedInternalStorageChangedEventHandler;
  56         private static Interop.Storage.StorageChangedCallback s_ChangedEventCallback = (int id, Interop.Storage.StorageDevice devicetype, Interop.Storage.StorageState state, string fstype, string fsuuid, string rootDirectory, bool primary, int flags, IntPtr userData) =>
  57         {
  58             Storage storage = new Storage(id, Interop.Storage.StorageArea.External, state, rootDirectory, devicetype, fstype, fsuuid, primary, flags);
  59
  60             if (devicetype == Interop.Storage.StorageDevice.ExtendedInternalStorage)
  61                 s_ExtendedInternalStorageChangedEventHandler?.Invoke(storage, EventArgs.Empty);
  62             else
  63                 s_ExternalStorageChangedEventHandler?.Invoke(storage, EventArgs.Empty);
  64         };
  65
  66         private static void RegisterChangedEvent(StorageArea type)
  67         {
  68             Interop.Storage.ErrorCode err = Interop.Storage.StorageSetChanged((int)type, s_ChangedEventCallback, IntPtr.Zero);
  69             if (err != Interop.Storage.ErrorCode.None)
  70             {
  71                 Log.Warn(LogTag, string.Format("Failed to Register changed event callback for external storage. err = {0}", err));
  72
  73                 switch (err)
  74                 {
  75                     case Interop.Storage.ErrorCode.NotSupported:
  76                         throw new NotSupportedException("Storage Not Supported");
  77                     default:
  78                         break;
  79                 }
  80             }
  81
  82         }
  83
  84         private static void UnregisterChangedEvent(StorageArea type)
  85         {
  86             Interop.Storage.ErrorCode err = Interop.Storage.StorageUnsetChanged((int)type, s_ChangedEventCallback);
  87             if (err != Interop.Storage.ErrorCode.None)
  88             {
  89                 Log.Warn(LogTag, string.Format("Failed to Unreegister changed event callback for external storage. err = {0}", err));
  90
  91                 switch (err)
  92                 {
  93                     case Interop.Storage.ErrorCode.NotSupported:
  94                         throw new NotSupportedException("Storage Not Supported");
  95                     default:
  96                         break;
  97                 }
  98             }
  99         }
 100
 101         /// <summary>
 102         /// Registers an eventhandler for state changes of specific storage type.
 103         /// </summary>
 104         /// <param name="type">The type of the storage.</param>
 105         /// <param name="handler">An eventhandler to register.</param>
 106         /// <since_tizen> 5 </since_tizen>
 107         /// <feature> http://tizen.org/feature/storage.external </feature>
 108         /// <exception cref="NotSupportedException">Thrown when the storage is not supported.</exception>
 109         public static void SetChangedEvent(StorageArea type, EventHandler handler)
 110         {
 111             if (type == StorageArea.Internal)
 112             {
 113                 Log.Warn(LogTag, "Internal storage state is not changed");
 114             }
 115             if (s_ExternalStorageChangedEventHandler == null && s_ExtendedInternalStorageChangedEventHandler == null)
 116             {
 117                 RegisterChangedEvent(type);
 118             }
 119             if ((type == StorageArea.External && s_ExternalStorageChangedEventHandler == null) ||
 120                 (type == StorageArea.ExtendedInternal && s_ExtendedInternalStorageChangedEventHandler == null))
 121             {
 122                 RegisterChangedEvent(type);
 123             }
 124             if (type == StorageArea.External)
 125                 s_ExternalStorageChangedEventHandler += handler;
 126             else if (type == StorageArea.ExtendedInternal)
 127                 s_ExtendedInternalStorageChangedEventHandler += handler;
 128         }
 129
 130         /// <summary>
 131         /// Unregisters an eventhandler for state changes of specific storage type.
 132         /// </summary>
 133         /// <param name="type">The type of the storage.</param>
 134         /// <param name="handler">An eventhandler to unregister.</param>
 135         /// <since_tizen> 5 </since_tizen>
 136         /// <feature> http://tizen.org/feature/storage.external </feature>
 137         /// <exception cref="NotSupportedException">Thrown when the storage is not supported.</exception>
 138         public static void UnsetChangedEvent(StorageArea type, EventHandler handler)
 139         {
 140             if (type == StorageArea.Internal)
 141             {
 142                 Log.Warn(LogTag, "Internal storage state is not changed");
 143             }
 144             if (type == StorageArea.External)
 145                 s_ExternalStorageChangedEventHandler -= handler;
 146             else if (type == StorageArea.ExtendedInternal)
 147                 s_ExtendedInternalStorageChangedEventHandler -= handler;
 148             if ((type == StorageArea.External && s_ExternalStorageChangedEventHandler == null) ||
 149                 (type == StorageArea.ExtendedInternal && s_ExtendedInternalStorageChangedEventHandler == null))
 150             {
 151                 UnregisterChangedEvent(type);
 152             }
 153         }
 154     }
 155 }