Adobe Flash Media Gateway

Flash Media Gateway preview 2 is now available to download. The new update includes support for 64-bit Windows and Linux systems.It is a new real-time server platform that enables Adobe® Flash® and Adobe AIR® applications to connect with traditional communication devices via SIP.

FMG Telephony SDK plugs in seamlessly with existing Adobe Flash Media Server server-side applications to allow quick integration of telephony related workflows, therefore, giving full control to customize the level of features and policies that application may require. Out of the box samples make it easier to setup and start with making first call to audio and video capable Session Initiation Protocol (SIP) phones without writing any ActionScript code. There are many exciting features in Flash Media Gateway that can be used to build rich communication solutions:

• Two way audio calls — FMG enables two way audio calls between Flash clients and PSTN/Mobile phones. All you needs is a SIP account with a SIP service provider or on an in-premise SIP capable PBX.
• Call to video conferencing devices — FMG also enables a Flash Media Server application to ingest high quality H.264 video by placing calls to SIP enabled video conferencing devices or video bridge. After call setup, the video stream becomes available for recording or live webcast to Flash Player clients via Flash Media Server.
• Flexible Telephony APIs — FMG telephony APIs for Flash Media Server server side allows complete decoupling of call management from participating client. This allows dynamic management of calls using server-side scripting logic. For example, it facilitates applications provide features like failover and call transfer among flash clients.
• Customizable call flows — FMG allows writing customized call flows in XML to decide what action must be taken when a number is dialed. An application may choose to record audio, collect DTMF or play a welcome file before connecting the call to the next participant. Custom action may be decided based upon call parameters.
• HTTP management and control interface — Server administrators can get information or update critical server configuration. HTTP interface can also be used to issue control commands.
• Real-Time Transcoding — FMG supports Nellymoser (NM), Speex and G711 audio codecs and enables SIP and RTMP endpoints to be configured independently without caring about codec type mismatch. In the background, FMG detects and performs the real-time audio transcoding.
• Audio mixing — This allows one call to support multiple input audio streams from Flash Media Server. FMG does the real time mixing to generate a mixed audio. This allows applications to switch among multiple audio sources dynamically. It also makes it easier to integrate web audio conferences on Flash Media Server with telephony bridges.
• Supports SIP registrations — This makes it easier to setup a test environment by registering your SIP devices on FMG without requiring a SIP server.

 
Flash Media Gateway can be used to enable existing Flash Player installations into as many voice end-points connected to your network. With Flash, you can deploy rich communication services without requiring a client download. It also enables Flash developers enhance user experience by creating a new category of rich-connected/engaging applications. Adobe Connect web conferencing software uses Flash Media Gateway to enable Universal voice and Video Telephony capabilities.

Flex 4.6 SDK and Flash Builder 4.6

This year, Adobe released a great environment with Flex SDK and Flash Builder to support mobile application development with mobile optimized components and framework. Flash Builder 4.5 provides mobile project type, multiplatform device simulations and on device debugging and easy packaging for deployment on range of application stores.

I really like the environment, single framework and tool to build and deploy rich, expressive mobile and tablet apps on Android, BlackBerry Tablet, iPag and iPhone device.

You can get ideas about Flash Builder 4.5 from here : What's new in Flash Builder 4.5

Introduction of Flex 4.6

According to Adobe, Flex 4.6 will be released later this year, with new version of the SDK and a corresponding update to Flash Builder with new components and functionality specifically designed to help to create application for latest mobile and tablet device.

New Components

• SplitViewNavigator : A new top-level application component specifically designed for the tablet experience. With only few lines of code, manage the layout of multiple views and have them adapt automatically based on device orientation.

• CallOutButton : A versatile component that pops over existing content and can contain text, components or even entire views.

• SpinnerList : This popular tablet component is an adaption of the existing List component. It not only has a new look, but also gives options like recirculating content and a position based selection model.

• DateSpinner : A highly flexible component that is not only locale-aware, but provides multiple out-of-the-box configurations to fit most date/time entry needs.

• Text Enhancements : Flex 4.6 solves the problem of cross-device text input. Flex exposes the native text-editing controls on EVERY platform—this enables the developer to customize the keyboard and the user to experience the native UI of common operations like selection, copy/paste and spelling checking.

