Iotcon API

 try {
     var cborPath = "App_installed_fullpath/iotcon-test.dat"
     tizen.iotcon.initialize(cborPath);
     tizen.iotcon.deviceName = "my_test";
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 try {
     var cborPath = "App_installed_fullpath/iotcon-test.dat"
     tizen.iotcon.initialize(cborPath);
     tizen.iotcon.deviceName = "my_test";
     var iotClient = tizen.iotcon.getClient();
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 try {
     var cborPath = "App_installed_fullpath/iotcon-test.dat"
     tizen.iotcon.initialize(cborPath);
     tizen.iotcon.deviceName = "my_test";
     var iotServer = tizen.iotcon.getServer();
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 tizen.iotcon.setTimeout(60);
 var timeout  = tizen.iotcon.getTimeout();
 console.log("timeout value is " + timeout);
 

 tizen.iotcon.setTimeout(60);
 var timeout  = tizen.iotcon.getTimeout();
 console.log("timeout value is " + timeout);
 

   var watchId
   function RandomPinSuccess(pin){
       console.log("Pin code : " + pin);
       tizen.iotcon.removeGeneratedPinListener(watchId);
    }

     var cborPath = "App_installed_fullpath/iotcon-test.dat"
     tizen.iotcon.initialize(cborPath);
     watchId =tizen.iotcon.addGeneratedPinListener(RandomPinSuccess);
 

 function onerror(err) {
     console.log("Failed to find resource: " + err.message);
 }

 function foundSuccess(resource) {
     if(resource) {
         console.log("######## Found a resource ########")
         console.log("URI: " + resource.uriPath);
         console.log("Host Address: " + resource.hostAddress);
         console.log("Device ID: " + resource.deviceId);
         var resourceTypes = resource.resourceTypes;
         console.log("Resource Types: ");
         for(var index in resourceTypes) {
             console.log("    " + resourceTypes[index]);
         }
         var resourceInterfaces = resource.resourceInterfaces;
         console.log("Resource interfaces: ");
         for(var index in resourceInterfaces) {
             console.log("    " + resourceInterfaces[index]);
         }
     }
 }

 try {
     var client = tizen.iotcon.getClient();
     var hostAddress = null;
     var query = { resourceType: "core.door" };
     var connectivityType = "IP";
     client.findResource(hostAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 var client;
 var watchID;
 var connectivityType = "IP";

 function presenceSuccess(presenceResponse) {
     console.log("######## Get a presence response ########");
     if(presenceResponse.resultType != "OK") {
         console.log("the result is not OK")
         return;
     }
     console.log("Trigger type: " + presenceResponse.triggerType);
     console.log("Host address: " + presenceResponse.hostAddress);
     console.log("Connectivity type: " + presenceResponse.connectivityType);
     console.log("Presence resource type: " + presenceResponse.resourceType);

     client.removePresenceEventListener(watchID);
 }

 try {
     client = tizen.iotcon.getClient();
     watchID = client.addPresenceEventListener(null, null, connectivityType, presenceSuccess);
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 // hostDeviceIpAddress should be a valid IP address
 var hostDeviceIpAddress = "coaps://192.168.0.10:12345";
 var connectivityType = "IP";
 var query = { resourceType: "core.door" };

 function onerror(err) {
     console.log("Failed to find resource: " + err.message);
 }

 function foundSuccess(deviceInfo) {
     if(deviceInfo) {
         console.log("######## Get a device info ########");
         console.log("Name: " + deviceInfo.deviceName);                     // human friendly name for device.
         console.log("Spec version: " + deviceInfo.specVersion);            // spec version of the core specification.
         console.log("ID: " + deviceInfo.oicDeviceId);                      // unique identifier for OIC device.
         console.log("Data model version: " + deviceInfo.dataModelVersion); // version of the specs this device data model is implemented to.
     }
 }

 try {
     var client = tizen.iotcon.getClient();
     client.findDeviceInfo(hostDeviceIpAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 var hostDeviceIpAddress = "coaps://192.168.0.10:12345";
 var connectivityType = "IP";
 var query = { resourceType: "core.door" };

 function onerror(err) {
     console.log("Failed to find resource: " + err.message);
 }

 function foundSuccess(platformInfo) {
     console.log("######## Get a platform info ########");
     console.log("ID: " + platformInfo.platformId);
     console.log("Manufacturer name: " + platformInfo.manufacturerName);
     console.log("Manufacturer URL: " + platformInfo.manufacturerUrl);
     console.log("Model number: " + platformInfo.modelNumber);
     console.log("Date of manufacture: " + platformInfo.manufactureDate);
     console.log("Platform version: " + platformInfo.platformVersion);
     console.log("OS version: " + platformInfo.operatingSystemVersion);
     console.log("Hardware version: " + platformInfo.hardwareVersion);
     console.log("Firmware version: " + platformInfo.firmwareVersion);
     console.log("Support URL: " + platformInfo.supportUrl);
     console.log("System time: " + platformInfo.systemTime);
 }

 try {
     var client = tizen.iotcon.getClient();
     client.findPlatformInfo(hostDeviceIpAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 var server = tizen.iotcon.getServer();
 var resources = server.getResources();
 

 var server = tizen.iotcon.getServer();
 var doorResource;
 var uriPath = "/door";
 var resourceTypes = ["core.door"];
 var resourceInterfaces = ["oic.if.b"];
 var attributes = { openstate : 'open' };
 var policy = {
     isObservable : true,
     isDiscoverable : true
 };

 var requestListener = {
       onget: function(request) {
           console.log("onget");
           var response = new tizen.Response(request);
           try {
               var representation = new tizen.Representation(doorResource.uriPath);
               representation.resourceTypes =doorResource.resourceTypes;
               representation.resourceInterfaces = doorResource.resourceInterfaces;
               representation.attributes = attributes;
               response.representation = representation;
               response.result = "SUCCESS";
           } catch(err) {
               console.log(err.name + ": " + err.message);
               response.result = "ERROR";
           }
           response.send();
       },
       onput: function(request) {
           console.log("onput");
           //add request handle code
       },
       onpost: function(request) {
           console.log("onpost");
           //add request handle code
       },
       ondelete: function(request) {
           console.log("ondelete");
           //add request handle code
       },
       onobserving: function(request, observeType, observeId) {
           console.log("onobserving");
           //add request handle code
       }
 }

 doorResource = server.createResource(uriPath, resourceTypes, resourceInterfaces, requestListener, policy);
 

 var resource = server.createResource(uriPath, resourceTypes, resourceInterfaces, requestListener, policy);
 server.removeResource(resource);
 

 var server = tizen.iotcon.getServer();
 server.startPresence(60);

/* Do something */
 server.stopPresence();
 

 var query = {};

 function onerror(err) {
     console.log("Error occured: " + err.message);
 }

 function onresponse(remoteResponse) {
     if(remoteResponse.result != "SUCCESS") {
         console.log("the result is not SUCCESS");
         return;
     }
     var repr =  remoteResponse.representation;
     console.log("Resource attributes: ")
     for(var key in repr.attributes) {
         console.log("    key: " + key + ", value: " + repr.attributes[key]);
     }
 }

 function foundSuccess(resource) {
     if(resource){
         query["filter"] =  {openstate: 'open'};
         resource.methodGet(onresponse, query, onerror);
     }
 }

 try {
     var client = tizen.iotcon.getClient();
     var hostAddress = null;
     var query = { resourceType: "core.door" };
     var connectivityType = "IP";
     client.findResource(hostAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log (err.name +': ' + err.message);
 }
 

 var query = {};
 var representation;
 var uriPath = "/door";

 function onerror(err) {
     console.log("Error occured: " + err.message);
 }

 function onresponse(remoteResponse) {
     console.log("result is "+remoteResponse.result );
     var repr =  remoteResponse.representation;
     console.log("representation attributes: ")
     for(var key in repr.attributes) {
         console.log("    key: " + key + ", value: " + repr.attributes[key]);
     }
 }

 function foundSuccess(resource) {
     if(resource){
         query["filter"] =  {openstate: 'open'};
         representation = new tizen.Representation(uriPath);
         representation.resourceTypes = ["core.door"];
         representation.attributes = {openstate : 'closed'};
         resource.methodPut(representation, onresponse, query, onerror);
     }
 }

 try {
     var client = tizen.iotcon.getClient();
     var hostAddress = null;
     var query = { resourceType: "core.door" };
     var connectivityType = "IP";
     client.findResource(hostAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 var representation;
 var uriPath = "/door";

 function onerror(err) {
     console.log("Error occured: " + err.message);
 }

 function onresponse(remoteResponse) {
     console.log("result is "+remoteResponse.result );
     var repr =  remoteResponse.representation;
     console.log("representation attributes: ")
     for(var key in repr.attributes) {
         console.log("    key: " + key + ", value: " + repr.attributes[key]);
     }
 }

 function foundSuccess(resource) {
     if(resource){
         representation = new tizen.Representation(uriPath);
         representation.resourceTypes = ["core.door"];
         representation.attributes = {openstate: 'closed'};
         resource.methodPost(representation, onresponse, null, onerror);
     }
 }

 try {
     var client = tizen.iotcon.getClient();
     var hostAddress = null;
     var query = { resourceType: "core.door" };
     var connectivityType = "IP";
     client.findResource(hostAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 function onerror(err) {
     console.log("Error occured: " + err.message);
 }

 function onresponse(remoteResponse) {
     if(remoteResponse.result == "RESOURCE_DELETED" || remoteResponse.result == "SUCCESS") {
         console.log("Successfully deleted");
     }

 function foundSuccess(resource) {
     if(resource){
         resource.methodDelete(onresponse, onerror);
     }
 }

 try {
     var client = tizen.iotcon.getClient();
     var hostAddress = null;
     var query = { resourceType: "core.door" };
     var connectivityType = "IP";
     client.findResource(hostAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log (err.name +': ' + err.message);
 }
 

 var doorResource;

 function onchanged(remoteResponse) {
     if(remoteResponse.result == "SUCCESS") {
         var attributes = remoteResponse.representation.attributes;
         console.log("start observing, door is " + attributes["openstate"]);
     }
     doorResource.stopObserving();
 }

 function foundSuccess(resource) {
     if(resource) {
         if(resource.uriPath == "/door") {
             doorResource = resource;
             try {
                 doorResource.startObserving("IGNORE_OUT_OF_ORDER", onchanged);
             } catch(err) {
                 console.log(err.name + ': ' + err.message);
             }
         }
     }
 }

 try {
     var client = tizen.iotcon.getClient();
     var hostAddress = null;
     var query = { resourceType: "core.door" };
     var connectivityType = "IP";
     client.findResource(hostAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 var resource;

 function onerror(err) {
     console.log("Error occured: " + err.message);
 }

 function onupdated(representation) {
     console.log("######## updated representation ########");
     for(var key in representation.attributes) {
         console.log("key: " + key + ", value: " + representation.attributes[key]);
     }
     resource.stopCaching();
 }

 function foundSuccess(remoteResource) {
     if(remoteResource) {
         resource = remoteResource;
         remoteResource.startCaching(onupdated);   //start caching
     }
 }

 try {
     var client = tizen.iotcon.getClient();
     var hostAddress = null;
     var query = { resourceType: "core.door" };
     var connectivityType = "IP";
     client.findResource(hostAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log (err.name +': ' + err.message);
 }
 

 var doorResource;

 function onchanged(isAlive) {
     if (isAlive == true) {
         console.log("Remote resource is alive");
     } else {
         console.log("Remote resource is lost");
     }
     doorResource.unsetResourceStateChangeListener();
 }

 function foundSuccess(resource) {
     if(resource) {
         if(resource.uriPath == "/door") {
             try {
                 resource.setResourceStateChangeListener(onchanged);
             } catch(err) {
                 console.log(err.name + ': ' + err.message);
             }
         }
     }
 }

 try {
     var client = tizen.iotcon.getClient();
     var hostAddress = null;
     var query = { resourceType: "core.door" };
     var connectivityType = "IP";
     client.findResource(hostAddress, query, connectivityType, foundSuccess, onerror);
 } catch(err) {
     console.log (err.name +': ' + err.message);
 }
 

 resource.attributes = {openstate: 'open'};
 resource.notify("LOW", resource.observerIds);
 

 var server = tizen.iotcon.getServer();
 var uriPath = "/door";
 var resourceTypes = ["core.door"];
 var resourceInterfaces = ["oic.if.b"];
 var resource = server.createResource(uriPath, resourceTypes, resourceInterfaces, requestListener, policy);

 var types = [ "org.tizen.door"];
 resource.addResourceTypes(types);
 

 var resource = server.createResource(uriPath, resourceTypes, resourceInterfaces, requestListener, policy);

 var interface = "oic.if.ll";
 resource.addResourceInterface(interface);
 

 var doorResource;
 var lockResource;

 var uriPath = "/door";
 var resourceTypes = ["core.door"];
 var resourceInterfaces : ["oic.if.b"];
 var doorAttributes = { openstate : 'open' };
 var requestListener = {
       onget: function(request) {
           console.log("onget");
           var response = new tizen.Response(request);
           try {
               var representation = new tizen.Representation(doorResource.uriPath);
               representation.resourceTypes =doorResource.resourceTypes;
               representation.resourceInterfaces = doorResource.resourceInterfaces;
               representation.attributes = doorResource.attributes;
               response.representation = representation;
               response.result = "SUCCESS";
           } catch(err) {
               console.log(err.name + ": " + err.message);
               response.result = "ERROR";
           }
           response.send();
       },
       onput: function(request) {
           console.log("onput");
           //add request handle code
       },
       onpost: function(request) {
           console.log("onpost");
           //add request handle code
       },
       ondelete: function(request) {
           console.log("ondelete");
           //add request handle code
       },
       onobserving: function(request, observeType, observeId) {
           console.log("onobserving");
           //add request handle code
       }
 }

 doorResource = server.createResource(uriPath, resourceTypes, resourceInterfaces, requestListener, policy);
 doorResource.attributes = doorAttributes;

 uriPath = "/door/lock";
 resourceTypes = ["core.lock"];
 resourceInterfaces : ["oic.if.baseline"];
 var lockAttributes = { lockstate : 'closed' };
 policy = {
     isObservable : true,
     isDiscoverable : true
 };
 var lockRequestListener = {
       onget: function(request) {
           console.log("onget");
           var response = new tizen.Response(request);
           try {
               var representation = new tizen.Representation(lockResource.uriPath);
               representation.resourceTypes =lockResource.resourceTypes;
               representation.resourceInterfaces = lockResource.resourceInterfaces;
               representation.attributes = lockResource.attributes;
               response.representation = representation;
               response.result = "SUCCESS";
           } catch(err) {
               console.log(err.name + ": " + err.message);
               response.result = "ERROR";
           }
           response.send();
       },
       onput: function(request) {
           console.log("onput");
           //add request handle code
       },
       onpost: function(request) {
           console.log("onpost");
           //add request handle code
       },
       ondelete: function(request) {
           console.log("ondelete");
           //add request handle code
       },
       onobserving: function(request, observeType, observeId) {
           console.log("onobserving");
           //add request handle code
       }
 }

 lockResource = server.createResource(uriPath, resourceTypes, resourceInterfaces, lockRequestListener, policy);
 lockResource.attributes = lockAttributes;

 doorResource.addChildResource(lockResource);
 

 var lockResource = server.createResource(uriPath, resourceTypes, resourceInterfaces, requestListener, policy);
 doorResource.addChildResource(lockResource);
 doorResource.removeChildResource(lockResource);
 

 var server;
 var doorResource;

 var requestListener = {
       onget: function(request) {
           console.log("onget");
           var response = new tizen.Response(request);
           try {
               var representation = new tizen.Representation(doorResource.uriPath);
               representation.resourceTypes =doorResource.resourceTypes;
               representation.resourceInterfaces = doorResource.resourceInterfaces;
               representation.attributes = doorResource.attributes;
               response.representation = representation;
               response.result = "SUCCESS";
           } catch(err) {
               console.log(err.name + ": " + err.message);
               response.result = "ERROR";
           }
           response.send();
       },
       onput: function(request) {
           console.log("onput");
           //add request handle code
       },
       onpost: function(request) {
           console.log("onpost");
           //add request handle code
       },
       ondelete: function(request) {
           console.log("ondelete");
           //add request handle code
       },
       onobserving: function(request, observeType, observeId) {
           console.log("onobserving");
           //add request handle code
       }
 }

 var newRequestListener = {
       onget: function(request) {
           console.log("onget");
           var response = new tizen.Response(request);
           try {
               var representation = new tizen.Representation(doorResource.uriPath);
               representation.resourceTypes =doorResource.resourceTypes;
               representation.resourceInterfaces = doorResource.resourceInterfaces;
               representation.attributes = doorResource.attributes;
               response.representation = representation;
               response.result = "SUCCESS";
           } catch(err) {
               console.log(err.name + ": " + err.message);
               response.result = "ERROR";
           }
           response.send();
       },
       onput: function(request) {
           console.log("onput");
           var response = new tizen.Response(request);
           try {
               doorResource.attributes = request.representation.attributes;
               response.representation = request.representation;
               response.result = "RESOURCE_CHANGED";
           } catch(err) {
               console.log(err.name + ": " + err.message);
               response.result = "ERROR";
           }
           response.send();
       },
       onpost: function(request) {
           console.log("onpost");
           //add request handle code
       },
       ondelete: function(request) {
           console.log("ondelete");
           try {
               var representation = new tizen.Representation(doorResource.uriPath);
               representation.resourceTypes =doorResource.resourceTypes;
               representation.resourceInterfaces = doorResource.resourceInterfaces;
               representation.attributes = doorResource.attributes;
               response.representation = representation;
               response.result = "RESOURCE_DELETED";
           } catch(err) {
               console.log(err.name + ": " + err.message);
               response.result = "ERROR";
           }
           response.send();
           server.removeResource(doorResource);
       },
       onobserving: function(request, observeType, observeId) {
           console.log("onobserving observeType:" +observeType + ", observeId:" + observeId);
       }
 }

 try {
     server = tizen.iotcon.getServer();
     var uriPath = "/door";
     var resourceTypes = ["core.door"];
     var resourceInterfaces = ["oic.if.b"];
     var attributes = {openstate : 'open' };
     var policy = {
       isObservable : true,
       isDiscoverable : true
     };

     doorResource = server.createResource(uriPath, resourceTypes, resourceInterfaces, requestListener, policy);
     doorResource.attributes =  attributes;
     doorResource.setRequestListener(newRequestListener);
 } catch(err) {
     console.log(err.name +': ' + err.message);
 }
 

 try {
     var uriPath = "/door";
     var representation = new tizen.Representation(uriPath);
     representation.resourceTypes = ["core.door"];
     representation.resourceInterfaces = ["oic.if.b"];
     representation.attributes = {"openstate": "open"};

     var response = new tizen.Response(request);
     response.representation = representation;
     response.result = "SUCCESS";
 } catch(err) {
     console.log(err.name + ': ' + err.message);
     response.result = "ERROR";
 }
 response.send();