ARM64 Toolchain Setup for SimplexMQ

I am seeking a freelancer who can help me download and compile the open source SimplexMQ GitHub repository (https://github.com/simplex-chat/simplexmq) using android toolchain to generate the native binary for ARM64 architecture. The task will require setting up the development environment, configuring the necessary tools, and ensuring that the library is successfully compiled.

Requirements:
- Experience with cross-compiling for ARM64 WITH ANDROID TOOLCHAIN
- Familiarity with Haskell and C/C++ build tools (e.g., GHC, Hadrian, GCC, Make, CMAKE).
- Experience with toolchains and cross-compilation techniques, in a Linux Ubuntu environment.
- Good documentation skills for providing a clear guide.
- Strong communication skills for the walkthrough session.

Deliverables:
- Compiled native binary for ARM64 with android toolchain.
- Documentation detailing the environment setup, compilation steps, and any necessary configurations.
- Remote or recorded walkthrough session to ensure I can replicate the setup and compilation process.

Success Criteria:

$ file libsimplex.so
libsimplex.so: ELF 64-bit LSB shared object, ARM aarch64, version 1 (SYSV), dynamically linked, stripped

$ strings libsimplex.so | grep clang
COMPILER=clang-12.0.1
clang version 12.0.1
Android (7211189, based on r416183) clang version 12.0.4 (https://android.googlesource.com/toolchain/llvm-project c935d99d7cf2016289302412d708641d52d2f7ee)

If you can do this task please reach out.

Disclaimer: It must be ARM64 and must be with ANDROID toolchain. Documentation of the setup IS A MUST. Deliverables submitted and checked prior to release.Looking forward to working with you!


Q/A:
1. Do you need the compilation to support any specific Android API level?
- Yes, target Android API Level 30 (Android 11).

2. Should I enable any specific debug symbols or strip the binary for production use?
- During development, include debug symbols (`-g` flag). For production, strip the binary to reduce size (`strip --strip-unneeded`). The final binary should be an ELF arm64 format with stripped debug symbols.

3. Is the Android NDK version flexible, or should I use the latest stable release?
- Preferably use NDK r23 (build number 7211189), as it has been tested. However, if compatibility issues arise, the latest stable NDK release can be considered.

4. Should I include JNI bindings in the documentation, or is the native library integration sufficient?
- If JNI bindings are required, document them clearly. However, if native integration alone is sufficient, JNI documentation is not necessary.

5. Do you need the library signed or packaged in any specific format?
- No specific signing or packaging is required at this stage. The compiled ELF arm64 binary should be provided, and APK packaging or signing will be handled separately if needed.

6. Should the build process use any specific optimization flags for performance?**
- Yes, please use optimizations for ARM64 arch builds

7. Do you need the library tested on a specific Android device or emulator?**
- Yes, it should be tested on an ARM64-based Android device, preferably latest models of a Samsung Quantum Galaxy phone. If an emulator is needed, use an ARM64 emulator image.

8. Should I include a minimal Android test project to verify the compiled library?
- Yes, include a minimal Android test project that initializes and performs basic messaging using SimplexMQ to verify that the library compiles and functions correctly on Android.

9. Are there any additional dependencies I should be aware of in the SimplexMQ build process?
- The build process pulls the `simplexmq` repository via `cabal`. Ensure that all Haskell dependencies are properly installed, including `ghc`, `cabal-install`, and necessary system libraries like `zlib`, `openssl`, and `libsodium`. Also, verify if any additional Android-specific dependencies (like `libffi` or `android-ndk`) are required.

10. Do you require logging or debugging options during compilation before stripping symbols?
- Yes, enable logging and debugging options during the initial build (`-g` flag for debugging symbols). However, before the final release build, strip unnecessary symbols to reduce the binary size.

11. Do I need to build the android toolchain from source?
- No, you don't necessarily need to build the Android toolchain from source. The Android NDK provides prebuilt toolchains that support various architectures (armv7, arm64, x86, x86_64). You just need to cross-compile the binary for Android, and use these prebuilt toolchains.