/*****************************************************************************************
 *
 *      Tuxia Primitives
 *      Version 1.9 MCS
 *
 ****************************************************************************************/
var shellCommand = null;
var vod = null;
var video = null;
var sound = null;
var configd = null;

var fixedSdpFileName =  "/wfs/mpg/currentmp4.sdp";
var tv_standard      = null;
var currentVersion = "";
var globalFirstTime  = 0;
var STBInit = null;
/*-----------------------------------------------------------*/
var callback = {
    BeginningOfVideo : function()
    {
       // alert("In beginning of video function");
		summary = document.getElementById(currentSelection).summary;
		var args=summary.split(":"); 
		if(ThisPage==enumPage.LiveContent || ThisPage==enumPage.ScheduledPrograms){
			STB_createreq(args[0],enumEvent.VBrickSTB_BeginVideoEvent,args[2],args[3]);
		}else{
			STB_createreq(args[1],enumEvent.VBrickSTB_BeginVideoEvent,args[3],args[4]);
		}
    },
    EndOfVideo : function(state)
    {
      // alert("In end of video function");
		LogPlayerStop();
    }
}

/*-----------------------------------------------------------*/
function shellCommandObj()
{
    this.shellCommandXPCOM  = null;
    this.getVersionInterface= null;
    var aComp               = null;
    var aVerComp             = null;

    try
    {       
        aComp = Components.classes["@tuxia.com/goannaComponents/shellCommand;1"].getService();
        if (aComp != null)
            this.shellCommandXPCOM = aComp.QueryInterface(Components.interfaces.IshellCommand);
    }
    catch(e)
    {
        alert("Could not get IshellCommand interface. "+e.toString());
        return;
    }

    try
    {
        aVerComp = Components.classes["@tuxia.com/goannaComponents/getVersion;1"].getService();
        if (aVerComp != null)
            this.getVersionInterface = aVerComp.QueryInterface(Components.interfaces.IGetVersion);
    }
    catch(e)
    {
        currentVersion = "3.69";
        this.getVersionInterface = null;
    }
}

shellCommandObj.prototype.RunShellCommand = function(commandString)
{
    if (this.shellCommandXPCOM != null)
    {
        this.shellCommandXPCOM.RunShellCommand(commandString);
    }
}

shellCommandObj.prototype.GetVersion = function()
{
    var retVal = 0;
    if (this.getVersionInterface != null)
    {
        try
        {
            retVal = this.getVersionInterface.GetTasteVersion();
        }
        catch(e)
        {
            alert(e.toString());
        }
    }
    return(retVal);
}

shellCommandObj.prototype.GetSDPFile = function(url)
{
    if (this.shellCommandXPCOM != null)
    {
        //construct the command to get the sdp file
        var command = "curl "+url+" > "+fixedSdpFileName;

        //Run the shell command to get the SDP file.
        this.RunShellCommand(command);
    }
}

/*-----------------------------------------------------------*/
function configdObj()
{
    this.configdXPCOM = null;
    var aComp = null;

    //Get configuration manager service and query interface
    try
    {
        aComp = Components.classes["@tuxia.com/goannaComponents/configdComp;1"].createInstance();
        if(aComp != null)
            this.configdXPCOM = aComp.QueryInterface(Components.interfaces.IconfigdComp);                   
    }
    catch(e)
    {
        alert("Could not create component:\n"+e.toString());
        return;
    }

    if(this.configdXPCOM != null)
    {
        //Login to configuration manager
        this.configdXPCOM.Init("localhost");
    }
}

configdObj.prototype.GetValue = function(compName)
{
    return this.configdXPCOM.GetValue(compName);
}

