The number of seconds of data currently in the buffer. You can use this property with the bufferTime property to estimate how close the buffer is to being full — for example, to display feedback to a user who is waiting for data to be loaded into the buffer.

See also

Specifies how long to buffer messages before starting to display the stream. For example, to make sure that the first 15 seconds of the stream play without interruption, set bufferTime to 15; the application begins playing the stream only after 15 seconds of data are buffered.

The default value is 0.1 (one-tenth of a second). To determine the number of seconds currently in the buffer, use the bufferLength property.

Note: To avoid distortion when streaming pre-recorded (not live) content, do not set the value of Netstream.bufferTime to 0. By default, the application uses an input buffer for pre-recorded content that queues the media data and plays the media properly. For pre-recorded content use the default setting or increase the buffer time.

Starting with Flash Player 9 Update 3, Flash Player no longer clears the buffer when NetStream.pause() is called. Before Flash Player 9 Update 3, Flash Player waited for the buffer to fill up before resuming playback, which often caused a delay.

For a single pause, the NetStream.bufferLength property has a limit of either 60 seconds or twice the value of NetStream.bufferTime, whichever value is higher. For example, if bufferTime is 20 seconds, Flash Player buffers until NetStream.bufferLength is the higher value of either 20*2 (40), or 60, so in this case it buffers until bufferLength is 60. If bufferTime is 40 seconds, Flash Player buffers until bufferLength is the higher value of 40*2 (80), or 60, so in this case it buffers until bufferLength is 80 seconds.

The bufferLength property also has an absolute limit. If any call to pause() causes bufferLength to increase more than 600 seconds or the value of bufferTime * 2, whichever is higher, Flash Player flushes the buffer and resets bufferLength to 0. For example, if bufferTime is 120 seconds, Flash Player flushes the buffer if bufferLength reaches 600 seconds; if bufferTime is 360 seconds, Flash Player flushes the buffer if bufferLength reaches 720 seconds.

Tip: You can use NetStream.pause() in code to buffer data while viewers are watching a commercial, for example, and then unpause when the main video starts.

For more information about the new pause behavior, see http://www.adobe.com/go/learn_fms_smartpause_en.

Flash Media Server. The buffer behavior depends on whether the buffer time is set on a publishing stream or a subscribing stream. For a publishing stream, bufferTime specifies how long the outgoing buffer can grow before the application starts dropping frames. On a high-speed connection, buffer time should not be a concern; data will be sent almost as quickly as the application can buffer it. On a slow connection, however, there might be a significant difference between how fast the application buffers the data and how fast it can be sent to the client.

For a subscribing stream, bufferTime specifies how long to buffer incoming data before starting to display the stream. For example, if you want to make sure that the first 15 seconds of the stream play without interruption, set bufferTime to 15; Flash will begin playing the stream only after 15 seconds of data have been buffered.

When a recorded stream is played, if bufferTime is zero, Flash sets it to a small value (approximately 10 milliseconds). If live streams are later played (for example, from a playlist), this buffer time persists. That is, bufferTime remains nonzero for the stream.

See also

The number of bytes of data that have been loaded into the application. You can use this property with the bytesTotal property to estimate how close the buffer is to being full — for example, to display feedback to a user who is waiting for data to be loaded into the buffer.

See also

The total size in bytes of the file being loaded into the application.

See also

Specifies whether the application should try to download a cross-domain policy file from the loaded video file's server before beginning to load the video file. This property applies when you are using a NetStream object for progressive video download (standalone files), or when you are loading files that are outside the calling file's own domain. This property is ignored when you are using a NetStream object to get an RTMP asset.

Set this property to true when you are loading an video file from outside the calling file's domain and you need to use the BitmapData.draw() method for pixel-level access to the video. If you call BitmapData.draw() without setting the checkPolicyFile property to true at loading time, you may get a SecurityError exception because the required policy file was not downloaded.

If you don't need pixel-level access to the video you are loading, avoid setting checkPolicyFile to true. Checking for a policy file consumes network bandwidth and may delay the start of your download.

