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 handler code. */
  },
  onpost: function(request)
  {
    console.log("onpost");
    /* Add request handler code. */
  },
  ondelete: function(request)
  {
    console.log("ondelete");
    /* Add request handler code. */
  },
  onobserving: function(request, observeType, observeId)
  {
    console.log("onobserving");
    /* Add request handler 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 occurred: " + 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 occurred: " + 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 occurred: " + 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 occurred: " + 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 occurred: " + 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 handler code. */
  },
  onpost: function(request)
  {
    console.log("onpost");
    /* Add request handler code. */
  },
  ondelete: function(request)
  {
    console.log("ondelete");
    /* Add request handler code. */
  },
  onobserving: function(request, observeType, observeId)
  {
    console.log("onobserving");
    /* Add request handler 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 handler code. */
  },
  onpost: function(request)
  {
    console.log("onpost");
    /* Add request handler code. */
  },
  ondelete: function(request)
  {
    console.log("ondelete");
    /* Add request handler code. */
  },
  onobserving: function(request, observeType, observeId)
  {
    console.log("onobserving");
    /* Add request handler 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 handler code. */
  },
  onpost: function(request)
  {
    console.log("onpost");
    /* Add request handler code. */
  },
  ondelete: function(request)
  {
    console.log("ondelete");
    /* Add request handler code. */
  },
  onobserving: function(request, observeType, observeId)
  {
    console.log("onobserving");
    /* Add request handler 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 handler 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();