More Books
Flash Communication Server
Flash Communication Server
Table of Contents
Copyright
About the Authors
Brian Lesser
Giacomo
Joey Lott
Robert Reinhardt
Justin Watkins
Foreword
Preface
What Does FlashCom Offer?
What's in This Book?
How to Use This Book
Audience
ActionScript 1.0 Versus ActionScript 2.0
Server-Side ActionScript
The flash-communications.net Site
Director, Breeze, and Other Options
Flash Video Options
Licensing and Hosting Options
Conventions Used in This Book
Voice
Using Code Examples
Safari Enabled
Comments and Questions
Acknowledgments
Part I:  FlashCom Foundation
Chapter 1.  Introducing the Flash Communication Server
Section 1.1.  Clients and Servers
Section 1.2.  Creating an Application
Section 1.3.  Real-Time Messaging Protocol
Section 1.4.  The Communication Classes
Section 1.5.  Communicating with Application Servers, Databases, and Directory Servers
Section 1.6.  Firewalls and Security
Section 1.7.  Getting Started
Section 1.8.  Hello Video!
Section 1.9.  Conclusion
Chapter 2.  Communication Components
Section 2.1.  Overview of Communication Components
Section 2.2.  Summary of Communication Components
Section 2.3.  Creating an Application that Monitorsa Connection
Section 2.4.  Building a Simple Chat Room
Section 2.5.  Adding Audio and Video to the Chat Room
Section 2.6.  Forgoing the SimpleConnect Component
Section 2.7.  Conclusion
Chapter 3.  Managing Connections
Section 3.1.  Making a Connection
Section 3.2.  Managing a Connection
Section 3.3.  Reusing a NetConnection Object
Section 3.4.  Multiple Simultaneous NetConnection Objects
Section 3.5.  Testing and Debugging Network Connections
Section 3.6.  Subclassing the NetConnection Class
Section 3.7.  Communication Components Without SimpleConnect
Section 3.8.  Conclusion
Chapter 4.  Applications, Instances, and Server-Side ActionScript
Section 4.1.  Scripting Application Instances
Section 4.2.  Differences Between Flash ActionScript and Server-Side ActionScript
Section 4.3.  The Life of an Application Instance
Section 4.4.  Running a Simple Hello World Test Script
Section 4.5.  A More Realistic Example
Section 4.6.  Instance-to-Instance Communications
Section 4.7.  Script Filenames and Locations in Detail
Section 4.8.  Testing and Debugging Server-SideScript Files
Section 4.9.  Designing Communication Applications
Section 4.10.  Conclusion
Part II:  Audio, Video, and Data Streams
Chapter 5.  Managing Streams
Section 5.1.  A Simple Publisher/Subscriber Example
Section 5.2.  Stream Names
Section 5.3.  Publishing Streams in Detail
Section 5.4.  Playing Streams in Detail
Section 5.5.  The Stream Class
Section 5.6.  Publishing and Playing ActionScript Data
Section 5.7.  Creating Synchronized Presentations
Section 5.8.  The NetStream and Stream Information Objects
Section 5.9.  Stream Enhancements and Limitations
Section 5.10.  Conclusion
Chapter 6.  Microphone and Camera
Section 6.1.  Working with Microphone/Audio Input
Section 6.2.  Working with Camera Input
Section 6.3.  Building a Message-Taking Application
Section 6.4.  Building a Surveillance Application
Section 6.5.  Conclusion
Chapter 7.  Media Preparation and Delivery
Section 7.1.  Audio and Video Compression
Section 7.2.  Converting Prerecorded Materialto FLV Format
Section 7.3.  Using Flash Pro's Media Components
Section 7.4.  Enabling Multiple Bit Rate FLVsWithin an Application
Section 7.5.  Streaming MP3 Audio
Section 7.6.  Conclusion
Part III:  Remote Connectivity and Communication
Chapter 8.  Shared Objects
Section 8.1.  Objects and Shared Objects
Section 8.2.  Getting a Shared Object in Flash
Section 8.3.  Updates and Frame Rates
Section 8.4.  Scripting Shared Objects on the Server
Section 8.5.  Temporary and Persistent Shared Objects
Section 8.6.  Proxied Shared Objects
Section 8.7.  Shared Objects and Custom Classes
Section 8.8.  Avoiding Collisions
Section 8.9.  Optimizing Shared Object Performance
Section 8.10.  Broadcasting Remote Method Callswith send( )
Section 8.11.  A Simple Video and Text Chat Application
Section 8.12.  Conclusion
Chapter 9.  Remote Methods
Section 9.1.  Why Use Calls?
Section 9.2.  The send( ) and call( ) Methods
Section 9.3.  Client-to-Server Calls
Section 9.4.  Server-to-Client Calls
Section 9.5.  Server-to-Server Calls
Section 9.6.  A Simple Lobby/Rooms Application
Section 9.7.  Debugging Calls
Section 9.8.  Advanced Topics
Section 9.9.  Conclusion
Chapter 10.  Server Management API
Section 10.1.  Connecting to the Admin Service
Section 10.2.  Using the Server Management API
Section 10.3.  Server Management API Uses
Section 10.4.  Conclusion
Chapter 11.  Flash Remoting
Section 11.1.  The Remoting Gateway
Section 11.2.  Remoting Basics
Section 11.3.  Role of Remoting in FlashCom Applications
Section 11.4.  Securing Access
Section 11.5.  Conclusion
Chapter 12.  ColdFusion MX and FlashCom
Section 12.1.  Understanding ColdFusion MXand Flash Remoting
Section 12.2.  Using Flash Remoting to Log Events
Section 12.3.  Getting a List of Streams
Section 12.4.  Using ColdFusion and FTP to Mirror Streams
Section 12.5.  Conclusion
Part IV:  Design and Deployment
Chapter 13.  Building Communication Components
Section 13.1.  Source Files
Section 13.2.  People Lists
Section 13.3.  A Simple People List
Section 13.4.  Listenable Shared Objects
Section 13.5.  Status and People List
Section 13.6.  Text Chat
Section 13.7.  Shared Text
Section 13.8.  Video Conference and Video Window
Section 13.9.  PeopleGrid
Section 13.10.  Summary
Section 13.11.  Conclusion
Chapter 14.  Understanding the Macromedia Component Framework
Section 14.1.  The Component Framework
Section 14.2.  Under the Hood of the Chat Component
Section 14.3.  Creating a Simple Component from Scratch: SharedTextInput
Section 14.4.  Creating a Container Component: SharedAddressForm
Section 14.5.  Creating an Authenticating Component
Section 14.6.  Integrating Components with Your Existing Applications
Section 14.7.  Understanding the Framework
Section 14.8.  Conclusion
Chapter 15.  Application Design Patterns and Best Practices
Section 15.1.  Shared Object Management
Section 15.2.  Moving Code to the Server
Section 15.3.  Building Façades on the Server
Section 15.4.  Server-Side Client Queues
Section 15.5.  A Framework for Recording and Playing Back Componentized Applications
Section 15.6.  Components and Component Frameworks
Section 15.7.  Conclusion
Chapter 16.  Building Scalable Applications
Section 16.1.  Coordinating Instances
Section 16.2.  Scalability and Load Balancing
Section 16.3.  Conclusion
Chapter 17.  Network Performance, Latency,and Concurrency
Section 17.1.  Latency
Section 17.2.  Bandwidth
Section 17.3.  Concurrency
Section 17.4.  Conclusion
Chapter 18.  Securing Applications
Section 18.1.  The Three A's: Authentication, Authorization, and Accounting
Section 18.2.  Authentication
Section 18.3.  Authorization
Section 18.4.  Accounting
Section 18.5.  Suggestions and References
Section 18.6.  Conclusion
Index
SYMBOL
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
R
S
T
U
V
W

