First, we’ll need to install getlibs, an incredibly useful package for those of us running 64bit Linux systems with the need to run 32bit software. In a previous tutorial, we used getlibs to install some required libraries for running a 32bit Flash Player debug edition on a 64bit Linux operating system. Now, we’ll use a similar technique to get 32bit AIR installed and running. Let’s download and install getlibs. If you have getlibs installed, you can safely skip this step and move on.

1
2
3

wget -O getlibs-all.deb http://frozenfox.freehostia.com/cappy/getlibs-all.deb
sudo dpkg -i getlibs-all.deb
rm getlibs-all.deb

The above code will download getlibs-all.deb, install it, and remove it, leaving you just what you need and nothing more. Now, let’s move on to the next step, downloading the Adobe AIR installer and installing some 32bit libraries.

1
2
3
4
5
6

wget -O AdobeAIRInstaller.bin http://airdownload.adobe.com/air/lin/download/latest/AdobeAIRInstaller.bin
chmod +x AdobeAIRInstaller.bin
sudo getlibs ./AdobeAIRInstaller.bin
sudo getlibs -l libgnome-keyring.so
sudo getlibs -l libgnome-keyring.so.0
sudo getlibs -l libgnome-keyring.so.0.1.1

According to Adobe’s website, this installs several other components that are necessary to AIR for internet connectivity, sound, etc. While you can technically install Adobe AIR without these libraries, you’ll find that many applications malfunction and many won’t even start. So yes, I recommend following the directions on this one

Now, we need to download and install some other libraries not available through getlibs. Let’s hit it up:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# Download some debs
wget -O libnss3.deb "http://mirrors.kernel.org/ubuntu/pool/main/n/nss/libnss3-1d_3.12.0~beta3-0ubuntu1_i386.deb"
wget -O libnspr.deb "http://mirrors.kernel.org/ubuntu/pool/main/n/nspr/libnspr4-0d_4.7.1~beta2-0ubuntu1_i386.deb"
 
# Extract 'em, get what we need, then remove them.
mkdir -p libnss3
sudo dpkg -x libnss3.deb libnss3
sudo cp libnss3/usr/lib/libnss3.so.1d /usr/lib32
sudo cp libnss3/usr/lib/libnssutil3.so.1d /usr/lib32
sudo cp libnss3/usr/lib/libsmime3.so.1d /usr/lib32
sudo cp libnss3/usr/lib/libssl3.so.1d /usr/lib32
rm -fr libnss3
rm libnss3.deb
 
mkdir -p libnspr
sudo dpkg -x libnspr.deb libnspr
sudo cp libnspr/usr/lib/libnspr4.so.0d /usr/lib32
sudo cp libnspr/usr/lib/libplc4.so.0d /usr/lib32
sudo cp libnspr/usr/lib/libplds4.so.0d /usr/lib32
rm -fr libnspr
rm libnspr.deb
 
# Link 'em up!
sudo ln -s /usr/lib32/libnss3.so.1d /usr/lib32/libnss3.so
sudo ln -s /usr/lib32/libssl3.so.1d /usr/lib32/libssl3.so
sudo ln -s /usr/lib32/libnspr4.so.0d /usr/lib32/libnspr4.so

Phew! That was a lot of work, so I hope you’re still with me. Now, we’ve got everything all ready for our fresh install of Adobe AIR. Let’s install it!

1

sudo ./AdobeAIRInstaller.bin

Cool! Now, we’ve got one last step to perform before we’re done, copying a simple file over to the /usr/lib32 folder:

1

sudo cp /usr/lib/libadobecertstore.so /usr/lib32

Done! You should now have an installed and fully functional AIR runtime installed on your system. Now, let’s try to encapsulate all of this into a shell script so anyone can install AIR in one step rather than a bunch of ‘em. Download airInstall.sh.gz, extract it, then run it like so:

1
2
3

wget http://blog.tkassembled.com/u/2010/02/airInstall.sh.gz
gzip -d airInstall.sh.gz
sudo ./airInstall.sh

And, for your reference, here’s what the shell script looks like and does, for those of you who are into that kind of thing:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#!/bin/bash
 
# Check if this is root.
if [[ $EUID -ne 0 ]]; then
	echo "This script must be run as root." 1>&2
	exit 1
fi
 
# Download and install getlibs-all.deb
wget -O getlibs-all.deb http://frozenfox.freehostia.com/cappy/getlibs-all.deb;
dpkg -i getlibs-all.deb;
rm getlibs-all.deb;
 
# Download AIR
wget -O AdobeAIRInstaller.bin http://airdownload.adobe.com/air/lin/download/latest/AdobeAIRInstaller.bin;
chmod +x AdobeAIRInstaller.bin;
 
