Android JNI NDKの C言語側で R.rawや Assetのファイルを FileDescriptor経由で直接読み込む方法

Google Android JNI NDKの Ｃ／Ｃ＋＋言語開発環境の構築のつもり

Google Play は App Bundle から、デバイス設定ごとに最適化した APK を生成、配信します。
それによって、個々のデバイスでアプリを実行するのに必要なコードとリソースだけがダウンロードされます。
デベロッパー側では、多様なデバイスのサポートを最適化するために複数の APK をビルド、署名、管理する必要がなくなり、
ユーザー側では、よりサイズが小さく、最適化された APK をダウンロードできるようになります。

  android {
      ndkVersion "17.2.4988734"
  }
Windows 32 ビット  android-ndk-r17c-windows-x86.zip  608358310  5bb25bf13fa494ee6c3433474c7aa90009f9f6a9
Windows 64 ビット  android-ndk-r17c-windows-x86_64.zip  650626501  3e3b8d1650f9d297d130be2b342db956003f5992

  android {
      ndkVersion "16.1.4479499"
  }
Windows 32 ビット  android-ndk-r16b-windows-x86.zip  656720029  becaf3d445a4877ca1a9300a62f0934a4838c7fa
Windows 64 ビット  android-ndk-r16b-windows-x86_64.zip  723301086  f3f1909ed1052e98dda2c79d11c22f3da28daf25

Asset
#include <asset_manager.h>
#include <asset_manager_jni.h>

アセット:
オーディオ ファイルを assets/ フォルダに格納することで、Android ネイティブ アセット マネージャー API から直接アクセスできるようになります。
これらの API の詳細については、ヘッダー ファイルの
android/asset_manager.h と android/asset_manager_jni.h
をご覧ください。

● NDK JNI側 （C言語）
  clazz = (*env)->FindClass(env, "java/io/FileDescriptor");
  filePath = ( *env )->GetStringUTFChars( env, filePathJ, 0 )

● NDK JNI側 （C++言語）
  clazz = env->FindClass("java/io/FileDescriptor");
  filePath = env->GetStringUTFChars( filePathJ, 0 )

    private String copyRawResourceFile(@RawRes int rawId, @NonNull String fileName) {
        try {
            File rawDir = getDir("raw", Context.MODE_PRIVATE);
            File rawFile = new File(rawDir, fileName);
            final String filepath = rawFile.getAbsolutePath();
            if (rawFile.exists()) {
                return filepath;
            }

            InputStream is = getResources().openRawResource(rawId);
            OutputStream os = new FileOutputStream(rawFile);

            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = is.read(buffer)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            is.close();
            os.close();

            return filepath;

        } catch (Exception e) {

            return null;
        }
    }

    String filepath;
    // /data/user/0/jp.hoge.hoge/app_app/fileName.dat
    long ret = NativeImplJni.hogehoge( filepath );


● NativeImplJni.java
public class NativeImplJni {
    public static final native long hogehoge( String filePath );
}

● NDK JNI側 （C言語）
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

