PDF generation is supported by Adobe LiveCycle and LCDS, as well as other server-side products. Suppose that you have a Flex or AIR window with a number of UI controls, and you want to create a PDF out of it. One option is to create a snapshot of the Flex component or container using the class mx.graphics.ImageSnapshot and its function captureImage(), which can scale the image to a specific resolution and encode it into a specified image format. You can send an instance of this class via RemoteObject to the server with LCDS installed. LCDS then creates a PDF document (or merges it with a PDF form) and includes the new image received from the client.

The problem with this approach is that the resulting PDF will not be searchable. For instance, if a Flex Panel has text fields, you won’t be able to find the text of these fields in Acrobat Reader if the Panel is embedded as a bitmap.

Such PDFs have limitations on resolution as well (to create a PDF with resolution 300 dpi, you’d need to create a multimegabyte image). Also, printed materials often use different CSS and metrics from the screen ones. You don’t want to print, say, a background gradient that looks fine on the monitor, but bad on paper.

To embed forms into PDF documents, Adobe uses the XDP format. If you purchase an LCDS license, you’ll have the option to use it. You can design forms in Acrobat Designer and export the data from your Flex view, and LCDS will merge the data and the form on the server. On the Java side, LCDS adds several JARs in the lib directory of your web application, which makes the XFAHelper Java class available for your server-side PDF generation.

After generating the PDF, the server-side program can be:

Depending on the business requirements, the server-side PDF generation might not be feasible. You might have just disconnected the AIR application, or the server software may not have any of the technologies supporting PDF creation installed. If the Flex UI is truly dynamic, that might change the number of displayed components based on some business criteria; developing an additional UI in Acrobat Designer just for printing can in these ways become either impossible or time-consuming. The LCDS Developer Guide describes this process in the document called “Using the PDF Generation Feature”.

In general, for server-side PDF generation from Adobe Flex applications, you have to do the following:

Although this process provides guaranteed quality and predictable results, it also requires the double effort of developing XDP forms for printing and Flex forms for displaying. Besides, LiveCycle Designer is another piece of software that application developers in your organization may not be familiar with.

LCDS generation with merging data and forms produces good printing quality with LCDS. The Flex client sends data as XML to the server along with the name of the form file (template) to be used for merging, as shown in Example 11-2. In this case, the LCDS layer just needs to process it with the XDPXFAHelper class and return it as a PDF stream to the browser for displaying.

The ActionScript class FormRenderer sends generated XDP to the server and opens a web browser’s window to display the PDF when it arrives from the server.

import flash.net.*;
import flash.utils.ByteArray;

public class FormRenderer {
 public static function openPdf(xdp:String, target:String="_blank"):void{
   var req:URLRequest = new URLRequest("/createPDF.jsp");
   req.method = URLRequestMethod.POST;

   var ba :ByteArray = new ByteArray();;
   ba.writeMultiByte(xdp, "iso-8859-1");
   ba.compress();
   ba.position = 0;
   req.data = ba;
   navigateToURL(req, target);
 }
}

You also need an XDP file with the data and presentation. If you don’t have LiveCycle Designer, you can make the XDP file programmatically, ensuring that it matches the printer’s paper size and corporate stationery. XDP documents are XML objects, which are easily processed in Flex using E4X syntax, for example:

Because original Flex components don’t know how to represent themselves in the XDP format, you’ll need to teach them to do so. This becomes the next task in enhancing Flex components.

For example, each UI component can implement some interface (e.g., IXdpObject with the only getter, xmlContent()) that allows it to return its own XDP content or, in the case of containers, to traverse the list of its child components for their XDP content. For example, a new panel component (PanelXdp) may have the following structure:

public class PanelXdp extends Panel implements IXdpObject{
    public function get xmlContent():Object{
       // The code to return representation of the panel
       // in the XDP format goes here
    }
}

Repeat the process of attaching XML to the XDP template using E4X until all print pages are ready. This method of printing from Flex requires less effort for reporting and creation of dynamic layouts. It might also provide better printing quality and searchability within the printed document.

Example 11-3 is the server-side part written as a Java ServerSide Page. It uncompresses the XDP stream received from the client, creates the PDF using XDPXFAHelper, turns it into an array of bytes, and sends it back to the client as the MIME type "application/pdf".

<%@ page language="java"
   import="java.io.*,
   java.util.*,
   javax.xml.parsers.*,
   org.w3c.dom.Document,
   flex.messaging.*,
   flex.acrobat.pdf.XDPXFAHelper,
   flex.messaging.util.UUIDUtils,
   org.w3c.dom.Document
   "
%><%!
private static void _log(Object o){
   System.out.println(""+o);
}
private String getParam(HttpServletRequest request, String name, String defVal)
throws Exception{
       String val = request.getParameter(name);
     return (val!=null && val.length()>0)?val:defVal;
}
private String getParam(HttpServletRequest request, String name) throws Exception{
   return getParam(request, name, null);
}
private void processRenderRequest(HttpServletRequest request,
                        HttpServletResponse response) throws Exception{

   String data      = getParam(request, "document");
   String template = getParam(request, "template"); // Security hole, check path
   _log("template="+template);
   _log("data="+data);
   template = FlexContext.getServletContext().getRealPath(template);
   _log("template real="+template);

       // You must have LCDS license to use XDPXFAHelper
   XDPXFAHelper helper = new XDPXFAHelper();
   helper.open(template);
   // Import XFA dataset
   if( data!=null ){
      _log("data.length="+data.length());
      ByteArrayInputStream bais = new
                        ByteArrayInputStream(data.getBytes("UTF-8"));
      DocumentBuilderFactory builderFactory =
                                    DocumentBuilderFactory.newInstance();
      DocumentBuilder builder =
                                    builderFactory.newDocumentBuilder();
      Document dataset = builder.parse(bais);
      helper.importDataset(dataset);
   } else
      _log("data="+null);

   byte[] content = helper.saveToByteArray();
   _log("content="+content);
   helper.close();
   ServletOutputStream out3 = response.getOutputStream();
   response.setContentType("application/pdf");
   response.setContentLength(content.length);
   out3.write(content);
}
%><%
_log("");
_log("--------------------------------------------");
_log("render.jsp");
processRenderRequest(request, response);
%>

Now we’ll take a look at how to generate a PDF on the Flex side.