# Install some libraries using getlibs
getlibs ./AdobeAIRInstaller.bin;
getlibs -l libgnome-keyring.so;
getlibs -l libgnome-keyring.so.0;
getlibs -l libgnome-keyring.so.0.1.1;
 
# Download some unavailable libraries manually
wget -O libnss3.deb "http://mirrors.kernel.org/ubuntu/pool/main/n/nss/libnss3-1d_3.12.0~beta3-0ubuntu1_i386.deb";
wget -O libnspr.deb "http://mirrors.kernel.org/ubuntu/pool/main/n/nspr/libnspr4-0d_4.7.1~beta2-0ubuntu1_i386.deb";
 
# Extract the deb files we just downloaded, and install the libraries we need from them
mkdir -p libnss3;
dpkg -x libnss3.deb libnss3;
cp libnss3/usr/lib/libnss3.so.1d /usr/lib32;
cp libnss3/usr/lib/libnssutil3.so.1d /usr/lib32;
cp libnss3/usr/lib/libsmime3.so.1d /usr/lib32;
cp libnss3/usr/lib/libssl3.so.1d /usr/lib32;
rm -fr libnss3;
rm libnss3.deb;
 
mkdir -p libnspr;
dpkg -x libnspr.deb libnspr;
cp libnspr/usr/lib/libnspr4.so.0d /usr/lib32;
cp libnspr/usr/lib/libplc4.so.0d /usr/lib32;
cp libnspr/usr/lib/libplds4.so.0d /usr/lib32;
rm -fr libnspr;
rm libnspr.deb;
 
# Link the libraries up
ln -s /usr/lib32/libnss3.so.1d /usr/lib32/libnss3.so;
ln -s /usr/lib32/libssl3.so.1d /usr/lib32/libssl3.so;
ln -s /usr/lib32/libnspr4.so.0d /usr/lib32/libnspr4.so;
 
# Install AIR!
./AdobeAIRInstaller.bin;
rm AdobeAIRInstaller.bin;
 
# And, finally, link some libraries
cp /usr/lib/libadobecertstore.so /usr/lib32;
 
echo "Adobe AIR should now be installed! Woo!";

Did everything work out okay? Questions? Go ahead and light up the comments and I’ll see how I can help. In the future, we’ll cover installing the new beta version of AIR 2.0 on a 64bit Linux machine.

Before we begin, let’s clarify our goals here. For now, we simply wish to burn an ISO image file directly to recordable media, such as a CD or a DVD, from the terminal in Linux. There are many GUI programs out there for burning DVDs and CDs, but that’s not quite our goal here. We want to harness the power of the terminal for automation of tasks and for learning’s sake.

First, let’s install a nifty little program called wodim. It includes many tools for implementation-agnostic writing to recordable media, including our target formats of DVD and CD. If you’re using Ubuntu 9.10, you should already have it installed, but it can’t hurt to run this to make sure:

1

sudo apt-get install wodim

Now, let’s take our ISO file and burn it to a CD-R in our CD-R drive. Enter this into your terminal and let’s get started with the burn:

1

sudo wodim -eject /home/rfkrocktk/my-disc.iso

Of course, replace “/home/rfkrocktk/my-disc.iso” with a real path to an ISO image file on your computer. If you’d like to do a “dry run,” so to speak, to test if everything will write correctly, run the following command instead:

1

sudo wodim -eject gracetime=30 /home/rfkrocktk/my-disc.iso

What this does is that it gives you 30 seconds of “grace time” to make sure you really want to burn that disc. The “-eject” parameter tells wodim to eject your disc after it’s done, very helpful if you ask me. Another handy feature about wodim is that it attempts to recognize the drive to use when burning media (eg: /dev/dvdrw or /dev/cdrw), and attempts to recognize the type of media you have inserted, so it uses the right device and format.

What this means is that the code given above should work for burning an ISO image to a CD or to a DVD. This makes it, for all intensive purposes, implementation-agnostic, meaning it doesn’t necessarily care whether you’re using a CD or a DVD. It’ll do its best to determine the type of media you’re using and burn it in an appropriate fashion.

By default, wodim burns discs in TAO (“Track at Once”) format. This is important only if you’re planning on burning audio discs. For audio discs, you’ll want to burn your discs in SAO/DAO (“Session At Once/Disc At Once”) mode, because TAO mode will insert 2 second gaps between your songs, and for me that’s unacceptable. We’ll cover burning audio discs in another post, so stay tuned for another tutorial on how to do that.

What if we want to do something a little more, well, advanced? You’ve probably heard of multi-session discs that allow you to take something which is “write-once” like a DVD-R or a CD-R and write to it multiple times. wodim supports this out-of-the-box using the “-multi” parameter as so:

1

sudo wodim -multi -eject /home/rfkrocktk/my-disc.iso