Foreword

Although Flash Communication Server MX has many groundbreaking features, it has roots in much of the work that preceded it.

Five things allowed Flash Communication Server to be realized:

  • The body of knowledge of real-time, collaborative communication software

  • The ubiquity of the Flash Player on the client

  • The growing availability of broadband

  • Adoption of digital devices like web cams and digital cameras

  • Macromedia's investment in server-side technologies

Looking back at the path that led us here, it is hard to believe that my interest in creating multiuser software already spans 10 years.

In 1994, I was working for Novell, developing a toolkit that allowed application programmers to write once and compile and deploy anywhere (similar to Java, Director, and Flash). In October of 1994, Novell decided to get out of this business. I had an opportunity to work for a different group or take a fat severance check and find another job. I decided to take the layoff and the check!

Dan Greening, who was the director of engineering for my group at Novell, asked me if I would be interested in starting a company. At that time, there was a lot of buzz about the Internet and I felt the timing was perfect to take some risks. Dan and I, along with two other Novell alumni, Ron Lussier and Glenn Crocker, started Chaco Communications, Inc., in November 1994. We spent the next couple of months exploring multiuser role-playing games.

During the next year, we developed a Chaco client that used VRML to represent the virtual world. The VRML client didn't succeed, but I learned many lessons from its failures. We had developed a client that could be customized using HTML and VRML, but there was no authoring tool. The product was a standalone client, not integrated with the browser, so it required a separate installation. Server-side extension was difficult, limiting its customizability. Creating content was not easy, and that was a big problem. VRML as a technology was ahead of the hardware, which wasn't yet capable of an immersive 3D experience, and broadband was not yet widely available.