/*-----------------------------------------------------------*/
function tvia5005Obj()
{
    this.tviaXPCOM        = null;
    this.port = 0x00;
    this.xloc = 0;
    this.yloc = 0;
    this.alphar = 0;
    this.alphag = 0;
    this.alphab = 0;
    this.tviaXPCOM = null;
    this.CAPTURE_PORT_VOD = 0x00;          // EM8400 (VOD) Capture port A
    this.CAPTURE_PORT_TV = 0x80;           // (tuner?) Capture port B
    var aComp = null;

    try
    {
        //Create instance of TVIA5000 object
        aComp = Components.classes["@tuxia.com/goannaComponents/tvia5000;1"].createInstance();
        if(aComp != null)
            this.tviaXPCOM = aComp.QueryInterface(Components.interfaces.Itvia5000);
    }
    catch(e)
    {
        alert("Could not create component:\n"+e.toString());
        return;
    }

    //set defaults
    if(this.tviaXPCOM != null)
    {
        if(tv_standard == "ntsc")
        {
            this.tviaXPCOM.SetSourceGeometry( 2, 0, 716, 480);            
        }
        else //PAL
        {
            this.tviaXPCOM.SetSourceGeometry( 2, 0, 716, 576);
        }

        this.tviaXPCOM.SetEnableBobWeave(false);
        this.tviaXPCOM.SetEnableKeyColor(true);
        this.tviaXPCOM.SetPlaybackKeyColor(255, 255, 255);
        this.tviaXPCOM.SetEnableInterlace(true);

        if(currentVersion > "3.69")
        {					
            if(tv_standard == "ntsc")
                this.tviaXPCOM.SetStandard( true );
            else
                this.tviaXPCOM.SetStandard( false );
        }
    }
    else
    {
        alert ("this.tviaXPCOM is NULL");
    }
}

tvia5005Obj.prototype.noVideo = function()
{
    if(this.tviaXPCOM != null)
    {
        this.tviaXPCOM.SetCapturePort(this.port);
        this.tviaXPCOM.SetPlaybackGeometry(0, 0, 0, 0);
        this.tviaXPCOM.SetEnableBobWeave(false);
        this.tviaXPCOM.SetEnablePlayback(false);
        this.tviaXPCOM.CallSetupVideo();
        this.tviaXPCOM.SetEnableAlphaBlending( false);
        this.tviaXPCOM.CallSetupAlphaBlending();
    }
}

tvia5005Obj.prototype.setVideoLocationSize = function(x, y, w, h)
{
    if(this.tviaXPCOM != null)
    {
        // for SCR 1270
        if ((tv_standard == "ntsc") && (globalFirstTime == 0))
        {
            video.setFullScreen();
            globalFirstTime = 1;
        }
        //for SCR 1270

        this.xloc = x;
        this.yloc = y;
        this.tviaXPCOM.SetCapturePort(this.port);
        this.tviaXPCOM.SetPlaybackGeometry(x, y, w, h);
        this.tviaXPCOM.SetEnableKeyColor( true);
        this.tviaXPCOM.SetPlaybackKeyColor( this.alphar, this.alphag, this.alphab);
        this.tviaXPCOM.SetEnablePlayback(true);

        if (tv_standard == "ntsc")
        {
            this.tviaXPCOM.SetEnableCloseCaptionPassThru(false, 0);
            this.tviaXPCOM.SetEnableBobWeave(true);
        }
        else//PAL
        {
            if(currentVersion >= "3.72j")
            {
                this.tviaXPCOM.SetEnableBobWeave(true);
            }
            else
            {
                this.tviaXPCOM.SetEnableBobWeave(false);
            }
        }
        this.tviaXPCOM.CallSetupVideo();
    }
}

tvia5005Obj.prototype.closeScreen = function()
{
    if(this.tviaXPCOM != null)
    {
        this.tviaXPCOM.SetCapturePort(this.port);
        this.tviaXPCOM.SetPlaybackGeometry(0, 0, 0, 0);
        this.tviaXPCOM.SetEnablePlayback(false);
        this.tviaXPCOM.CallSetupVideo();
    }
}

tvia5005Obj.prototype.setTransparentColor = function (r, g, b)
{
    this.alphar = r;
    this.alphag = g;
    this.alphab = b;
}

