7dbe95b7d2c976c6834bcdfe0a53c95ac3dc3c94
[platform/core/csapi/tizenfx.git] / src / Tizen.Location.Geofence / Tizen.Location.Geofence / Fence.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
19 namespace Tizen.Location.Geofence
20 {
21     /// <summary>
22     /// Geofence defines a virtual perimeter for a real-world geographic area.
23     /// If you create a geofence, you can trigger some activities when a device enters (or exits) the geofences defined by you.
24     /// You can create a geofence with the information of the Geopoint, Wi-Fi, or BT.
25     /// <list>
26     /// <item>Geopoint: Geofence is specified by the coordinates (Latitude and Longitude) and radius.</item>
27     /// <item>WIFI: Geofence is specified by the BSSID of the Wi-Fi access point.</item>
28     /// <item>BT: Geofence is specified by the Bluetooth address.</item>
29     /// </list>
30     /// The Basic service set identifier (BSSID) is the MAC address of the wireless access point (WAP) generated by combining the 24-bit Organization Unique Identifier (the manufacturer's identity)
31     /// and the manufacturer's assigned 24-bit identifier for the radio chipset in the WAP.
32     /// </summary>
33     /// <since_tizen> 3 </since_tizen>
34     public class Fence : IDisposable
35     {
36         private bool _disposed = false;
37
38         internal IntPtr Handle
39         {
40             get;
41             set;
42         }
43
44         internal Fence(IntPtr handle)
45         {
46             Handle = handle;
47         }
48
49         ~Fence()
50         {
51             Dispose(false);
52         }
53
54         /// <summary>
55         /// Gets the type of geofence.
56         /// </summary>
57         /// <since_tizen> 3 </since_tizen>
58         public FenceType Type
59         {
60             get
61             {
62                 FenceType val;
63                 GeofenceError ret = (GeofenceError)Interop.Geofence.FenceType(Handle, out val);
64                 if (ret != GeofenceError.None)
65                 {
66                     Tizen.Log.Error(GeofenceErrorFactory.LogTag, "Failed to get GeofenceType");
67                 }
68
69                 return val;
70             }
71         }
72
73         /// <summary>
74         /// Gets the ID of the place.
75         /// </summary>
76         /// <since_tizen> 3 </since_tizen>
77         public int PlaceId
78         {
79             get
80             {
81                 int result = -1;
82                 GeofenceError ret = (GeofenceError)Interop.Geofence.FencePlaceID(Handle, out result);
83                 if (ret != GeofenceError.None)
84                 {
85                     Tizen.Log.Error(GeofenceErrorFactory.LogTag, "Failed to get PlaceId");
86                 }
87
88                 return result;
89             }
90         }
91
92         /// <summary>
93         /// Gets the longitude of geofence.
94         /// </summary>
95         /// <since_tizen> 3 </since_tizen>
96         public double Longitude
97         {
98             get
99             {
100                 double result = -1;
101                 GeofenceError ret = (GeofenceError)Interop.Geofence.FenceLongitude(Handle, out result);
102                 if (ret != GeofenceError.None)
103                 {
104                     Tizen.Log.Error(GeofenceErrorFactory.LogTag, "Failed to get Longitude");
105                 }
106
107                 return result;
108
109             }
110         }
111
112         /// <summary>
113         /// Gets the latitude of geofence.
114         /// </summary>
115         /// <since_tizen> 3 </since_tizen>
116         public double Latitude
117         {
118             get
119             {
120                 double result = -1;
121                 GeofenceError ret = (GeofenceError)Interop.Geofence.FenceLatitude(Handle, out result);
122                 if (ret != GeofenceError.None)
123                 {
124                     Tizen.Log.Error(GeofenceErrorFactory.LogTag, "Failed to get Latitude");
125                 }
126
127                 return result;
128             }
129         }
130
131         /// <summary>
132         /// Gets the radius of geofence.
133         /// </summary>
134         /// <since_tizen> 3 </since_tizen>
135         public int Radius
136         {
137             get
138             {
139                 int result = -1;
140                 GeofenceError ret = (GeofenceError)Interop.Geofence.FenceRadius(Handle, out result);
141                 if (ret != GeofenceError.None)
142                 {
143                     Tizen.Log.Error(GeofenceErrorFactory.LogTag, "Failed to get Radius");
144                 }
145
146                 return result;
147             }
148         }
149
150         /// <summary>
151         /// Gets the address of geofence.
152         /// </summary>
153         /// <since_tizen> 3 </since_tizen>
154         public string Address
155         {
156             get
157             {
158                 string result = "";
159                 GeofenceError ret = (GeofenceError)Interop.Geofence.FenceAddress(Handle, out result);
160                 if (ret != GeofenceError.None)
161                 {
162                     Tizen.Log.Error(GeofenceErrorFactory.LogTag, "Failed to get Adress");
163                 }
164
165                 return result;
166             }
167         }
168
169         /// <summary>
170         /// Gets the BSSID of geofence.
171         /// </summary>
172         /// <since_tizen> 3 </since_tizen>
173         public string Bssid
174         {
175             get
176             {
177                 string result = "";
178                 GeofenceError ret = (GeofenceError)Interop.Geofence.FenceBSSID(Handle, out result);
179                 if (ret != GeofenceError.None)
180                 {
181                     Tizen.Log.Error(GeofenceErrorFactory.LogTag, "Failed to get Bssid");
182                 }
183
184                 return result;
185             }
186         }
187
188         /// <summary>
189         /// Gets the SSID of geofence.
190         /// </summary>
191         /// <since_tizen> 3 </since_tizen>
192         public string Ssid
193         {
194             get
195             {
196                 string result = "";
197                 GeofenceError ret = (GeofenceError)Interop.Geofence.FenceSSID(Handle, out result);
198                 if (ret != GeofenceError.None)
199                 {
200                     Tizen.Log.Error(GeofenceErrorFactory.LogTag, "Failed to get Ssid");
201                 }
202
203                 return result;
204             }
205         }
206
207         /// <summary>
208         /// Creates a geopoint type of the new geofence.
209         /// </summary>
210         /// <since_tizen> 3 </since_tizen>
211         /// <param name="placeId">The current place ID.</param>
212         /// <param name="latitude">Specifies the value of latitude of the geofence [-90.0 ~ 90.0] (degrees).</param>
213         /// <param name="longitude">Specifies the value of longitude of the geofence [-180.0 ~ 180.0] (degrees).</param>
214         /// <param name="radius">Specifies the value of radius of the geofence [100 ~ 500](meter).</param>
215         /// <param name="address">Specifies the value of the address.</param>
216         /// <returns>The newly created geofence instance.</returns>
217         /// <exception cref="ArgumentException">In case of an invalid parameter.</exception>
218         /// <exception cref="InvalidOperationException">In case of any system error.</exception>
219         /// <exception cref="NotSupportedException">In case the geofence is not supported.</exception>
220         public static Fence CreateGPSFence(int placeId, int latitude, int longitude, int radius, string address)
221         {
222             IntPtr handle = IntPtr.Zero;
223             GeofenceError ret = (GeofenceError)Interop.Geofence.CreateGPSFence(placeId, latitude, longitude, radius,address, out handle);
224             if (ret != GeofenceError.None)
225             {
226                 throw GeofenceErrorFactory.CreateException(ret, "Failed to create Geofence from GPS Data for " + placeId);
227             }
228
229             return new Fence(handle);
230         }
231
232         /// <summary>
233         /// Creates a Wi-Fi type of the new geofence.
234         /// </summary>
235         /// <since_tizen> 3 </since_tizen>
236         /// <param name="placeId">The current place ID.</param>
237         /// <param name="bssid">Specifies the value of BSSID of the Wi-Fi MAC address.</param>
238         /// <param name="ssid"> Specifies the value of SSID of the Wi-Fi device.</param>
239         /// <returns>The newly created geofence instance.</returns>
240         /// <exception cref="ArgumentException">In case of an invalid parameter.</exception>
241         /// <exception cref="InvalidOperationException">In case of any system error.</exception>
242         /// <exception cref="NotSupportedException">In case the geofence is not supported.</exception>
243         public static Fence CreateWifiFence(int placeId, string bssid, string ssid)
244         {
245             IntPtr handle = IntPtr.Zero;
246             GeofenceError ret = (GeofenceError)Interop.Geofence.CreateWiFiFence(placeId, bssid, ssid, out handle);
247             if (ret != GeofenceError.None)
248             {
249                 throw GeofenceErrorFactory.CreateException(ret, "Failed to create Geofence from Wifi Data for " + placeId);
250             }
251
252             return new Fence(handle);
253         }
254
255         /// <summary>
256         /// Creates a Bluetooth type of the new geofence.
257         /// </summary>
258         /// <since_tizen> 3 </since_tizen>
259         /// <param name="placeId">The current place ID.</param>
260         /// <param name="bssid">Specifies the value of BSSID of BT MAC address.</param>
261         /// <param name="ssid"> Specifies the value of SSID of BT Device.</param>
262         /// <returns>The newly created geofence instance.</returns>
263         /// <exception cref="ArgumentException">In case of an invalid parameter.</exception>
264         /// <exception cref="InvalidOperationException">In case of any system error.</exception>
265         /// <exception cref="NotSupportedException">In case the geofence is not supported.</exception>
266         public static Fence CreateBTFence(int placeId, string bssid, string ssid)
267         {
268             IntPtr handle = IntPtr.Zero;
269             GeofenceError ret = (GeofenceError)Interop.Geofence.CreateBTFence(placeId, bssid, ssid, out handle);
270             if (ret != GeofenceError.None)
271             {
272                 throw GeofenceErrorFactory.CreateException(ret, "Failed to create Geofence from Bluetooth Data for " + placeId);
273             }
274
275             return new Fence(handle);
276         }
277
278         /// <summary>
279         /// The overloaded Dispose API for destroying the fence handle.
280         /// </summary>
281         /// <since_tizen> 3 </since_tizen>
282         public void Dispose()
283         {
284             Dispose(true);
285             GC.SuppressFinalize(this);
286         }
287
288         private void Dispose(bool disposing)
289         {
290             if (_disposed)
291                 return;
292
293             if (Handle != IntPtr.Zero)
294             {
295                 Interop.Geofence.Destroy(Handle);
296                 Handle = IntPtr.Zero;
297             }
298
299             _disposed = true;
300         }
301     }
302 }