JNIEXPORT jlong JNICALL hogehoge(JNIEnv *env, jobject obj, jstring filePathJ )
{
    const char* filePath;

    if( filePathJ == NULL ||
        ( filePath = ( *env )->GetStringUTFChars( env, filePathJ, 0 ) ) == NULL ) {
        return 0L;
    }

    FILE* fOpenHandle = (void *) fopen(filePath, "rb");
    if (fOpenHandle == NULL) {
        return 0L;
    }

    // FIO19-C. ファイルサイズの計算に fseek() および ftell() を使用しない
    // https://www.jpcert.or.jp/sc-rules/c-fio19-c.html
    struct stat stbuf;
    if (stat(dicLibPath, &stbuf) == -1) {
        fclose(fOpenHandle);
        return 0L;
    }

    unsigned char*      fOpenBuffer;

    file_size = stbuf.st_size;
    fOpenBuffer = (void *) malloc(file_size);
    if (fOpenBuffer == NULL) {
        fclose(fOpenHandle);
        return 0L;
    }

    long read_size = fread(fOpenBuffer, file_size, 1, fOpenHandle);
    if (read_size == file_size) {
        fclose(fOpenHandle);
        return 0L;
    }

    fclose(fOpenHandle);

...

    fOpenBufferをいじくる処理

...

    // 終了時に freeで解放する
    free(fOpenBuffer);

    return 1L;

● Java側

    byte[] buffer = null;

    AssetFileDescriptor afd;
    afd = getContext().getResources().openRawResourceFd(R.raw.hogehoge_resource);

    int length = (int)afd.getLength();
    buffer = new byte[length];

    FileInputStream fis = afd.createInputStream()
    fis.read(buffer, 0, length);
    fis.close();

    hogehogeJNI( buffer );


● NDK JNI側 （C言語）
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

void Java_jp_ne_neko_freewing_HogeHogeApp_HogeClass_hogehogeJNI( JNIEnv* env,
    jobject thiz,
    jbyteArray bufferJ
    )
{
    unsigned long length;
    length = ( *env )->GetArrayLength( env, bufferJ );

    jbyte* buffer = ( *env )->GetByteArrayElements(env, bufferJ, 0);

...

    bufferをいじくる処理

    int pos = 123;
    jbyte b = buffer[pos]

...

    unsigned char*      fOpenBuffer;
    fOpenBuffer = (void *) malloc(length);

    memcpy(fOpenBuffer, buffer, length);

    // 終了時に ReleaseByteArrayElementsで解放する
    (*env)->ReleaseByteArrayElements(env, bufferJ, buffer, 0);

...

    fOpenBufferをいじくる処理

...

    // 終了時に freeで解放する
    free(fOpenBuffer);

    return;

● Java側

    AssetFileDescriptor afd;
    afd = getContext().getResources().openRawResourceFd(R.raw.hogehoge_resource);
    long ret = NativeImplJni.hogehoge( afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength() );

　※ FileDescriptor単体だとファイルサイズが不明なので afd.getLength()でファイルサイズ情報も JNI Native側に受け渡す
　※ afd.getStartOffset()も必要！

● NativeImplJni.java
public class NativeImplJni {
    public static final native long hogehoge( FileDescriptor fd, long startOffset, long length );
}

● R.raw.hogehoge_resource
/res/raw/hogehoge_resource.mp3
　等のファイル名で格納しておく（非圧縮！！）
　※ /res/raw/hogehoge_resource.datと、拡張子が .datの場合は、なぜか読み込みでエラーになるので注意！！

● NDK JNI側 （C言語）
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

static struct file_descriptor_offsets_t
{
    jclass mClass;
    jfieldID mDescriptor;
} gFileDescriptorOffsets;

JNIEXPORT jlong JNICALL hogehoge(JNIEnv *env, jobject obj, jobject dicLibFdJ, jlong startOffsetJ, jlong lengthJ )
{

    // Java Reflection
    jclass clazz;
    clazz = (*env)->FindClass(env, "java/io/FileDescriptor");
    // LOG_FATAL_IF(clazz == NULL, "Unable to find Java class java.io.FileDescriptor");
    gFileDescriptorOffsets.mClass = (jclass) (*env)->NewGlobalRef(env, clazz);
    gFileDescriptorOffsets.mDescriptor = (*env)->GetFieldID(env, clazz, "descriptor", "I");
    // LOG_FATAL_IF(gFileDescriptorOffsets.mDescriptor == NULL,
    //              "Unable to find descriptor field in java.io.FileDescriptor");


    unsigned char*      fOpenBuffer;

    long file_size = lengthJ;
    long start_offset = startOffsetJ;

    jint fd = ( *env )->GetIntField( env, dicLibFdJ, gFileDescriptorOffsets.mDescriptor );
    int newfd = dup(fd);

    FILE *fOpenHandle = fdopen(newfd, "rb");
    if (NULL == fOpenHandle) {
        close(newfd);
        return 0L;
    }

    if (-1 == fseek(fOpenHandle, start_offset, SEEK_SET)) {
        fclose(fOpenHandle);
        close(newfd);
        return 0L;
    }

    fOpenBuffer = (void *) malloc(file_size);
    if (fOpenBuffer == NULL) {
        fclose(fOpenHandle);
        close(newfd);
        return 0L;
    }

    long read_size = fread(fOpenBuffer, file_size, 1, fOpenHandle);
    if (read_size == file_size) {
        fclose(fOpenHandle);
        close(newfd);
        return 0L;
    }

    fclose(fOpenHandle);
    close(newfd);

...

    fOpenBufferをいじくる処理

...

    // 終了時に freeで解放する
    free(fOpenBuffer);

    return 1L;

● Java側
import java.io.FileDescriptor;
import java.lang.reflect.Field;

    // Java Reflection
    private static int getFileDescriptorDescriptor(FileDescriptor fd) throws NoSuchFieldException, IllegalAccessException {
        Field field = FileDescriptor.class.getDeclaredField("descriptor");
        field.setAccessible(true);
        int value = (Integer) field.get(fd);
        field.setAccessible(false);
        return value;
    }

    AssetFileDescriptor afd;
    afd = getContext().getResources().openRawResourceFd(R.raw.hogehoge_resource);
    final int descriptor = getFileDescriptorDescriptor(afd.getFileDescriptor());
    long ret = NativeImplJni.hogehoge( descriptor, afd.getStartOffset(), afd.getLength() );

● NDK JNI側 （C言語）
JNIEXPORT jlong JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_createWnnWork
  (JNIEnv *env, jobject obj, jint descriptorJ, jlong startOffsetJ, jlong lengthJ )
{
　読み込み部分は「その３Ａ」と同じ
}

 /*
 * These are JNI field IDs for the stuff we're interested in.  They're
 * computed when the class is loaded.
 */
static struct {
    jfieldID    descriptor;       /* int */
    jmethodID   constructorInt;
    jmethodID   setFD;
    jclass      clazz;
} gCachedFields;

static inline int getFd(JNIEnv* env, jobject obj)
{
    return (*env)->GetIntField(env, obj, gCachedFields.descriptor);
}

static void nativeClassInit(JNIEnv* env, jclass clazz)
{
    gCachedFields.clazz = (*env)->NewGlobalRef(env, clazz);
    gCachedFields.descriptor =
        (*env)->GetFieldID(env, clazz, "descriptor", "I");
    if(gCachedFields.descriptor == NULL) {
        jniThrowException(env, "java/lang/NoSuchFieldError", "FileDescriptor");
        return;
    }
    gCachedFields.constructorInt =
        (*env)->GetMethodID(env, clazz, "<init>", "()V");
    if(gCachedFields.constructorInt == NULL) {
        jniThrowException(env, "java/lang/NoSuchMethodError", "<init>()V");
        return;
    }
}

● Java側

AssetManager assetManager = getAssets();
createAssetAudioPlayer(assetManager, "background.mp3");

● Assetsファイル

/assets/background.mp3

● NDK JNI側 （C言語）
 // for native asset manager
#include <sys/types.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>

 // for assert
#include <assert.h>

 // create asset audio player
JNIEXPORT jboolean JNICALL
Java_com_example_nativeaudio_NativeAudio_createAssetAudioPlayer(
        JNIEnv* env, jclass clazz,
        jobject assetManager, jstring filename)
{
    SLresult result;

    // convert Java string to UTF-8
    const char *utf8 = (*env)->GetStringUTFChars(env, filename, NULL);
    assert(NULL != utf8);

    // use asset manager to open asset by filename
    AAssetManager* mgr = AAssetManager_fromJava(env, assetManager);
    assert(NULL != mgr);
    AAsset* asset = AAssetManager_open(mgr, utf8, AASSET_MODE_UNKNOWN);

    // release the Java string and UTF-8
    (*env)->ReleaseStringUTFChars(env, filename, utf8);

    // the asset might not be found
    if (NULL == asset) {
        return JNI_FALSE;
    }

    // これ使う？
    // open asset as file descriptor
    off_t start, length;
    int fd = AAsset_openFileDescriptor(asset, &start, &length);
    assert(0 <= fd);
    AAsset_close(asset);

    // これ使う？
    SLDataLocator_AndroidFD loc_fd = { SL_DATALOCATOR_ANDROIDFD, fd, start, length };
    SLDataFormat_MIME format_mime = { SL_DATAFORMAT_MIME, NULL, SL_CONTAINERTYPE_UNSPECIFIED };
    SLDataSource audioSrc = { &loc_fd, &format_mime };

...

    // こっち使う？ ← こっちの方法で動作を確認しました
    AAsset_read、AAsset_getBuffer、AAsset_getLength

    off_t length = AAsset_getLength(asset);

    unsigned char*      fOpenBuffer;
    long file_size = length;
    fOpenBuffer = (void *) malloc(file_size);

    int ret = AAsset_read(asset, fOpenBuffer, file_size);
    assert(0 <= ret);
    AAsset_close(asset);

    fOpenBufferをいじくる処理

    // 終了時に freeで解放する
    free(fOpenBuffer);

● CMakeLists.txt

find_library(android-lib android)

target_link_libraries(
            hogehogejni
            ${android-lib}
            )

● android/asset_manager.h

 /**
 * Open an asset.
 *
 * The object returned here should be freed by calling AAsset_close().
 */
AAsset* AAssetManager_open(AAssetManager* mgr, const char* filename, int mode);

 /**
 * Close the asset, freeing all associated resources.
 */
void AAsset_close(AAsset* asset);

 /**
 * Attempt to read 'count' bytes of data from the current offset.
 *
 * Returns the number of bytes read, zero on EOF, or < 0 on error.
 */
int AAsset_read(AAsset* asset, void* buf, size_t count);

 /**
 * Get a pointer to a buffer holding the entire contents of the assset.
 *
 * Returns NULL on failure.
 */
const void* AAsset_getBuffer(AAsset* asset);

 /**
 * Report the total size of the asset data.
 */
off_t AAsset_getLength(AAsset* asset);

 /**
 * Report the total size of the asset data. Reports the size using a 64-bit
 * number insted of 32-bit as AAsset_getLength.
 */
off64_t AAsset_getLength64(AAsset* asset);

● android/asset_manager.h

 /**
 * Open a new file descriptor that can be used to read the asset data.
 *
 * Returns < 0 if direct fd access is not possible (for example, if the asset is compressed).
 */
int AAsset_openFileDescriptor(AAsset* asset, off_t* outStart, off_t* outLength);

● bits/types.h

typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;

● sys/types.h

 /* This historical accident means that we had a 32-bit off_t on 32-bit architectures. */
 /* See https://android.googlesource.com/platform/bionic/+/master/docs/32-bit-abi.md */
#if defined(__USE_FILE_OFFSET64) || defined(__LP64__)
typedef int64_t off_t;
typedef off_t loff_t;
typedef loff_t off64_t;
#else
typedef __kernel_off_t off_t;
typedef __kernel_loff_t loff_t;
typedef loff_t off64_t;
#endif

・ Java 1.6の場合
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_6
        targetCompatibility JavaVersion.VERSION_1_6
    }

・ Java 1.5の場合（2020年 まだ使える）
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_5
        targetCompatibility JavaVersion.VERSION_1_5
    }
警告: [options] ソース値1.5は廃止されていて、今後のリリースで削除される予定です
警告: [options] ターゲット値1.5は廃止されていて、今後のリリースで削除される予定です
警告: [options] 廃止されたオプションについての警告を表示しないようにするには、-Xlint:オプションを使用します。

● app/build.gradle
android {
    defaultConfig {
        ndk {
            abiFilters 'arm64-v8a', 'x86_64'
        }
    }
}

● app/build.gradle
全部入りの場合 NDK r16bを使う
android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi', 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64', 'mips', 'mips64'
        }
    }
}

