My fellow evangelist Michael Chaize put together a video on a related topic - UDP. See this presentation on how to start with UDP (Universal Datagram Protocol) in Adobe AIR 2.0.

Discover the UDP API in Adobe AIR 2.0

Check also his second tutorial - UDP Video in AIR 2.0.

Enjoy!

The recording of seminar I did on Friday 27th 2010.

It includes information mostly about Object Replication and how to start with it. I also explain my P2P VoD project.

Check it out here (42 min.)
http://my.adobe.acrobat.com/p41024225/

Some of you guys were probably wondering how to establish P2P connections in the local network (LAN) without Stratus. Yes. It’s possible. Using native IP-only multicast. Let’s build a simple chat with Posting. Adding Multicast broadcast is just a simple next step which I am sure you can accomplish by yourself with few hints from my article about Multicast

Open an IP Multicast connection. This can be done by specifying connection string as “rtmpf:”. Note, that this technique cannot be used for one-to-one communication. So no DIRECT_CONNECTIONS with NetStream, but you can do all RTMFP Group operations.

netConnection.connect("rtmfp:");

Once you get connected (on NetConnection.Connect.Success) you can set up a NetGroup or NetStream via GroupSpecifier. Then just set ipMulticastMemberUpdatesEnabled to true, which is responsible for establishing local connections between peers call addIPMulticastAddress with a multicast address and port. Multicast address should begin with 224 at least and port should be higher than 1024 - that means: “224.0.0.0:1024″, but the general rule is the higher the better = unique.

For my example below I’ve chosen rather higher numbers.

groupspec.ipMulticastMemberUpdatesEnabled = true;
groupspec.addIPMulticastAddress("225.225.0.1:30303");

Together it will look like this:

private function connect():void{
	nc = new NetConnection();
	nc.addEventListener(NetStatusEvent.NET_STATUS, netStatus);
	nc.connect("rtmfp:");
}
 
private function netStatus(event:NetStatusEvent):void{
	switch(event.info.code){
		case "NetConnection.Connect.Success":
			setupGroup();
			break;
	}
}
 
private function setupGroup():void{
	var groupspec:GroupSpecifier = new GroupSpecifier("myGroup/groupOne");
	groupspec.postingEnabled = true;
	groupspec.ipMulticastMemberUpdatesEnabled = true;
	groupspec.addIPMulticastAddress("225.225.0.1:30303");
 
	group = new NetGroup(nc,groupspec.groupspecWithAuthorizations());
	group.addEventListener(NetStatusEvent.NET_STATUS,netStatus);
}

Try app

P2PChatLocal - open in two or more windows.

Download

You can download complete source code of a chat application here:
P2PChatLocal.mxml

Make sure you don’t miss following webinars this week prepared by Adobe Platform Evangelists. All of them will be live online using Screen Sharing technology via Adobe Connect Pro.

Especially if you are regular reader of my blog and interested in P2P, don’t miss Advanced P2P Programming on Friday - it will be summary of all my recent articles.

This week:

• Summer Cocktail: Doctrine 2, Zend Framework, Flex, and Flash Builder (Mihai Corlan)- Tuesday, August 24
• Advanced P2P programming in Flash (Tom Krcha) – Friday, August 27

Next week:

• Presentation Model pattern with Flex and Swiz Framework (Piotr Walczyszyn) – Tuesday, August 31, 2010

Register for free.

I can’t even say how much I was looking forward to this blog post. It’s here! This feature of Flash Player and special screensharing add-in, which you might know from Adobe Connect Pro or Adobe ConnectNow is now available for every single Flash Platform developer through LiveCycle Collaboration Service. This is THE KILLER FEATURE everyone, who is developing collaborative apps, was waiting for.

And I am happy to say: The waiting is over! You can now grab it and implement it right inside of your applications!

Try demo
Publisher | Subscriber

See how it works at Vimeo.

Source code is available in samples folder, which comes with LCCS SDK Navigator.

How screensharing works?

The best way to try this is definitely one of the Acrobat.com services - ConnectNow, which is completely built with LiveCycle Collaboration Service components.

What do I need for this?

If you start sharing your screen, the Flash Player asks you to install ConnectNow Add-In. The installation process is very seemless, you just wait couple seconds until the progress bar directly in Flash Player installs this essential component and then you are ready to go.

I want to start developing my own Screen Sharing apps…

For this - you need to get an LCCS account. LCCS is a cloud hosted service by Adobe - just go to LCCS Developer Portal, create account, download SDK and start building your apps.

