Posts Tagged Android
Flash Player 10.1 on Motorola Droid and Motorola Backflip
Posted by Mark Doherty in Android, Flash Player on January 7, 2010
The latest in our series of Flash Player 10.1 video demos comes hot on the heels of Motorola’s announcement of the Backflip, Droid and it’s Milestone variant.
You will remember that at MAX 2009 we showed a disguised Android device, previously unannounced, running Flash Player 10.1. That was in fact the Droid, and with our continued partnership with Motorola and Google it’s great to see Flash Player 10.1 start to filter through the platform. From a developer perspective, this is a good indicator that we’re now able to bring Flash to devices by platform; in this case Android 2.x.
In his video demo, Adrian shows the New York Times website which is now able to detect these Android devices and provide a more complete web experience including video, images and animations which until now have only been suited to the desktop.
Most news and entertainment sites today are using Flash to playback their video content, engaging with their audiences using rich media throughout their sites.
The award winning BBC News site is also shown in this video, and interestingly shows some nice device detection from the BBC whereby highly optimized video is sent across the web as they detect lower bandwidths using the Flash Media Server.
As with our other videos, these are teasers to give you some idea of the wide scope of devices including WebOS, Android, Windows Mobile, Symbian and Linux that will be able to run Flash Player 10.1 later this year.
Enjoy..
Google joins the Open Screen Project
Posted by Mark Doherty in Adobe MAX, Android, Devices, Flash Player, Industry News on October 5, 2009
Recently you probably noticed that I’ve been working on Android a little, and for good reason of course. Though it would be easy to focus this post on Android, let’s just look at some of the places where Google use Flash today.
- Youtube
- Google Maps
- Site Search
- Web Search
- Chrome / OS
So you see Flash is everywhere at Google and we’ve been working together for years to build upon this relationship. Google joining the Open Screen Project may seem like a matter of course given our demo’s last year and given their investments in the Flash Platform.
In the past few months we’ve seen stellar device launches from HTC and Motorola using Android. Those of you with beady eyes will also have spotted others from Sony Ericsson and “others” coming down the pipe soon.
I want ALL of them, but might stick to the Hero for now.
Oh, in case they’re watching. Dear HTC, please fix the SSL certificates for Exchange email eh?
Flash Development with Android SDK 1.5 Part 2
Posted by Mark Doherty in Android, Devices, Flash Lite, Flash Player, Mobile Content on August 12, 2009
As we already know by now the HTC Hero supports Flash in the browser, and by double tapping on Flash content it will be played in full screen mode. In fact I believe that’s also the reason why we cannot use the Flash Player directly with Intents.

Those of you familiar with Nokia’s WebRuntime or the iPhone UIWebView will recognize WebView, because it’s the same thing. Really it’s an implementation of the browser framework made available as a UI component. Some of these implementations come with hooks into the platform code through JScript, and enable the use of device APIs like Location.
So what can we do with the Android browser? Let’s look at the pieces provided by Android:
- WebView – Used to load and display web pages using the built-in device browser and chrome, embedded into your application.
- WebViewClient – Enables the handling of various browser actions like page loading and error handling. Overrides the Activity in the built in browser.
- WebChromeClient – Enables the replacement of the browser chrome for events like progress, alerts and for window controls. Can override the default Chrome.
Step 1: Launch the built-in browser using WebView
The code to do this couldn’t be simpler, but there are a few extra changes to make with the layout declarative XML and with the AndroidManifest.xml. Android supports the ability to lay out the application using standard components, much like Flex.
To add a WebView to our layout we must add the WebView node to the main.xml (in project/assets/layout). You can see the id property of the node looking rather special, and that’s because it’s indicating a binding.. again, just like Flex. We can use this resource, and any others later in our code using the builtin R class.
Now we’ve done that we have to add a new permission to the Android Manifest.xml. You’ll notice that the XML includes a number of nodes pertaining to my application, most of it is easy to understand. Note also that my application has it’s own Intent and an Activity called StubApp.
With that we only need to add a tiny piece of code to use the webview component, check it out.
As before we overload the onCreate method, call the parent for good measure and then get to business. We call setContentView to build the WebView using our layout XML file above and then get a reference to this view, set JScript to enabled and load a URL. It really couldn’t be simpler and as before this runs on the device, however there are issues.
Clicking links in WebView above causes the loss of client control over the page. The result is that Flash works, but we cannot control the user experience.
The next step was to attempt to bring the control over loading new pages within the webview instance. To do this we need to extend the WebViewClient class and override the shouldOverrideUrlLoading method, this gives us the opportunity to load the page ourselves; before the browser gets to it.
It looks like this and note that return true after view.loadUrl(url) means don’t bubble this event to other web views:
The result of this is work is that we can simply replace the currently loaded page without launching a new activity, but it comes with a penalty. As when I implemented the custom WebViewClient it became clear that the Flash plugin was not being loaded. Worse still, there’s no way to load it (despite APIs to the contrary) and that’s by design at this time.
So there you have it, the investigation into creating a Flash Application that lives in the browser can only succeed when using the native browser. The Android Platform allows for the creation of custom browser clients and chrome, but the penalty for this is that you loose access to plugins.
Hopefully this has been an informative post, and maybe inspired you to have a look at Android with Flash Player support. Maybe you can extend my examples, or by all means provide some secret code that can help us start up the plugins
Flash Development with Android SDK 1.5
Posted by Mark Doherty in Android, Devices, Flash Lite, Flash Player, Mobile Content on August 12, 2009
Following on from my previous post below I have also been playing around with the Android SDK, and specifically with the Flash Player on the Hero. It has been sometime since I did any programming, but some of you may know that I come from an engineering background. So below I’m going to go over the different tools and technologies that I encountered during these two days.
Be warned, there’s code and geek talk below
Step 1: Get the SDK and tools

