Activates the built-in Akamai Client Side Media Analytics plugin, by specifying the beacon path that the plugin should track against. To turn-off the tracking after enabling it, pass "" as the value. This property greatly simplifies integration with CSMA, by only requiring this singe point of activation. The beacon path is something you would obtain from your Akamai CSMA account manager after you have established a valid CSMA account.

The default value is true.

Use this accessor instead of the analyticsBeacon accessor if you want to add multiple instances of the plugin in the same player. This is ideal for tracking AD or PIP on a separate analytics channel.

See also

 
         var analyticsPluginLoaderInstance:AnalyticsPluginLoader = AnalyticsPluginLoader(AnalyticsPluginLoader.getLoader("PlayerName"));
         if (analyticsPluginLoaderInstance == null)
         {
             analyticsPluginLoaderInstance = AnalyticsPluginLoader.loadPluginMultiPlay("http://79423.analytics.edgesuite.net/csma/plugin/csma.swf", ANALYTICS_BEACON_URL);
             AnalyticsPluginLoader.putLoader("PlayerName", analyticsPluginLoaderInstance)
         }
         netstream.analyticsPluginLoaderInstance = this.analyticsPluginLoaderInstance;    
         

Specifies whether the class should automatically try to recover from a timeout. Normally, this should always be left true. The one exception would be the instance of streams protected by edge auth tokens, where the token service is unable to generate streams after an idle-timeout. IN this case, the player application should listen for the HDEvent.TIMEOUT event and then set autoRecoverFromTimeout to false to prevent the class from trying to reconnect without valid tokens.

The default value is true.

Defines whether the class should automatically switch between available bitrates. If a switch is already underway you cannot modify the switching mode.

The default value is true.

See also

The smoothed and averaged playback bits per second. The instantaneous value can be obtained from playbackKbps.

See also

Returns a Boolean value representing whether bandwidth estimation for MBR content at startup is enabled.

Returns the buffer length in seconds

[Setter is DEPRECATED] Returns the current target buffer time on the netstream. IMPORTANT - the class will not use the bufferTime value supplied by this method. The bufferTime in this class is actively managed by the class through a series of throttling command calls. Buffer behavior incorporates a fastStart mode for archive viewing, whereby the player builds only a small buffer before playback commences and then builds a larger buffer in the background while play is underway. The short-term target will be defined by startingBufferTimeOndemand. Once playback is underway, the bufferLength is actively managed to stay close to the target buffer time. This target time is set to linearly vary from TARGET_BUFFER_TIME_LOW_LATENCY at a RTT estimate of LOW_RTT to TARGET_BUFFER_TIME_HIGH_LATENCY at a RTT estimate of HIGH_RTT. These constants are fixed in this class and to adjust the buffer behavior you will need to modify the class itself. The current target buffer time being used can be obtained by reading the bufferTime property.

Returns the bytes loaded since the last play request.

Sets the client property of the NetStream. Since the class must also monitor callbacks against the client, a proxy object is used. This ensures that both the class and its parent can listen to callback functions such as onMetadata.

If enabled, the class will not switch up during multi-bitrate playback if the area that the video is being rendered at is smaller than the the native size of video. This rule is valid as long as the MBR package has been encoded with consistent "quality density" (i.e bitrate/pixel ratio), which implies that it is pointless to move up in an index if the video is already being scaled-down for display, since the video will not look any better to the end-user.

The default value is false.

The system cpu as a percentage. This property is only available on computers which have the Akamai NetSessionClient installed.

The current index that is rendering for a MBR object source.

The bitrate value of the current index,, in kbps.

See also

If set true, this property will prohibit the class from playing back the archive portion of a live stream. This includes accessing the archive while the stream is still being published (i.e DVR) as well as after publishing is complete. If a stream starts and the player realizes that it is archive, then class will halt playback and dispatch a new HDEVENT.ARCHIVE_PLAYBACK_DISABLED event. If both encoders stop and loop is false, then the live stream will just end with the HDEvent.COMPLETE. If loop is true, then loop will be disabled, playback will cease and the HDEVENT.ARCHIVE_PLAYBACK_DISABLED event dispatched.