tvia5005Obj.prototype.setFullScreen = function ()
{
	if(this.tviaXPCOM != null)
	{
		this.tviaXPCOM.SetEnableAlphaBlending( false);
		this.tviaXPCOM.CallSetupAlphaBlending();
		this.tviaXPCOM.SetCapturePort(this.port);
      
		if(tv_standard == "ntsc")
    {
      this.tviaXPCOM.SetPlaybackGeometry(0, 0, 720, 480);
      if (currentVersion >= "3.71") 
        this.tviaXPCOM.SetEnableCloseCaptionPassThru(true, 5);

			this.tviaXPCOM.SetEnableBobWeave(true);
    }
		else // PAL
    {
			this.tviaXPCOM.SetPlaybackGeometry(0, 0, 720, 576);
			this.tviaXPCOM.SetEnableBobWeave(false);
    }

		this.tviaXPCOM.SetEnablePlayback(true);
		this.tviaXPCOM.SetEnableKeyColor( true);
		this.tviaXPCOM.SetPlaybackKeyColor( this.alphar, this.alphag, this.alphab);
		this.tviaXPCOM.CallSetupVideo();
	}
}

tvia5005Obj.prototype.setTransparentColorOn = function ()
{
    if(this.tviaXPCOM != null)
    {
        this.tviaXPCOM.SetEnableKeyColor( false);
        this.tviaXPCOM.CallSetupVideo();
        this.tviaXPCOM.SetEnableAlphaBlending( true);
        this.tviaXPCOM.SetEnableAlphaWindow(0, true);
        this.tviaXPCOM.SetAlphaWindowSources(0, 0 ,0);
        this.tviaXPCOM.SetAlphaWindowColor(0, this.alphar, this.alphag, this.alphab);

        if(tv_standard == "ntsc")
            this.tviaXPCOM.SetAlphaWindowCoor(0, 0, 0, 720, 480);
        else
            this.tviaXPCOM.SetAlphaWindowCoor(0, 0, 0, 720, 576);

        this.tviaXPCOM.CallSetupAlphaBlending();
    }
}

tvia5005Obj.prototype.setTransparentColorOff = function ()
{
    if(this.tviaXPCOM != null)
    {
        this.tviaXPCOM.SetEnableAlphaBlending( false);
        this.tviaXPCOM.CallSetupAlphaBlending();
        this.tviaXPCOM.SetEnableKeyColor( false);
        this.tviaXPCOM.SetPlaybackKeyColor( this.alphar, this.alphag, this.alphab);
        this.tviaXPCOM.CallSetupVideo();
    }
}

tvia5005Obj.prototype.setCapturePort = function(newPort)
{
    this.port = newPort;
}

/*-----------------------------------------------------------*/
function vodSigmaObj(configdObj)
{
    this.vod_url = null;
    this.confd = configdObj;
    this.vodXPCOM = null;
    this.vod_rtsp_streaming_options = 0;
    var aComp                       = null;

    try
    {
        aComp = Components.classes["@tuxia.com/goannaComponents/VOD;1"].createInstance();
        if(aComp != null)
            this.vodXPCOM = aComp.QueryInterface(Components.interfaces.IVOD);
    }
    catch(e)
    {
        alert("Could not create component:\n"+e.toString());
        return;
    }

    if(currentVersion >= "3.72j")
    {
        try
        {
            this.vodXPCOM.RegisterCallback(callback, 0);
        }
        catch(e)
        {
            alert(e.toString());
        }
    }
}

vodSigmaObj.prototype.EnableDestWindow = function(enable)
{
    if(this.vodXPCOM != null)
    {
        this.vodXPCOM.EnableDestWindow(enable);
    }
}

vodSigmaObj.prototype.SetDestWindow = function(width, height)
{
    if(this.vodXPCOM != null)
    {
        this.vodXPCOM.SetDestWindow(width, height);
    }
}

vodSigmaObj.prototype.SetStandard = function()
{
	if(this.vodXPCOM != null)
	{
        if (tv_standard == "pal")
            this.vodXPCOM.SetStandard(1);
        else
            this.vodXPCOM.SetStandard(0);
	}
}