This will enable you to write multiple times to the same disc, provided that you pass the “-multi” parameter each time you attempt to change content on the disc. Pretty cool, huh?

You can’t get much easier or complex than wodim. You can run “sudo wodim my-disc.iso” to simply burn an ISO image to a DVD or CD, or you can really tweak your burn to do exactly what you want it to. Any questions or comments? Hope this helps someone out there!

Let’s introduce a real-world example, since any library can only be useful if it can be used to solve problems in the real world. We’ll pose a hypothetical that you’re trying to build a socket-based library for using a particular protocol, perhaps even one you invented yourself. The service class you’re creating wraps flash.net.Socket and dispatches custom events when particular things happen. We’ll say that you have two custom events you need to dispatch, “writeResult” and “writeFailed,” in addition to other events pertaining natively to the Socket instance for other objects to listen for error events and the like.

Here’s the code you would need to write in order to accomplish this using Flash Player’s native event system.

CustomSocket.as

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package com.mycompany.socket {
 
	import flash.events.EventDispatcher;
	import flash.events.Event;
	import flash.events.IOErrorEvent;
	import flash.net.Socket;	
 
	[Event(name="connect",type="flash.events.Event")]
 
	[Event(name="close",type="flash.events.Event")]
 
	[Event(name="ioError",type="flash.events.IOErrorEvent")]
 
	[Event(name="writeResult",type="com.mycompany.CustomSocketEvent")]
 
	[Event(name="writeFault",type="com.mycompany.CustomSocketEvent")]
	public class CustomSocket extends EventDispatcher {
 
		private var socket:Socket;
 
		public function CustomSocket() {
			this.socket = new Socket();
			this.socket.addEventListener(Event.CONNECT, dispatchEvent);
			this.socket.addEventListener(Event.CLOSE, dispatchEvent);
			this.socket.addEventListener(IOErrorEvent.IO_ERROR, dispatchEvent);
		}
 
		public function connect(host:String, port:int):void {
			this.socket.connect(host, port);
		}
 
		public function write():void {
			var writeValue:Boolean = Math.random() < 0.5;
			this.socket.writeBoolean(writeValue);
			if (writeValue) {
				this.dispatchEvent(new CustomSocketEvent(CustomSocketEvent.WRITE_RESULT));
			} else {
				this.dispatchEvent(new CustomSocketEvent(CustomSocketEvent.WRITE_FAULT));
			}
		}
	}
}

CustomSocketEvent.as

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package com.mycompany.socket {
 
	import flash.events.Event;
 
	public class CustomSocketEvent extends Event {
 
		public static const WRITE_RESULT:String = "writeResult";
 
		public static const WRITE_FAULT:String = "writeFault";
 
		public function CustomSocketEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false) {
			super(type, bubbles, cancelable);
		}
 
		public function clone():Event {
			return new CustomSocketEvent(type, bubbles, cancelable);
		}
	}
}

Client.as

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package {
 
	import com.mycompany.socket.CustomSocket;
	import com.mycompany.socket.CustomSocketEvent;
 
        import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.IOErrorEvent;
 
	public class Client extends Sprite {
 
		public function Client() {
			var socket:CustomSocket = new CustomSocket();
			socket.addEventListener(Event.CONNECT, onConnect);
			socket.addEventListener(Event.CLOSE, onClose);
			socket.addEventListener(IOErrorEvent.IO_ERROR, onIoError);
			socket.addEventListener(CustomSocketEvent.WRITE_RESULT, onWriteResult);
			socket.addEventListener(CustomSocketEvent.WRITE_FAULT, onWriteFault);
			socket.connect("localhost", 12345);
 
			socket.write();
		}
 
		private function onConnect(e:Event):void {
			trace("connect!");
		}
 
		private function onClose(e:Event):void {
			trace("close!");
		}
 
		private function onIoError(e:IOErrorEvent):void {
			trace("ioerror!");
		}
 
		private function onWriteResult(e:CustomSocketEvent):void {
			trace("writeResult!");
		}
 
		private function onWriteFault(e:CustomSocketEvent):void {
			trace("writeFault!");
		}
	}
}

Ok, so we’re done. Let’s talk about some of the inherent problems with this code.

First, there is not necessarily any compile-time or runtime way of knowing if a component dispatches events, and knowledge of which events it dispatches is nonexistent. However, as anyone well-versed in AS3 will point out, we have metadata! The [Event] tags at the top of the CustomSocket class let us know that CustomSocket will probably dispatch a type of event, but we have no way of knowing this. And, since the metadata has little or nothing to do with the code and is not enforced by the compiler, we’re really out in the dark. There is no compile-time enforcement of events.