A reference to any object that participates in the display stack and which has a access to the "stage" property. This reference is only required when SWF Authentication is required. This property must be set prior to play() being called or swf authentication will fail.

The downloadRatio is the ratio of the rate at which bytes are being downloaded over the rate at which they are being rendered. A downloadRatio > 1 means the buffer will grow, < 1 means it will shrink. The class uses this metric as a trigger to switch down to a lower bitrate. Note that the downloadRatio is affected by the throttle setting. A throtle < 100% will cause the ratio to appear smaller than it really is.

The estimated dropped-frame rate, expressed in Hz. This is a backwards looking estimate, calculated over the prior second.

Returns the absolute count of dropped frames since the last play request

Returns the duration of the stream in seconds. For live streams, this number will constantly increase as long as the live source continues publishing.

Returns the duration of the stream as HH:MM:SS timecode

Specifies the length of the DVR window, if implemented, in seconds. The DVR window is an optional rolling window that defines which portion of a live stream is accessible. For example, a live news broadcaster may want to make the last hour of their live 24x7 newscast available. In this case the dvrWindow will return a value of 3600. DVR window must be set as a property of the Akamai account and must be configured and initiated through the Akamai portal. DVR window only applies to LIVE streams or archives of formerly live streams, it does not apply to VOD streams. Listen for the HDEvent.DVR_WINDOW event to know when this property is detected or changed.

Returns the IP address of the Akamai Edge Server to which the client has connected. This property will only hold a valid value after the first onEdge data message has been received following a play() request.

Returns the version of the Akamai Edge Server to which the client has connected. This property will only hold a valid value after the first onEdge data message has been received following a play() request.

If there is an issue with the stream at startup or during playback it may be caused by a server condition. If this feature is enabled and your account is provision for this feature, when an issue arises, the stream will be re-requested from anther server that will have more resources available. The stream will continue from the same point on the new host.

If you enable this feature and enableAlternateServerMapping is not enabled - enableAlternateServerMapping will be enabled. Setting enableEndUserMapping to true will result in multiple ident requests to servers both mapped from nameserver and an end user's ip Depending on a comparison of the RTT value in these ident, a primary host is determined. This could result in locating a server closer to the end user and providing better over-all performance.

Enables the class to discover the NetSession interface . This property must be set true before play() is called, in order to prompt the class to make the discovery request to verify if NetSession is installed. This property must be set true if the netSessionClientAvailable is to be queried and the NETSESSION_CLIENT event be dispatched when playback starts.

The default value is true.

The estimated current throughput between client and server, expressed in kilobits per second.

The estimated maximum throughput between client and server, expressed in kilobits per second.

The estimated round-trip time between client and server, expressed in milliseconds. This value is only available after the first bitrate test has been completed.

eturns whether the flash runtime is in sleep mode.

True if the stream has ended

Specifies whether the stream playing is "live". A live stream is defined as one for which the duration is constantly increasing. Note that since DVR is enabled, it is possible to play a live stream at both "true live" i.e the latest possible time and also in archive mode. The difference can be determined by examining the isPlayingLive property.

The default value is false.

See also

True if the stream has was paused while isPlayingLive was true. This state is tracked separately since the connection is actually dropped completely if the user pauses while isPlayingLive is true, whereas normally the connection is maintained and throttling is set to zero.

The default value is false.

See also

Specifies whether the the stream is playing at "true" live. This is true if the stream is a live stream and the current time is within 5s of the duration.

See also

Defines whether the class is currently executing a switch. If it is, then you cannot change the switching mode.

See also

