AKM SDK - AppEndpoint Integration

AppEndpoint Integration

This guide explains how to integrate your application with AKM through the AppEndpoint's APP API. Applications communicate with AppEndpoint via a TCP socket connection on port 49600.

Connection Setup

Connect to AppEndpoint using a standard TCP socket:

Socket Connection

import socket

# Connect to AppEndpoint
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("127.0.0.1", 49600))
print("[*] Connected to AppEndpoint")

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define APP_API_PORT 49600
#define APP_API_HOST "127.0.0.1"

int main() {
    int sock;
    struct sockaddr_in server_addr;

    // Create socket
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket");
        return 1;
    }

    // Connect to AppEndpoint
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(APP_API_PORT);
    inet_pton(AF_INET, APP_API_HOST, &server_addr.sin_addr);

    if (connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("connect");
        close(sock);
        return 1;
    }

    printf("[*] Connected to AppEndpoint\n");
    return 0;
}

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdexcept>

class AppEndpointClient {
public:
    static constexpr int PORT = 49600;
    static constexpr const char* HOST = "127.0.0.1";

    AppEndpointClient() : sock_(-1) {}

    ~AppEndpointClient() {
        if (sock_ >= 0) close(sock_);
    }

    void connect() {
        sock_ = socket(AF_INET, SOCK_STREAM, 0);
        if (sock_ < 0) {
            throw std::runtime_error("Failed to create socket");
        }

        sockaddr_in server_addr{};
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(PORT);
        inet_pton(AF_INET, HOST, &server_addr.sin_addr);

        if (::connect(sock_, (sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
            close(sock_);
            throw std::runtime_error("Failed to connect");
        }

        std::cout << "[*] Connected to AppEndpoint" << std::endl;
    }

private:
    int sock_;
};

int main() {
    AppEndpointClient client;
    client.connect();
    return 0;
}

use std::net::TcpStream;
use std::io::{self, Read, Write};

const APP_API_HOST: &str = "127.0.0.1";
const APP_API_PORT: u16 = 49600;

fn main() -> io::Result<()> {
    // Connect to AppEndpoint
    let stream = TcpStream::connect((APP_API_HOST, APP_API_PORT))?;
    println!("[*] Connected to AppEndpoint");

    Ok(())
}

APP API Header Format

All messages to/from AppEndpoint must be prefixed with a 12-byte header:

Offset	Size	Field	Value
0	4	SOM (Start of Message)	`0xA55A5AA5`
4	2	Version	`(Major << 8) \| Minor`
6	2	Length	Payload length (U16)
8	2	~Length	Bitwise complement of length
10	2	Reserved	`0x0000`

Build AKM Header

import struct

AKM_APPENDPOINT_APP_API_SOM = 0xA55A5AA5
AKM_MAJOR_VERSION = 1
AKM_MINOR_VERSION = 0

FMT_AKM_HEADER = "<LHHH2s"   # 12 bytes
AKM_HEADER_SIZE = struct.calcsize(FMT_AKM_HEADER)  # 12

def build_akm_header(payload_len):
    """Build the 12-byte AKM header for a message."""
    version = (AKM_MAJOR_VERSION << 8) | AKM_MINOR_VERSION
    msg_len = payload_len
    msg_len_comp = (~msg_len) & 0xFFFF
    return struct.pack(
        FMT_AKM_HEADER,
        AKM_APPENDPOINT_APP_API_SOM,
        version,
        msg_len,
        msg_len_comp,
        b"\x00\x00"
    )

#include <stdint.h>
#include <string.h>

#define AKM_APP_API_SOM       0xA55A5AA5
#define AKM_MAJOR_VERSION     1
#define AKM_MINOR_VERSION     0
#define AKM_HEADER_SIZE       12

typedef struct __attribute__((packed)) {
    uint32_t som;
    uint16_t version;
    uint16_t length;
    uint16_t length_complement;
    uint16_t reserved;
} akm_header_t;

void build_akm_header(akm_header_t* hdr, uint16_t payload_len) {
    hdr->som = AKM_APP_API_SOM;
    hdr->version = (AKM_MAJOR_VERSION << 8) | AKM_MINOR_VERSION;
    hdr->length = payload_len;
    hdr->length_complement = ~payload_len;
    hdr->reserved = 0;
}

#include <cstdint>
#include <array>
#include <vector>

constexpr uint32_t AKM_APP_API_SOM = 0xA55A5AA5;
constexpr uint8_t AKM_MAJOR_VERSION = 1;
constexpr uint8_t AKM_MINOR_VERSION = 0;
constexpr size_t AKM_HEADER_SIZE = 12;

#pragma pack(push, 1)
struct AkmHeader {
    uint32_t som;
    uint16_t version;
    uint16_t length;
    uint16_t length_complement;
    uint16_t reserved;

    AkmHeader(uint16_t payload_len)
        : som(AKM_APP_API_SOM)
        , version((AKM_MAJOR_VERSION << 8) | AKM_MINOR_VERSION)
        , length(payload_len)
        , length_complement(~payload_len)
        , reserved(0) {}

    std::array<uint8_t, AKM_HEADER_SIZE> to_bytes() const {
        std::array<uint8_t, AKM_HEADER_SIZE> buf;
        std::memcpy(buf.data(), this, AKM_HEADER_SIZE);
        return buf;
    }
};
#pragma pack(pop)

const AKM_APP_API_SOM: u32 = 0xA55A5AA5;
const AKM_MAJOR_VERSION: u8 = 1;
const AKM_MINOR_VERSION: u8 = 0;
const AKM_HEADER_SIZE: usize = 12;

#[repr(C, packed)]
#[derive(Clone, Copy)]
struct AkmHeader {
    som: u32,
    version: u16,
    length: u16,
    length_complement: u16,
    reserved: u16,
}

impl AkmHeader {
    fn new(payload_len: u16) -> Self {
        Self {
            som: AKM_APP_API_SOM,
            version: ((AKM_MAJOR_VERSION as u16) << 8) | (AKM_MINOR_VERSION as u16),
            length: payload_len,
            length_complement: !payload_len,
            reserved: 0,
        }
    }

    fn to_bytes(&self) -> [u8; AKM_HEADER_SIZE] {
        unsafe { std::mem::transmute(*self) }
    }
}

Registration Flow

Before sending data, your application must register with an ATR ID and unique App Value. The App Value identifies your application within the ATR and must be unique among all applications registered to the same ATR.

Important: Each application must use a unique App Value. Two applications on the same ATR cannot share the same App Value.

Register Request

REGISTER_APP_REQUEST = 0x00000004
REGISTER_APP_RESPONSE = 0x00000044
STRUCT_REGISTER_REQUEST = "<LHH"  # opcode (4) + ATR_ID (2) + App_Value (2)

def build_register_request(atrid, appvalue):
    """Build a registration request packet."""
    payload = struct.pack(
        STRUCT_REGISTER_REQUEST,
        REGISTER_APP_REQUEST,
        atrid,
        appvalue
    )
    return build_akm_header(len(payload)) + payload

# Example: Register with ATR ID 0x0001 and App Value 100
packet = build_register_request(0x0001, 100)
sock.sendall(packet)

#define REGISTER_APP_REQUEST    0x00000004
#define REGISTER_APP_RESPONSE   0x00000044

typedef struct __attribute__((packed)) {
    uint32_t opcode;
    uint16_t atr_id;
    uint16_t app_value;
} register_request_t;

int send_register_request(int sock, uint16_t atr_id, uint16_t app_value) {
    uint8_t buffer[AKM_HEADER_SIZE + sizeof(register_request_t)];
    akm_header_t* hdr = (akm_header_t*)buffer;
    register_request_t* req = (register_request_t*)(buffer + AKM_HEADER_SIZE);

    build_akm_header(hdr, sizeof(register_request_t));
    req->opcode = REGISTER_APP_REQUEST;
    req->atr_id = atr_id;
    req->app_value = app_value;

    return send(sock, buffer, sizeof(buffer), 0);
}

// Example: Register with ATR ID 0x0001 and App Value 100
send_register_request(sock, 0x0001, 100);

constexpr uint32_t REGISTER_APP_REQUEST = 0x00000004;
constexpr uint32_t REGISTER_APP_RESPONSE = 0x00000044;

#pragma pack(push, 1)
struct RegisterRequest {
    uint32_t opcode;
    uint16_t atr_id;
    uint16_t app_value;
};
#pragma pack(pop)

std::vector<uint8_t> build_register_request(uint16_t atr_id, uint16_t app_value) {
    RegisterRequest req{REGISTER_APP_REQUEST, atr_id, app_value};
    AkmHeader hdr(sizeof(RegisterRequest));

    std::vector<uint8_t> packet(AKM_HEADER_SIZE + sizeof(RegisterRequest));
    auto hdr_bytes = hdr.to_bytes();
    std::memcpy(packet.data(), hdr_bytes.data(), AKM_HEADER_SIZE);
    std::memcpy(packet.data() + AKM_HEADER_SIZE, &req, sizeof(RegisterRequest));

    return packet;
}

// Example: Register with ATR ID 0x0001 and App Value 100
auto packet = build_register_request(0x0001, 100);
send(sock, packet.data(), packet.size(), 0);

const REGISTER_APP_REQUEST: u32 = 0x00000004;
const REGISTER_APP_RESPONSE: u32 = 0x00000044;

#[repr(C, packed)]
struct RegisterRequest {
    opcode: u32,
    atr_id: u16,
    app_value: u16,
}

fn build_register_request(atr_id: u16, app_value: u16) -> Vec<u8> {
    let header = AkmHeader::new(std::mem::size_of::<RegisterRequest>() as u16);
    let request = RegisterRequest {
        opcode: REGISTER_APP_REQUEST,
        atr_id,
        app_value,
    };

    let mut packet = Vec::with_capacity(AKM_HEADER_SIZE + std::mem::size_of::<RegisterRequest>());
    packet.extend_from_slice(&header.to_bytes());
    packet.extend_from_slice(&unsafe {
        std::mem::transmute::<_, [u8; 8]>(request)
    });
    packet
}

// Example: Register with ATR ID 0x0001 and App Value 100
let packet = build_register_request(0x0001, 100);
stream.write_all(&packet)?;

Sending Data

Once registered, use SEND_APP_DATA_REQUEST to send data to another application on the same ATR:

Send Data

MAX_APP_BUFFER_SIZE = 4046
SEND_APP_DATA_REQUEST = 0x00000005
STRUCT_SEND_DATA_REQUEST = f"<LHH{MAX_APP_BUFFER_SIZE}sL"

def build_app_data_packet(message, atrid, target_appvalue):
    """Build a data packet to send to another application."""
    data = message.encode()
    padded = data.ljust(MAX_APP_BUFFER_SIZE, b"\x00")

    payload = struct.pack(
        STRUCT_SEND_DATA_REQUEST,
        SEND_APP_DATA_REQUEST,
        atrid,
        target_appvalue,
        padded,
        len(data)
    )

    return build_akm_header(len(payload)) + payload

# Send "Hello" to App Value 200 on ATR 0x0001
packet = build_app_data_packet("Hello", 0x0001, 200)
sock.sendall(packet)

#define MAX_APP_BUFFER_SIZE     4046
#define SEND_APP_DATA_REQUEST   0x00000005

typedef struct __attribute__((packed)) {
    uint32_t opcode;
    uint16_t atr_id;
    uint16_t target_app_value;
    uint8_t  data[MAX_APP_BUFFER_SIZE];
    uint32_t data_length;
} send_data_request_t;

int send_app_data(int sock, uint16_t atr_id, uint16_t target_app_value,
                  const uint8_t* data, uint32_t data_len) {
    size_t packet_size = AKM_HEADER_SIZE + sizeof(send_data_request_t);
    uint8_t* buffer = (uint8_t*)calloc(1, packet_size);

    akm_header_t* hdr = (akm_header_t*)buffer;
    send_data_request_t* req = (send_data_request_t*)(buffer + AKM_HEADER_SIZE);

    build_akm_header(hdr, sizeof(send_data_request_t));
    req->opcode = SEND_APP_DATA_REQUEST;
    req->atr_id = atr_id;
    req->target_app_value = target_app_value;
    memcpy(req->data, data, data_len < MAX_APP_BUFFER_SIZE ? data_len : MAX_APP_BUFFER_SIZE);
    req->data_length = data_len;

    int result = send(sock, buffer, packet_size, 0);
    free(buffer);
    return result;
}

// Send "Hello" to App Value 200 on ATR 0x0001
const char* msg = "Hello";
send_app_data(sock, 0x0001, 200, (uint8_t*)msg, strlen(msg));

constexpr size_t MAX_APP_BUFFER_SIZE = 4046;
constexpr uint32_t SEND_APP_DATA_REQUEST = 0x00000005;

#pragma pack(push, 1)
struct SendDataRequest {
    uint32_t opcode;
    uint16_t atr_id;
    uint16_t target_app_value;
    uint8_t  data[MAX_APP_BUFFER_SIZE];
    uint32_t data_length;
};
#pragma pack(pop)

std::vector<uint8_t> build_send_data_packet(uint16_t atr_id, uint16_t target_app_value,
                                            const std::string& message) {
    SendDataRequest req{};
    req.opcode = SEND_APP_DATA_REQUEST;
    req.atr_id = atr_id;
    req.target_app_value = target_app_value;
    std::memcpy(req.data, message.data(),
                std::min(message.size(), MAX_APP_BUFFER_SIZE));
    req.data_length = static_cast<uint32_t>(message.size());

    AkmHeader hdr(sizeof(SendDataRequest));
    std::vector<uint8_t> packet(AKM_HEADER_SIZE + sizeof(SendDataRequest));
    auto hdr_bytes = hdr.to_bytes();
    std::memcpy(packet.data(), hdr_bytes.data(), AKM_HEADER_SIZE);
    std::memcpy(packet.data() + AKM_HEADER_SIZE, &req, sizeof(SendDataRequest));

    return packet;
}

// Send "Hello" to App Value 200 on ATR 0x0001
auto packet = build_send_data_packet(0x0001, 200, "Hello");
send(sock, packet.data(), packet.size(), 0);

const MAX_APP_BUFFER_SIZE: usize = 4046;
const SEND_APP_DATA_REQUEST: u32 = 0x00000005;

#[repr(C, packed)]
struct SendDataRequest {
    opcode: u32,
    atr_id: u16,
    target_app_value: u16,
    data: [u8; MAX_APP_BUFFER_SIZE],
    data_length: u32,
}

fn build_send_data_packet(atr_id: u16, target_app_value: u16, message: &[u8]) -> Vec<u8> {
    let mut request = SendDataRequest {
        opcode: SEND_APP_DATA_REQUEST,
        atr_id,
        target_app_value,
        data: [0u8; MAX_APP_BUFFER_SIZE],
        data_length: message.len() as u32,
    };

    let copy_len = message.len().min(MAX_APP_BUFFER_SIZE);
    request.data[..copy_len].copy_from_slice(&message[..copy_len]);

    let header = AkmHeader::new(std::mem::size_of::<SendDataRequest>() as u16);

    let mut packet = Vec::with_capacity(AKM_HEADER_SIZE + std::mem::size_of::<SendDataRequest>());
    packet.extend_from_slice(&header.to_bytes());
    packet.extend_from_slice(unsafe {
        std::slice::from_raw_parts(
            &request as *const _ as *const u8,
            std::mem::size_of::<SendDataRequest>()
        )
    });
    packet
}

// Send "Hello" to App Value 200 on ATR 0x0001
let packet = build_send_data_packet(0x0001, 200, b"Hello");
stream.write_all(&packet)?;

Receiving Data

Incoming data arrives asynchronously as RECEIVE_APP_DATA_RESPONSE messages. Use a receive thread to handle incoming data:

Receive Loop

import threading

RECEIVE_APP_DATA_RESPONSE = 0x00000046

def recv_exact(sock, size):
    """Receive exactly `size` bytes from socket."""
    data = b""
    while len(data) < size:
        chunk = sock.recv(size - len(data))
        if not chunk:
            raise ConnectionError("Socket closed")
        data += chunk
    return data

def receive_loop(sock, stop_event):
    """Background thread to receive data from AppEndpoint."""
    while not stop_event.is_set():
        # Read AKM header (12 bytes)
        hdr = recv_exact(sock, AKM_HEADER_SIZE)
        som, version, msg_len, msg_len_comp, _ = struct.unpack(FMT_AKM_HEADER, hdr)

        # Validate header
        if som != AKM_APPENDPOINT_APP_API_SOM:
            raise ValueError(f"Invalid SOM: 0x{som:08X}")
        if msg_len != (~msg_len_comp & 0xFFFF):
            raise ValueError("Length complement mismatch")

        # Read payload
        payload = recv_exact(sock, msg_len)
        resp_code = struct.unpack("<L", payload[:4])[0]

        if resp_code == RECEIVE_APP_DATA_RESPONSE:
            atrid, appv = struct.unpack("<HH", payload[4:8])
            buf = payload[8:8 + MAX_APP_BUFFER_SIZE]
            length = struct.unpack("<L", payload[8 + MAX_APP_BUFFER_SIZE:12 + MAX_APP_BUFFER_SIZE])[0]
            message = buf[:length].decode(errors="ignore")

            print(f"[RX] From ATR=0x{atrid:04X} App={appv}: {message}")

# Start receive thread
stop_event = threading.Event()
rx_thread = threading.Thread(target=receive_loop, args=(sock, stop_event), daemon=True)
rx_thread.start()

#include <pthread.h>

#define RECEIVE_APP_DATA_RESPONSE 0x00000046

typedef struct __attribute__((packed)) {
    uint32_t opcode;
    uint16_t atr_id;
    uint16_t source_app_value;
    uint8_t  data[MAX_APP_BUFFER_SIZE];
    uint32_t data_length;
} receive_data_response_t;

int recv_exact(int sock, void* buf, size_t len) {
    size_t received = 0;
    while (received < len) {
        ssize_t n = recv(sock, (uint8_t*)buf + received, len - received, 0);
        if (n <= 0) return -1;
        received += n;
    }
    return 0;
}

void* receive_loop(void* arg) {
    int sock = *(int*)arg;
    uint8_t buffer[AKM_HEADER_SIZE + sizeof(receive_data_response_t)];

    while (1) {
        akm_header_t hdr;
        if (recv_exact(sock, &hdr, AKM_HEADER_SIZE) < 0) break;

        // Validate header
        if (hdr.som != AKM_APP_API_SOM) break;
        if (hdr.length != (uint16_t)~hdr.length_complement) break;

        // Read payload
        uint8_t payload[4096];
        if (recv_exact(sock, payload, hdr.length) < 0) break;

        uint32_t opcode = *(uint32_t*)payload;
        if (opcode == RECEIVE_APP_DATA_RESPONSE) {
            receive_data_response_t* resp = (receive_data_response_t*)payload;
            printf("[RX] From ATR=0x%04X App=%d: %.*s\n",
                   resp->atr_id, resp->source_app_value,
                   resp->data_length, resp->data);
        }
    }
    return NULL;
}

// Start receive thread
pthread_t rx_thread;
pthread_create(&rx_thread, NULL, receive_loop, &sock);

#include <thread>
#include <atomic>

constexpr uint32_t RECEIVE_APP_DATA_RESPONSE = 0x00000046;

#pragma pack(push, 1)
struct ReceiveDataResponse {
    uint32_t opcode;
    uint16_t atr_id;
    uint16_t source_app_value;
    uint8_t  data[MAX_APP_BUFFER_SIZE];
    uint32_t data_length;
};
#pragma pack(pop)

class AppEndpointClient {
public:
    void start_receive_thread() {
        running_ = true;
        rx_thread_ = std::thread([this]() { receive_loop(); });
    }

    void stop() {
        running_ = false;
        if (rx_thread_.joinable()) rx_thread_.join();
    }

private:
    void receive_loop() {
        while (running_) {
            AkmHeader hdr{0};
            if (!recv_exact(&hdr, AKM_HEADER_SIZE)) break;

            if (hdr.som != AKM_APP_API_SOM) break;
            if (hdr.length != static_cast<uint16_t>(~hdr.length_complement)) break;

            std::vector<uint8_t> payload(hdr.length);
            if (!recv_exact(payload.data(), hdr.length)) break;

            uint32_t opcode = *reinterpret_cast<uint32_t*>(payload.data());
            if (opcode == RECEIVE_APP_DATA_RESPONSE) {
                auto* resp = reinterpret_cast<ReceiveDataResponse*>(payload.data());
                std::string msg(resp->data, resp->data + resp->data_length);
                std::cout << "[RX] From ATR=0x" << std::hex << resp->atr_id
                          << " App=" << std::dec << resp->source_app_value
                          << ": " << msg << std::endl;
            }
        }
    }

    bool recv_exact(void* buf, size_t len) {
        size_t received = 0;
        while (received < len) {
            ssize_t n = recv(sock_, (uint8_t*)buf + received, len - received, 0);
            if (n <= 0) return false;
            received += n;
        }
        return true;
    }

    int sock_;
    std::atomic<bool> running_{false};
    std::thread rx_thread_;
};

use std::thread;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;

const RECEIVE_APP_DATA_RESPONSE: u32 = 0x00000046;

#[repr(C, packed)]
struct ReceiveDataResponse {
    opcode: u32,
    atr_id: u16,
    source_app_value: u16,
    data: [u8; MAX_APP_BUFFER_SIZE],
    data_length: u32,
}

fn recv_exact(stream: &mut TcpStream, buf: &mut [u8]) -> io::Result<()> {
    let mut received = 0;
    while received < buf.len() {
        let n = stream.read(&mut buf[received..])?;
        if n == 0 {
            return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "connection closed"));
        }
        received += n;
    }
    Ok(())
}