Second, the CustomSocketEvent class is almost entirely useless. Even if we were passing some information along with the event, we had to write all of those boilerplate lines of code for almost no reason.While it is not necessary to write CustomSocketEvent, best practices tell us that we should, and if we’re expecting to pass values attached to events, we must. In the spirit of keeping with “best practices,” which may or may not even exist according to some, we’ve defined this event class.

Third, since the event system works on a String-key basis, there is really no way to distinguish between a flash.events.Event.CONNECT and a com.mycompany.socket.CustomSocketEvent.CONNECT if the constants define the same String literal “connect.”

These are just some of the flaws plaguing Flash Player’s built-in event system. Does it work? Yes! Does it work well? You decide. This is where as3-signals comes into play.

Let’s rewrite this same example using as3-signals.

CustomSocket.as

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package com.mycompany.socket {
 
	import flash.events.Event;
	import flash.events.IOErrorEvent;
	import flash.net.Socket;
 
	import org.osflash.signals.Signal;
	import org.osflash.signals.natives.NativeSignal;
 
	public class CustomSocket {
 
		public var connect:NativeSignal;
 
		public var close:NativeSignal;
 
		public var ioError:NativeSignal;
 
		public var writeFault:Signal;
 
		public var writeResult:Signal;
 
		private var socket:Socket;
 
		public function CustomSocket() {
			this.socket = new Socket();
 
			this.connect = new NativeSignal(this.socket, Event.CONNECT, Event);
			this.close = new NativeSignal(this.socket, Event.CLOSE, Event);
			this.ioError = new NativeSignal(this.socket, IOErrorEvent.IO_ERROR, IOErrorEvent);
 
			this.writeFault = new Signal();
			this.writeResult = new Signal();
		}
 
//		because we already have a member named "connect," 
//		we'll name this guy "connectSocket" (thanks Robert :] )
		public function connectSocket(host:String, port:int):void {
			this.socket.connect(host, port);
		}
 
		public function write():void {
			var writeValue:Boolean = Math.random() < 0.5;
			this.socket.writeBoolean(writeValue);
			if (writeValue) {
				this.writeResult.dispatch();
			} else {
				this.writeFault.dispatch();
			}
		}
	}
}

Client.as

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package {
 
	import com.mycompany.socket.CustomSocket;
 
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.IOErrorEvent;
 
	public class Client extends Sprite {
 
		public function Client() {
			var socket:CustomSocket = new CustomSocket();
			socket.connect.add(onConnect);
			socket.close.add(onClose);
			socket.ioError.add(onIoError);
			socket.writeResult.add(onWriteResult);
			socket.writeFault.add(onWriteFault);
			socket.connectSocket("localhost", 12345);
 
			socket.write();
		}
 
		private function onConnect(e:Event):void {
			trace("connect!");
		}
 
		private function onClose(e:Event):void {
			trace("close!");
		}
 
		private function onIoError(e:IOErrorEvent):void {
			trace("io error!");
		}
 
		private function onWriteResult():void {
			trace("write result!");
		}
 
		private function onWriteFault():void {
			trace("write fault!");
		}
	}
}

Now, let’s talk about why this code is better than the first example.

First, as you can see, we completely eliminated the event class that we created in the first example. There’s simply no need to create new Event subclasses when using as3-signals. The framework itself is very flexible and lightweight as it can be.

Next, as you can see, we have established a contract between the client and CustomSocket, binding the notion of “events” to members of the class. There’s no key-based guessing-game here. From the layout of the class itself, you can see that CustomSocket dispatches certain types of events. There isn’t really a way to add a listener for an event that isn’t defined. All “events” (signals?) must be defined explicitly in the class itself. You may also have noticed that in the client class, our listener for “writeResult” doesn’t define any parameters. It doesn’t have to, since signals by default are empty. No more bloat than needed. Theoretically, you could even rewrite the example to make simple flash.events.Event signals not even pass the event along, since who actually uses the simple Event instance anyway?

Now, let’s discuss the code. In as3-signals, there are basically three types of signals. There is Signal, a default implementation of the notion of an event or signal, DeluxeSignal, which adds some advanced functionality to Signal, and NativeSignal, a signal which wraps native events, allowing you to “port” your events into signals.

The signal classes sport a few methods that are fairly important: “add(listener:Function):void”, “addOnce(listener:Function):void”, “remove(listener:Function):void”,  ”removeAll():void”, and “dispatch(…parameters):void”. As you can see, complete control is established over event/signal flow. You can listen for a signal once or indefinitely. You can remove one listener, or all of them at once. Finally, using “dispatch(…parameters)” you can send a signal to all registered listeners.

Let’s take a moment to talk about the “dispatch(…parameters)” method. The flash.events.IEventDispatcher.dispatchEvent method takes one parameter of type flash.events.Event. So how do we use “dispatch(…parameters)”, then? It’s actually quite simple. When creating the signal implementation, you can pass Class objects to the constructor. Let’s wire up an example real quick to demonstrate this.

