/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Defination of class CCalendarInterface
*
*/
var __device_sensors_service_entry = {"name": null,
"version": null,
"proto": __device_sensors,
"descriptor": __device_sensors_descriptor,
"providers": [{"descriptor": __sp_sensors_descriptor, "instance": __sp_sensors_instance}]
};
// Private location prototype: called from service factory
function __device_sensors(provider){
//Private properties
this.provider = provider;
//Read-only properties
this.interfaceName = provider.descriptor.interfaceName;
this.version = provider.descriptor.version;
//Extended methods
this.getChannels = __device_sensors_getChannels;
this.startChannel = __device_sensors_setNotifier;
this.stopChannel = __device_sensors_cancelNotifier;
this.getScaleFactor = __device_sensors_getScaleFactor;
}
function __device_sensors_descriptor(provider){
this.interfaceName = provider.interfaceName;
this.version = provider.version;
}
function __device_sensors_getChannels(){
return this.provider.getChannels();
}
function __device_sensors_setNotifier(sensors_cb, channel,__fail_cb){
return this.provider.startChannel(sensors_cb, channel,__fail_cb);
}
function __device_sensors_cancelNotifier(channel){
return this.provider.stopChannel(channel);
}
function __device_sensors_getScaleFactor(channel){
return this.provider.getScaleFactor(channel);
}
// S60 sp-based sensors provider
function __sp_sensors_descriptor(){
//Read-only properties
this.interfaceName = "sensors";
if(window.__Service_Interface_Ver)
this.version =__Service_Interface_Ver;
else
this.version =1.0;
//Class-static properties
}
function __sp_sensors_instance(){
//Descriptor
this.descriptor = new __sp_sensors_descriptor();
//Extended methods
this.getChannels = __sp_sensors_getChannels;
this.startChannel = __sp_sensors_setNotifier;
this.stopChannel = __sp_sensors_cancelNotifier;
this.getScaleFactor = __sp_sensors_getScaleFactor;
//Public properties
try {
//__device_debug("Trying sensors service");
this.so = device.getServiceObject('Service.Sensor', 'ISensor');
//__device_debug("Got sensors service object: ");
}
catch (e){
this.so = null;
__device_handle_exception (e, "sensors service not available");
}
}
var __rotation_channel = {
ucb: null,
tids: null
};
var __XYZ_channel = {
ucb: null,
tids: null
};
var __orientation_channel = {
ucb: null,
tids: null
};
function __rotation_cb(arg1, arg2, arg3){
if(arg2 != event_cancelled)
{
var output = null ;
if (arg3.ReturnValue)
{
var time = arg3.ReturnValue.TimeStamp;
var xrot = arg3.ReturnValue.XRotation;
var yrot = arg3.ReturnValue.YRotation;
var zrot = arg3.ReturnValue.ZRotation;
arg3.ReturnValue.close();
output = {};
modifyObjectBaseProp(output);
output.timeStamp = time;
output.rotationAboutXAxis = xrot;
output.rotationAboutYAxis = yrot;
output.rotationAboutZAxis = zrot;
}
__rotation_channel.ucb(output);
}
}
function __XYZ_cb(arg1, arg2, arg3){
if(arg2 != event_cancelled)
{
var output = null ;
if (arg3.ReturnValue)
{
var time = arg3.ReturnValue.TimeStamp;
var xaxis = arg3.ReturnValue.XAxisData;
var yaxis = arg3.ReturnValue.YAxisData;
var zaxis = arg3.ReturnValue.ZAxisData;
arg3.ReturnValue.close();
output = {};
modifyObjectBaseProp(output);
output.timeStamp = time;
output.axisX = xaxis;
output.axisY = yaxis;
output.axisZ = zaxis;
}
__XYZ_channel.ucb(output);
}
}
function __orientation_cb(arg1, arg2, arg3){
if(arg2 != event_cancelled)
{
var output = null ;
if (arg3.ReturnValue)
{
var time = arg3.ReturnValue.TimeStamp;
var orientation = arg3.ReturnValue.DeviceOrientation;
arg3.ReturnValue.close();
output = {};
modifyObjectBaseProp(output);
output.timeStamp = time;
output.deviceOrientation = orientation;
}
__orientation_channel.ucb(output);
}
}
// For now this is statically configured though this could be dynamically populated by the sensors sp
function __sp_sensors_getChannels(){
return ["Rotation", "AccelerometerAxis", "Orientation"];
}
function __sp_sensors_setNotifier(__succes_cb, __channel,__fail_cb){
var error = new DeviceException(0, 'dummy');
if (!__succes_cb) {//alert("!__succes_cb");
throw new DeviceAPIError(error.MISSING_ARG_ERR, "Callback is missing");
}
if ((typeof __succes_cb) != "function") {
throw new DeviceAPIError(error.INVALID_ARG_ERR, "Callback is of invalid type");
}
if (__fail_cb && ((typeof __fail_cb) != "function")) {
throw new DeviceAPIError(error.INVALID_ARG_ERR, "InValid error Callback");
}
if (!__channel) {
throw new DeviceAPIError(error.MISSING_ARG_ERR, "Channel is missing");
}
if ((typeof __channel) != "string") {
throw new DeviceAPIError(error.INVALID_ARG_ERR, "Channel is of invalid type");
}
var rval;
var cb;
var channelInfo = {};
modifyObjectBaseProp(channelInfo);
switch(__channel){
case "Rotation":
channelInfo.SearchCriterion = "Rotation";
cb = __rotation_cb;
__rotation_channel.ucb = __succes_cb;
break;
case "AccelerometerAxis":
//alert("case AccelerometerAxis");
channelInfo.SearchCriterion = "AccelerometerAxis";
cb = __XYZ_cb;
__XYZ_channel.ucb = __succes_cb;
break;
case "Orientation":
channelInfo.SearchCriterion = "Orientation";
cb = __orientation_cb;
__orientation_channel.ucb = __succes_cb;
break;
default:
//alert("default");
throw new DeviceAPIError(error.NOT_SUPPORTED_ERR, "Unsupported input channel");
}
try{
rval = this.so.ISensor.FindSensorChannel(channelInfo);
if (channelInfo) {
delete channelInfo.SearchCriterion;
}
if(rval.ErrorCode != 0)
{
throw new DeviceAPIError(error.NOT_SUPPORTED_ERR, "StartChannel:Operation Failed");
}
var cmap = [];
var transactionid = [];
var returnvalue = rval["ReturnValue"];
var count = returnvalue.length;
cmap = returnvalue[0];
var sensorParams = {};
modifyObjectBaseProp(sensorParams);
sensorParams.ListeningType = "ChannelData";
sensorParams.ChannelInfoMap = cmap;
var result = this.so.ISensor.RegisterForNotification(sensorParams, cb);
if(sensorParams){
delete sensorParams.ChannelInfoMap;
delete sensorParams.ListeningType;
}
if(cmap){
delete cmap.index;
}
transactionid[0] = result["TransactionID"];
if(result.ErrorCode != 0)
{
//throw result.ErrorCode;
if( result.ErrorCode == 1005)
{
__fail_cb(new DeviceAPIError(error.SERVICE_IN_USE_ERR,"Not Allowed Operation"));
return;
}
else
{
throw new DeviceAPIError(error.NOT_SUPPORTED_ERR, "StartChannel:Operation Failed");
}
}
}catch(e2){
__device_handle_exception (e2, "__sp_sensors_setNotifier: RegisterForNotification: " + e2);
}
switch(__channel){
case "Rotation":
__rotation_channel.tid = transactionid;
break;
case "AccelerometerAxis":
__XYZ_channel.tid = transactionid;
break;
case "Orientation":
__orientation_channel.tid = transactionid;
break;
}
return transactionid;
}
function __sp_sensors_cancelNotifier(__channel){
var error1 = new DeviceException(0, 'dummy');
if(!__channel)
throw new DeviceAPIError(error1.MISSING_ARG_ERR, "Channel is missing");
if((typeof __channel) != "string")
throw new DeviceAPIError(error1.INVALID_ARG_ERR, "Channel is of invalid type");
var id ;
switch (__channel)
{
case "Rotation":
id = __rotation_channel.tid;
__rotation_channel.tid = null;
break;
case "AccelerometerAxis":
id = __XYZ_channel.tid;
__XYZ_channel.tid = null;
break;
case "Orientation":
id = __orientation_channel.tid;
__orientation_channel.tid = null;
break;
default:
throw new DeviceAPIError(error1.NOT_SUPPORTED_ERR, "Unsupported input channel");
}
if(!id)
{
throw new DeviceAPIError(error1.DATA_NOT_FOUND_ERR, "Stop Channel:Operation Failed");
}
var cancelParams = {};
modifyObjectBaseProp(cancelParams);
for (var i in id) {
cancelParams.TransactionID = id[i];
try {
var result = this.so.ISensor.Cancel(cancelParams);
if (cancelParams) {
delete cancelParams.TransactionID;
}
if (result.ErrorCode != 0) {
throw new DeviceAPIError(error1.DATA_NOT_FOUND_ERR, "Stop Channel:Operation Failed");
}
}
catch (e1) {
__device_handle_exception(e1, "__sp_sensors_cancelNotifier: " + e1);
}
}
}
function __sp_sensors_getScaleFactor(__channel){
var error2 = new DeviceException(0, 'dummy');
if(!__channel)
throw new DeviceAPIError(error2.MISSING_ARG_ERR, "Channel is missing");
if((typeof __channel) != "string")
throw new DeviceAPIError(error2.INVALID_ARG_ERR, "Channel is of invalid type");
if(__channel != "AccelerometerAxis")
throw new DeviceAPIError(error2.NOT_SUPPORTED_ERR, "Unsupported input channel");
try{
var channelInfo = {};
channelInfo.SearchCriterion = "AccelerometerAxis";
var rval = this.so.ISensor.FindSensorChannel(channelInfo);
if (channelInfo) {
delete channelInfo.SearchCriterion;
}
if(rval.ErrorCode != 0)
{
throw new DeviceAPIError(error2.NOT_SUPPORTED_ERR, "getScaleFactor:Operation Failed");
}
var cmap = [];
var returnvalue = rval["ReturnValue"];
cmap = returnvalue[0];
var sensorParams = {};
modifyObjectBaseProp(sensorParams);
sensorParams.ListeningType = "ChannelData";
sensorParams.ChannelInfoMap = cmap;
var result = this.so.ISensor.GetScaleFactor(sensorParams);
if(sensorParams){
delete sensorParams.ChannelInfoMap;
delete sensorParams.ListeningType;
}
if(cmap){
delete cmap.index;
}
if(result.ErrorCode != 0)
{
throw new DeviceAPIError(error2.NOT_SUPPORTED_ERR, "getScaleFactor:Operation Failed");
}
}
catch (e1) {
__device_handle_exception(e1, "__sp_sensors_getScaleFactor: " + e1);
}
return result["ReturnValue"];
}