The Hero runs Android 1.5 with a custom UI from HTC called “Sense”. With 1.5 comes a number of additional features like on-screen keyboards and Android Widgets. All I needed to do was download the SDK for Eclipse, the same development environment we use for Flash Builder, or Carbide for Symbian C++. The Android toolchain is a real dream and it runs across Mac, Windows and Linux with feature parity.
If you have Eclipse/FlashBuilder or Carbide installed then you’re good to go. Just install the ADT plugin using software update, unzip the SDK into a relevant folder and point to it like this.

Step 2: Create the HelloWorld app
It used to be that you had to actually type something to create your HelloWorld app, with Android there’s no need
Using the File->New Project menu you create an Android Project, and setup the app name, package name and the name of your Activity; then click finish.

You’ll end up with a typical application created in the Package Explorer, and if you look in the source folder you find the generated .java files. Remember that Android uses the Java language, but it’s own APIs, and so it’s familiar to look at.
Notice that my application extends Activity, part of the Android application package. An Activity is generally considered an interactive component, like a screen or dialog. For our purposes we can thinking of it like a MovieClip or UIComponent if your a Flex person. In this auto-generated code we have simply overridden the onCreate method as this is the first function to be called. There’s also an onStart method and that should be used if you want to be formal.


From here I can simply run the emulator, but just for fun I decided to plugin my HTC Hero, go for bust I say! The great news is that devices are auto-detected by the ADT plugin in Eclipse as shown above. From here I can run or debug my application using the normal IDE buttons, and also with the SDK comes a nice tool to capture screenshots from the device while connected to the ADT plugin.

Step 3: Launch Flash Player Standalone
This is where things get more complex, simply because I don’t know exactly how the player was implemented for Android. Android uses pretty standard methodology for application development, and so I can presume that the implementation followed the rules. So what are the fundamental rules?
- Activity – Is a UI component that presents itself to the user for interaction
- Service – A background process that carries out a task for other components such as pulling emails and calendar synchronization.
- Broadcast Receiver – A component that listens and does something in response to broadcasts. Widgets are great examples of broadcast receivers.
- Content Provider – A useful way of wrapping access to content, images, audio files or even data base access.
Activities, Services and Broadcast Receivers are all started by and registered to receive messages from the platform called Intents. An Intent is a simple message object with a simple Action string and it’s also possible to send data, or call a specific component to handle the message.
So with a spot of “playing” around with a decompiler I was able to find two potential Intents.
1. To launch the FilePicker with SWF/FLV files detected automatically.

This works pretty well, though seems restricted to landscape mode.
2. To launch the player Activity (com.htc.flash.SingleViewActivity) directly passing a SWF file to play.

It’s possible to launch the Activity using this method but the file provided in “putExtra” doesn’t actually load. So while this would be the best solution it appears like it’s designed not to work in this way.
So in summary, the only valid path for standalone apps (as far as I can tell) is to load the FilePicker. This method is pretty good for on device testing, maybe you want to see what your mobile web site looks like and need to tailor the flash content to fit the screen.
Next we’ll look at the browser solution…




















Recent Comments