TV Manager API

Introduction

The TV Manager API interfaces provide a bunch of properties and a set of operations to allow Web applications to acquire the information of TV sources, TV channels and TV programs as well as to manage the native TV hardwares (i.e., TV tuners) or the TV Web services.

User Cases

The TV Manager API is aimed to cover the following user cases:

The web content is able to control the TV channel of the TV device with the TV tuner.
One TV can have multiple TV tuners. For example, one is for watching TV and the other is for recording.
TV Tuner can scan broadcasting channels, where each TV tuner can have its own scanning algorithm provided by the vendor.
Web content needs to know which broadcasting types are supported by the TV tuners.
Web content needs to know the information of Electronic Program Guide (EPG) that is being broadcasted.
Users can navigate through the EPG and selects a program to watch.
Users can watch the broadcasting program while browsing through the list of other programs that are currently broadcasted.
Web content needs to know if the currently displayed TV channel has bad or no signal. Can be covered by VideoElement?
One TV channel can have multiple video/audio tracks in the same broadcasting stream.
Emergency broadcasting for earthquake, tsunami... etc.
In the first step, only certified apps are allowed to use the TV Manager API.
The DTV can keep track of the multiple TV tuners that a TV channel can belong to, so that web content can do more flexible services like: when the user is using the TV tuner A to watch and record a certain TV channel at the same time, supposing the user wants to switch to other channels to watch, the DTV should use the TV tuner B to switch channels so that it won't stop the original recording task on the TV tuner A.
EPG can be dynamically updated by the broadcasters. We need a way to notify the web contents to update its EPG menu from time to time.
It is necessary to support multiple channels that can be concurrently displayed on the TV (i.e. Picture-in-Picture).
DTV needs to connect to the broadcasters' remote servers to provide more TV services through the Web. To do this, the web content needs a universal way to identify the TV program.

Examples

If an application has the privilege to use the TV Manager API, it can use a bunch of basic methods defined in the TVManager to manage the TV device.

The following example shows how to get all the TV tuners that are currently available on the TV device and how to listen to the events for the TV tuner changes.

          // An array which saves all the currently available TV tuners.
          var curTuners = [];

          // Set the 'ontunerchanged' event handler.
          navigator.mozTV.ontunerchanged = function ontunerchanged(event) {
            var operation = event.operation;
            var changedTuner = event.tuner;

            switch (operation) {
              case "added":
                curTuners.push(changedTuner);
                break;
              case "removed":
                curTuners.some(function findTuner(tuner, index) {
                  if (tuner.id == changedTuner.id) {
                    curTuners.splice(index, 1);
                    return true;
                  }
                  return false;
                });
                break;
              default:
                break;
            }
          };

          // Retrieve all the currently available TV tuners.
          navigator.mozTV.getTuners().then(function onsuccess(tuners) {
            curTuners = tuners;

            tuners.forEach(function setEventHandler(tuner) {
              // Set the 'oncurrentsourcechanged' event handler.
              tuner.oncurrentsourcechanged = function oncurrentsourcechanged(event) {
                alert("The current TV source of TV tuner: " + tuner.id +
                      " is configured to: " + event.source.type);
              };
            });
          }, function onerror(error) {
            alert(error);
          });