vodSigmaObj.prototype.Open = function()
{
    var retval = 0;

//rdp example of use of function
//SendStringToSerialPort("We are in open (local).\n\r");

    if (this.vodXPCOM != null)
    {
        this.vodXPCOM.Close();    // <rdp 05/02/2005> for SCR 1224

        if (currentVersion > "3.69")
        {
            /*The following values are applicable only for MPEG-4 streams.
              Even if 'SetOptions' is called, the options are ignored for MPEG-1 and MPEG-2 streams*/
            var dchar1 = 0;
            var dchar2 = 0;
            var dchar3 = 0;
            var dchar4 = 0;
            var dchar5 = 0;
            var dchar6 = 0;
            var dchar7 = 0;
            
            dchar1=this.confd.GetValue("browsers/nanozilla/base/interface/chrome-STB/purple.SECONDS_FOR_BUFFERING");
            dchar2=this.confd.GetValue("browsers/nanozilla/base/interface/chrome-STB/purple.AUDIO_DATAPORT");
            dchar3=this.confd.GetValue("browsers/nanozilla/base/interface/chrome-STB/purple.VIDEO_DATAPORT");
            this.vodXPCOM.SetOptions(dchar1, dchar2, dchar3);
            
            dchar4=this.confd.GetValue("browsers/nanozilla/base/interface/chrome-STB/purple.RTP_DATAPORT");
            this.vodXPCOM.SetRTPDataPort(dchar4);

            if (currentVersion >= "3.71") 
            { 
                dchar4 = this.confd.GetValue("browsers/nanozilla/base/interface/chrome-STB/purple.CC_DATAPORT");
                this.vodXPCOM.SetCCOptions(dchar4);

                this.vodXPCOM.SetRtspStreamingOptions(this.vod_rtsp_streaming_options); //set via SetVideoTypeName()

                dchar5 = this.confd.GetValue("browsers/nanozilla/base/interface/chrome-STB/purple.BUFFER_CHECK");
                if ("yes" == dchar5)
                {
                    dchar6 = 1;
                    dchar7 = this.confd.GetValue("browsers/nanozilla/base/interface/chrome-STB/purple.BITRATE_BUFFER_CHECK");
                }
                else
                {
                    dchar6 = 0;
                    dchar7 = 0;
                }
                this.vodXPCOM.SetBufferCheckOptions(dchar6, dchar7);

                //this is NOT local-fullscreen mode, we DON'T want unconditional retries....
                if (tv_standard == "pal")
                {
                    this.vodXPCOM.SetOpenRetryOptions(0, 1, 720, 576);
                }
                else
                {
                    this.vodXPCOM.SetOpenRetryOptions(0, 0, 720, 480);
                }
            }
        }
        
        retval = this.vodXPCOM.Open(this.vod_url, 0, 0); //this.vod_url is set in setVODURL() called by SetVideoTypeName()
        if(retval != 0)
        {
            alert("Unable to open url - "+this.vod_url);
            return;
        }

        if(currentVersion > "3.69")
        {
            this.SetStandard();
        }
    }
}

vodSigmaObj.prototype.Play = function()
{
    if(this.vodXPCOM != null)
    {
        this.vodXPCOM.Play();
    }
}

vodSigmaObj.prototype.Rewind = function()
{
    if(this.vodXPCOM != null)
    {
        this.vodXPCOM.Rewind();
    }
}

vodSigmaObj.prototype.FastForward = function()
{
    if(this.vodXPCOM != null)
    {
        this.vodXPCOM.FastForward();
    }
}

vodSigmaObj.prototype.Pause = function()
{
    if(this.vodXPCOM != null)
    {
        this.vodXPCOM.Pause();
    }
}

// rdp 05/02/2005 this function is obsolete (now is a noop) -- always call Close instead (or in tandem)
vodSigmaObj.prototype.Stop = function()
{
    if(this.vodXPCOM != null)
    {
        this.vodXPCOM.Stop();
    }
}

vodSigmaObj.prototype.Close = function()
{
    if (this.vodXPCOM != null)
    {
        this.vodXPCOM.Close();
    }
}

vodSigmaObj.prototype.setVODURL = function(new_vod_url)
{
    this.vod_url = new_vod_url;
}

vodSigmaObj.prototype.setRtspStreamingOptions = function(option)
{
    if (currentVersion >= "3.71") 
        this.vod_rtsp_streaming_options = option;
}

/*-----------------------------------------------------------*/
function soundMixerObj(configd)
{
    this.soundMixerXPCOM = null;
    this.confd = configd;
    this.main_vol_val       = 0;
    this.line1_vol_val    = 0;
    var aComp               = null;

    try
    {
        aComp = Components.classes["@tuxia.com/goannaComponents/soundMixer;1"].getService();
        if(aComp != null)
        this.soundMixerXPCOM = aComp.QueryInterface(Components.interfaces.IsoundMixer);
    }
    catch(e)
    {
        alert("Could not create component:\n"+e.toString());
        return;
    }
    if(currentVersion > "3.69")
    {
        this.main_vol_val = this.GetConfiguredVolume();
        this.line1_vol_val = this.GetConfiguredLine1Volume();
        if(this.main_vol_val != this.line1_vol_val)
        {
            this.soundMixerXPCOM.SetLine1Volume(this.main_vol_val);
        }
        this.SetMainVolume(this.main_vol_val);
    }
}

