src/nfc/nfc_api.js

   1 /*
   2  * Copyright (c) 2015 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 var privUtils_ = xwalk.utils;
  18 var privilege_ = privUtils_.privilege;
  19 var validator_ = privUtils_.validator;
  20 var types_ = validator_.Types;
  21 var type_ = privUtils_.type;
  22 var converter_ = privUtils_.converter;
  23 var native_ = new xwalk.utils.NativeManager(extension);
  24
  25
  26 var NDEFRecordTextEncoding = {
  27   UTF8: 'UTF8',
  28   UTF16: 'UTF16'
  29 };
  30
  31 var NFCTagType = {
  32   GENERIC_TARGET: 'GENERIC_TARGET',
  33   ISO14443_A: 'ISO14443_A',
  34   ISO14443_4A: 'ISO14443_4A',
  35   ISO14443_3A: 'ISO14443_3A',
  36   MIFARE_MINI: 'MIFARE_MINI',
  37   MIFARE_1K: 'MIFARE_1K',
  38   MIFARE_4K: 'MIFARE_4K',
  39   MIFARE_ULTRA: 'MIFARE_ULTRA',
  40   MIFARE_DESFIRE: 'MIFARE_DESFIRE',
  41   ISO14443_B: 'ISO14443_B',
  42   ISO14443_4B: 'ISO14443_4B',
  43   ISO14443_BPRIME: 'ISO14443_BPRIME',
  44   FELICA: 'FELICA',
  45   JEWEL: 'JEWEL',
  46   ISO15693: 'ISO15693',
  47   UNKNOWN_TARGET: 'UNKNOWN_TARGET'
  48 };
  49
  50 var CardEmulationMode = {
  51   ALWAYS_ON: 'ALWAYS_ON',
  52   OFF: 'OFF'
  53 };
  54
  55 var SecureElementType = {
  56   ESE: 'ESE',
  57   UICC: 'UICC',
  58   HCE: 'HCE'
  59 };
  60
  61 var CardEmulationCategoryType = {
  62   PAYMENT: 'PAYMENT',
  63   OTHER: 'OTHER'
  64 };
  65
  66 var HCEEventType = {
  67   DEACTIVATED: 'DEACTIVATED',
  68   ACTIVATED: 'ACTIVATED',
  69   APDU_RECEIVED: 'APDU_RECEIVED'
  70 };
  71
  72 function HCEEventData(data) {
  73   Object.defineProperties(this, {
  74     eventType: {
  75       value: data.eventType,
  76       writable: false,
  77       enumerable: true
  78     },
  79     apdu: {
  80       value: data.apdu || [],
  81       writable: false,
  82       enumerable: true
  83     },
  84     length: {
  85       value: data.length || 0,
  86       writable: false,
  87       enumerable: true
  88     }
  89   });
  90 }
  91
  92 function ListenerManager(native, listenerName) {
  93   this.listeners = {};
  94   this.nextId = 1;
  95   this.nativeSet = false;
  96   this.native = native;
  97   this.listenerName = listenerName;
  98 }
  99
 100 ListenerManager.prototype.onListenerCalled = function(msg) {
 101   for (var key in this.listeners) {
 102     if (this.listeners.hasOwnProperty(key)) {
 103       if ('CardElement' === msg.type) {
 104         this.listeners[key](msg.mode);
 105       } else if ('Transaction' === msg.type) {
 106         this.listeners[key](msg.aid, msg.data);
 107       } else if('HCEEventData' === msg.type) {
 108         var hceData = new HCEEventData(msg.result);
 109         this.listeners[key](hceData);
 110       }
 111     }
 112   }
 113 };
 114
 115 ListenerManager.prototype.addListener = function(callback) {
 116   var id = this.nextId;
 117   if (!this.nativeSet) {
 118     this.native.addListener(this.listenerName, this.onListenerCalled.bind(this));
 119     this.nativeSet = true;
 120   }
 121   this.listeners[id] = callback;
 122   ++this.nextId;
 123   return id;
 124 };
 125
 126 ListenerManager.prototype.removeListener = function(watchId) {
 127   if (this.listeners.hasOwnProperty(watchId)) {
 128     delete this.listeners[watchId];
 129   }
 130 };
 131
 132 var PEER_LISTENER = 'PeerListener';
 133 var RECEIVE_NDEF_LISTENER = 'ReceiveNDEFListener';
 134 var CARD_EMULATION_MODE_LISTENER = 'CardEmulationModeChanged';
 135 var ACTIVE_SECURE_ELEMENT_LISTENER = 'ActiveSecureElementChanged';
 136 var TRANSACTION_EVENT_ESE_LISTENER = 'TransactionEventListener_ESE';
 137 var TRANSACTION_EVENT_UICC_LISTENER = 'TransactionEventListener_UICC';
 138 var HCE_EVENT_LISTENER = 'HCEEventListener';
 139 var TAG_LISTENER = 'TagListener';
 140 var cardEmulationModeListener = new ListenerManager(native_, CARD_EMULATION_MODE_LISTENER);
 141 var activeSecureElementChangeListener = new ListenerManager(native_, ACTIVE_SECURE_ELEMENT_LISTENER);
 142 var transactionEventListenerEse = new ListenerManager(native_, TRANSACTION_EVENT_ESE_LISTENER);
 143 var transactionEventListenerUicc = new ListenerManager(native_, TRANSACTION_EVENT_UICC_LISTENER);
 144 var HCEEventListener = new ListenerManager(native_, HCE_EVENT_LISTENER);
 145 var isWebkitVisibilityChangeListenerSet = false;
 146
 147 //////////////////NFCManager /////////////////
 148
 149 function NFCManager() {
 150   Object.defineProperties(this, {
 151     NFC_RECORD_TNF_EMPTY: {value: 0, writable: false, enumerable: true},
 152     NFC_RECORD_TNF_WELL_KNOWN: {value: 1, writable: false, enumerable: true},
 153     NFC_RECORD_TNF_MIME_MEDIA: {value: 2, writable: false, enumerable: true},
 154     NFC_RECORD_TNF_URI: {value: 3, writable: false, enumerable: true},
 155     NFC_RECORD_TNF_EXTERNAL_RTD: {value: 4, writable: false, enumerable: true},
 156     NFC_RECORD_TNF_UNKNOWN: {value: 5, writable: false, enumerable: true},
 157     NFC_RECORD_TNF_UNCHANGED: {value: 6, writable: false, enumerable: true}
 158   });
 159 }
 160
 161 NFCManager.prototype.getDefaultAdapter = function() {
 162   // First check NFC suppor on C++ level
 163   var result = native_.callSync(
 164       'NFCManager_getDefaultAdapter',
 165       {}
 166       );
 167   if (native_.isFailure(result)) {
 168     throw native_.getErrorObject(result);
 169   }
 170
 171   // If NFC is supported then return new NFCAdapter instance
 172   return new NFCAdapter();
 173 };
 174
 175 NFCManager.prototype.setExclusiveMode = function() {
 176
 177   var args = validator_.validateArgs(arguments, [
 178     {name: 'exclusiveMode', type: types_.BOOLEAN}
 179   ]);
 180
 181   var result = native_.callSync('NFCManager_setExclusiveMode', {
 182     exclusiveMode: args.exclusiveMode
 183   });
 184
 185   if (native_.isFailure(result)) {
 186     throw native_.getErrorObject(result);
 187   }
 188 };
 189
 190 //////////////////NFCAdapter /////////////////
 191
 192 function NFCAdapter() {
 193   function poweredGetter() {
 194     var ret = native_.callSync('NFCAdapter_getPowered');
 195
 196     if (native_.isFailure(ret)) {
 197       return false;
 198     }
 199
 200     return native_.getResultObject(ret);
 201   }
 202
 203   function cardEmulationModeGetter() {
 204     var result = native_.callSync('NFCAdapter_cardEmulationModeGetter');
 205
 206     if (native_.isFailure(result)) {
 207       throw native_.getErrorObject(result);
 208     }
 209
 210     return native_.getResultObject(result);
 211   }
 212
 213   function cardEmulationModeSetter(cem) {
 214
 215     var args = validator_.validateArgs(arguments, [
 216       {name: 'emulationMode', type: types_.STRING}
 217     ]);
 218
 219     var result = native_.callSync(
 220         'NFCAdapter_cardEmulationModeSetter',
 221         { 'emulationMode': args.emulationMode}
 222         );
 223
 224     if (native_.isFailure(result)) {
 225       throw native_.getErrorObject(result);
 226     }
 227     return;
 228   }
 229
 230   function activeSecureElementGetter() {
 231
 232     var result = native_.callSync('NFCAdapter_activeSecureElementGetter');
 233
 234     if (native_.isFailure(result)) {
 235       throw native_.getErrorObject(result);
 236     }
 237
 238     return native_.getResultObject(result);
 239   }
 240
 241   function activeSecureElementSetter(ase) {
 242
 243     var args = validator_.validateArgs(arguments, [
 244       {name: 'secureElement', type: types_.STRING}
 245     ]);
 246
 247     var result = native_.callSync(
 248         'NFCAdapter_activeSecureElementSetter',
 249         { 'secureElement': args.secureElement}
 250         );
 251
 252     if (native_.isFailure(result)) {
 253       throw native_.getErrorObject(result);
 254     }
 255     return;
 256   }
 257
 258   Object.defineProperties(this, {
 259     powered: {enumerable: true,
 260       set: function() {},
 261       get: poweredGetter
 262     },
 263     cardEmulationMode: {enumerable: true,
 264       set: cardEmulationModeSetter,
 265       get: cardEmulationModeGetter
 266     },
 267     activeSecureElement: {enumerable: true,
 268       set: activeSecureElementSetter,
 269       get: activeSecureElementGetter
 270     }
 271   });
 272 }
 273
 274 NFCAdapter.prototype.setPowered = function() {
 275   privUtils_.warn('DEPRECATION WARNING: setPowered() is deprecated and will be removed from next release. Let the user turn NFC on/off '
 276       + 'through the Settings application instead.');
 277
 278   var args = validator_.validateArgs(arguments, [
 279     {
 280       name: 'powered',
 281       type: types_.BOOLEAN
 282     },
 283     {
 284       name: 'successCallback',
 285       type: types_.FUNCTION,
 286       optional: true,
 287       nullable: true
 288     },
 289     {
 290       name: 'errorCallback',
 291       type: types_.FUNCTION,
 292       optional: true,
 293       nullable: true
 294     }
 295   ]);
 296
 297   var result = native_.call('NFCAdapter_setPowered', {
 298     powered: args.powered
 299   }, function(result) {
 300     if (native_.isFailure(result)) {
 301       args.errorCallback(result.error);
 302     } else {
 303       args.successCallback();
 304     }
 305   });
 306
 307   if (native_.isFailure(result)) {
 308     throw native_.getErrorObject(result);
 309   }
 310 };
 311
 312 function setTagListener() {
 313   var args = validator_.validateArgs(arguments, [
 314     {
 315       name: 'listener',
 316       type: types_.LISTENER,
 317       values: ['onattach', 'ondetach']
 318     },
 319     {
 320       name: 'tagType',
 321       type: types_.ARRAY,
 322       values: types_.STRING,
 323       optional: true,
 324       nullable: true
 325     }
 326   ]);
 327
 328   if (!type_.isNullOrUndefined(args.tagType)) {
 329     for (var i = 0; i < args.tagType.length; i++) {
 330       if (NFCTagType[args.tagType[i]] === undefined) {
 331         throw new WebAPIException(
 332             WebAPIException.TYPE_MISMATCH_ERR, 'Invalid tag type.');
 333       }
 334     }
 335   }
 336
 337   // Listener object creation
 338   var listenerCallback = function(message) {
 339     var tagObject = undefined;
 340
 341     if ('onattach' === message.action) {
 342       tagObject = new NFCTag(message.id);
 343
 344       // If filter is set for listener but tag type is not searched one
 345       if (!type_.isNullOrUndefined(args.tagType) &&
 346           args.tagType.indexOf(tagObject.type) < 0) {
 347         return;
 348       }
 349     }
 350     native_.callIfPossible(args.listener[message.action], tagObject);
 351   };
 352
 353   // Register (acivate) core listener if not done yet
 354   if (!native_.isListenerSet(TAG_LISTENER)) {
 355     var result = native_.callSync('NFCAdapter_setTagListener');
 356     if (native_.isFailure(result)) {
 357       throw native_.getErrorObject(result);
 358     }
 359   }
 360
 361   native_.addListener(TAG_LISTENER, listenerCallback);
 362   return;
 363 };
 364
 365 NFCAdapter.prototype.setTagListener = function() {
 366   setTagListener.apply(this, arguments);
 367 }
 368
 369 function setPeerListener() {
 370   var args = validator_.validateArgs(arguments, [
 371     {
 372       name: 'listener',
 373       type: types_.LISTENER,
 374       values: ['onattach', 'ondetach']
 375     }
 376   ]);
 377
 378   var listener = function(msg) {
 379     var data = undefined;
 380     if ('onattach' === msg.action) {
 381       data = new NFCPeer(msg.id);
 382     }
 383     native_.callIfPossible(args.listener[msg.action], data);
 384   };
 385
 386   if (!native_.isListenerSet(PEER_LISTENER)) {
 387     var result = native_.callSync('NFCAdapter_setPeerListener');
 388     if (native_.isFailure(result)) {
 389       throw native_.getErrorObject(result);
 390     }
 391   }
 392
 393   native_.addListener(PEER_LISTENER, listener);
 394   return;
 395 };
 396
 397 NFCAdapter.prototype.setPeerListener = function() {
 398   setPeerListener.apply(this, arguments);
 399 };
 400
 401 NFCAdapter.prototype.unsetTagListener = function() {
 402
 403   native_.removeListener(TAG_LISTENER);
 404
 405   var result = native_.callSync('NFCAdapter_unsetTagListener');
 406   if (native_.isFailure(result)) {
 407     throw native_.getErrorObject(result);
 408   }
 409
 410   return;
 411 };
 412
 413 NFCAdapter.prototype.unsetPeerListener = function() {
 414   native_.removeListener(PEER_LISTENER);
 415
 416   var result = native_.callSync('NFCAdapter_unsetPeerListener');
 417   if (native_.isFailure(result)) {
 418     throw native_.getErrorObject(result);
 419   }
 420
 421   return;
 422 };
 423
 424 function addCardEmulationModeChangeListener() {
 425   var args = validator_.validateArgs(arguments, [
 426     {
 427       name: 'callback',
 428       type: types_.FUNCTION
 429     }
 430   ]);
 431
 432   if (type_.isEmptyObject(cardEmulationModeListener.listeners) &&
 433       type_.isEmptyObject(activeSecureElementChangeListener.listeners)) {
 434     var result = native_.callSync(
 435         'NFCAdapter_addCardEmulationModeChangeListener');
 436     if (native_.isFailure(result)) {
 437       throw native_.getErrorObject(result);
 438     }
 439   }
 440
 441   return cardEmulationModeListener.addListener(args.callback);
 442 };
 443
 444 NFCAdapter.prototype.addCardEmulationModeChangeListener = function() {
 445   return addCardEmulationModeChangeListener.apply(this, arguments);
 446 };
 447
 448 function removeCardEmulationModeChangeListener() {
 449   if (type_.isEmptyObject(cardEmulationModeListener.listeners)) {
 450     privUtils_.checkPrivilegeAccess(privilege_.NFC_CARDEMULATION);
 451   }
 452
 453   var args = validator_.validateArgs(arguments, [
 454     {
 455       name: 'listenerId',
 456       type: types_.LONG
 457     }
 458   ]);
 459   cardEmulationModeListener.removeListener(args.listenerId);
 460
 461   if (type_.isEmptyObject(cardEmulationModeListener.listeners) &&
 462       type_.isEmptyObject(activeSecureElementChangeListener.listeners)) {
 463     var result = native_.callSync('NFCAdapter_removeCardEmulationModeChangeListener');
 464
 465     if (native_.isFailure(result)) {
 466       throw native_.getErrorObject(result);
 467     }
 468   }
 469 };
 470
 471 NFCAdapter.prototype.removeCardEmulationModeChangeListener = function() {
 472   removeCardEmulationModeChangeListener.apply(this, arguments);
 473 };
 474
 475 function addTransactionEventListener() {
 476   var args = validator_.validateArgs(arguments, [
 477     {
 478       name: 'type',
 479       type: types_.ENUM,
 480       values: type_.getValues(SecureElementType)
 481     },
 482     {
 483       name: 'callback',
 484       type: types_.FUNCTION
 485     }
 486   ]);
 487
 488   var result;
 489
 490   if (SecureElementType.ESE === args.type) {
 491     if (type_.isEmptyObject(transactionEventListenerEse.listeners)) {
 492       result = native_.callSync('NFCAdapter_addTransactionEventListener', {
 493         type: args.type});
 494       if (native_.isFailure(result)) {
 495         throw native_.getErrorObject(result);
 496       }
 497     }
 498     return transactionEventListenerEse.addListener(args.callback);
 499   } else {
 500     if (type_.isEmptyObject(transactionEventListenerUicc.listeners)) {
 501       result = native_.callSync('NFCAdapter_addTransactionEventListener', {
 502         type: args.type});
 503       if (native_.isFailure(result)) {
 504         throw native_.getErrorObject(result);
 505       }
 506     }
 507     return transactionEventListenerUicc.addListener(args.callback);
 508   }
 509 };
 510
 511 NFCAdapter.prototype.addTransactionEventListener = function() {
 512   return addTransactionEventListener.apply(this, arguments);
 513 };
 514
 515 function removeTransactionEventListener() {
 516   var ese_empty = type_.isEmptyObject(transactionEventListenerEse.listeners);
 517   var uicc_empty = type_.isEmptyObject(transactionEventListenerUicc.listeners);
 518
 519   if (!ese_empty || !uicc_empty) {
 520     privUtils_.checkPrivilegeAccess(privilege_.NFC_CARDEMULATION);
 521   }
 522
 523   var args = validator_.validateArgs(arguments, [
 524     {
 525       name: 'watchId',
 526       type: types_.LONG
 527     }
 528   ]);
 529
 530   transactionEventListenerEse.removeListener(args.watchId);
 531   transactionEventListenerUicc.removeListener(args.watchId);
 532
 533   if (type_.isEmptyObject(transactionEventListenerEse.listeners) && !ese_empty) {
 534     var result = native_.callSync('NFCAdapter_removeTransactionEventListener', {
 535       type: SecureElementType.ESE});
 536
 537     if (native_.isFailure(result)) {
 538       throw native_.getErrorObject(result);
 539     }
 540   }
 541
 542   if (type_.isEmptyObject(transactionEventListenerUicc.listeners)
 543             && !uicc_empty) {
 544     var result = native_.callSync('NFCAdapter_removeTransactionEventListener', {
 545       type: SecureElementType.UICC});
 546
 547     if (native_.isFailure(result)) {
 548       throw native_.getErrorObject(result);
 549     }
 550   }
 551
 552 };
 553
 554 NFCAdapter.prototype.removeTransactionEventListener = function() {
 555   removeTransactionEventListener.apply(this, arguments);
 556 };
 557
 558 function addActiveSecureElementChangeListener() {
 559   var args = validator_.validateArgs(arguments, [
 560     {
 561       name: 'callback',
 562       type: types_.FUNCTION
 563     }
 564   ]);
 565
 566   if (type_.isEmptyObject(cardEmulationModeListener.listeners) &&
 567       type_.isEmptyObject(activeSecureElementChangeListener.listeners)) {
 568     var result = native_.callSync(
 569         'NFCAdapter_addActiveSecureElementChangeListener');
 570     if (native_.isFailure(result)) {
 571       throw native_.getErrorObject(result);
 572     }
 573   }
 574
 575   return activeSecureElementChangeListener.addListener(args.callback);
 576 };
 577
 578 NFCAdapter.prototype.addActiveSecureElementChangeListener = function() {
 579   return addActiveSecureElementChangeListener.apply(this, arguments);
 580 };
 581
 582 function removeActiveSecureElementChangeListener() {
 583   if (type_.isEmptyObject(activeSecureElementChangeListener.listeners)) {
 584     privUtils_.checkPrivilegeAccess(privilege_.NFC_CARDEMULATION);
 585   }
 586
 587   var args = validator_.validateArgs(arguments, [
 588     {
 589       name: 'listenerId',
 590       type: types_.LONG
 591     }
 592   ]);
 593   activeSecureElementChangeListener.removeListener(args.listenerId);
 594
 595   if (type_.isEmptyObject(cardEmulationModeListener.listeners) &&
 596       type_.isEmptyObject(activeSecureElementChangeListener.listeners)) {
 597     var result = native_.callSync('NFCAdapter_removeCardEmulationModeChangeListener');
 598
 599     if (native_.isFailure(result)) {
 600       throw native_.getErrorObject(result);
 601     }
 602   }
 603 };
 604
 605 NFCAdapter.prototype.removeActiveSecureElementChangeListener = function() {
 606   removeActiveSecureElementChangeListener.apply(this, arguments);
 607 };
 608
 609 NFCAdapter.prototype.getCachedMessage = function() {
 610   var result = native_.callSync('NFCAdapter_getCachedMessage');
 611
 612   if (native_.isFailure(result)) {
 613     throw native_.getErrorObject(result);
 614   }
 615
 616   if (!result.records) {
 617     return new tizen.NDEFMessage();
 618   }
 619
 620   return new tizen.NDEFMessage(toRecordsArray(result.records));
 621 };
 622
 623 NFCAdapter.prototype.setExclusiveModeForTransaction = function() {
 624
 625   var args = validator_.validateArgs(arguments, [
 626     {
 627       name: 'transactionMode',
 628       type: types_.BOOLEAN
 629     }
 630   ]);
 631
 632   var result = native_.callSync(
 633       'NFCAdapter_setExclusiveModeForTransaction',
 634       { 'transactionMode': args.transactionMode}
 635       );
 636
 637   if (native_.isFailure(result)) {
 638     throw native_.getErrorObject(result);
 639   }
 640   return;
 641 };
 642
 643 function addHCEEventListener() {
 644   var args = validator_.validateArgs(arguments, [
 645     {name: 'eventCallback', type: types_.FUNCTION}
 646   ]);
 647
 648   if (!arguments.length || !type_.isFunction(arguments[0])) {
 649     throw new WebAPIException(WebAPIException.TYPE_MISMATCH_ERR);
 650   }
 651
 652   if (type_.isEmptyObject(HCEEventListener.listeners)) {
 653     var result = native_.callSync('NFCAdapter_addHCEEventListener');
 654     if (native_.isFailure(result)) {
 655       throw native_.getErrorObject(result);
 656     }
 657   }
 658
 659   return HCEEventListener.addListener(args.eventCallback);
 660 };
 661
 662 NFCAdapter.prototype.addHCEEventListener = function() {
 663   return addHCEEventListener.apply(this, arguments);
 664 }
 665
 666 function removeHCEEventListener() {
 667   if (type_.isEmptyObject(HCEEventListener.listeners)) {
 668     privUtils_.checkPrivilegeAccess(privilege_.NFC_CARDEMULATION);
 669   }
 670
 671   var args = validator_.validateArgs(arguments, [
 672     {name: 'watchId', type: types_.LONG}
 673   ]);
 674
 675   if (!arguments.length || !type_.isNumber(arguments[0])) {
 676     throw new WebAPIException(WebAPIException.TYPE_MISMATCH_ERR);
 677   }
 678
 679   HCEEventListener.removeListener(args.watchId);
 680
 681   if (type_.isEmptyObject(HCEEventListener.listeners)) {
 682     var result = native_.callSync('NFCAdapter_removeHCEEventListener');
 683     if (native_.isFailure(result)) {
 684       throw native_.getErrorObject(result);
 685     }
 686   }
 687 };
 688
 689 NFCAdapter.prototype.removeHCEEventListener = function() {
 690   removeHCEEventListener.apply(this, arguments);
 691 };
 692
 693 NFCAdapter.prototype.sendHostAPDUResponse = function(apdu, successCallback, errorCallback) {
 694   var args = validator_.validateArgs(arguments, [
 695     {name: 'apdu', type: types_.ARRAY, values: types_.BYTE},
 696     {name: 'successCallback', type: types_.FUNCTION, optional: true, nullable: true},
 697     {name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true}
 698   ]);
 699
 700   if (!arguments.length || !type_.isArray(arguments[0])) {
 701     throw new WebAPIException(WebAPIException.TYPE_MISMATCH_ERR);
 702   }
 703
 704   var data = {
 705     apdu: args.apdu
 706   };
 707
 708   var callback = function(result) {
 709     if (native_.isFailure(result)) {
 710       native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 711       return;
 712     }
 713     native_.callIfPossible(args.successCallback);
 714   };
 715
 716   var result = native_.call('NFCAdapter_sendHostAPDUResponse', data, callback);
 717
 718   if (native_.isFailure(result)) {
 719     throw native_.getErrorObject(result);
 720   }
 721 };
 722
 723 NFCAdapter.prototype.isActivatedHandlerForAID = function(type, aid) {
 724
 725   var args = validator_.validateArgs(arguments, [
 726     {
 727       name: 'type',
 728       type: types_.ENUM,
 729       values: type_.getValues(SecureElementType)
 730     },
 731     {name: 'aid', type: types_.STRING}
 732   ]);
 733
 734   if (arguments.length < 2) {
 735     throw new WebAPIException(WebAPIException.TYPE_MISMATCH_ERR);
 736   }
 737
 738   var data = {
 739     type: args.type,
 740     aid: args.aid
 741   };
 742
 743   var result = native_.callSync('NFCAdapter_isActivatedHandlerForAID', data);
 744
 745   if (native_.isFailure(result)) {
 746     throw native_.getErrorObject(result);
 747   }
 748   return native_.getResultObject(result);
 749 };
 750
 751 NFCAdapter.prototype.isActivatedHandlerForCategory = function(type, category) {
 752
 753   var args = validator_.validateArgs(arguments, [{
 754     name: 'type',
 755     type: types_.ENUM,
 756     values: type_.getValues(SecureElementType)
 757   }, {
 758     name: 'category',
 759     type: types_.ENUM,
 760     values: Object.keys(CardEmulationCategoryType)
 761   }]);
 762
 763   if (arguments.length < 2) {
 764     throw new WebAPIException(WebAPIException.TYPE_MISMATCH_ERR);
 765   }
 766
 767   var data = {
 768     type: args.type,
 769     category: args.category
 770   };
 771
 772   var result = native_.callSync('NFCAdapter_isActivatedHandlerForCategory', data);
 773
 774   if (native_.isFailure(result)) {
 775     throw native_.getErrorObject(result);
 776   }
 777   return native_.getResultObject(result);
 778 };
 779
 780 NFCAdapter.prototype.registerAID = function(type, aid, category) {
 781
 782   var args = validator_.validateArgs(arguments, [{
 783     name: 'type',
 784     type: types_.ENUM,
 785     values: type_.getValues(SecureElementType)
 786   }, {
 787     name: 'aid',
 788     type: types_.STRING
 789   }, {
 790     name: 'category',
 791     type: types_.ENUM,
 792     values: Object.keys(CardEmulationCategoryType)
 793   }]);
 794
 795   if (arguments.length < 3 || !type_.isString(arguments[0])) {
 796     throw new WebAPIException(WebAPIException.TYPE_MISMATCH_ERR);
 797   }
 798
 799   var data = {
 800     type: args.type,
 801     aid: args.aid,
 802     category: args.category
 803   };
 804
 805   var result = native_.callSync('NFCAdapter_registerAID', data);
 806
 807   if (native_.isFailure(result)) {
 808     throw native_.getErrorObject(result);
 809   }
 810 };
 811
 812 NFCAdapter.prototype.unregisterAID = function(type, aid, category) {
 813
 814   var args = validator_.validateArgs(arguments, [
 815     {
 816       name: 'type',
 817       type: types_.ENUM,
 818       values: type_.getValues(SecureElementType)
 819     },
 820     {name: 'aid', type: types_.STRING},
 821     {name: 'category', type: types_.ENUM, values: Object.keys(CardEmulationCategoryType)}
 822   ]);
 823
 824   if (arguments.length < 3 || !type_.isString(arguments[0])) {
 825     throw new WebAPIException(WebAPIException.TYPE_MISMATCH_ERR);
 826   }
 827
 828   var data = {
 829     type: args.type,
 830     aid: args.aid,
 831     category: args.category
 832   };
 833
 834   var result = native_.callSync('NFCAdapter_unregisterAID', data);
 835
 836   if (native_.isFailure(result)) {
 837     throw native_.getErrorObject(result);
 838   }
 839 };
 840
 841 function AIDData(data) {
 842   Object.defineProperties(this, {
 843     type: {
 844       value: data.type,
 845       writable: false,
 846       enumerable: true
 847     },
 848     aid: {
 849       value: data.aid || [],
 850       writable: false,
 851       enumerable: true
 852     },
 853     readOnly: {
 854       value: data.readOnly || false,
 855       writable: false,
 856       enumerable: true
 857     }
 858   });
 859 }
 860
 861 NFCAdapter.prototype.getAIDsForCategory = function(type, category, successCallback, errorCallback) {
 862
 863   var args = validator_.validateArgs(arguments, [{
 864     name: 'type',
 865     type: types_.ENUM,
 866     values: type_.getValues(SecureElementType)
 867   }, {
 868     name: 'category',
 869     type: types_.ENUM,
 870     values: Object.keys(CardEmulationCategoryType)
 871   }, {
 872     name: 'successCallback',
 873     type: types_.FUNCTION
 874   }, {
 875     name: 'errorCallback',
 876     type: types_.FUNCTION,
 877     optional: true,
 878     nullable: true
 879   }]);
 880
 881   if (arguments.length < 3) {
 882     throw new WebAPIException(WebAPIException.TYPE_MISMATCH_ERR);
 883   }
 884
 885   var data = {
 886     type: args.type,
 887     category: args.category
 888   };
 889
 890   var callback = function(result) {
 891     if (native_.isFailure(result)) {
 892       native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 893       return;
 894     }
 895     var aids = [];
 896     var r = native_.getResultObject(result);
 897     for (var i = 0; i < r.length; i++) {
 898       aids.push(new AIDData(r[i]));
 899     }
 900     native_.callIfPossible(args.successCallback, aids);
 901   };
 902
 903   var result = native_.call('NFCAdapter_getAIDsForCategory', data, callback);
 904
 905   if (native_.isFailure(result)) {
 906     throw native_.getErrorObject(result);
 907   }
 908 };
 909
 910 function WebkitVisibilityChangeListener() {
 911   var result;
 912   if (true === privUtils_.global.document.hidden) {
 913     result = native_.call('NFCAdapter_unsetPreferredApp');
 914   } else if (false === privUtils_.global.document.hidden) {
 915     result = native_.call('NFCAdapter_setPreferredApp');
 916   }
 917
 918   if (native_.isFailure(result)) {
 919     privUtils_.log('Failed to (un)set: ' + result.error.message);
 920   }
 921 }
 922
 923 NFCAdapter.prototype.setPreferredApp = function() {
 924   var result = native_.call('NFCAdapter_setPreferredApp');
 925
 926   if (native_.isFailure(result)) {
 927     throw native_.getErrorObject(result);
 928   } else {
 929     if (false === isWebkitVisibilityChangeListenerSet) {
 930       privUtils_.global.document.addEventListener("webkitvisibilitychange", WebkitVisibilityChangeListener);
 931       isWebkitVisibilityChangeListenerSet = true;
 932     }
 933   }
 934 };
 935
 936 NFCAdapter.prototype.unsetPreferredApp = function() {
 937   var result = native_.call('NFCAdapter_unsetPreferredApp');
 938
 939   if (native_.isFailure(result)) {
 940     throw native_.getErrorObject(result);
 941   } else {
 942     if (true === isWebkitVisibilityChangeListenerSet) {
 943       privUtils_.global.document.removeEventListener("webkitvisibilitychange", WebkitVisibilityChangeListener);
 944       isWebkitVisibilityChangeListenerSet = false;
 945     }
 946   }
 947 };
 948
 949 function InternalRecordData(tnf, type, payload, id) {
 950   this.tnf = tnf;
 951   this.type = type;
 952   this.payload = payload;
 953   this.id = id;
 954 };
 955
 956 var toRecordsArray = function(array) {
 957   var result = [];
 958   if (type_.isNullOrUndefined(array) || !type_.isArray(array)) {
 959     return result;
 960   }
 961
 962   for (var i = 0; i < array.length; i++) {
 963     var data = new InternalRecordData(array[i].tnf, array[i].type, array[i].payload, array[i].id);
 964
 965     if (array[i].recordType == 'Record') {
 966       result.push(new tizen.NDEFRecord(data.tnf, data.type, data.payload, data.id));
 967       continue;
 968     }
 969
 970     if (array[i].recordType == 'RecordText') {
 971       result.push(new tizen.NDEFRecordText(array[i].text, array[i].languageCode,
 972           array[i].encoding, data));
 973       continue;
 974     }
 975
 976     if (array[i].recordType == 'RecordURI') {
 977       result.push(new tizen.NDEFRecordURI(array[i].uri, data));
 978       continue;
 979     }
 980
 981     if (array[i].recordType == 'RecordMedia') {
 982       result.push(new tizen.NDEFRecordMedia(array[i].mimeType, null, data));
 983       continue;
 984     }
 985   }
 986
 987   return result;
 988 };
 989
 990 //////////////////NFCTag /////////////////
 991
 992 function NFCTag(tagid) {
 993
 994   var _my_id = tagid;
 995
 996   function TypeGetter() {
 997
 998     var result = native_.callSync('NFCTag_typeGetter', {'id' : _my_id});
 999
1000     if (native_.isFailure(result)) {
1001       return;
1002     }
1003     return native_.getResultObject(result);
1004   }
1005
1006   function IsSupportedNDEFGetter() {
1007
1008     var result = native_.callSync('NFCTag_isSupportedNDEFGetter', {'id' : _my_id});
1009
1010     if (native_.isFailure(result)) {
1011       return;
1012     }
1013     return native_.getResultObject(result);
1014   }
1015
1016   function NDEFSizeGetter() {
1017
1018     var result = native_.callSync('NFCTag_NDEFSizeGetter', {'id' : _my_id});
1019
1020     if (native_.isFailure(result)) {
1021       return;
1022     }
1023     return native_.getResultObject(result);
1024   }
1025
1026   function PropertiesGetter() {
1027
1028     var result = native_.callSync('NFCTag_propertiesGetter', {'id' : _my_id});
1029
1030     if (native_.isFailure(result)) {
1031       return;
1032     }
1033
1034     privUtils_.log('Current result: ' + result);
1035
1036     var result_array = {};
1037     for (var i in result.result) {
1038       var current = result.result[i];
1039       var keys = Object.keys(current);
1040       for (var x in keys) {
1041         result_array[keys[x]] = current[keys[x]];
1042       }
1043     }
1044     return result_array;
1045   }
1046
1047   function IsConnectedGetter() {
1048
1049     var result = native_.callSync('NFCTag_isConnectedGetter', {'id' : _my_id});
1050
1051     if (native_.isFailure(result)) {
1052       return;
1053     }
1054     return native_.getResultObject(result);
1055   }
1056
1057   // Function defined here (not outside Tag "constructor"
1058   // because access to internal _my_id variable is needed)
1059   NFCTag.prototype.readNDEF = function() {
1060     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_TAG);
1061
1062     var args = validator_.validateArgs(arguments, [
1063       {
1064         name: 'readCallback',
1065         type: types_.FUNCTION
1066       },
1067       {
1068         name: 'errorCallback',
1069         type: types_.FUNCTION,
1070         optional: true,
1071         nullable: true
1072       }
1073     ]);
1074
1075     var result = native_.call('NFCTag_readNDEF', {'id' : _my_id},
1076         function(result) {
1077           if (native_.isFailure(result)) {
1078             if (!type_.isNullOrUndefined(args.errorCallback)) {
1079               args.errorCallback(native_.getErrorObject(result));
1080             }
1081           } else {
1082             var message = new tizen.NDEFMessage(toRecordsArray(result.records));
1083             args.readCallback(message);
1084           }
1085         });
1086
1087     if (native_.isFailure(result)) {
1088       throw native_.getErrorObject(result);
1089     }
1090   };
1091
1092   NFCTag.prototype.writeNDEF = function() {
1093     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_TAG);
1094
1095     var args = validator_.validateArgs(arguments, [
1096       {
1097         name: 'message',
1098         type: types_.PLATFORM_OBJECT,
1099         values: tizen.NDEFMessage
1100       },
1101       {
1102         name: 'successCallback',
1103         type: types_.FUNCTION,
1104         optional: true,
1105         nullable: true
1106       },
1107       {
1108         name: 'errorCallback',
1109         type: types_.FUNCTION,
1110         optional: true,
1111         nullable: true
1112       }
1113     ]);
1114
1115     var result = native_.call('NFCTag_writeNDEF',
1116         {
1117           'id' : _my_id,
1118           'records' : args.message.records,
1119           'recordsSize' : args.message.recordCount
1120         },
1121         function(result) {
1122           if (native_.isFailure(result)) {
1123             if (!type_.isNullOrUndefined(args.errorCallback)) {
1124               args.errorCallback(native_.getErrorObject(result));
1125             }
1126           } else {
1127             if (!type_.isNullOrUndefined(args.successCallback)) {
1128               args.successCallback();
1129             }
1130           }
1131         });
1132
1133     if (native_.isFailure(result)) {
1134       throw native_.getErrorObject(result);
1135     }
1136   };
1137
1138   NFCTag.prototype.transceive = function() {
1139     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_TAG);
1140
1141     var args = validator_.validateArgs(arguments, [
1142       {
1143         name: 'data',
1144         type: types_.ARRAY,
1145         values: types_.BYTE
1146       },
1147       {
1148         name: 'dataCallback',
1149         type: types_.FUNCTION
1150       },
1151       {
1152         name: 'errorCallback',
1153         type: types_.FUNCTION,
1154         optional: true,
1155         nullable: true
1156       }
1157     ]);
1158
1159     var result = native_.call('NFCTag_transceive',
1160         {
1161           'id' : _my_id,
1162           'data' : args.data
1163         },
1164         function(result) {
1165           if (native_.isFailure(result)) {
1166             if (!type_.isNullOrUndefined(args.errorCallback)) {
1167               args.errorCallback(result.error);
1168             }
1169           } else {
1170             if (!type_.isNullOrUndefined(args.dataCallback)) {
1171               args.dataCallback(result.data);
1172             }
1173           }
1174         });
1175
1176     if (native_.isFailure(result)) {
1177       throw native_.getErrorObject(result);
1178     }
1179   };
1180
1181   Object.defineProperties(this, {
1182     type: {
1183       set: function() {},
1184       get: TypeGetter,
1185       enumerable: true
1186     },
1187     isSupportedNDEF: {
1188       set: function() {},
1189       get: IsSupportedNDEFGetter,
1190       enumerable: true
1191     },
1192     ndefSize: {
1193       set: function() {},
1194       get: NDEFSizeGetter,
1195       enumerable: true
1196     },
1197     properties: {
1198       set: function() {},
1199       get: PropertiesGetter,
1200       enumerable: true
1201     },
1202     isConnected: {
1203       set: function() {},
1204       get: IsConnectedGetter,
1205       enumerable: true
1206     }
1207   });
1208 }
1209
1210
1211 //////////////////NFCPeer /////////////////
1212
1213 function NFCPeer(peerid) {
1214   var _my_id = peerid;
1215
1216   function isConnectedGetter() {
1217     var ret = native_.callSync('NFCAdapter_PeerIsConnectedGetter', {'id' : _my_id});
1218     if (native_.isFailure(ret)) {
1219       return false;
1220     }
1221     return native_.getResultObject(ret);
1222   }
1223
1224   NFCPeer.prototype.sendNDEF = function() {
1225     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_P2P);
1226
1227     var args = validator_.validateArgs(arguments, [
1228       {
1229         name: 'message',
1230         type: types_.PLATFORM_OBJECT,
1231         values: tizen.NDEFMessage
1232       },
1233       {
1234         name: 'successCallback',
1235         type: types_.FUNCTION,
1236         optional: true,
1237         nullable: true
1238       },
1239       {
1240         name: 'errorCallback',
1241         type: types_.FUNCTION,
1242         optional: true,
1243         nullable: true
1244       }
1245     ]);
1246
1247     var result = native_.call('NFCPeer_sendNDEF', {
1248       'id' : _my_id,
1249       'records' : args.message.records,
1250       'recordsSize' : args.message.recordCount
1251     }, function(result) {
1252       if (native_.isFailure(result)) {
1253         args.errorCallback(result.error);
1254       } else {
1255         args.successCallback();
1256       }
1257     });
1258
1259     if (native_.isFailure(result)) {
1260       throw native_.getErrorObject(result);
1261     }
1262   };
1263
1264   NFCPeer.prototype.setReceiveNDEFListener = function() {
1265     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_P2P);
1266
1267     var args = validator_.validateArgs(arguments, [
1268       {
1269         name: 'listener',
1270         type: types_.FUNCTION
1271       }
1272     ]);
1273
1274     var listener = function(msg) {
1275       var data = undefined;
1276       if ('onsuccess' === msg.action && _my_id === msg.id) {
1277         data = new tizen.NDEFMessage(toRecordsArray(msg.records));
1278       }
1279       args.listener(data);
1280     };
1281
1282     var result = native_.callSync('NFCPeer_setReceiveNDEFListener', {'id' : _my_id});
1283     if (native_.isFailure(result)) {
1284       throw native_.getErrorObject(result);
1285     }
1286
1287     native_.addListener(RECEIVE_NDEF_LISTENER, listener);
1288     return;
1289   };
1290
1291   NFCPeer.prototype.unsetReceiveNDEFListener = function() {
1292     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_P2P);
1293
1294     native_.removeListener(RECEIVE_NDEF_LISTENER);
1295
1296     var result = native_.callSync('NFCPeer_unsetReceiveNDEFListener', {'id' : _my_id});
1297     if (native_.isFailure(result)) {
1298       throw native_.getErrorObject(result);
1299     }
1300
1301     return;
1302   };
1303
1304   Object.defineProperties(this, {
1305     isConnected: {
1306       enumerable: true,
1307       set: function() {},
1308       get: isConnectedGetter
1309     }
1310   });
1311 }
1312
1313 var toByteArray = function(array, max_size, nullable) {
1314   var resultArray = [];
1315   if (type_.isNullOrUndefined(array) && nullable === true)
1316     return resultArray;
1317
1318   var convertedArray = converter_.toArray(array);
1319   var len = convertedArray.length;
1320
1321   if (len > max_size)
1322     throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1323   for (var i = 0; i < len; i++) {
1324     resultArray.push(converter_.toOctet(convertedArray[i]));
1325   }
1326   return resultArray;
1327 };
1328
1329 var isArrayOfType = function(array, type) {
1330   for (var i = 0; i < array.length; i++) {
1331     if (!(array[i] instanceof type))
1332       return false;
1333   }
1334   return true;
1335 };
1336
1337 //////////////////NDEFMessage /////////////////
1338 //[Constructor(),
1339 // Constructor(NDEFRecord[] ndefRecords),
1340 // Constructor(byte[] rawData)]
1341 //interface NDEFMessage {
1342 //  readonly attribute long recordCount;
1343 //
1344 //  attribute NDEFRecord[] records;
1345 //
1346 //  byte[] toByte() raises(WebAPIException);
1347 //};
1348
1349 tizen.NDEFMessage = function(data) {
1350   validator_.isConstructorCall(this, tizen.NDEFMessage);
1351   var records_ = [];
1352   try {
1353     if (arguments.length >= 1) {
1354       if (type_.isArray(data)) {
1355         if (isArrayOfType(data, tizen.NDEFRecord)) {
1356           records_ = data;
1357         } else {
1358           var raw_data_ = toByteArray(data);
1359           var result = native_.callSync(
1360               'NDEFMessage_constructor', {
1361                                 'rawData': raw_data_,
1362                                 'rawDataSize' : raw_data_.length
1363               }
1364               );
1365
1366           if (native_.isFailure(result)) {
1367             throw native_.getErrorObject(result);
1368           }
1369
1370           var records_array = result.result.records;
1371           for (var i = 0; i < records_array.length; i++) {
1372             records_.push(new tizen.NDEFRecord(records_array[i].tnf,
1373                                 records_array[i].type, records_array[i].payload,
1374                                 records_array[i].id));
1375           }
1376         }
1377       } else {
1378         throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1379       }
1380     }
1381   } catch (e) {
1382     //constructor call failed - empty object should be created
1383     records_ = undefined;
1384   }
1385
1386   var recordsSetter = function(data) {
1387     if (type_.isArray(data)) {
1388       // Do not check type of array elements - allow all arrays
1389       //if ( isArrayOfType(data, tizen.NDEFRecord) ) {
1390       records_ = data;
1391       //}
1392     }
1393   };
1394
1395   Object.defineProperties(this, {
1396     recordCount: { enumerable: true,
1397       set: function() {},
1398       get: function() { return records_ ? records_.length : undefined;}},
1399     records: { enumerable: true,
1400       set: recordsSetter,
1401       get: function() {return records_;}}
1402   });
1403 };
1404
1405 tizen.NDEFMessage.prototype.toByte = function() {
1406   var result = native_.callSync(
1407       'NDEFMessage_toByte', {
1408         'records' : this.records,
1409         'recordsSize' : this.recordCount
1410       }
1411       );
1412   if (native_.isFailure(result)) {
1413     throw native_.getErrorObject(result);
1414   }
1415
1416   return toByteArray(result.result.bytes);
1417 };
1418
1419 //helper for inherited object constructors /////////////////////////////////////////////
1420 function InternalData() {
1421 }
1422
1423 //////////////////NDEFRecord /////////////////
1424 tizen.NDEFRecord = function(first, type, payload, id) {
1425   var tnf_ = undefined;
1426   var typ_ = undefined;
1427   var payload_ = undefined;
1428   var id_ = undefined;
1429   //if it is inherited call, then ignore validation
1430   if (!(first instanceof InternalData)) {
1431     validator_.isConstructorCall(this, tizen.NDEFRecord);
1432     try {
1433       if (arguments.length >= 1) {
1434         if (type_.isArray(first)) {
1435           var raw_data_ = toByteArray(first);
1436           var result = native_.callSync(
1437               'NDEFRecord_constructor', {
1438                 'rawData': raw_data_,
1439                 'rawDataSize' : raw_data_.length
1440               }
1441               );
1442           if (native_.isFailure(result)) {
1443             throw native_.getErrorObject(result);
1444           }
1445           tnf_ = converter_.toLong(result.result.tnf);
1446           typ_ = toByteArray(result.result.type, 255);
1447           payload_ = toByteArray(result.result.payload, Math.pow(2, 32) - 1);
1448           id_ = toByteArray(result.result.id, 255);
1449         } else if (arguments.length >= 3) {
1450           tnf_ = converter_.toLong(first);
1451           typ_ = toByteArray(type, 255);
1452           payload_ = toByteArray(payload, Math.pow(2, 32) - 1);
1453           id_ = toByteArray(id, 255, true, []);
1454         }
1455       } else {
1456         throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1457       }
1458     } catch (e) {
1459       //constructor call failed - empty object should be created
1460       tnf_ = undefined;
1461       typ_ = undefined;
1462       payload_ = undefined;
1463       id_ = undefined;
1464     }
1465   }
1466
1467   Object.defineProperties(this, {
1468     tnf: {value: tnf_, writable: false, enumerable: true},
1469     type: {value: typ_, writable: false, enumerable: true},
1470     id: {value: id_, writable: false, enumerable: true},
1471     payload: {value: payload_, writable: false, enumerable: true}
1472   });
1473 };
1474
1475 //////////////////NDEFRecordText /////////////////
1476 tizen.NDEFRecordText = function(text, languageCode, encoding, internal_) {
1477   var text_ = undefined;
1478   var languageCode_ = undefined;
1479   var encoding_ = NDEFRecordTextEncoding[encoding] ?
1480       NDEFRecordTextEncoding[encoding] : NDEFRecordTextEncoding['UTF8'];
1481   try {
1482     if (arguments.length >= 2) {
1483       text_ = converter_.toString(text);
1484       languageCode_ = converter_.toString(languageCode);
1485
1486       if (!type_.isNullOrUndefined(internal_) && (internal_ instanceof InternalRecordData)) {
1487         tizen.NDEFRecord.call(this, internal_.tnf, internal_.type, internal_.payload, internal_.id);
1488       } else {
1489         var result = native_.callSync(
1490             'NDEFRecordText_constructor', {
1491               'text': text_,
1492               'languageCode' : languageCode_,
1493               'encoding' : encoding_
1494             }
1495             );
1496         if (native_.isFailure(result)) {
1497           throw native_.getErrorObject(result);
1498         }
1499         tizen.NDEFRecord.call(this, result.result.tnf, result.result.type,
1500             result.result.payload, result.result.id);
1501       }
1502     } else {
1503       throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1504     }
1505   } catch (e) {
1506     //constructor call failed - empty object should be created
1507     tizen.NDEFRecord.call(this);
1508     text_ = undefined;
1509     languageCode_ = undefined;
1510     encoding_ = undefined;
1511   }
1512
1513   Object.defineProperties(this, {
1514     text: {value: text_, writable: false, enumerable: true},
1515     languageCode: {value: languageCode_, writable: false, enumerable: true},
1516     encoding: {value: encoding_, writable: false, enumerable: true}
1517   });
1518 };
1519
1520 tizen.NDEFRecordText.prototype = new tizen.NDEFRecord(new InternalData());
1521
1522 tizen.NDEFRecordText.prototype.constructor = tizen.NDEFRecordText;
1523
1524 //////////////////NDEFRecordURI /////////////////
1525 tizen.NDEFRecordURI = function(uri, internal_) {
1526   var uri_ = undefined;
1527   try {
1528     if (arguments.length >= 1) {
1529       uri_ = converter_.toString(uri);
1530
1531       if (!type_.isNullOrUndefined(internal_) && (internal_ instanceof InternalRecordData)) {
1532         tizen.NDEFRecord.call(this, internal_.tnf, internal_.type, internal_.payload, internal_.id);
1533       } else {
1534         var result = native_.callSync(
1535             'NDEFRecordURI_constructor', {
1536               'uri': uri_
1537             }
1538             );
1539         if (native_.isFailure(result)) {
1540           throw native_.getErrorObject(result);
1541         }
1542         tizen.NDEFRecord.call(this, result.result.tnf, result.result.type,
1543             result.result.payload, result.result.id);
1544       }
1545     } else {
1546       throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1547     }
1548   } catch (e) {
1549     //constructor call failed - empty object should be created
1550     tizen.NDEFRecord.call(this);
1551     uri_ = undefined;
1552   }
1553
1554   Object.defineProperties(this, {
1555     uri: {value: uri_, writable: false, enumerable: true}
1556   });
1557 };
1558
1559 tizen.NDEFRecordURI.prototype = new tizen.NDEFRecord(new InternalData());
1560
1561 tizen.NDEFRecordURI.prototype.constructor = tizen.NDEFRecordURI;
1562
1563 //////////////////NDEFRecordMedia /////////////////
1564 tizen.NDEFRecordMedia = function(mimeType, data, internal_) {
1565   var mimeType_ = undefined;
1566   var data_ = undefined;
1567   try {
1568     if (arguments.length >= 2) {
1569       mimeType_ = converter_.toString(mimeType);
1570
1571       if (!type_.isNullOrUndefined(internal_) && (internal_ instanceof InternalRecordData)) {
1572         tizen.NDEFRecord.call(this, internal_.tnf, internal_.type, internal_.payload, internal_.id);
1573       } else {
1574         data_ = toByteArray(data, Math.pow(2, 32) - 1);
1575         var result = native_.callSync(
1576             'NDEFRecordMedia_constructor', {
1577               'mimeType': mimeType_,
1578               'data': data_,
1579               'dataSize': data_.length
1580             }
1581             );
1582         if (native_.isFailure(result)) {
1583           throw native_.getErrorObject(result);
1584         }
1585         tizen.NDEFRecord.call(this, result.result.tnf, result.result.type,
1586             result.result.payload, result.result.id);
1587       }
1588     } else {
1589       throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1590     }
1591   } catch (e) {
1592     //constructor call failed - empty object should be created
1593     tizen.NDEFRecord.call(this);
1594     mimeType_ = undefined;
1595   }
1596
1597   Object.defineProperties(this, {
1598     mimeType: {value: mimeType_, writable: false, enumerable: true}
1599   });
1600 };
1601
1602 tizen.NDEFRecordMedia.prototype = new tizen.NDEFRecord(new InternalData());
1603
1604 tizen.NDEFRecordMedia.prototype.constructor = tizen.NDEFRecordMedia;
1605 //Exports
1606 exports = new NFCManager();