src/nfc/nfc_api.js

   1 // Copyright 2014 Samsung Electronics Co, Ltd. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 var validator_ = xwalk.utils.validator;
   6 var types_ = validator_.Types;
   7 var T_ = xwalk.utils.type;
   8 var Converter_ = xwalk.utils.converter;
   9 var native_ = new xwalk.utils.NativeManager(extension);
  10
  11 function ListenerManager(native, listenerName) {
  12     this.listeners = {};
  13     this.nextId = 1;
  14     this.nativeSet = false;
  15     this.native = native;
  16     this.listenerName = listenerName;
  17 }
  18
  19 ListenerManager.prototype.onListenerCalled = function(msg) {
  20     for (var key in this.listeners) {
  21         if (this.listeners.hasOwnProperty(key)) {
  22             if ('CardElement' == msg.type) {
  23                 this.listeners[key](msg.mode);
  24             } else if ('Transaction' == msg.type) {
  25                 this.listeners[key](msg.aid, msg.data);
  26             }
  27       }
  28     }
  29 };
  30
  31 ListenerManager.prototype.addListener = function(callback) {
  32     var id = this.nextId;
  33     if (!this.nativeSet) {
  34       this.native.addListener(this.listenerName, this.onListenerCalled.bind(this));
  35       this.nativeSet = true;
  36     }
  37     this.listeners[id] = callback;
  38     ++this.nextId;
  39     return id;
  40 };
  41
  42 ListenerManager.prototype.removeListener = function(watchId) {
  43     if (this.listeners.hasOwnProperty(watchId)) {
  44         delete this.listeners[watchId];
  45     }
  46 };
  47
  48 var CARD_EMULATION_MODE_LISTENER = 'CardEmulationModeChanged';
  49 var ACTIVE_SECURE_ELEMENT_LISTENER = 'ActiveSecureElementChanged';
  50 var TRANSACTION_EVENT_ESE_LISTENER = 'TransactionEventListener_ESE';
  51 var TRANSACTION_EVENT_UICC_LISTENER = 'TransactionEventListener_UICC';
  52 var cardEmulationModeListener = new ListenerManager(native_, CARD_EMULATION_MODE_LISTENER);
  53 var activeSecureElementChangeListener = new ListenerManager(native_, ACTIVE_SECURE_ELEMENT_LISTENER);
  54 var transactionEventListenerEse = new ListenerManager(native_, TRANSACTION_EVENT_ESE_LISTENER);
  55 var transactionEventListenerUicc = new ListenerManager(native_, TRANSACTION_EVENT_UICC_LISTENER);
  56
  57 //enumeration NDEFRecordTextEncoding ////////////////////////////////////////////////////
  58 var NDEFRecordTextEncoding = {
  59     UTF8 : 'UTF8',
  60     UTF16 : 'UTF16'
  61 };
  62
  63 //enumeration NFCTagType ////////////////////////////////////////////////////
  64 var NFCTagType = {
  65     GENERIC_TARGET : 'GENERIC_TARGET',
  66     ISO14443_A : 'ISO14443_A',
  67     ISO14443_4A : 'ISO14443_4A',
  68     ISO14443_3A : 'ISO14443_3A',
  69     MIFARE_MINI : 'MIFARE_MINI',
  70     MIFARE_1K : 'MIFARE_1K',
  71     MIFARE_4K : 'MIFARE_4K',
  72     MIFARE_ULTRA : 'MIFARE_ULTRA',
  73     MIFARE_DESFIRE : 'MIFARE_DESFIRE',
  74     ISO14443_B : 'ISO14443_B',
  75     ISO14443_4B : 'ISO14443_4B',
  76     ISO14443_BPRIME : 'ISO14443_BPRIME',
  77     FELICA : 'FELICA',
  78     JEWEL : 'JEWEL',
  79     ISO15693 : 'ISO15693',
  80     UNKNOWN_TARGET : 'UNKNOWN_TARGET'
  81 };
  82
  83 ////enumeration CardEmulationMode ////////////////////////////////////////////////////
  84 var CardEmulationMode = {
  85     ALWAYS_ON : 'ALWAYS_ON',
  86     OFF : 'OFF'
  87 };
  88
  89 ////enumeration SecureElementType ////////////////////////////////////////////////////
  90 var SecureElementType = {
  91     ESE : 'ESE',
  92     UICC : 'UICC'
  93 };
  94
  95 //////////////////NFCManager /////////////////
  96
  97 function NFCManager() {
  98     Object.defineProperties(this, {
  99         NFC_RECORD_TNF_EMPTY:   {value: 0, writable: false, enumerable: true},
 100         NFC_RECORD_TNF_WELL_KNOWN:    {value: 1, writable: false, enumerable: true},
 101         NFC_RECORD_TNF_MIME_MEDIA:    {value: 2, writable: false, enumerable: true},
 102         NFC_RECORD_TNF_URI:    {value: 3, writable: false, enumerable: true},
 103         NFC_RECORD_TNF_EXTERNAL_RTD:    {value: 4, writable: false, enumerable: true},
 104         NFC_RECORD_TNF_UNKNOWN:    {value: 5, writable: false, enumerable: true},
 105         NFC_RECORD_TNF_UNCHANGED:    {value: 6, writable: false, enumerable: true}
 106     });
 107 }
 108
 109 NFCManager.prototype.getDefaultAdapter = function() {
 110     // First check NFC suppor on C++ level
 111     var result = native_.callSync(
 112         'NFCManager_getDefaultAdapter',
 113         {}
 114     );
 115     if(native_.isFailure(result)) {
 116         throw new tizen.WebAPIException(0, result.error.message,
 117                 result.error.name);
 118     }
 119
 120     // If NFC is supported then return new NFCAdapter instance
 121     return new NFCAdapter();
 122 };
 123
 124 NFCManager.prototype.setExclusiveMode = function() {
 125
 126     var args = validator_.validateArgs(arguments, [
 127         {name: 'exclusiveMode', type: types_.BOOLEAN}
 128     ]);
 129
 130     var result = native_.callSync(
 131         'NFCManager_setExclusiveMode',
 132         { 'exclusiveMode': args.exclusiveMode}
 133     );
 134
 135     // If failed then exception should be thrown.
 136     if(native_.isFailure(result)) {
 137         throw new tizen.WebAPIException(0, result.error.message,
 138                 result.error.name);
 139         // Uncoment line below (and remove line above) when problem
 140         // with error conversion is fixed:
 141         //
 142         //throw native_.getErrorObject(result);
 143     }
 144     // Otherwise just return
 145     return;
 146 };
 147
 148 //////////////////NFCAdapter /////////////////
 149
 150 function NFCAdapter() {
 151     function poweredGetter() {
 152         var ret = native_.callSync('NFCAdapter_getPowered');
 153
 154         if (native_.isFailure(ret)) {
 155             return false;
 156         }
 157
 158         return native_.getResultObject(ret);
 159     }
 160
 161     function cardEmulationModeGetter() {
 162         var result = native_.callSync('NFCAdapter_cardEmulationModeGetter');
 163
 164         if (native_.isFailure(result)) {
 165             throw new tizen.WebAPIException(0, result.error.message, result.error.name);
 166         }
 167
 168         return native_.getResultObject(result);
 169     }
 170
 171     function cardEmulationModeSetter(cem) {
 172
 173         var args = validator_.validateArgs(arguments, [
 174             {name: 'emulationMode', type: types_.STRING}
 175         ]);
 176
 177         var result = native_.callSync(
 178             'NFCAdapter_cardEmulationModeSetter',
 179             { 'emulationMode': args.emulationMode}
 180         );
 181
 182         if(native_.isFailure(result)) {
 183             throw new tizen.WebAPIException(0, result.error.message, result.error.name);
 184         }
 185         return;
 186     }
 187
 188     function activeSecureElementGetter() {
 189
 190         var result = native_.callSync('NFCAdapter_activeSecureElementGetter');
 191
 192         if (native_.isFailure(result)) {
 193             throw new tizen.WebAPIException(0, result.error.message, result.error.name);
 194         }
 195
 196         return native_.getResultObject(result);
 197     }
 198
 199     function activeSecureElementSetter(ase) {
 200
 201         var args = validator_.validateArgs(arguments, [
 202             {name: 'secureElement', type: types_.STRING}
 203         ]);
 204
 205         var result = native_.callSync(
 206             'NFCAdapter_activeSecureElementSetter',
 207             { 'secureElement': args.secureElement}
 208         );
 209
 210         if(native_.isFailure(result)) {
 211             throw new tizen.WebAPIException(0, result.error.message, result.error.name);
 212         }
 213         return;
 214     }
 215
 216     Object.defineProperties(this, {
 217         powered:   {enumerable: true,
 218             set : function(){},
 219             get : poweredGetter
 220         },
 221         cardEmulationMode:   {enumerable: true,
 222             set : cardEmulationModeSetter,
 223             get : cardEmulationModeGetter
 224         },
 225         activeSecureElement:   {enumerable: true,
 226             set : activeSecureElementSetter,
 227             get : activeSecureElementGetter
 228         }
 229     });
 230 };
 231
 232 NFCAdapter.prototype.setPowered = function() {
 233     var args = validator_.validateArgs(arguments, [
 234         {
 235             name : 'powered',
 236             type : types_.BOOLEAN
 237         },
 238         {
 239             name : 'successCallback',
 240             type : types_.FUNCTION,
 241             optional : true,
 242             nullable : true
 243         },
 244         {
 245             name : 'errorCallback',
 246             type : types_.FUNCTION,
 247             optional : true,
 248             nullable : true
 249         }
 250     ]);
 251
 252     native_.call('NFCAdapter_setPowered', {
 253         powered: args.powered
 254     }, function(result) {
 255         if (native_.isFailure(result)) {
 256             args.errorCallback(result.error);
 257         } else {
 258             args.successCallback();
 259         }
 260     });
 261 };
 262
 263 NFCAdapter.prototype.setTagListener  = function() {
 264
 265 };
 266
 267 NFCAdapter.prototype.setPeerListener = function() {
 268
 269 };
 270
 271 NFCAdapter.prototype.unsetTagListener = function() {
 272
 273 };
 274
 275 NFCAdapter.prototype.unsetPeerListener = function() {
 276
 277 };
 278
 279 NFCAdapter.prototype.addCardEmulationModeChangeListener = function() {
 280     var args = validator_.validateArgs(arguments, [
 281         {
 282             name: 'callback',
 283             type: types_.LISTENER,
 284             values: ['onchanged']
 285         }
 286     ]);
 287
 288     if (T_.isEmptyObject(cardEmulationModeListener.listeners) &&
 289             T_.isEmptyObject(activeSecureElementChangeListener.listeners)) {
 290         var result = native_.callSync(
 291                 'NFCAdapter_addCardEmulationModeChangeListener');
 292         if (native_.isFailure(result)) {
 293             throw new tizen.WebAPIException(0, result.error.message,
 294                     result.error.name);
 295         }
 296     }
 297
 298     return cardEmulationModeListener.addListener(args.callback);
 299 };
 300
 301 NFCAdapter.prototype.removeCardEmulationModeChangeListener = function() {
 302     var args = validator_.validateArgs(arguments, [
 303         {
 304             name: 'listenerId',
 305             type: types_.LONG
 306         }
 307     ]);
 308     cardEmulationModeListener.removeListener(args.listenerId);
 309
 310     if (T_.isEmptyObject(cardEmulationModeListener.listeners) &&
 311             T_.isEmptyObject(activeSecureElementChangeListener.listeners)) {
 312         native_.callSync('NFCAdapter_removeCardEmulationModeChangeListener');
 313     }
 314 };
 315
 316 NFCAdapter.prototype.addTransactionEventListener = function() {
 317     var args = validator_.validateArgs(arguments, [
 318         {
 319             name: 'type',
 320             type: types_.ENUM,
 321             values: T_.getValues(SecureElementType)
 322         },
 323         {
 324             name: 'callback',
 325             type: types_.LISTENER,
 326             values: ['ondetected']
 327         }
 328     ]);
 329
 330     var result;
 331
 332     if (SecureElementType.ESE == args.type) {
 333         if (T_.isEmptyObject(transactionEventListenerEse.listeners)) {
 334             result = native_.callSync('NFCAdapter_addTransactionEventListener',{
 335                 type: args.type});
 336             if (native_.isFailure(result)) {
 337                 throw new tizen.WebAPIException(0, result.error.message,
 338                         result.error.name);
 339             }
 340         }
 341         return transactionEventListenerEse.addListener(args.callback);
 342     } else {
 343         if (T_.isEmptyObject(transactionEventListenerUicc.listeners)) {
 344             result = native_.callSync('NFCAdapter_addTransactionEventListener',{
 345                 type: args.type});
 346             if (native_.isFailure(result)) {
 347                 throw new tizen.WebAPIException(0, result.error.message,
 348                         result.error.name);
 349             }
 350         }
 351         return transactionEventListenerUicc.addListener(args.callback);
 352     }
 353 };
 354
 355 NFCAdapter.prototype.removeTransactionEventListener = function() {
 356     var args = validator_.validateArgs(arguments, [
 357         {
 358             name: 'watchId',
 359             type: types_.LONG
 360         }
 361     ]);
 362
 363     var ese_empty = T_.isEmptyObject(transactionEventListenerEse.listeners)
 364     var uicc_empty = T_.isEmptyObject(transactionEventListenerUicc.listeners)
 365
 366     transactionEventListenerEse.removeListener(args.watchId);
 367     transactionEventListenerUicc.removeListener(args.watchId);
 368
 369     if (T_.isEmptyObject(transactionEventListenerEse.listeners) && !ese_empty) {
 370         native_.callSync('NFCAdapter_removeTransactionEventListener',{
 371             type: SecureElementType.ESE});
 372     }
 373
 374     if (T_.isEmptyObject(transactionEventListenerUicc.listeners)
 375             && !uicc_empty) {
 376         native_.callSync('NFCAdapter_removeTransactionEventListener',{
 377             type: SecureElementType.UICC});
 378     }
 379
 380 };
 381
 382 NFCAdapter.prototype.addActiveSecureElementChangeListener = function() {
 383     var args = validator_.validateArgs(arguments, [
 384        {
 385            name: 'callback',
 386            type: types_.LISTENER,
 387            values: ['onchanged']
 388        }
 389    ]);
 390
 391     if (T_.isEmptyObject(cardEmulationModeListener.listeners) &&
 392             T_.isEmptyObject(activeSecureElementChangeListener.listeners)) {
 393         var result = native_.callSync(
 394                 'NFCAdapter_addActiveSecureElementChangeListener');
 395         if (native_.isFailure(result)) {
 396             throw new tizen.WebAPIException(0, result.error.message,
 397                     result.error.name);
 398         }
 399     }
 400
 401    return activeSecureElementChangeListener.addListener(args.callback);
 402 };
 403
 404 NFCAdapter.prototype.removeActiveSecureElementChangeListener = function() {
 405     var args = validator_.validateArgs(arguments, [
 406         {
 407             name: 'listenerId',
 408             type: types_.LONG
 409         }
 410     ]);
 411     activeSecureElementChangeListener.removeListener(args.listenerId);
 412
 413     if (T_.isEmptyObject(cardEmulationModeListener.listeners) &&
 414             T_.isEmptyObject(activeSecureElementChangeListener.listeners)) {
 415         native_.callSync('NFCAdapter_removeCardEmulationModeChangeListener');
 416     }
 417 };
 418
 419 NFCAdapter.prototype.getCachedMessage = function() {
 420
 421 };
 422
 423 NFCAdapter.prototype.setExclusiveModeForTransaction = function() {
 424
 425     var args = validator_.validateArgs(arguments, [
 426         {
 427             name : 'transactionMode',
 428             type : types_.BOOLEAN
 429         }
 430     ]);
 431
 432     var result = native_.callSync(
 433         'NFCAdapter_setExclusiveModeForTransaction',
 434         { 'transactionMode': args.transactionMode}
 435     );
 436
 437     if(native_.isFailure(result)) {
 438         throw new tizen.WebAPIException(0, result.error.message, result.error.name);
 439         // throw native_.getErrorObject(result);
 440     }
 441     return;
 442 };
 443
 444 //////////////////NFCTag /////////////////
 445
 446 function NFCTag(data) {
 447     Object.defineProperties(this, {
 448         type:   {value: data.type, writable: false, enumerable: true},
 449         isSupportedNDEF:   {value: data.isSupportedNDEF,
 450             writable: true, enumerable: true},
 451         ndefSize:   {value: data.ndefSize,
 452             writable: true, enumerable: true},
 453         properties:   {value: data.properties, writable: true, enumerable: true},
 454         isConnected:   {value: data.isConnected,
 455             writable: true, enumerable: true}
 456     });
 457 }
 458
 459 NFCTag.prototype.readNDEF = function() {
 460
 461 };
 462
 463 NFCTag.prototype.writeNDEF = function() {
 464
 465 };
 466
 467 NFCTag.prototype.transceive = function() {
 468
 469 };
 470
 471 //////////////////NFCPeer /////////////////
 472
 473 function NFCPeer(data) {
 474     Object.defineProperties(this, {
 475         isConnected:   {value: data.isConnected,
 476             writable: true, enumerable: true}
 477     });
 478 }
 479
 480 NFCPeer.prototype.setReceiveNDEFListener = function() {
 481
 482 };
 483
 484 NFCPeer.prototype.unsetReceiveNDEFListener = function() {
 485
 486 };
 487
 488 NFCPeer.prototype.sendNDEF = function() {
 489
 490 };
 491
 492
 493 var toByteArray = function(array, max_size, nullable) {
 494     var resultArray = [];
 495     if (T_.isNullOrUndefined(array) && nullable === true)
 496         return resultArray;
 497
 498     var convertedArray = Converter_.toArray(array);
 499     var len = convertedArray.length;
 500
 501     if (len > max_size)
 502         throw new tizen.WebAPIException(tizen.WebAPIException.INVALID_VALUES_ERR);
 503     for (var i = 0; i < len; i++){
 504         resultArray.push(Converter_.toByte(convertedArray[i]));
 505     }
 506     return resultArray;
 507 }
 508
 509 var isArrayOfType = function(array, type) {
 510     for (var i = 0; i < array.length; i++) {
 511         if (!(array[i] instanceof type))
 512             return false;
 513     }
 514     return true;
 515 }
 516
 517 //////////////////NDEFMessage /////////////////
 518 //[Constructor(),
 519 // Constructor(NDEFRecord[] ndefRecords),
 520 // Constructor(byte[] rawData)]
 521 //interface NDEFMessage {
 522 //  readonly attribute long recordCount;
 523 //
 524 //  attribute NDEFRecord[] records;
 525 //
 526 //  byte[] toByte() raises(WebAPIException);
 527 //};
 528
 529 tizen.NDEFMessage = function(data) {
 530     var records_ = [];
 531     var recordCount_ = 0;
 532
 533     try {
 534         if (arguments.length >= 1) {
 535             if (T_.isArray(data)) {
 536                 if ( isArrayOfType(data, tizen.NDEFRecord) ) {
 537                     records_ = data;
 538                     recordCount_ = data.length;
 539                 } else {
 540                     var raw_data_ = toByteArray(data);
 541 //                  var result = native_.callSync(
 542 //                  'NDEFMessage_constructor', {
 543 //                  'rawData': raw_data_,
 544 //                  'rawDataSize' : raw_data_.length
 545 //                  }
 546 //                  );
 547 //                  //set all needed fields here basing on result object
 548                 }
 549             } else {
 550                 throw new tizen.WebAPIException(tizen.WebAPIException.INVALID_VALUES_ERR);
 551             }
 552         }
 553     } catch (e) {
 554         //constructor call failed - empty object should be created
 555         records_ = undefined;
 556         recordCount_ = undefined;
 557     }
 558
 559     var recordsSetter = function(data){
 560         if (T_.isArray(data)) {
 561             if ( isArrayOfType(data, tizen.NDEFRecord) ) {
 562                 recordCount_ = data.length;
 563                 records_ = data;
 564             }
 565         }
 566     }
 567
 568     Object.defineProperties(this, {
 569         recordCount:   { enumerable: true,
 570             set : function(){},
 571             get : function(){return recordCount_;}},
 572         records:   { enumerable: true,
 573             set : recordsSetter,
 574             get : function(){return records_;}}
 575     });
 576 };
 577
 578 tizen.NDEFMessage.prototype.toByte = function() {
 579
 580 };
 581
 582 //helper for inherited object constructors /////////////////////////////////////////////
 583 function InternalData() {
 584 }
 585
 586 //////////////////NDEFRecord /////////////////
 587 tizen.NDEFRecord = function(first, type, payload, id) {
 588     var tnf_ = undefined;
 589     var type_ = undefined;
 590     var payload_ = undefined;
 591     var id_ = undefined;
 592     //if it is inherited call, then ignore validation
 593     if ( !(first instanceof InternalData) ){
 594         try {
 595             if (arguments.length >= 1) {
 596                 if (T_.isArray(first)) {
 597                     var raw_data_ = toByteArray(first);
 598 //                  var result = native_.callSync(
 599 //                  'NDEFRecord_constructor', {
 600 //                  'rawData': raw_data_,
 601 //                  'rawDataSize' : raw_data_.length
 602 //                  }
 603 //                  );
 604 //                  //set all needed fields here basing on result object
 605                 } else if (arguments.length >= 3){
 606                     tnf_ = Converter_.toLong(first);
 607                     type_ = toByteArray(type, 255);
 608                     payload_ = toByteArray(payload, Math.pow(2, 32)-1);
 609                     id_ = toByteArray(id, 255, true, []);
 610                 }
 611             } else {
 612                 throw new tizen.WebAPIException(tizen.WebAPIException.INVALID_VALUES_ERR);
 613             }
 614         } catch (e) {
 615             //constructor call failed - empty object should be created
 616             tnf_ = undefined;
 617             type_ = undefined;
 618             payload_ = undefined;
 619             id_ = undefined;
 620         }
 621     }
 622
 623     Object.defineProperties(this, {
 624         tnf:   {value: tnf_, writable: false, enumerable: true},
 625         type:   {value: type_, writable: false, enumerable: true},
 626         id:   {value: id_, writable: false, enumerable: true},
 627         payload:   {value: payload_, writable: false, enumerable: true},
 628     });
 629 };
 630
 631 //////////////////NDEFRecordText /////////////////
 632 var ENCODING = ["UTF8", "UTF16"];
 633
 634 tizen.NDEFRecordText = function(text, languageCode, encoding) {
 635     var text_ = undefined;
 636     var languageCode_ = undefined;
 637     var encoding_ = ENCODING[0];
 638     try {
 639         if (arguments.length >= 2) {
 640             text_ = Converter_.toString(text);
 641             languageCode_ = Converter_.toString(languageCode);
 642
 643             if (!T_.isNullOrUndefined(encoding)) {
 644                 encoding_ = Converter_.toEnum(encoding, ENCODING, true);
 645             }
 646
 647 //          call parent constructor
 648 //          var result = native_.callSync(
 649 //          'NDEFRecordText_constructor', {
 650 //          'text': text_,
 651 //          'languageCode' : languageCode_,
 652 //          'encoding' : encoding_,
 653 //          }
 654 //          );
 655 //          //set all needed fields here basing on result object
 656             tizen.NDEFRecord.call(this, 1, [1,2,3], [1,2,3], [1,2,3]);
 657         } else {
 658             throw new tizen.WebAPIException(tizen.WebAPIException.INVALID_VALUES_ERR);
 659         }
 660     } catch (e) {
 661         //constructor call failed - empty object should be created
 662         tizen.NDEFRecord.call(this);
 663         text_ = undefined;
 664         languageCode_ = undefined;
 665         encoding_ = undefined;
 666     }
 667
 668     Object.defineProperties(this, {
 669         text:   {value: text_, writable: false, enumerable: true},
 670         languageCode:   {value: languageCode_, writable: false, enumerable: true},
 671         encoding:   {value: encoding_, writable: false, enumerable: true},
 672     });
 673 };
 674
 675 tizen.NDEFRecordText.prototype = new tizen.NDEFRecord(new InternalData());
 676
 677 tizen.NDEFRecordText.prototype.constructor = tizen.NDEFRecordText;
 678
 679 //////////////////NDEFRecordURI /////////////////
 680 tizen.NDEFRecordURI = function(uri) {
 681     var uri_ = undefined;
 682     try {
 683         if (arguments.length >= 1) {
 684             uri_ = Converter_.toString(uri);
 685
 686 //          call parent constructor
 687 //          var result = native_.callSync(
 688 //          'NDEFRecordURI_constructor', {
 689 //          'uri': uri_
 690 //          }
 691 //          );
 692 //          //set all needed fields here basing on result object
 693             tizen.NDEFRecord.call(this, 1, [1,2,3], [1,2,3], [1,2,3]);
 694         } else {
 695             throw new tizen.WebAPIException(tizen.WebAPIException.INVALID_VALUES_ERR);
 696         }
 697     } catch (e) {
 698         //constructor call failed - empty object should be created
 699         tizen.NDEFRecord.call(this);
 700         uri_ = undefined;
 701     }
 702
 703     Object.defineProperties(this, {
 704         uri:   {value: uri_, writable: false, enumerable: true}
 705     });
 706 };
 707
 708 tizen.NDEFRecordURI.prototype = new tizen.NDEFRecord(new InternalData());
 709
 710 tizen.NDEFRecordURI.prototype.constructor = tizen.NDEFRecordURI;
 711
 712 //////////////////NDEFRecordMedia /////////////////
 713 tizen.NDEFRecordMedia = function(mimeType, data) {
 714     var mimeType_ = undefined;
 715     var data_ = undefined;
 716     try {
 717         if (arguments.length >= 2) {
 718             miemType_ = Converter_.toString(mimeType);
 719             data_ = toByteArray(data, Math.pow(2, 32)-1);
 720
 721 //          call parent constructor
 722 //          var result = native_.callSync(
 723 //          'NDEFRecordMedia_constructor', {
 724 //          'mimeType': mimeType_,
 725 //            'data': data_,
 726 //          }
 727 //          );
 728 //          //set all needed fields here basing on result object
 729             tizen.NDEFRecord.call(this, 1, [1,2,3], [1,2,3], [1,2,3]);
 730         } else {
 731             throw new tizen.WebAPIException(tizen.WebAPIException.INVALID_VALUES_ERR);
 732         }
 733     } catch (e) {
 734         //constructor call failed - empty object should be created
 735         tizen.NDEFRecord.call(this);
 736         mimeType_ = undefined;
 737     }
 738
 739     Object.defineProperties(this, {
 740         mimeType:   {value: mimeType_, writable: false, enumerable: true}
 741     });
 742 };
 743
 744 tizen.NDEFRecordMedia.prototype = new tizen.NDEFRecord(new InternalData());
 745
 746 tizen.NDEFRecordMedia.prototype.constructor = tizen.NDEFRecordMedia;
 747 //Exports
 748 exports = new NFCManager();