The last throttle value requested form the server. Throttle values are expressed as percentage of stream bitrate. So a throttle of 0 means stop sending data, a throttle of 100 means send data at the stream bitrate and a throttle of 200 means send data at twice the stream bitrate.

For live streams only, the estimated difference between the duration that the class is rendering and the latest duration that the server has, in seconds. This drift will be induced due to buffering on the client.

If enabled, once the stream is complete it will loop back and begin playing from the start. Note that the HDEvent.COMPLETE event will not be dispatched when the content loops. The HDEvent.LOOP event will be dispatched in its place.

The default value is false.

Specifies the maximum buffer length in seconds to allow when a) the class is paused b) single bitrate content is playing c) multi-bitrate content is playing at the highest rendition available. For multi-bitrate renditions below the maximum, or LIVE streams playing at the true live point, the buffer length is automatically managed to balance transition time with buffer robustness.

The default value is 60.

Specifies wether the class should set the target buffer to a high value (default is 60s) for non-live single-bitrate content and for non-live multi-bitrate content where you are playing the highest available index. The reasoning here is that in either of these two scenarios, you are playing at your optimum quality level, so it is best to build a larger buffer to ensure some robustness over transient variance in throughput. The situation in which you may not want to do this is if you intend to manually switch out of the highest bitrate in a MBR package, in order to force it to a thumbnail view for example. The default value is false.

The default value is true;.

When switching multi-bitrate content in auto-mode, this property specifies the maximum stream bitrate, in kbps, that the class is allowed to play. Even if the class finds a very high estimated bandwidth, it will only allow itself to play the highest rendition which is <= this value. If you set this property to a value lower than that currently playing, the class will switch down to satisfy this requirement. If you set it to a value that is lower than the lowest bitrate, it will still play that lowest bitrate.

The default value is int.MAX_VALUE.

The highest index available for the current MBR object. The max index available may be limited by the maximumBitrateAllowed setting, which is why this property may not correspond to the highest index specified in the MBR object. Index values start at zero.

See also

The bitrate value of the highest index that is available, in kbps.

See also

[DEPRECATED] The maximum live drift value allowed, in seconds. If the stream is playing at true live and the liveDrift value exceeds this value, then the class will automatically pull itself back to live by making a new play request for seek=live

The default value is INT.MAX_VALUE.

See also

The maximum number of seconds that the class has not received data while playing.

The current IMBRObject instance that the class is playing MBR content, or else null for SBR.

Returns whether the Akamai NetStession client has had its EULA accepted.

See also

Returns true if the Akamai NetSession client is installed on the client machine. This property will only contain a meaningful value if enableNetSessionDiscovery is set to true prior to calling play(). It will take a few seconds to detect the NetSession client after play() is called, so wait for the NETSESSION_CLIENT event before querying this property.

See also

Sets the CP code that the Akamai NetSession client will use. This property must be set before calling play() on the HDNetStream class. This property is only required if the Akamai NetSession client is being used by this class.

The estimated frame rate of the video. This metric is estimated by taking the max of the currentFPS property for the stream. It is calculated since it is not provided reliably in the onMetaData object.

Returns the playback bitrate of the current stream, in kbps. This rate includes the sum of the audio and video bitrates for flash player 10.0.32.18+. For lower versions, due to a flash player bug, it only returns the audio component of the bitrate.

Returns the IP address of this player. This property will only hold a valid value after the first onEdge data message has been received following a play() request.

Sets the primaryToken for the class to use to perform EdgeAuthentication against the Akamai network. Note that this property provides a simplified path to token use and is not to be confused with the tokenService property. The primaryToken property must be set before the start of play. The class will use it once, upon making its first play request but will then discard it. You must ensure that the token correctly hashes the first stream that will be requested. By default this is the largest bitrate <= 500kbps. If the getStartingIndex() method has been over-written or an explicit startingIndex has been supplied, then the appropriate token must be supplied.

See also