When you call the NetStream.play() method with checkPolicyFile set to true, Flash Player or the AIR runtime must either successfully download a relevant cross-domain policy file or determine that no such policy file exists before it begins downloading the object specified in your call to NetStream.play(). To verify the existence of a policy file, Flash Player or the AIR runtime performs the following actions, in this order:

1. The application considers policy files that have already been downloaded.
2. The application tries to download any pending policy files specified in calls to the Security.loadPolicyFile() method.
3. The application tries to download a policy file from the default location that corresponds to the URL you passed to NetStream.play(), which is /crossdomain.xml on the same server as that URL.

In all cases, Flash Player or the AIR runtime requires that an appropriate policy file exist on the video's server, that it provide access to the object at the URL you passed to play() based on the policy file's location, and that it allow the domain of the calling code's file to access the video, through one or more <allow-access-from> tags.

If you set checkPolicyFile to true, the application waits until the policy file is verified before downloading the video. Wait to perform any pixel-level operations on the video data, such as calling BitmapData.draw(), until you receive onMetaData or NetStatus events from your NetStream object.

If you set checkPolicyFile to true but no relevant policy file is found, you won't receive an error until you perform an operation that requires a policy file, and then the application throws a SecurityError exception.

Be careful with checkPolicyFile if you are downloading a file from a URL that uses server-side HTTP redirects. The applicatoins tries to retrieve policy files that correspond to the initial URL that you specify in NetStream.play(). If the final file comes from a different URL because of HTTP redirects, the initially downloaded policy files might not be applicable to the file's final URL, which is the URL that matters in security decisions.

For more information on policy files, see the "Flash Player Security" chapter of Programming ActionScript 3.0.

See also

Specifies the object on which callback methods are invoked. The default object is this, the NetStream object being created. If you set the client property to another object, callback methods will be invoked on that other object.

The number of frames per second being displayed. If you are exporting video files to be played back on a number of systems, you can check this value during testing to help you determine how much compression to apply when exporting the file.

The number of seconds of data in the subscribing stream's buffer in live (unbuffered) mode. This property specifies the current network transmission delay (lag time).

This property is intended primarily for use with a server such as Flash Media Server; for more information, see the class description.

You can get the value of this property to roughly gauge the transmission quality of the stream and communicate it to the user.

The object encoding (AMF version) for this NetStream object. The NetStream object inherits its objectEncoding value from the associated NetConnection object. It's important to understand this property if your ActionScript 3.0 SWF file needs to communicate with servers released prior to Flash Player 9. For more information, see the objectEncoding property description in the NetConnection class.

The value of this property depends on whether the stream is local or remote. Local streams, where null was passed to the NetConnection.connect() method, return the value of NetConnection.defaultObjectEncoding. Remote streams, where you are connecting to a server, return the object encoding of the connection to the server.

If you try to read this property when not connected, or if you try to change this property, the application throws an exception.

See also

Controls sound in this NetStream object. For more information, see the SoundTransform class.

See also

The position of the playhead, in seconds.

Flash Media Server For a subscribing stream, the number of seconds the stream has been playing. For a publishing stream, the number of seconds the stream has been publishing. This number is accurate to the thousandths decimal place; multiply by 1000 to get the number of milliseconds the stream has been playing.

For a subscribing stream, if the server stops sending data but the stream remains open, the value of time stops incrementing. When the server begins sending data again, the value continues incrementing from where it left off plus the time that elapsed while no data was sent.

The value of time continues to increment when the stream switches from one playlist element to another. This property is set to 0 when NetStream.play() is called with reset set to 1 or true, or when NetStream.close() is called.

See also

Creates a stream that can be used for playing video files through the specified NetConnection object.

For information about supported codecs and file formats, see http://www.adobe.com/go/hardware_scaling_en and the Flash Media Server documentation.

See also

Specifies an audio stream sent over the NetStream object, from a Microphone object passed as the source. This method is available only to the publisher of the specified stream.

The attachAudio method is intended for use with Flash Media Server. This method is often called by a user sending live audio (or live video with audio) from a client computer to the server.