• ToggleSwitch : This simple and much-requested control is now available in Flex 4.6.

Also in addition to supporting the new features in the Flex framework, Flash Builder 4.6 exposes new capabilities that will enable developers to build better cross-platform mobile applications—Native Extensions and Captive Runtime.

Native Extensions allows developers to complement their Flex application with native C, Objective-C, and Java libraries—this new feature opens a world of new possibilities for both mobile and desktop applications. Providing access to Apple iOS, Google Android, and BlackBerry Tablet OS specific APIs, your applications can access native features like notifications or the calendar. Flash Builder provides complete support for both managing and packaging Native Extensions. To read more about the possibilities or learn how to build your own native extension, see Oliver Goldman's article,Extending Adobe AIR.

Here you will get more information about Flash Builder 4.6 & Flex 4.6.
 

So Friends, Enjoy RIA :)

Object Oriented Concepts: Polymorphism

I thought to spend some time on object-oriented concepts. Mostly, developers look into this kind of OOPs concepts based articles in two kinds of situations either for application development or interviews preparation !!! :) Anyway, let's focus on Polymorphism.

As it's well known that Polymorphism is an object-oriented concept. Polymorphism in AS3 can be approached from two direction or way. One approach is to use Inheritance. The other approach is through Interface.

Abstract Class base Inheritance

Inheritance means to extend a Class. For example,

public class SampleClass extends BaseClass

SampleClass inherits all the public / protected properties and methods of BaseClass. And the BaseClass can be referred as super class of SampleClass. In this kind of situation ActionScript provides the ability to override methods of super class. Only those properties and methods which utilize the public or protected namespaces can be overridden and super class 's private properties and methods are not accessible to the class which extending the super class.

Let me take an sample and well known example to explain it:

public class Animal
{
        protected var animalName : String;
        public function Animal( animalname:String )
        {
           this.animalName =  animalname;
        }
     
        public function getName():String
        {
            return animalName;
        }

        public function talk() : void
        {
        }

        public function eat(): void
        {

        } 
} 

  Abstract class Animal, provides basic functionality the animals in app will use. For example, each animal has name. Now we extend the Animal class and create an animal.  

public class Dog extends Animal
{
        public function Dog()
        {
            super("dog");
        }

       override public function talk() : void
       {
           // code
       }

       override public function eat() : void
       {
           // code
      }
}

  The Dog Class extends abstract class Animal. So the Dog class is known as concrete Animal class, which override the public methods of base class.  

public class PolymorphismDemo extends Sprite
{
         public var animalsArray : Array = [ ];
         public function  PolymorphismDemo()
        {
             var dog : Animal = new Dog();
             animalsArray = [ dog ];
             for each( var animal:Animal in animalsArray)
             {
                  trace(animal.getName());
                  animal.eat();
                  animal.talk();
             }
      }
}

You can observe that inheritance being used across the Flash platform. For example, any object on stage is extending DisplayObject, all events are extending base class known as Event. Polymorphism through Intereface Now, we are discussing the second approach for polymorphism through Interface. Interface is used to create class that implement a specific contract.

public interface IAnimal
{

         function getName() : String;
         function eat() : void;
         function talk() : void;
}

  You can see Ianimal declares methods as its declared in abstract animal class in example of first approach. But if you observer something is missing from above methods is public namespace and brackets containing function body. Interfaces allow only public function declarations. You can't declare properties, static or private methods in interface. Because interface represents a contract that lets outside objects know that public methods can be accessed on a class that implements the interface. Since outside objects can't access private methods. Public properties can't added to an interface for good encapsulation. And in case if its required to access properties of Interface then will have an great option getter and setter for properties in interface.  

public class Dog  implements  IAnimal
{
        public function Dog()
        {
        }

        public function getName() : String
        {
            return "dog";
        }

        public function talk() : void
       {
            // code
       }

       public function eat() : void
      {
           // code
      }
}

Above Dog class implements IAnimal interface. And with interface there is no need to use the override syntax. By using the second approach ( with interface ) classes much more reusable.

Enjoy RIA .. :)