The quality of experience metric is a single number (with a range of 0-100) which attempts to sum up the quality of the playback experience. It updates constantly throughout a playback session. Much like your GPA was used to represent your ability at school, so the QoE metric attempts to characterize the playback expereince which the user is receiving. It takes bandwidth, switching, rebuffers and framedrops in to account.

See also

True if the stream has reached its target buffer after starting.

[DEPRECATED] - this property is maintained only to ensure backwards compatibility.

See also

When set to false, if you pause a live stream, the stream will resume playing at the point at which it was paused. If the pause point falls outside of a limited DVR window, the resume point will be the beginning of the DVR window. If the content is secure and it is paused over 120 seconds, a new token and play method call will be required. When set to true, if you pause a live stream while at the live position, the stream will resume playing at the live point - unless the content is secure and it is paused over 120 seconds. In this case you will need to request a new token and issue a play command with the new token and this will result in the stream starting at the live point. If not playing at the live position the stream will resume at the paused point. Default value is true

The estimated time in seconds until the buffer is empty. A 5s buffer will last 5s only if zero data is being sent by the server. If the buffer were declining at 0.5s per second, then the buffer would empty after 10s. This property captures that time and is used in several of the switching decisions.

Sets the soundTransform object of the stream.

Returns the source object which the class is currently playing. This will be either an HDMBRObject, or a String.

See also

Sets the max bitrate value you wish to use at startup in kbps. The index chosen will be the largest index whose total bitrate is smaller than or equal to this value. This property must be set before play() is called. Note that the bitrate value used is the sum of the video and audio, so if a rendition is labeled as "_700" its true bandwidth may be 786kbps. It's generally good practice then to specify a starting bitrate at N kbps or so higher than the bitrate you intend to target, where N is the max audio bitrate you are using. If you set both startingIndex and startingBitrate, startingIndex will be used. Set it to NaN to turn it off after setting it.

Setting this value will effect the startup time of the stream. The minimum accepted value is .75 seconds. The maximum accepted value is 10 seconds. If you set the value lower or higher then the accepted values, your value will be coerced to the closest acceptable value.

Benefits of changing this value are as follows:

• A lower value will result in a faster stream startup time.
• A higher value will reduce the chance that the end user will experience a rebuffer event.

The starting index to use when playing MBR content. This index is zeroth based. If this value is not set (the default is null), then the starting index will be determined by the protected getStartingIndex() function. If you wish to add custom business logic for determining how the starting index is selected, then extend this class and override that function.

The real world start time of the stream, in milliseconds since midnight January 1, 1970, universal time.

Returns in integer representing the type of stream content that is currently rendering. Possible stream types are

Returns the playhead time of the stream in seconds.

Returns the playhead time of the stream as HH:MM:SS timecode

Sets the token service that the class will use to request an EdgeAuth token. This property is only required when playing content protected by EdgeAuth. The property must be set to a valid instance of an ITokenService before the play() method is called.

See also

The raw bufferTime value of the underlying netstream class. This is separate from the bufferTime property, which returns the target buffer time which the class is trying to achieve.

See also

For single-bite rate content, there can be minimal benefit in constant throttle commands being issued. Therefore, if this property is set true, the class will build the buffer using a throttle of 200% to its target and after that, will have a fixed throttle of 100%. No bandwidth tests or RTT tests will be run.

The default value is false.

Toggles use of verbose logging on GHost. Turning verbose logging on can assist with debugging server-side delivery issues.

Sets the volume of the stream. Volume ranges from 0 (mute) to 1(max loudness).

Constructor. The class requires a NetConnection in its constructor. This NetConnection must be connected to "null" since HD is a purely progressive solution.

Checks to see if the Akamai NetSessionClient is installed on this machine. Since the request is asynchronous, this method does not return a response. Instead, you must listen for the HDEvent.NETSESSION_CLIENT event which will return a Boolean data property indicating whether the client is present or not.

See also

Closes the NeStream and stops all running timers

