<!--
#
# Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description:
#
-->
<project name="Utilities">
<!--
This file contains common utilities for each build.xml file.
Following properties are mandatory for a basic build process. Most of the
APIs can use default values, but if some property is not suitable, it can
be overridden.
java.src.paths The source path. If there are more than one source path
concatenate the paths using ':' as separator. Default is
'../javasrc
java.src.second.paths The source path for the second phase compilation.
If there are more than one source path concatenate the
paths using ':' as separator. Default is '../javasrc.cdc
bootclasspath The bootclasspath used for compile time. Default is CLDC
bootclasspath.second The bootclasspath used for the second phase
compilation.. Default is CDC
native.dll.name The name of the dll (without extension) which will
contain the rommized byte code. The default value is the
name of the ant project.
Following properties are optionals:
javah.classnames A list of classes using ',' as separator to be
"javah"ed.
-->
<import file="properties.xml"/>
<!--Importing platform specific utilities. This might seem quite complex,
since we need to import a default one (utilities.fake.xml), because
the property ${platform.utilities.xml.file} need to have some meaningful
value when the utilities.xml is used for the first time. The default one
isn't used at all, instead the platform dependent xml file is defined
using additional antcall after the dynamic properties have been defined.
See targets deploy and deploy.dual-->
<import file="${platform.utilities.xml.file}"/>
<!-- Importing emma utilities for Java code coverage measurement. -->
<import file="emmautilities.xml"/>
<!-- Import cobertura utilities for Java code coverage measurement on Symbian. -->
<condition property="cobertura.import"
value="coberturautilities.xml"
else="coberturautilities_stub.xml">
<isset property="set.cobertura.enabled" />
</condition>
<import file="${cobertura.import}"/>
<!--STARTING POINTS START-->
<!--The start point of the component's build when there are classes that can
be compiled against same configuration (cldc, cdc, etc). This is the
normal case for the most of the components-->
<target name="deploy" depends="init.properties, make.target.dirs, component.init">
<antcall target="deploy.internal">
<param name="platform.utilities.xml.file"
value="${dyn.platform.utilities.xml.file}"/>
</antcall>
</target>
<!--The start point of the component's build when there are classes from two
different configurations (cldc, cdc, etc). The default order is that cldc
is compiled in first phase and cdc in the second, but the component is
able to variate the behavior.
-->
<target name="deploy.dual" depends="init.properties, make.target.dirs, component.init">
<antcall target="deploy.dual.internal">
<param name="platform.utilities.xml.file" value="${dyn.platform.utilities.xml.file}"/>
</antcall>
</target>
<!--For overriding by the build.xml of the component-->
<target name="component.init">
</target>
<!--STARTING POINTS END-->
<!--TARGETS FOR THE FIRST PHASE COMPILATION START-->
<!--An internal target to be called using antcall in order to import correct
platform specific helper xml file for the first phase compilation.
This targe assumes that the antcall to this target (or target that
depends on this) defines following property:
* platform.utilities.xml.file A file containg platform specific
implementations of certain common
targets
-->
<target name="deploy.internal" depends="do.export, deploy.first, finalize">
</target>
<!--Target that launches the first phase compilation. After this target
classes are compiled into classes/first directory, copied to
classes/collection directory, finetuned (platform specific) and
copied into jar containig all the classes of the different components.-->
<target name="deploy.first" depends="do.export">
<!--If the platform specific directory exists, it is added to the
source path -->
<condition property="additional.java.src.path.first"
value=";${javasrc.platform.specific}"
else="">
<isset property="javasrc.platform.specific.present" />
</condition>
<!--Start the job described above using antcall -->
<antcall target="do.java.compile">
<param name="compile.target" value="compile"/>
<param name="int.bcp" value=""/>
<param name="bcp" value="${bootclasspath}"/>
<param name="jsrc"
value="${java.src.paths}${additional.java.src.path.first}"/>
<param name="dst.dir" value="${classes.first.dir}"/>
</antcall>
</target>
<!--TARGETS FOR THE FIRST PHASE COMPILATION END-->
<!--TARGETS FOR THE SECOND PHASE COMPILATION START-->
<!--An internal target for the second phase compilation. Look for the
description of the target 'deploy.internal'.
-->
<target name="deploy.dual.internal" depends="deploy.second, finalize">
</target>
<!--Target that launches the second phase compilation. After this target
classes are compiled into classes/second directory, copied to
classes/collection directory, finetuned (platform specific) and
copied into jar containig all the classes of the different components.-->
<target name="deploy.second" depends="deploy.first, init.second.phase">
<!--If the platform specific cdc directory exists, it is added to the
source path -->
<condition property="additional.java.src.path.second"
value=";${javasrc.platform.specific.cdc}"
else="">
<isset property="javasrc.platform.specific.cdc.present" />
</condition>
<!--Start the job described above using antcall -->
<antcall target="do.java.compile">
<param name="compile.target" value="compile.second"/>
<param name="int.bcp" value="${classes.first.dir}"/>
<param name="bcp" value="${bootclasspath.second}"/>
<param name="jsrc"
value="${java.src.second.paths}${additional.java.src.path.second}"/>
<param name="dst.dir" value="${classes.second.dir}"/>
</antcall>
</target>
<!--TARGETS FOR THE SECOND PHASE COMPILATION END-->
<!--COMPILE AND FINALIZE START-->
<!--This target compiles the java code, finetunes the classes in
platform specific way (if exists) and adds the classes into
collection jar file. The target is meant to be called using
<antcall> which must define following properties:
*compile.target Target to be used doing the 'javac'
*bcp The bootclasspath for the 'javac'
*jsrc A list of dir(s) containing the Java files.
*dst.dir A directory where to put the resulted classes.
*int.bcp An internal additional bootclasspath. This is used
in the second phase of the dual compilation for
adding the classes compiled in the first phase
into bootclasspath of the 'javac'
-->
<target name="do.java.compile" depends="do.java.preprocessing">
<!--If the pre-processing is done change the java source to point
to preprocessed sources.-->
<condition property="jsrc.for.javac"
value="${java.cpp.tmp.dir}"
else="${jsrc}">
<isset property="java.cpp.tmp.dir" />
</condition>
<ant target="${compile.target}"/>
<ant target="cobertura.instr" />
<ant target="finetune.classes"/>
<ant target="emma.instr"/>
<ant target="add.classes.to.collection.jar"/>
<ant target="collect.localisation.files"/>
<!--Copy only changed classes into collection dir -->
<copy todir="${classes.collection.dir}">
<fileset dir="${dst.dir}" includes="**/*.class">
<depend targetdir="${classes.collection.dir}"/>
</fileset>
</copy>
</target>
<!--Target that does the pre rpocessing of the java code. This is not done
by default - it is done only if property java.cpp.defines has been
defined by the component. Java source files are pre processed into
component's classes/firstjavacpp (or classes/secondjavacpp in case of
second phase compilation) directory
-->
<target name="do.java.preprocessing" if="java.cpp.defines">
<property name="java.cpp.tmp.dir" location="${dst.dir}javacpp"/>
<mkdir dir="${java.cpp.tmp.dir}"/>
<exec executable="python" failonerror="true">
<arg value="${java.src.root}/build/buildutils/javacpp.py"/>
<arg value="${jsrc}"/>
<arg value="${java.cpp.tmp.dir}"/>
</exec>
</target>
<!--Groups a set of functionalities that are done after java code has
been compiled ad finetuned -->
<target name="finalize" depends="create.internal.api.jar,
create.public.api.jar, javah, generate.odc,
rommize.classes, jni.utils">
</target>
<!--COMPILE AND FINALIZE END-->
<!--INITIALIZATIONS START-->
<!--Creates target directories -->
<target name="make.target.dirs">
<mkdir dir="${classes.collection.dir}"/>
<mkdir dir="${classes.first.dir}"/>
<mkdir dir="${temp.javah.dir}"/>
<mkdir dir="${javah.dir}"/>
<mkdir dir="${jar.destination.root}"/>
</target>
<!--Creates target directories when dual phase compilation is
used. In normal case this is not used.-->
<target name="init.second.phase">
<property name="second.phase.compilation" value="true"/>
<mkdir dir="${classes.second.dir}"/>
</target>
<!--Target for making component specific initalizations depending on
the values of dynamic properties (e.g. Target platform).
The default implementation of this target is empty and the component
should override this if it provides public APIs -->
<target name="init.target">
</target>
<!--INITIALIZATIONS END-->
<!--JAVAC START-->
<!--Javac
TODO: bootclasspath should look like this:
bootclasspath="${bcp}:${int.bcp}:${platform.api.jar}:${public.api.jar}">
-->
<presetdef name="omj.javac">
<javac
source="${javac.source}"
target="${javac.target}"
destdir="${dst.dir}"
debug="${javac.debug.on}"
debuglevel="lines,vars,source"
includeAntRuntime="false"
bootclasspath="${bcp}:${int.bcp}:${platform.api.jar}:${public.api.jar}${eswt.jar}:${cobertura.classpath}">
<!-- Uncomment the following line if you want to see Javac warnings. -->
<!-- <compilerarg value="-Xlint"/> -->
<src path="${jsrc.for.javac}"/>
</javac>
</presetdef>
<!--Do the first Java compilation. May be overridden-->
<target name="compile">
<omj.javac/>
</target>
<!--Do the second Java compilation. May be overridden-->
<target name="compile.second">
<omj.javac/>
</target>
<!--JAVAC END-->
<!--SYSTEM PROPERTIES START-->
<!--Default empty target for the system properties. If the componen wants
to publish some system properties, it must override this target. Example:
<target name="system.properties">
<properties>
microedtion.locale=Fi-fi
microedtion.encoding=utf-8
</properties>
</target>
-->
<target name="system.properties">
</target>
<!--Used in overridable target 'system.properties' to list the properties
into component's properties.txt file-->
<presetdef name="properties">
<echo file="${component.root.dir}/properties.txt">
</echo>
</presetdef>
<!--SYSTEM PROPERTIES END-->
<!--ODC FILE START-->
<!--Generate the odc files -->
<target name="generate.odc" depends="system.properties,cobertura.systemprop" unless="no.rommizing">
<exec executable="python" failonerror="true">
<arg value="${java.src.root}/build/buildutils/generateOdcFile.py"/>
<arg value="${component.root.dir}/${odc.file.name}.odc"/>
<arg value="${native.dll.name}"/>
<arg value="${classes.collection.dir}"/>
<arg value="${component.root.dir}/properties.txt"/>
</exec>
<!--Copy the odc file into location where the VM can find it -->
<copy file="${component.root.dir}/${odc.file.name}.odc"
todir="${bcp.dest.directory}"/>
</target>
<!--ODC FILE END-->
<!--INTERNAL, PUBLIC AND COLLECTION JAR FILE GENERATION START-->
<presetdef name="omj.internal.apis">
<jar destfile="${platform.api.jar}"
basedir="${classes.collection.dir}"
update="true"/>
</presetdef>
<!--Create an internal API jar file into directory containig all the
internal API jar files. The default implementation of this target is
empty and the component should override this if it provides internal
APIs -->
<target name="create.internal.api.jar">
</target>
<!--Public APIs -->
<presetdef name="omj.public.apis">
<jar destfile="${public.api.jar}"
basedir="${classes.collection.dir}"
update="true"
/>
</presetdef>
<!--Create a public API jar file into directory containig all the
public API jar files. The default implementation of this target is
empty and the component should override this if it provides public
APIs -->
<target name="create.public.api.jar">
</target>
<!--Updated the classes into the common jar file. If the Java code contains
cldc compilable code it is put into jar file ${impl.cldc.jar} otherwise
${impl.cdc.jar} is updated.-->
<target name="add.classes.to.collection.jar" unless="no.collection.update">
<condition property="collection.target.jar"
value="${impl.cdc.jar}"
else="${impl.cldc.jar}">
<equals arg1="${bcp}" arg2="${bootclasspath.cdc}"/>
</condition>
<jar destfile="${collection.target.jar}"
basedir="${dst.dir}"
update="true"
/>
</target>
<!--INTERNAL, PUBLIC AND COLLECTION JAR FILE GENERATION END-->
<!--JAVAH START-->
<!--Run the javah if needed. Javah results goes to temp directory and
if they have changed, then they are copied into a directory that
is included to the component's makefile -->
<target name="javah" if="javah.classnames">
<javah destdir="${temp.javah.dir}" force="yes"
classpath="${classes.collection.dir}:${platform.api.jar}:${public.api.jar}"
class = "${javah.classnames}">
</javah>
<!--Copy the files if they are changed-->
<copy todir="${javah.dir}">
<fileset dir="${temp.javah.dir}" includes="*.h" casesensitive="false">
<different targetdir="${javah.dir}"
ignoreFileTimes="true"/>
</fileset>
</copy>
</target>
<!--JAVAH END-->
<!--EXPORT START-->
<!--Start the do.export using antcall. The usage of ant call is needed
in order to include platform specific utility xml file.-->
<target name="export" depends="init.properties, make.target.dirs">
<antcall target="do.export">
<param name="platform.utilities.xml.file"
value="${dyn.platform.utilities.xml.file}"/>
</antcall>
</target>
<!--EXPORT START-->
<!--RELEASEABLES FOR S60 START-->
<!--The common releasables-->
<target name="common.releasables" depends="init.properties">
<echo file="${java.src.root}/build/java_releasables_${target.platform}_${target.cfg}.tmp" append="false">${platform.api.jar}
${public.api.jar}
${impl.cldc.jar}
${impl.cdc.jar}
${signature.jar}
</echo>
</target>
<!--The only releasable in S60 is the odc file-->
<target name="s60releasables" if="target.s60">
<echo file="java_releasables_${target.platform}_${target.cfg}.tmp" append="false">${bcp.dest.directory}\${odc.file.name}.odc
</echo>
</target>
<!--The start point for releasables-->
<target name="releasables" depends="init.properties, s60releasables">
</target>
<!--RELEASEABLES FOR S60 END-->
<!--LOCALISATION START-->
<target name="collect.localisation.files" depends="init.properties"
if="localisation.file.base">
<zip destfile="${resource.jar}" update="true" filesonly="true">
<!-- Original localisation file -->
<zipfileset dir="../loc" prefix="resources/com/nokia/mj/impl"
includes="${localisation.file.base}.loc"/>
</zip>
</target>
<!--LOCALISATION END-->
<!--CLEANING START-->
<target name="clean" depends="clean.impl, component.clean">
</target>
<!--For overriding by the build.xml of the component-->
<target name="component.clean">
</target>
<!--Do the cleaning-->
<target name="clean.impl" depends="init.properties, clean.from.collection.jars,
emma.clean, cobertura.clean">
<!--
<echo message = "target.platform = ${target.platform}"/>
<echo message = "target.cfg = ${target.cfg}"/>
<echo message = "bootclasspath = ${bootclasspath}"/>
-->
<echo message=""/>
<!--Clean the javah results from inc.javah-->
<delete>
<fileset dir="${javah.dir}" includes="*.h">
<present present="both" targetdir="${temp.javah.dir}"/>
</fileset>
</delete>
<delete dir="${component.root.dir}"/>
<delete file="${bcp.dest.directory}/${jar.filename}"/>
<delete file="${bcp.dest.directory}/${odc.file.name}.odc"/>
</target>
<!--
This target will remove the classes of the component from
the collection jar files. It is quite time consuming so at the moment
this is not done by default unless the component specifies
collection.clean propert.
-->
<target name="clean.from.collection.jars" if="collection.clean">
<antcall target="clean.from.jar">
<param name="source.jar.file" value="${platform.api.jar}"/>
<param name="source.src.dir" value="${classes.collection.dir}"/>
</antcall>
<antcall target="clean.from.jar">
<param name="source.jar.file" value="${public.api.jar}"/>
<param name="source.src.dir" value="${classes.first.dir}"/>
</antcall>
<antcall target="clean.from.jar">
<param name="source.jar.file" value="${impl.cldc.jar}"/>
<param name="source.src.dir" value="${classes.first.dir}"/>
</antcall>
<antcall target="clean.from.jar">
<param name="source.jar.file" value="${impl.cdc.jar}"/>
<param name="source.src.dir" value="${classes.second.dir}"/>
</antcall>
</target>
<target name="existence.check">
<available file="${source.jar.file}" property="cleaning.jar.present"/>
</target>
<target name="clean.from.jar" depends="existence.check" if="cleaning.jar.present">
<property name="clean.tmp" location="${component.root.dir}/cleantmp"/>
<mkdir dir="${clean.tmp}"/>
<unzip src="${source.jar.file}" dest="${clean.tmp}/"/>
<delete file="${source.jar.file}"/>
<jar destfile="${source.jar.file}">
<fileset dir="${clean.tmp}">
<present present="srconly" targetdir="${source.src.dir}"/>
</fileset>
</jar>
<delete dir="${clean.tmp}"/>
</target>
<!--Do the cleaning-->
<target name="clean.api.jars" depends="init.properties">
<delete file="${platform.api.jar}"/>
<delete file="${public.api.jar}"/>
<delete file="${impl.cldc.jar}"/>
<delete file="${impl.cdc.jar}"/>
<delete file="${signature.jar}"/>
</target>
<!--CLEANING END-->
<!--Generate signature jar file-->
<target name="generate.signature.jars" depends="init.properties">
<zip destfile="${signature.jar}">
<zipfileset src="${bootclasspath.cldc}"/>
<zipfileset src="${impl.cldc.jar}"/>
</zip>
</target>
<!--GENERATE JAVADOC START-->
<target name="javadoc" description="Create javadoc. Use -javadoc.dir=dir to override location">
<property name="javadoc.dir" value="javadoc" />
<javadoc destdir="${javadoc.dir}"
version="true"
use="true"
defaultexcludes="true"
windowtitle="Runtime API">
<fileset dir="${java.src.root}/javacommons/" defaultexcludes="yes">
<include name="utils/javasrc/com/nokia/mj/impl/rt/support/*.java"/>
<include name="utils/javasrc/com/nokia/mj/impl/utils/**/*.java"/>
<include name="utils/javasrc/com/nokia/mj/impl/rt/ui/**/*.java"/>
<include name="fileutils/javasrc/**/*.java"/>
<include name="comms/javasrc/**/*.java"/>
<include name="javastorage/javasrc/**/*.java"/>
</fileset>
<doctitle><![CDATA[<h1>Runtime API</h1>]]></doctitle>
<bottom><![CDATA[<i>Copyright © 2008 Nokia. All Rights Reserved.</i>]]></bottom>
</javadoc>
</target>
<!--GENERATE JAVADOC END-->
</project>