fn receive_loop(mut stream: TcpStream, running: Arc<AtomicBool>) {
    let mut hdr_buf = [0u8; AKM_HEADER_SIZE];

    while running.load(Ordering::Relaxed) {
        if recv_exact(&mut stream, &mut hdr_buf).is_err() { break; }

        let hdr: AkmHeader = unsafe { std::ptr::read(hdr_buf.as_ptr() as *const _) };

        if hdr.som != AKM_APP_API_SOM { break; }
        if hdr.length != !hdr.length_complement { break; }

        let mut payload = vec![0u8; hdr.length as usize];
        if recv_exact(&mut stream, &mut payload).is_err() { break; }

        let opcode = u32::from_le_bytes(payload[0..4].try_into().unwrap());
        if opcode == RECEIVE_APP_DATA_RESPONSE {
            let resp: &ReceiveDataResponse = unsafe {
                &*(payload.as_ptr() as *const ReceiveDataResponse)
            };
            let msg = String::from_utf8_lossy(&resp.data[..resp.data_length as usize]);
            println!("[RX] From ATR=0x{:04X} App={}: {}",
                     resp.atr_id, resp.source_app_value, msg);
        }
    }
}

// Start receive thread
let running = Arc::new(AtomicBool::new(true));
let stream_clone = stream.try_clone()?;
let running_clone = running.clone();
thread::spawn(move || receive_loop(stream_clone, running_clone));