Prepares the class instance for deletion by cleaning out objects that may be held in memory. Only call this method once you intend to dispose of the class instance. The class will not function correctly after this method has been called. This should be the last method you call on this class. This method will call the public close method so there is no need to call netStream.close if you are calling netStream.destroy.

In version v2.5 a feature was added to help stabilize the buffer by increasing it by 10 seconds per index once the index has been playing without a switch for more than 25 seconds. Now there is a public API to enable or disable that functionality as well as configure the observationPeriod and the amount of time to increase the buffer.

This feature is enabled by default

Parameters

See also

This is for unit testing only.

Installs the Akamai NetSession client with a given filename and optional acceptance of the EULA and specificaiton of the EULA version.

Parameters

See also

Returns whether or not the class is playing multi-bitrate content. A SMIL can be supplied with only a single bitrate, so it will be true if a SMIL source has been supplied and if that source has at least 2 bitrates.

Triggers the class to make a request to the server for an updated TAT time.

Sends a request to the Akamai NetSession client indicating that the user has accepted the EULA.

See also

Pauses the video. Must only be called after a play() or seek() request otherwise it will have no effect. An HDEvent.PAUSE event will be dispatched when this method is called.

Commences playback of content through this netstream. Two different content types are supported:

1. Simple URL: a simple string URL can be passed in referencing a single asset. Typical structure would be
   http://<customer.edgesuite.net>/event_angle_bitrate@xxxxx
   where
   • <customer.edgesuite.net> = a HD-enabled domain on the Akamai FreeFlow network
   • event_angle_bitrate@xxxxx = the stream name, comprised of the event (common to an event such as a sports game), the angle (a view of the event synced with other angles), the bitrate (a rendition of that angle at a specific bitrate) and the stream ID (which is unique across the Akamai namespace and assigned by our portal). The class can switch smoothly between angles and bitrates.

   Examples include http://demo2.HD.akamai.com/quantum_top_1500k@123456 http://demo2.HD.akamai.com/quantum_side_700k@123456 http://demo2.HD.akamai.com/quantum_side_1500k@123456
   If a domain is protected with SWfAuth, then the authorizing cp code must be appended to the URL as a query param with the reserved name "authCP". An example would be:
   http://demo2.HD.akamai.com/quantum_h264_1500k@123456?authCP=59606
2. Simple path (URL) to a SMIL file. An example would be
   http://mydomain.com/smil/mymbrcontent.smil
   If this resource is located on a different domain to that serving the swf, then be sure to provide a crossdomain.xml file at the root of the server delivering the SMIL. The SMIL format currently used is this:
   <?xml version="1.0"?> <!DOCTYPE smil PUBLIC "-//W3C//DTD SMIL 2.0//EN" "http://www.w3.org/2001/SMIL20/SMIL20.dtd"> <smil xmlns="http://www.w3.org/2001/SMIL20/Language"> <head> <meta name="title" content="Earth Trailer" /> <meta name="httpBase" content="http://efvod-hdnetwork.akamai.com.edgesuite.net/" </head> <body> <switch id="Earth Trailer"> <video src="earth2_h264_3500@14411" system-bitrate="3500000"/> <video src="earth2_h264_2500@14411" system-bitrate="2500000"/> <video src="earth2_h264_1500@14411" system-bitrate="1500000"/> <video src="earth2_h264_700@14411" system-bitrate="700000"/> <video src="earth2_h264_300@14411" system-bitrate="300000"/> </switch> </body> </smil>