Once you install LCCS SDK Navigator (an AIR app), you can see some tutorials, which are part of it, deploy SDK or do other related stuff. I have also done a couple LCCS video tutorials in the past, you can see them here.

In LCCS API, you will find the new four classes:

- ScreenShareCanvas
- ScreenSharePublisher
- ScreenShareSubscriber
- ScreenShareSubscriberComplex
Read about Screen Sharing at LCCS learning resource

There are more things in the latest update - like recording. Please refer to article at official Adobe Collaborative Methods Blog:
Screen Sharing and Recording: August Feature TSUNAMI

Development tip: it might happen that you don’t connect correctly and it will not work. Use http instead of https in your connection string and it will be fixed.

In the previous tutorial File Sharing over P2P in Flash Player 10.1 with Object Replication we went through the Object Replication basics. And you can see that the Receiver is requesting packets one by one. That’s not suitable for the real world app, but it’s good for testing on a LAN to see the progress. In the real world app, you can immediately request all packets using NetGroup.addWantObjects(beginIndex, endIndex);.

Transferring VoD video over P2P

Let’s get something real with Object Replication. The use-case I like most is a Realtime P2P Distributed System for Video-on-Demand.


This is the vision. It could be nicely integrated by video/news portals, especially on the currently most demanded videos (latest hits, hot news, etc.). When users are currently acquiring one video or a few hot videos from a server, why not try to lighten the load on the server and improve the viewers experience.

I am not afraid to say that this can save you millions or at least most of your video portal costs.

*Note: This is only a study how it could work. It still needs further work and testing.

See how it works

This technique shows how you can distribute VoD video with Flash Player 10.1 Object Replication

Getting the video
To download a video file, you can use URLStream class. Register ProgressEvent to control every byte segment you get, while putting these segments together you can already start creating deliverable chunks (~64KB) for object replication. If you are on a slow network, you will probably get more segments to chunk, than on a fast network. This is illustrated below. It doesn’t matter, just keep in mind, that you need to wait until you can separate these segments into chunks.

Sharing the video
While downloading, you can already start sharing the video in the P2P network using Object Replication. Once others receive packets, they start sharing them as well, while receiving the rest. This makes the network more stable and less dependent on a relatively low number of original providers.

Viewing the video
Flash Player 10.1 added a new NetStream function called appendBytes, which enables you to pass a ByteArray containing FLV bytes to a NetStream and then display it. This was originally added for HTTP streaming, but we can leverage it nicely as well. You can read more about it here.

Solution #1 (Basic)

Sender | Receiver | Tester (both in frames) | FLV video for testing

In this demo, you browse for a FLV video on a local storage device; once you choose it, it starts providing packets for other peers.

Basically, you cut video into chunks and start providing it using NetGroup.addHaveObjects(0, 84); - this video has 84 chunks. On the receiver side, you ask for a zero chunk, which is a file descriptor, using NetGroup.addWantObjects(0,0); In this descriptor you receive the total chunks count and you can add more info like file name, size, etc. Once you receive the zero chunk, you ask for the rest of the objects using NetGroup.addWantObjects(1,84); and Flash Player will start receiving the rest of the packets after a few seconds.

Try opening the receiver in other 5 or more windows and you will find an error. There is no guarantee that packets are received one by one, they can be received in completely different order and for this, you will need a special buffer. More in Advanced solution below.

Solution #2 (Advanced)

The Challenges

There were couple challenges, which need to be addressed to make it work properly.

Chunks
You need to split received bytes from URLStream to deliverable chunks. You have to wait until you receive at least one chunk (64KB) and than add it to an array. If you receive less, you wait, until you have 64 KB or more and then you add it. (So - First buffer). If you receive more than 64 KB in one progress event, you need to cut it in a cycle. So for instance if you receive 100 KB, you create one chunk (64 KB) and the rest (36 KB) you leave in the buffer to be filled (to at least 64 KB).  If you receive 200 KB (you create 3 chunks and keep 8 KB for the next batch). If you receive last bits of the data, which is in Event.COMPLETE, than you create just final chunk (which is always going to be less than 64 KB or same). All these things are done in URLByteLoader.as. Check especially createChunks() function.

Download buffer for viewing
While downloading, I put chunks into a buffer, which is appended directly to the NetStream and then played in a Video object. This enables me to display video during the download process.

