### Example ant-javacard Build Output

Source: https://github.com/martinpaljak/ant-javacard/blob/next/README.md

This is an example of the console output when the ant-javacard task is executed, showing the SDKs being used, package names, generated applet AIDs, and the final CAP file location.

```text
target:
      [cap] INFO: using JavaCard 3.0.5 SDK in sdks/jc305u4_kit
      [cap] INFO: targeting JavaCard 2.2.2 SDK in sdks/jc222_kit
      [cap] Setting package name to testapplets.empty
      [cap] INFO: generated applet AID: A000000617008E5CDAAE01 for testapplets.empty.Empty
      [cap] Building CAP with 1 applet from package testapplets.empty (AID: A000000617008E5CDAAE)
      [cap] testapplets.empty.Empty A000000617008E5CDAAE01
  [compile] Compiling files from /Users/martin/projects/ant-javacard/src/testapplets/empty
  [compile] Compiling 1 source file to /var/folders/gf/_m9mq9td3lz32qv1hd4r12yw0000gn/T/jccpro841338375581620546
      [cap] CAP saved to /Users/martin/projects/ant-javacard/Empty_A000000617008E5CDAAE_50da91a4_2.2.2.cap
```

--------------------------------

### Download ant-javacard.jar with Ant

Source: https://github.com/martinpaljak/ant-javacard/blob/next/README.md

Use the Ant get task to download the ant-javacard.jar file. Set skipexisting to true to avoid re-downloading if the file already exists.

```xml
<get src="https://github.com/martinpaljak/ant-javacard/releases/latest/download/ant-javacard.jar" dest="." skipexisting="true"/>
```

--------------------------------

### Maven Integration with `maven-antrun-plugin`

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Integrate `ant-javacard` into a Maven build by using the `maven-antrun-plugin`. This example shows how to configure the plugin to execute an Ant build file (`build.xml`) during the `package` phase.

```xml
<build>
    <plugins>
        <plugin>
            <artifactId>maven-antrun-plugin</artifactId>
            <version>3.2.0</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <configuration>
                        <target>
                            <ant antfile="build.xml" inheritAll="false"/>
                        </target>
                    </configuration>
                    <goals>
                        <goal>run</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
```

```xml
<!-- <taskdef name="javacard" classname="pro.javacard.ant.JavaCard" classpath="ant-javacard.jar"/> -->
<!-- <javacard jckit="sdks/jc305u4_kit"> ... </javacard> -->
```

--------------------------------

### Configure Ant JavaCard for Modern JavaCards (JDK 17)

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Use this configuration to target modern JavaCards (3.0.4+) with JDK 17 and SDK 3.2.0. Ensure JAVA_HOME is set to your JDK 17 installation when running the build.

```xml
<javacard>
    <cap jckit="sdks/jc320v24.0_kit"
         targetsdk="3.0.5"
         sources="src/main/javacard"
         aid="A000000062">
        <applet class="com.example.MyApplet" aid="A00000006201"/>
    </cap>
</javacard>
```

```bash
JAVA_HOME=/path/to/jdk17 ant build
```

--------------------------------

### Configure Ant JavaCard for Legacy JavaCards (JDK 11)

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Use this configuration for legacy JavaCard versions (2.2.x) with JDK 11 and SDK 3.0.5. Ensure JAVA_HOME is set to your JDK 11 installation when running the build.

```xml
<javacard>
    <cap jckit="sdks/jc305u4_kit"
         targetsdk="sdks/jc222_kit"
         sources="src/main/javacard"
         aid="A000000062">
        <applet class="com.example.MyApplet" aid="A00000006201"/>
    </cap>
</javacard>
```

```bash
JAVA_HOME=/path/to/jdk11 ant build
```

--------------------------------

### Configure Global SDK for CAP Builds

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Use the `<javacard>` task to set a default SDK path for all nested `<cap>` elements. This ensures a consistent build environment for multiple CAP files.

```xml
<!-- build.xml: use a global jckit for all cap elements in this target -->
<target name="build" depends="init">
    <javacard jckit="sdks/jc305u4_kit">
        <!-- All <cap> children inherit this SDK unless they override it -->
        <cap sources="src/main/javacard" aid="0102030405">
            <applet class="com.example.MyApplet" aid="010203040501"/>
        </cap>
    </javacard>
</target>
```