3. IMBRObject - basically a collection of renditions of the same piece of content at different bitrates. It represents a package of files which the class may switch through as bandwidth conditions change. The HDMBRObject implements IMBRObject and conveniently bundles an array representing the stream names and their bitrates, along with the associated httpbase, rtmpBase and title of the package.
4. USMIL format - a url format that contains the required elements of a SMIL file. This has the same results as if you are using a .smil or IMBRObject to define a MBR profile.
   • Example of url including the optional width and height parms: - http://tceast-f.hdflash.edgesuite.net/will/robin_hood_25fps_,a~300~320~180,b~600~640~360,c~1200~640~360,d~1800~640~360,e~2400~1280~720,f~3000~1280~720,.f4v.usmil
   • Example of url excluding the optional width and height parms: - http://tceast-f.hdflash.edgesuite.net/will/robin_hood_25fps_,a~300,b~600,c~1200,d~1800,e~2400,f~3000,.f4v.usmil
   • Example of live stream usmil url: - http://live.edgeflash.akamai.com.edgesuite.net/akamai247_2_,800~800,1600~1600,@13903.usmil
   The parts of a usmil url are:
   • HTTP Base: http://tceast-f.hdflash.edgesuite.net/
   • Common Stream name: will/robin_hood_25fps_
   • MBR CSV: unique_name~300~320~180, [unique file name, bitrate, width (optional), height (optional)]
   • Extension (VOD): .f4v.usmil
   • Extension (LIVE): @XXXXX.usmil

UTC Start time for LIVE streams To start a live stream at a certain point, a UTC time can be supplied as a query arg appended to the media url or as the second argument to the play method.

