import java.util.concurrent.CountDownLatch;
 
public class CountDownLatchExample {
 
	public static void main(String... args) {
		// Instantiating countdownlatch class.
		CountDownLatch countDown = new CountDownLatch(1);
		System.out.println("Creating threads...");
 
		// going to create 50 threads.
		for(int i=0;i<50;i++) {
			Worker worker = new Worker(countDown, "Worker #"+i);
			new Thread(worker).start();
		}
 
		// Now start all threads at the same time.
		countDown.countDown();
 
	}
 
	/**
	 * This class is just a simple dummy thread.
	 */
	private static class  Worker implements Runnable {
		CountDownLatch startLatch;
		String name;
 
		public Worker(CountDownLatch startLatch, String name) {
			super();
			this.startLatch = startLatch;
			this.name = name;
		}
 
		public void run() {
			try {
				// Going to wait until the signal is being fired.
				this.startLatch.await();
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
			System.out.println("Running " + name+".");
		}
	}
}

package renidev.examples.jaspereports;
 
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
 
import net.sf.jasperreports.engine.JRDataSource;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRField;
import net.sf.jasperreports.engine.JRRewindableDataSource;
 
/**
 * This is a sample custom data source for xml.
 * @author Renan Huanca
 *
 */
public class CustomXMLDataSource implements JRDataSource, JRRewindableDataSource {
 
	private NodeList childNodes;
	private int index;
 
	public CustomXMLDataSource(Document document) {
		// Note: document.getFirstChild() will return the root node.
		this.childNodes = document.getFirstChild().getChildNodes();
		this.index = -1;
	}
 
	/**
	 * Implementation of the getFieldValue method.
	 * In this case this method is extracting the value 
	 * from the note's attributes.
	 */
	public Object getFieldValue(JRField jrField) throws JRException {
		String nodeName = jrField.getDescription();
		return childNodes.item(index).getAttributes().getNamedItem(nodeName).getTextContent();
	}
 
	public boolean next() throws JRException {
		++this.index;
		return this.index < childNodes.getLength();
	}
 
	public void moveFirst() throws JRException {
		this.index = -1;
	}
}

package renidev.examples.jasperreports;
 
import static org.junit.Assert.*;
import org.junit.Test;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRField;
import net.sf.jasperreports.engine.design.JRDesignField;
import renidev.examples.jaspereports.CustomXMLDataSource;
 
 
public class CustomXMLDataSourceTest {
 
	@Test
	public void single_case() throws JRException{
		String xml ="<root></root>";
		CustomXMLDataSource dataSource = new CustomXMLDataSource(SimpleDocumentBuilder.buildDocument(xml));
		assertFalse(dataSource.next());
	}
 
	@Test
	public void one_child_node() throws JRException{
		String xml ="<friends><friend name='carlos'/></friends>";
		CustomXMLDataSource dataSource = new CustomXMLDataSource(SimpleDocumentBuilder.buildDocument(xml));
		assertTrue(dataSource.next());
		assertEquals("carlos", dataSource.getFieldValue(createField("name")));
		assertFalse(dataSource.next());
	}
 
	@Test
	public void two_child_nodes() throws JRException{
		String xml =
				"<friends>" +
					"<friend name='carlos'/>" +
					"<friend name='gonzalo'/>" +
				"</friends>";
		CustomXMLDataSource dataSource = new CustomXMLDataSource(SimpleDocumentBuilder.buildDocument(xml));
		JRField nameField = createField("name");
 
		// reading data data
		assertTrue(dataSource.next());
		assertEquals("carlos", dataSource.getFieldValue(nameField));
		assertTrue(dataSource.next());
		assertEquals("gonzalo", dataSource.getFieldValue(nameField));
 
		// checking there is no more data 
		assertFalse(dataSource.next());
	}
 