You can call this method before or after you call the publish() method and actually begin transmitting. Subscribers who want to hear the audio must call the NetStream.play() method. You can control the sound properties of this audio stream through the soundTransform property of the specified Microphone object.

Parameters

See also

Starts capturing video from a camera, or stops capturing if theCamera is set to null. This method is available only to the publisher of the specified stream.

This method is intended for use with Flash Media Server; for more information, see the class description.

After attaching the video source, you must call NetStream.publish() to begin transmitting. Subscribers who want to display the video must call the NetStream.play() and Video.attachCamera() methods to display the video on the Stage.

You can use snapshotMilliseconds to send a single snapshot (by providing a value of 0) or a series of snapshots — in effect, time-lapse footage — by providing a positive number that adds a trailer of the specified number of milliseconds to the video feed. The trailer extends the display time of time the video message is displayed. By repeatedly calling attachCamera() with a positive value for snapshotMilliseconds, the sequence of alternating snapshots and trailers create time-lapse footage. For example, you could capture one frame per day and append it to a video file. When a subscriber plays the file, each frame remains onscreen for the specified number of milliseconds and then the next frame is displayed.

The purpose of the snapshotMilliseconds parameter is different from the fps parameter you can set with Camera.setMode(). When you specify snapshotMilliseconds, you control how much time elapses between recorded frames. When you specify fps using Camera.setMode(), you are controlling how much time elapses during recording and playback.

For example, suppose you want to take a snapshot every 5 minutes for a total of 100 snapshots. You can do this in two ways:

• You can issue a NetStream.attachCamera(myCamera, 500) command 100 times, once every 5 minutes. This takes 500 minutes to record, but the resulting file will play back in 50 seconds (100 frames with 500 milliseconds between frames).
• You can issue a Camera.setMode() command with an fps value of 1/300 (one per 300 seconds, or one every 5 minutes), and then issue a NetStream.attachCamera(source) command, letting the camera capture continuously for 500 minutes. The resulting file will play back in 500 minutes — the same length of time that it took to record — with each frame being displayed for 5 minutes.

Both techniques capture the same 500 frames, and both approaches are useful; the approach to use depends primarily on your playback requirements. For example, in the second case, you could be recording audio the entire time. Also, both files would be approximately the same size.

Parameters

Stops playing all data on the stream, sets the time property to 0, and makes the stream available for another use. This method also deletes the local copy of a video file that was downloaded through HTTP. Although the application deletes the local copy of the file that it creates, a copy might persist in the cache directory. If you must completely prevent caching or local storage of the video file, use Flash Media Server.

When using Flash Media Server, this method is invoked implicitly when you call NetStream.play() from a publishing stream or NetStream.publish() from a subcribing stream. Please note that:

• If close() is called from a publishing stream, the stream stops publishing and the publisher can now use the stream for another purpose. Subscribers no longer receive anything that was being published on the stream, because the stream has stopped publishing.
• If close() is called from a subscribing stream, the stream stops playing for the subscriber, and the subscriber can use the stream for another purpose. Other subscribers are not affected.
• You can stop a subscribing stream from playing, without closing the stream or changing the stream type by using flash.net.NetStream.play(false).

See also

Pauses playback of a video stream. Calling this method does nothing if the video is already paused. To resume play after pausing a video, call resume(). To toggle between pause and play (first pausing the video, then resuming), call togglePause().

Starting with Flash Player 9 Update 3, Flash Player no longer clears the buffer when NetStream.pause() is called. Before Flash Player 9 Update 3, Flash Player waited for the buffer to fill up before resuming playback, which often caused a delay.

For a single pause, the NetStream.bufferLength property has a limit of either 60 seconds or twice the value of NetStream.bufferTime, whichever value is higher. For example, if bufferTime is 20 seconds, Flash Player buffers until NetStream.bufferLength is the higher value of either 20*2 (40), or 60, so in this case it buffers until bufferLength is 60. If bufferTime is 40 seconds, Flash Player buffers until bufferLength is the higher value of 40*2 (80), or 60, so in this case it buffers until bufferLength is 80 seconds.