1

var signal:Signal = new Signal(String, Object);

The above code tells your signal object that, when the dispatch() method is called, the first parameter should be of type String and the second parameter should be of type Object. On the other side, the listener can take typed arguments:

1
2
3
4
5
6

signal.add(myListener);
signal.dispatch("key", {a: "b"});
 
function myListener(key:String, value:Object):void {
 
}

As you can probably tell, this eliminates almost any need to create custom Event classes to contain values. All of this is accomplished really only using one class which has already been created and won’t need to be reinvented indefinitely as in the AS3 event system. Signal will check and see if types match when “dispatch(…parameters)” is run, and throw an Error if types don’t match.

So that’s a pretty thorough explanation and intro to using as3-signals. The only downside I have found with as3-signals is since it reinvents the Event system (word pun intended), it won’t “just work” with Flex, since Flex is so tied to AS3’s event system. Unfortunately, that means I won’t be able to use it as often as I would like (ie: all of the time). And that sums up as3-signals! If you have any questions or comments, please feel free to reply below in the comments.

“dd” has to be one of the easiest command line programs that there is to work with on Linux. Open up a terminal and we’ll demonstrate just how simple this is. Enter the following command to start the rip:

dd if="/dev/dvd" of="my-dvd.iso"

Is that it? Yep! “dd” will quietly and painlessly rip your disc to your hard drive in the location specified by “of”. It takes “/dev/dvd” as the input to rip from, so you’d probably want to change this to “/dev/cdrom” if you’re ripping from a CD. Let’s demonstrate how to rip from a CD next:

dd if="/dev/cdrom" of="my-cd.iso"

Easy, right? Exactly! Now you can store all of your software and discs locally on your computers hard drive. Since I actually used to use Windows, I can make backups of my Windows XP install disc easily and painlessly. And if you’re a VLC user, you can actually rip a DVD movie to an ISO using the above commands and play back the DVD as if it were in your drive (menus and all!) by opening the ISO with VLC! “dd” is truly a powerful little tool that can quickly get an often-complicated job done without any fuss.

Let’s install it. Run

sudo apt-get install abcde id3 id3v2

to install abcde and ID3 for tagging files. Alternatively, you can click here to install abcde through your browser. Please note that you probably should install “lame” before trying to rip cds to MP3 files. To install lame, make sure you have Medibuntu in your sources list and run

sudo apt-get install lame

before ripping any discs. Alternatively, if you want to install “lame” through your browser and you already have the Medibuntu repository installed, you can click here.

Now that it’s all ready and installed, let’s try ripping a CD! Let’s pop open a terminal and create a new directory to rip our CD to.

mkdir -p "Desktop/Rips"
cd ~/Desktop/Rips

As a good starting point, I recommend the following command line options to rip the CD to the current directory:

abcde -N -g -d /dev/cdrom -a read,encode,tag -o mp3  -x

This does a few clever things. Since, in my case, I had a TON of CDs to rip and really didn’t want to be bothered with anything until each encode is done, I passed the “-N” option which basically puts abcde in non-interactive mode. In addition, I passed the “-x” parameter, telling abcde to simply eject the disc after it has finished all of its operations. I also passed “-g” which tells lame to enable “gapless” encoding for songs. Few things bother me as much as unnecessary gaps between songs on an album, and this simple parameter eliminates that problem outright, providing you’re using lame as an encoder. I specified /dev/cdrom as my CD-ROM device, though this is usually unnecessary since abcde defaults to using /dev/cdrom anyway. I passed “-a read,encode,tag” to tell abcde to simply take the CD, rip the raw output from it, encode it, tag it using default values, and be done. I wanted a non-interactive rip, and I definitely got it! The last parameter I passed was “-o mp3″, informing abcde to encode the songs to MP3 files.

First, abcde uses a program called cdparanoia to rip the raw wave files from the CD to the local hard disk. Then, it passes those files to the encoder, in my case lame, and then it tags the files using some default values and puts them in a new directory under the current working directory. Fast. Painless. Noninteractive. Exactly what I needed.

This certainly isn’t the only way to configure abcde, either. abcde definitely feels like one of those swiss-army-knife-like programs I’ll use on a fairly regular basis to bring music from a CD into my music library. Combine it with a tool like EasyTAG, and you’re in business.

Let’s get to it! Go ahead and download the plugin, and we’ll walk through installation. When you first untar/unzip the package, you’ll find that there’s really only one file inside: libflashplayer.so. It seems that Adobe still hasn’t addressed the ease-of-installation problems yet! For the average Joe, a file named “libflashplayer.so” doesn’t mean anything at all. You can’t really execute it from the commandline, and double-clicking yields nothing at all. Bummer! Well, Joe, we’re going to have to do some terminal work to get this up and going, so don’t lose heart!