	@Test
	public void two_child_nodes_and_two_attributes() throws JRException{
		String xml =
				"<friends>" +
					"<friend name='carlos' from='work'/>" +
					"<friend name='gonzalo' from='raquet'/>" +
				"</friends>";
		CustomXMLDataSource dataSource = new CustomXMLDataSource(SimpleDocumentBuilder.buildDocument(xml));
		JRField nameField = createField("name");
		JRField fromField = createField("from");
 
		// reading data data
		assertTrue(dataSource.next());
		assertEquals("carlos", dataSource.getFieldValue(nameField));
		assertEquals("work", dataSource.getFieldValue(fromField));
		assertTrue(dataSource.next());
		assertEquals("gonzalo", dataSource.getFieldValue(nameField));
		assertEquals("raquet", dataSource.getFieldValue(fromField));
 
		// checking there is no more data 
		assertFalse(dataSource.next());
	}
 
 
	@Test
	public void two_child_nodes_and_rewind() throws JRException{
		String xml =
				"<friends>" +
					"<friend name='carlos'/>" +
					"<friend name='gonzalo'/>" +
				"</friends>";
 
		CustomXMLDataSource dataSource = new CustomXMLDataSource(SimpleDocumentBuilder.buildDocument(xml));
		JRField nameField = createField("name");
 
		// bypassing two nodes
		assertTrue(dataSource.next());
		assertTrue(dataSource.next());
 
		// checking there is no more data 
		assertFalse(dataSource.next());
 
		// rewind the data source
		dataSource.moveFirst();
 
		// reading data data
		assertTrue(dataSource.next());
		assertEquals("carlos", dataSource.getFieldValue(nameField));
		assertTrue(dataSource.next());
		assertEquals("gonzalo", dataSource.getFieldValue(nameField));
	}
 
	public JRField createField(String description){
		JRDesignField field = new JRDesignField();
		field.setDescription(description);
		return field;
	}
}

package renidev.utils.xml;
 
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
 
/**
 * This class helps to create a instance of a DOM document instance
 * simplifying the way to create it.
 * @author Renan Huanca
 */
public class SimpleDocumentBuilder {
    private static DocumentBuilder documentBuilder;
 
    static {
        try {
            documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
        } catch (ParserConfigurationException e) {
            throw new RuntimeException("Unable to get document builder. - "+ e.getMessage(), e);
        }
    }
 
    /**
     * Allow to create a DOM Document instance with the given parameter.
     * 
     * @param xml
     * @return
     */
    public static Document buildDocument(String xml) {
        Document doc = null;
        try {
            doc = documentBuilder.parse(new ByteArrayInputStream(xml.getBytes()));
        } catch (Exception e) {
            handleException(e);
        } 
        return doc;
    }
 
    /**
     * Allow to create a DOM Document instance with the given parameter.
     * @param stream
     * @return
     */
    public static Document buildDocument(InputStream stream) {
        Document doc = null;
        try {
            doc = documentBuilder.parse(stream);
        } catch (Exception e) {
            handleException(e);
        } 
        return doc;
    }
 
    public static void handleException(Exception e){
        if(e instanceof IOException) {
            throw new RuntimeException("Unable to read xml - " + e.getMessage(), e);
        } else if (e instanceof SAXParseException) {
            SAXParseException exception = (SAXParseException) e;
            throw new RuntimeException("Unable to parse xml - Line: " + 
                    exception.getLineNumber() + " - " + e.getMessage(), e);
        } else if ( e instanceof SAXException) {
            throw new RuntimeException("Unable to parse xml - " + e.getMessage(), e);
        } else {
            throw new RuntimeException(e);
        }
    }
}

package renidev.utils.xml;
 
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import static org.junit.Assert.*;
 
public class SimpleDocumentBuilderTest {
 
    @Test
    public void one_node(){
        String xml = "<data>hello world</data>";
        Document doc = SimpleDocumentBuilder.buildDocument(xml);
        Node dataNode = doc.getFirstChild();
        assertEquals(1, dataNode.getChildNodes().getLength());
        assertEquals("hello world", dataNode.getTextContent());
    }
 
    @Test
    public void one_level(){
        String xml = "<data><child>hello world</child></data>";
        Document doc = SimpleDocumentBuilder.buildDocument(xml);
        Node dataNode = doc.getFirstChild();
        assertEquals(1, dataNode.getChildNodes().getLength());
        assertEquals("hello world", dataNode.getFirstChild().getTextContent());
    }
 
    @Test 
    public void test_exception(){
        String xml = "<data>hello world<data>";
        try {
            @SuppressWarnings("unused")
            Document doc = SimpleDocumentBuilder.buildDocument(xml);
        } catch (RuntimeException e) {
            assertEquals("Unable to parse xml - Line: 1 - XML document structures must start and end within the same entity.", e.getMessage());
            return;
        }
        fail("No exception was throw");
    }
}

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
    <context:component-scan base-package="com.infomedia.notesmigrator"/>
    <context:annotation-config/>
    ...
    <!-- Database connection -->
	<bean id="projectsDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/projects"/>
        <property name="username" value="root"/>
        <property name="password" value=""/>
    </bean>
 
 
    <bean id="humanResourcesDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/recursos_humanos"/>
        <property name="username" value="root"/>
        <property name="password" value=""/>
    </bean>
    ...
</beans>

package edu.renan.samples;
 
import javax.sql.DataSource;
/**
 * To manage projects in our company.
 */
public interface ProjectsDao {
 