In 1996, NTT of Japan noticed Chaco's MUD (multiuser domain/dungeon/dimension) client and approached us to build a Java-based client and server for children, based on the Hello Kitty theme. We delivered this product in 1997, and it was very popular in Japan. The requirement for this project was to create an extensible client that ran inside a browser with a seamless install. We picked Java, which was the most ubiquitous client at the time. This proved very successful and showed me the importance of a ubiquitous client and an easy-to-customize application with the right authoring and development tools.

In 1997, Chaco merged with Songline Studios (owned by O'Reilly) to form LikeMinds. We changed direction, and I started work on a personalization server, intended to customize the web experience for repeat visitors to a given site. For the next 3 years, I was deep in the world of real-time data mining. This product was used by companies like NetFlix, Columbia House, and a bunch of dot-com retailers, many of which are no longer in business. Working on the LikeMinds personalization server, I learned a lot about building highly scalable servers in terms of moving large amounts of data in and out, managing large numbers of connections, interfacing with other systems, and so on.

While working on the LikeMinds social server, which was a chat server that we developed for NTT, we needed a data synchronization scheme, and I came up with something called distributed buckets. This was little more than name/value pairs plus a mechanism to replicate the name/value on all clients when any client added to a distributed bucket. I later used a similar design in the Flash Communication Server, and we called it shared objects.

LikeMinds was acquired by Andromedia, which was in turn acquired by Macromedia in 1999. Toward the end of 2000, Macromedia sold LikeMinds' technology to IBM, and it is now part of the IBM WebSphere personalization engine. I was still working for Macromedia when they decided to get out of personalization technology. I started exploring other opportunities, but I wanted to stick with server-side development. At that time, Macromedia did not have a lot of server-side technology; one product I considered was Generator. Before I had made a decision, I got a call from Jonathan Gay (the Father of Flash) who asked me if I would be interested in exploring a new project.

Jon had this idea of building real-time communication capabilities into the client-side Flash Player and wanted to know if I could help him build a server product to provide the server-side functionality. This brought back memories of my Chaco days. I felt that the time was right to again venture into the world of multiuser collaboration. Given my earlier experience of building multiuser communication products and knowing the reasons for its failures, I felt that with the combination of Flash Player, broadband, and the adoption of communication technologies like IM, there was a huge opportunity to move the technology to the next level by introducing audio and video. Combined with the multimedia capabilities of Flash, we had a realistic chance of succeeding, and I felt I could make a significant contribution in making this a reality.

For the next 4 months, we did an extensive study of the market, technologies, and trends to see what we should build. Our vision was to build a real-time communication infrastructure to take Flash and Macromedia into a new, profitable business in the telecommunications world. Flash's adoption as the standard for web animation was made possible by providing a lightweight Player and a rich, easy-to-use authoring system that provides a set of high-level APIs approachable by a large audience. We wanted to continue this vision by providing a platform for real-time communications that was easy to develop for and deploy. To better understand what this platform had to provide, we put together ideas for 10 real-time applicationsclassroom, company meeting, front door cam, customer service, car race, remote presence, and so onand collected all the requirements to come up with the base features. All applications required some combination of audio, video, or data as streams (some real-time and some on-demand) and data synchronization. They all required an application model to create and control groups, which resulted in the server-side application model defined by Flash Communication Server.

This resulted in the following features the platform needed to provide:

  • An easy-to-install, ubiquitous client supporting multimedia devices such as microphones and cameras

  • A low-overhead protocol with support for real-time delivery of media, data, and control messages

  • Real-time or stored (on-demand) data

  • Software applications that add intelligence and support communication

  • An easy way to blend content and communication

  • Support for remote presence

The first two items on the list describe the Flash Player and the RTMP protocol. But to succeed, we also needed to provide a simple, reliable, and flexible model for communications and application development, with a high-level API for developers. Furthermore, we needed to set application development standards and help the developer community understand how to build communication applications.

Despite the misperception that Flash Communication Server (FlashCom) was based on Shockwave Multiuser Server (SMUS), a multiuser server once provided with Macromedia Director, FlashCom was built from the ground up. FlashCom provides features never available in SMUS, such as shared objects and the publish-subscribe model for audio, video, and data streams. That is not to say FlashCom didn't borrow from my past projects in real-time collaborative software. As I said, the distributed buckets in LikeMinds' social server became FlashCom shared objects. And I had developed a high-performance socket I/O architecture for the LikeMinds server that became the core I/O architecture for FlashCom. Of course, FlashCom provided new challenges, for which I developed the RTMP protocol (with help from Jon Gay and Brad Edelman), its server-side object model, on-demand streaming, the FlashCom application model, and the configuration model.

After nearly 2 years of development, Macromedia released Flash Communication Server MX 1.0 in September 2002. FlashCom version 1.5 followed in March 2003, and the latest update, version 1.5.2, was released in May 2004. We succeeded in defining a new application development platform for real-time communication applications. Looking back at the vision and value we pursued, I am very proud to say that we delivered on our promise. We may have had some unrealistic optimism about its instant success, but over the last year, we have seen Flash Communication Server establish a toehold in the market, and now we are seeing our dreams realized.

One of the challenges with any new technology is finding early adopters who can invest in an unproven technology. This problem was compounded by the fact that the Internet bubble burst, and developing a collaboration application requires a new skill set and significant resources. Given this slow adoption, we decided it was time for us to eat our own dog food and show what could be done with FlashCom, so we built Breeze Live atop the FlashCom platform. Breeze Live is probably one of the most complex FlashCom applications ever developed and has greatly benefited me in evolving the core FlashCom platform. And Breeze Live is one of Macromedia's fastest-growing products, proving that there is a market for compelling, media-rich, real-time communication applications.

Another key to the success of any platform is teaching developers how to build applications beyond "hello world." I am confident that Programming Flash Communication Server will go a long way in making this adoption possible. It is a must-read book for anyone serious about writing communication applications using Flash Communication Server.

Pritham Shetty

Principal Architect

Flash Communication Server

Macromedia