Postponed buffer for P2P (put chunks together)
The biggest problem with receiving Object Replication packets is that there is no guarantee that you will receive packets in correct linear order one by one. Typically you receive packets a completely mixed order - e.g. 1,2,3,4,20,21,22,5,6,7 and so on. So you need a Timer that puts these packets together and waits for the next one in the line and then continues with appending bytes to the NetStream. This basically enables you to display video during the Object Replication process and you don’t have to wait until you receive all the packets before you start playing video.

Deciding who is provider
In the real world, you will need to decide who is the provider and who is the receiver. Providers should be clients on the best uplink/downlink network. You can make a network check before playing video and then say that this client is going to be a provider. You can save this information in cookies with a corresponding expire time.

The Source

Download here (src.zip, 10 KB)

Where to go from here

Check out these other tutorials on P2P in Flash:

- File Sharing over P2P in Flash Player 10.1 with Object Replication
- P2P GroupSpecifier Class Explained In Details Part 1
- Multicast Explained in Flash 10.1 P2P
- Directed Routing Explained in Flash 10.1 P2P
- Simple chat with P2P NetGroup in FP 10.1

Video tutorials:
- P2P Chat with NetGroup in Flash Player 10.1
- Multicast Streaming in Flash Player 10.1 Tutorial

I am very happy that the community is getting more and more involved in P2P. I told you, it has endless possibilities!

AS3-P2P-LIB
AS3-P2P-LIB is a pure ActionScript 3.0 Library by Dominic Graefen that helps Flash developers get started with P2P easily.

All Classes | Example | Project page at GitHub

P2P Video Calls on Android

My fellow evangelist Mark Doherty built a great demo app using P2P and AIR 2.5 for Android. Watch this video, where he shows how it works. And btw: I should really teach him how to pronounce my name Mark, you are going to get a lesson at MAX 2010!

Check Mark’s blog post for further information.

Read also: Video-on-Demand over P2P in Flash Player 10.1 with Object Replication

Object Replication

Object Replication is the most lowest-level P2P access available in Flash Player 10.1 (followed by Multicast, Posting and Directed Routing). It basically enables you to send chunks of data between peers. Object Replication is the only P2P access method that guarantees that all data will be transferred to all receiving peers.

Demo

I’ve built this simple file sharing application, which basically loads a file and then you start sharing it. Open another client to start receiving the file.



How to use it:
Open a provider in one window - browse for a file (JPG, PNG, GIF). Once it’s loaded, it will start sharing the file. Open a receiver in many other windows and start receiving. Provider and receiver are included in one app in this example.

How does it work

A classic scenario for Object Replication in Flash is file sharing. You have two clients, one is sending the data (Provider) and the other one receives the data (Receiver). You were able to do this already in Flash Player 10 using NetStream - but this worked only for two clients and there where no replication of objects to the members of a group => Massive File Sharing! In our scenario, you can have thousands of receivers.

Provider
Provides data for others. This is the originator. First you need to have an object with data you want to share. You most probably will load a file using URLStream or FileReference. Then you need to split this file into separate ByteArray chunks and give them indexes (it can be an indexed array). Keep the chunks reasonably small to avoid transfer issues (around 64KB). So if you load a 2 MB file, you will have 32 chunks. Finally call NetGroup.addHaveObject(0, 32); which says you have in this case 32 chunks available for others.

Receiver
Receives data from a provider. Here you just call NetGroup.addWantObjects(index, index); and start receiving objects from the provider. I do this by keeping the increasing the index by 1 once received a chunk. So you basically call NetGroup.addWantObjects(index, index); 32 times. When you call addWantObjects, the Providers gets a status “NetGroup.Replication.Request”. At this point the provider needs to write data to a group using NetGroup.writeRequestedObject(event.info.requestID,chunks[event.info.index]). Once it writes the data, the Receiver gets a “NetGroup.Replication.Fetch.Result” status event and save the data locally to an object. Remember, that the Receiver is just receiving data, it is not providing the data to other peers. After it has received all chunks, the Receiver just goes through the chunks and put them together into a final ByteArray.

Receiver/Provider
So why not to provide the received data to other peers to make the trasfer faster and maybe more stable. Once you receive some data using NetGroup.addWantObjects(index, index); and save them in “NetGroup.Replication.Fetch.Result”, you can start providing the data to other peers using NetGroup.addHaveObject(index, index);.

Of course there is lot more to be done, but first let’s have a look at this schema for the above.

Simple Object Replication