The bufferLength property also has an absolute limit. If any call to pause() causes bufferLength to increase more than 600 seconds or the value of bufferTime * 2, whichever is higher, Flash Player flushes the buffer and resets bufferLength to 0. For example, if bufferTime is 120 seconds, Flash Player flushes the buffer if bufferLength reaches 600 seconds; if bufferTime is 360 seconds, Flash Player flushes the buffer if bufferLength reaches 720 seconds.

Tip: You can use NetStream.pause() in code to buffer data while viewers are watching a commercial, for example, and then unpause when the main video starts.

For more information about the new pause behavior, see http://www.adobe.com/go/learn_fms_smartpause_en.

See also

Begins playback of video files.

For information about supported codecs and file formats, see http://www.adobe.com/go/hardware_scaling_en and the Flash Media Server documentation.

To view video data, you must create a Video object and call the Video.attachNetStream() method; audio being streamed with the video, or a file that contains only audio, is played automatically. To stream audio from a microphone, use the NetStream.attachAudio() method and control some aspects of the audio through the Microphone object.

To control the audio associated with a video file, you can use the DisplayObjectContainer.addChild() method to route the audio to an object on the display list; you can then create a Sound object to control some aspects of the audio. For more information, see the DisplayObjectContainer.addChild() method.

If the video file can't be found, the netStatus event is dispatched. To stop a stream that is currently playing, use the close() method.

When you use this method without Flash Media Server, there are security considerations. A file in the local-trusted or local-with-networking sandbox can load and play a video file from the remote sandbox, but cannot access the remote file's data without explicit permission in the form of a cross-domain policy file. Also, you can prevent a SWF file running in Flash Player from using this method by setting the allowNetworking parameter of the the object and embed tags in the HTML page that contains the SWF content.

For more information, see the following:

• The security chapter in the Programming ActionScript 3.0 book and the latest comments on LiveDocs
• The Flash Player 9 Security white paper
• The Netstream.checkPolicyFile property.

Parameters

See also

  ns.play("record1", 0, 100, true);
  

  ns.play("stephen");
  

Sends streaming audio, video, and text messages from a client to Flash Media Server, optionally recording the stream during transmission. This method is available only to the publisher of the specified stream.

Don't use this method to let a client play a stream that has already been published and recorded. Instead, create a NetStream instance for that client and call the play() method:

  var subscribeNS:NetStream = new NetStream(myNetConnection);
  subscribeNS.play("streamToPlay");
  

When you record a stream using Flash Media Server, the server creates a file and stores it in a subdirectory in the application's directory on the server. Each stream is stored in a directory whose name matches the application instance name passed to NetConnection.connect(). The server creates these directories automatically; you don't have to create one for each application instance. For example, the following code shows how you would connect to a specific instance of an application stored in a directory named lectureSeries in your application's directory. A file named lecture.flv is stored in a subdirectory named /yourAppsFolder/lectureSeries/streams/Monday:

  var myNC:NetConnection = new NetConnection();
  myNC.connect("rtmp://server.domain.com/lectureSeries/Monday");
  var myNS:NetStream = new NetStream(myNC);
  myNS.publish("lecture", "record");
  

The following example shows how to connect to a different instance of the same application but issue an identical publish command. A file named lecture.flv is stored in a subdirectory named /yourAppsFolder/lectureSeries/streams/Tuesday.

  var myNC:NetConnection = new NetConnection();
  myNC.connect("rtmp://server.domain.com/lectureSeries/Tuesday");
  var myNS:NetStream = new NetStream(myNC);
  myNS.publish("lecture", "record");
  

If you don't pass a value for the instance name, that matches the value passed to the name property is stored in a subdirectory named /yourAppsFolder/appName/streams/_definst_ (for "default instance"). For more information on using instance names, see the NetConnection.connect() method. For information on playing back video files, see the NetStream.play() method.