    /**
     * Sets a notes data source for this dao.
     * @param projectDataSource
     */
    public void setProjectsDataSource(DataSource projectDataSource);
 
    /**
     * list all projects...(je je this is just an example)
     */
    public Collection listAllProjects();
}

package edu.renan.samples;
 
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;
import java.util.Date;
 
@Component("projectsDao")
public class ProjectsDaoImpl implements ProjectsDao {
 
    private JdbcTemplate jdbcTemplate;
 
    @Autowired
    public void setProjectsDataSource(@Qualifier("projectsDataSource") DataSource projectsDataSource) {
        this.jdbcTemplate = new JdbcTemplate(projectsDataSource);
    }
 
    public Collection listAllProjects(){
        return this.jdbcTemplate.query( "select * from projects", new ProjectMapper());
    }
}

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    ...
 
    <!-- defining some properties -->
    <properties>
        <org.springframework.version>3.0.0.RELEASE</org.springframework.version>
    </properties>
 
    <!-- dependencies -->
    <dependencies>
        ...
        <!-- jsp/servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
 
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
 
        <!-- spring 3 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.flex</groupId>
            <artifactId>spring-flex</artifactId>
            <version>1.0.3.RELEASE</version>
        </dependency>
 
        <!-- blazeds -->
        <dependency>
            <groupId>com.adobe.blazeds</groupId>
            <artifactId>blazeds-core</artifactId>
            <version>3.2.0.3978</version>
        </dependency>
        <dependency>
            <groupId>com.adobe.blazeds</groupId>
            <artifactId>blazeds-proxy</artifactId>
            <version>3.2.0.3978</version>
        </dependency>
        <dependency>
            <groupId>com.adobe.blazeds</groupId>
            <artifactId>blazeds-opt</artifactId>
            <version>3.2.0.3978</version>
        </dependency>
        <dependency>
            <groupId>com.adobe.blazeds</groupId>
            <artifactId>blazeds-remoting</artifactId>
            <version>3.2.0.3978</version>
        </dependency>
 
        ...
    </dependencies>
    <build>
        <finalName>helloblazeds</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
            ...    
        </plugins>
    </build>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="ifm_service_catalog" version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
                             http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 
    <display-name>Hello World with SpringBlazeDS</display-name>
 
    <!-- filter -->
    <filter>
        <filter-name>encoding-filter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
 
    <filter-mapping>
        <filter-name>encoding-filter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
 
    <!-- servlet -->
 
    <servlet>
        <servlet-name>spring-flex</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/flex-servlet-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>spring-flex</servlet-name>
        <url-pattern>/messagebroker/*</url-pattern>
    </servlet-mapping>
 
    <!-- Welcome file list -->
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>
</web-app>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:flex="http://www.springframework.org/schema/flex"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/flex
                           http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
    <context:component-scan base-package="test.flex" />
    <flex:message-broker/>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<services-config>
    <services>
        <service-include file-path="remoting-config.xml" />
        <default-channels>
           <channel ref="my-amf-channel"/>
        </default-channels>
    </services>
 
    <channels>
        <channel-definition id="my-amf-channel" class="mx.messaging.channels.AMFChannel">
            <endpoint url="http://{server.name}:{server.port}/{context.root}/messagebroker/amf"
                      class="flex.messaging.endpoints.AMFEndpoint"/>
        </channel-definition>
    </channels>
    <logging>
        <target class="flex.messaging.log.ConsoleTarget" level="Error">
            <properties>
                <prefix>[BlazeDS]</prefix>
                <includeDate>false</includeDate>
                <includeTime>false</includeTime>
                <includeLevel>false</includeLevel>
                <includeCategory>false</includeCategory>
            </properties>
            <filters>
                <pattern>Endpoint.*</pattern>
                <pattern>Service.*</pattern>
                <pattern>Configuration</pattern>
            </filters>
        </target>
    </logging>
    <system>
        <redeploy>
            <enabled>false</enabled>
        </redeploy>
    </system>
</services-config>

<?xml version="1.0" encoding="UTF-8"?>
<service id="remoting-service"
         class="flex.messaging.services.RemotingService">
    <adapters>
        <adapter-definition id="java-object"
                            class="flex.messaging.services.remoting.adapters.JavaAdapter"
                            default="true"/>
    </adapters>
    <default-channels>
        <channel ref="my-amf-channel"/>
    </default-channels>
</service>

package test.flex;
 
import java.io.*;
import java.util.List;
import org.springframework.flex.remoting.RemotingDestination;
import org.springframework.stereotype.Service;
 
@Service("SayHello")
@RemotingDestination
public class SayHello {
 
    public String hello(){
        return "Hola Mundo";
    }
}

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
<mx:Script>
<![CDATA[
import mx.rpc.events.ResultEvent;
import mx.rpc.events.FaultEvent;
import mx.utils.ObjectUtil;
import mx.controls.Alert;
import mx.utils.StringUtil;
 
/**
 * Response handler
 */            
private function resultHandler(event:ResultEvent):void{
    Alert.show( ObjectUtil.toString(event.result) );   
}
/**
 * Failure handler
 */
private function faultHandler(event:FaultEvent):void{
    Alert.show( ObjectUtil.toString(event.fault) );
}
]]>
 
