Many of the collaboration workflows in Acrobat (for example the Review Initiation wizards) are developed in JavaScript because it's a more rapid development environment. As a result, we are also a customer of the JavaScript APIs that we add and the new Net.HTTP object is a good example of this.

Reader uses the Mozilla Spidermonkey JavaScript engine (it's also used by the Firefox web browser) and they recently added support for E4X - ECMAScript For XML. It allows you to imbed XML directly in your JavaScript, parse XML to a DOM, manipulate an XML DOM and serialize a DOM back to XML. E4X is also supported by the Flash Player ActionScript engine since version 9.0.

In the past, creating XML messages in JavaScript involved concating strings together like this:

var msg = "This is a bad way to generate XML!";
var myXML = "<element>" + msg + "</element>";

Things get more complicated because you need to entity encode the string to make sure it is valid XML and if you want to manipulate the XML later, you would need to write an XML parser. By contrast, with E4X you can use an XML "template" that will substitute in JavaScript values:

var msg = "This is a better way to generate XML!";
var myXML = <element>{ msg }</element>

var dogML = <dogs>
   <dog gender="male">
      <name>Rover</name>
      <breed>Labrador</breed>
      <color>black</color>
   </dog>
   <dog gender="male">
      <name>Spot</name>
      <breed>Jack Russell</breed>
      <color>brown</color>
   </dog>
</dogs>

// Access the DOM with JavaScript expressions
console.println("Name: " + dogML..dog[0].name);
console.println("Color: " + dogML..dog[1].color);

for each (var h in dogML..breed)  // Iterate over an XML Element
{ 
  console.println("Breed: " + h) 
};

// Evaluate a predicate over the DOM
console.println("Rover's Color: " + dogML.dog.(name=="Rover").color);

// Serialize back to an XML string
console.println("XML: " + dogML.toXMLString());

Name: Rover
Color: brown
Breed: Labrador
Breed: Jack Russell
Rover's Color: black
XML: <dogs>
   <dog gender="male">
      <name>Rover</name>
      <breed>Labrador</breed>
      <color>black</color>
   </dog>
   <dog gender="male">
      <name>Spot</name>
      <breed>Jack Russell</breed>
      <color>brown</color>
   </dog>
</dogs>

Alright - you get the idea. There are lots of tutorials about using E4X - I've put some links at the end of this article. One important thing to keep in mind when adding JavaScript to PDF documents - E4X language features cannot be processed by pre-8.0 Acrobat / Reader so Document JavaScript using E4X will most likely not run in older versions.

HTTP Networking support

Much like the varous XMLHttpRequest objects in the browser, Reader now has support for asynchronously invoking Web Services using HTTP. It works more or less as you would expect and is an extension of the SOAP support that has been in Acrobat for a while. The Net.HTTP.request() method allows you to specify the HTTP verb, the request headers and the body and will return the response headers and response body. For security reasons, this method is only available when executed outside of a document (such as the JavaScript console, a JavaScript .js file or a Tracker application) - the intention is to make it possible to extend Reader / Acrobat without resorting to writing a C++ plugin.

As a real world use case, here is an example of invoking the WebDAV PROPFIND method on a web server. PROPFIND is an request for the contents of a WebDAV collection - it more or less asks for the contents of a directory with various properties of the contents.

var EnumerateCollection = function(cURL)
{
    var params = 
    {
        cVerb: "PROPFIND", // Use the WebDAV PROPFIND Verb
        cURL: cURL,
        oHandler: // This is the handler for when the response is returned.
        {
            cURL: cURL,
            oBaseURL: util.crackURL(cURL),
            response: function(response, uri, e)
            {
                try
                {
                    if(e != undefined)
                    {
                        console.println("An error occurred: " + e);
                    }
                    else 
                    {
                        console.println("PROPFIND of " + cURL);
                        
                        // We get passed a stream object - convert it into a string
                        var string = util.stringFromStream(response);
                        
                        // E4X only parse XML fragments so we have to remove the
                        // XML Declaration
                        var xmlDeclMatcher = /^<\?xml version[^>]+?>/; 
                        string = string.replace(xmlDeclMatcher ,'')
                        string = string.replace(/\n/g ,'')

                        var msg = XML(string);

                        // WebDAV responses are all in the DAV XML Namespace so
                        // we when we refer to a node, we need to use the XML QName
                        var ns = new Namespace("DAV:");
                        var responses = msg..ns::response;

                        for(var i in responses)
                        {
                            var resp = responses[i];
                            var prop = responses[i].ns::propstat.ns::prop;
                            var resource = {};

                            // ensure that the resource URL begins with the base URL
                            var href = resp.ns::href;
                            // A better check here would be to parse the URL 
                            // and check it's scheme
                            if(href.charAt(0) == '/')
                            {
                                // This is a relative URL so append it to the base URL
                                with(this.oBaseURL)
                                {
                                    // Relative to base href
                                    resource.url = cScheme;
                                    resource.url += "://";
                                    resource.url += cHost;
                                    if(nPort != undefined)
                                        resource.url += ":" + nPort;

                                    resource.url += href;
                                }
                            }
                            else
                            {
                                // Absolute URL
                                resource.url = href.toString();
                            }

                            // Extract properties from the resource element
                            resource.displayName = prop.ns::displayname;
                            resource.lastModified = prop.ns::getlastmodified;
                            resource.contentLength = prop.ns::getcontentlength;
                            resource.contentType = prop.ns::getcontenttype;
                            resource.etag = prop.ns::getetag;
                            resource.type = prop.ns::resourcetype;

                            if(resource.url == this.cURL)
                            {
                                // Don't include the collection we want the contents of
                            }
                            else if(resource.type.ns::collection == undefined)
                            {
                                console.println(resource.displayName + " / " + 
                                resource.contentLength + " bytes / " + 
                        resource.contentType);
                            } else console.println("/" + resource.displayName);
                        }
                    }
                }
                catch(e)
                {
                    console.println("EXCEPTION: " + e);
                    e.printStackTrace();
                }
            }
        },
        aHeaders: // HTTP Request Headers
        [
            { name: "Depth", value: "1" } // Set the depth so it's not recursive
        ]
    };

    Net.HTTP.request(params); // Invoke the service asynchronously
}
EnumerateCollection("http://example.org/webdav/");

You can run this code (with your own real WebDAV server URL) in the Acrobat JavaScript debugger. I used an Apache Tomcat server and it produced the following:

PROPFIND of http://example.org/webdav/
/SubCollection
Sample.xml / 2106 bytes / text/xml
Sample.pdf / 285856 bytes / application/pdf

In this case, there were three items in the WebDAV collection:

You could use the Net.HTTP.request() method again with the HTTP GET verb to download one of these file into Acrobat.

Resources

• Mozilla presentation on E4X support in Firefox / Spidermonkey
• A tutorial on getting started with E4X
• An article on using E4X in ActionScript
• Using XML Namespace with E4X and ActionScript
• How to parse XML Documents with E4X
• E4X FAQ
• Wikipedia E4X page

UPDATE: Removing the OS X Login Item is a little tricky because the Self Heal code that repairs the Reader install puts it back. See the note at the bottom of this post about how to disable self heal for this part of the install.

When does it run?

One of the design goals of Synchronizer was to make it as unobtrusive as possible for users especially when it is not needed.

• Synchronizer runs briefly on user login - if there is nothing to synchronize then it will exit immediatly.
• Synchronizer will run in the background if you are participating in a Shared Review or add a subscription to the Tracker.
• Synchronizer runs while Acrobat or Reader runs if you participate in a Shared Review or use specific features such as the Reviewing preferences panel or Tracker.
• Synchronizer will not run if you remove all Shared Reviews and subscriptions from the Tracker.

What does it do?

The Adobe Synchronizer is a networking agent that is used to build disconnection tolerant applications. The Synchronizer provides a local copy of data on a server so that applications can utilize it regardless of network connectivity. As data changes on the server, Synchronizer updates the local copy and as the user publishes changes made locally, Synchronizer makes the modifications to the server. If the client is disconnected from the network, Synchronizer will continue trying.

• Shared Review Workflows - Synchronizer sends and receives document comments and metadata in an XML file format (RSS 2.0 with some extensions) to a shared review location - either a Network Folder, a Sharepoint workspace, or WebDAV server.
• Review Tracker Subscriptions - The Synchronizer fetches any RSS / ATOM subscriptions that you add through the Review Tracker including attachments (such as in a PDFCast).

Where is the Synchronizer data stored?

Synchronizer stores a local copy of the data in your Acrobat user data directoryusing a combination of a small database (SQLite) and the filesystem.

On Windows, data is stored here:
C:\Documents and Settings\<USERNAME>\Application Data\Adobe\Acrobat\8.0\Synchronizer

On OS X, this is:
~/Library/Acrobat User Data/8.0_<ppc or x86>/Synchronizer

How do I make the Synchronizer Stop Synchronizing?

Synchronizer will no longer synchronize shared reviews or subscriptions once they are removed from Tracker. Once there is nothing to synchronize, it will no longer run in the background.

Stop Tracking Shared Reviews

To stop tracking a Shared Review, open the Review Tracker ("Comments->Review Tracker" menu). Click on the first tab item in the left-hand tab pane. Right click on the document that you no longer wish to track and select "Remove From Review Tracker". If you want to resume tracking the review, just open the shared review document again.

Removing a Subscription

To remove a subscription, open the Review Tracker ("Comments->Review Tracker" menu). Click on the "RSS" tab in the left pane. Right click on the feed you'd like to unsubscribe from and choose "Remove"

Remember, removing all RSS feeds and Reviews from the Review Tracker will cause Synchronizer to stop the next time you quit Acrobat or Reader. Alternatively, you can delete all of the folders described above to accomplish the same thing. IMPORTANT - this DELETES all of your local Review and RSS data. It is a permanent operation that cannot be undone.

UPDATE - Removing the OS X LoginItem permanently

Things are a bit more complicated than we initially thought - if you remove the LoginItem the code that repairs the Reader install will put it back. Until this is fixed, here's how you can work around the issue. Note that this will prevent all synchronization of RSS and Review data using Synchronizer while Reader is not running. Also note that this is an unsupported work-around, so you're mileage may vary. Please backup the file we're modifying before you edit it!

1. Close Reader
2. Navigate to /Library/Application Support/Adobe/Acrobat/ on your boot drive
3. Back up the RdrENU80SelfHeal.xml file to some other place. (ENU refers to the English version of Reader so it may be a different name if you are using a non-english version)
4. Open the RdrENU80SelfHeal.xml file in a text editor
5. Search for AdobeResourceSynchronizer.app. You should see a section that looks like:
   
   <key>from</key>
   <string>Contents/Support/AdobeResourceSynchronizer.app</string>
   <key>isappassociated</key>
   <false/>
   <key>iscolorprofile</key>
   <false/>
   <key>isinstalled</key>
   <true/>
   <key>isloginitem</key>
   <true/>
   
6. On the line after <key>isloginitem</key>, change <true/> to <false/>.
7. Save the file
8. Remove the login item from the Accounts System Preferences
9. Launch Reader. You should no longer have the login item added on restart of Adobe Reader.

This post was written by the Adobe Synchronizer team - Steve Dakin, Barnaby James and Pat Wibbeler

Shared Review files can be distributed any way you want—website, e-mail, document management system, network share drive and so on. Browser-based review files can only be distributed via a website (hence the name). The new shared-review infrastructure is no longer dependent on the location of the document. The path to the comment server is baked into the document when you send it for review, so you can open a document in a web browser, make comments, save it to your desktop/open Acrobat, make more comments, save it and then email it to someone else—in all cases, the review will "just work." This also means you can use the review document with a content management system that Adobe doesn't support (like eRoom) because you can just upload it like any other file and it will just work. Shared review works in the browser or in stand-alone Acrobat. And because each review has a unique review ID, you can send the same document for review multiple times (for example, if you wanted to have different sets of reviewers).

Acrobat 8.0 introduces a new method for document reviews called Shared Review. In previous versions, Acrobat has supported two types of reviews - email reviews and online (or browser-based) reviews. Email reviews require the initiator to distribute the document by email and reviewers send their comments back - it works fairly well for small groups of people because there are no configuration issues (for the most part) but the only reviewer that sees my comments is the initiator.

Online reviewing, by contrast, uses a central comment store (usually some kind of WebDAV server or Network Folder) for comments and the document is viewed in the browser. The review is tracked by the URL of the document which sometimes caused problems and configuration was difficult but all of the reviewers can see each others comments as they are made.

For Acrobat 8.0, we looked into the problems that customers were encountering with the existing reviewing options and the type of network infrastructure that is commonly available. Shared Review is designed to take the best aspects of email and online reviewing and improve the whole experience - the idea was to make the whole review process robust.

• Reviewing works independently of how the file is distributed - you can open a review in the browser, save it locally and email it to someone else and it will just work.
• Setting up a shared review location and initiating a review is much easier than for online reviewing.
• Reviewing a document can be easily used when disconnected from the network.
• Review files can be enabled to allow Reader 8.0 users to participate (this requires Acrobat 8.0 Professional).
• Changes in the review since the last time the review was opened are tracked - for example, new reviewers and new comments.
• When reviewers cannot connect to the review location (for example, a reviewer outside your firewall) are automatically routed into an email workflow.
• Reviewer comments are stored as an RSS 2.0 file (a common XML format) with some extensions to make it easy to extract information (for example, to integrate the comment workflow with a server side application).

When you initiate a shared review, you specify a location for your comments (either a Network Folder, a WebDAV server or a Sharepoint Workspace) which is baked into the PDF so that whenever the document is opened, it will know where to locate the comments. Because of this, you can distribute the file anyway you want - through email, upload it to a content management system or put on a server (possibly to be distributed as a PDFCast). As with email reviews, Acrobat 8.0 Professional is able to Reader enable a shared review document so that anyone with Adobe Reader 8.0 will be able to participate.

When a participant receives a shared review document, the first thing they see is an opt-in dialog - a shared review needs to be able to talk to a commenting server and we need permission from the user to do this. If the user agrees to participate, the welcome dialog is shown which indicates the current state of the review since the last time the document was opened - how many new reviewers have joined, how many new comments have been made.

Participating in a shared review creates a subscription relationship between Acrobat / Reader and the comment server so comments are synchronized as changes are made. A utility called the Adobe Synchronizer copies new comments from the review location and publishes your comments in the background. The Synchronizer handles network disconnection by keeping a local copy of the review data so you can always work with the most recent version. This allows you to seamlessly participate in a review while disconnected, for example on a long airline flight. When you reconnect to the network, any comments that have been published and new comments from other reviewers will automatically be synchronized with your client.

Connected to the review location	Disconnected from the review location

The review tracker allows you to keep track of the review state for all of the reviews that you are participating in.

Ted Padova has a useful how to article on using the Tracker in Acrobat to read blogs. Many people are surprised when they find out Acrobat 7.0 has an RSS reader in it - who ordered that? While it's true that RSS is most closely associated with keeping up to date with blogs, it can be used for tracking changes in many sources of information - for example workflow notifications, updates to documents, important sets of forms etc. Today, a lot of this information is sent around in email largely because it's universally available - in a lot of cases it's not the best tool for the job. For example, if a workflow item changes state 10 times that might generate 10 notification emails because you can't modify an email once it has been sent. FeedBurner has a report that highlights the potential of using RSS for content distribution.

The Tracker is designed to be a client for this type of information - with RSS you subscribe to a service that publishes this information as a feed. RSS and ATOM are open formats for feeds that can be easily generated using blogs, wikis, social bookmarking tools or just a text file on a server. By using an open format, Tracker can easily integrate with other products - the idea is that end users can just plug things together and they will work.

What's new with Tracker in Acrobat / Reader 8.0

The two big changes in Tracker for 8.0 are that Tracker is now available in Reader and that enclosures are supported. Enclosures are like email attachments associated with each item in the feed that can be binary files (like video or audio). Of more interest to Acrobat / Reader users, this content can be PDF documents that will be automatically downloaded to the local machine when the feed is updated. This is particularly useful for people who are occasionally disconnected from the network or who work with large documents because their documents and workflows are immediatly available when they need them. Some examples where this might be useful:

• A set of forms used within a company (such as PTO and Expense Reports) could be published as a feed that employees can subscribe to. When an updated PTO form becomes available, the feed is updated so that the enclosure point to the URL of the PTO form. This will cause the old form to be removed and a new version downloaded automatically. You could imagine the IRS publishing all of the tax forms as a feed so you always have the latest one when you need it.
• A sales organization can publish documents for marketing collateral and price lists to make sure that all of the salespeople always have the most current version. An example of this type of workflow is Spanning Partners Spanning SalesForce that provides RSS feeds to data within SalesForce.com including documents.
• A service could generate a feed with a personalized set of Shared Review documents that need to be reviewed by specific users. Shared Reviews (like Tracker) have the ability to work completely disconnected from the network.
• A service could publish a feed of documents requiring approval for each user. For example, Approver.com does document approval workflows with RSS feeds.
• Journals / serialized books can be published as articles in a feeds (or you could subscribe to a feed which is a collection of articles you may find interesting from a variety of sources). For example, a law firm could distribute WestLaw and Lexis articles customized to each persons practice area.

I created a sample PDFCast (the term is a derivative of Podcasting) to show how this works - the link below will add the subscription to the Tracker (you need Acrobat / Reader 8.0 for this to work).

Here's a screen shot of what it looks like:

Clicking on the PDF icon on the left or the open button will cause the document to be opened from the local copy of the enclosure. In this particular case, I added some custom metadata to the feed and used some of the customization features of Tracker to group articles based on the value of that metadata. The UI and behavior of feeds in Tracker can be extensively customized - I'll cover this in a later blog post but it's all described in the Tracker SDK.

And for the sake of completeness, ETech was really interesting - well worth going. Audio for many of the sessions is now available from ITConversations - I particularly enjoyed Sam Ruby's Neurotransmitters talk, Eric Bonabeau's talk on Hunch Engines and the Roomba fighting.

Lest you get the impression that I'm some jet setting conference hound, I assure you this is quite a rarity and I spend almost all of my time at my desk writing code! I think the last conference I went to was BloggerCon III. At any rate, if you're going to be ETech and want to talk about Collaboration, I'd be interested in talking to you.

These are the different areas that I'll be discussing on this blog:

• Web Services (SOAP / WSDL / REST) for Messaging


• Service Discovery using DNS Service Discovery


• Customizing Acrobat with JavaScript


• Content Syndication using RSS and the Acrobat Tracker


• Acrobat / Reader Networking issues