When a Flash Media Server application client calls publish(), the application receives an onPublish event. The application must handle the event in a server-side script. When the client stops publishing, the application receives an onUnpublish event. For more information, see the Flash Media Server Server-Side ActionScript Language Reference .

This method can dispatch a netStatus event with several different information objects. For example, if someone is already publishing on a stream with the specified name, the netStatus event is dispatched with a code property of NetStream.Publish.BadName. For more information, see the netStatus event.

Parameters

See also

Specifies whether incoming audio plays on the stream. This method is available only to clients subscribed to the specified stream, not to the stream's publisher.

This method is intended primarily for use with Flash Media Server; for more information, see the class description.

You can call this method before or after you call the NetStream.play() method and actually begin receiving the stream. For example, you can attach these methods to a button the user clicks to mute and unmute the incoming audio stream.

If the specified stream contains only audio data, passing a value of false to this method stops NetStream.time from further incrementing.

Parameters

Specifies whether incoming video will play on the stream. This method is available only to clients subscribed to the specified stream, not to the stream's publisher.

This method is intended primarily for use with Flash Media Server; for more information, see the class description.

You can call this method before or after you call the NetStream.play() method and actually begin receiving the stream. For example, you can attach these methods to a button the user presses to show or hide the incoming video stream.

If the specified stream contains only video data, passing a value of false to this method stops NetStream.time from further incrementing.

Parameters

Specifies the frame rate for incoming video. This method is available only to clients subscribed to the specified stream, not to the stream's publisher.

This method is intended primarily for use with Flash Media Server; for more information, see the class description.

You can call this method before or after you call the NetStream.play() method and actually begin receiving the stream. For example, you can attach these methods to a text field where the user can set the incoming video frame rate.

To stop receiving video, pass 0 for FPS. To determine the current frame rate, use NetStream.currentFPS.

If you pass a value to the FPS parameter to limit the frame rate of the video, Flash Media Server attempts to reduce the frame rate while preserving the integrity of the video. The server sends the minimum number of frames needed to satisfy the desired rate between every two keyframes. Keep in mind, however, that i-frames (or intermediate frames) must be sent contiguously; otherwise, the video will be corrupted. Therefore, the desired number of frames is sent immediately and contiguously following a keyframe. Since the frames are not evenly distributed, the motion appears smooth in segments punctuated by stalls.

Parameters

Deletes all locally cached digital rights management (DRM) voucher data for the current content.

The application must download the voucher again for the user to be able to access the the encrypted content.

Resumes playback of a video stream that is paused. If the video is already playing, calling this method does nothing.

See also

Seeks the keyframe (also called an I-frame in the video industry) closest to the specified location. The keyframe is placed at an offset, in seconds, from the beginning of the stream.

Video streams are usually encoded with two types of frames, keyframes (or I-frames) and P-frames. A keyframe contains an entire image, while a P-frame is an interim frame that provides additional video information between keyframes. A video stream typically has a keyframe every 10 to 50 frames.

On Flash Media Server, the behavior of seek() is controlled by the value of the EnhancedSeek element in the Application.xml configuration file.

If EnhancedSeek is false, the server uses normal seek mode. In normal seek mode, the server starts streaming from the nearest keyframe. For example, if a video has keyframes at 0 and 10 seconds, a seek to 4 seconds causes playback to start at 4 seconds using the keyframe at 0 seconds. The video stays frozen until it reaches the next keyframe at 10 seconds. To get a better seeking experience, you need to reduce the keyframe interval. In normal seek mode, you cannot start the video at a point between the keyframes.

If EnhancedSeek is true, the default value, the server generates a new keyframe at offset based on the previous keyframe and any intervening P-frames. However, this creates a high processing load on the server, and distortion might occur in the generated keyframe. If the video codec is On2, the keyframe before the seek point and any P-frames between the keyframe and the seek point are sent to the client.

Parameters

See also

Sends a message on a published stream to all subscribing clients. This method is available only to the publisher of the specified stream, and is intended for use with Flash Media Server. To process and respond to this message, create a handler on the NetStream object, for example, ns.HandlerName.

