|
You can assemble a PDF Portfolio using the Assembler Java
and web service API. A portfolio can combine several documents of
various types, including word file, image files (for example, a
jpeg file), and PDF documents. The layout of the portfolio can be
set to different styles like the Grid with Preview, the On an Image layout
or even Revolve.
The following illustration is a screenshot of a portfolio with On an Image style
layout.
Creating a PDF Portfolio serves as a paperless alternative to
passing a collection of documents. Using LiveCycle you can
create portfolios by invoking the Assembler service with a structured
DDX document. The following DDX document is an example of a DDX
document that creates a PDF Portfolio.
<DDX xmlns="http://ns.adobe.com/DDX/1.0/">
<PDF result="portfolio1.pdf">
<Portfolio>
<Navigator source="myNavigator">
<Resource name="navigator/image.xxx" source="myImage.png"/>
</Navigator>
</Portfolio>
<PackageFiles source="dog1" >
<FieldData name="X">72</FieldData>
<FieldData name="Y">72</FieldData>
<File filename="saint_bernard.jpg" mimetype="image/jpeg"/>
</PackageFiles>
<PackageFiles source="dog2" >
<FieldData name="X">120</FieldData>
<FieldData name="Y">216</FieldData>
<File filename="greyhound.pdf"/>
</PackageFiles>
</PDF>
</DDX>
The DXX document must contain a Portfolio tag with
a nested Navigator tag. Note the tag <Resource name="navigator/image.xxx" source="myImage.png"/> is
only necessary if myNavigator is assigned as the
onImage layout navigator: AdobeOnImage.nav. This
tag allows the Assembler service to select the image to use as the
portfolio background. Include PackageFiles and File tags
to define the filename and MIME type of the packaged file.
Summary of stepsTo create a PDF Portfolio, perform the following tasks:
Include project files.
Create a PDF Assembler client.
Reference an existing DDX document.
Reference the required documents.
Set run-time options.
Assemble the portfolio.
Save the assembled portfolio.
Include project filesInclude the necessary files in your development
project. If you are creating a client application by using Java,
include the necessary JAR files. If you are using web services,
ensure that you include the proxy files.
The following JAR
files must be added to your project’s class path:
adobe-livecycle-client.jar
adobe-usermanager-client.jar
adobe-assembler-client.jar
adobe-utilities.jar (required if LiveCycle is deployed
on JBoss)
jbossall-client.jar (required if LiveCycle is deployed
on JBoss)
Create a PDF Assembler clientBefore you can programmatically
perform an Assembler operation, create an Assembler service client.
Reference an existing DDX documentA DDX document must be referenced
to assemble a PDF Portfolio. This DDX document must contain the Portfolio, Navigator and, PackageFiles elements.
Reference the required documentsTo assemble a PDF Portfolio, reference
all files that represents the documents to assemble. For example,
pass all image files that are specified in the DDX document to the
Assembler service. Notice that these files are referenced in the
DDX document specified in this section: myImage.png and saint_bernard.jpg.
When
assembling a PDF Portfolio, pass a NAV file (a navigator file) to
the Assembler service. The NAV file that you pass to the Assembler
service depends upon what type of PDF Portfolio to create. For example,
to create an On an Image layout, pass the AdobeOnImage.nav
file. You can locate NAV files in the following folder:
<Install folder>\Acrobat 9.0\Acrobat\Navigators
Copy
the NAV file from the Acrobat 9 (or later) installation directory.
Place the NAV file in a location where your client application can
access it. All files are passed to the Assembler service within
a Map collection object.
Hinweis: The quick starts
that are associated with Assembling PDF Portfolios use AdobeOnImage.nav.
Set run-time optionsYou can set run-time options that control
the behavior of the Assembler service while it performs a job. For
example, you can set an option that instructs the Assembler service
to continue processing a job if an error is encountered.
Assemble the portfolioTo assemble a PDF Portfolio, you call the invokeDDX operation.
The Assembler service returns the PDF Portfolio within a collection object.
Save the assembled portfolioA PDF Portfolio is returned within
a collection object. Iterate through the collection object and save
PDF Portfolio as a PDF file.
Assemble a PDF Portfolio using the Java APIAssemble a PDF Portfolio by using the Assembler Service
API (Java):
Include project files.
Include client JAR files,
such as adobe-assembler-client.jar, in your Java project’s class
path.
Create a PDF Assembler client.
Reference an existing DDX document.
Create
a java.io.FileInputStream object that represents
the DDX document by using its constructor and passing a string value that
specifies the location of the DDX file.
Create a com.adobe.idp.Document object by
using its constructor and passing the java.io.FileInputStream object.
Reference the required documents.
Create a java.util.Map object
that is used to store input PDF documents by using a HashMap constructor.
Create a java.io.FileInputStream object
by using its constructor. Pass the location of the required NAV
file (repeat this task for each file required to create a portfolio).
Create a com.adobe.idp.Document object and
pass the java.io.FileInputStream object that contains
the NAV file (repeat this task for each file required to create
a portfolio).
Add an entry to the java.util.Map object
by invoking its put method and passing the following
arguments:
A string value that represents the key
name. This value must match the value of the source element specified
in the DDX document. (repeat this task for each file required to
create a portfolio).
A com.adobe.idp.Document object that contains
the PDF document. (repeat this task for each file required to create
a portfolio).
Set run-time options.
Create an AssemblerOptionSpec object
that stores run-time options by using its constructor.
Set run-time options to meet your business requirements by invoking
a method that belongs to the AssemblerOptionSpec object.
For example, to instruct the Assembler service to continue processing
a job when an error occurs, invoke the AssemblerOptionSpec object’s setFailOnError method
and pass false.
Assemble the portfolio.
Invoke the AssemblerServiceClient object’s invokeDDX method
and pass the following required values:
A com.adobe.idp.Document object
that represents the DDX document to use
A java.util.Map object that contains the
files required to build a PDF Portfolio.
A com.adobe.livecycle.assembler.client.AssemblerOptionSpec object
that specifies the runtime options, including the default font and
the job log level
The invokeDDX method
returns a com.adobe.livecycle.assembler.client.AssemblerResult object
that contains the assembled PDF Portfolio and any exceptions that
occurred.
Save the assembled portfolio.
To obtain the PDF Portfolio,
perform the following actions:
Invoke the AssemblerResult object’s getDocuments method.
This method returns a java.util.Map object.
Iterate through the java.util.Map object
until you find the resultant com.adobe.idp.Document object.
Invoke the com.adobe.idp.Document object’s copyToFile method
to extract the PDF Portfolio.
Assemble a PDF Portfolio using the web service APIAssemble a PDF Portfolio by using the Assembler Service
API (web service):
Include project files.
Create a Microsoft .NET
project that uses MTOM. Ensure that you use the following WSDL definition
when setting a service reference: http://localhost:8080/soap/services/AssemblerService?WSDL&lc_version=9.0.1.
Hinweis: Replace localhost with the IP
address of the server hosting LiveCycle.
Create a PDF Assembler client.
Create an AssemblerServiceClient object
by using its default constructor.
Create an AssemblerServiceClient.Endpoint.Address object
by using the System.ServiceModel.EndpointAddress constructor.
Pass a string value that specifies the WSDL to the LiveCycle
service (for example, http://localhost:8080/soap/services/AssemblerService?blob=mtom).
You do not need to use the lc_version attribute.
This attribute is used when you create a service reference.
Create a System.ServiceModel.BasicHttpBinding object
by getting the value of the AssemblerServiceClient.Endpoint.Binding field.
Cast the return value to BasicHttpBinding.
Set the System.ServiceModel.BasicHttpBinding object’s MessageEncoding field
to WSMessageEncoding.Mtom. This value ensures that
MTOM is used.
Enable basic HTTP authentication by performing the following tasks:
Assign the LiveCycle user name to the field AssemblerServiceClient.ClientCredentials.UserName.UserName.
Assign the corresponding password value to the field AssemblerServiceClient.ClientCredentials.UserName.Password.
Assign the constant value HttpClientCredentialType.Basic to
the field BasicHttpBindingSecurity.Transport.ClientCredentialType.
Assign the constant value BasicHttpSecurityMode.TransportCredentialOnly to
the field BasicHttpBindingSecurity.Security.Mode.
Reference an existing DDX document.
Create
a BLOB object by using its constructor. The BLOB object
is used to store the DDX document.
Create a System.IO.FileStream object by
invoking its constructor and passing a string value that represents the
file location of the DDX document and the mode in which to open
the file.
Create a byte array that stores the content of the System.IO.FileStream object.
You can determine the size of the byte array by getting the System.IO.FileStream object’s Length property.
Populate the byte array with stream data by invoking the System.IO.FileStream object’s Read method.
Pass the byte array, the starting position, and the stream length
to read.
Populate the BLOB object by assigning its MTOM property
with the contents of the byte array.
Reference the required documents.
For each
input file, create a BLOB object by using its constructor.
The BLOB object is used to store the input file.
Create a System.IO.FileStream object by
invoking its constructor and passing a string value that represents the
file location of the input file and the mode in which to open the file.
Create a byte array that stores the content of the System.IO.FileStream object.
You can determine the size of the byte array by getting the System.IO.FileStream object’s Length property.
Populate the byte array with stream data by invoking the System.IO.FileStream object’s Read method.
Pass the byte array, the starting position, and the stream length
to read.
Populate the BLOB object by assigning its MTOM field
with the contents of the byte array.
Create a MyMapOf_xsd_string_To_xsd_anyType object.
This collection object is used to store input files required to
create a PDF Portfolio.
For each input file, create a MyMapOf_xsd_string_To_xsd_anyType_Item object.
Assign a string value that represents the key name to the MyMapOf_xsd_string_To_xsd_anyType_Item object's key field.
This value must match the value of the element specified in the
DDX document. (Perform this task for each input file.)
Assign the BLOB object that stores the input file
to the MyMapOf_xsd_string_To_xsd_anyType_Item object's value field.
(Perform this task for each input PDF document.)
Add the MyMapOf_xsd_string_To_xsd_anyType_Item object
to the MyMapOf_xsd_string_To_xsd_anyType object.
Invoke the MyMapOf_xsd_string_To_xsd_anyType object's Add method
and pass the MyMapOf_xsd_string_To_xsd_anyType object.
(Perform this task for each input PDF document.)
Set run-time options.
Create an AssemblerOptionSpec object
that stores run-time options by using its constructor.
Set run-time options to meet your business requirements by assigning
a value to a data member that belongs to the AssemblerOptionSpec object.
For example, to instruct the Assembler service to continue processing
a job when an error occurs, assign false to the AssemblerOptionSpec object’s failOnError data
member.
Assemble the portfolio.
Invoke the AssemblerServiceClient object’s invokeDDX method
and pass the following values:
A BLOB object
that represents the DDX document
The MyMapOf_xsd_string_To_xsd_anyType object
that contains the required files
An AssemblerOptionSpec object that specifies
run-time options
The invokeDDX method
returns an AssemblerResult object that contains
the results of the job and any exceptions that occurred.
Save the assembled portfolio.
To obtain the newly
created PDF Portfolio, perform the following actions:
Access the AssemblerResult object’s documents field,
which is a Map object that contains the resultant
PDF documents.
Iterate through the Map object to obtain each
resultant document. Then, cast that array member’s value to
a BLOB.
Extract the binary data that represents the PDF document
by accessing its BLOB object’s MTOM property.
This returns an array of bytes that you can write out to a PDF file.
|
|
|