Protocol Constants

Constants

# AKM Header
AKM_APPENDPOINT_APP_API_SOM = 0xA55A5AA5
AKM_MAJOR_VERSION = 1
AKM_MINOR_VERSION = 0
AKM_HEADER_SIZE = 12

# Buffer sizes
MAX_APP_BUFFER_SIZE = 4046
MAX_APP_PAYLOAD_SIZE = 4084
TOTAL_ATRS_ALLOWED = 10

# Request codes
GET_ENDPOINT_INFO_REQUEST = 0x00000001
GET_ATR_INFO_REQUEST = 0x00000002
GET_VERSION_REQUEST = 0x00000003
REGISTER_APP_REQUEST = 0x00000004
SEND_APP_DATA_REQUEST = 0x00000005

# Response codes
GET_ENDPOINT_INFO_RESPONSE = 0x00000041
GET_ATR_INFO_RESPONSE = 0x00000042
GET_VERSION_RESPONSE = 0x00000043
REGISTER_APP_RESPONSE = 0x00000044
RECEIVE_APP_DATA_RESPONSE = 0x00000046

// AKM Header
#define AKM_APP_API_SOM           0xA55A5AA5
#define AKM_MAJOR_VERSION         1
#define AKM_MINOR_VERSION         0
#define AKM_HEADER_SIZE           12