soundMixerObj.prototype.GetMainVolume = function()
{
    return (this.soundMixerXPCOM.GetMainVolume());
}

soundMixerObj.prototype.MuteToggle = function()
{
    this.soundMixerXPCOM.Mute();
}

soundMixerObj.prototype.SetMainVolume = function(volume)
{
    this.main_vol_val=volume;
    this.soundMixerXPCOM.SetMainVolume(volume);
    this.soundMixerXPCOM.SetLine1Volume(volume);
}

soundMixerObj.prototype.MainVolumePlus = function()
{
    this.main_vol_val = parseInt(this.main_vol_val, 10) + parseInt(5, 10); //5 is an arbitrary number...can be changed  
    if(this.main_vol_val > 100)
    {
        this.main_vol_val = 100;
    }
    if(this.soundMixerXPCOM != null)
    {
        this.SetMainVolume(this.main_vol_val);
    }
}

soundMixerObj.prototype.MainVolumeMinus = function()
{
    this.main_vol_val = parseInt(this.main_vol_val, 10) - parseInt(5, 10); //5 is an arbitrary number...can be changed  
    if(this.main_vol_val < 0)
    {
        this.main_vol_val = 0;
    }   
    if(this.soundMixerXPCOM != null)
    {
        this.SetMainVolume(this.main_vol_val);
    }
}

soundMixerObj.prototype.GetConfiguredVolume = function()
{
    var dchar = null;
    dchar = this.confd.GetValue("browsers/nanozilla/base/interface/chrome-STB/purple.MAIN_VOL");
    return dchar;
}

soundMixerObj.prototype.GetConfiguredLine1Volume = function()
{
    var dchar = null;
    dchar = this.confd.GetValue("browsers/nanozilla/base/interface/chrome-STB/purple.LINE1_VOL");
    return dchar;
}

/*-----------------------------------------------------------*/
function initSTB( version )
{
	var currentVersionNumber = 0;
	
	netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
	configd = new configdObj();

	var dchar = null;
	if (configd != null)
	{
		dchar=configd.GetValue("display/xf86_base.RESOLUTION");
		if (dchar != null)
		{
			switch(dchar)
			{
				case "720x480-NTSC":
					tv_standard = "ntsc";
					break;

				case "720x576-PAL":
					tv_standard = "pal";
					break;

				default:
					tv_standard = "ntsc";
					break;
			}
		}
	}
    else
    {
        alert ("configD is NULL");
        return;
    }
    shellCommand = new shellCommandObj();
    currentVersionNumber = shellCommand.GetVersion();
    if(currentVersionNumber > 0)
        currentVersion = ConvertVersionToString(currentVersionNumber);

    vod   = new vodSigmaObj(configd);
    video = new tvia5005Obj();
    sound = new soundMixerObj(configd);
}

/*-----------------------------------------------------------*/
function NoVideo()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if(video != null)
    {
      video.noVideo();
    }
    if(vod != null)
    {
      vod.EnableDestWindow(2);
    }
}

/*-----------------------------------------------------------*/
function GetResolution()
{
    return tv_standard;
}

/*-----------------------------------------------------------*/
function SetVideoLocationSize (x, y, height, width)
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( video != null )
    {
      video.setVideoLocationSize(x, y, width, height);
    }
}

/*-----------------------------------------------------------*/
function SetFullScreen ()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( video != null )
    {
        video.setFullScreen ();
        if (tv_standard == "ntsc")
        {
            if (currentVersion >= "3.71") 
            {
                var command;

                command = "poketvia";
                shellCommand.RunShellCommand(command);
            }
        }
    }
    if(vod != null)
    {
      vod.EnableDestWindow(1);

	  if(tv_standard == "ntsc")
	  {
		vod.SetDestWindow(720, 480);
	  }
	  else
	  {
		vod.SetDestWindow(720, 576);
 	  }
    }
}