The following example shows how to get all the TV channels that are currently available in the currently configured TV source of a TV tuner and how to listen to the events for the TV channel changes.

          // A matrix which maps the TV tuner to its corresponding array of TV
          // channels based on the currently configured TV source.
          // E.g., { "tunerId1": [...], "tunerId2": [...] }.
          var curChannelsOfTuners = {};

          // Retrieve all the currently available TV tuners in the TV device.
          navigator.mozTV.getTuners().then(function onsuccess(tuners) {
            tuners.forEach(function getChannelsByTuner(tuner) {
              var tunerId = tuner.id;
              var currentSource = tuner.currentSource;

              if (!currentSource) {
                return;
              }

              // Set the 'onscanningstatechanged' event handler.
              currentSource.onscanningstatechanged = function onscanningstatechanged(event) {
                var state = event.state;
                var scannedChannel = event.channel;

                switch (state) {
                  case "cleared":
                    if (curChannelsOfTuners[tunerId]) {
                      delete curChannelsOfTuners[tunerId];
                    }
                    break;
                  case "scanned":
                    var channels = curChannelsOfTuners[tunerId];
                    if (channels) {
                      channels.push(scannedChannel);
                    } else {
                      curChannelsOfTuners[tunerId] = [scannedChannel];
                    }
                    break;
                  default:
                    break;
                }
              };

              // Retrieve all the currently available TV channels in the
              // currently configured TV source of the TV tuner.
              currentSource.getChannels().then(function onsuccess(channels) {
                curChannelsOfTuners[tunerId] = channels;

                channels.forEach(function setEventHandler(channel) {
                  // Set the 'onprotectionstatechanged' event handler.
                  channel.onprotectionstatechanged = function onprotectionstatechanged(event) {
                    alert("The current protection state of TV channel: " + channel.name +
                          " is configured to: " + event.isProtected);
                  };
                });
              }, function onerror(error) {
                alert(error);
              });
            });
          }, function onerror(error) {
            alert(error);
          });

The following example shows how to get all the TV programs that are currently available in the TV channel and how to listen to the events for the TV program changes.

          // A matrix which maps the TV channel to its corresponding array of TV
          // programs. E.g., { "channelNumber1": [...], "channelNumber2": [...] }.
          var curProgramsOfChannels = {};

          // Retrieve all the currently available TV tuners in the TV device.
          navigator.mozTV.getTuners().then(function onsuccess(tuners) {
            if (tuners.length == 0) {
              return;
            }

            // Just use the first TV tuner.
            var tuner = tuners[0];
            var currentSource = tuner.currentSource;

            if (!currentSource) {
              return;
            }

            // Set the 'oneitbroadcasted' event handler.
            currentSource.oneitbroadcasted = function oneitbroadcasted(event) {
              var newPrograms = event.programs;

              // Flush the EPG because a new EIT is broadcasted by the TV source.
              curProgramsOfChannels = {};

              newPrograms.forEach(function addProgram(program) {
                var channelNumber = program.channel.number;

                var programs = curProgramsOfChannels[channelNumber];
                if (programs) {
                  programs.push(program);
                } else {
                  curProgramsOfChannels[channelNumber] = [program];
                }
              });
            };

            // Retrieve all the currently available TV channels in the currently
            // configured TV source of the TV tuner.
            currentSource.getChannels().then(function onsuccess(channels) {
              channels.forEach(function getProgramsByChannel(channel) {
                var channelNumber = channel.number;

                // Retrieve all the currently available TV programs in the TV
                // channel.
                channel.getPrograms().then(function onsuccess(programs) {
                  curProgramsOfChannels[channelNumber] = programs;
                }, function onerror(error) {
                  alert(error);
                });
              });
            }, function onerror(error) {
              alert(error);
            });
          });

The following example shows how to play the MediaStream of a TV source by assigning the MediaStream to a HTMLMediaElement.

          <!DOCTYPE html>
          <html>
            <head>
              <script>
                // Retrieve all the currently available TV tuners first.
                navigator.mozTV.getTuners().then(function onsuccess(tuners) {
                  if (tuners.length == 0) {
                    return;
                  }

                  // Just use the first TV tuner.
                  var tuner = tuners[0];

                  var video = document.getElementById("video-player");
                  video.srcObject = tuner.stream;
                }, function onerror(error) {
                  alert(error);
                });
              </script>
            </head>
            <body>
              <p><video id="video-player" autoplay></video></p>
            </body>
          </html>

