2 * Copyright (c) 2015 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.
17 var T = xwalk.utils.type;
18 var Converter = xwalk.utils.converter;
19 var AV = xwalk.utils.validator;
20 var Privilege = xwalk.utils.privilege;
21 var privUtils_ = xwalk.utils;
22 var native = new xwalk.utils.NativeManager(extension);
24 // class BluetoothClassDeviceMajor /////////////////////////////////////////
25 var BluetoothClassDeviceMajor = function() {
26 Object.defineProperties(this, {
27 MISC: { value: 0x00, writable: false, enumerable: true },
28 COMPUTER: { value: 0x01, writable: false, enumerable: true },
29 PHONE: { value: 0x02, writable: false, enumerable: true },
30 NETWORK: { value: 0x03, writable: false, enumerable: true },
31 AUDIO_VIDEO: { value: 0x04, writable: false, enumerable: true },
32 PERIPHERAL: { value: 0x05, writable: false, enumerable: true },
33 IMAGING: { value: 0x06, writable: false, enumerable: true },
34 WEARABLE: { value: 0x07, writable: false, enumerable: true },
35 TOY: { value: 0x08, writable: false, enumerable: true },
36 HEALTH: { value: 0x09, writable: false, enumerable: true },
37 UNCATEGORIZED: { value: 0x1f, writable: false, enumerable: true }
41 // class BluetoothClassDeviceMinor /////////////////////////////////////////
42 var BluetoothClassDeviceMinor = function() {
43 Object.defineProperties(this, {
44 COMPUTER_UNCATEGORIZED: { value: 0x00, writable: false, enumerable: true },
45 COMPUTER_DESKTOP: { value: 0x01, writable: false, enumerable: true },
46 COMPUTER_SERVER: { value: 0x02, writable: false, enumerable: true },
47 COMPUTER_LAPTOP: { value: 0x03, writable: false, enumerable: true },
48 COMPUTER_HANDHELD_PC_OR_PDA: { value: 0x04, writable: false, enumerable: true },
49 COMPUTER_PALM_PC_OR_PDA: { value: 0x05, writable: false, enumerable: true },
50 COMPUTER_WEARABLE: { value: 0x06, writable: false, enumerable: true },
52 PHONE_UNCATEGORIZED: { value: 0x00, writable: false, enumerable: true },
53 PHONE_CELLULAR: { value: 0x01, writable: false, enumerable: true },
54 PHONE_CORDLESS: { value: 0x02, writable: false, enumerable: true },
55 PHONE_SMARTPHONE: { value: 0x03, writable: false, enumerable: true },
56 PHONE_MODEM_OR_GATEWAY: { value: 0x04, writable: false, enumerable: true },
57 PHONE_ISDN: { value: 0x05, writable: false, enumerable: true },
59 AV_UNRECOGNIZED: { value: 0x00, writable: false, enumerable: true },
60 AV_WEARABLE_HEADSET: { value: 0x01, writable: false, enumerable: true },
61 AV_HANDSFREE: { value: 0x02, writable: false, enumerable: true },
62 AV_MICROPHONE: { value: 0x04, writable: false, enumerable: true },
63 AV_LOUDSPEAKER: { value: 0x05, writable: false, enumerable: true },
64 AV_HEADPHONES: { value: 0x06, writable: false, enumerable: true },
65 AV_PORTABLE_AUDIO: { value: 0x07, writable: false, enumerable: true },
66 AV_CAR_AUDIO: { value: 0x08, writable: false, enumerable: true },
67 AV_SETTOP_BOX: { value: 0x09, writable: false, enumerable: true },
68 AV_HIFI: { value: 0x0a, writable: false, enumerable: true },
69 AV_VCR: { value: 0x0b, writable: false, enumerable: true },
70 AV_VIDEO_CAMERA: { value: 0x0c, writable: false, enumerable: true },
71 AV_CAMCORDER: { value: 0x0d, writable: false, enumerable: true },
72 AV_MONITOR: { value: 0x0e, writable: false, enumerable: true },
73 AV_DISPLAY_AND_LOUDSPEAKER: { value: 0x0f, writable: false, enumerable: true },
74 AV_VIDEO_CONFERENCING: { value: 0x10, writable: false, enumerable: true },
75 AV_GAMING_TOY: { value: 0x12, writable: false, enumerable: true },
77 PERIPHERAL_UNCATEGORIZED: { value: 0x00, writable: false, enumerable: true },
78 PERIPHERAL_KEYBOARD: { value: 0x10, writable: false, enumerable: true },
79 PERIPHERAL_POINTING_DEVICE: { value: 0x20, writable: false, enumerable: true },
80 PERIPHERAL_KEYBOARD_AND_POINTING_DEVICE: {
85 PERIPHERAL_JOYSTICK: { value: 0x01, writable: false, enumerable: true },
86 PERIPHERAL_GAMEPAD: { value: 0x02, writable: false, enumerable: true },
87 PERIPHERAL_REMOTE_CONTROL: { value: 0x03, writable: false, enumerable: true },
88 PERIPHERAL_SENSING_DEVICE: { value: 0x04, writable: false, enumerable: true },
89 PERIPHERAL_DEGITIZER_TABLET: { value: 0x05, writable: false, enumerable: true },
90 PERIPHERAL_CARD_READER: { value: 0x06, writable: false, enumerable: true },
91 PERIPHERAL_DIGITAL_PEN: { value: 0x07, writable: false, enumerable: true },
92 PERIPHERAL_HANDHELD_SCANNER: { value: 0x08, writable: false, enumerable: true },
93 PERIPHERAL_HANDHELD_INPUT_DEVICE: {
99 IMAGING_UNCATEGORIZED: { value: 0x00, writable: false, enumerable: true },
100 IMAGING_DISPLAY: { value: 0x04, writable: false, enumerable: true },
101 IMAGING_CAMERA: { value: 0x08, writable: false, enumerable: true },
102 IMAGING_SCANNER: { value: 0x10, writable: false, enumerable: true },
103 IMAGING_PRINTER: { value: 0x20, writable: false, enumerable: true },
105 WEARABLE_WRITST_WATCH: { value: 0x01, writable: false, enumerable: true },
106 WEARABLE_PAGER: { value: 0x02, writable: false, enumerable: true },
107 WEARABLE_JACKET: { value: 0x03, writable: false, enumerable: true },
108 WEARABLE_HELMET: { value: 0x04, writable: false, enumerable: true },
109 WEARABLE_GLASSES: { value: 0x05, writable: false, enumerable: true },
111 TOY_ROBOT: { value: 0x01, writable: false, enumerable: true },
112 TOY_VEHICLE: { value: 0x02, writable: false, enumerable: true },
113 TOY_DOLL: { value: 0x03, writable: false, enumerable: true },
114 TOY_CONTROLLER: { value: 0x04, writable: false, enumerable: true },
115 TOY_GAME: { value: 0x05, writable: false, enumerable: true },
117 HEALTH_UNDEFINED: { value: 0x00, writable: false, enumerable: true },
118 HEALTH_BLOOD_PRESSURE_MONITOR: { value: 0x01, writable: false, enumerable: true },
119 HEALTH_THERMOMETER: { value: 0x02, writable: false, enumerable: true },
120 HEALTH_WEIGHING_SCALE: { value: 0x03, writable: false, enumerable: true },
121 HEALTH_GLUCOSE_METER: { value: 0x04, writable: false, enumerable: true },
122 HEALTH_PULSE_OXIMETER: { value: 0x05, writable: false, enumerable: true },
123 HEALTH_PULSE_RATE_MONITOR: { value: 0x06, writable: false, enumerable: true },
124 HEALTH_DATA_DISPLAY: { value: 0x07, writable: false, enumerable: true },
125 HEALTH_STEP_COUNTER: { value: 0x08, writable: false, enumerable: true },
126 HEALTH_BODY_COMPOSITION_ANALYZER: {
131 HEALTH_PEAK_FLOW_MONITOR: { value: 0x0a, writable: false, enumerable: true },
132 HEALTH_MEDICATION_MONITOR: { value: 0x0b, writable: false, enumerable: true },
133 HEALTH_KNEE_PROSTHESIS: { value: 0x0c, writable: false, enumerable: true },
134 HEALTH_ANKLE_PROSTHESIS: { value: 0x0d, writable: false, enumerable: true }
138 // class BluetoothClassDeviceService ///////////////////////////////////////
139 var BluetoothClassDeviceService = function() {
140 Object.defineProperties(this, {
141 LIMITED_DISCOVERABILITY: { value: 0x0001, writable: false, enumerable: true },
142 POSITIONING: { value: 0x0008, writable: false, enumerable: true },
143 NETWORKING: { value: 0x0010, writable: false, enumerable: true },
144 RENDERING: { value: 0x0020, writable: false, enumerable: true },
145 CAPTURING: { value: 0x0040, writable: false, enumerable: true },
146 OBJECT_TRANSFER: { value: 0x0080, writable: false, enumerable: true },
147 AUDIO: { value: 0x0100, writable: false, enumerable: true },
148 TELEPHONY: { value: 0x0200, writable: false, enumerable: true },
149 INFORMATION: { value: 0x0400, writable: false, enumerable: true }
153 //class tizen.BluetoothLEServiceData //////////////////////////
154 tizen.BluetoothLEServiceData = function(d) {
155 AV.isConstructorCall(this, tizen.BluetoothLEServiceData);
159 Object.defineProperties(this, {
166 uuid_ = Converter.toString(v);
175 data_ = Converter.toString(v);
180 if (arguments.length >= 2) {
181 // public constructor
182 this.uuid = arguments[0];
183 this.data = arguments[1];
184 } else if (d && T.isObject(d)) {
185 // internal constructor
194 //class BluetoothLEAdvertiseData //////////////////////////
195 tizen.BluetoothLEAdvertiseData = function(dict) {
196 AV.isConstructorCall(this, tizen.BluetoothLEAdvertiseData);
197 var includeName_ = false;
199 var solicitationuuids_ = null;
200 var appearance_ = null;
201 var includeTxPowerLevel_ = false;
202 var serviceData_ = null;
203 var manufacturerData_ = null;
205 Object.defineProperties(this, {
212 includeName_ = Converter.toBoolean(v, true);
223 } else if (T.isArray(v)) {
224 for (var i = 0; i < v.length; ++i) {
225 if (!T.isString(v[i])) {
226 v[i] = Converter.toString(v[i]);
236 return solicitationuuids_;
240 solicitationuuids_ = v;
241 } else if (T.isArray(v)) {
242 for (var i = 0; i < v.length; ++i) {
243 if (!T.isString(v[i])) {
244 v[i] = Converter.toString(v[i]);
247 solicitationuuids_ = v;
257 appearance_ = Converter.toUnsignedLong(v, true);
260 includeTxPowerLevel: {
263 return includeTxPowerLevel_;
266 includeTxPowerLevel_ = Converter.toBoolean(v, true);
275 if (T.isNull(v) || v instanceof tizen.BluetoothLEServiceData) {
283 return manufacturerData_;
286 if (T.isNull(v) || v instanceof tizen.BluetoothLEManufacturerData) {
287 manufacturerData_ = v;
293 if (T.isObject(dict)) {
297 if (T.isNull(dict.includeName) || T.isBoolean(dict.includeName)) {
298 o.includeName = dict.includeName;
299 } else if (!T.isUndefined(dict.includeName)) {
304 if (T.isNull(dict.uuids)) {
305 o.uuids = dict.uuids;
306 } else if (T.isArray(dict.uuids)) {
307 for (var i = 0; i < dict.uuids.length; ++i) {
308 if (!T.isString(dict.uuids[i])) {
312 o.uuids = dict.uuids;
313 } else if (!T.isUndefined(dict.uuids)) {
318 if (T.isNull(dict.solicitationuuids)) {
319 o.solicitationuuids = dict.solicitationuuids;
320 } else if (T.isArray(dict.solicitationuuids)) {
321 for (var i = 0; i < dict.solicitationuuids.length; ++i) {
322 if (!T.isString(dict.solicitationuuids[i])) {
326 o.solicitationuuids = dict.solicitationuuids;
327 } else if (!T.isUndefined(dict.solicitationuuids)) {
332 if (T.isNull(dict.appearance) || T.isNumber(dict.appearance)) {
333 o.appearance = dict.appearance;
334 } else if (!T.isUndefined(dict.appearance)) {
338 // includeTxPowerLevel
339 if (T.isNull(dict.includeTxPowerLevel) || T.isBoolean(dict.includeTxPowerLevel)) {
340 o.includeTxPowerLevel = dict.includeTxPowerLevel;
341 } else if (!T.isUndefined(dict.includeTxPowerLevel)) {
347 T.isNull(dict.serviceData) ||
348 dict.serviceData instanceof tizen.BluetoothLEServiceData
350 o.serviceData = dict.serviceData;
351 } else if (!T.isUndefined(dict.serviceData)) {
357 T.isNull(dict.manufacturerData) ||
358 dict.manufacturerData instanceof tizen.BluetoothLEManufacturerData
360 o.manufacturerData = dict.manufacturerData;
361 } else if (!T.isUndefined(dict.manufacturerData)) {
365 for (var prop in o) {
366 if (o.hasOwnProperty(prop) && this.hasOwnProperty(prop)) {
367 this[prop] = o[prop];
373 //class tizen.BluetoothLEManufacturerData //////////////////////////
374 tizen.BluetoothLEManufacturerData = function(d) {
375 AV.isConstructorCall(this, tizen.BluetoothLEManufacturerData);
379 Object.defineProperties(this, {
386 id_ = Converter.toString(v);
395 data_ = Converter.toString(v);
400 if (arguments.length >= 2) {
401 // public constructor
402 this.id = arguments[0];
403 this.data = arguments[1];
404 } else if (d && T.isObject(d)) {
405 // internal constructor
414 // class BluetoothClass //////////////////////////
415 var BluetoothClass = function(data) {
418 services = data.services;
421 Object.defineProperties(this, {
422 major: { value: data.major, writable: false, enumerable: true },
423 minor: { value: data.minor, writable: false, enumerable: true },
428 return services.slice();
434 var BluetoothClass_hasService = function() {
435 privUtils_.log('Entered BluetoothClass.hasService()');
436 privUtils_.checkPrivilegeAccess4Ver(
439 Privilege.BLUETOOTH_GAP
442 var args = AV.validateMethod(arguments, [
445 type: AV.Types.UNSIGNED_LONG
449 var size = this.services.length;
450 for (var i = 0; i < size; i++) {
451 if (this.services[i] === args.service) {
458 BluetoothClass.prototype.hasService = function() {
459 return BluetoothClass_hasService.apply(this, arguments);
462 // class BluetoothSocket //////////////////////////
463 var _BLUETOOTH_SOCKET_STATE_CLOSED = 'CLOSED';
465 function BluetoothSocketListeners() {
467 this.socketCallback = function(data) {
469 var socket = that.sockets[event.id];
472 if ('onclose' === event.event) {
474 that.removeListener(event.id);
476 Object.defineProperty(socket, 'state', {
477 value: _BLUETOOTH_SOCKET_STATE_CLOSED
481 var callback = socket[event.event];
482 if (T.isFunction(callback)) {
486 privUtils_.log('Received event for an unknown socket: ' + event.id);
491 BluetoothSocketListeners.prototype.sockets = {};
493 BluetoothSocketListeners.prototype.addListener = function(socket) {
494 if (T.isEmptyObject(this.sockets)) {
495 native.addListener('BLUETOOTH_SOCKET_STATE_CHANGED', this.socketCallback);
498 this.sockets[socket._id] = socket;
501 BluetoothSocketListeners.prototype.removeListener = function(id) {
502 delete this.sockets[id];
504 if (T.isEmptyObject(this.sockets)) {
505 native.removeListener('BLUETOOTH_SOCKET_STATE_CHANGED', this.socketCallback);
509 var _bluetoothSocketListeners = new BluetoothSocketListeners();
511 var BluetoothSocket = function(data) {
512 Object.defineProperties(this, {
513 uuid: { value: data.uuid, writable: false, enumerable: true },
521 value: new BluetoothDevice(data.peer),
525 onmessage: { value: null, writable: true, enumerable: true },
526 onclose: { value: null, writable: true, enumerable: true },
527 _id: { value: data.id, writable: false, enumerable: false }
530 _bluetoothSocketListeners.addListener(this);
533 BluetoothSocket.prototype.writeData = function() {
534 privUtils_.log('Entered BluetoothSocket.writeData()');
536 var args = AV.validateMethod(arguments, [
539 type: AV.Types.ARRAY,
540 values: AV.Types.BYTE
549 var result = native.callSync('BluetoothSocket_writeData', callArgs);
551 if (native.isFailure(result)) {
552 throw native.getErrorObject(result);
554 return native.getResultObject(result);
558 BluetoothSocket.prototype.readData = function() {
559 privUtils_.log('Entered BluetoothSocket.readData()');
565 var result = native.callSync('BluetoothSocket_readData', callArgs);
567 if (native.isFailure(result)) {
568 throw native.getErrorObject(result);
570 return native.getResultObject(result);
574 BluetoothSocket.prototype.close = function() {
575 privUtils_.log('Entered BluetoothSocket.close()');
577 if (_BLUETOOTH_SOCKET_STATE_CLOSED !== this.state) {
582 var result = native.callSync('BluetoothSocket_close', callArgs);
584 if (native.isFailure(result)) {
585 throw native.getErrorObject(result);
589 Object.defineProperty(this, 'state', { value: _BLUETOOTH_SOCKET_STATE_CLOSED });
593 //class BluetoothLEDevice //////////////////////////
594 var BluetoothLEDevice = function(data) {
600 solicitationuuids = null,
602 manufacturerData = null,
606 address = data.address;
607 name = data.name || null;
608 txpowerlevel = data.txpowerlevel || null;
609 appearance = data.appearance || null;
610 uuids = data.uuids || null;
611 solicitationuuids = data.solicitationuuids || null;
612 if (data.serviceData) {
614 data.serviceData.forEach(function(d) {
615 serviceData.push(new tizen.BluetoothLEServiceData(d));
618 if (data.manufacturerData) {
619 manufacturerData = new tizen.BluetoothLEManufacturerData(
620 data.manufacturerData
628 Object.defineProperties(this, {
629 address: { value: address, writable: false, enumerable: true },
630 name: { value: name, writable: false, enumerable: true },
631 txpowerlevel: { value: txpowerlevel, writable: false, enumerable: true },
632 appearance: { value: appearance, writable: false, enumerable: true },
637 var service_uuids = uuids ? uuids.slice() : null;
638 return service_uuids;
645 return solicitationuuids ? solicitationuuids.slice() : null;
652 return serviceData ? serviceData.slice() : null;
656 value: manufacturerData,
660 rssi: { value: rssi, writable: false, enumerable: true }
664 BluetoothLEDevice.prototype.connect = function() {
665 privUtils_.log('Entered BluetoothLEDevice.connect()');
666 var args = AV.validateMethod(arguments, [
668 name: 'successCallback',
669 type: AV.Types.FUNCTION,
674 name: 'errorCallback',
675 type: AV.Types.FUNCTION,
681 var callback = function(result) {
682 if (native.isFailure(result)) {
683 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
685 native.callIfPossible(args.successCallback);
688 // Errors are handled by error callback
689 var result = native.call(
690 'BluetoothLEDevice_connect',
691 { address: this.address },
694 if (native.isFailure(result)) {
695 throw native.getErrorObject(result);
699 BluetoothLEDevice.prototype.disconnect = function() {
700 privUtils_.log('Entered BluetoothLEDevice.disconnect()');
701 var args = AV.validateMethod(arguments, [
703 name: 'successCallback',
704 type: AV.Types.FUNCTION,
709 name: 'errorCallback',
710 type: AV.Types.FUNCTION,
715 var callback = function(result) {
716 if (native.isFailure(result)) {
717 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
719 native.callIfPossible(args.successCallback);
723 var result = native.call(
724 'BluetoothLEDevice_disconnect',
725 { address: this.address },
728 if (native.isFailure(result)) {
729 throw native.getErrorObject(result);
733 BluetoothLEDevice.prototype.getService = function() {
734 privUtils_.log('Entered BluetoothLEDevice.getService()');
735 var args = AV.validateMethod(arguments, [
738 type: AV.Types.STRING
744 address: this.address
747 var result = native.callSync('BluetoothLEDevice_getService', callArgs);
748 if (native.isFailure(result)) {
749 throw native.getErrorObject(result);
751 return new BluetoothGATTService(native.getResultObject(result));
755 BluetoothLEDevice.prototype.getServiceAllUuids = function() {
756 privUtils_.log('Entered BluetoothLEDevice.getServiceAllUuids()');
759 address: this.address
762 var result = native.callSync('BluetoothLEDevice_getServiceAllUuids', callArgs);
763 if (native.isFailure(result)) {
764 throw native.getErrorObject(result);
766 var uuids = native.getResultObject(result);
771 BluetoothLEDevice.prototype.addConnectStateChangeListener = function() {
772 privUtils_.log('Entered BluetoothLEDevice.addConnectStateChangeListener()');
773 var args = AV.validateMethod(arguments, [
776 type: AV.Types.LISTENER,
777 values: ['onconnected', 'ondisconnected']
783 var func = function(event) {
784 if (event.address === that.address && args.listener[event.action]) {
785 args.listener[event.action](that);
789 var watchId = _bleConnectChangeListener.addListener(func);
794 BluetoothLEDevice.prototype.removeConnectStateChangeListener = function() {
795 privUtils_.log('Entered BluetoothLEDevice.removeConnectStateChangeListener()');
797 var args = AV.validateMethod(arguments, [
804 _bleConnectChangeListener.removeListener(args.watchID);
807 // class BluetoothDevice //////////////////////////
808 var BluetoothDevice = function(data) {
810 function _getter(field) {
813 callArgs.address = self.address;
814 callArgs.field = field;
816 var result = native.callSync('BluetoothDevice_getBoolValue', callArgs);
818 if (native.isFailure(result)) {
821 return native.getResultObject(result);
825 function isBondedGetter() {
826 return _getter('isBonded');
829 function isTrustedGetter() {
830 return _getter('isTrusted');
833 function isConnectedGetter() {
834 return _getter('isConnected');
842 Object.defineProperties(this, {
843 name: { value: data.name, writable: false, enumerable: true },
844 address: { value: data.address, writable: false, enumerable: true },
846 value: new BluetoothClass(data.deviceClass),
863 get: isConnectedGetter
869 return uuids.slice();
875 BluetoothDevice.prototype.connectToServiceByUUID = function() {
876 privUtils_.log('Entered BluetoothDevice.connectToServiceByUUID()');
878 var args = AV.validateMethod(arguments, [
881 type: AV.Types.STRING
884 name: 'successCallback',
885 type: AV.Types.FUNCTION
888 name: 'errorCallback',
889 type: AV.Types.FUNCTION,
896 address: this.address,
899 var callback = function(result) {
900 if (native.isFailure(result)) {
901 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
903 args.successCallback(new BluetoothSocket(native.getResultObject(result)));
907 var result = native.call(
908 'BluetoothDevice_connectToServiceByUUID',
912 if (native.isFailure(result)) {
913 throw native.getErrorObject(result);
917 // class BluetoothServiceHandler //////////////////////////
918 function BluetoothServiceListeners() {
920 this.serviceCallback = function(data) {
922 var service = that.services[e.uuid];
923 var result = new BluetoothSocket(e);
926 privUtils_.log(service);
927 service.onconnect(result);
932 BluetoothServiceListeners.prototype.services = {};
934 BluetoothServiceListeners.prototype.addListener = function(service) {
935 if (T.isEmptyObject(this.services)) {
936 native.addListener('BLUETOOTH_SERVICE_ONCONNECT', this.serviceCallback);
939 this.services[service.uuid] = service;
942 BluetoothServiceListeners.prototype.removeListener = function(uuid) {
943 delete this.services[uuid];
945 if (T.isEmptyObject(this.services)) {
946 native.removeListener('BLUETOOTH_SERVICE_ONCONNECT', this.serviceCallback);
950 var _bluetoothServiceListeners = new BluetoothServiceListeners();
952 var BluetoothServiceHandler = function(data) {
953 function isConnectedGetter() {
958 var result = native.callSync('BluetoothAdapter_isServiceConnected', {
962 if (native.isFailure(result)) {
965 return native.getResultObject(result);
969 Object.defineProperties(this, {
970 uuid: { value: data.uuid, writable: false, enumerable: true },
971 name: { value: data.name, writable: false, enumerable: true },
975 get: isConnectedGetter
977 onconnect: { value: null, writable: true, enumerable: true }
980 _bluetoothServiceListeners.addListener(this);
983 BluetoothServiceHandler.prototype.unregister = function() {
984 privUtils_.log('Entered BluetoothServiceHandler.unregister()');
985 var args = AV.validateMethod(arguments, [
987 name: 'successCallback',
988 type: AV.Types.FUNCTION,
993 name: 'errorCallback',
994 type: AV.Types.FUNCTION,
1004 var callback = function(result) {
1005 if (native.isFailure(result)) {
1006 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
1008 native.callIfPossible(args.successCallback);
1012 var result = native.call('BluetoothServiceHandler_unregister', callArgs, callback);
1013 if (native.isFailure(result)) {
1014 throw native.getErrorObject(result);
1017 _bluetoothServiceListeners.removeListener(this.uuid);
1020 // class BluetoothHealthApplication //////////////////////////
1021 function BluetoothHealthApplicationListeners() {
1023 this.appCallback = function(data) {
1025 var app = that.apps[event.id];
1028 var callback = app[event.event];
1029 if (T.isFunction(callback)) {
1031 switch (event.event) {
1033 param = new BluetoothHealthChannel(native.getResultObject(event));
1037 privUtils_.log('Unknown event: ' + event.event);
1043 privUtils_.log('Received event for an unknown application: ' + event.id);
1048 BluetoothHealthApplicationListeners.prototype.apps = {};
1050 BluetoothHealthApplicationListeners.prototype.addListener = function(app) {
1051 if (T.isEmptyObject(this.apps)) {
1052 native.addListener('BLUETOOTH_HEALTH_APPLICATION_CHANGED', this.appCallback);
1055 this.apps[app._id] = app;
1058 BluetoothHealthApplicationListeners.prototype.removeListener = function(id) {
1059 delete this.apps[id];
1061 if (T.isEmptyObject(this.apps)) {
1062 native.removeListener('BLUETOOTH_HEALTH_APPLICATION_CHANGED', this.appCallback);
1066 var _bluetoothHealthApplicationListeners = new BluetoothHealthApplicationListeners();
1068 var BluetoothHealthApplication = function(data) {
1069 Object.defineProperties(this, {
1070 dataType: { value: data.dataType, writable: false, enumerable: true },
1071 name: { value: data.name, writable: false, enumerable: true },
1072 onconnect: { value: null, writable: true, enumerable: true },
1073 _id: { value: data._id, writable: false, enumerable: false }
1076 _bluetoothHealthApplicationListeners.addListener(this);
1079 BluetoothHealthApplication.prototype.unregister = function() {
1080 privUtils_.log('Entered BluetoothHealthApplication.unregister()');
1081 var args = AV.validateMethod(arguments, [
1083 name: 'successCallback',
1084 type: AV.Types.FUNCTION,
1089 name: 'errorCallback',
1090 type: AV.Types.FUNCTION,
1096 var callArgs = { id: this._id };
1098 var callback = function(result) {
1099 if (native.isFailure(result)) {
1100 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
1102 native.callIfPossible(args.successCallback);
1106 var result = native.call('BluetoothHealthApplication_unregister', callArgs, callback);
1107 if (native.isFailure(result)) {
1108 throw native.getErrorObject(result);
1111 _bluetoothHealthApplicationListeners.removeListener(this._id);
1114 // class BluetoothProfileHandler //////////////////////////
1115 var _BluetoothProfileType = {
1119 var BluetoothProfileHandler = function(data) {
1121 Object.defineProperties(this, {
1122 profileType: { value: data.profileType, writable: false, enumerable: true }
1127 // class BluetoothHealthProfileHandler //////////////////////////
1128 var BluetoothHealthProfileHandler = function(data) {
1129 BluetoothProfileHandler.call(this, data);
1132 BluetoothHealthProfileHandler.prototype = new BluetoothProfileHandler();
1134 BluetoothHealthProfileHandler.prototype.constructor = BluetoothProfileHandler;
1136 BluetoothHealthProfileHandler.prototype.registerSinkApplication = function() {
1137 privUtils_.log('Entered BluetoothHealthProfileHandler.registerSinkApplication()');
1139 var args = AV.validateMethod(arguments, [
1142 type: AV.Types.LONG // there's no short type
1146 type: AV.Types.STRING
1149 name: 'successCallback',
1150 type: AV.Types.FUNCTION
1153 name: 'errorCallback',
1154 type: AV.Types.FUNCTION,
1161 dataType: args.dataType,
1165 var callback = function(result) {
1166 if (native.isFailure(result)) {
1167 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
1169 args.successCallback(
1170 new BluetoothHealthApplication(native.getResultObject(result))
1175 var result = native.call(
1176 'BluetoothHealthProfileHandler_registerSinkApp',
1180 if (native.isFailure(result)) {
1181 throw native.getErrorObject(result);
1185 BluetoothHealthProfileHandler.prototype.connectToSource = function() {
1186 privUtils_.log('Entered BluetoothHealthProfileHandler.connectToSource()');
1188 var args = AV.validateMethod(arguments, [
1191 type: AV.Types.PLATFORM_OBJECT,
1192 values: BluetoothDevice
1195 name: 'application',
1196 type: AV.Types.PLATFORM_OBJECT,
1197 values: BluetoothHealthApplication
1200 name: 'successCallback',
1201 type: AV.Types.FUNCTION
1204 name: 'errorCallback',
1205 type: AV.Types.FUNCTION,
1212 address: args.peer.address,
1213 appId: args.application._id
1216 var callback = function(result) {
1217 if (native.isFailure(result)) {
1218 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
1220 var channel = native.getResultObject(result);
1221 channel.peer = args.peer;
1222 channel.appId = args.application._id;
1223 args.successCallback(new BluetoothHealthChannel(channel));
1227 var result = native.call(
1228 'BluetoothHealthProfileHandler_connectToSource',
1232 if (native.isFailure(result)) {
1233 throw native.getErrorObject(result);
1237 // class BluetoothHealthChannel //////////////////////////
1238 var BluetoothHealthChannel = function(data) {
1239 Object.defineProperties(this, {
1240 peer: { value: data.peer, writable: false, enumerable: true },
1241 channelType: { value: data.channelType, writable: false, enumerable: true },
1243 value: _bluetoothHealthApplicationListeners.apps[data.appId],
1248 value: data.isConnected,
1253 _id: { value: data._id, writable: false, enumerable: false }
1257 BluetoothHealthChannel.prototype.close = function() {
1258 privUtils_.log('Entered BluetoothHealthChannel.close()');
1260 if (this.isConnected) {
1263 address: this.peer.address
1266 var result = native.callSync('BluetoothHealthChannel_close', callArgs);
1268 if (native.isFailure(result)) {
1269 throw native.getErrorObject(result);
1272 Object.defineProperty(this, 'isConnected', { value: false });
1276 BluetoothHealthChannel.prototype.sendData = function() {
1277 privUtils_.log('Entered BluetoothHealthChannel.sendData()');
1278 var args = AV.validateMethod(arguments, [
1281 type: AV.Types.ARRAY,
1282 values: AV.Types.BYTE
1291 var result = native.callSync('BluetoothHealthChannel_sendData', callArgs);
1293 if (native.isFailure(result)) {
1294 throw native.getErrorObject(result);
1296 return native.getResultObject(result);
1300 var _healthListeners = {};
1302 function _BluetoothHealthChannelChangeCallback(event) {
1304 var callback = _healthListeners[e.id];
1316 privUtils_.log('Unknown mode: ' + e.event);
1320 if (callback[e.event]) {
1321 callback[e.event](d);
1325 var BluetoothHealthChannel_setListener = function() {
1326 privUtils_.log('Entered BluetoothHealthChannel.setListener()');
1327 privUtils_.checkPrivilegeAccess4Ver(
1329 Privilege.BLUETOOTH,
1330 Privilege.BLUETOOTH_HEALTH
1332 var args = AV.validateMethod(arguments, [
1334 name: 'changeCallback',
1335 type: AV.Types.LISTENER,
1336 values: ['onmessage', 'onclose']
1340 if (T.isEmptyObject(_healthListeners)) {
1342 'BluetoothHealthChannelChangeCallback',
1343 _BluetoothHealthChannelChangeCallback
1346 _healthListeners[this._id] = args.changeCallback;
1349 BluetoothHealthChannel.prototype.setListener = function() {
1350 BluetoothHealthChannel_setListener.apply(this, arguments);
1353 var BluetoothHealthChannel_unsetListener = function() {
1354 privUtils_.log('Entered BluetoothHealthChannel.unsetListener ()');
1355 if (T.isEmptyObject(_healthListeners)) {
1356 privUtils_.checkPrivilegeAccess4Ver(
1358 Privilege.BLUETOOTH,
1359 Privilege.BLUETOOTH_HEALTH
1363 delete _healthListeners[this._id];
1365 if (T.isEmptyObject(_healthListeners)) {
1366 native.removeListener(
1367 'BluetoothHealthChannelChangeCallback',
1368 _BluetoothHealthChannelChangeCallback
1373 BluetoothHealthChannel.prototype.unsetListener = function() {
1374 BluetoothHealthChannel_unsetListener.apply(this, arguments);
1378 * Creates a manager for specified listener event.
1380 * @param {string} name - name of the listener this manager handles
1381 * @param {function} callback - function to be invoked when event specified by the name
1383 * This function should return false if the callback
1384 * doesn't want to handle the event anymore, true otherwise.
1385 * This function should have following signature:
1386 * bool callback(event, successCallback, errorCallback);
1388 * @return {object} object which allows to add or remove callbacks for specified listener
1390 function _singleListenerBuilder(name, callback) {
1391 var listenerName = name;
1392 var successCallback;
1394 var callbackFunction = callback;
1395 var listenerRegistered = false;
1397 function innerCallback(event) {
1398 if (!callbackFunction(event, successCallback, errorCallback)) {
1403 function addListener(s, e) {
1404 successCallback = s;
1407 if (!listenerRegistered) {
1408 native.addListener(listenerName, innerCallback);
1409 listenerRegistered = true;
1413 function removeListener() {
1414 if (listenerRegistered) {
1415 native.removeListener(listenerName, innerCallback);
1416 listenerRegistered = false;
1419 successCallback = undefined;
1420 errorCallback = undefined;
1424 addListener: addListener,
1425 removeListener: removeListener
1429 var _bleScanListener = _singleListenerBuilder('BluetoothLEScanCallback', function(
1437 switch (event.action) {
1439 d = new BluetoothLEDevice(event.data);
1443 if (errorCallback) {
1444 errorCallback(native.getErrorObject(event));
1449 privUtils_.log('Unknown mode: ' + event.action);
1452 if (successCallback) {
1459 var _bleAdvertiseListener = _singleListenerBuilder(
1460 'BluetoothLEAdvertiseCallback',
1461 function(event, successCallback, errorCallback) {
1465 switch (event.action) {
1467 if (successCallback) {
1468 successCallback(native.getResultObject(event));
1469 if (native.getResultObject(event) == 'STOPPED') {
1470 _bleAdvertiseListener.removeListener();
1476 if (errorCallback) {
1477 errorCallback(native.getErrorObject(event));
1482 privUtils_.log('Unknown mode: ' + event.action);
1488 //class BluetoothLEAdapter //////////////////////////
1489 var BluetoothLEAdapter = function() {};
1491 BluetoothLEAdapter.prototype.startScan = function() {
1492 privUtils_.log('Entered BluetoothLEAdapter.startScan()');
1493 var args = AV.validateMethod(arguments, [
1495 name: 'successCallback',
1496 type: AV.Types.FUNCTION
1499 name: 'errorCallback',
1500 type: AV.Types.FUNCTION,
1506 var result = native.callSync('BluetoothLEAdapter_startScan', {});
1507 if (native.isFailure(result)) {
1508 throw native.getErrorObject(result);
1511 _bleScanListener.addListener(args.successCallback, args.errorCallback);
1514 BluetoothLEAdapter.prototype.stopScan = function() {
1515 privUtils_.log('Entered BluetoothLEAdapter.stopScan()');
1517 _bleScanListener.removeListener();
1519 var result = native.callSync('BluetoothLEAdapter_stopScan', {});
1520 if (native.isFailure(result)) {
1521 throw native.getErrorObject(result);
1525 var _BluetoothAdvertisePacketType = {
1526 ADVERTISE: 'ADVERTISE',
1527 SCAN_RESPONSE: 'SCAN_RESPONSE'
1530 var _BluetoothAdvertisingMode = {
1531 BALANCED: 'BALANCED',
1532 LOW_LATENCY: 'LOW_LATENCY',
1533 LOW_ENERGY: 'LOW_ENERGY'
1536 BluetoothLEAdapter.prototype.startAdvertise = function() {
1537 privUtils_.log('Entered BluetoothLEAdapter.startAdvertise()');
1538 var args = AV.validateMethod(arguments, [
1540 name: 'advertiseData',
1541 type: AV.Types.PLATFORM_OBJECT,
1542 values: tizen.BluetoothLEAdvertiseData
1546 type: AV.Types.ENUM,
1547 values: T.getValues(_BluetoothAdvertisePacketType)
1550 name: 'successCallback',
1551 type: AV.Types.FUNCTION
1554 name: 'errorCallback',
1555 type: AV.Types.FUNCTION,
1561 type: AV.Types.ENUM,
1562 values: T.getValues(_BluetoothAdvertisingMode),
1567 name: 'connectable',
1568 type: AV.Types.BOOLEAN,
1575 advertiseData: args.advertiseData,
1576 packetType: args.packetType,
1577 mode: T.isNullOrUndefined(args.mode)
1578 ? _BluetoothAdvertisingMode.BALANCED
1580 connectable: T.isNullOrUndefined(args.connectable) ? true : args.connectable
1583 var result = native.callSync('BluetoothLEAdapter_startAdvertise', callArgs);
1585 if (native.isFailure(result)) {
1586 throw native.getErrorObject(result);
1589 _bleAdvertiseListener.addListener(args.successCallback, args.errorCallback);
1592 BluetoothLEAdapter.prototype.stopAdvertise = function() {
1593 privUtils_.log('Entered BluetoothLEAdapter.stopAdvertise()');
1595 var result = native.callSync('BluetoothLEAdapter_stopAdvertise', {});
1597 if (native.isFailure(result)) {
1598 throw native.getErrorObject(result);
1602 //class BluetoothGATTService //////////////////////////
1603 var BluetoothGATTService = function(data, address) {
1604 var handle_ = data.handle;
1605 var uuid_ = data.uuid;
1606 //address_ is needed to control if device is still connected
1607 var address_ = address || data.address;
1608 function servicesGetter() {
1610 var result = native.callSync('BluetoothGATTService_getServices', {
1614 if (native.isSuccess(result)) {
1615 var resultObject = native.getResultObject(result);
1616 resultObject.forEach(function(s) {
1617 services.push(new BluetoothGATTService(s, address_));
1622 function characteristicsGetter() {
1623 var characteristics = [];
1624 var result = native.callSync('BluetoothGATTService_getCharacteristics', {
1629 if (native.isSuccess(result)) {
1630 var resultObject = native.getResultObject(result);
1631 resultObject.forEach(function(c) {
1632 characteristics.push(new BluetoothGATTCharacteristic(c, address_));
1635 return characteristics;
1637 Object.defineProperties(this, {
1638 uuid: { value: uuid_, writable: false, enumerable: true },
1639 services: { enumerable: true, set: function() {}, get: servicesGetter },
1643 get: characteristicsGetter
1648 var toByteArray = function(array) {
1651 array.forEach(function(b) {
1652 d.push(Converter.toOctet(b));
1657 //class BluetoothGATTCharacteristic //////////////////////////
1658 var BluetoothGATTCharacteristic = function(data, address) {
1659 var handle_ = data.handle;
1660 var descriptors_ = [];
1661 var isBroadcast_ = false;
1662 var hasExtendedProperties_ = false;
1663 var isNotify_ = false;
1664 var isIndication_ = false;
1665 var isReadable_ = false;
1666 var isSignedWrite_ = false;
1667 var isWritable_ = false;
1668 var isWriteNoResponse_ = false;
1669 //address_ is needed to control if device is still connected
1670 var address_ = address;
1672 if (T.isObject(data)) {
1673 data.descriptors.forEach(function(dd) {
1674 descriptors_.push(new BluetoothGATTDescriptor(dd, address_));
1676 isBroadcast_ = data.isBroadcast;
1677 hasExtendedProperties_ = data.hasExtendedProperties;
1678 isNotify_ = data.isNotify;
1679 isIndication_ = data.isIndication;
1680 isReadable_ = data.isReadable;
1681 isSignedWrite_ = data.isSignedWrite;
1682 isWritable_ = data.isWritable;
1683 isWriteNoResponse_ = data.isWriteNoResponse;
1686 Object.defineProperties(this, {
1690 return descriptors_.slice();
1697 return isBroadcast_;
1701 hasExtendedProperties: {
1704 return hasExtendedProperties_;
1718 return isIndication_;
1732 return isSignedWrite_;
1743 isWriteNoResponse: {
1746 return isWriteNoResponse_;
1752 this.readValue = function() {
1753 privUtils_.log('Entered BluetoothGATTCharacteristic.readValue()');
1754 var args = AV.validateMethod(arguments, [
1756 name: 'successCallback',
1757 type: AV.Types.FUNCTION
1760 name: 'errorCallback',
1761 type: AV.Types.FUNCTION,
1767 var callback = function(result) {
1768 if (native.isFailure(result)) {
1769 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
1771 var d = toByteArray(native.getResultObject(result));
1772 args.successCallback(d);
1776 var callArgs = { handle: handle_, address: address_ };
1778 var result = native.call('BluetoothGATT_readValue', callArgs, callback);
1780 if (native.isFailure(result)) {
1781 throw native.getErrorObject(result);
1785 this.writeValue = function() {
1786 privUtils_.log('Entered BluetoothGATTCharacteristic.writeValue()');
1787 var args = AV.validateMethod(arguments, [
1790 type: AV.Types.ARRAY,
1791 values: AV.Types.BYTE
1794 name: 'successCallback',
1795 type: AV.Types.FUNCTION,
1800 name: 'errorCallback',
1801 type: AV.Types.FUNCTION,
1807 var callback = function(result) {
1808 if (native.isFailure(result)) {
1809 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
1811 native.callIfPossible(args.successCallback);
1817 value: toByteArray(args.value),
1821 var result = native.call('BluetoothGATT_writeValue', callArgs, callback);
1823 if (native.isFailure(result)) {
1824 throw native.getErrorObject(result);
1828 var addValueChangeListener = function() {
1829 privUtils_.log('Entered BluetoothGATTCharacteristic.addValueChangeListener()');
1830 privUtils_.checkPrivilegeAccess4Ver(
1832 Privilege.BLUETOOTH,
1833 Privilege.BLUETOOTH_ADMIN
1835 var args = AV.validateMethod(arguments, [
1838 type: AV.Types.FUNCTION
1842 var callArgs = { handle: handle_, address: address_ };
1844 var callback = function(event) {
1845 if (event.handle === handle_) {
1846 args.callback(toByteArray(native.getResultObject(event)));
1850 return _bluetoothGATTCharacteristicListener.addListener(callback, callArgs);
1853 this.addValueChangeListener = function() {
1854 return addValueChangeListener.apply(this, arguments);
1857 this.removeValueChangeListener = function() {
1858 privUtils_.log('Entered BluetoothGATTCharacteristic.removeValueChangeListener()');
1860 var args = AV.validateMethod(arguments, [
1867 var callArgs = { handle: handle_, address: address_ };
1869 return _bluetoothGATTCharacteristicListener.removeListener(
1877 * Creates a manager for specified listener event. Manager handles multiple
1878 * registered listeners
1880 * @param {string} name - name of the listener this manager handles
1881 * @param {function} callback - function to be invoked when event specified by the name
1883 * This function should have following signature:
1884 * void callback(listener, event);
1885 * @param {string} addListenerId - optional parameter. If specified, this native
1886 * method will be called synchronously when
1887 * listener is added.
1888 * @param {string} removeListenerId - optional parameter. If specified, this native
1889 * method will be called synchronously when
1890 * listener is removed.
1891 * @param {bool} repeatNativeCall - optional parameter. If specified, the addListenerId
1892 * and removeListenerId methods will be called
1893 * synchronously each time listener is added/removed.
1894 * Otherwise they are going to be called just once: when
1895 * first listener is added and last listener is removed.
1897 * @return {object} object which allows to add or remove callbacks for specified listener
1899 function _multipleListenerBuilder(
1906 var listenerName = name;
1907 var addId = addListenerId;
1908 var removeId = removeListenerId;
1909 var callbackFunction = callback;
1912 var jsListenerRegistered = false;
1913 var nativeListenerRegistered = false;
1914 var repeatNativeListenerCall = repeatNativeCall;
1916 function innerCallback(event) {
1917 for (var watchId in listeners) {
1918 if (listeners.hasOwnProperty(watchId)) {
1919 callbackFunction(listeners[watchId], event);
1924 function addListener(callback, args) {
1927 if (addId && (!nativeListenerRegistered || repeatNativeListenerCall)) {
1928 var result = native.callSync(addId, args || {});
1929 if (native.isFailure(result)) {
1930 throw native.getErrorObject(result);
1932 nativeListenerRegistered = true;
1935 if (!jsListenerRegistered) {
1936 native.addListener(listenerName, innerCallback);
1937 jsListenerRegistered = true;
1940 listeners[id] = callback;
1944 function removeListener(watchId, args) {
1945 if (listeners.hasOwnProperty(watchId)) {
1946 delete listeners[watchId];
1951 ((nativeListenerRegistered && T.isEmptyObject(listeners)) ||
1952 repeatNativeListenerCall)
1954 var result = native.callSync(removeId, args || {});
1955 if (native.isFailure(result)) {
1956 throw native.getErrorObject(result);
1958 nativeListenerRegistered = false;
1961 if (jsListenerRegistered && T.isEmptyObject(listeners)) {
1962 native.removeListener(listenerName, innerCallback);
1963 jsListenerRegistered = false;
1968 addListener: addListener,
1969 removeListener: removeListener
1973 var _bluetoothGATTCharacteristicListener = _multipleListenerBuilder(
1974 'BluetoothGATTCharacteristicValueChangeListener',
1975 function(listener, event) {
1978 'BluetoothGATTCharacteristic_addValueChangeListener',
1979 'BluetoothGATTCharacteristic_removeValueChangeListener',
1983 var _bleConnectChangeListener = _multipleListenerBuilder(
1984 'BluetoothLEConnectChangeCallback',
1985 function(listener, event) {
1988 'BluetoothLEDevice_addConnectStateChangeListener',
1989 'BluetoothLEDevice_removeConnectStateChangeListener'
1992 //class BluetoothGATTDescriptor //////////////////////////
1993 var BluetoothGATTDescriptor = function(data, address) {
1994 var handle_ = data.handle;
1995 //address_ is needed to control if device is still connected
1996 var address_ = address;
1998 this.readValue = function() {
1999 privUtils_.log('Entered BluetoothGATTDescriptor.readValue()');
2000 var args = AV.validateMethod(arguments, [
2002 name: 'successCallback',
2003 type: AV.Types.FUNCTION
2006 name: 'errorCallback',
2007 type: AV.Types.FUNCTION,
2013 var callback = function(result) {
2014 if (native.isFailure(result)) {
2015 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2017 var d = toByteArray(native.getResultObject(result));
2018 args.successCallback(d);
2022 var callArgs = { handle: handle_, address: address_ };
2024 var result = native.call('BluetoothGATT_readValue', callArgs, callback);
2026 if (native.isFailure(result)) {
2027 throw native.getErrorObject(result);
2031 this.writeValue = function() {
2032 privUtils_.log('Entered BluetoothGATTDescriptor.writeValue()');
2033 var args = AV.validateMethod(arguments, [
2036 type: AV.Types.ARRAY,
2037 values: AV.Types.BYTE
2040 name: 'successCallback',
2041 type: AV.Types.FUNCTION,
2046 name: 'errorCallback',
2047 type: AV.Types.FUNCTION,
2053 var callback = function(result) {
2054 if (native.isFailure(result)) {
2055 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2057 native.callIfPossible(args.successCallback);
2063 value: toByteArray(args.value),
2067 var result = native.call('BluetoothGATT_writeValue', callArgs, callback);
2069 if (native.isFailure(result)) {
2070 throw native.getErrorObject(result);
2075 // class BluetoothAdapter //////////////////////////
2076 var BluetoothAdapter = function() {
2077 function nameGetter() {
2078 var result = native.callSync('BluetoothAdapter_getName', {});
2080 if (native.isFailure(result)) {
2083 return native.getResultObject(result);
2087 function addressGetter() {
2088 var result = native.callSync('BluetoothAdapter_getAddress', {});
2090 if (native.isFailure(result)) {
2093 return native.getResultObject(result);
2097 function poweredGetter() {
2098 var result = native.callSync('BluetoothAdapter_getPowered', {});
2100 if (native.isFailure(result)) {
2103 return native.getResultObject(result);
2107 function visibleGetter() {
2108 var result = native.callSync('BluetoothAdapter_getVisible', {});
2110 if (native.isFailure(result)) {
2113 return native.getResultObject(result);
2117 Object.defineProperties(this, {
2141 BluetoothAdapter.prototype.setName = function() {
2142 privUtils_.log('Entered BluetoothAdapter.setName()');
2143 var args = AV.validateMethod(arguments, [
2146 type: AV.Types.STRING
2149 name: 'successCallback',
2150 type: AV.Types.FUNCTION,
2155 name: 'errorCallback',
2156 type: AV.Types.FUNCTION,
2166 var callback = function(result) {
2167 if (native.isFailure(result)) {
2168 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2170 native.callIfPossible(args.successCallback);
2174 var result = native.call('BluetoothAdapter_setName', callArgs, callback);
2175 if (native.isFailure(result)) {
2176 throw native.getErrorObject(result);
2180 BluetoothAdapter.prototype.setPowered = function() {
2181 privUtils_.log('Entered BluetoothAdapter.setPowered()');
2183 'DEPRECATION WARNING: setPowered() is deprecated and will be removed from ' +
2184 'next release. Let the user turn on/off Bluetooth through the Settings ' +
2185 'application instead.'
2188 var args = AV.validateMethod(arguments, [
2191 type: AV.Types.BOOLEAN
2194 name: 'successCallback',
2195 type: AV.Types.FUNCTION,
2200 name: 'errorCallback',
2201 type: AV.Types.FUNCTION,
2208 powered: args.powered
2211 var callback = function(result) {
2212 if (native.isFailure(result)) {
2213 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2215 native.callIfPossible(args.successCallback);
2219 var result = native.call('BluetoothAdapter_setPowered', callArgs, callback);
2220 if (native.isFailure(result)) {
2221 throw native.getErrorObject(result);
2225 // This method is deprecated since Tizen 2.3 and will be removed in Tizen 3.0.
2226 BluetoothAdapter.prototype.setVisible = function() {
2227 privUtils_.log('Entered BluetoothAdapter.setVisible()');
2229 'DEPRECATION WARNING: setVisible() is deprecated and will be removed from ' +
2230 'next release. Let the user change the Bluetooth visibility through the ' +
2231 'Settings application instead.'
2234 var args = AV.validateMethod(arguments, [
2237 type: AV.Types.BOOLEAN
2240 name: 'successCallback',
2241 type: AV.Types.FUNCTION,
2246 name: 'errorCallback',
2247 type: AV.Types.FUNCTION,
2253 type: AV.Types.UNSIGNED_LONG,
2260 visible: args.visible
2263 if (args.visible === true) {
2264 if (T.isNullOrUndefined(args.timeout)) {
2265 callArgs.timeout = 0;
2267 callArgs.timeout = args.timeout > 65535 ? 180 : args.timeout;
2271 var callback = function(result) {
2272 if (native.isFailure(result)) {
2273 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2275 native.callIfPossible(args.successCallback);
2279 var result = native.call('BluetoothAdapter_setVisible', callArgs, callback);
2280 if (native.isFailure(result)) {
2281 throw native.getErrorObject(result);
2287 function _BluetoothAdapterChangeCallback(event) {
2288 privUtils_.log('_BluetoothAdapterChangeCallback');
2294 case 'onstatechanged':
2298 case 'onnamechanged':
2302 case 'onvisibilitychanged':
2307 privUtils_.log('Unknown mode: ' + e.action);
2311 if (_listener[e.action]) {
2312 _listener[e.action](d);
2316 BluetoothAdapter.prototype.setChangeListener = function() {
2317 privUtils_.log('Entered BluetoothAdapter.setChangeListener()');
2318 var args = AV.validateMethod(arguments, [
2320 name: 'changeCallback',
2321 type: AV.Types.LISTENER,
2322 values: ['onstatechanged', 'onnamechanged', 'onvisibilitychanged']
2326 if (T.isNullOrUndefined(_listener)) {
2328 'BluetoothAdapterChangeCallback',
2329 _BluetoothAdapterChangeCallback
2332 _listener = args.changeCallback;
2335 BluetoothAdapter.prototype.unsetChangeListener = function() {
2336 privUtils_.log('Entered BluetoothAdapter.unsetChangeListener()');
2337 if (!T.isNullOrUndefined(_listener)) {
2338 native.removeListener(
2339 'BluetoothAdapterChangeCallback',
2340 _BluetoothAdapterChangeCallback
2342 _listener = undefined;
2346 var _discoverDevicesSuccessCallback;
2347 var _discoverDevicesErrorCallback;
2349 function _BluetoothDiscoverDevicesSuccessCallback(event) {
2357 case 'ondevicefound':
2358 d = new BluetoothDevice(e.data);
2361 case 'ondevicedisappeared':
2366 var result = e.data;
2368 result.forEach(function(data) {
2369 d.push(new BluetoothDevice(data));
2372 //remove listeners after discovering
2373 native.removeListener(
2374 'BluetoothDiscoverDevicesSuccessCallback',
2375 _BluetoothDiscoverDevicesSuccessCallback
2377 native.removeListener(
2378 'BluetoothDiscoverDevicesErrorCallback',
2379 _BluetoothDiscoverDevicesErrorCallback
2384 privUtils_.log('Unknown mode: ' + e.action);
2388 if (_discoverDevicesSuccessCallback[e.action]) {
2389 _discoverDevicesSuccessCallback[e.action](d);
2393 function _BluetoothDiscoverDevicesErrorCallback(event) {
2395 setTimeout(function() {
2396 native.callIfPossible(_discoverDevicesErrorCallback, native.getErrorObject(e));
2400 BluetoothAdapter.prototype.discoverDevices = function() {
2401 privUtils_.log('Entered BluetoothAdapter.discoverDevices()');
2402 var args = AV.validateMethod(arguments, [
2404 name: 'successCallback',
2405 type: AV.Types.LISTENER,
2406 values: ['onstarted', 'ondevicefound', 'ondevicedisappeared', 'onfinished']
2409 name: 'errorCallback',
2410 type: AV.Types.FUNCTION,
2416 _discoverDevicesSuccessCallback = args.successCallback;
2417 _discoverDevicesErrorCallback = args.errorCallback;
2419 'BluetoothDiscoverDevicesSuccessCallback',
2420 _BluetoothDiscoverDevicesSuccessCallback
2423 'BluetoothDiscoverDevicesErrorCallback',
2424 _BluetoothDiscoverDevicesErrorCallback
2427 var result = native.callSync('BluetoothAdapter_discoverDevices', {});
2429 if (native.isFailure(result)) {
2430 native.removeListener(
2431 'BluetoothDiscoverDevicesSuccessCallback',
2432 _BluetoothDiscoverDevicesSuccessCallback
2434 native.removeListener(
2435 'BluetoothDiscoverDevicesErrorCallback',
2436 _BluetoothDiscoverDevicesErrorCallback
2438 throw native.getErrorObject(result);
2442 BluetoothAdapter.prototype.stopDiscovery = function() {
2443 privUtils_.log('Entered BluetoothAdapter.stopDiscovery()');
2444 var args = AV.validateMethod(arguments, [
2446 name: 'successCallback',
2447 type: AV.Types.FUNCTION,
2452 name: 'errorCallback',
2453 type: AV.Types.FUNCTION,
2459 var callback = function(result) {
2460 if (native.isFailure(result)) {
2461 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2463 native.callIfPossible(args.successCallback);
2467 var result = native.call('BluetoothAdapter_stopDiscovery', {}, callback);
2468 if (native.isFailure(result)) {
2469 throw native.getErrorObject(result);
2473 BluetoothAdapter.prototype.getKnownDevices = function() {
2474 privUtils_.log('Entered BluetoothAdapter.getKnownDevices()');
2475 var args = AV.validateMethod(arguments, [
2477 name: 'successCallback',
2478 type: AV.Types.FUNCTION
2481 name: 'errorCallback',
2482 type: AV.Types.FUNCTION,
2488 var callback = function(result) {
2489 if (native.isFailure(result)) {
2490 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2492 var r = native.getResultObject(result).devices;
2494 r.forEach(function(data) {
2495 devices.push(new BluetoothDevice(data));
2497 args.successCallback(devices);
2501 var result = native.call('BluetoothAdapter_getKnownDevices', {}, callback);
2502 if (native.isFailure(result)) {
2503 throw native.getErrorObject(result);
2507 BluetoothAdapter.prototype.getDevice = function() {
2508 privUtils_.log('Entered BluetoothAdapter.getDevice()');
2509 var args = AV.validateMethod(arguments, [
2512 type: AV.Types.STRING
2515 name: 'successCallback',
2516 type: AV.Types.FUNCTION
2519 name: 'errorCallback',
2520 type: AV.Types.FUNCTION,
2526 var callback = function(result) {
2527 if (native.isFailure(result)) {
2528 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2530 args.successCallback(new BluetoothDevice(native.getResultObject(result)));
2534 var result = native.call(
2535 'BluetoothAdapter_getDevice',
2536 { address: args.address },
2539 if (native.isFailure(result)) {
2540 throw native.getErrorObject(result);
2544 BluetoothAdapter.prototype.createBonding = function() {
2545 privUtils_.log('Entered BluetoothAdapter.createBonding()');
2546 var args = AV.validateMethod(arguments, [
2549 type: AV.Types.STRING
2552 name: 'successCallback',
2553 type: AV.Types.FUNCTION,
2558 name: 'errorCallback',
2559 type: AV.Types.FUNCTION,
2566 address: args.address
2569 var callback = function(result) {
2570 if (native.isFailure(result)) {
2571 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2573 args.successCallback(new BluetoothDevice(native.getResultObject(result)));
2577 var result = native.call('BluetoothAdapter_createBonding', callArgs, callback);
2578 if (native.isFailure(result)) {
2579 throw native.getErrorObject(result);
2583 BluetoothAdapter.prototype.destroyBonding = function() {
2584 privUtils_.log('Entered BluetoothAdapter.destroyBonding()');
2585 var args = AV.validateMethod(arguments, [
2588 type: AV.Types.STRING
2591 name: 'successCallback',
2592 type: AV.Types.FUNCTION,
2597 name: 'errorCallback',
2598 type: AV.Types.FUNCTION,
2605 address: args.address
2608 var callback = function(result) {
2609 if (native.isFailure(result)) {
2610 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2612 native.callIfPossible(args.successCallback);
2616 var result = native.call('BluetoothAdapter_destroyBonding', callArgs, callback);
2617 if (native.isFailure(result)) {
2618 throw native.getErrorObject(result);
2622 BluetoothAdapter.prototype.registerRFCOMMServiceByUUID = function() {
2623 privUtils_.log('Entered BluetoothAdapter.registerRFCOMMServiceByUUID()');
2624 var args = AV.validateMethod(arguments, [
2627 type: AV.Types.STRING
2631 type: AV.Types.STRING
2634 name: 'successCallback',
2635 type: AV.Types.FUNCTION
2638 name: 'errorCallback',
2639 type: AV.Types.FUNCTION,
2650 var callback = function(result) {
2651 if (native.isFailure(result)) {
2652 native.callIfPossible(args.errorCallback, native.getErrorObject(result));
2654 // if registration was finished with success create BluetoothServiceHandler
2655 // with parameters passed to this function (uuid and name).
2656 args.successCallback(new BluetoothServiceHandler(callArgs));
2660 var result = native.call(
2661 'BluetoothAdapter_registerRFCOMMServiceByUUID',
2665 if (native.isFailure(result)) {
2666 throw native.getErrorObject(result);
2670 BluetoothAdapter.prototype.getBluetoothProfileHandler = function() {
2671 privUtils_.log('Entered BluetoothAdapter.getBluetoothProfileHandler()');
2673 var args = AV.validateMethod(arguments, [
2675 name: 'profileType',
2676 type: AV.Types.ENUM,
2677 values: T.getValues(_BluetoothProfileType)
2681 var callArgs = { profileType: args.profileType };
2683 var result = native.callSync('BluetoothAdapter_getBluetoothProfileHandler', callArgs);
2685 if (native.isFailure(result)) {
2686 throw native.getErrorObject(result);
2688 switch (args.profileType) {
2689 case _BluetoothProfileType.HEALTH:
2690 return new BluetoothHealthProfileHandler(callArgs);
2693 throw new WebAPIException(
2694 'NotSupportedError',
2695 'Profile ' + args.profileType + ' is not supported.'
2701 // class BluetoothManager //////////////////////////
2702 var BluetoothManager = function() {
2703 Object.defineProperties(this, {
2705 value: new BluetoothClassDeviceMajor(),
2710 value: new BluetoothClassDeviceMinor(),
2715 value: new BluetoothClassDeviceService(),
2722 var BluetoothManager_getDefaultAdapter = function() {
2723 privUtils_.checkPrivilegeAccess4Ver(
2725 Privilege.BLUETOOTH,
2726 Privilege.BLUETOOTH_GAP
2729 return new BluetoothAdapter();
2732 BluetoothManager.prototype.getDefaultAdapter = function() {
2733 privUtils_.log('Entered BluetoothManager.getDefaultAdapter()');
2734 return BluetoothManager_getDefaultAdapter();
2737 var BluetoothManager_getLEAdapter = function() {
2738 privUtils_.checkPrivilegeAccess4Ver(
2740 Privilege.BLUETOOTH,
2741 Privilege.BLUETOOTH_ADMIN
2744 return new BluetoothLEAdapter();
2747 BluetoothManager.prototype.getLEAdapter = function() {
2748 privUtils_.log('Entered BluetoothManager.getLEAdapter()');
2749 return BluetoothManager_getLEAdapter();
2751 // exports /////////////////////////////////////////
2752 exports = new BluetoothManager();