WWDC2003 Session 731

Transcript

Kind: captions
Language: en
welcome to session 731 internet
application development my name is
Ursula Wrangham I'm a partnership
management here at Apple computers a
developer group today's session is going
to cover macromedia central the new
product that will be releasing later
this year we have two people from man
can we use development team for central
David Cal price and Michael Williams and
we have a third party developer who's
created some applications that work with
central Alex right so now I'll turn this
over to Dave Cal price thanks for luck
all right so here we're going to teach
you a little bit about Max media central
we're currently in beta right now at the
new product under under development so
see here so we're going to learn about
is central to this new environment for
Internet enabled apps I'm going to talk
about also how a macromedia in general
views Internet applications so what
we're going to learn is we're going to
get a little bit of a situation overview
kind of where the state is of apps in
general and talk about Central and of
course the process for developing apps
for Central and we're gonna talk about
rich internet app XML soap Wiz dull and
force flash so first of all a little bit
about the vision macromedia division
currently our vision all right now is
all about experiences we feel that great
experiences build great businesses and
this is this doesn't just pertain to
application development pertains to
pretty much anything whether you going
out to see a movie or drive a car or get
a cup of coffee people want will pay
more and and expect great experiences so
macromedia is all about helping people
deliver on these experiences so in order
to do that we are promoting this idea of
what we call rich internet applications
which has been become very popular
lately
what they tend to do is combine the best
of a contradiction desktop application
so we're talking about things like the
usability and user interface that you
get with desktop application the
availability of desktop applications you
can always access them regardless of
whether you're connected or not and also
the integration with the operating
system as well as the best of web
applications web applications are great
at you know accessibility to data
they're all they're connected you can
also have the most up-to-date
information and also communication are
starting to see a lot of communication
used in applications lately and this is
also something we feel is really
important to improve the user experience
so we're talking about things like not
just sort of text-based chat and I am
but also a two-way or n way video and
audio communication so all of these
things for combined together to make
what we call rich internet app so what
is central and what are the issues that
addresses so right now most of the
internet is document-centric so
essentially this is grown out of the
history of the web you know based on
HTML in the web browser most websites
are our page based and document-centric
and and so most applications as well are
also document-centric and from page
based you you also have to click through
multiple pages to perform a task and
this is sort of a step backwards from
actually in sort of the early 90s or
even late 80s when you had much more
rich user interfaces in a desktop
application another problem that central
is trying to address as an application
platform is that the the installation of
applications from the internet is often
very clumsy typically you know if you
want to install an application you have
to download an executable file find out
where you downloaded it to on your
desktop double-click it may be run an
installer I go through a few screens and
also have to worry about download a
virus or something like that so this is
also a problem that we're trying to
solve with central additionally
applications in general don't work very
well together unless they were designed
ahead of time to to cooperate such as in
the studio or sweet applications are
pretty much developed as independent
silos and apart from maybe copy and
paste there's very little interaction
between its applications they have a
little very little way of sharing data
and so that's also something that we're
trying to improve the central next
offline use typically web applications
we go to a shopping application or any
sort of application on the internet you
know if you are disconnected if you
become disconnected from the net that
information is no longer available to
you you know browser pretty much becomes
useless as long if you're no longer
connected and so that's also something
that we're trying to solve a central and
finally applications you know often have
many different ways of notifying the
user of events some you know bounce the
icon in the dock other one thing up
little windows and so there's not really
very much consistency about how events
are essentially communicated to the end
user and so we're trying to also provide
some consistency in a framework for
notification as well so just coming back
to the basics of what central is its
environment for collecting and managing
applications we call it United because
of the applications work together
cooperatively and unplugged meaning that
you can still stay productive even when
you don't have the web connection so
from the customers point of view what's
good about central again it combines the
best of desktop interactivity and sort
of the availability and usability of
desktop apps with web-based deployment
and also the ability and all the time
up-to-date information from the internet
the applications in central are
cooperative and can work together and
share data this delivers a much more
efficient experience for the customer
because rather than them having to go to
indeed one application and sort of get a
result from one application for example
if you're doing some shopping and you
want to look information of a product
and have to go to another site to find a
review on that product that's sort of
inefficient workflow and so with central
of the applications can work together
and actually share this data even if
they weren't designed to work together
when when they were built
next fast and easy installation I
mentioned the force of the clumsy nature
of the installation process currently
for applications on desktop platforms
you with central you can build an
application and with a single click from
a web page can be installed and running
on end user's machine and this sort of
mechanism makes it office or leads into
this tribe I mechanism which I'm gonna
talk about here there's a commerce
system also built into central this is a
very important aspect of the platform
that as a developer you can create an
application posted on your website and
connect with our commerce system and
sell your application and get money fed
into your own merchant account without
having to set up all the infrastructure
to handle all the credit card
transaction processing that kind of
thing all by yourself that's
infrastructure that Mac community
provides as part of building for Central
and because of the trial system and the
try by the purchase system is built in
central it's consistent across all the
different applications the third party
apps and macromedia applications that
run inside the central and so the end
user has sort of an expected experience
they're not going to be afraid of trying
to download new applications try them
out purchase and purchase them and so on
they have to be afraid of you know
different types of purchase mechanisms
something that they can trust finally
you can use applications online and
offline this is the course up to the
application developer to support both
modes but since central is not tied to a
web browser you can actually have
applications that store data for offline
use to make it available when you're
even expected and finally on
applications built for central will run
on OS 10 as well as Windows and also in
future handheld devices they're all
based on the flash player technology so
to develop form a community central you
you just use actually to flash MX which
is our shipping flash authoring tool and
the central SDK which is currently in
beta right now and then later this
summer or early fall will be available
for public release use existing
components that ship with flash and are
also other components UI widgets and
other types of components are available
from third parties you can use those as
well as we some additional components
that we've built just for sense
goal to provide a consistent look and
feel across application also you can
build on top of web services and other
structured data so central includes
built-in native support for soap and
whistle so you can use web services
directly from the central clients to
talk to a server and the environment of
the mentioned four it's all built on
flash technology so if you can develop
for flash then you can develop for
central so you've got the development as
a developer you have the benefits of a
very widely supported development tool
there's built-in support for the
transaction infrastructure for download
and installation of applications
services for exchanging data to servers
as well as between applications running
locally on the client as well as auto
updating technology so if you build an
application for Central and then a few
months down the road you want to push
out a new version all that
infrastructure is already there for you
in Central and so you don't do any
special works to port auto update and
finally a macromedia is going to provide
an application finder which is the
global directory of all of the
applications out there available for try
and buy and you will you can become
listed in this application directory
called the app finder and then everybody
who has Central has this directory
always available on their machine that's
part of the central runtime environment
so if they're out there looking for new
applications they can find them and
we'll show you a little bit of a demo of
that in the screenshot in a minute so
it's a really good way to get exposure
to your application and of course the
benefits of just being based on the
flash technology the ubiquity of the
flash player distributed virtually all
desktop systems over the last few years
so people have a current / 6 player
already have the capability of for
downloading installing central and
central applications and so there's
already some millions of develop and
users out there with that capability yet
the community of 750,000 flash
developers worldwide today so there's a
very large developer base and a support
network set up for people developing for
flash got the portability across
platforms as I mentioned before as well
as the ease of development of the flash
and space of the space
file format and architecture and finally
/ is a multimedia player and so in
additional that was a good stuff you've
got support for things like video audio
animation you know anti aliased vector
graphics images interactivity and so on
so here's a screenshot of the user
interface of central so what you see
here in the main window here is what we
call the application window pointers not
working too well in the application
whether this is the main area where
applications inside central run and at
the very top you'll see kind of a
toolbar with icons on it and that's the
launcher area and so each application
you install has an icon and it becomes
listed at the top there in that in that
toolbar and simply the end users are
simply clicking on that icon launches
the application and you can bring up
multiple with these applications if you
want just like a web browser it's a very
simple sort of easy to use interface you
know you get an icon you click on it and
runs the application the rest of that
window space in that window is the is
for the application itself to run and
that's up to you as a developer to
decide you know whatever you want to put
in that space like I said before we'll
be providing a set of components that
you can use to handle a lot of the
common user interface functionality on
the right side of the screen is what we
call the console and this is a kind of a
toolbar that can display optionally
small miniature versions of these
applications that can be there sort of a
persistent presence on the users desktop
as an option so for example here we've
got a traffic camera showing all the
time and a weather satellite map and so
you can imagine other types of things
like stock tickers or news information
other types of feeds they can run as
little tiles in this toolbar and this is
also where notifications appear as well
if application wants to present a notice
to the user that some event has occurred
a price of a product that they're
interested in is dropped to a certain
amount but then the notices will can
appear there in the console as well and
these windows can be open or closed
independently so you don't have to have
any of these windows open and you can
just be running in the background or you
can be interacting the main application
space where you just have that console
up if you just want to have a small bit
of real estate used just to show this
information on your desktop
so those are the basic elements of the
central you I so as far as the
installation goes I mentioned before you
can install directly from a website so
here's an example of the company called
pricegrabber which has a shopping site
so lets you compare prices for different
products online and we've been working
with them to build an application for
central and so here's an example of what
their website could look like with a
central installation button on it so
essentially I like to do is put a small
flash movie in your website with a
button on it to install all these guys
to do is click that button if they don't
have central installed it's
automatically downloaded and installed
then the application itself is
automatically downloaded installed and
it's launched this all happens in a
matter of a couple of seconds and then
they're up and running with the
application outside of the browser so
that's installing from a web page and
then the alternative is you can also
install from the application finder and
probably too easy to see with this
Escalade but it's essentially a
directory of applications and you can
the end user can sort by different
categories there's there's a whole
rating system where people can provide
feedback to applications and rape them
I'll get all the information on whether
it's a free application whether it's how
much it costs what the list the trial
period is and so on there's different
ways to browse through the whole
directory of applications and this is
available like i said its built-in
component of central and for all users
and there'll also be a version of this
on the website so you can access it even
outside the central if you want so next
I'm going to bring up Alex Wright who is
an independent developer he's been
working with us since the conception of
central helping develop applications and
helping design the look and feel of our
application and he's going to give some
demonstrations of some apps run inside
centre ok great thank oh thanks Avery
alright so Steve much i'm going to show
you a couple of examples of some central
applications that we've been working on
for the last few months and preface this
by saying a lot of us is work in
progress are going to give you peek
under the hood and show you some of the
some of the apps or curling development
but first I just thought I'd say a word
about central sort from my point of view
as a third-party developer coming from a
background in web development which is
what I've been doing for the past
several years working on web based
applications you know I think central
represents a really interesting
opportunity for developers and two
reasons for that primarily one is it's
just a much better more responsive
environments for creating user
interfaces in than a web browser they
take well if you talk to a lot of UI
designers they would tell you that the
webs are to set them back about 10 years
in versus sort of desktop OS UI design
and the reason for that is you know the
web browser is basically kind of a dumb
client it's you know a lot of ways to
sort of equivalent of a green screen
interface to a server me there's no
runtime environment there's no session
state you know you really give up a lot
of the advantages the performance
advantages that you have versus you know
it's developing desktop based
application so I think what you know the
first thing that I think is really cool
about Central but it does give you that
runtime environment it gives you a
session state where you can build
applications that can actually talk to
each other share data and you just are
able to reduce the latency in the
interface by taking advantage of this
runtime so you're not sitting there
dependent on you know packaging up a
request and sending it to a server and
getting it back just inherently there's
a big advantage there just with the
flash runtime environment the other
interesting aspect I think is the
built-in web services support gives you
an opportunity to do some really
interesting things to do it in a much
more efficient manner than you could do
with a with a traditional web based
application so so on that note let me
just well cut to the chase here and show
you what we've been working on some so
this is the current beta release of
central that I just went out today this
morning yep so it's just hot off the
presence of hope it works so they've
already gave you a preview of the UI so
I'll just let this load quickly that's
price grammar
over here okay so you see here's the
application window here's the console
and we've got a couple of applications
loaded into the app finder here so what
I'm going to do first is just walk you
through a couple of the applications and
sort of show you how they work so um
will we will come back the upfront or
later maybe but i'll start with one for
pricegrabber which they showed you a
sort of a snapshot of so again
pricegrabber is one of these services
that provides comparative pricing data
on consumer products so they have
something like I think it's something
like 15,000 products in their catalog
and they get prices from a lot of
different retailers on a daily basis and
you can get sort of like my Simon or
there's several services like that and
their business models they basically
syndicate this data to other sites like
I think white goes uses them a few
others do so really there well they do
have a website that you can do it going
you know search for prices on what
they're really in the business of its
indicating this pricing data so what we
wanted to do was see if we could create
sort of a better interface to
comparative pricing data using the
central environment and this is what we
come up with this is actually sort of a
first bill that but we're actually
working on a next build it'll actually
be a little more sophisticated and have
some new features but i'll show you some
of the basics here so one thing i can do
here is just do a search so let's say i
wanted to search for an ibook so i'm
going to click the submit button and
what's happening here is the application
is putting together singh a request that
gets sent out via HTTP to the
pricegrabber server what happens to the
pricegrabber server responds with an XML
file that we read into the application
that contains all the data that you see
here so basically what it came back with
with three matches for apple ibook and
what it's showing you is the best price
for each of them and they'll get I think
up to like 20 different prices but don't
make at least in our application will
show you the best price and then it
shows you sort of where that search
results fits in this product hierarchy
or texana me that they've got which I
can also browse around and explore here
if I want to
for instance do this you can see it's
pretty responsive every time i'm
clicking on the every time I clicking on
something on the screen it's going
prodding up sending a request off to
pricegrabber and bringing a data set
back you can see just in the process of
sort of clicking around here so this is
a much more efficient interaction that
it would be saying a web browser where
you'd have to go you know web page to
web page to web page get a whole chunk
of HTML back with every one of these
requests this was with with central
we're able to put together a request and
very efficiently just request the exact
pieces of data that we want to get back
and read into the application a couple
other things we can do with the using
some of the standard components that
macromedia is developed this is one
called the datagrid that lets me do
sorting very simple you know very
familiar or sort of desktop a less
convention but again if you compare this
to the experience in a web browser you
know there's no easy way to do this in a
web browser without going off to a
server where this is all happening
locally inside the application oops we
didn't see that okay so as I'm going
through here I'll just move on through
the application a little bit and that
goes Oh what do they do okay I wanted to
do that all right tell you what
okay and here we go okay so here's
another feature or central remember
where I was when I just shut down came
back to the application it preserves the
state remembers exactly where you left
the application when you come back so
see if I can pick up where it left off
okay so as I go through and browse of
these items you can see what's appearing
down in the preview pane is sort of a
thumbnail image displaying the you know
a product shot some basic data about the
product specs we also get user reviews
that are also provided by pricegrabber
now if I see a product that I like I can
add it to my favorites list and what
happens here is it gets added you can
see it switched to another tab here
where I can keep sort of a short list of
product we're also creating features
where you'll be able to set a price
notification so if the price drops you
can get a notification in Central that
will tell you that the price went down
so those are just a couple of things you
can do with it and another thing we're
working on is the ability to do feel to
do some more advanced searching based on
specs and filter you know basically
looking at different criteria respects
around the product be able to do more
advanced searching and filtering around
up stuff anyway so that's pricegrabber
i'm going to show you another example of
an app we've been working on and this is
a stock ticker app so the first thing
you'll see here when this comes up when
i run it this is an example of the tribe
I feature so this basically is sort of
an example of how this would work if
you're a third-party developer and you
launch an app you release an application
on Central you will have a built-in try
by facility so that you can put an
application out for trial for as long as
you want and then put a price on it and
then the user can either try or buy so
soon as the prop here expires they'd be
forced to buy it or they wouldn't be
able to use it anymore let's say I'm
still in the trial period still hit try
and this is basically just a fairly raw
prototype of the application but once
this will do what they want to look up a
stock quote I'll put in that's these
guys and this is going queering a
third-party web service pulling back you
know the
stock stock load data so it gives me
current a current quote change date and
then some additional detail down below
select that so it's fairly
straightforward to me nothing you know
sort of lead expect a stock ticker to do
but again a little more efficient than
you could do with a web-based
application but what's interesting about
this is I can also set an alert so that
if I wanted to set a target price or
sort of a stop price on a particular
stock I could set up a notification and
it would proact if it if the stock hit
that price it would proactively notify
me in the console using a notification
feature so again a way of making the
application a little smarter a little
more aware and you know adding a little
bit of value for the user so let me show
you quickly we haven't talked much about
the console yet i'll show you the think
this is a good example here since this
is such a lightweight sort of you know
concise little application it's a good
candidate for sort of what we're calling
tiles or pods or these these things that
appear up in the the console so this is
just a sort of boil down version of via
of the application considered jetblue is
doing so get some more sort of thing
just give you a very nice little you
know handy little utility application
that you can use to just go quick
queries legs up let's see so let's keep
moving along here here's a prototype of
a weather application we've been working
on and so using accuweather so what you
get here is basically you know again
fairly straightforward you can just look
up weather for you know any location and
it'll still accept alpha numeric strings
or zip code so let's a look up the name
for the weather in my neighborhood using
San Francisco gives me the five-day
forecast and I can have up to I think
it's up to 10 weather forecast you can
see if I flip through these it's fairly
efficient because this is all happening
on the client side so once this is this
data is cash in the application it's all
at all this is happening locally now
let's say I want to just keep an eye on
the weather what I just did was like hit
tile here
and I could launch a little version of
it so I can basically just take this
little weather forecast sort of pin it
to my desktop and keep an eye on it and
it'll automatically refresh you know and
it's that interval so you can see now
has got two things going on in my in my
console here I've got the accuweather
application and the stock application
and you can have sort of an indefinite
number of these things over time so it
gives you a way of you know creating
applications that can you know have a
little persistence on the desktop and
you know give the user a little take
advantage of the runtime environment to
do things like polling and notification
just create a little more of a rich
experience for those for the user and I
think what's really the really
interesting opportunity with these
applications is the ability cuz you're
in this single session state in the
central environment opens up all kinds
of possibilities for these applications
to talk to each other and to share data
with each other you can actually permit
one application to expose its data to
another application so for instance if
you were looking up a movie time you
could add it to your calendar very
easily so you could take you know and
calendar be another application that
might exist at some point and there are
all kinds of opportunities like that for
instance let's say you're thinking of I
don't know traveling somewhere you know
you might be able to look up the weather
and get a map so to do a location and
you know add that to a to a shared
calendar that you might uh so naps
people so there's all kinds of
opportunities to share data and Korean
basically give you an environment where
applications can talk to each other and
be sort of aware of each other which is
something is just very difficult to do
with web traditional web based
applications where you're really in much
more of a siloed mode where each
application needs to exist separately so
so those are just a couple of examples
we talked about the app finder so I
thought I'd just show you the working
version of this real quick this is just
a sort of sample couple of applications
that are in there now this is a sort of
a demo prototype for a homeland security
application and I don't know if this
will actually see the light of day or
not but it's sort of the idea you could
just get a Tom Burgess days and getting
a notification if the threat level goes
out
so then if you want to do so that should
be a good candidate for a tile
application where you just put that on
your desktop and you can even set a
notice if it goes too high some reason
then you could get a notification on
your desktop so for what it's worth okay
so so that's where we're at these are
just a few of the applications hope this
gives you some idea some of the things
that are possible these are all you know
somewhat prototype be there's several
other applications that are currently in
development that should ship when the
final version of central goes out but
please do somebody at some of the things
that we're thinking about if we can come
up with better ideas in these so you
like so think that's all I've got I'm
going to turn it over to Mike here who's
going to tell us a little more about
developing a central thanks Alex can I
go back to the slides thank you so what
I'm going to do is give you a little
overview of how all of this works and
and show you a little bit how to build a
really simple application using the
central framework in environment first
of all I want to give you an overview of
what the file format of flashes if it's
called Swift which stands for a small
web format that is what kind of
basically is the heart of flash and when
you create something using the flash
authoring tool you're actually creating
a swift file it's basically the native
format it's a compiled binary file that
contains bytecode and media that's been
compiled by the authoring tool and so
there's a number of different tools that
create Swift content macromedia is kind
of like these the keeper of that format
currently and it's an open format that
that has you know basically become the
de facto standard for doing rich media
on the web and kind of central is our
you know our next step to taking things
outside of the web browser and more into
the desktop environment and the primary
scripting language of flash is act what
we called ActionScript it's based upon
ECMA 262 with extensions for the flash
document object model or dom and it's
some of the same exact scripting
language that you would use for
javascript inside of a web browser
so the essential application
architecture is made up of four major
parts there's the application shell the
console the central user interface
components and a number of different
Swift files that kind of broker that
data back and forth for you as a
developer so that you don't have to do
kind of a lot of the dirty work needed
to make these applications and pieces
work to go to give it properly so the
main central parts are the main
application that you create the tiles
and these things that we call it agents
and agents are kind of like invisible
background processes that allow you to
kind of broker data back and forth
between all these different parts so all
of this was built as I said before on
top of the flash player with some with
some things added on top of it and those
things are first of all something that's
very exciting the mac users is we added
a lot of performance enhancements not
only on windows but on the macintosh as
well to make it run a lot better we vet
out the vet enhancements for for
graphics and alpha channels and things
that in the past have been significantly
slower on the mac and now we have parity
between windows and mac for that for
that kind of performance that's
something that makes mac users very
happy we've added native web service API
so that you can call Wiz DeLand you can
make direct soap calls without having to
go through as you today as you do today
through flash remoting or some type of a
gateway on the server side we've also
added because of the fact that we don't
have to worry so much about the size of
the flash player we've added regular
expression a pianist as you can do lots
of more advanced string manipulation
that you have to do when you're bringing
in large data sets from the web and
we've also made it so that because
you're not in the browser you don't have
the ability to kind of cache data we've
given you api's where you can manually
cash that data and we've also made it so
that we have a direct connection to an
e-commerce system so if you want to sell
your applications or do transactional
processing we do that for you so this is
kind of a visual overview of what the
central application architecture looks
like it's made up of like i said before
three two major issue this two major
visual areas which are the application
window and the console on the console
contains both tiles and notices tiles
are the kind of
assistant areas where you always have an
application running and notices they're
kind of things that come up and tell you
that something has changed like your
stock price has gone way below where you
want it to be or before it's gone up and
that's a good thing and all that stuff
kind of goes in that area and you kind
of have control over that as a developer
through your application and the API is
that are going through agents so those
agents have been connections to web
services on the internet or just xml
data feeds and or local data storage
which is in flash or called shared
objects so you can basically take any
object that you have inside the
ActionScript DOM and store it locally on
the disk so if you want to store like
the paid last page visited like you saw
on that application before it's easy to
do and then the next time the person
comes up and opens the application they
immediately get back to that at that
point excuse me so here's a quick kind
of stack diagram that shows you know
what's actually going on inside flash so
at the most basic level is the native
operating system Mac Windows a device
such as pocket pc or any other device
that comes along that can run the flash
player such as the kind of Nokia
handhelds all those kind of things that
we had the flash player running on and
the next thing up is the flash
standalone player and it's basically
taking the runtime version that you have
inside the browser and it's wrapped
around and executable that kind of
brokers and holds this data and sitting
on top of that is something we call the
controller which is a swift movie that
then kind of that does all of the the
controlling of you know what messages
are going to be sent between what
windows opening new windows opening new
consoles getting data from the server
side storing preferences and sitting on
top of that is kind of the the primary
areas as a developer where you can build
something so as a developer you can
build your own application that sits
inside the app shell you can build your
own tiles that's it inside the console
and you can build your own agent that's
it inside the agent manager they kind of
deals with all these kind of invisible
persistence background processes
so like I said applications contain
three primary parts there's an XML
product definition so there's an XML
file called the product XML that says
this is what this file this is what this
application is it contains this size
this whip these contents the next part
of it is the actual Swift that you
compiled using the authoring tool that
has all of your application logic your
graphics your video your audio all the
things you can do in flash and the last
thing is kind of the icon that
represents that inside of our inside of
the central application runtime kind of
hard to see but this is basically an
example of what a product XML file is
and whatever is NC kind of gives you
data upon you know who created at what
time it was and all the things that that
represent your application so to central
this is your application this is kind of
the metadata that wraps up what is
application that you built and you know
what is the application need to do so
any time we add something to the central
framework you will define it using the
product XML file and that's how you kind
of tell the system what you want to do
and how you want to build it so
basically the tricky thing that came
along when we tried to kind of build
this environment where we have multiple
flash movies all communicating to each
other was people have never done that
before typically when you build some
flash content you're building a single
flash movie running inside of a web
browser and that's all you're worried
about you might be doing some animation
you might building a banner you might be
building some type of you know simple
web service application but you're not
really worried about having two
different movies communicate and share
persistent data so in order to solve
that problem in Flash Player six we
added something called local connection
which allows separate flash movies to
then communicate each other over kind of
eight a global space so you can actually
have flash movies that running on top of
the desktop or they could be running
inside the browser and they can then
send data back and forth to each other
so this allows us to then have multiple
elements of enough of a flash you know
kind of run time that are written
entirely in a scripting
rather than us having to build
everything in kind of a very low-level
language like C or C++ we can actually
build it in the na in our higher level
actionscript language so that things are
more portable and changeable so we can
write our framework at once and it will
run on multiple platforms we don't have
to worry about having to report
everything to Windows and Mac and a
device everything will work exactly the
same way so basically everything that
you write as an application developer
it's the same kind of framework that we
have to go through at micro media to
build this so as we add more and more
frameworks and more and more abilities
the central framework becomes more
powerful for us and it also becomes more
powerful for developers as we start
drilling down more into the operating
system so that drilling drilling down is
actually being done entirely by the
controller and the controller the one
that actually talks to the flash player
and that's what talks to the operating
system so if we want to send a notice
and we want to make the icon in the dock
bounce you do that through an action
scroll if you want to do that if you
want to add a new application we do that
through ActionScript rather than you
having to write that in kind of a a
lower level language it's all done in
our higher level language and the
controllers does that and as we expose
more and more AP is those get exposed
through the controller and through kind
of all the standard API is that we
document that's part of our SDK so it
manages what application shells are
running you know what it's currently
focused all the kind of dirty work of
what's going on in making an application
behave like an application that often
people have to deal with and kind of
manage we kind of do all that for you
inside the controller so all you have to
worry about is building a really great
experience not to worry about making
sure that you have application focus and
dealing with all these kind of little
dirty things that you have to do to make
an application work well
so the next thing is part of the
framework is agents and agents are
basically they have no visual
representation their background
processes that allow you to make script
only connections to data services on the
web and let you have persistent data for
your applications so I'm going to build
a weather application and I want to hook
it up to my calendar and say you know
we're only going to go out on Saturday
if it's sunny and warm I can make it so
that they you know the calendar
application knows it talks to the
weather application and says that the
weather is over 80 degrees booked this
trip and booked this you know event with
my friends and send a notice out to them
so all that kind of communication is
going through agent so each application
has its own agent and each one then can
communicate with others so they can open
up kind of channels of communication to
each other and that again is managed by
the controller and something called the
agent manager and when you're in your
product XML basically if you want to
have an agent you just define this line
here and you're saying I have an agent
it's got this name and this is the Swiss
that contains that logic the next major
part is the console and this is kind of
a screenshot it's actually an early a
later version of the prototype than what
we showed up there kind of our current
thinking of what it's going to look like
and basically it's your persistent area
where each application lives and kind of
resides in my desktop the same ways you
have any other kind of persistent
application running on your desktop you
can build that kind of environment and
run it here and if you want to give
people information and the latest kind
of up-to-date data that's what goes here
same thing with notices they go inside
of this kind of persistent area that
runs on your desktop and that's kind of
fully controllable over you of where it
lives and how big it is and what what's
inside of it as and what we call each of
those elements first part is called
tiles and that's basically the framework
for consistent desktop presence and for
instance you could have a weather chil
that shows your local weather and
basically in or you have any type of
application and those tiles are
basically configured
over what you see inside them could be
either configure within themselves or
configured by the application that
created them so I've have whatever at
weather application and I'm looking at
the weather for Chicago and say I want
to monitor that I can take care save a
tile it automatically excuse me add that
tile to the console and it will contain
the latest information that you had for
Chicago so you're not having to go back
and forth and we can figure it that data
can be sent along and persisted across
from from different elements of the
central framework sorry the next part is
notices and this is another kind of
screen shot of some current prototypes
of what we think notices will look like
and basically you'll have this kind of
information about each application so I
basically want to say tell me when the
animatrix DVD comes out and it'll come
up and say the Animatrix DVD is out so I
kind of notice it'll open up that
application and give you all the data
maybe you could buy the DVD you could go
check out get all the latest information
so it's really giving you kind of
up-to-date the latest information and
they can be triggered and those are all
triggered by events within an agent and
the last part is the application shell
which is kind of your primary
representation of where you build an
application inside Central and it's
where not only your application resides
but the end user where they store their
collections of applications so if
they've gone all over the web and they
found a whole bunch of applications they
like that's where they're always going
to go to get them that's where they
launch their applications that's where
they find new applications and we
provide api's within that for changing
the window size the position of it
getting the events from the user when
they resize the window so you can deal
with layout getting the information
about when they're typing certain
keyboard events so you know the index of
your tab ordering the other information
over the status bar preferences knowing
when the window opens and closes you
also have notification as to when the
network connection is lost or or open so
if you want to build an application that
runs both online and offline but you
want to make sure that it gives the user
some notification of that or you
instead of going and querying a web
service you're querying local data you
can first check and see if am I actually
connected to the web with a single call
without having to kind of do that
yourself as you would have to do inside
of a web browser and you can also deal
with setting notices agents and creating
and these ten removing tiles so after
you've gone and through and done all
this stuff and you've built a full
application thinking next thing you want
to do is you want to package that up so
that you can distribute it on the web
and the way you do that is you build
kind of what's called an installer Swift
can we give kind of a basic framework
for how to do this this Swift resides
inside the inside of your website or any
website where you want to distribute
your application and basically it points
at a product XML file which describes
what your application is where it comes
from the dimensions of it all that kind
of metadata about it and when you click
on the install button it reads that XML
file it then kind of sends a message if
it's a player saying do they have the
central runtime if I don't it goes and
downloads it puts it on their machine
app launches it runs it and all of a
sudden comes up your application focus
forward and you know if you want
immediately will be there for them to
use and that's the entire installation
process it's very straightforward and
easy to do and you can build whatever
user interface you want for the
installation process because all it is
is a flash movie that's triggering some
native events with inside flash and you
can also basically if you don't want to
do it yourself and you want to get a
larger distribution you can say this is
my application put it up inside the
macromedia at finder and everybody who
comes to macromedia calm the millions of
people every day and go and check out
your application and you won't have to
worry about being the one that's
distributed in it it's going to be
entirely distributed by macromedia the
next major part is the user interface
component so this is something that's
kind of been involving pretty rapidly in
the last year or so with with macromedia
and with with flash is people are trying
to not just build animation any more
than at just building simple multimedia
they're trying to actually build real
applications that have the kind of look
and feel of an operating system and
behave the way people
spect so part of that was our first
initiative to build components and user
interface frameworks to make that
possible and so part of that we give you
a bunch of standard user interface
frameworks that you kind of expect so
you don't have to go and build them
yourself and what we call these
frameworks is kind of the name for them
as halo and halo kinda gives you a
consistent look and feel across not only
macromedia tools that all the content is
built using them and so you don't have
to go and kind of do that work and all
these things are hosted by macro
mediacom in a in a runtime shared
library runtime shared libraries are
rather than having all the assets inside
of your Swift file are coming from a
remote location and then instantiated so
rather than you having to go and do that
every time it automatically gets it from
macromedia and rather than having to
download those every single time you
automatically get them and when we
update them and we change them you
automatically get it and it keeps the
sizes your applications much smaller so
you're not having to include the data
for what a check boxes or a radio button
every single time you build an
application so the way you consume in
store data inside central is primarily
via XML and that's something that has
been in the flash player for several
revisions but has been focused and
improved upon over the last two releases
and in Flash Player six and in the
central and player we've add significant
performance enhancements to make XML
data retrieval and manipulation much
faster and much much more the best way
to do things that I've been dealing with
kind of native objects inside flash
which can be cumbersome and we also have
given you native web service support so
that you can take structured XML data
that you're getting from a server from
the server and then do something with
its intelligent and then you can take
that data store it inside of a local
shared object and then the final thing
that I refer to before was that you can
now cash that data locally on your
machine so it can be anything it can be
an image jpg a video and you can store
it locally so someone want to download a
movie and watch it you don't have to
download it every single time you can
say cash that thing once it's finished
downloading next time they come on if
they're online or offline it's going to
give them that data
so now I want to kind of show you I
think I believe yeah i'm going to show
how you actually built something for
this i was going to kind of step through
what the basics are and then show you
some code examples inside the authoring
tool so the basics of building something
inside central and some of you may be
familiar with how you build applications
inside flash is you basically want to
build inside the first frame of your
movie you're going to be putting some
action scripts the first thing you do is
you kind of tell central where i am who
i am that i am a central application and
that I expect to be getting messages
from the from the overall central
framework rather than just me being a
web application you kind of have to tell
it via this kind of initialization
operation you say you know I'm so I'm
inside central please start giving me
messages and and once you are finished
getting those messages and you are fully
loaded inside of the central environment
central is going to call you with a
function called on activate and that's
basically going to tell you I'm fully
loaded inside of central you can now do
whatever you want have fun so for
installation what you have to do is you
have to create a product XML file one
that or you can modify one from the
development kit you place your apps with
your product XML your icons and your
installer on one on your server and you
make sure they're all in the same
directory or using relative path and
then you basically click on that button
install it and they get put into sight
of the central environment I'll show you
how that works shortly and another thing
is like I've discussed it for a local
connection is really something that you
want to be able to you know kind of
learn how to use and become more
familiar with if you're not already and
basically it's a simple API allows you
to open up a connection to another file
so a bit so to another Swift file and
this is kind of a simple example of
someone having a agent that's a stock
agent you want to make connection to it
and you want to call a function that's
called get ticker so that's what
basically is here and and you're passing
it a basic argument and this allows you
to communicate between your application
and the agent
your application in a tile or between
the tile and the agent all of that
communication goes over local connection
you can also use this a debug so if you
want to actually have information being
sent to another window basically saying
the kind of state of your application
that is not something visual you can use
it for debugging as well so in order to
add a tile here's some information about
how you add a tile inside a flash
basically you create a new swift that
represents your tile you set up the
phone call the same way as you did
inside of the first application you say
like basically initialize this tile
central goes initialize it calls back
saying okay you're done you're loaded
now do whatever you want to do on
activate very similar to how you build
an application and you install basically
you add a line about the fact that this
tile exists inside your product XML and
you can have as many times as you want
for application so tiles so here's some
examples of things you might want to use
tiles for you want to use them for live
monitoring of push data such as courage
stock prices current scores any type of
persistent constantly updating data and
you can use it to get you know a subset
of an application of functionality
rather than rather than having to go
into the full application you want to
give just a little bit information about
like my latest calendar data that's
where I can show it to you rather than
having to launch the full app some ideas
of what not to use tiles for they're not
necessarily the main application they're
not always going to be the best way for
you to interact entirely and you don't
want to make it so that you are
constantly trying to be the number one
tile you're always kind of pushing
people are pushing other tiles around
you want to make sure that this is kind
of a an environment where you're not
going to object with the user's
environment you're going to make it so
something that people want to use and
want to have there all the time and you
basically you don't want to use it for
notification because you're going to use
that what you're going to use is agents
and notification to do that and
basically to add a agent the same kind
of stories same thing you basically
initialize an agent given on activate
and you add it to your product XML same
thing use agents for persistent
monitoring of data and this is the
actual data set that you're getting from
that you're going to be giving to your
tiles and out
locations the actual tiles are more like
the view and this is kind of the model
like going back and forth and the
controller that's kind of giving you all
that data and it's pushing it into a
tile or it's pushing it into an
application and you can also use agents
for communications with other apps not
only apps inside central but asked
inside of a web browser as well you
don't want to use them for processor
intensive tasks because these type of
things like things like iterative
functions that are going over and over
because the user can't see these things
they're going to be running if you
create some slightly you could be
creating an invisible process that is
slowing the entire machine down and the
user has no way to stop it without
quitting Central and you're basically
going to muck up the entire environment
so here's a little bit of code about how
you actually would create unnoticed and
basically you create a new notice object
and within and this is basically a call
back from the notice manage the agent
manager that basically says you know
this isn't what this is basically going
to say I'm going to add a notice that
says this data saying this is really
simple it's just saying I notice came up
and it has no data in it so this is a
really simple thing it's not actually
giving you anything it's just a kind of
core framework for how you actually
create a notice and you want to use them
to notify users and you don't want to
use them to display errors and only use
them to display connection notifications
like 4440 fours and you want to be
polite with them you don't want to be
constantly coming up with notices you
can also create custom preferences with
inside of your application so if you
want to be setting certain particular
information about your application and
make it so people can configure notices
configure tiles configure what all the
kind of persistent things that they have
no control over you want to give them a
way to visually do that and as a full
you know kind of framework for how you
do that with inside central and you
don't want to use preferences to create
references that are already done by
central essential already has kind of a
core preferences where you can set up
global things like your location and
your information and that information is
then persistent and available to you so
once the user defines their name and
information you can query that and get
their email address and all
if they've made that available to you so
offline data management I've said this a
little bit before stem was shared
objects and each application has a limit
of 100 k in the taken store for their
application if you want to store more
than 100 k if it comes over the dialogue
and says this application wants to store
more do what to allow it and basically
that data kind of sits persistently on
the hard drive and never goes away and
it's basically best for the kind of
internal data that you're storing that
you want to make sure that always comes
up in the type net applications loaded
and stored in kind of in a textual way
local internet URLs is basically
anything that you can pull off the
internet you can store you can even pull
things down that aren't even readable by
flash so it's kind of it's a very open
way for you to cache data and cache
information and there's a limit of how
much you can store it by default the 20
megabytes same story with if you go over
that limit it's going to warn you say
you know this application is trying to
request more data than you need and you
currently have set and you want to allow
that and this is a short example short
explanation of how that API works it
downloads it begins once you call it
immediately starts making that call you
can access it through normal
ActionScript message saying is this
loaded when it's done do something with
it so it's the same way that you deal
with any type of a loaded data same way
you deal with loading XML say no you
still loading an image inside flash the
same way you deal with that inside of
Central so if you know how to do it in
flash same exact skills and just kind of
telling you basically in the first beta
each request is a new HTTP stream and
basically in beta 2 we start queuing
that up like the browser does it's
important also to show that your
application is requesting data because
it's not something that we automatically
come up with a progress dialog and say
you know you're downloading a bunch of
data so your application may seem like
nothing's going on you need to make sure
that you actually are showing progress
of your application and giving the user
free back and we're actually we do
provide a p is for you to set some
information in the
that is bar that of the current status
of your application how much is loading
what's going on and we really encourage
we use that to give the user kind of a
consistent method of feedback rather
than you having to do that every single
time yourself offline behavior talked
about this a little bit already you
basically will get a call back and
you're going to check to see whether or
not that the network has gone online or
offline and you can use that to properly
set up your application to make sure
that when that callback gets notified
that you either switch to using local
data or you make sure that you're not
making requests to the server side it's
fairly straightforward and sharing data
between apps you're going to be using an
agent server local connections and
updating your application is very
straightforward all you have to do on
your server where you have your product
XML increment your version number from
one to two or any any number above every
week the central environment down the
person's machine will go and check that
product XML if the number is greater
it's going to go and download your new
version so all that kind of update
functionality that's fairly difficult to
deal with is all handled by the
environment itself so now I'm going to
switch over to the computer and show you
how to build a really simple application
okay first thing I'm going to do is I'm
going to open up the flash authoring
tool and I'm going to open up a simple
application here so this application
here is very very simple application all
it does is has two text fields and n 2
button and the way that you do that
inside flash if you want to add text
fields or buttons as basically you have
one second here you have a text control
here and you can basically dragged out
and create new text fields as you please
and then you can define them give them
instance names everything you want to do
so I already have two created here one
is input text and want to stock info
that's right right here is define their
instance name so that's how I'm going to
access it via ActionScript to know how
to give it information how to change it
and i also have to push buttons
components here one is going to actually
make the request to get the stock
information and this one is going to
like just test that I've properly
created the notice and you can see that
I've also given both of them instance
names when you add new components as you
over here you have the Flash UI
components panel and you can simply
click and drag new user interface
elements and we give you a bunch of
pre-made ones for central they give you
that look and feel and have all the kind
of proper functionality for you deal
with remote shared library so you don't
have to deal with any of that work so if
i go over here into the first frame of
my movie and I open it up and say
actions I can see all the script that
makes up this movie and explain it to
you Hanson and everybody see that I'm
right there actually
terms of the far side
so basically the first function that
you're going to have here is called on
activate and this is what gets called
when your application has been fully
loaded into the central environment
basically you get a callback that
basically gives you a shell object and
that she'll object contains all the
api's that make up central so when
you're inside this environment you
always refer to where you live as the
shell and in this particular example the
first thing I'm going to do is I'm going
to add an agent and that agent is the
stock checker so inside of the product
XML I defined a stock stock checker
agent and I can refer to it now within
my script within the in scripting
environment and say add that agent and
that agent is another Swift file which
I'll show you in a second and basically
I'm referring next thing i'm doing here
is i'm referring to the button that I
named here which is the ticker symbol
which is basically going and checking to
see if as a new ticker symbol and
telling that button when I when it's
released it's going to make a new local
connection and it's been going to call a
function inside of the agent call it
where it says to app underscore agent
called get stock so it's basically
saying to the agent call a webservice
method that's going to get the stock
data and then it's going to return it so
that information I'll strong a second
here if I go through this and this is
basically all of the information for
displaying that data so once i get that
data back i'm going to then take that
text field and fill it with data that i
got back from the local connection which
is what this is your stock info text the
text value of that stock info text field
i'm going to give it the value of the
price of the stock that I got back from
low service and right here this do test
notice button is when i click on the
test notice it's going to actually go
through the process of adding a new
notice and giving a really simple notice
it just says new test notice and this is
kind of all the different properties of
that notice whether or not it's going to
show an alert in the tray
and whether and this is basically
setting the progress excuse me the
progress bar at the bottom of the shell
and this is a same thing if I get a
notice event I'm going to set the
progress bar to be back to way it was
and also there's a little example here
of the actual logo that I'm using inside
it here is a little central logo I'm
saying take that thing first time it
loads up add it to my local internet
cash so I can give it any type of path
to a file and we'll store it locally on
my machine and then in the future all
you got to do is refer to that pertain
path and if it's locally cached already
rather than fetching it from the web
it's going to fetch it from my cash
first so it's always whenever you do a
load movie call and flash rather than in
the way it was in flash where I would
always go out and fetch the data the
first thing it does is it checks the
local internet cache and then it goes
out to the web and then the final call
here is basically saying that this is
the first thing is going to be called
when the application is first loaded is
going to say hello I'm an application
call me back in a second when I'm loaded
so that's enough the application so when
you actually build an application in
flash so now I have to actually publish
this movie and so I'm going the same
export movie which is going to take this
with file and export it and I'm going to
export it so now it created that movie
it's not going to run inside the
environment so what I want to do now is
take that actual application and then I
want to install it into Central so way I
do that is I have this this saber Swift
that I've created and basically inside
of that favor Swift i define the path to
the product xml that defines its
application so if i open up this it
shows the product xml for this very
simple empty application it just says
you know what the version of it is
what's the information about it who made
it what's the name of it whereas where
is this icon and also like where is the
source of this application the primary
application is called empty underscore
apt up for it which is what I just
created and i also have defined that
I have an agent and a tile and so
basically what i have now is i open up
this savory HTML and click Save it goes
and launches central
and it will go and ask me do I want to
install that application and it uses all
the data from the product XML saying
this is a virgin this is the version of
it and what domain it came from i could
say okay it now installs it so and then
immediately takes me to that application
so here's the application if I have so
when that application first started is
actually also initiated an agent so I
can right now I should be able to say
give me the current stock price of
macromedia it's going to go out talk to
that agent get some data from a web
service and return it back to this text
fields here assuming that I did it
correctly so the first thing we're going
to do is this application doesn't have
the right to do that under our security
model so it's going to come up and say
so I want to allow my local machine to
access this URL so I'm going to say yes
allow it to do that or I can tell it to
always allow that and then if it's
allowed it's going to make the request
come back and then feed that data into
this text field
absolutely what do their goes so there's
the current macromedia stock price so
that's basically a very simple
application that I built so let me show
you really quickly how the actual agent
was built so if I open up this app agent
flaw this is the one that's being called
by the local connection in the other
movie basically it says it's the same
thing i was showing before the way you
build it easy say on activate when this
thing gets loaded it gets a call back
with the agent manager it's going to
start an interval which is set interval
it's going to say recursively go through
and say load some data for me from the
server and make a local connection to
that up to the application that created
it it's going to make a web service call
so this is the api's that have been
added to flash rather than in the past
you have to kind of do it yourself you
can now directly make call a webservice
you just say new web service give it a
Wizzle file and that will come back to
you with a objected has all the
callbacks of that wisdom file so you to
say stock service that do company info
which is the callback of that web
service you give it in this one in
particular has a user ID and password of
user in a user any password give it a
ticker symbol that I entered in that
text field call it when I get a result
back the same way as you deal with any
result from an XML file I'm then going
to send that local connection back to
flash into the other movie from the
agent into the the hosting application
and I'm going to say call the function
received ticker with the current price
and that's the the other function that
they had inside there was called receive
ticker that then receives the data puts
it in a text field so that is basically
a very simple stock ticker application
and if I want to also in that
application i can say test notice so
there i just added a new notice it if i
had sound you could hear it you can also
see that the doc item bounced for a
second and i get notification basically
through the operating system as well and
right here on notice keep up staying
here in New test notice that's the same
notice information that I set up inside
the application goes and does that go
through the framework uses the same data
that you set in there so there we are
I'm also have an advisory that Homeland
Security has been gone to elevate it so
that's how you build the basic elements
of central and from there you can build
the whole wide range of application and
those are kind of the really basic
things so can I go back to the slides so
I think given that basically want to
give you a quick idea of where the state
of the project is currently like Dave
said we're in beta we just got beta
through today after a lot of work and
we're undergoing a lot of kind of
usability and interface looking feel and
like figuring out the best way to do
this and we're going to have a public
release of the SDK and the environment
for all people to develop for this in
the end of the summer 2003 and we're
going to launch the platform for end
users towards the end of the year and if
you want to get more information about
this you can go to the macromedia
central development center and which is
listed up here or you need to go to
macromedia calm and look up central and
that's where you can sign up for this DK
and here's our contact information and
for information all in here so if you
have any questions