The following example shows how to scan and get all the TV channels that are available in the currently configured TV source of the TV tuner.

          // Retrieve all the currently available TV tuners in the TV device.
          navigator.mozTV.getTuners().then(function onsuccess(tuners) {
            if (tuners.length == 0) {
              return;
            }

            // Just use the first TV tuner.
            var tuner = tuners[0];
            var currentSource = tuner.currentSource;

            if (!currentSource) {
              return;
            }

            // Set the 'onscanningstatechanged' event handler.
            currentSource.onscanningstatechanged = function onscanningstatechanged(event) {
              var state = event.state;
              var scannedChannel = event.channel;

              switch (state) {
                case "cleared":
                  alert("All the TV channels are cleared for rescanning.");
                  break;
                case "scanned":
                  alert("A new TV channel is scanned: " + scannedChannel.name);
                  break;
                case "completed":
                  alert("The scanning process is completed.");
                  break;
                case "stopped":
                  alert("The scanning process is stopped.");
                  break;
                default:
                  break;
              }
            };

            if (currentSource.isScanning) {
              return;
            }

            // Ask the currently configured TV source to scan the TV channels.
            currentSource.startScanning({
              isRescanned: true
            }).then(function onsuccess() {
              // Retrieve all the currently available TV channels in the
              // currently configured TV source of the TV tuner.
              currentSource.getChannels().then(function onsuccess(channels) {
                alert("Succeeded to scan and get all the TV channels.");
              }, function onerror(error) {
                alert(error);
              });
            }, function onerror(error) {
              alert(error);
            });
          });

The following example shows how to tune the TV channel by the TV channel number.

          // Retrieve all the currently available TV tuners.
          navigator.mozTV.getTuners().then(function onsuccess(tuners) {
            if (tuners.length == 0) {
              return;
            }

            // Just use the first TV tuner.
            var tuner = tuners[0];
            var currentSource = tuner.currentSource;

            if (!currentSource) {
              return;
            }

            // Retrieve all the currently available TV channels in the currently
            // configured TV source of the TV tuner.
            currentSource.getChannels().then(function onsuccess(channels) {
              if (channels.length == 0) {
                return;
              }

              // Just use the first TV channel.
              var channel = channels[0];
              var channelNumber = channel.number.

              // Tune the currently streamed TV channel based on the TV channel
              // number.
              currentSource.setCurrentChannel(channelNumber).then(function onsuccess() {
                alert("Succeeded to tune the currently streamed TV channel.");
              }, function onerror(error) {
                alert(error);
              });
            }, function onerror(error) {
              alert(error);
            });
          }, function onerror(error) {
            alert(error);
          });

The following example shows how to unlock the TV parental control.

          // Retrieve all the currently available TV tuners.
          navigator.mozTV.getTuners().then(function onsuccess(tuners) {
            if (tuners.length == 0) {
              return;
            }

            // Just use the first TV tuner.
            var tuner = tuners[0];
            var currentSource = tuner.currentSource;

            if (!currentSource) {
              return;
            }

            // This event handler will be triggered when the TV channel is tuned.
            currentSource.oncurrentchannelchanged = function oncurrentchannelchanged(event) {
              var changedCurrentChannel = event.channel;

              if (navigator.mozTV.isParentalControlLocked &&
                  changedCurrentChannel.isProtected) {
                // If the TV parental control is locked and the currently tuned
                // TV channel is protected, the |tuner.stream|'s media tracks
                // will be disabled (i.e. black screen). The UA can then pop up
                // a prompt to ask the user to enter the password to unlock it.
                alert("Parental control is locked. Please enter the password.");

                // Unlock the TV parental control which will be applied system-wisely.
                navigator.mozTV.unlockParentalControl().then(function onsuccess() {
                  alert("Parental control is unlocked until the next reboot.");
                }, function onerror(error) {
                  alert(error);
                });
              }
            };

            // Retrieve all the currently available TV channels in the currently
            // configured TV source of the TV tuner.
            currentSource.getChannels().then(function onsuccess(channels) {
              if (channels.length == 0) {
                return;
              }

              // Just use the first TV channel.
              var channel = channels[0];
              var channelNumber = channel.number;

              // Tune the currently streamed TV channel based on the TV channel
              // number.
              currentSource.setCurrentChannel(channelNumber).then(function onsuccess() {
                alert("Succeeded to tune the currently streamed TV channel.");
              }, function onerror(error) {
                alert(error);
              });
            }, function onerror(error) {
              alert(error);
            });
          }, function onerror(error) {
            alert(error);
          });

TVManager Interface

The TVManager interface represents a bunch of properties and a set of operations that can be used to manage the TV device.

