xmpcorecoverage.java

flash xmp sdk,flash官方SDK

// =================================================================================================
// ADOBE SYSTEMS INCORPORATED
// Copyright 2006-2007 Adobe Systems Incorporated
// All Rights Reserved
//
// NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the terms
// of the Adobe license agreement accompanying it.
// =================================================================================================

package samples;

import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.net.URI;
import java.net.URL;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.Map;
import java.util.SimpleTimeZone;
import java.util.TimeZone;

import com.adobe.xmp.XMPConst;
import com.adobe.xmp.XMPDateTime;
import com.adobe.xmp.XMPDateTimeFactory;
import com.adobe.xmp.XMPException;
import com.adobe.xmp.XMPIterator;
import com.adobe.xmp.XMPMeta;
import com.adobe.xmp.XMPMetaFactory;
import com.adobe.xmp.XMPPathFactory;
import com.adobe.xmp.XMPSchemaRegistry;
import com.adobe.xmp.options.AliasOptions;
import com.adobe.xmp.options.IteratorOptions;
import com.adobe.xmp.options.ParseOptions;
import com.adobe.xmp.options.PropertyOptions;
import com.adobe.xmp.options.SerializeOptions;
import com.adobe.xmp.properties.XMPAliasInfo;
import com.adobe.xmp.properties.XMPProperty;
import com.adobe.xmp.properties.XMPPropertyInfo;


/**
 * An example for XMPCore. 
 * It covers most of the functionality of XMPCore,
 * but does not provide any meaningful workflow.
 * 
 * @author  smakswit
 * @since   11.02.2007
 */
public class XMPCoreCoverage implements XMPCoreCoverageConst
{
	/** the log stream for all outputs */
	private static PrintStream log;
	/** shortcut for the schema registry */
	private static XMPSchemaRegistry registry = XMPMetaFactory.getSchemaRegistry();
	
	
	/**
	 * Runs the example
	 * @param args not used
	 */
	public static void main(String[] args)
	{
		try
		{
			URL url = XMPCoreCoverage.class.getResource(".");
			String filePath = "file:" + url.getPath().replaceFirst("/bin/", "/src/")
					+ "XMPCoreCoverage.log";
			File file = new File (new URI(filePath));
			file.createNewFile();
			FileOutputStream out = new FileOutputStream(file); 
			log = new PrintStream(out);
			
			println("XMPCoreCoverage starting   " + new Date());
			println("XMPCore Version: " + XMPMetaFactory.getVersionInfo());
			println();

			
			doCoreCoverage();

			
			println(); println();
			println("XMPCoreCoverage ending   " + new Date());
		}
		catch (XMPException e)
		{
			println("Caught XMPException " + e.getErrorCode() + " :   " +e.getMessage());
		}
		catch (Throwable e)
		{
			println("Caught Throwable '" + e.getMessage()  + "'"); 
		}
		finally
		{
			if (log != null)
			{	
				log.close();
			}
		}	
	}

			
	/**
	 * Runs example functions that explain some features of XMPCore.
	 * @throws Exception Forwards exceptions
	 */
	private static void doCoreCoverage() throws Exception
	{
		coverNamespaceRegistry();
			
		coverAliasRegistry();

		coverCreatingXMP();

		XMPMeta meta = coverSetPropertyMethods();

		coverGetPropertyMethods(meta);

		coverExistingProperties(meta);		

		coverDeleteProperties(meta);

		coverLocalisedProperties();

		coverLiteralProperties();

		coverParsing();
	
		coverLinefeedValues();
	
		coverSerialization();

		coverIterator();
		
		coverPathCreation();
		
		coverDateTime();
	}


	/**
	 * List predefined namespaces and aliases;
	 * register new namespaces and aliases.
	 * @throws XMPException Forward exceptions
	 */
	private static void coverNamespaceRegistry() throws XMPException
	{
		writeMajorLabel ("Test of namespace registry");

		// Lists of predefined namespaces
		writeMinorLabel ("List predefined namespaces");
		Map namespaces = registry.getNamespaces();
		for (Iterator it = namespaces.keySet().iterator(); it.hasNext();)
		{
			String prefix = (String) it.next();
			String namespace = (String) namespaces.get(prefix);
			println(prefix + "   --->   " + namespace);
		}
		println();
		
		
		// Registry namespace functions
		writeMinorLabel ("Test namespace registry functions");

		String prefix = registry.registerNamespace(NS1, "ns1");
		println ("registerNamespace ns1:   " + prefix + "   --->   " + 
			registry.getNamespaceURI(prefix));

		prefix = registry.registerNamespace(NS2, "ns2");
		println ("registerNamespace ns2:   " + prefix + "   --->   " + 
			registry.getNamespaceURI(prefix));

		prefix = registry.getNamespacePrefix(NS1);
		println ("getNamespacePrefix ns1:   " + prefix);

		String ns = registry.getNamespaceURI("ns1");
		println ("getNamespaceURI ns1:   " + ns);
		
		prefix = registry.getNamespacePrefix("bogus");
		println ("getNamespacePrefix bogus:   " + prefix);
		
		ns = registry.getNamespaceURI("bogus");
		println ("getNamespaceURI ns1:   " + ns);
	}


