// The following identifier turns the IE conditional pre-compilation on.
/*@cc_on @*/
/**
* @namespace Parent namespace for the api.ovi.com project.
*/
if (typeof ovi == 'undefined') {
ovi = {};
};
(function (ovi) {
// ovi = function() {
var that = {};
ovi.description = {
proxy_url: window.location.protocol + "//" + window.location.host + "/ovi-api",
sourceLocation: "/js",
urlSeperator: "/",
libFileExtension: ".js",
minified: false,
sign_method : "method-delegate-oauth",
env_path : "/alpha",
dispatch_path : "/api",
proxy_prefix : "", //useful during dev, so same consumer key can be reused for multiple instances of ovi-api
request_timeout : 30, // Network request timeout lapse (in seconds).
caller_id : "", //random id used for caller authentication
env_device : true // Do not change anything in this line, even the spacing. Else the project won't build properly for SPB.
};
// that.description = description;
//Ignore console calls, in case it is not imported
ovi.console = {init:function(){},log:function(){},error:function(){},debug:function(){},info:function(){}};
//Ignore config calls, in case config.js is not imported
ovi.config = {setenv:function(){},setServiceEndPoint:function(){}};
var _loaded = {}; //Mapping from script source URL to status (0 - not loaded, 1 - loaded)
var _libMappings = {}; //Mapping from script source URL to libName
var _pending_callbacks = []; //Used to delay callbacks, until all dependencies are loaded
/**
* Method to initialize source URL using location of path from where oviapi.js was loaded
*
*/
var _initSourceURL = function() {
var scripts = document.getElementsByTagName('script');
if (!scripts) return; // TODO Throw an exception instead.
var srcFilePattern = new RegExp("/js/ovi/(oviapi|oviapi-min|oviapi_(.+)|oviapi_(.+)-min).js$", "gi");
for(var index = 0; index < scripts.length; index++) {
var ssrc = scripts.item(index).src;
if (typeof ssrc !== 'undefined') {
ssrc = ssrc.replace(/^\s*|\s*$/g,''); // To remove any white spaces.
var startIndex = ssrc.search(srcFilePattern);
if (startIndex > 0) {
// To determine whether the minified version of ovi libraries are used.
if (ssrc.indexOf("min") > 0) {
ovi.description.minified = true;
}
// If only relative src can be accessed, then use window.location ro create sourceURL
if (ssrc.substr(0,6) !== 'http:/' && ssrc.substr(0,7) !== 'https:/') {
var rootdir = window.location.pathname.split('/');
if (rootdir.length > 1)
ovi.description.proxy_url = window.location.protocol + "//" + window.location.host + "/" + rootdir[1];
break;
} else {
ovi.description.proxy_url = ssrc.substring(0, startIndex);
break;
}
}
}
}
};
_initSourceURL();
/**
* Get an array of the loaded libs
* @param {Integer} Optional param to specify the status of the loaded library.
* @return Array of libNames
*/
var _getLoadedLibNames = function(status){
var loadedLibs = [];
if (typeof status === 'undefined') status = -1;
for (var item in _loaded){
if ((status === -1) || (_loaded[item] === status)){
loadedLibs.push(_libMappings[item]);
}
}
return loadedLibs;
};
/**
* Get an object with loaded lib name as key and load status as value (1 - loaded, 0 - not loaded)
* @param {Integer} Optional param to specify the status of the loaded library.
* @return Object with libNames as key and load status as value
*/
var _getLoadedLibNamesAsObject = function(status){
var loadedLibs = {};
if (typeof status === 'undefined') status = -1;
for (var item in _loaded){
if ((status === -1) || (_loaded[item] === status)){
loadedLibs[_libMappings[item]] = _loaded[item];
}
}
return loadedLibs;
};
/**
* Test if script was already loaded
* @param {String} scriptSrcURL source URL of script
* @return {Boolean}
*/
var _isExistingScript = function(scriptSrcURL){
for (var item in _loaded){
if (scriptSrcURL === item){
return true;
}
}
return false;
};
/**
* Method to verify if a library object has already been loaded. In case of packaged/minified
* version of ovi libraries all the libraries would reside in one single JS file.
*
* @param {String} libraryName Name of the library object to check.
* @return {Boolean} Based on whether the check is true/false.
*/
var _isExistingLib = function(libraryName) {
for (var lib in ovi.libName) {
if (libraryName == lib) {
return true;
}
}
return false;
}
var _determineScriptSrc = function(libName, options){
var fileName = libName;
var scriptSrcURL = ovi.description.proxy_url;
// This helps while using this on a widget.
if (options != undefined && options.sourceURL != undefined) {
scriptSrcURL = options.sourceURL;
}
var fileExt = "";
// If not using slash path, then use ".js" file extension and replace dot with slash.
if(fileName.indexOf('/') == -1){
fileExt = ovi.description.libFileExtension;
fileName = fileName.replace(/\./g,'/');
}
var rootDir = "";
//If ovi package, then use source location as root dir
if (fileName.substr(0,3) === "ovi")
rootDir = ovi.description.sourceLocation;
scriptSrcURL = scriptSrcURL + rootDir + "/" + fileName
+ ((ovi.description.minified) ? "-min" : "")
+ fileExt;
return scriptSrcURL;
};
var _loadScript = function(scriptSrcURL, srcLib, options){
function _loadedcallback(){
//console.log(new Date().getTime()+" Loaded script:"+scriptSrcURL+" "+_getLoadedLibNames(1));
//console.log("not loaded:"+_getLoadedLibNames(0));
//Mark script as loaded
_loaded[scriptSrcURL] = 1;
//If callback exists, then add to pending callbacks
if (options && options.callback != null)
_pending_callbacks.push(options.callback);
//If 1 or more items are pending, then don't call callbacks
var done = true;
for (var item in _loaded){
if (_loaded[item] === 0){
done = false;
break;
}
}
//If all libs are loaded, then call callbacks for all includes, if any
if (done == true){
//console.log(new Date().getTime()+" DONE AT LAST\n");
//Call all pending callbacks
for (var index = 0; index < _pending_callbacks.length; index++){
try{
_pending_callbacks[index].call();
}catch(err){
//console.log("failed to exec callback");
}
}
_pending_callbacks = []; //Reset pending callbacks list
ovi.onReady(_getLoadedLibNamesAsObject(1)); //call onReady
}
}
// If the library is already loaded (throug packaged/minified source file) then skip the download process.
if (!_isExistingLib(srcLib)) {
var scriptTag = document.createElement('script');
scriptTag.type = 'text/javascript';
scriptTag.src = scriptSrcURL;
if(window.opera){
scriptTag.onload = function(){
scriptTag.onload = null;
_loadedcallback();
};
}
//From Nicholas C. Zakas (http://www.nczonline.net/blog/2009/06/23/loading-javascript-without-blocking/)
else if (scriptTag.readyState){ //IE
scriptTag.onreadystatechange = function(){
if (scriptTag.readyState == "loaded" || scriptTag.readyState == "complete"){
scriptTag.onreadystatechange = null;
_loadedcallback();
}
};
} else { //Others
scriptTag.onload = function(){
_loadedcallback();
};
}
var documentHead = document.getElementsByTagName("head")[0];
var newScriptTag = documentHead.appendChild(scriptTag);
if (newScriptTag) return true;
} else {
_loadedcallback();
return true;
}
return false;
};
/**
* ovi.include - Method to dynamically include JS libraries from "api.ovi.com".<br/><br/>
* The ovi.onReady(libs) function is triggered once the library and its
* dependencies are loaded. See documentation of ovi.onReady.
*
* @param {String,Array}
* libNames Names of one or more libraries to be included, specified as an
* array of strings or as a comma separated string.
* Library name can be specified in dot notation or as a relative path. <span
* style="color:blue">e.g., "ovi.api.people",
* "ovi/api/people.1.0.js".</span> External libraries must start
* with "lib" <span style="color:blue">e.g., "lib.jquery",
* "lib/jquery.json.js".</span>
* @param {Object}
* options Name/Value object to hold other optional parameters.
* @param {Function}
* options.callback Function to be called after a library has
* been loaded.
*
* @example
* ovi.include("ovi.api.maps");
* ovi.include("ovi.api.people",{callback:function(){callMeBack()}});
* ovi.include("ovi.api.people, ovi.api.share", {callback:function(){callMeBack()}});
*
*
*
* @function
* @methodOf ovi
*/
ovi.include = function(libNames, options) {
var importStatus = true;
try {
if (libNames != undefined) {
if (typeof libNames === 'string')
libNames = libNames.split(',');
// Determine which scripts (and also libraries) need to be loaded
var toLoadScript = [];
for (var index = 0; index < libNames.length; index++){
var libName = libNames[index].replace(/^\s*|\s*$/g,''); // Remove any white spaces.
// Determine script source URL from libName
var scriptSrcURL = _determineScriptSrc(libName, options);
if (!_isExistingScript(scriptSrcURL)) {
_loaded[scriptSrcURL] = 0; //Mark script as pending
_libMappings[scriptSrcURL] = libName;
toLoadScript.push(scriptSrcURL);
} else {
if (options && options.callback)
toLoadScript.push(scriptSrcURL);
}
//console.log("o================o");
}
var lstatus;
//Load scripts that need to be loaded. Pass optional callback only for last script (since callback should be called only once).
for (var index = 0; index < toLoadScript.length; index ++){
if (index == (toLoadScript.length-1)) // if last lib, then pass optional callback
lstatus = _loadScript(toLoadScript[index], _libMappings[toLoadScript[index]], options);
else
lstatus = _loadScript(toLoadScript[index], _libMappings[toLoadScript[index]]);
if (!lstatus) importStatus = false;
}
}
} catch (exception) {
importStatus = false;
}
return importStatus;
};
// that.include = include;
/**
* ovi.onReady - Callback function triggered after calling ovi.include,
* once the library and its dependencies are loaded. Developers can override the default
* implementation, with their own ovi.onReady function. If successive calls to ovi.include are made,
* ovi.onReady may be triggered only once.
*
* @param {Object}
* libs - library name as key and load status as value (0 - not
* loaded, 1 - loaded). Developer must check if the libraries
* they need are loaded before using them using the ovi.testIfLoaded function.
*
* @function
* @methodOf ovi
*/
ovi.onReady = function(libs) {
//default, do nothing
//console.log("onReady:");
//console.log(libs);
};
// that.onReady = onReady;
/**
* ovi.testIfLoaded - Utility function to test if the specified lib names are marked as loaded in the specified loaded libs object.
* Used to test the status of libs in ovi.onReady.
*
* @param {String,Array}
* libNames Names of one or more libraries to be included, specified as an
* array of strings or as a comma separated string.
*
* @param {Object}
* loadedLibs A mapping of lib name string to load status (0 - not loaded, 1 - loaded)
*
* @return {Boolean}
*
* @function
* @methodOf ovi
*/
ovi.testIfLoaded = function(libNames, loadedLibs){
var reqdlibs = libNames;
if (typeof libNames === 'string')
reqdlibs = libNames.split(',');
for (var index = 0; index < reqdlibs.length; index ++){
var libName = reqdlibs[index].replace(/\s/g,'');
if ((libName in loadedLibs) && (loadedLibs[libName] == 1))
continue;
else
return false;
}
return true;
};
// that.testIfLoaded = testIfLoaded;
/**
* ovi.setCallerId - Sets caller id required to authenticate API caller with Ovi API backend.
*
* @param {String}
* cid - Caller id string
*
* @function
* @methodOf ovi
*/
ovi.setCallerId = function(cid){
ovi.description.caller_id = cid;
};
// return that;
// }();
})(ovi);
/**
* @property {Object} services Object that holds configurable parameters of all the libraries.
* @memberOf ovi
*/
ovi.services = {};
ovi.services["import"] = ovi.description;
/**
* @property {Object} libName Object that holds the identified name of all the OVI API libraries.
* @memberOf ovi
*/
ovi.libName = {};
ovi.libName["ovi.oviapi"] = ovi;
ovi.include('ovi.config');
/*
@@todo:
- if one include inside of another fails to load, then failure is silent
- file imports will fail silently if the path is wrong
- Safari reinclude doesn't work (seems that DOM removeChild doesn't really remove the script)
*/