Promise getTuners (): This method makes a request to retrieve all the TV tuners that are available in the TV device. It returns a new Promise that will be used to notify the caller about the result of the operation, which is an array of TVTuner elements.
Promise unlockParentalControl (): This method makes a request to unlock the TV parental control by popping up a prompt to ask the user to input the correct password. Once the TV parental control is unlocked, it won't be locked until the next reboot. It returns a new Promise that will be used to notify the caller about the result of the operation.
readonly attribute boolean isParentalControlLocked: MUST return the current lock state of the TV parental control, which is system-widely applied to the TV device (i.e., once the parental control is unlocked, all the protected TV channels/programs will be unlocked until the next reboot).
attribute EventHandler onparentalcontrolchanged: Handles the onparentalcontrolchanged event of type TVParentalControlChangedEvent, fired when the method unlockParentalControl is invoked to unlock the TV parental control.
attribute EventHandler ontunerchanged: Handles the ontunerchanged event of type TVTunerChangedEvent, fired when the TV device detects a TV tuner is added/removed.

Steps

The getTuners method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV device to retrieve all the TV tuners that are available in the TV device.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Let tuners be the array of the retrieved TVTuner elements.
Invoke resolver's fulfill algorithm with tuners as the value argument.

The unlockParentalControl method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV device to unlock the TV parental control. The user agent has to pop up a prompt to ask the user to input the password to unlock the TV parental control.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Invoke resolver's fulfill algorithm without assigning a value to the value argument.

Event handlers

The following are the event handlers (and their corresponding event types) that MUST be supported as attributes by the TVManager object.

Event handler	Event name	Event type	Short description
`ontunerchanged`	`tunerchanged`	`TVTunerChangedEvent`	Handles the information of the TV tuner that is added/removed by the TV device.
`onparentalcontrolchanged`	`parentalcontrolchanged`	`TVParentalControlChangedEvent`	Handles the information of the changed state of the TV parental control.

TVTuner Interface

The TVTuner interface represents a bunch of properties and a set of operations related to the TV tuner.

Promise getSources ()

This method makes a request to retrieve all the TV sources that are available in the TV tuner. It returns a new Promise that will be used to notify the caller about the result of the operation, which is an array of TVSource elements that belong to the TV tuner.

Promise setCurrentSource ()

This method makes a request to configure the current TV source of the TV tuner by the sourceType parameter. It returns a new Promise that will be used to notify the caller about the result of the operation.

TVSourceType sourceType: Specifies the TV source type for configuring the current TV source.

readonly attribute DOMString id

MUST return the ID of the TV tuner.

readonly attribute TVSourceType[] supportedSourceTypes

MUST return the types of the supported TV sources.

readonly attribute TVSource? currentSource

MUST return the currently configured TV source. MUST return null if the TV source is not configured.

readonly attribute MediaStream? stream

MUST return a MediaStream object that is currently streamed by the TV tuner, which can be played by the video element by assigning the MediaStream to the HTMLMediaElement (details) and can be recorded by the MediaRecorder. MUST return null if the TV tuner is not streaming any data, which happens when the streaming signal is broken or due to any other reasons that the TV tuner fails to stream the data.

attribute EventHandler oncurrentsourcechanged

Handles the oncurrentsourcechanged event of type TVCurrentSourceChangedEvent, fired when the method setCurrentSource is invoked to configure the current TV source.

Steps

The getSources method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV tuner to retrieve all the TV sources that are available in the TV tuner.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Let sources be the array of the retrieved TVSource elements.
Invoke resolver's fulfill algorithm with channels as the value argument.

The setCurrentSource method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV tuner to configure the current TV source according to the sourceType parameter.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Invoke resolver's fulfill algorithm without assigning a value to the value argument.

Event handlers

The following are the event handlers (and their corresponding event types) that MUST be supported as attributes by the TVTuner object.

Event handler	Event name	Event type	Short description
`oncurrentsourcechanged`	`currentsourcechanged`	`TVCurrentSourceChangedEvent`	Handles the information of the current TV source that is configured by the method `setCurrentSource`.

TVSource Interface

The TVSource interface represents a bunch of properties and a set of operations related to the TV source.

Promise getChannels ()

This method makes a request to retrieve all the TV channels that are available in the TV source. It returns a new Promise that will be used to notify the caller about the result of the operation, which is an array of TVChannel elements that belong to the TV source.