	/**
	 * List predefined aliases, register new aliases and resolve aliases.
	 * @throws XMPException Forward exceptions
	 */
	private static void coverAliasRegistry() throws XMPException
	{
		writeMajorLabel ("Test alias registry and functions");
		dumpAliases();

		// Register new aliases
		writeMinorLabel ("Add ns2: to ns1: aliases");
		
		registry.registerAlias (NS2, "SimpleAlias", NS1, "SimpleActual", null);

		registry.registerAlias (NS2, "BagAlias", NS1, "BagActual", null);
		registry.registerAlias (NS2, "SeqAlias", NS1, "SeqActual", null);
		registry.registerAlias (NS2, "AltAlias", NS1, "AltActual", null);
		registry.registerAlias (NS2, "AltTextAlias", NS1, "AltTextActual", null);

		registry.registerAlias (NS2, "BagItemAlias", NS1, "BagActual", 
			new AliasOptions().setArray(true));
		registry.registerAlias (NS2, "SeqItemAlias", NS1, "SeqActual", 
			new AliasOptions().setArrayOrdered(true));
		registry.registerAlias (NS2, "AltItemAlias", NS1, "AltActual", 
			new AliasOptions().setArrayAlternate(true));
		registry.registerAlias (NS2, "AltTextItemAlias", NS1, "AltTextActual",
			new AliasOptions().setArrayAltText(true));

		dumpAliases();


		// Resolve aliases
		writeMinorLabel ("Resolve ns2: to ns1: aliases");

		XMPAliasInfo aliasInfo = registry.resolveAlias (NS1, "SimpleActual");
		println ("resolveAlias ns1:SimpleActual:   " + aliasInfo + "   (wrong way!)");

		aliasInfo = registry.resolveAlias (NS2, "SimpleAlias");
		println ("resolveAlias ns2:SimpleAlias:   " + aliasInfo);
		println();

		
		aliasInfo = registry.resolveAlias (NS2, "BagAlias");
		println ("resolveAlias ns2:BagAlias:   " + aliasInfo);

		aliasInfo = registry.resolveAlias (NS2, "SeqAlias");
		println ("resolveAlias ns2:SeqAlias:   " + aliasInfo);

		aliasInfo = registry.resolveAlias (NS2, "AltAlias");
		println ("resolveAlias ns2:AltAlias:   " + aliasInfo);

		aliasInfo = registry.resolveAlias (NS2, "AltTextAlias");
		println ("resolveAlias ns2:AltTextAlias:   " + aliasInfo);
		println();

		
		aliasInfo = registry.resolveAlias (NS2, "BagItemAlias");
		println ("resolveAlias ns2:BagItemAlias:   " + aliasInfo);

		aliasInfo = registry.resolveAlias (NS2, "SeqItemAlias");
		println ("resolveAlias ns2:SeqItemAlias:   " + aliasInfo);

		aliasInfo = registry.resolveAlias (NS2, "AltItemAlias");
		println ("resolveAlias ns2:AltItemAlias:   " + aliasInfo);

		aliasInfo = registry.resolveAlias (NS2, "AltTextItemAlias");
		println ("resolveAlias ns2:AltTextItemAlias:   " + aliasInfo);
		println();
		
		
		// set alias properties
		writeMinorLabel ("Test setProperty through ns2: simple aliases");
		
		XMPMeta meta = XMPMetaFactory.create();
		meta.setProperty (NS2, "SimpleAlias", "Simple value");
		meta.setProperty (NS2, "ns2:BagItemAlias", "BagItem value");
		meta.setProperty (NS2, "SeqItemAlias", "SeqItem value");
		meta.setProperty (NS2, "AltItemAlias", "AltItem value");
		meta.setProperty (NS2, "AltTextItemAlias", "AltTextItem value");
		printXMPMeta(meta, "Check for aliases and bases");

		
		// delete aliases
		writeMinorLabel ("Delete some ns2: to ns1: aliases");

		registry.deleteAlias (NS2, "ns2:SimpleAlias");
		registry.deleteAlias (NS2, "SeqAlias");
		registry.deleteAlias (NS2, "AltAlias");
		registry.deleteAlias (NS2, "SeqItemAlias");
		registry.deleteAlias (NS2, "AltItemAlias");

		dumpAliases();
	}
	
	
	/**
	 * Test simple constructors and parsing, setting the instance ID
	 * @throws XMPException Forwards exceptions
	 */
	private static void coverCreatingXMP() throws XMPException
	{
		writeMajorLabel ("Test simple constructors and parsing, setting the instance ID");

		XMPMeta meta1 = XMPMetaFactory.create();
		printXMPMeta(meta1, "Empty XMP object");
				
		XMPMeta meta2 = XMPMetaFactory.create();
		meta2.setObjectName("New object name");
		printXMPMeta(meta2, "XMP object with name");
		
		XMPMeta meta3 = XMPMetaFactory.parseFromString(RDF_COVERAGE);
		printXMPMeta(meta3, "Construct and parse from buffer");

		meta3.setProperty (XMPConst.NS_XMP_MM, "InstanceID", "meta2:Original");
		printXMPMeta(meta3, "Add instance ID");

		XMPMeta meta4 = (XMPMeta) meta3.clone();
		meta4.setProperty (XMPConst.NS_XMP_MM, "InstanceID", "meta2:Clone");
		printXMPMeta(meta3, "Clone and add instance ID");
	}
	