• Query Arg SBR: play(http://multiformatlive-f.akamaihd.net/demostream_1_300@2131?seekABS=1343059379)
• Query Arg MBR SMIL, USMIL or MBRObject: play(http://multiformatlive-f.akamaihd.net/demostream_1_,300~300,800~800,1200~1200,@2131.usmil?seekABS=1343059379)
• As Start Time Argument for SBR or MBR: play(http://multiformatlive-f.akamaihd.net/demostream_1_,300~300,800~800,1200~1200,@2131.usmil, 1343059379)

Sub-Clips Sub-clips are only supported for VOD content. The play method supports the following argument combinations for sub-clips:

• play(streamName, 20) This will start the stream 20 seconds in, play the entire stream and the entire stream is seekable.
• play(streamName, 20, 10) This will create a sub-clip of the stream that will start 20 seconds in and play for 10 seconds. The time and duration properties will reflect a sub-clip. In other words, it will appear to the player that the stream is only 10 seconds long.
• play(streamName, 20, -1) This will also create a sub-clip of the stream. It will start 20 seconds in and play for the duration of the stream, but the time and duration properties will correctly reflect a sub-clip.
• play(streamName, 20, 0) This will start the stream 20 seconds in but play only until the first key frame. The duration property will be zero in this case.

Sub-clips are also supported in a SMIL file using the clipBegin and clipEnd attributes on a media tag. For example:

<switch id="Seas Trailer"> <video src="seas2_h264_3500@14411" system-bitrate="3500000" clipBegin="60" clipEnd="65"/> <video src="seas2_h264_2500@14411" system-bitrate="2500000" clipBegin="60" clipEnd="65"/> <video src="seas2_h264_1500@14411" system-bitrate="1500000" clipBegin="60" clipEnd="65"/> <video src="seas2_h264_700@14411" system-bitrate="700000" clipBegin="60" clipEnd="65"/> <video src="seas2_h264_300@14411" system-bitrate="300000" clipBegin="60" clipEnd="65"/> </switch>

Sub-clips are also supported via the IMBRObject2 interface. There are properties for setting clipBegin and clipEnd and this class will honor them if you supply an object which implements that interface.

Parameters

See also

Resumes playback of paused video. Must only be called after a pause() request otherwise it will have no effect. An HDEvent.RESUME event will be dispatched when this method is called.

A utility function for converting seconds into HH:MM:SS timecode.

Parameters

Seek the stream. If the value is -1, then this indicates a desire to seek to the latest available portion of a live stream.

Parameters

Triggers the class to dispatch an update its stats. Currently this only involves updating the rendition stats and the isLive status.

See also

This method should only be used for MBR content and must be set before calling play. When enabled, a bandwidth test will be conducted and last for the length of time specified by the second arg of this method. The default time is 1 second. The results of this test will then explicitly set the starting index of the MBR content to the nearest kbps.

Parameters

Sets the desired active index for multibitrate content. This method will only work if you are playing multi-bitrate content, autoSwitching is enabled and if the index you are attempting to set is not the index that is already playing or that is being ignored.

Parameters

Tells the player what the dimensions of the rendered area for the video. The player will use this to make switching decisions if considerDimensionsWhenSwitching is true.

Parameters

See also

For testing QOS alternate server mapping switch back to primary.

For testing QOS Alternate server mapping force tag

Triggers the class to dispatch a HDEvent.RENDITION_CHANGE event, which carries information about the current index that is rendering and the max index that is available. Typically this information is used to update a HD meter.

See also

Dispatched when the class fails over to the alternate server map. This will only occur if the enableAlternateSeverMapping property has been set true. Failover occurs when the class receives no incoming data for 5s, the buffer length is smaller than 5s and the stream is not paused.

• newHost: the new host that it is switching to
• oldHost: the old host it is switching from

See also

Dispatched when the disableAllArchivePlayback property is set true, and the class detects that the user is trying to access a live stream (or a stream that was formerly live) at a point other than true live, which is defined as being within 10s of the latest TAT time returned by the server.

See also

Dispatched when a new estimate of the maximum bandwidth available between client and server is available from the class.

Dispatched when stream playback is complete. This event is also dispatched if a player is paused and the DVR Window slides out from under its paused position.

Dispatched when the class receives a data message embedded in the stream. These data messages do not include onMetaData or onEdge messages. However, all other custom messages will trigger this event.

• name: the name of the data message
• value: the value of the data message

Dispatched when the class detects that no bytes have been received in 10s following a buffer empty event. Developers may use this as an indication that the connectivity to the server has been lost and can take appropriate action such as attempting a new request. The class will not shut down any of its metrics functions when this event is dispatched and will continue to attempt to play the existing stream.

Contains a debug message. These messages are not intended for consumers but are provided to help developers debug the player code. This class will bubble up debug events it receives from the HDPrimaryTokenService class.

Dispatched when the DVR window is detected or is changed. A stream which does not have DVR window enabled will not dispatch this event after play() is called.

See also

Dispatched when the player is paused on a live stream with dvr window enabled, and the player slides out of the available dvr window. Once this event is dispatched, playback is halted and can only be resumed through a seek(0) or play() request. By calling seek(0), the stream will start at the beginning of the DVR window. By calling play, the stream will start at the live point.

See also

Dispatched when this class receives an error from the server. Possible errors include

Dispatched when the server informs the client that it must disconnect from the HTTP network and fail-over to the RTMP network. This event would be sent only in a worst-case scenario and should not be considered a part of normal operating procedure. Note that this class will NOT support RTMP streaming. It is up to the player implementing this class to invoke a new standard NetStream over which it can stream the fail-over content.

Dispatched when a failure event occurs in one of the sub-classes which this class invokes, specifically the HDPrimaryTokenService or the HDController.

See also

Dispatched when the buffering state of the class changes. A stream is considered to be buffering between the NetStream.Play.Start event and the NetStream.Buffer.Full NEtStreamStatus events.

Dispatched when the state of the stream switches between live and archive. A live stream is one in which the duration is constantly increasing. Note that a stream can be live and you can still play through its archive component. A purely archived stream will have a constant duration.

Dispatched when the state of the stream switches between playing live and not playing live. Since a live stream is one for which the duration is constantly increasing, you are playing live if the current playhead time is within 10s of the duration. You can be not playing live, but still viewing a live stream, if you are viewing that live stream at a playhead position that is more than 10s back from live. You can never play an on-demand stream in true live mode.

Dispatched when the stream loops back and plays from the start after completing. Note that the HDEvent.COMPLETE event will not be dispatched when the content loops. The HDEvent.LOOP event will be dispatched in its place.

See also

Dispatched when a onMetaData callback has been received by the class. This is triggered whenever the class finds an onMetdata event embedded in the stream. onMetadata events are typically received after each play or seek command and also at switch boundaries.

Dispatched when the class detects a change in the presence of the Akamai NetSession client.

Dispatched when the class detects a change in the EULA status of the Akamai NetSession client.

Returns the NetStatus events. This is a copy of what you would get by listening for flash.events.NetStatusEvent, but it is provided as an HDEvent for consistency in handling.

Dispatched when the class has been given a pause command.

See also

Dispatched when the class receives a play request.

• source: the object now playing as the play source. This object will be either String or HDMBRObject instance. The string can represent a path to a single assets, or to a SMIL file which in turn defines a MBR package.
• stream: a string representing the actual resource that is now playing. If the source is a HDMBRObject, then the stream will contains the rendition stream name it is starting with.
• index: a number representing the index in the HDMBRObject represented by the stream. If the source has no MBR content associated with it, then this value will return 0.

See also

The progress event is an update event that is dispatched by the class at 100ms intervals. It is used to drive updates to UI elements such as time displays and scrub bars. The progress event will start after play() is called and will stop after

1. close() is called
2. onEdge receives a status of 3 - COMPLETE

Dispatched after the stream has experienced an unexpected rebuffer event during playback and has successfully re-filled its buffer. Note that this event is not dispatched during normal play() and seek() behaviors, when rebuffering is expected.

Dispatched when there is a change in the rendition index that is being rendered. This event will still be dispatched for single bitrate content, in which case current will always be 0 and max index will always equal 1 and the currentKbps will be null, since it is not known.

• currentIndex: the current index being played
• maxIndex: the max number of indices available. Note that the max index itself will be one less than this value, since the indices are zeroth based.
• currentKbps: the bitrate in kbps associated with the current index.
• maxKbps: the bitrate in kbps associated with the max index.

Dispatched when the class has been given a resume command.

See also

Dispatched when a new estimate of the Round Trip Time between client and server is available from the class.

Dispatched when the class has been given a seek command.

• seekFrom: the time we are seeking from, in seconds, rounded to 2 decimal places.
• seekTo: the time we are seeking to, in seconds, rounded to 2 decimal places.

See also

Dispatched when the class receives a new session ID from the server

Dispatched when the Flash Player's sleep mode has changed.

See also

Dispatched when there is a change in the stream name being rendered.

Dispatched when the stream cannot be found on the server.

Dispatched when the class receives a stream-not-found message from the server during the course of normal playback. Typically this will occur with live streams if both primary and backend encoders loose connectivity and do not stop publishing cleanly. This event is distinct from HDEvent.STREAM_NOT_FOUND, which is usually dispatched right when playback is attempted, but never begins. Note that all timers will be stopped after this event is dispatched, so playback will only resume after a new play() is issued.

See also

Dispatched when the class detects a change in the stream start time. This event is only dispatched for live streams.

Dispatched when there is a change in the type of stream being rendered. Possible stream types are

Dispatched when a switch has completed.

Dispatched when a switch failure has been indicated by the server.

Dispatched when switch has commenced between multi-bitrate renditions.

• index: the index that is being switched to.
• reason: the reason for this switch
• ruleID: a constant value from the SwitchingRuleIDs class specifying the rule ID requesting the switch.

Dispatched when the server times-out the connection due to its being idle past the idle-threshold. The current idle threshold is 120 seconds. An idle state is when the stream is paused and throttled to 0, so that the server is not sending any data to the client. When a timeout is encountered, the class will automatically try to reconnect. This involves repeating the entire authentication process, including retrieving the primaryToken if a tokenService has been supplied and establishing the session token if requiresSwfAuth is true.

See also

Dispatched when the Flash Player sleep state changes. Call the isAsleep property to get the current state.

See also