</mx:Script>
 
<!-- Remote object that is accessed from the server.-->
<mx:RemoteObject id="remoteObject" 
 destination="SayHello"   
 result="resultHandler(event)"
 fault="faultHandler(event)"     
 endpoint="http://localhost:8080/helloblazeds/messagebroker/amf"/>
 
<mx:Panel width="457" 
    height="228" 
    layout="vertical" 
    title="Hola Mundo con AMF/Flex y BlazeDS" 
    horizontalAlign="center">
    <mx:Button label="Hola Mundo!" click="remoteObject.hello()"/>
</mx:Panel>    		
</mx:Application>

package some.good.packague.to.work; // :)
 
import org.springframework.flex.remoting.RemotingDestination;
import org.springframework.stereotype.Service;
 
@Service("userService")
@RemotingDestination
public class UserService{
 
    public String getUserName(String userId) {
        .....
        return "The best name in the world :)";
    }
 
}

package yep.this.is.a.very.good.package;
 
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.classreading.SimpleMetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.util.ClassUtils;
 
import java.util.Set;
import java.util.HashSet;
import java.io.IOException;
 
/**
 * This class is a adaptation of:
 *
 *    http://java-chimaera.blogspot.com/2008/10/scanning-classpath-annotated-classes.html
 */
/**
 * @author Renan Huanca
 * @since Apr 16, 2010 9:52:12 PM
 */
public class AnnotatedClassFinder {
    private String basePackage;
    private ResourcePatternResolver resourceResolver = null;
    private MetadataReaderFactory metadataReaderFactory = null;
    private TypeFilter annotationFilter = null;
 
    public AnnotatedClassFinder(String basePackage) {
        this.basePackage = basePackage;
        this.resourceResolver = new PathMatchingResourcePatternResolver(
                Thread.currentThread().getContextClassLoader());
        this.metadataReaderFactory = new SimpleMetadataReaderFactory();
    }
 
    public static AnnotatedClassFinder getInstance(String basePackage){
        return new AnnotatedClassFinder(basePackage);
    }
 
    public Set findByAnnotation(Class annotation) {
        this.annotationFilter = new AnnotationTypeFilter(annotation);
        Set <Class>annotatedClasses = new HashSet();
        /*
        * First of all we load all resources that are under a specific package by using a ResourcePatternResolver.
        * By doing so we will use class files as simple resources without passing
        * by the ClassLoader which can for example cause the execution of a static initialization block.
        * It resolves also transparently resources in jars.
        */
        String candidateClassesLocationPattern = "classpath*:" + basePackage + "/**/*.class";
        Resource[] resources = null;
        try {
            resources = resourceResolver.getResources(candidateClassesLocationPattern);
        } catch (IOException e) {
            throw new RuntimeException(
                    "An I/O problem occurs when trying to resolve ressources matching the pattern : "
                            + candidateClassesLocationPattern, e);
        }
 
        /*
        * then we proceed resource by resource, using a MetadataReaderFactory to create
        * MetadataReader wich hides the ASM related interface and complexity.
        *
        */
        for (Resource resource : resources) {
            MetadataReader metadataReader = null;
            try {
                metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
 
                if (this.annotationFilter.match(metadataReader, metadataReaderFactory)) {
 
                    /*
                    * the AnnotationMetadata is a simple abstaction of the informations
                    * that holds the annotation
                    */
                    String className = convertResourceToClassName(resource, basePackage);
                    try {
                        annotatedClasses.add(ClassUtils.forName(className));
                    } catch (Exception e) {
                        throw new RuntimeException("problems occurs when trying to load the annotated class : " + className, e);
                    }
                }
            } catch (IOException e) {
                throw new RuntimeException("An I/O problem occurs when trying to process resource : " + resource, e);
            }
        }
 
        return annotatedClasses;
    }
 