--------------------------------

### Build a JavaCard CAP File with Detailed Configuration

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Configure the `<cap>` element for building a CAP file, specifying SDKs, source paths, output names, and various build options like export, debug, and integer handling.

```xml
<!-- Full example: explicit SDK, custom output name, export, debug off, ints on -->
<javacard>
    <cap jckit="sdks/jc305u4_kit"
         targetsdk="sdks/jc222_kit"
         sources="src/main/javacard"
         classes="build/classes"
         package="com.example.myapplet"
         aid="A000000062"
         version="1.2"
         output="MyApplet_%v_%h.cap"
         export="dist/export"
         jar="dist/myapplet.jar"
         jca="dist/myapplet.jca"
         debug="false"
         strip="false"
         ints="true"
         verify="true">
        <applet class="com.example.myapplet.MyApplet" aid="A00000006201"/>
        <import jar="lib/gpapi.jar" exps="lib/gpapi-exps"/>
    </cap>
</javacard>
<!-- Expected output:
     [cap] INFO: using JavaCard 3.0.5 SDK in sdks/jc305u4_kit with JDK 11
     [cap] INFO: targeting JavaCard 2.2.2 SDK in sdks/jc222_kit
     [cap] Building CAP with 1 applet from package com.example.myapplet (AID: A000000062)
     [cap] com.example.myapplet.MyApplet A00000006201
 [compile] Compiling 1 source file to /tmp/jccproXXXXXX
     [cap] CAP saved to MyApplet_v1.2_9a037e30.cap
-->
```

--------------------------------

### Run Off-Card Verifier

Source: https://github.com/martinpaljak/ant-javacard/blob/next/README.md

Execute the off-card verifier with specified SDK, target SDK, CAP file, and export files. The SDK path is required, and target SDK is optional.

```bash
java -jar ant-javacard.jar <sdk> [<targetsdk>] <capfile> <expfiles>
```

--------------------------------

### Configure Javacard CAP File Build

Source: https://github.com/martinpaljak/ant-javacard/blob/next/README.md

Use the <javacard> and <cap> tags to define the build process for a Java Card applet's CAP file. Specify SDK paths, source/class locations, applet details, and output configurations.

```xml
<javacard jckit="/path/to/jckit_dir1">
  <cap targetsdk="/path/to/jckit_dir2" aid="0102030405" package="package.name" version="0.1" output="MyApplet.cap" sources="src/myapplet" classes="path/to/classes" export="mylib">
    <applet class="myapplet.MyApplet" aid="0102030405060708"/>
    <import exps="path/to/exps" jar="/path/to/lib.jar"/>
  </cap>
</javacard>
```

--------------------------------

### Create JavaCard CAP Files with Ant

Source: https://github.com/martinpaljak/ant-javacard/blob/next/README.md

Use the defined 'javacard' task to create CAP files. Specify the JavaCard Kit directory and the main applet AID. Nested 'applet' tags define individual applets within the CAP file, including their class and AID.

```xml
<javacard>
  <cap jckit="/path/to/jckit_dir" aid="0102030405">
    <applet class="myapplet.MyApplet" aid="0102030405060708"/>
  </cap>
</javacard>
```

--------------------------------

### Import External Library JAR and Export Files

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Link an applet against an external JavaCard library JAR for compilation and its .exp files for the converter. The 'jar' attribute is for the classpath, and 'exps' provides the folder of .exp files.

```xml
<!-- Build a library first, then use it in an applet -->
<target name="build-library" depends="init">
    <javacard jckit="sdks/jc305u4_kit">
        <cap targetsdk="sdks/jc222_kit"
             sources="src/testapplets/library"
             package="testapplets.library"
             aid="01020304050607"
             export="testlib"
             version="0.1"/>
    </javacard>
</target>

<target name="build-applet" depends="build-library">
    <javacard>
        <cap jckit="sdks/jc222_kit"
             sources="src/testapplets/libraryuser">
            <applet class="testapplets.libraryuser.LibraryUser" aid="0102030405060708"/>
            <!-- jar for compilation, exp files extracted automatically from jar -->
            <import jar="testlib/library.jar"/>
        </cap>
    </javacard>
</target>
```

--------------------------------