● app/build.gradle
android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi', 'armeabi-v7a', 'arm64-v8a'
        }
    }
}

● NDK JNI側 （C言語）
#include <android/log.h>

#define TAG         "HogeHogeJni"
#define LOGV(...)   __android_log_print(ANDROID_LOG_VERBOSE, TAG, __VA_ARGS__)
#define LOGD(...)   __android_log_print(ANDROID_LOG_DEBUG,   TAG, __VA_ARGS__)
#define LOGI(...)   __android_log_print(ANDROID_LOG_INFO,    TAG, __VA_ARGS__)
#define LOGW(...)   __android_log_print(ANDROID_LOG_WARN,    TAG, __VA_ARGS__)
#define LOGE(...)   __android_log_print(ANDROID_LOG_ERROR,   TAG, __VA_ARGS__)
#define LOGF(...)   __android_log_print(ANDROID_LOG_FATAL,   TAG, __VA_ARGS__)

    long file_size = 123456L;
    LOGD("file_size %08lx", file_size);

● CMakeLists.txt

find_library(log-lib log)

target_link_libraries(
            hogehogejni
            ${log-lib}
            )

● android/log.h

 /**
 * Android log priority values, in increasing order of priority.
 */
typedef enum android_LogPriority {
  /** For internal use only.  */
  ANDROID_LOG_UNKNOWN = 0,

  /** The default priority, for internal use only.  */
  ANDROID_LOG_DEFAULT, /* only for SetMinPriority() */

  /** Verbose logging. Should typically be disabled for a release apk. */
  ANDROID_LOG_VERBOSE,

  /** Debug logging. Should typically be disabled for a release apk. */
  ANDROID_LOG_DEBUG,

  /** Informational logging. Should typically be disabled for a release apk. */
  ANDROID_LOG_INFO,

  /** Warning logging. For use with recoverable failures. */
  ANDROID_LOG_WARN,

  /** Error logging. For use with unrecoverable failures. */
  ANDROID_LOG_ERROR,

  /** Fatal logging. For use when aborting. */
  ANDROID_LOG_FATAL,

  /** For internal use only.  */
  ANDROID_LOG_SILENT, /* only for SetMinPriority(); must be last */

} android_LogPriority;

static NJ_UINT8 dic_01_data[] __attribute__ ((aligned (16))) = {
    0x4e, 0x4a, 0x44, 0x43, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x32, 0xf7,
    ...
    };

static NJ_UINT8 dic_02_data[] __attribute__ ((aligned (16))) = {
    0x4e, 0x4a, 0x44, 0x43, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x37, 0x99,
    ...
    };

NJ_UINT8* con_data[ ] __attribute__ ((aligned (16))) = {
        con_01_data
    };

NJ_UINT32 dic_size[ ] __attribute__ ((aligned (16))) = {
        78665, 79851, 280537, 7323, 81907, 783246, 5785, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };

    ...

  -malign-double          Align doubles to two words in structs (x86 only)

AACの記事から１年経ってデータ バインディングの俺的カンニング帳を作る

Androidのアプリ開発で AAR形式のライブラリを Androidプロジェクトに組み込む方法

Kotlin大嫌い人間が Kotlin言語を必死に勉強する

2019年になったから Android Architecture Componentsで開発しようじゃないか！今から始めても遅くない！

Androidアプリ作成に必須の多端末に対応するデザイン方法について解説する dipを極める