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
 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     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     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_.OCTET},
 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 InternalRecordData(tnf, type, payload, id) {
 911   this.tnf = tnf;
 912   this.type = type;
 913   this.payload = payload;
 914   this.id = id;
 915 };
 916
 917 var toRecordsArray = function(array) {
 918   var result = [];
 919   if (type_.isNullOrUndefined(array) || !type_.isArray(array)) {
 920     return result;
 921   }
 922
 923   for (var i = 0; i < array.length; i++) {
 924     var data = new InternalRecordData(array[i].tnf, array[i].type, array[i].payload, array[i].id);
 925
 926     if (array[i].recordType == 'Record') {
 927       result.push(new tizen.NDEFRecord(data.tnf_, data.type_, data.payload_, data.id_));
 928       continue;
 929     }
 930
 931     if (array[i].recordType == 'RecordText') {
 932       result.push(new tizen.NDEFRecordText(array[i].text, array[i].languageCode,
 933           array[i].encoding, data));
 934       continue;
 935     }
 936
 937     if (array[i].recordType == 'RecordURI') {
 938       result.push(new tizen.NDEFRecordURI(array[i].uri, data));
 939       continue;
 940     }
 941
 942     if (array[i].recordType == 'RecordMedia') {
 943       result.push(new tizen.NDEFRecordMedia(array[i].mimeType, array[i].data, data));
 944       continue;
 945     }
 946   }
 947
 948   return result;
 949 };
 950
 951 //////////////////NFCTag /////////////////
 952
 953 function NFCTag(tagid) {
 954
 955   var _my_id = tagid;
 956
 957   function TypeGetter() {
 958
 959     var result = native_.callSync('NFCTag_typeGetter', {'id' : _my_id});
 960
 961     if (native_.isFailure(result)) {
 962       return;
 963     }
 964     return native_.getResultObject(result);
 965   }
 966
 967   function IsSupportedNDEFGetter() {
 968
 969     var result = native_.callSync('NFCTag_isSupportedNDEFGetter', {'id' : _my_id});
 970
 971     if (native_.isFailure(result)) {
 972       return;
 973     }
 974     return native_.getResultObject(result);
 975   }
 976
 977   function NDEFSizeGetter() {
 978
 979     var result = native_.callSync('NFCTag_NDEFSizeGetter', {'id' : _my_id});
 980
 981     if (native_.isFailure(result)) {
 982       return;
 983     }
 984     return native_.getResultObject(result);
 985   }
 986
 987   function PropertiesGetter() {
 988
 989     var result = native_.callSync('NFCTag_propertiesGetter', {'id' : _my_id});
 990
 991     if (native_.isFailure(result)) {
 992       return;
 993     }
 994
 995     privUtils_.log('Current result: ' + result);
 996
 997     var result_array = {};
 998     for (var i in result.result) {
 999       var current = result.result[i];
1000       var keys = Object.keys(current);
1001       for (var x in keys) {
1002         result_array[keys[x]] = current[keys[x]];
1003       }
1004     }
1005     return result_array;
1006   }
1007
1008   function IsConnectedGetter() {
1009
1010     var result = native_.callSync('NFCTag_isConnectedGetter', {'id' : _my_id});
1011
1012     if (native_.isFailure(result)) {
1013       return;
1014     }
1015     return native_.getResultObject(result);
1016   }
1017
1018   // Function defined here (not outside Tag "constructor"
1019   // because access to internal _my_id variable is needed)
1020   NFCTag.prototype.readNDEF = function() {
1021     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_TAG);
1022
1023     var args = validator_.validateArgs(arguments, [
1024       {
1025         name: 'readCallback',
1026         type: types_.FUNCTION
1027       },
1028       {
1029         name: 'errorCallback',
1030         type: types_.FUNCTION,
1031         optional: true,
1032         nullable: true
1033       }
1034     ]);
1035
1036     var result = native_.call('NFCTag_readNDEF', {'id' : _my_id},
1037         function(result) {
1038           if (native_.isFailure(result)) {
1039             if (!type_.isNullOrUndefined(args.errorCallback)) {
1040               args.errorCallback(native_.getErrorObject(result));
1041             }
1042           } else {
1043             var message = new tizen.NDEFMessage(toRecordsArray(result.records));
1044             args.readCallback(message);
1045           }
1046         });
1047
1048     if (native_.isFailure(result)) {
1049       throw native_.getErrorObject(result);
1050     }
1051   };
1052
1053   NFCTag.prototype.writeNDEF = function() {
1054     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_TAG);
1055
1056     var args = validator_.validateArgs(arguments, [
1057       {
1058         name: 'message',
1059         type: types_.PLATFORM_OBJECT,
1060         values: tizen.NDEFMessage
1061       },
1062       {
1063         name: 'successCallback',
1064         type: types_.FUNCTION,
1065         optional: true,
1066         nullable: true
1067       },
1068       {
1069         name: 'errorCallback',
1070         type: types_.FUNCTION,
1071         optional: true,
1072         nullable: true
1073       }
1074     ]);
1075
1076     var result = native_.call('NFCTag_writeNDEF',
1077         {
1078           'id' : _my_id,
1079           'records' : args.message.records,
1080           'recordsSize' : args.message.recordCount
1081         },
1082         function(result) {
1083           if (native_.isFailure(result)) {
1084             if (!type_.isNullOrUndefined(args.errorCallback)) {
1085               args.errorCallback(native_.getErrorObject(result));
1086             }
1087           } else {
1088             if (!type_.isNullOrUndefined(args.successCallback)) {
1089               args.successCallback();
1090             }
1091           }
1092         });
1093
1094     if (native_.isFailure(result)) {
1095       throw native_.getErrorObject(result);
1096     }
1097   };
1098
1099   NFCTag.prototype.transceive = function() {
1100     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_TAG);
1101
1102     var args = validator_.validateArgs(arguments, [
1103       {
1104         name: 'data',
1105         type: types_.ARRAY
1106       },
1107       {
1108         name: 'dataCallback',
1109         type: types_.FUNCTION
1110       },
1111       {
1112         name: 'errorCallback',
1113         type: types_.FUNCTION,
1114         optional: true,
1115         nullable: true
1116       }
1117     ]);
1118
1119     var result = native_.call('NFCTag_transceive',
1120         {
1121           'id' : _my_id,
1122           'data' : args.data
1123         },
1124         function(result) {
1125           if (native_.isFailure(result)) {
1126             if (!type_.isNullOrUndefined(args.errorCallback)) {
1127               args.errorCallback(result.error);
1128             }
1129           } else {
1130             if (!type_.isNullOrUndefined(args.dataCallback)) {
1131               args.dataCallback(result.data);
1132             }
1133           }
1134         });
1135
1136     if (native_.isFailure(result)) {
1137       throw native_.getErrorObject(result);
1138     }
1139   };
1140
1141   Object.defineProperties(this, {
1142     type: {
1143       set: function() {},
1144       get: TypeGetter,
1145       enumerable: true
1146     },
1147     isSupportedNDEF: {
1148       set: function() {},
1149       get: IsSupportedNDEFGetter,
1150       enumerable: true
1151     },
1152     ndefSize: {
1153       set: function() {},
1154       get: NDEFSizeGetter,
1155       enumerable: true
1156     },
1157     properties: {
1158       set: function() {},
1159       get: PropertiesGetter,
1160       enumerable: true
1161     },
1162     isConnected: {
1163       set: function() {},
1164       get: IsConnectedGetter,
1165       enumerable: true
1166     }
1167   });
1168 }
1169
1170
1171 //////////////////NFCPeer /////////////////
1172
1173 function NFCPeer(peerid) {
1174   var _my_id = peerid;
1175
1176   function isConnectedGetter() {
1177     var ret = native_.callSync('NFCAdapter_PeerIsConnectedGetter', {'id' : _my_id});
1178     if (native_.isFailure(ret)) {
1179       return false;
1180     }
1181     return native_.getResultObject(ret);
1182   }
1183
1184   NFCPeer.prototype.sendNDEF = function() {
1185     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_P2P);
1186
1187     var args = validator_.validateArgs(arguments, [
1188       {
1189         name: 'message',
1190         type: types_.PLATFORM_OBJECT,
1191         values: tizen.NDEFMessage
1192       },
1193       {
1194         name: 'successCallback',
1195         type: types_.FUNCTION,
1196         optional: true,
1197         nullable: true
1198       },
1199       {
1200         name: 'errorCallback',
1201         type: types_.FUNCTION,
1202         optional: true,
1203         nullable: true
1204       }
1205     ]);
1206
1207     var result = native_.call('NFCPeer_sendNDEF', {
1208       'id' : _my_id,
1209       'records' : args.message.records,
1210       'recordsSize' : args.message.recordCount
1211     }, function(result) {
1212       if (native_.isFailure(result)) {
1213         args.errorCallback(result.error);
1214       } else {
1215         args.successCallback();
1216       }
1217     });
1218
1219     if (native_.isFailure(result)) {
1220       throw native_.getErrorObject(result);
1221     }
1222   };
1223
1224   NFCPeer.prototype.setReceiveNDEFListener = function() {
1225     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_P2P);
1226
1227     var args = validator_.validateArgs(arguments, [
1228       {
1229         name: 'listener',
1230         type: types_.FUNCTION
1231       }
1232     ]);
1233
1234     var listener = function(msg) {
1235       var data = undefined;
1236       if ('onsuccess' === msg.action && _my_id === msg.id) {
1237         data = new tizen.NDEFMessage(toRecordsArray(msg.records));
1238       }
1239       args.listener(data);
1240     };
1241
1242     var result = native_.callSync('NFCPeer_setReceiveNDEFListener', {'id' : _my_id});
1243     if (native_.isFailure(result)) {
1244       throw native_.getErrorObject(result);
1245     }
1246
1247     native_.addListener(RECEIVE_NDEF_LISTENER, listener);
1248     return;
1249   };
1250
1251   NFCPeer.prototype.unsetReceiveNDEFListener = function() {
1252     xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.NFC_P2P);
1253
1254     native_.removeListener(RECEIVE_NDEF_LISTENER);
1255
1256     var result = native_.callSync('NFCPeer_unsetReceiveNDEFListener', {'id' : _my_id});
1257     if (native_.isFailure(result)) {
1258       throw native_.getErrorObject(result);
1259     }
1260
1261     return;
1262   };
1263
1264   Object.defineProperties(this, {
1265     isConnected: {
1266       enumerable: true,
1267       set: function() {},
1268       get: isConnectedGetter
1269     }
1270   });
1271 }
1272
1273 var toByteArray = function(array, max_size, nullable) {
1274   var resultArray = [];
1275   if (type_.isNullOrUndefined(array) && nullable === true)
1276     return resultArray;
1277
1278   var convertedArray = converter_.toArray(array);
1279   var len = convertedArray.length;
1280
1281   if (len > max_size)
1282     throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1283   for (var i = 0; i < len; i++) {
1284     resultArray.push(converter_.toOctet(convertedArray[i]));
1285   }
1286   return resultArray;
1287 };
1288
1289 var isArrayOfType = function(array, type) {
1290   for (var i = 0; i < array.length; i++) {
1291     if (!(array[i] instanceof type))
1292       return false;
1293   }
1294   return true;
1295 };
1296
1297 //////////////////NDEFMessage /////////////////
1298 //[Constructor(),
1299 // Constructor(NDEFRecord[] ndefRecords),
1300 // Constructor(byte[] rawData)]
1301 //interface NDEFMessage {
1302 //  readonly attribute long recordCount;
1303 //
1304 //  attribute NDEFRecord[] records;
1305 //
1306 //  byte[] toByte() raises(WebAPIException);
1307 //};
1308
1309 tizen.NDEFMessage = function(data) {
1310   validator_.isConstructorCall(this, tizen.NDEFMessage);
1311   var records_ = [];
1312   try {
1313     if (arguments.length >= 1) {
1314       if (type_.isArray(data)) {
1315         if (isArrayOfType(data, tizen.NDEFRecord)) {
1316           records_ = data;
1317         } else {
1318           var raw_data_ = toByteArray(data);
1319           var result = native_.callSync(
1320               'NDEFMessage_constructor', {
1321                                 'rawData': raw_data_,
1322                                 'rawDataSize' : raw_data_.length
1323               }
1324               );
1325
1326           if (native_.isFailure(result)) {
1327             throw native_.getErrorObject(result);
1328           }
1329
1330           var records_array = result.result.records;
1331           for (var i = 0; i < records_array.length; i++) {
1332             records_.push(new tizen.NDEFRecord(records_array[i].tnf,
1333                                 records_array[i].type, records_array[i].payload,
1334                                 records_array[i].id));
1335           }
1336         }
1337       } else {
1338         throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1339       }
1340     }
1341   } catch (e) {
1342     //constructor call failed - empty object should be created
1343     records_ = undefined;
1344   }
1345
1346   var recordsSetter = function(data) {
1347     if (type_.isArray(data)) {
1348       // Do not check type of array elements - allow all arrays
1349       //if ( isArrayOfType(data, tizen.NDEFRecord) ) {
1350       records_ = data;
1351       //}
1352     }
1353   };
1354
1355   Object.defineProperties(this, {
1356     recordCount: { enumerable: true,
1357       set: function() {},
1358       get: function() { return records_ ? records_.length : undefined;}},
1359     records: { enumerable: true,
1360       set: recordsSetter,
1361       get: function() {return records_;}}
1362   });
1363 };
1364
1365 tizen.NDEFMessage.prototype.toByte = function() {
1366   var result = native_.callSync(
1367       'NDEFMessage_toByte', {
1368         'records' : this.records,
1369         'recordsSize' : this.recordCount
1370       }
1371       );
1372   if (native_.isFailure(result)) {
1373     throw native_.getErrorObject(result);
1374   }
1375
1376   return toByteArray(result.result.bytes);
1377 };
1378
1379 //helper for inherited object constructors /////////////////////////////////////////////
1380 function InternalData() {
1381 }
1382
1383 //////////////////NDEFRecord /////////////////
1384 tizen.NDEFRecord = function(first, type, payload, id) {
1385   var tnf_ = undefined;
1386   var typ_ = undefined;
1387   var payload_ = undefined;
1388   var id_ = undefined;
1389   //if it is inherited call, then ignore validation
1390   if (!(first instanceof InternalData)) {
1391     validator_.isConstructorCall(this, tizen.NDEFRecord);
1392     try {
1393       if (arguments.length >= 1) {
1394         if (type_.isArray(first)) {
1395           var raw_data_ = toByteArray(first);
1396           var result = native_.callSync(
1397               'NDEFRecord_constructor', {
1398                 'rawData': raw_data_,
1399                 'rawDataSize' : raw_data_.length
1400               }
1401               );
1402           if (native_.isFailure(result)) {
1403             throw native_.getErrorObject(result);
1404           }
1405           tnf_ = converter_.toLong(result.result.tnf);
1406           typ_ = toByteArray(result.result.type, 255);
1407           payload_ = toByteArray(result.result.payload, Math.pow(2, 32) - 1);
1408           id_ = toByteArray(result.result.id, 255);
1409         } else if (arguments.length >= 3) {
1410           tnf_ = converter_.toLong(first);
1411           typ_ = toByteArray(type, 255);
1412           payload_ = toByteArray(payload, Math.pow(2, 32) - 1);
1413           id_ = toByteArray(id, 255, true, []);
1414         }
1415       } else {
1416         throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1417       }
1418     } catch (e) {
1419       //constructor call failed - empty object should be created
1420       tnf_ = undefined;
1421       typ_ = undefined;
1422       payload_ = undefined;
1423       id_ = undefined;
1424     }
1425   }
1426
1427   Object.defineProperties(this, {
1428     tnf: {value: tnf_, writable: false, enumerable: true},
1429     type: {value: typ_, writable: false, enumerable: true},
1430     id: {value: id_, writable: false, enumerable: true},
1431     payload: {value: payload_, writable: false, enumerable: true}
1432   });
1433 };
1434
1435 //////////////////NDEFRecordText /////////////////
1436 tizen.NDEFRecordText = function(text, languageCode, encoding, internal_) {
1437   var text_ = undefined;
1438   var languageCode_ = undefined;
1439   var encoding_ = NDEFRecordTextEncoding[encoding] ?
1440       NDEFRecordTextEncoding[encoding] : NDEFRecordTextEncoding['UTF8'];
1441   try {
1442     if (arguments.length >= 2) {
1443       text_ = converter_.toString(text);
1444       languageCode_ = converter_.toString(languageCode);
1445
1446       if (!type_.isNullOrUndefined(internal_) && (internal_ instanceof InternalRecordData)) {
1447         tizen.NDEFRecord.call(this, internal_.tnf, internal_.type, internal_.payload, internal_.id);
1448       } else {
1449         var result = native_.callSync(
1450             'NDEFRecordText_constructor', {
1451               'text': text_,
1452               'languageCode' : languageCode_,
1453               'encoding' : encoding_
1454             }
1455             );
1456         if (native_.isFailure(result)) {
1457           throw native_.getErrorObject(result);
1458         }
1459         tizen.NDEFRecord.call(this, result.result.tnf, result.result.type,
1460             result.result.payload, result.result.id);
1461       }
1462     } else {
1463       throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1464     }
1465   } catch (e) {
1466     //constructor call failed - empty object should be created
1467     tizen.NDEFRecord.call(this);
1468     text_ = undefined;
1469     languageCode_ = undefined;
1470     encoding_ = undefined;
1471   }
1472
1473   Object.defineProperties(this, {
1474     text: {value: text_, writable: false, enumerable: true},
1475     languageCode: {value: languageCode_, writable: false, enumerable: true},
1476     encoding: {value: encoding_, writable: false, enumerable: true}
1477   });
1478 };
1479
1480 tizen.NDEFRecordText.prototype = new tizen.NDEFRecord(new InternalData());
1481
1482 tizen.NDEFRecordText.prototype.constructor = tizen.NDEFRecordText;
1483
1484 //////////////////NDEFRecordURI /////////////////
1485 tizen.NDEFRecordURI = function(uri, internal_) {
1486   var uri_ = undefined;
1487   try {
1488     if (arguments.length >= 1) {
1489       uri_ = converter_.toString(uri);
1490
1491       if (!type_.isNullOrUndefined(internal_) && (internal_ instanceof InternalRecordData)) {
1492         tizen.NDEFRecord.call(this, internal_.tnf, internal_.type, internal_.payload, internal_.id);
1493       } else {
1494         var result = native_.callSync(
1495             'NDEFRecordURI_constructor', {
1496               'uri': uri_
1497             }
1498             );
1499         if (native_.isFailure(result)) {
1500           throw native_.getErrorObject(result);
1501         }
1502         tizen.NDEFRecord.call(this, result.result.tnf, result.result.type,
1503             result.result.payload, result.result.id);
1504       }
1505     } else {
1506       throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1507     }
1508   } catch (e) {
1509     //constructor call failed - empty object should be created
1510     tizen.NDEFRecord.call(this);
1511     uri_ = undefined;
1512   }
1513
1514   Object.defineProperties(this, {
1515     uri: {value: uri_, writable: false, enumerable: true}
1516   });
1517 };
1518
1519 tizen.NDEFRecordURI.prototype = new tizen.NDEFRecord(new InternalData());
1520
1521 tizen.NDEFRecordURI.prototype.constructor = tizen.NDEFRecordURI;
1522
1523 //////////////////NDEFRecordMedia /////////////////
1524 tizen.NDEFRecordMedia = function(mimeType, data, internal_) {
1525   var mimeType_ = undefined;
1526   var data_ = undefined;
1527   try {
1528     if (arguments.length >= 2) {
1529       mimeType_ = converter_.toString(mimeType);
1530       data_ = toByteArray(data, Math.pow(2, 32) - 1);
1531
1532       if (!type_.isNullOrUndefined(internal_) && (internal_ instanceof InternalRecordData)) {
1533         tizen.NDEFRecord.call(this, internal_.tnf, internal_.type, internal_.payload, internal_.id);
1534       } else {
1535         var result = native_.callSync(
1536             'NDEFRecordMedia_constructor', {
1537               'mimeType': mimeType_,
1538               'data': data_,
1539               'dataSize': data_.length
1540             }
1541             );
1542         if (native_.isFailure(result)) {
1543           throw native_.getErrorObject(result);
1544         }
1545         tizen.NDEFRecord.call(this, result.result.tnf, result.result.type,
1546             result.result.payload, result.result.id);
1547       }
1548     } else {
1549       throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
1550     }
1551   } catch (e) {
1552     //constructor call failed - empty object should be created
1553     tizen.NDEFRecord.call(this);
1554     mimeType_ = undefined;
1555   }
1556
1557   Object.defineProperties(this, {
1558     mimeType: {value: mimeType_, writable: false, enumerable: true}
1559   });
1560 };
1561
1562 tizen.NDEFRecordMedia.prototype = new tizen.NDEFRecord(new InternalData());
1563
1564 tizen.NDEFRecordMedia.prototype.constructor = tizen.NDEFRecordMedia;
1565 //Exports
1566 exports = new NFCManager();