Promise setCurrentChannel ()

This method makes a request to tune the currently streamed TV channel by the channelNumber parameter. It returns a new Promise that will be used to notify the caller about the result of the operation.

DOMString channelNumber: Specifies the TV channel number for tuning the currently streamed TV channel.

Promise startScanning ()

This method makes a request to start scanning all the TV channels that are available in the TV source by the options parameter. It returns a new Promise that will be used to notify the caller about the result of the operation. Note that this method has to be called first so that the method getChannels can retrieve the channels that have successfully been scanned by the TV source.

optional TVStartScanningOptions options: Specifies the options for scanning the TV channels. The isRescanned option in the options parameter specifies whether or not the process of scanning the TV channels has to clear the currently scanned TV channels before scanning; if it is not passed, this method will rescan all the TV channels as if it is passed as true.

Promise stopScanning ()

This method makes a request to stop scanning the TV channels for the TV source. It returns a new Promise that will be used to notify the caller about the result of the operation.

readonly attribute TVTuner tuner

MUST return the TV tuner which the TV source belongs to.

readonly attribute TVSourceType type

MUST return the type of the TV source.

readonly attribute boolean isScanning

MUST indicate whether the TV source is scanning the TV channels or not.

readonly attribute TVChannel? currentChannel

MUST return the TV channel that is currently streamed by the TV tuner which owns the TV source. MUST return null if the TV tuner is not streaming any data.

attribute EventHandler oncurrentchannelchanged

Handles the oncurrentchannelchanged event of type TVCurrentChannelChangedEvent, fired when the method setCurrentChannel is invoked to tune the currently streamed TV channel.

attribute EventHandler oneitbroadcasted

Handles the oneitbroadcasted event of type TVEITBroadcastedEvent, fired when the Event Information Table (EIT) is broadcasted by the TV source.

attribute EventHandler onscanningstatechanged

Handles the onscanningstatechanged event of type TVScanningStateChangedEvent, fired when the state of scanning the TV channels is changed by the TV source. E.g., it can be fired when the method startScanning or the method stopScanning starts or stops scanning the TV channels.

Steps

The getChannels method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV source to retrieve all the TV channels that are available in the TV source.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Let channels be the array of the retrieved TVChannel elements.
Invoke resolver's fulfill algorithm with channels as the value argument.

The setCurrentChannel method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV source to tune the currently streamed TV channel according to the channelNumber parameter.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Invoke resolver's fulfill algorithm without assigning a value to the value argument.

The startScanning method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV source to start scanning all the TV channels that are available in the TV source according to the scanning options specified in the options parameter. If the isRescanned option in the options parameter is not passed or it is passed as true, the user agent has to clear the currently scanned TV channels before scanning; if it is passed as false, the user agent will simply scan additional TV channels which haven't been scanned yet.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Invoke resolver's fulfill algorithm without assigning a value to the value argument.

The stopScanning method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV source to stop scanning the TV channels.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Invoke resolver's fulfill algorithm without assigning a value to the value argument.

Event handlers

The following are the event handlers (and their corresponding event types) that MUST be supported as attributes by the TVSource object.

Event handler	Event name	Event type	Short description
`oncurrentchannelchanged`	`currentchannelchanged`	`TVCurrentChannelChangedEvent`	Handles the information of the currently streamed TV channel that is tuned by the method `setCurrentChannel`.
`oneitbroadcasted`	`eitbroadcasted`	`TVEITBroadcastedEvent`	Handles the information of the available TV programs in the EIT that is broadcasted by the TV source.
`onscanningstatechanged`	`scanningstatechanged`	`TVScanningStateChangedEvent`	Handles the information of the state of scanning the TV channels, which is changed by the TV source.

TVChannel Interface

The TVChannel interface represents a bunch of properties and a set of operations related to the TV channel.

Promise getPrograms ()

This method makes a request to retrieve all the TV programs that are available in the TV channel by the options parameter. It returns a new Promise that will be used to notify the caller about the result of the operation, which is an array of TVProgram elements that belong to the TV channel.

optional TVGetProgramsOptions options: Specifies the options for retrieving the TV programs. If this parameter is not passed, this method will retuen all the available TV programs.