    static String convertResourceToClassName(Resource resource, String basePackage) throws IOException {
        String path = resource.getFile().getPath();
        String pathWithoutSuffix = path.substring(0, path.length() - ClassUtils.CLASS_FILE_SUFFIX.length());
        String relativePathWithoutSuffix = "";
        if(System.getProperty("file.separator").equals("\\")) {
            relativePathWithoutSuffix = pathWithoutSuffix.substring(pathWithoutSuffix.indexOf(basePackage.replace('/', '\\')));
            relativePathWithoutSuffix = relativePathWithoutSuffix.replace('\\', '/');
        } else if(System.getProperty("file.separator").equals("//")) {
            relativePathWithoutSuffix = pathWithoutSuffix.substring(pathWithoutSuffix.indexOf(basePackage));
        } else {
            throw new RuntimeException("File separator is not recognized");
        }
 
        // taking out extra \ or /
        relativePathWithoutSuffix = relativePathWithoutSuffix.substring(1);
 
        return relativePathWithoutSuffix.replace('/', '.');
    }
}

AnnotatedClassFinder finder = AnnotatedClassFinder.getInstance("/the/package/you/want/to/search");
Set classes = finder.findByAnnotation(RemotingDestination.class);

import __AS3__.vec.Vector;
 
import flash.desktop.NativeProcess;
import flash.desktop.NativeProcessStartupInfo;
import flash.events.IOErrorEvent;
import flash.events.NativeProcessExitEvent;
import flash.events.ProgressEvent;
import flash.events.TimerEvent;
import flash.filesystem.File;
import flash.utils.Timer;
 
import mx.core.FlexGlobals;
 
public class PDF2SWFConverter
{
	private var command:String;
	private var finished:Boolean = false;
	private var error:Boolean = false;
	private var timer:Timer;
 
	public function PDF2SWFConverter(command:String)
	{
		this.command = command;	
	}
 
	public static function getInstance():PDF2SWFConverter{
		return new PDF2SWFConverter("/path/to/pdf2swf.exe");	
	} 
 
	public function convert(pdfPath:String, swfPath:String):Boolean {
		var nativeProcessStartupInfo:NativeProcessStartupInfo =  new NativeProcessStartupInfo();
		var commandFile:File = new File(command); 
		nativeProcessStartupInfo.executable = commandFile;
		var args:Vector.<String> = new Vector.<String>();
		args.push(pdfPath);
		args.push("-t");
		args.push("-T9");
		args.push("-o");
		args.push(swfPath);
 
		nativeProcessStartupInfo.arguments = args;
		var process:NativeProcess;
 
		timer = new Timer(1);
 
		process = new NativeProcess();
		process.start(nativeProcessStartupInfo);
		process.addEventListener(NativeProcessExitEvent.EXIT, onExit);
		process.addEventListener(ProgressEvent.STANDARD_ERROR_DATA, onErrorData);
		process.addEventListener(IOErrorEvent.STANDARD_ERROR_IO_ERROR, onIOError);
 
		timer.addEventListener(TimerEvent.TIMER, myTimerHandler);
 
		this.finished = false;
		this.error = false;
		timer.start();
 
		return !error;
	}
 
	protected function onExit(event:NativeProcessExitEvent):void
	{
		this.finished = true;
	}
 
	public function onErrorData(event:ProgressEvent):void
	{
      		this.error = true;
          		this.finished = true; 
      	}
 
	public function onIOError(event:IOErrorEvent):void
      	{
      		this.error = true;
      		this.finished = true;
      	}
 
      	public function myTimerHandler(e:TimerEvent):void{
      		if(this.finished)
		{
			timer.stop();
		} 
	}
}

<i><supportedProfiles>extendedDesktop</supportedProfiles></i>

var converter:PDF2SWFConverter = PDF2SWFConverter.getInstance();
converter.convert("/path/to/doc.pdf","/path/to/new/doc.swf");