Flash Player or AIR does not serialize methods or their data, object prototype variables, or non-enumerable variables. For display objects, Flash Player or AIR serializes the path but none of the data.

You can call the send() method to add data keyframes to a live stream sent to Flash Media Server. A data keyframe is a message a publisher adds to a live stream. Data keyframes are typically used to add metadata to a live stream before data is captured for the stream from camera and microphone. A publisher can add a data keyframe at any time while the live stream is being published. The data keyframe is saved in the server's memory as long as the publisher is connected to the server.

Clients who are subscribed to the live stream before a data keyframe is added receive the keyframe as soon as it is added. Clients who subscribe to the live stream after the data keyframe is added receive the keyframe when they subscribe.

To add a keyframe of metadata to a live stream sent to Flash Media Server, use @setDataFrame as the handler name, followed by two additional arguments, for example:

  var ns:NetStream = new NetStream(nc);
  ns.send("@setDataFrame", "onMetaData", metaData);
  

The @setDataFrame argument refers to a special handler built in to Flash Media Server. The onMetaData argument is the name of a callback function in your client application that listens for the onMetaData event and retrieves the metadata. The third item, metaData, is an instance of Object or Array with properties that define the metadata values. Publishers should set property names that subscribers can easily understand; see the Flash Media Server documentation for a list of suggested property names.

Use @clearDataFrame to clear a keyframe of metadata that has already been set in the stream:

  ns.send("@clearDataFrame", "onMetaData");
  

Parameters

See also

package {
   import flash.display.Sprite;
   import flash.net.NetConnection;
   import flash.net.NetStream;
   import flash.events.NetStatusEvent;
   import flash.media.Video;
   import flash.utils.setTimeout;

 
   public class TestExample extends Sprite
   {
     var nc:NetConnection = new NetConnection();
     var ns1:NetStream;
     var ns2:NetStream;
     var vid:Video = new Video(300,300);
     var obj:Object = new Object();
 
     public function TestExample() {
        nc.objectEncoding = 0;
        nc.addEventListener("netStatus", onNCStatus);
        nc.connect("rtmp://localhost/FlashVideoApp");
        addChild(vid); 
     }
  
     function onNCStatus(event:NetStatusEvent):void {
       switch (event.info.code) {
           case "NetConnection.Connect.Success":
               trace("You've connected successfully");
               ns1 = new NetStream(nc);
               ns2 = new NetStream(nc);
               
               ns1.client = new CustomClient();
               ns1.publish("dummy", "live");
    
               ns2.play("dummy");
               ns2.client = new CustomClient();
               vid.attachNetStream(ns2);
               setTimeout(sendHello, 3000);
               break;
              
           case "NetStream.Publish.BadName":
               trace("Please check the name of the publishing stream" );
               break;
        }   
     }

     function sendHello():void {
         ns1.send("myFunction", "hello");
     }       
   }
 }
 
 class CustomClient {
    public function myFunction(event:String):void {
       trace(event);
    }
 }

private function netStatusHandler(event:NetStatusEvent):void {
     switch (event.info.code) {  
        case "NetStream.Publish.Start":
            var metaData:Object = new Object();
            metaData.title = "myStream";
            metaData.width = 400;
            metaData.height = 200;
            ns.send("@setDataFrame", "onMetaData", metaData);
            ns.attachCamera( Camera.getCamera() );
            ns.attachAudio( Microphone.getMicrophone() );        
    }
}

 public function onMetaData(info:Object):void {
    trace("width: " + info.width);
    trace("height: " + info.height);
 }

 // Create a NetStream for playing
 var my_ns:NetStream = new NetStream(my_nc);
 my_video.attachNetStream(my_ns);
 
 // Play the stream record1
 my_ns.play("record1", 0, -1, true);
 
 // Switch to the stream live1 and play for 5 seconds.  
 // Since reset is false, live1 will start to play after record1 is done.
 my_ns.play("live1", -1 , 5, false);

 //To play at normal speed
 var my_ns:NetStream = new NetStream(my_nc);
 my_ns.play("log", 0, -1);
 
 //To get the data messages all at once
 my_ns.play("log", 0, -1, 3);