	/**
	 * Cover some basid set calls (including arrays and structs).
	 * @return Returns an <code>XMPMeta</code> object that is reused in the next examples.
	 * @throws XMPException Forwards Exceptions
	 */
	private static XMPMeta coverSetPropertyMethods() throws XMPException
	{
		// Basic set/get methods
		writeMajorLabel ("Test setProperty and related methods");

		XMPMeta meta = XMPMetaFactory.create();
		meta.setProperty (NS1, "Prop", "Prop value");
		meta.setProperty (NS1, "ns1:XMLProp", "<PropValue/>");
		meta.setProperty (NS1, "ns1:URIProp", "URI:value/", new PropertyOptions().setURI(true));

		meta.appendArrayItem(NS1, "Bag", new PropertyOptions().setArray(true), "BagItem value",
				null);
		meta.appendArrayItem(NS1, "ns1:Seq", new PropertyOptions().setArrayOrdered(true),
				"SeqItem value", null);
		meta.appendArrayItem(NS1, "ns1:Alt", new PropertyOptions().setArrayAlternate(true),
				"AltItem value", null);

		meta.setArrayItem (NS1, "Bag", 1, "BagItem 3");
		meta.insertArrayItem (NS1, "ns1:Bag", 1, "BagItem 1");
		meta.insertArrayItem (NS1, "ns1:Bag", 2, "BagItem 2");
		meta.appendArrayItem (NS1, "Bag", "BagItem 4");

		meta.setStructField (NS1, "Struct", NS2, "Field1", "Field1 value");
		meta.setStructField (NS1, "ns1:Struct", NS2, "Field2", "Field2 value");
		meta.setStructField (NS1, "ns1:Struct", NS2, "Field3", "Field3 value");

		printXMPMeta(meta, "A few basic set property calls");
		
		// -----------------------------------------------------------------------------------------
		
		// Add some properties with qualifier
		writeMinorLabel ("Add some properties with qualifier");
		println ("CountArrayItems Bag = " + meta.countArrayItems(NS1, "Bag"));

		meta.setProperty (NS1, "QualProp1", "Prop value");
		meta.setQualifier (NS1, "QualProp1", NS2, "Qual1", "Qual1 value");
		meta.setProperty (NS1, "QualProp1/?ns2:Qual3", "Qual3 value");
		meta.setProperty (NS1, "QualProp1/?xml:lang", "x-qual");

		meta.setProperty (NS1, "QualProp2", "Prop value");
		meta.setQualifier (NS1, "QualProp2", XMPConst.NS_XML, "lang", "en-us");
		meta.setProperty (NS1, "QualProp2/@xml:lang", "x-attr");