// Buffer sizes
#define MAX_APP_BUFFER_SIZE       4046
#define MAX_APP_PAYLOAD_SIZE      4084
#define TOTAL_ATRS_ALLOWED        10

// Request codes
#define GET_ENDPOINT_INFO_REQUEST 0x00000001
#define GET_ATR_INFO_REQUEST      0x00000002
#define GET_VERSION_REQUEST       0x00000003
#define REGISTER_APP_REQUEST      0x00000004
#define SEND_APP_DATA_REQUEST     0x00000005

// Response codes
#define GET_ENDPOINT_INFO_RESPONSE  0x00000041
#define GET_ATR_INFO_RESPONSE       0x00000042
#define GET_VERSION_RESPONSE        0x00000043
#define REGISTER_APP_RESPONSE       0x00000044
#define RECEIVE_APP_DATA_RESPONSE   0x00000046

// AKM Header
constexpr uint32_t AKM_APP_API_SOM           = 0xA55A5AA5;
constexpr uint8_t  AKM_MAJOR_VERSION         = 1;
constexpr uint8_t  AKM_MINOR_VERSION         = 0;
constexpr size_t   AKM_HEADER_SIZE           = 12;

// Buffer sizes
constexpr size_t   MAX_APP_BUFFER_SIZE       = 4046;
constexpr size_t   MAX_APP_PAYLOAD_SIZE      = 4084;
constexpr size_t   TOTAL_ATRS_ALLOWED        = 10;