### Download and Define Ant JavaCard Task

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Automate the download of the ant-javacard.jar and define the 'javacard' task in your build.xml. This sets up the necessary Ant task for subsequent build steps.

```xml
<!-- build.xml: download the jar if not present, then define the task -->
<project name="my-applet" default="build">

    <!-- Step 1: Download the latest release -->
    <target name="fetch-task">
        <get src="https://github.com/martinpaljak/ant-javacard/releases/latest/download/ant-javacard.jar"
             dest="ant-javacard.jar"
             skipexisting="true"/>
    </target>

    <!-- Step 2: Load the task from the local jar -->
    <target name="init" depends="fetch-task">
        <taskdef name="javacard"
                 classname="pro.javacard.ant.JavaCard"
                 classpath="ant-javacard.jar"/>
    </target>

</project>
```

--------------------------------

### Off-Card Verification of CAP Files

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Perform off-card verification of a CAP file against a specified Java Card SDK. You can also specify a target SDK for compatibility checks and include external export files (`.exp` or `.jar`) for verification.

```bash
java -jar ant-javacard.jar sdks/jc305u4_kit MyApplet.cap
```

```bash
java -jar ant-javacard.jar sdks/jc305u4_kit sdks/jc222_kit MyApplet.cap
```

```bash
java -jar ant-javacard.jar sdks/jc305u4_kit MyApplet.cap lib/gpapi-exps
```

--------------------------------

### Dump CAP File Metadata

Source: https://github.com/martinpaljak/ant-javacard/blob/next/README.md

Use this command to extract metadata from a built .cap file. Ensure ant-javacard.jar is in your current directory or provide its full path.

```bash
java -jar ant-javacard.jar <capfile>
```

--------------------------------

### Declare Multiple Applets in a CAP File

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Declare multiple applets within a single CAP file, sharing a common package AID prefix. If an AID is omitted, it is auto-generated.

```xml
<javacard jckit="sdks/jc303_kit">
    <cap sources="src/testapplets/multiapp"
         aid="010203040506"
         output="Multiapp.cap">
        <applet class="testapplets.multiapp.First"  aid="01020304050607"/>
        <applet class="testapplets.multiapp.Second" aid="0102030405060708"/>
    </cap>
</javacard>
```

--------------------------------

### Load ant-javacard Task in build.xml

Source: https://github.com/martinpaljak/ant-javacard/blob/next/README.md

Define the ant-javacard task in your build.xml file by specifying the task name, classname, and the classpath pointing to the downloaded ant-javacard.jar.

```xml
<taskdef name="javacard" classname="pro.javacard.ant.JavaCard" classpath="ant-javacard.jar"/>
```

--------------------------------

### Environment Variables for Ant-Javacard

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Configure Ant-Javacard behavior using environment variables. These include specifying the Java Card SDK home (`JC_HOME`), the JDK home (`JAVA_HOME`), a temporary directory for build files (`ANT_JAVACARD_TMP`), and enabling debug logging (`ANT_JAVACARD_DEBUG`).

```bash
# Point to the JavaCard SDK to use when jckit is not set in build.xml
export JC_HOME=/path/to/jc305u4_kit

# Point to a specific JDK (critical for SDK/JDK compatibility)
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk

# Keep temporary build files for debugging (not cleaned up after build)
export ANT_JAVACARD_TMP=/tmp/jc-debug

# Enable verbose debug logging from ant-javacard
export ANT_JAVACARD_DEBUG=1

# Then run ant normally
ant build
```

--------------------------------

### Customize CAP Output File Name with Variables

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Customize the CAP file name using a template string with substitution variables. The default template is `%n_%a_%h_%j_%J.cap`.

```xml
<cap jckit="sdks/jc305u4_kit"
     sources="src/main/javacard"
     aid="A000000062"
     version="1.0"
     output="%n_%a_%v_%h_%H_%j_%J.cap">
    <!-- %n  = common name (applet class short name or package name) -->
    <!-- %a  = package AID hex                                        -->
    <!-- %v  = package version prefixed with 'v'                     -->
    <!-- %h  = first 8 hex chars of SHA-256 Load File Data Block hash -->
    <!-- %H  = full SHA-256 Load File Data Block hash                 -->
    <!-- %j  = targeted JavaCard version, e.g. 3.0.5                 -->
    <!-- %J  = JDK version used, e.g. jdk11                          -->
    <!-- %p  = full package name                                      -->
    <applet class="com.example.MyApplet" aid="A00000006201"/>
</cap>
```