Sets the DRM authentication credentials needed for viewing the underlying encrypted content.

The setDRMAuthenticationCredentials() method must provide credentials that match those known and accepted by the content provider or the proxy server. These are the same credentials used by the user when obtaining the permission to view the content.

Parameters

See also

Pauses or resumes playback of a stream. The first time you call this method, it pauses play; the next time, it resumes play. You could use this method to let users pause or resume playback by pressing a single button.

See also

Dispatched when an exception is thrown asynchronously — that is, from native asynchronous code. This event is dispatched when a server calls a method on the client that is not defined.

This event has the following properties:

See also

Dispatched when a NetStream object tries to play a digital rights management (DRM) encrypted content that requires a user credential for authentication before playing.

Use the setDRMAuthenticationCredentials() method of the NetStream object to authenticate the user. If user authentication failed, the application will retry authentication and dispatch a new DRMAuthenticateEvent event for the NetStream object.

This event has the following properties:

See also

Dispatched when a NetStream object, trying to play a digital rights management (DRM) encrypted file, encounters a DRM-related error. For example, a DRMErrorEvent object is dispatched when the user authorization fails. This may be because the user has not purchased the rights to view the content or because the content provider does not support the viewing application.

This event has the following properties:

See also

Dispatched when the digital rights management (DRM) encrypted content begins playing (when the user is authenticated and authorized to play the content).

DRMStatusEvent object contains information related to the voucher, such as whether the content can be made available offline or when the voucher will expire and the content can no longer be viewed.

This event has the following properties:

See also

Dispatched when an input or output error occurs that causes a network operation to fail.

This event has the following properties:

Dispatched when a NetStream object is reporting its status or error condition. The netStatus event contains an info property, which is an information object that contains specific information about the event, such as if a connection attempt succeeded or failed.

This event has the following properties:

See also

Invoked when an embedded cue point is reached while playing a video file. You can use this handler to trigger actions in your code when the video reaches a specific cue point, which lets you synchronize other actions in your application with video playback events. For information about video file formats supported by Flash Media Server, see the Flash Media Server documentation.

This event is intended for use with Flash Media Server. It is not part of the Flash Player or AIR API, but is included in this language reference for your convenience. You cannot use the addEventListener() method, or any other EventDispatcher methods, to listen for or process this event. Rather, you must define a single callback function and attach it directly to one of the following objects:

• The object referenced by the client property of a NetStream instance.
• An instance of a NetStream subclass. NetStream is a sealed class, which means that properties or methods cannot be added to a NetStream object at runtime. However, you can create a subclass of NetStream and define your event handler in the subclass or make the subclass dynamic and add the event handler function to an instance of the subclass.

The following types of cue points can be embedded in a video file:

• A navigation cue point specifies a keyframe within the video file and the cue point's time property corresponds to that exact keyframe. Navigation cue points are often used as bookmarks or entry points to let users navigate through the video file.
• An event cue point is specified by time, whether or not that time corresponds to a specific keyframe. An event cue point usually represents a time in the video when something happens that could be used to trigger other application events.

The onCuePoint event object has the following properties:

You can define cue points in a video file when you first encode the file, or when you import a video clip in the Flash authoring tool by using the Video Import wizard.

The onMetaData event also retrieves information about the cue points in a video file. However the onMetaData event gets information about all of the cue points before the video begins playing. The onCuePoint event receives information about a single cue point at the time specified for that cue point during playback.

Generally, to have your code respond to a specific cue point at the time it occurs, use the onCuePoint event to trigger some action in your code.

You can use the list of cue points provided to the onMetaData event to let the user start playing the video at predefined points along the video stream. Pass the value of the cue point's time property to the NetStream.seek() method to play the video from that cue point.

See also

Dispatched when the application receives descriptive information embedded in the video being played. For information about video file formats supported by Flash Media Server, see the Flash Media Server documentation.