So what are we supposed to do with this file? First, lets move the file to an arbitrary place where we can keep track of it. Open up a terminal and “cd” to the directory in which you downloaded “libflashplayer-10.*.gz”. For me, it’s in ~/Downloads, so I’ll run

cd ~/Downloads

to get where I need to be. Now, let’s unpack the sucker. Run the following command in your terminal to unpack the plugin:

tar -zxvf libflashplayer-*.tar.gz

A quick look at the directory should show you that there is now a file named “libflashplayer.so” present. This is our browser plugin, exactly what we need. Now, let’s move it to a global location where we can reference it later. We’ll create a directory layout under /opt and move the plugin to that directory. Let’s make that directory:

# Replace "10.0.42.34 with the version of Flash Player you downloaded.
# The tar.gz file you just downloaded should contain the version number in the filename.
sudo mkdir -p /opt/adobe/flashplayer/10.0.42.34/release/64/
sudo mv libflashplayer.so /opt/adobe/flashplayer/10.0.42.34/release/64/

Note the directory hierarchy we just created. We created a directory called /opt/adobe/flashplayer for storing all of our different versions of Flash Player that we may or may not decide to install in the future. Next, we created a directory within /opt/adobe/flashplayer named after the version of Flash Player we’re using. Within that folder, we created a folder called “release.” (There are two different types of Flash Player plugins, a debugger and a release player, the one used most often by the general public.) Within that folder, we created a folder called “64,” since this is a 64bit version of Flash Player. In a future post, we’ll talk about how to install Flash Player 32bit edition on a 64bit machine, but for now, we’re using the native 64bit plugin.

Next, before we start linking up our shiny new 64bit Flash Player plugin, we need to make sure that we remove any 32bit versions of Flash Player. Execute the following commands to remove all Flash Player plugins installed on your system:

sudo apt-get remove --purge gnash flashplugin-installer flashplugin-nonfree
sudo rm -f /usr/lib/mozilla/plugins/*flash*
sudo rm -f ~/.mozilla/plugins/*flash*
sudo rm -f /usr/lib/firefox/plugins/*flash*
sudo rm -f /usr/lib/firefox-addons/plugins/*flash*
sudo rm -f /usr/lib/nspluginwrapper/plugins/*flash*

This removes all Flash Player plugins you may have installed. If you are sure that you don’t have Flash Player installed, you might not need to run line 1 above, but you should run the rest of the code just in case.

Now, let’s create symbolic links pointing to our shiny new 64bit Flash Player plugin!

sudo ln -s /opt/adobe/flashplayer/10.0.42.34/release/64/libflashplayer.so /usr/lib/mozilla/plugins/libflashplayer.so
sudo ln -s /opt/adobe/flashplayer/10.0.42.34/release/64/libflashplayer.so ~/.mozilla/plugins/libflashplayer.so
sudo ln -s /opt/adobe/flashplayer/10.0.42.34/release/64/libflashplayer.so /usr/lib/firefox/plugins/libflashplayer.so
sudo ln -s /opt/adobe/flashplayer/10.0.42.34/release/64/libflashplayer.so /usr/lib/firefox-addons/plugins/libflashplayer.so

Alright! Good job! You’ve just installed a 64bit copy of Flash Player on your Linux desktop! Give yourself a nice pat on the back! Restart your browser(s) and you’re good to go! Just remember to be sure that your browsers actually exit. A nice test would be to run

killall chrome
killall firefox

to make sure that your browsers really did get zapped!

Now, the next part is optional, though it is recommended that you give it a try. Since there are still a few bugs with Flash Player on Linux in general (not just with 64bit edition), you’ll notice some strange functionality at times running Flash Player. Sometimes, YouTube videos will not accept mouse input, leaving a user at the will of autoplay. To fix this problem, we need to edit a configuration file within /usr/lib/nspluginwrapper/i386/linux . Let’s open it in “gedit”:

sudo gedit /usr/lib/nspluginwrapper/i386/linux/npviewer

You’ll now notice that the file looks something like this:

#!/bin/sh
TARGET_OS=linux
TARGET_ARCH=i386
. /usr/lib/nspluginwrapper/noarch/npviewer

Modify this file so that it looks like this:

#!/bin/sh
TARGET_OS=linux
TARGET_ARCH=i386
GDK_NATIVE_WINDOWS=1
. /usr/lib/nspluginwrapper/noarch/npviewer

This modification tells “npviewer” to use GTK native windows. Now, you shouldn’t be experiencing some of those nasty bugs!

I know what you’re thinking. “This is ridiculous! Why doesn’t Adobe just package Flash Player in a .deb file and do all of this work behind the scenes for us?” And that’s a good question, but I don’t have an answer for it. Hopefully when the Linux 64bit Flash Player plugin comes out of alpha, we’ll at least get a nice deb file that we can double click and install away to our utmost enjoyment

Any suggestions? Run into any problems? Post back in the comments below and we’ll see if we can walk you though this and help you get your 64bit Flash Player running like clockwork!

The first question we should ask, however, is “Why EasyTAG?” Linux is not wanting as far as for music management tools. Why not use Cowbell, or one of the many other Linux tools? Well, that’s why you’re here, isn’t it?

While Cowbell manages your music on a per-album basis, EasyTAG manages your music on a per-anything basis. You can manage anything from a single song to your entire music collection in one swoop. Cowbell is really only tailored to being a simple ID3 tag editor for your individual albums, while EasyTAG aims to be a full-blown, all-purpose tool for managing your entire music collection. It supports almost all ID3v2 tags, including the ability to embed images in your music files for album art. It supports MP3, MP2, Ogg Vorbis, FLAC, MP4 files, and much more. It sports album and song information lookup using free web services. It also operates asynchronously and writing to files is only initiated after a user asks it to do so. Until then, changes are stored in a list of operations which EasyTAG will perform on saving the files to disk.

Let’s get started using EasyTAG real quick. We’re going to be using Ubuntu, but if you’re using any Debian-derivative, you should be able to follow the installation line-by-line. If you’re using another distro, check out EasyTAG’s website to download a package appropriate for your distribution. Here we go!

Let’s install EasyTAG. In a terminal, type in the following command:

1

sudo apt-get install easytag

(Or, if you’re lazy, click this link.) After it installs, you should have a new entry under Applications->Sound & Video called EasyTAG, like so:

Screenshot of the location of EasyTAG within the Ubuntu main menu

Go ahead and start EasyTAG and we’ll get you familiar using it in no time!

After you start EasyTAG, you’ll be presented with something like this:

Screenshot of the EasyTAG home screen.

On the left, you have your file browser, in the middle, you’ll see all music files in the selected directory, eg:

When you select a directory, EasyTAG shows the files in the middle content pane.

And on the right, we have our tag-editing fields of glory. You may have noticed that next to each field is a small box. What this box does is, when clicked, it tags all of the selected files with the tag you have selected. For instance, if I wanted to change the album tag of this album, I would select all files in the middle that I wanted to edit, then make the change to the tag on the right, and then click the box next to the album name input. What this does is add the changes to the queue at the bottom. One of my favorite features is that EasyTAG never just “assumes” anything and never writes any changes to disk without explicitly being told to, as mentioned above.

After making that change, this is what my EasyTAG window looks like:

Now, EasyTAG has stored the operation you just performed to be executed later. Brilliant!

As you can see, it recorded the changes in the bar below. It also tried to automatically correct a file within the directory, which can be configured using the preferences. After editing your tags, you can click the save button in the top bar to write your changes to disk, as shown below:

The all-too-important "Save to Disk" button.

Click this button, and your changes will be written to disk.

Well, what about renaming files? For that, you’ll need to select the files you wish to change, then click the “Scan” button at the top of the screen:

The scan button for scanning, retagging, and renaming files.

This should pop up a new window allowing you to set a renaming filter to apply to the files. Make sure you select “Rename File and Directory” via the dropdown box, and then click the green icon next to the dropdown box.

The scan dialog box. Provides some interesting options for renaming and retagging the selected items.

After you’re done, hit close. Now, you should see that the changes propagated to the selected files in the status box below. When you’re all done, again click the “Save to Disk” button pictured above to write your changes to disk.

Though this is only a cursory introduction to EasyTAG, it’s easy to see how incredibly powerful this is. My music collection just hit the 4000-plus club the other day, with so many different files acquired over the years, following no rules as to file naming and tagging. Now, my entire collection has been renamed to follow the pattern pictured above “%n – %t” which is basically “TRACK_NUMBER – TRACK_TITLE,” so the third song of an album called “Billy Joe” will be renamed on disk to “03 – Billy Joe.mp3″. EasyTAG makes what is simple to do with one song simple to do with your entire library.

To be honest, we really haven’t even scratched the surface of what EasyTAG is capable of. EasyTAG simplifies the process for embedding cover art in each individual file as a tag, which is a huge plus for me. As mentioned before, it also provides a song-info lookup service for finding all of the tags for your songs and albums, removing yet another painful step in managing a large collection.

Due to my circumstances outside of my control, I’m using a Windows machine at work, and as far as filenames go, Windows and Linux are very different beasts. For example, a folder named “Lord of the Rings: The Return of The King” would work great on a Linux machine, but on a Windows machine, colons (“:”) are a no-go. Fortunately, EasyTAG automagically prevents these problems by adjusting filenames to be crossplatform. Another headache I didn’t have to endure.

As the reader can probably see, EasyTAG is a vital tool for anyone who manages a music library. Almost any collection can benefit from some organization, and why put it off when you can do it today? EasyTAG certainly makes a valid case for putting your collection back in order.

Let’s face it. AS3 needed an IoC container. Spring Actionscript delivered it. In an older post, I compared Spring Actionscript and Parsley as IoC containers and the main thing missing from Spring Actionscript (that Parsley had) was documentation. Now, with the release of Spring Actionscript 0.8, that issue is solved.The documentation available at Spring Actionscript’s site (link above) is awesome. It is in keeping with the main Spring IoC container’s documentation, as well as other large libraries such as Hibernate’s documentation. The documentation is pretty extensive and the feature list is growing by the day. It’s becoming easier and easier to throw together a project with Spring Actionscript.

One of the new features that I had originally requested for a while back is autowiring. If you’re not familiar with autowiring, it is something that will ultimately save you a lot of lines of configuration code and a lot of time. Autowiring is the process by which an IoC container finds and injects dependencies automatically, either by type or by name. Rather than writing something like this:

...
<object name=”myObject” class=”com.something.else.SuperDependency”>
<property name=”megaDependency”>
<object class=”com.something.else.MegaDependency”/>
</property>
</object>
...

You can write something like this:

...
<object class="com.something.else.SuperDependency" autowire="byType"/>
<object class="com.something.else.MegaDependency"/>
...

In this case, “MegaDependency” is automagically injected into “SuperDependency” because of a few things: 1) The object tag describing “SuperDependency” has the autowire attribute set to “byType”, 2) “SuperDependency” declares a property “megaDependency” of type “MegaDependency”. Basically, what is happening behind the scenes is that Spring Actionscript is using introspection and runtime reflection (provided by the AS3 Commons Reflection library) to analyze the fields (getters/setters/instance level variables) of a type, and then is looking for other objects managed by the IoC (Inversion of Control) container which match that type. If it finds an object eligible for injection, it automagically injects that object into the autowired one, saving you 2-3 lines of code per object.

Granted, the process above describes autowiring by type. There is another method of autowiring known as autowiring by name, but that seems pretty self-explanatory, right? Find an object in the IoC container whose name matches the name of the referenced property. Eg: if “SuperDependency” has a property called “megaDependency,” the IoC container will look for an object within itself called “megaDependency.”

Another game-changing feature of Spring Actionscript 0.8 is Stage autowiring. When used in Flex, Spring Actionscript can now autowire stage objects. By listening for the Event.ADDED event on the Stage, Spring can tell when display objects are added to the stage. When this happens, certain properties can be autowired.

Check out this example:

...
[Autowired(mode = "byType")]
public var myDependency:MyDependency;
 
[Autowired(mode = "byType")]
public function get myOtherDependency():AnotherDependency { ... }
public function set myOtherDependency(value:AnotherDependency):void { ... }

Assuming this is a class that extends flash.display.DisplayObject, when this instance is added to the display list, Spring Actionscript is notified by the Event.ADDED event, and it attempts to autowire this instance. By looking at the metadata, Spring Actionscript will autowire any necessary properties declared by your class, saving you a lot of work.

Basically, this version of Spring Actionscript is amazing. I love it. By working with it, I have saved tons of time, both in development and in preventing epic madness in the future.

The Spring Actionscript team has also been extremely helpful in fixing a few bugs related to the release. The first major one of these was Module autowiring on the stage. The problem with using Modules in Flex with Spring Actionscript is that Spring is counting on all class definitions being in the main ApplicationDomain. When loading a Module, by default a new ApplicationDomain is created for memory purposes, and the Module’s classes are loaded into it rather than the main ApplicationDomain.

Unfortunately this poses a problem as Spring is unable to find class definitions for all Module classes. However, the Spring Actionscript team has been very helpful in addressing the bug and trying to provide a fix. At this point, in the trunk, the issue has been patched but not fixed by preventing Modules from being autowired. Hopefully in the future, a fix will come so that we’ll be able to use stage autowiring anywhere, no matter which ApplicationDomain the classes are loaded into.

Another issue that has been fixed since the 0.8 release is complex property resolution. Spring Actionscript uses the Java property format (my.complex.property = something), and that format usually allows for complex property resolution (my.complex.property = ${my.other.property}/tk), but this wasn’t working with the 0.8 release. Fortunately, I have been told that this functionality is working great in the trunk, but I have yet to try it out.

Again, mad props to the Spring Actionscript team! Thank you so much for an awesome IoC container for AS3! Looking forward to the next release!

Technorati Tags: as3, ioc, dependency injection, flash, flex, spring