Bionic API status

#include <string.h>

// Always available
strlen, strcpy, strncpy, strcat, strncat
strcmp, strncmp, strchr, strrchr, strstr
memcpy, memmove, memset, memcmp, memchr
strtok, strerror, strdup

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

void safe_string_ops() {
    char dest[32];
    const char* src = "Hello, Android NDK!";
    
    // Use strncpy to prevent buffer overflow
    strncpy(dest, src, sizeof(dest) - 1);
    dest[sizeof(dest) - 1] = '\0'; // Ensure null termination
    
    // Use strncat for safe concatenation
    char buffer[64] = "Prefix: ";
    strncat(buffer, src, sizeof(buffer) - strlen(buffer) - 1);
    
    // Modern alternative: use strlcpy/strlcat (API 28+)
    #if __ANDROID_API__ >= 28
        char modern[32];
        strlcpy(modern, src, sizeof(modern));
    #endif
}

#include <math.h>

// Always available
sin, cos, tan, asin, acos, atan, atan2
sqrt, pow, exp, log, log10
fabs, ceil, floor, round, fmod

// Example usage
double calculate_distance(double x1, double y1, double x2, double y2) {
    double dx = x2 - x1;
    double dy = y2 - y1;
    return sqrt(dx * dx + dy * dy);
}

#if __ANDROID_API__ >= 26
#include <sys/random.h>

void generate_secure_random() {
    unsigned char random_data[32];
    if (getentropy(random_data, sizeof(random_data)) == 0) {
        // Use cryptographically secure random data
    }
}
#endif

#if __ANDROID_API__ >= 28
#include <string.h>

void safe_string_copy(char* dest, size_t dest_size, const char* src) {
    // Returns length of src, truncates if needed
    size_t result = strlcpy(dest, src, dest_size);
    
    if (result >= dest_size) {
        // String was truncated
        __android_log_print(ANDROID_LOG_WARN, "App", "String truncated");
    }
}
#endif

#if __ANDROID_API__ >= 31
#include <time.h>
#include <stdlib.h>

void modern_c_features() {
    // High-resolution timestamp
    struct timespec ts;
    timespec_get(&ts, TIME_UTC);
    
    // Aligned allocation for SIMD
    void* aligned_data = aligned_alloc(32, 1024); // 32-byte aligned
    if (aligned_data) {
        // Use for SIMD operations
        free(aligned_data);
    }
}
#endif

#include <pthread.h>
#include <android/log.h>
#include <unistd.h>

#define LOG_TAG "Threading"

void* thread_function(void* arg) {
    const char* name = (const char*)arg;
    
    // Set thread name (Android-specific, helps with debugging)
    pthread_setname_np(pthread_self(), name);
    
    __android_log_print(ANDROID_LOG_INFO, LOG_TAG, 
        "Thread '%s' started", name);
    
    // Do work...
    sleep(2);
    
    __android_log_print(ANDROID_LOG_INFO, LOG_TAG, 
        "Thread '%s' finished", name);
    
    return NULL;
}

void create_worker_thread() {
    pthread_t thread;
    pthread_attr_t attr;
    
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    
    if (pthread_create(&thread, &attr, thread_function, "Worker") == 0) {
        pthread_join(thread, NULL);
    }
    
    pthread_attr_destroy(&attr);
}

#include <pthread.h>
#include <stdlib.h>

typedef struct {
    pthread_mutex_t mutex;
    int counter;
} shared_data_t;

shared_data_t* create_shared_data() {
    shared_data_t* data = malloc(sizeof(shared_data_t));
    pthread_mutex_init(&data->mutex, NULL);
    data->counter = 0;
    return data;
}

void increment_counter(shared_data_t* data) {
    pthread_mutex_lock(&data->mutex);
    data->counter++;
    pthread_mutex_unlock(&data->mutex);
}

void destroy_shared_data(shared_data_t* data) {
    pthread_mutex_destroy(&data->mutex);
    free(data);
}

#include <stdlib.h>
#include <string.h>

// Basic allocation
void* allocate_buffer(size_t size) {
    void* buffer = malloc(size);
    if (buffer == NULL) {
        // Handle allocation failure
        return NULL;
    }
    memset(buffer, 0, size);
    return buffer;
}

// Aligned allocation for SIMD
void* allocate_aligned(size_t size, size_t alignment) {
    void* ptr = NULL;
    if (posix_memalign(&ptr, alignment, size) != 0) {
        return NULL;
    }
    return ptr;
}

// Example: SIMD-aligned buffer
void example_simd_allocation() {
    // Allocate 1KB buffer aligned to 16-byte boundary for NEON
    void* simd_buffer = allocate_aligned(1024, 16);
    if (simd_buffer) {
        // Use with NEON intrinsics
        free(simd_buffer);
    }
}

// Instead of System V shared memory
#ifdef __ANDROID__
    // Use POSIX shared memory
    #include <sys/mman.h>
    int shm_fd = shm_open("/my_shm", O_CREAT | O_RDWR, 0600);
#else
    // Use System V on other platforms
    #include <sys/shm.h>
    int shm_id = shmget(IPC_PRIVATE, size, IPC_CREAT | 0600);
#endif

// Portable number formatting (locale-independent)
#include <stdio.h>
void format_number(char* buffer, size_t size, double value) {
    // Don't use locale-specific formatting on Android
    snprintf(buffer, size, "%.2f", value);
}