/*-----------------------------------------------------------*/
function SetTransparentColor (r, g, b)
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( video != null )
    {
       video.setTransparentColor (r, g, b);
    }
}

/*-----------------------------------------------------------*/
function SetTransparentColorOn()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( video != null )
    {
       video.setTransparentColorOn ();
    }
}

/*-----------------------------------------------------------*/
function SetTransparentColorOff ()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( video != null )
    {
       video.setTransparentColorOff ();
    }
}

/*-----------------------------------------------------------*/
/* In the special case of mpeg4 multicast the "name" parameter is actually a valid sdp string */
function SetVideoTypeName(vidType, name)
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");

    var localURL = null;
    var workName = null;
    
    if (null != vod)
    {
        if ("MPEG4Multicast" == vidType)
        {
            writeSdpToFile(name);
            workName = fixedSdpFileName;
            localURL = "RTSP@ISMA_SDP_FILE";
        }
        else
        {
            workName = name;

            switch (vidType)
            {
                case "MPEG2Multicast":
                    localURL = "RTSP@MULTICAST_MPEG2_TRANSPORT";
                    break;
                case "MPEG2Kasenna":
                    localURL = "RTSP@KASENNA_MPEG2_TRANSPORT";
                    break;
                case "MPEG2Infovalue":
                    localURL = "RTSP@INFOVALUE_MPEG2_TRANSPORT";
                    break;
                case "MPEG1Multicast":
                    localURL = "RTSP@MULTICAST_MPEG1";
                    break;
                case "MPEG1Kasenna":
                    localURL = "RTSP@KASENNA_MPEG1";
                    break;
                case "MPEG1Infovalue":
                    localURL = "RTSP@INFOVALUE_MPEG1";
                    break;
                case "MPEG4Rtsp":
                case "MPEG4RtspForceUdp":
                    localURL = "RTSP@ISMA";
                    if (currentVersion >= "3.71") 
                        vod.setRtspStreamingOptions(0);
                    break;
                case "MPEG4RtspForceTcp":
                    localURL = "RTSP@ISMA";
                    if (currentVersion >= "3.71") 
                        vod.setRtspStreamingOptions(1);
                    break;
                        case "MPEG4RtspAuto":
                    localURL = "RTSP@ISMA";
                    if (currentVersion >= "3.71") 
                        vod.setRtspStreamingOptions(2);
                    break;
                 case "SDPFile":
                    GetSDP(name);
                    workName = fixedSdpFileName;
                    localURL = "RTSP@ISMA_SDP_FILE";
                    break;
                case "UnicastMPEG1":
                    workName = "#dataport=" + workName;
                    localURL = "RTSP@UNICAST_MPEG1";
                    break;
                case "UnicastMPEG2Transport":
                    workName = "#dataport=" + workName;
                    localURL = "RTSP@UNICAST_MPEG2_TRANSPORT";
                    break; 
                default:
                    localURL = "RTSP@MULTICAST_MPEG2_TRANSPORT";
                    break;
            }
        }
        localURL = localURL + "://";
        localURL = localURL + workName;

        vod.setVODURL(localURL);
    }
}

/*-----------------------------------------------------------*/
// after this function is called the mouse pointer will disappear after 3 seconds of inactivity until
// ShowInactiveMousePointer is called to kill the unclutter background task....
function HideInactiveMousePointer()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    shellCommand.RunShellCommand("uncluttercontrol stop >/dev/null 2>&1");
    shellCommand.RunShellCommand("uncluttercontrol start 3 >/dev/null 2>&1");
}

function ShowInactiveMousePointer()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    shellCommand.RunShellCommand("uncluttercontrol stop >/dev/null 2>&1");
}

/*-----------------------------------------------------------*/
function Vod_Fastforward ()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( vod != null )
    {
        vod.FastForward();
    }
}

/*-----------------------------------------------------------*/
function Vod_Rewind ()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( vod != null )
    {
        vod.Rewind();
    }
}

/*-----------------------------------------------------------*/
function Vod_Pause ()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( vod != null )
    {
        vod.Pause();
    }
}

/*-----------------------------------------------------------*/
function Vod_Open ()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( vod != null )
    {
         vod.Open();
    }
}

