2 * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 namespace Tizen.System
22 /// Enumeration for the battery levels.
24 /// <since_tizen> 3 </since_tizen>
25 public enum BatteryLevelStatus
28 /// The battery goes empty.
29 /// Prepare for the safe termination of the application,
30 /// because the device starts a shutdown process soon
31 /// after entering this level.
33 /// <since_tizen> 3 </since_tizen>
36 /// The battery charge is at a critical state.
37 /// You may have to stop using the multimedia features,
38 /// because they are not guaranteed to work correctly
39 /// with this battery status.
41 /// <since_tizen> 3 </since_tizen>
44 /// The battery has little charge left.
46 /// <since_tizen> 3 </since_tizen>
49 /// The battery status is not to be careful.
51 /// <since_tizen> 3 </since_tizen>
54 /// The battery status is full.
56 /// <since_tizen> 3 </since_tizen>
61 /// The Battery class provides the properties and events for the device battery.
64 /// The Battery API provides the way to get the current battery capacity value (Percent),
65 /// the battery state, and the charging state. It also provides the events for an application
66 /// to receive the battery status change events from the device.
67 /// To receive the battery event, the application should register with the respective EventHandler.
70 /// Console.WriteLine("battery Charging state is: {0}", Tizen.System.Battery.IsCharging);
71 /// Console.WriteLine("battery Percent is: {0}", Tizen.System.Battery.Percent);
73 public static class Battery
75 private static readonly object s_lock = new object();
77 /// Gets the battery charge percentage.
79 /// <since_tizen> 3 </since_tizen>
80 /// <value>It returns an integer value from 0 to 100 that indicates the remaining
81 /// battery charge as a percentage of the maximum level.</value>
82 public static int Percent
87 DeviceError res = (DeviceError)Interop.Device.DeviceBatteryGetPercent(out percent);
88 if (res != DeviceError.None)
90 Log.Warn(DeviceExceptionFactory.LogTag, "unable to get battery percentage.");
96 /// Gets the current battery level.
98 /// <since_tizen> 3 </since_tizen>
99 public static BatteryLevelStatus Level
104 DeviceError res = (DeviceError)Interop.Device.DeviceBatteryGetLevelStatus(out level);
105 if (res != DeviceError.None)
107 Log.Warn(DeviceExceptionFactory.LogTag, "unable to get battery status.");
109 return (BatteryLevelStatus)level;
113 /// Gets the current charging state.
115 /// <since_tizen> 3 </since_tizen>
116 public static bool IsCharging
121 DeviceError res = (DeviceError)Interop.Device.DeviceBatteryIsCharging(out charging);
122 if (res != DeviceError.None)
124 Log.Warn(DeviceExceptionFactory.LogTag, "unable to get battery charging state.");
130 private static EventHandler<BatteryPercentChangedEventArgs> s_capacityChanged;
132 /// CapacityChanged is triggered when the battery charge percentage is changed.
134 /// <since_tizen> 3 </since_tizen>
135 /// <param name="sender"></param>
136 /// <param name="e">BatteryCapacityChangedEventArgs is an object that contains the changed battery capacity (Percent).</param>
138 /// public static async Task BatteryEventHandler()
140 /// EventHandler<BatteryPercentChangedEventArgs> handler = null;
141 /// handler = (object sender, BatteryChargingStateChangedEventArgs args) =>
143 /// Console.WriteLine("battery Percent is: {0}", args.Percent);
145 /// Battery.PercentChanged += handler;
146 /// await Task.Delay(20000);
149 public static event EventHandler<BatteryPercentChangedEventArgs> PercentChanged
155 if (s_capacityChanged == null)
157 EventListenerStart(EventType.BatteryPercent);
159 s_capacityChanged += value;
166 s_capacityChanged -= value;
167 if (s_capacityChanged == null)
169 EventListenerStop(EventType.BatteryPercent);
175 private static event EventHandler<BatteryLevelChangedEventArgs> s_levelChanged;
178 /// LevelChanged is triggered when the battery level is changed.
180 /// <since_tizen> 3 </since_tizen>
181 /// <param name="sender"></param>
182 /// <param name="e">BatteryLevelChangedEventArgs is an object that contains the changed battery level.</param>
184 /// public static async Task BatteryEventHandler()
186 /// EventHandler<BatteryLevelChangedEventArgs> handler = null;
187 /// handler = (object sender, BatteryLevelChangedEventArgs args) =>
189 /// Console.WriteLine("battery Level is: {0}", args.Level);
191 /// Battery.LevelChanged += handler;
192 /// await Task.Delay(20000);
195 public static event EventHandler<BatteryLevelChangedEventArgs> LevelChanged
201 if (s_levelChanged == null)
203 EventListenerStart(EventType.BatteryLevel);
205 s_levelChanged += value;
212 s_levelChanged -= value;
213 if (s_levelChanged == null)
215 EventListenerStop(EventType.BatteryLevel);
221 private static event EventHandler<BatteryChargingStateChangedEventArgs> s_chargingStateChanged;
223 /// ChargingStatusChanged is triggered when the battery charging status is changed.
224 /// This event is triggered when the charger is connected/disconnected.
226 /// <since_tizen> 3 </since_tizen>
227 /// <param name="sender"></param>
228 /// <param name="e">BatteryChargingStateChangedEventArgs is an object that contains the changed battery charging state.</param>
230 /// public static async Task BatteryEventHandler()
232 /// EventHandler<BatteryChargingStateChangedEventArgs> handler = null;
233 /// handler = (object sender, BatteryChargingStateChangedEventArgs args) =>
235 /// Console.WriteLine("battery Level is: {0}", args.IsCharging);
237 /// Battery.ChargingStateChanged += handler;
238 /// await Task.Delay(20000);
241 public static event EventHandler<BatteryChargingStateChangedEventArgs> ChargingStateChanged
247 if (s_chargingStateChanged == null)
249 EventListenerStart(EventType.BatteryCharging);
251 s_chargingStateChanged += value;
258 s_chargingStateChanged -= value;
259 if (s_chargingStateChanged == null)
261 EventListenerStop(EventType.BatteryCharging);
267 private static Interop.Device.deviceCallback s_cpacityHandler;
268 private static Interop.Device.deviceCallback s_levelHandler;
269 private static Interop.Device.deviceCallback s_chargingHandler;
271 private static void EventListenerStart(EventType eventType)
275 case EventType.BatteryPercent:
276 s_cpacityHandler = (int type, IntPtr value, IntPtr data) =>
278 int val = value.ToInt32();
279 BatteryPercentChangedEventArgs e = new BatteryPercentChangedEventArgs()
283 s_capacityChanged?.Invoke(null, e);
287 Interop.Device.DeviceAddCallback(eventType, s_cpacityHandler, IntPtr.Zero);
290 case EventType.BatteryLevel:
291 s_levelHandler = (int type, IntPtr value, IntPtr data) =>
293 int val = value.ToInt32();
294 BatteryLevelChangedEventArgs e = new BatteryLevelChangedEventArgs()
296 Level = (BatteryLevelStatus)val
298 s_levelChanged?.Invoke(null, e);
302 Interop.Device.DeviceAddCallback(eventType, s_levelHandler, IntPtr.Zero);
305 case EventType.BatteryCharging:
306 s_chargingHandler = (int type, IntPtr value, IntPtr data) =>
308 bool val = (value.ToInt32() == 1);
309 BatteryChargingStateChangedEventArgs e = new BatteryChargingStateChangedEventArgs()
313 s_chargingStateChanged?.Invoke(null, e);
316 Interop.Device.DeviceAddCallback(eventType, s_chargingHandler, IntPtr.Zero);
321 private static void EventListenerStop(EventType eventType)
325 case EventType.BatteryPercent:
326 Interop.Device.DeviceRemoveCallback(eventType, s_cpacityHandler);
329 case EventType.BatteryLevel:
330 Interop.Device.DeviceRemoveCallback(eventType, s_levelHandler);
333 case EventType.BatteryCharging:
334 Interop.Device.DeviceRemoveCallback(eventType, s_chargingHandler);