3034d6c43e41aad9e6d030871e6e5b5c7de3563e
[platform/core/csapi/tizenfx.git] / src / Tizen.Network.Bluetooth / Tizen.Network.Bluetooth / BluetoothLeAdapter.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.Threading.Tasks;
19 using System.Collections.Generic;
20 using System.Collections.Specialized;
21 using System.Runtime.InteropServices;
22
23 namespace Tizen.Network.Bluetooth {
24
25     /// <summary>
26     /// This is the BluetoothLeAdvertiser class. It handles the LE advertising operation amd callback.
27     /// </summary>
28     public class BluetoothLeAdvertiser
29     {
30         private static readonly BluetoothLeAdvertiser _instance = new BluetoothLeAdvertiser();
31
32         internal static BluetoothLeAdvertiser Instance
33         {
34             get
35             {
36                 return _instance;
37             }
38         }
39
40         private BluetoothLeAdvertiser()
41         {
42         }
43
44         /// <summary>
45         /// This event is called when the LE advertising state changes.
46         /// </summary>
47         public event EventHandler<AdvertisingStateChangedEventArgs> AdvertisingStateChanged
48         {
49             add
50             {
51                 BluetoothLeImplAdapter.Instance.AdapterLeAdvertisingStateChanged += value;
52             }
53             remove
54             {
55                 BluetoothLeImplAdapter.Instance.AdapterLeAdvertisingStateChanged -= value;
56             }
57         }
58         /// <summary>
59         /// Starts advertising using the advertise data object.
60         /// </summary>
61         /// <remarks>
62         /// The Bluetooth must be enabled.
63         /// </remarks>
64         /// <param name="advertiseData">The advertiser object carrying information of the advertising.</param>
65         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
66         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled.</exception>
67         public void StartAdvertising(BluetoothLeAdvertiseData advertiseData)
68         {
69             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
70             {
71                 int ret = BluetoothLeImplAdapter.Instance.StartAdvertising (advertiseData.GetHandle ());
72                 if (ret != (int)BluetoothError.None) {
73                     Log.Error (Globals.LogTag, "Failed to start advertising- " + (BluetoothError)ret);
74                     BluetoothErrorFactory.ThrowBluetoothException(ret);
75                 }
76             }
77             else
78             {
79                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
80             }
81         }
82
83         /// <summary>
84         /// Stops the advertising.
85         /// </summary>
86         /// <remarks>
87         /// The Bluetooth must be enabled.
88         /// </remarks>
89         /// <param name="advertiseData">The advertiser object carrying information of the advertising.</param>
90         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
91         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled.</exception>
92         public void StopAdvertising(BluetoothLeAdvertiseData advertiseData)
93         {
94             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
95             {
96                 int ret = BluetoothLeImplAdapter.Instance.StopAdvertising (advertiseData.GetHandle ());
97                 if (ret != (int)BluetoothError.None) {
98                     Log.Error (Globals.LogTag, "Failed to stop advertising operation- " + (BluetoothError)ret);
99                     BluetoothErrorFactory.ThrowBluetoothException(ret);
100                 }
101             }
102             else
103             {
104                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
105             }
106         }
107     }
108
109     /// <summary>
110     /// This is the BluetoothLeDevice class.
111     /// It handles the LE device operations like getting data from the scan result information.
112     /// </summary>
113     public class BluetoothLeDevice
114     {
115         //properties of Bluetoothlesacandata
116         private string _remoteAddress;
117         private BluetoothLeDeviceAddressType _addressType;
118         private int _rssi;
119         private byte[] _advDataValue;
120         private byte[] _scanDataValue;
121         private BluetoothLePacketType _packetType;
122         private BluetoothLeScanData _scanData;
123
124         /// <summary>
125         /// This event is called when the GATT client connects/disconnects with the server.
126         /// </summary>
127         public event EventHandler<GattConnectionStateChangedEventArgs> GattConnectionStateChanged
128         {
129             add
130             {
131                 BluetoothLeImplAdapter.Instance.LeGattConnectionStateChanged += value;
132             }
133             remove
134             {
135                 BluetoothLeImplAdapter.Instance.LeGattConnectionStateChanged -= value;
136             }
137         }
138
139         internal BluetoothLeDevice(BluetoothLeScanData scanData)
140         {
141             _scanData = new BluetoothLeScanData ();
142             _scanData = scanData;
143
144             Log.Info (Globals.LogTag, "Rssi" + _scanData.Rssi);
145             _rssi = scanData.Rssi;
146             Log.Info (Globals.LogTag, "RemoteAddress" + _scanData.RemoteAddress);
147             if (scanData.RemoteAddress != null)
148                 _remoteAddress = scanData.RemoteAddress;
149             Log.Info (Globals.LogTag, "AddressType" + _scanData.AddressType);
150             _addressType = scanData.AddressType;
151
152             Log.Info (Globals.LogTag, "AdvDataLength" + _scanData.AdvDataLength);
153             if (_scanData.AdvDataLength > 0)
154             {
155                 _advDataValue = new byte[_scanData.AdvDataLength];
156                 scanData.AdvData.CopyTo(_advDataValue, 0);
157             }
158
159             Log.Info(Globals.LogTag, "ScanDataLength" + _scanData.ScanDataLength);
160             //  Check length before copying
161             if (_scanData.ScanDataLength > 0)
162             {
163                 _scanDataValue = new byte[_scanData.ScanDataLength];
164                 scanData.ScanData.CopyTo(_scanDataValue, 0);
165             }
166         }
167
168         ~BluetoothLeDevice()
169         {
170             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
171             {
172                 BluetoothLeImplAdapter.Instance.FreeServiceDataList();
173             }
174         }
175
176         /// <summary>
177         /// The remote address.
178         /// </summary>
179         public string RemoteAddress
180         {
181             get
182             {
183                 return _remoteAddress;
184             }
185         }
186
187         /// <summary>
188         /// The type of the address.
189         /// </summary>
190         public BluetoothLeDeviceAddressType AddressType
191         {
192             get
193             {
194                 return _addressType;
195             }
196         }
197
198         /// <summary>
199         /// The rssi value.
200         /// </summary>
201         public int Rssi
202         {
203             get
204             {
205                 return _rssi;
206             }
207         }
208
209         /// <summary>
210         /// The advertsing data information.
211         /// </summary>
212         public byte[] AdvertsingDataInformation
213         {
214             get
215             {
216                 return _advDataValue;
217             }
218         }
219
220         /// <summary>
221         /// The scan data information.
222         /// </summary>
223         public byte[] ScanDataInformation
224         {
225             get
226             {
227                 return _scanDataValue;
228             }
229         }
230
231         /// <summary>
232         /// The type of the packet.
233         /// </summary>
234         public BluetoothLePacketType PacketType
235         {
236             get
237             {
238                 return _packetType;
239             }
240             set
241             {
242                 _packetType = value;
243             }
244         }
245
246         /// <summary>
247         /// Gets the service UUIDs list from the LE scan result information.
248         /// </summary>
249         /// <value> Gets the list of the string service UUIDs.</value>
250         /// <remarks>
251         /// The Bluetooth must be enabled.
252         /// </remarks>
253         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
254         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled.</exception>
255         public IEnumerable<string> ServiceUuid
256         {
257             get
258             {
259                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
260                 {
261                     Log.Info(Globals.LogTag, "Retrieving Service uuid- ");
262                     return BluetoothLeImplAdapter.Instance.GetLeScanResultServiceUuids(_scanData, _packetType);
263                 }
264                 return null;
265             }
266         }
267
268         /// <summary>
269         /// Gets the device name from the LE scan result information.
270         /// </summary>
271         /// <value> Gets the device name.</value>
272         /// <remarks>
273         /// The Bluetooth must be enabled.
274         /// </remarks>
275         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
276         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled.</exception>
277         public string DeviceName
278         {
279             get
280             {
281                 Log.Info(Globals.LogTag, "Retrieving device name- ");
282                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
283                 {
284                     return BluetoothLeImplAdapter.Instance.GetLeScanResultDeviceName(_scanData, _packetType);
285                 }
286                 return null;
287             }
288         }
289         /// <summary>
290         /// Gets the transmission power level from the LE scan result information.
291         /// </summary>
292         /// <value> Gets the transmission power level in dB.</value>
293         /// <remarks>
294         /// The Bluetooth must be enabled.
295         /// </remarks>
296         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
297         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled.</exception>
298         public int TxPowerLevel
299         {
300             get
301             {
302                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
303                 {
304                     return BluetoothLeImplAdapter.Instance.GetScanResultTxPowerLevel(_scanData, _packetType);
305                 }
306                 return -1;
307             }
308         }
309
310         /// <summary>
311         /// Gets the service solicitation UUID list from the scan result information.
312         /// </summary>
313         /// <value> Gets the list of the service solicitation UUIDs.</value>
314         /// <remarks>
315         /// The Bluetooth must be enabled.
316         /// </remarks>
317         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
318         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled.</exception>
319         public IEnumerable<string> ServiceSolictationUuid
320         {
321             get
322             {
323                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
324                 {
325                     return BluetoothLeImplAdapter.Instance.GetScanResultSvcSolicitationUuids(_scanData, _packetType);
326                 }
327                 return null;
328             }
329         }
330         /// <summary>
331         /// Gets the manufacturer data from the scan result information.
332         /// </summary>
333         /// <value> Gets the appearance value.</value>
334         /// <remarks>
335         /// The Bluetooth must be enabled.
336         /// </remarks>
337         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
338         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled.</exception>
339         public int Appearance
340         {
341             get
342             {
343                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
344                 {
345                     return BluetoothLeImplAdapter.Instance.GetScanResultAppearance(_scanData, _packetType);
346                 }
347                 return -1;
348             }
349         }
350         /// <summary>
351         /// Gets the manufacturer data from the scan result information.
352         /// </summary>
353         /// <value> Gets the manufacturer data containing the manucturer data and ID information.</value>
354         /// <remarks>
355         /// The Bluetooth must be enabled.
356         /// </remarks>
357         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
358         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled.</exception>/// 
359         public ManufacturerData ManufacturerData
360         {
361             get
362             {
363                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
364                 {
365                     return BluetoothLeImplAdapter.Instance.GetScanResultManufacturerData(_scanData, _packetType);
366                 }
367                 return null;
368             }
369         }
370
371         /// <summary>
372         /// Gets the service data list from the scan result information.
373         /// </summary>
374         /// <remarks>
375         /// The Bluetooth must be enabled.
376         /// </remarks>
377         /// <returns> Returns the service data list.</returns>
378         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
379         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled.</exception>
380         public IEnumerable<BluetoothLeServiceData> GetServiceDataList()
381         {
382             int serviceCount = 0;
383             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
384             {
385                 return BluetoothLeImplAdapter.Instance.GetScanResultServiceDataList(_scanData,
386                                             _packetType, out serviceCount);
387             }
388             return null;
389         }
390
391
392         /// <summary>
393         /// Creates a GATT connection with the remote device.
394         /// </summary>
395         /// <remarks>
396         /// The Bluetooth must be enabled.
397         /// </remarks>
398         /// <param name="autoConnect"> The auto connect flag.</param>
399         /// <returns>client instance</returns>
400         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
401         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
402         /// or when the gatt connection attempt to remote device fails.</exception>
403         public BluetoothGattClient GattConnect(bool autoConnect)
404         {
405             BluetoothGattClient client = null;
406             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
407             {
408                 int ret = BluetoothLeImplAdapter.Instance.GattConnect (_remoteAddress, autoConnect);
409                 if (ret != (int)BluetoothError.None) {
410                     Log.Error (Globals.LogTag, "Failed to create GATT Connection with remote device- " + (BluetoothError)ret);
411                 }
412                 else
413                 {
414                     client = BluetoothGattClient.CreateClient(_remoteAddress);
415                 }
416             }
417             else
418             {
419                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
420             }
421             return client;
422         }
423
424         /// <summary>
425         /// Disconnects a GATT connection with the remote device.
426         /// </summary>
427         /// <remarks>
428         /// The Bluetooth must be enabled.
429         /// </remarks>
430         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
431         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
432         /// or when the GATT disconnection attempt to remote device fails.</exception>
433         public void GattDisconnect()
434         {
435             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
436             {
437                 int ret = BluetoothLeImplAdapter.Instance.GattDisconnect (_remoteAddress);
438                 if (ret != (int)BluetoothError.None) {
439                     Log.Error (Globals.LogTag, "Failed to disconnect GATT connection with remote device- " + (BluetoothError)ret);
440                 }
441             }
442             else
443             {
444                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
445             }
446         }
447     }
448
449     /// <summary>
450     /// Bluetooth LE advertise data. Handles the data advertising.
451     /// </summary>
452     public class BluetoothLeAdvertiseData:IDisposable
453     {
454         private IntPtr _handle = IntPtr.Zero;
455         private BluetoothLeAdvertisingMode _mode;
456         private bool _advertisingConnectable;
457         private BluetoothLePacketType _packetType;
458         private int _appearance;
459         private bool _includePowerLevel;
460         private bool _includeDeviceName;
461
462         /// <summary>
463         /// The default constructor initializes an object of the BluetoothLeAdvertiseData.
464         /// </summary>
465         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
466         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
467         /// or when create advertiser fails.</exception>
468         public BluetoothLeAdvertiseData()
469         {
470             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
471             {
472                 Log.Debug(Globals.LogTag, " Creating LeAdvertiser()");
473                 int ret = Interop.Bluetooth.CreateAdvertiser(out _handle);
474                 if (ret != (int)BluetoothError.None)
475                 {
476                     Log.Error(Globals.LogTag, "Failed to create advertiser object- " + (BluetoothError)ret);
477                     BluetoothErrorFactory.ThrowBluetoothException(ret);
478                 }
479             }
480             else
481             {
482                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
483             }
484         }
485
486         ~BluetoothLeAdvertiseData()
487         {
488             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
489             {
490                 //clean-up
491                 ClearAdvertisingData (BluetoothLePacketType.BluetoothLeAdvertisingPacket);
492                 ClearAdvertisingData (BluetoothLePacketType.BluetoothLeScanResponsePacket);
493                 BluetoothLeImplAdapter.Instance.DestroyAdvertiser (_handle);
494             }
495             Dispose(false);
496         }
497
498         internal IntPtr GetHandle()
499         {
500             return _handle;
501         }
502
503         /// <summary>
504         /// The advertising mode to control the advertising power and latency.
505         /// </summary>
506         /// <remarks>
507         /// The Bluetooth must be enabled.
508         /// </remarks>
509         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
510         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
511         /// or when the set advertising mode fails.</exception>
512         public BluetoothLeAdvertisingMode AdvertisingMode
513         {
514             get
515             {
516                 return _mode;
517             }
518             set
519             {
520                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
521                 {
522                     _mode = value;
523                     int ret = Interop.Bluetooth.SetAdvertisingMode (GetHandle (), _mode);
524                     if (ret != (int)BluetoothError.None) {
525                         Log.Error (Globals.LogTag, "Failed to set advertising mode- " + (BluetoothError)ret);
526                         BluetoothErrorFactory.ThrowBluetoothException (ret);
527                     }
528                 }
529             }
530         }
531
532         /// <summary>
533         /// The advertising connectable type.
534         /// </summary>
535         /// <remarks>
536         /// The Bluetooth must be enabled.
537         /// </remarks>
538         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
539         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
540         /// or when the set advertising connectable mode fails.</exception>
541         public bool AdvertisingConnectable
542         {
543             get
544             {
545                 return _advertisingConnectable;
546             }
547             set
548             {
549                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
550                 {
551                     _advertisingConnectable = value;
552                     int ret = Interop.Bluetooth.SetAdvertisingConnectable (GetHandle (), _advertisingConnectable);
553                     if (ret != (int)BluetoothError.None) {
554                         Log.Error (Globals.LogTag, "Failed to set advertising connectable value- " + (BluetoothError)ret);
555                         BluetoothErrorFactory.ThrowBluetoothException (ret);
556                     }
557                 }
558             }
559         }
560
561         public void Dispose()
562         {
563             Dispose(true);
564             GC.SuppressFinalize(this);
565         }
566
567         private void Dispose(bool disposing)
568         {
569             //todo...
570         }
571
572         /// <summary>
573         /// The type of the packet.
574         /// </summary>
575         public BluetoothLePacketType PacketType
576         {
577             get
578             {
579                 return _packetType;
580             }
581             set
582             {
583                 _packetType = value;
584             }
585         }
586         /// <summary>
587         /// Sets the external appearance of this device to the advertise or the scan response data.
588         /// Please refer to the adopted Bluetooth specification for the appearance.
589         /// </summary>
590         /// <remarks>
591         /// The Bluetooth must be enabled.
592         /// </remarks>
593         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
594         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
595         /// or when the set appearance fails.</exception>
596         public int Appearance
597         {
598             get
599             {
600                 return _appearance;
601             }
602             set
603             {
604                 _appearance = value;
605                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize) {
606                     int ret = Interop.Bluetooth.SetAdvertisingAppearance (GetHandle (), _packetType, _appearance);
607                     if (ret != (int)BluetoothError.None) {
608                         Log.Error (Globals.LogTag, "Failed to add appearance value to advertising data- " + (BluetoothError)ret);
609                         BluetoothErrorFactory.ThrowBluetoothException(ret);
610                     }
611                 }
612             }
613         }
614         /// <summary>
615         /// Sets whether the device name has to be included in the advertise or the scan response data.
616         /// The maximum advertised or responded data size is 31 bytes including the data type and the system wide data.
617         /// </summary>
618         /// <remarks>
619         /// The Bluetooth must be enabled.
620         /// </remarks>
621         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
622         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
623         /// or when the set advertising device name fails.</exception>
624         public bool IncludeDeviceName
625         {
626             get
627             {
628                 return _includeDeviceName;
629             }
630             set
631             {
632                 _includeDeviceName = value;
633                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
634                 {
635                     int ret = Interop.Bluetooth.SetAdvertisingDeviceName(GetHandle(), _packetType, _includeDeviceName);
636                     if (ret != (int)BluetoothError.None) {
637                         Log.Error (Globals.LogTag, "Failed to add device name to advertising data- " + (BluetoothError)ret);
638                         BluetoothErrorFactory.ThrowBluetoothException(ret);
639                     }
640                 }
641             }
642         }
643
644
645         /// <summary>
646         /// Sets whether the transmission power level should be included in the advertise or the scan response data.
647         /// The maximum advertised or responded data size is 31 bytes including the data type and the system wide data.
648         /// </summary>
649         /// <remarks>
650         /// The Bluetooth must be enabled.
651         /// </remarks>
652         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
653         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
654         /// or when the set advertising TC power level fails.</exception>
655         public bool IncludeTxPowerLevel
656         {
657             get
658             {
659                 return _includePowerLevel;
660             }
661             set
662             {
663                 _includePowerLevel = value;
664                 if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
665                 {
666                     int ret = Interop.Bluetooth.SetAdvertisingTxPowerLevel(GetHandle(), _packetType, _includePowerLevel);
667                     if (ret != (int)BluetoothError.None)
668                     {
669                         Log.Error(Globals.LogTag, "Failed to add advertising service solicitation uuid- " + (BluetoothError)ret);
670                     }
671                 }
672             }
673         }
674         /// <summary>
675         /// Adds a service UUID to the advertise or the scan response data.
676         /// The maximum advertised or responded data size is 31 bytes
677         /// including the data type and the system wide data.
678         /// </summary>
679         /// <remarks>
680         /// The Bluetooth must be enabled.
681         /// </remarks>
682         /// <param name="packetType">The packet type.</param>
683         /// <param name="serviceUuid"> The service UUID to add to advertise data.</param>
684         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
685         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
686         /// or when the add advertising service UUID procedure fails.</exception>
687         public void AddAdvertisingServiceUuid(BluetoothLePacketType packetType, string serviceUuid)
688         {
689             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
690             {
691                 int ret = Interop.Bluetooth.AddAdvertisingServiceUuid (GetHandle (), packetType, serviceUuid);
692                 if (ret != (int)BluetoothError.None) {
693                     Log.Error (Globals.LogTag, "Failed to add service uuid to advertising data- " + (BluetoothError)ret);
694                     BluetoothErrorFactory.ThrowBluetoothException (ret);
695                 }
696             }
697             else
698             {
699                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
700             }
701         }
702
703         /// <summary>
704         /// Adds a service solicitation UUID to advertise or scan the response data.
705         /// The maximum advertised or responded data size is 31 bytes
706         /// including the data type and the system wide data.
707         /// </summary>
708         /// <remarks>
709         /// The Bluetooth must be enabled.
710         /// </remarks>
711         /// <param name="packetType">The packet type.</param>
712         /// <param name="serviceSolicitationUuid"> The service solicitation UUID to add to advertise data.</param>
713         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
714         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
715         /// or when the add advertising service solicitation UUID procedure fails.</exception>
716         public void AddAdvertisingServiceSolicitationUuid(BluetoothLePacketType packetType,
717                                                         string serviceSolicitationUuid)
718         {
719             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
720             {
721                 int ret = Interop.Bluetooth.AddAdvertisingServiceSolicitationUuid(GetHandle(), packetType,
722                                                                 serviceSolicitationUuid);
723                 if (ret != (int)BluetoothError.None) {
724                     Log.Error (Globals.LogTag, "Failed to add service solicitation uuid to advertising data- " + (BluetoothError)ret);
725                     BluetoothErrorFactory.ThrowBluetoothException(ret);
726                 }
727             }
728             else
729             {
730                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
731             }
732         }
733
734         /// <summary>
735         /// Adds a service data to the advertise or the scan response data.
736         /// The maximum advertised or responded data size is 31 bytes
737         /// including data type and system wide data.
738         /// </summary>
739         /// <remarks>
740         /// The Bluetooth must be enabled.
741         /// </remarks>
742         /// <param name="packetType">The packet type.</param>
743         /// <param name="data"> The service data to be added to advertising.</param>
744         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
745         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
746         /// or when the add advertising data procedure fails.</exception>
747         public void AddAdvertisingServiceData(BluetoothLePacketType packetType, BluetoothServiceData data)
748         {
749             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
750             {
751                 IntPtr serviceDataPtr;
752                 serviceDataPtr = Marshal.AllocHGlobal(data.DataLength);
753                 Marshal.Copy(data.Data, 0, serviceDataPtr, data.DataLength);
754
755                 for (int i = 0; i < 3; i++)
756                     Log.Error (Globals.LogTag, " service data is  " + data.Data [i]);
757                 int ret = Interop.Bluetooth.AddAdvertisingServiceData(GetHandle(), packetType,
758                     data.Uuid, serviceDataPtr, data.DataLength);
759                 if (ret != (int)BluetoothError.None)
760                 {
761                     Log.Error(Globals.LogTag, "Failed to add service data to advertising data- " + (BluetoothError)ret);
762                     BluetoothErrorFactory.ThrowBluetoothException(ret);
763                 }
764             }
765             else
766             {
767                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
768             }
769         }
770
771         /// <summary>
772         /// Adds the manufacturer specific data to the advertise or the scan response data.
773         /// Please refer to the adopted Bluetooth specification for the the appearance.
774         /// </summary>
775         /// <remarks>
776         /// The Bluetooth must be enabled.
777         /// </remarks>
778         /// <param name="packetType">The packet type.</param>
779         /// <param name="manufacturerData"> The manufacturer specific data.</param>
780         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
781         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
782         /// or when the add advertising manufacturer data procedure fails.</exception>
783         public void AddAdvertisingManufacturerData(BluetoothLePacketType packetType,
784                                     ManufacturerData manufacturerData)
785         {
786             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
787             {
788                 IntPtr manufDataPtr;
789                 manufDataPtr = Marshal.AllocHGlobal(manufacturerData.DataLength);
790                 Marshal.Copy(manufacturerData.Data, 0, manufDataPtr, manufacturerData.DataLength);
791
792                 int ret = Interop.Bluetooth.AddAdvertisingManufData(GetHandle(), packetType,
793                     manufacturerData.Id, manufDataPtr, manufacturerData.DataLength);
794                 if (ret != (int)BluetoothError.None)
795                 {
796                     Log.Error(Globals.LogTag, "Failed to add service solicitation uuid to advertising data- " + (BluetoothError)ret);
797                     BluetoothErrorFactory.ThrowBluetoothException(ret);
798                 }
799             }
800             else
801             {
802                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
803             }
804         }
805
806         /// <summary>
807         /// Clears all data to be advertised or responded to the scan request from the LE scanning device.
808         /// </summary>
809         /// <remarks>
810         /// The Bluetooth must be enabled.
811         /// </remarks>
812         /// <param name="packetType">The packet type to be cleared.</param>
813         /// <exception cref="NotSupportedException">Thrown when the Bluetooth LE is not supported.</exception>
814         /// <exception cref="InvalidOperationException">Thrown when the Bluetooth LE is not enabled
815         /// or when the clear advertising data procedure fails.</exception>
816         internal void ClearAdvertisingData(BluetoothLePacketType packetType)
817         {
818             if (BluetoothAdapter.IsBluetoothEnabled && Globals.IsInitialize)
819             {
820                 int ret = Interop.Bluetooth.ClearAdvertisingData (GetHandle (), packetType);
821                 if (ret != (int)BluetoothError.None) {
822                     Log.Error (Globals.LogTag, "Failed to Clear Advertising Data- " + (BluetoothError)ret);
823                 }
824             }
825             else
826             {
827                 BluetoothErrorFactory.ThrowBluetoothException((int)BluetoothError.NotEnabled);
828             }
829         }
830     }
831 }