// Request codes
constexpr uint32_t GET_ENDPOINT_INFO_REQUEST = 0x00000001;
constexpr uint32_t GET_ATR_INFO_REQUEST      = 0x00000002;
constexpr uint32_t GET_VERSION_REQUEST       = 0x00000003;
constexpr uint32_t REGISTER_APP_REQUEST      = 0x00000004;
constexpr uint32_t SEND_APP_DATA_REQUEST     = 0x00000005;

// Response codes
constexpr uint32_t GET_ENDPOINT_INFO_RESPONSE  = 0x00000041;
constexpr uint32_t GET_ATR_INFO_RESPONSE       = 0x00000042;
constexpr uint32_t GET_VERSION_RESPONSE        = 0x00000043;
constexpr uint32_t REGISTER_APP_RESPONSE       = 0x00000044;
constexpr uint32_t RECEIVE_APP_DATA_RESPONSE   = 0x00000046;

// AKM Header
const AKM_APP_API_SOM: u32 = 0xA55A5AA5;
const AKM_MAJOR_VERSION: u8 = 1;
const AKM_MINOR_VERSION: u8 = 0;
const AKM_HEADER_SIZE: usize = 12;

// Buffer sizes
const MAX_APP_BUFFER_SIZE: usize = 4046;
const MAX_APP_PAYLOAD_SIZE: usize = 4084;
const TOTAL_ATRS_ALLOWED: usize = 10;

// Request codes
const GET_ENDPOINT_INFO_REQUEST: u32 = 0x00000001;
const GET_ATR_INFO_REQUEST: u32 = 0x00000002;
const GET_VERSION_REQUEST: u32 = 0x00000003;
const REGISTER_APP_REQUEST: u32 = 0x00000004;
const SEND_APP_DATA_REQUEST: u32 = 0x00000005;

// Response codes
const GET_ENDPOINT_INFO_RESPONSE: u32 = 0x00000041;
const GET_ATR_INFO_RESPONSE: u32 = 0x00000042;
const GET_VERSION_RESPONSE: u32 = 0x00000043;
const REGISTER_APP_RESPONSE: u32 = 0x00000044;
const RECEIVE_APP_DATA_RESPONSE: u32 = 0x00000046;

AppEndpoint Integration

AppEndpoint Integration

Connection Setup

APP API Header Format

Registration Flow

Sending Data

Receiving Data

Protocol Constants

Next Steps

API Reference

Examples