This special event is intended for use with Flash Media Server; for more information, see the class description. It is not technically part of the Flash Player or AIR API, but is included in this language reference for your convenience. You cannot use the addEventListener() method, or any other EventDispatcher methods, to listen for or process this event. Rather, you must define a single callback function and attach it directly to one of the following objects:

• The object that the client property of a NetStream instance references.
• An instance of a NetStream subclass. NetStream is a sealed class, which means that properties or methods cannot be added to a NetStream object at runtime. However, you can create a subclass of NetStream and define your event handler in the subclass or make the subclass dynamic and add the event handler function to an instance of the subclass.

The Flash Video Exporter utility (version 1.1 or later) embeds a video's duration, creation date, data rates, and other information into the video file itself. Different video encoders embed different sets of meta data.

This event is triggered after a call to the NetStream.play() method, but before the video playhead has advanced.

In many cases, the duration value embedded in stream metadata approximates the actual duration but is not exact. In other words, it does not always match the value of the NetStream.time property when the playhead is at the end of the video stream.

See also

Dispatched when a NetStream object has completely played a stream. This handler returns information objects that provide information in addition to what's returned by the netStatus event. You can use this handler to trigger actions in your code when a NetStream object has switched from one stream to another stream in a playlist (as indicated by the information object NetStream.Play.Switch) or when a NetStream object has played to the end (as indicated by the information object NetStream.Play.Complete). To respond to this event, you must create a function to process the information object sent by the server.

This event is intended for use with Flash Media Server; for more information, see the class description. It is not part of the Flash Player or AIR API, but is included in this language reference for your convenience. You cannot use the addEventListener() method, or any other EventDispatcher methods, to listen for or process this event. Rather, you must define a single callback function and attach it directly to one of the following objects:

• The object that the client property of a NetStream instance references.
• An instance of a NetStream subclass. NetStream is a sealed class, which means that properties or methods cannot be added to a NetStream object at runtime. However, you can create a subclass of NetStream and define your event handler in the subclass or make the subclass dynamic and add the event handler function to an instance of the subclass.

This event can return an information object with the following properties:

See also

Dispatched when the application attempts to play content encrypted with digital rights management (DRM), by invoking the NetStream.play() method. The value of the status code property will be "DRM.encryptedFLV".

This event has the following properties:

See also

In this example, the code that creates the Video and NetStream objects and calls the Video.attachNetStream() and NetStream.play() methods is placed in a handler function. The handler is called only if the attempt to connect to the NetConnection object is successful; that is, when the netStatus event returns an info object with a code property that indicates success. It is recommended that you wait for a successful connection before you call NetStream.play().

package {
    import flash.display.Sprite;
    import flash.events.NetStatusEvent;
    import flash.events.SecurityErrorEvent;
    import flash.media.Video;
    import flash.net.NetConnection;
    import flash.net.NetStream;
    import flash.events.Event;

    public class NetConnectionExample extends Sprite {
        private var videoURL:String = "Video.flv";
        private var connection:NetConnection;
        private var stream:NetStream;

        public function NetConnectionExample() {
            connection = new NetConnection();
            connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
            connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
            connection.connect(null);
        }

        private function netStatusHandler(event:NetStatusEvent):void {
            switch (event.info.code) {
                case "NetConnection.Connect.Success":
                    connectStream();
                    break;
                case "NetStream.Play.StreamNotFound":
                    trace("Stream not found: " + videoURL);
                    break;
            }
        }

        private function securityErrorHandler(event:SecurityErrorEvent):void {
            trace("securityErrorHandler: " + event);
        }

        private function connectStream():void {
            stream = new NetStream(connection);
            stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
            stream.client = new CustomClient();
            var video:Video = new Video();
            video.attachNetStream(stream);
            stream.play(videoURL);
            addChild(video);
        }
    }
}

class CustomClient {
    public function onMetaData(info:Object):void {
        trace("metadata: duration=" + info.duration + " width=" + info.width + " height=" + info.height + " framerate=" + info.framerate);
    }
    public function onCuePoint(info:Object):void {
        trace("cuepoint: time=" + info.time + " name=" + info.name + " type=" + info.type);
    }
}