To demonstrate how Object Replication works, let’s try this second demo. In this example you have an object, which we fill with and array of 100 elements. Then start sharing this array. Run the second client to start receiving the array.

Provider peer:
1. Once connected, click fillObject
2. Then click addHaveObjects
3. That’s all

Receiver peer:
1. Once connected, click addWantObjects
2. It should start receiving objects shortly
(there is a loop, first chunk you receive is count of objects, once you receive a chunk the index increases by 1 and asks for next chunk until they are all received)

There are couple more buttons - you can try playing with it a little bit if you want.

How was it built?

Once connected to a server setup a NetGroup instance like this:

private function setupGroup():void{
	var spec:GroupSpecifier = new GroupSpecifier("myGroup");
	spec.serverChannelEnabled = true;
	spec.objectReplicationEnabled = true;
 
	netGroup = new NetGroup(netConnection,spec.groupspecWithAuthorizations());
	netGroup.addEventListener(NetStatusEvent.NET_STATUS,netStatus);
}

Once connected to a NetGroup, which means that user allowed P2P connections, UDP is enabled and so on - you do operations on a NetGroup. First set object replication strategy. We will be receiving packets one by one (moreless).

netGroup.replicationStrategy = NetGroupReplicationStrategy.LOWEST_FIRST;

In your netStatusHandler - catch two codes:

// This code is called on a Provider
case "NetGroup.Replication.Request": 
	// calling this causes "NetGroup.Replication.Fetch.Result" invocation on a Receiver
	netGroup.writeRequestedObject(event.info.requestID,obj[event.info.index])
 
	break;
 
// This code is called on a Receiver
case "NetGroup.Replication.Fetch.Result":
        // received chunks can be already provided to others
	netGroup.addHaveObjects(event.info.index,event.info.index);
 
        // write a chunk into an object/array
	obj[event.info.index] = event.info.object;
 
	if(event.info.index == 0){
		// First chunk (0) holds the number of chunks
		objSize = Number(event.info.object);
	}else{
		// Receive chunks until you are full
		if(event.info.index+1<objSize){
			netGroup.addWantObjects(event.info.index+1,event.info.index+1);
			actualFetchIndex = event.info.index+1;
		}
	}
	break;

The whole source code can be found here.

Creating ByteArray P2P File Sharing

By following the concept above it’s possible to load a file from disk or url and then start sharing it with others.

This explains how the first demo works.

For this I’ve split the application into four different classes:

LocalFileLoader.as
Loads a file using FileReference and splits it into chunks (~64 KB each).

P2PFileShare.as
Connects to Stratus and handles all Object Replication sending and receiving

P2PSharedObject.as
A simple value object, which holds the data (ByteArray), size, packetLenght, actualFetchIndex and chunks; it’s used by both classes above.

P2PFileSharing.mxml
The user interface, which puts it all together.

The complete source code can be found here.

The Provider should look like this after sending the data:

The Receiver should look like this after receiving the data:

In the next tutorial, I will look at how to use Object Replication with VOD video.

Where to go from here

Check other tutorials on P2P in Flash:

- Video-on-Demand over P2P in Flash Player 10.1 with Object Replication
- P2P GroupSpecifier Class Explained In Details Part 1
- Multicast Explained in Flash 10.1 P2P
- Directed Routing Explained in Flash 10.1 P2P
- Simple chat with P2P NetGroup in FP 10.1

Video tutorials:
- P2P Chat with NetGroup in Flash Player 10.1
- Multicast Streaming in Flash Player 10.1 Tutorial

Chris Scott (author of Swiz Framework) visited Prague and while here, he did a very nice presentation about Swiz at the Adobe User Group Meeting. We were lucky to have him here and before his UG session, we did a little interview.

Here it is (Watch on Vimeo):

Don’t miss the next Prague Adobe User Group Meeting on Tuesday 13th July 18:00-20:00.

I really recommend this meeting as it’s a great chance to meeting an independent ActionScript expert from USA, ask advanced questions and so on.

Chris Scott is an Enterprise Software Consultant in the Philadelphia area with over ten years of Java, ColdFusion, ActionScript and Flex experience as well as a strong interest in the implementation of open source solutions. Chris is the lead developer of the Swiz Framework and the ColdSpring Framework, including the first Aspect Oriented Programming framework for ColdFusion.

Address: Adobe Praha, Radlická 714/113a

More info in Czech at Viktor’s blog.

Meeting info at Adobe Groups