--------------------------------

### Select Specific Source Files with Nested Sources

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Use nested `<sources>` elements to define per-directory include/exclude patterns for fine-grained source file selection. This is mutually exclusive with the flat `sources` and `sources2` attributes on `<cap>`.

```xml
<javacard jckit="sdks/jc305u4_kit">
    <cap aid="A000000062" package="com.example.combined">
        <applet class="com.example.combined.Main" aid="A00000006201"/>
        <sources path="src/main/javacard"   includes="**/*.java" excludes="**/Test*.java"/>
        <sources path="src/shared/javacard" includes="com/example/shared/*.java"/>
    </cap>
</javacard>
```

--------------------------------

### Dump CAP File Metadata

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Use `ant-javacard.jar` to extract and display human-readable metadata from a `.cap` file, including AIDs, version, code size, and hashes. This is useful for understanding the contents of a compiled Java Card applet package.

```bash
java -jar ant-javacard.jar MyApplet_A000000062_9a037e30_2.2.2_jdk11.cap
```

--------------------------------

### Maven Dependency for `capfile` Library

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Add the `javacard.pro` repository and include the `capfile` library as a Maven dependency. This allows independent use of CAP file parsing and Java Card SDK related classes in your tools.

```xml
<repositories>
    <repository>
        <id>javacard-pro</id>
        <url>https://mvn.javacard.pro/maven/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>com.github.martinpaljak</groupId>
        <artifactId>capfile</artifactId>
        <version>24.03.08</version>  <!-- use latest release tag -->
    </dependency>
</dependencies>
```

--------------------------------

### Cross-Compile CAP for Older Java Card Versions

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Use the `targetsdk` attribute to specify a newer SDK's converter while targeting an older Java Card platform, ensuring backward compatibility. For multi-target SDKs (3.1+), use a version string.

```xml
<!-- Use JC 3.0.5 converter but produce a CAP targeting JC 2.2.2 -->
<javacard>
    <cap jckit="sdks/jc305u4_kit"
         targetsdk="sdks/jc222_kit"
         sources="src/main/javacard"
         aid="0102030405">
        <applet class="com.example.MyApplet" aid="010203040501"/>
    </cap>
</javacard>

<!-- For multi-target SDK (3.1+), use version string as targetsdk -->
<javacard>
    <cap jckit="sdks/jc320v24.0_kit"
         targetsdk="3.0.5"
         sources="src/main/javacard"
         aid="0102030405">
        <applet class="com.example.MyApplet" aid="010203040501"/>
    </cap>
</javacard>
```

--------------------------------

### Trigger ant-javacard from Maven

Source: https://github.com/martinpaljak/ant-javacard/wiki/How-to-use-from-Maven

Configure the maven-antrun-plugin in your pom.xml to execute ant-javacard tasks during the package phase. Ensure your build.xml is correctly set up.

```xml
<plugin>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>3.2.0</version>
    <executions>
        <execution>
            <phase>package</phase>
            <configuration>
                <target>
                    <ant antfile="build.xml" inheritAll="false"/>
                </target>
            </configuration>
            <goals>
                <goal>run</goal>
            </goals>
        </execution>
    </executions>
</plugin>
```

--------------------------------

### Add Maven Repository

Source: https://github.com/martinpaljak/ant-javacard/blob/next/README.md

Configure your pom.xml to include the javacard-pro Maven repository. This allows you to use ant-javacard as a dependency in your Maven projects.

```xml
<repositories>
    <repository>
        <id>javacard-pro</id>
        <url>https://mvn.javacard.pro/maven/</url>
    </repository>
</repositories>
```

--------------------------------

### Rename CAP File to Standard Name

Source: https://context7.com/martinpaljak/ant-javacard/llms.txt

Rename a CAP file to adhere to a standard naming convention based on its internal metadata. The `CAP_NAME_TEMPLATE` environment variable can be used to customize the output format.

```bash
java -jar ant-javacard.jar -r MyApplet.cap
```

```bash
CAP_NAME_TEMPLATE="%n_%v_%h.cap" java -jar ant-javacard.jar -r MyApplet.cap
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.