Promise setProtectionState ()

This method makes a request to configure the current protection state of the TV channel by the isProtected parameter. It returns a new Promise that will be used to notify the caller about the result of the operation.

boolean isProtected: Specifies the new protection state for configuring the current protection state of the TV channel.

readonly attribute DOMString networkId

MUST return the identification of a broadcast transmission network. On satellite and IP broadband, typically one networkId corresponds to an operator. On cable and terrestrial, where different radio frequencies might be used in different regions, operators typically use one networkId per such region.

readonly attribute DOMString transportStreamId

MUST return the identification of a time-domain multiplex of several programmes carried in Transport Stream (TS) packets. One or more multiplexes can be transmitted on any given radio frequency in a DVB network.

readonly attribute DOMString serviceId

MUST return the identification of a TV, radio or data programme within a TS multiplex. The number of programmes is limited by the capacity of the underlying physical channel.

readonly attribute TVSource source

MUST return the TV source which the TV channel belongs to.

readonly attribute TVChannelType type

MUST return the type of the TV channel.

readonly attribute DOMString name

MUST return the name of the TV channel. E.g., "CNN", "NHK"... etc.

readonly attribute DOMString number

MUST return the Logical Channel Number (LCN) of the TV channel. E.g., "12-1", "12-2", "12-2"... etc.

readonly attribute boolean isProtected

MUST return the current protection state of the TV channel, which decides whether or not the TV channel is protected from being watched by the children.

readonly attribute boolean isEmergency

MUST indicate whether the TV channel is for the emergency purpose.

readonly attribute boolean isFree

MUST indicate whether the TV channel is free to watch.

readonly attribute TVProgram? currentProgram

MUST return the TV program that is currently broadcasted by the TV channel. MUST return null if the TV tuner is not streaming any data.

attribute EventHandler oncurrentprogramchanged

Handles the oncurrentprogramchanged event of type TVCurrentProgramChangedEvent, fired when the currently broadcasted TV program is changed by the TV channel.

attribute EventHandler onprotectionstatechanged

Handles the onprotectionstatechanged event of type TVProtectionStateChangedEvent, fired when the method setProtectionState is invoked to configure the current protection state of the TV channel.

Steps

The getPrograms method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV channel to retrieve all the TV programs that are available in the TV channel according to the retrieving options specified in the options parameter.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Let programs be the array of the retrieved TVProgram elements.
Invoke resolver's fulfill algorithm with programs as the value argument.

The setProtectionState method when invoked MUST run the following steps:

Let promise be a new Promise object and resolver be its associated resolver.
Return promise to the caller.
Make a request to the TV channel to configure the current protection state of the TV channel according to the isProtected parameter.
If an error occurs invoke resolver's reject algorithm with error as the value argument.
When the request has been successfully completed:

Invoke resolver's fulfill algorithm without assigning a value to the value argument.

Event handlers

The following are the event handlers (and their corresponding event types) that MUST be supported as attributes by the TVChannel object.

Event handler	Event name	Event type	Short description
`oncurrentprogramchanged`	`currentprogramchanged`	`TVCurrentProgramChangedEvent`	Handles the information of the currently broadcasted TV program that is changed by the TV channel.
`onprotectionstatechanged`	`protectionstatechanged`	`TVProtectionStateChangedEvent`	Handles the information of the current protection state of the TV channel that is configured by the method `setProtectionState`.

Introduction

User Cases

Examples

Terminology

Navigator Interface

TVManager Interface

Steps

Event handlers

TVTuner Interface

Steps

Event handlers

TVSource Interface

Steps

Event handlers

TVChannel Interface

Steps

Event handlers

TVProgram Interface

TVStartScanningOptions Dictionary

TVGetProgramsOptions Dictionary

TVParentalControlChangedEvent Interface

TVTunerChangedEvent Interface

TVCurrentSourceChangedEvent Interface

TVEITBroadcastedEvent Interface

TVScanningStateChangedEvent Interface

TVCurrentChannelChangedEvent Interface

TVCurrentProgramChangedEvent Interface

TVProtectionStateChangedEvent Interface

Enumerations

Acknowledgements