/*-----------------------------------------------------------*/
function Vod_Play ()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( vod != null )
    {
         vod.Play();
    }
}

/*-----------------------------------------------------------*/
function Vod_Stop ()
{
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    if ( vod != null )
    {
        vod.Stop();
        vod.Close();
    }
}

/*-----------------------------------------------------------*/
function sound_GetMainVolume()
{
    var volume = 0;
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");   
    if(currentVersion <= "3.69")
    {
        volume = sound.GetConfiguredVolume();
        return;
    }
    else
    {
        volume = sound.GetMainVolume();
    }
    return (volume);
}

/*-----------------------------------------------------------*/
function sound_SetMainVolume(volume)
{
    if(currentVersion <= "3.69")
        return;
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");   
    sound.SetMainVolume(volume);
}

/*-----------------------------------------------------------*/
function sound_MainVolumePlus()
{
    if(currentVersion <= "3.69")
        return;
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");   
    if(sound != null)
    {
        sound.MainVolumePlus();
    }
}

/*-----------------------------------------------------------*/
function sound_MainVolumeMinus()
{
    if(currentVersion <= "3.69")
        return;
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");   
    if(sound != null)
    {
        sound.MainVolumeMinus();
    }
}

/*-----------------------------------------------------------*/
function sound_Mute()
{
    if(currentVersion <= "3.69")
        return;
    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");   
    if(sound != null)
    {
        sound.MuteToggle();
    }
}
/*-----------------------------------------------------------*/

function writeSdpToFile( sdpOriginalString )
{
    var stringCmd;
    var sdpSubstitutedString;

    // the input string has to be legal SDP, therefore the first and last char cannot be ', ", etc., etc. 
    sdpSubstitutedString = sdpOriginalString.charAt(0);
    for (var i = 1; i < sdpOriginalString.length; i++)
    {
        if (sdpOriginalString.charAt(i) == "\'")
        {
            sdpSubstitutedString = sdpSubstitutedString + "\'\"\'\"\'";
        }
        else 
        {
            sdpSubstitutedString = sdpSubstitutedString + sdpOriginalString.charAt(i);
        }
    }

    // first remove the file if it is there
    stringCmd = "rm -f " + fixedSdpFileName; 
    shellCommand.RunShellCommand(stringCmd);

    // bash does support printf!
    stringCmd = "printf '" + sdpSubstitutedString + "' >" +  fixedSdpFileName; 
    shellCommand.RunShellCommand(stringCmd);
}

function ConvertVersionToString(curVersionNumber)
{
    var verstring = "";
    var majorVersion = 0;
    var majorVersionStr = "";
    var alphabetNum = 0;
    var alphabetChar = "";

    if(curVersionNumber < 8192 || curVersionNumber > 11386)
        return verstring;

    majorVersion = ((curVersionNumber / 32) + 44) / 100;
    if(majorVersion < 1 || majorVersion > 100)
        return verstring;

    majorVersionStr = majorVersion.toString();
    if(majorVersionStr.length <= 3)
    {
        majorVersion = majorVersion.toFixed(2);
        majorVersionStr = majorVersion.toString();
    }

    var decimalPos = majorVersionStr.indexOf('.');
    majorVersionStr = majorVersionStr.slice(0, decimalPos + 3);
    alphabetNum = curVersionNumber % 32;
    alphabetNum = 96 + alphabetNum;
    if(alphabetNum >= 97 && alphabetNum <= 122)
        alphabetChar = String.fromCharCode(alphabetNum);
    verstring = majorVersionStr + alphabetChar;
    return verstring;
}

function GetVersion()
{
    //VBrick/<hwtype>v<version>
    var retString = "VBrick/00v0"+currentVersion;
    return retString;
}

function GetSDP(url)
{
    if(currentVersion <= "3.69")
        return;
    shellCommand.GetSDPFile(url);
}

function SendStringToSerialPort(stringText)
{
    var dchar = 0;
    var command;

    dchar = configd.GetValue("system/shell/serial_shell.PASSTHROUGH_ACTIVE");
    if ("yes" == dchar)
    {
        command = "printf '" + stringText + "' > /dev/ttyS0"; 
        shellCommand.RunShellCommand(command);
    }
}