I built a qt c++ application on a Linux system which uses network requests as part of its functionality, and on the system which it was built on it works alright, after I deployed it (using cqtdeployer), and ran the application on a different Linux computer, the GUI opens up and everything, but when it tries to perform HTTP requests it logs the following error to the console:
qt.tlsbackend.ossl: Incompatible version of OpenSSL (built with OpenSSL 1.x, runtime version is >= 3.x)
My question is - can Qt be built with modern OpenSSL versions, or do I have to manually install OpenSSL1.x on the computer which tries to run the program? Maybe I can just provide a bunch of libraries to the deployment folder?
Thanks.
OpenSSL is generally binary incompatible between major versions, especially with version 3, which is a major API change.
Perhaps it will be a good investment of time for you to take this opportunity to learn how to use your Linux distribution's package manager, (rpm/dnf on Fedora-based Linux distributions, and dpkg/apt on Debian-derived distributions) which exists precisely to solve these kinds of problems.
Most major Linux distributions still include an additional compatibility package for code that's built with OpenSSL 1. If you use your Linux distribution's package manager and prepared an appropriate package, the compatibility package would've gotten installed, automatically, by the package manager together with your package. That's what the package manager is for.
It's also a fair chance that the version of Qt is different too, and there's also a high chance of an incompatibility between your code that's compiled for one version of Qt and the different version that's installed on the computer in question, even though it seemingly runs. If you used the package manager it would've figured it out too, and alerted you.
I have an application written in pure C++ and Qt 5.5.1. It compiles fine in both GCC (Lubuntu 15.10 x86) and MSVC 14.0 (Windows 8.1 x64), and works properly on both those platforms. I now want to distribute it so that it will run on other Linux distros without recompiling them there.
I'm not entirely sure how to achieve this; the Qt docs page generally suggests to link everything statically, but this is not what most other sources say (from what I understand it is a bad idea to link with glibc statically). In any case I cannot really link everything statically because GCC complains that Using 'getaddrinfo' in statically linked applications requires at runtime the shared libraries from the glibc version used for linking and from what I understand this isn't a warning one can simply ignore. I've tired linking statically against only libgcc and libstdc++, I copied the other missing libraries - libXau.so.6, libXdmcp.so.6 and libxcb.so.1 on a clean CentOS 7 installation and tried to run the program there, but that gave me a segmentation fault; possibly because the system is 64 bit as opposed to the platform I compiled the application on?
How can I distribute the application in a form runnable by most common configurations? Static linking is not an issue because the source is going to be released anyway.
Is it better to link against Qt statically or dynamically (if maximum binary portability is the priority)?
Do I need to provide two separate versions of the binary, 32 and 64 bit, or will a 32 bit build suffice?
My suggestion would be to offer two builds: an unsupported, fully static build that will work "anywhere" with an asterisk that there's no way you can support it if it's a commercial offering. People'll try to run it on their fridges, I kid you not. The officially supported builds must be for specific platforms only, and you can't but have VMs/test targets that run these platforms, and where you build and test on.
Obviously you can't really run Mac or Linux apps on Windows, but can you compile binaries for those platforms using MSVC++ for example (plugging in additional compilers and tools obviously)? For a serious build system, you don't want one build server per platform so having an automated build server which compiles for all target platforms seems quite a reasonable aim.
Crosstool-NG seems like your best option for Linux apps; they show that as one of the standard configurations. I do not know about Mac OS X; this question suggests that it will probably be difficult.
I would like to believe (notice my careful words) that GCC can be built to run on windows (any relevant form of the triplet --mingw*) and target another triplet.
A proof-of-concept for the non-believers is provided here, where you can find Win64 hosted compilers that build native linux binaries. I assume the same can be done for mac if the necessary libraries (like the CRT and necessary Mac framework libraries) can be built/used by that compiler.
if you want to build applications using C++, why not use Qt from Nokia. it's cross platform. http://qt.nokia.com/
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 11 years ago.
I'm trying to develop/port a game to Android, but it's in C, and Android supports Java, but I'm sure there must be a way to get a C app on there, anyone knows of a way to accomplish this?
For anyone coming to this via Google, note that starting from SDK 1.6 Android now has an official native SDK.
You can download the Android NDK (Native Development Kit) from here:
https://developer.android.com/ndk/downloads/index.html
Also there is an blog post about the NDK:
http://android-developers.blogspot.com/2009/06/introducing-android-15-ndk-release-1.html
The Android NDK is a toolset that lets you implement parts of your app in native code, using languages such as C and C++. For certain types of apps, this can help you reuse code libraries written in those languages.
For more info on how to get started with native development, follow this link.
Sample applications can be found here.
Normally, you have to:
Install Google Android NDK. It
contains libs, headers, makfile
examples and gcc toolchain
Build an executable from your C code
for ARM, optimize and link it with
provided libs if required
Connect to a phone using provided
adb interface and test your
executable
If you are looking to sell an app:
Build a library from your C code
Create simple Java code which will
use this library
Embed this library into application
package file
Test your app
Sell it or distribute it for free
Google has released a Native Development Kit (NDK) (according to http://www.youtube.com/watch?v=Z5whfaLH1-E at 00:07:30).
Hopefully the information will be updated on the google groups page (http://groups.google.com/group/android-ndk), as it says it hasn't been released yet.
I'm not sure where to get a simple download for it, but I've heard that you can get a copy of the NDK from Google's Git repository under the donut branch.
The official position seems to be that this isn't something you'd ever "want to do". See this thread on the Android Developers list. Google envisage android running on a variety of different devices (CPUs, displays, etc). The best way to enable development is therefore to use (portable) managed code that targets the Dalvik VM. For this reason, the Android SDK doesn't support C/C++.
BUT, take a look at this page:
Android includes a set of C/C++
libraries used by various components
of the Android system. These
capabilities are exposed to developers
through the Android application
framework.
The managed application framework appears to be layered on-top of these libraries. The page goes on to list the C/C++ libs: standard C library, media, 3D, SQL lite, and others.
So all you need is a compiler chain that will compile C/C++ to the appropriate CPU (ARM, in the case of the G1). Some brief instructions on how to do this are here.
What I don't know is where to find descriptions of the APIs that these libraries provide. I'd guess there may be header files buried in the SDK somewhere, but documentation may be sketchy/missing. But I think it can be done!
Hope thats useful. For the record, I haven't written any native android apps - just a few simple managed ones.
Andy
You can use nestedvm to translate C (or other GCC languages) into Java bytecode, and use that as the basis of your port. For example, see the Android port of Simon Tathams portable puzzle collection.
I expect this method is made obsolete by the NDK, but it might not be in if some networks or something don't allow people to upgrade their phones.
Google has already launched Google I/O 2011: Bringing C and C++ Games to Android session which is available at http://www.youtube.com/watch?v=5yorhsSPFG4
which is good to understand the use of NDK for writing application in c and c++ for android.
If you just want to cross compile any console based native game and run them on android then this Article has shown 3 methods for the same.
1: Static compilation using standalone toolchain
2: Cross compilation using Android NDK’s toolchain
3: Cross compilation using AOSP source code
Maybe you are looking for this?
http://www.mosync.com/
It is a middle layer for developing for several mobile platforms using c++.
Looking at this it seems it is possible:
http://openhandsetmagazine.com/2007/11/running-c-native-applications-on-android-the-final-point/ (now only available via the WayBack Machine)
"the fact is only Java language is supported doesn’t mean that you cannot develop applications in other languages. This have been proved by many developers, hackers and experts in application development for mobile. The guys at Elements Interactive B.V., the company behind Edgelib library, succeeded to run native C++ applications on the Android platform, even that at this time there is still many issues on display and sound … etc. This include the S-Tris2 game and a 3D animation demo of Edgelib."
Since 2009 there is a development on this matter.
Necessitas - Qt(C++ framework) for Android
Getting started video.
Take a look at google ndk group it looks promising, first version of the NDK will be available in 1H2009.
Update:
And it is released http://android-developers.blogspot.com/2009/06/introducing-android-15-ndk-release-1.html
I'm not sure the NDK provides full coverage of the official Java API.
From http://developer.android.com/sdk/ndk/index.html#overview :
Please note that the NDK does not
enable you to develop native-only
applications. Android's primary
runtime remains the Dalvik virtual
machine.
Google just released the NDK which allows exactly that.
http://feedproxy.google.com/~r/blogspot/hsDu/~3/2foWz7hwFtE/introducing-android-15-ndk-release-1.html
It can be found here:
http://developer.android.com/sdk/ndk/1.5_r1/index.html
This blog post may be a good start: http://benno.id.au/blog/2007/11/13/android-native-apps
Unfortunately, lots of the important stuff is "left as an exercise to the reader".
I do not know a tutorial but a good development tool: Airplay SDK from Ideaworks Labs. (Recently rebranded "Marmelade") Using C/C++ you can build apps for Windows Mobile, iPhones, Android. The only component I didn't like was the GUI composer - a buggy one, but you always can substitute it with the Notepad.
You can download c4droid and then install the GCC plugin and install to your SD. From the shell I just traverse to the directory where the GCC binary is and then call it to make an on board executable.
find / -name gcc
/mnt/sdcard/Android/data/com.n0n3m4.droidc/files/gcc/bin/arm-linux-androideabi-gcc
cat > test.c
#include<stdio.h>
int main(){
printf("hello arm!\n");
return 0;
}
./arm-linux-androideabi-gcc test.c -o test
./test
hello arm!
This three steps are good to have and store in this post.
1) How to port native c code on android
2) http://www.integratingstuff.com/2010/12/12/calling-native-c-code-through-jni-in-android-applications/
3) http://mindtherobot.com/blog/452/android-beginners-ndk-setup-step-by-step/
Native C/c++ Files libstdc++.* from your Ubuntu are x86 (or x86_64) binaries but Android devices and emulators are ARM. Of course, this will not work anyway, even if you'll set correct soname. This is very naive way which leads nowhere. Android has very limited support of C++ meaning there is no exceptions, standard C++ library (including STL) and RTTI. If you need such functionality, use my custom NDK distribution from
http://crystax.net/android/ndk.php - it support full C++ features listed above.
Why is there error: undefined reference to '__cxa_end_cleanup' link error. Android stlport
time. Because there is no link to libstdc + +. A. So wrong.
Because it uses some static library, it is necessary to link the full libstdc + +. A. Can
http://crystax.net/android/ndk.php here to download the package
sources \ cxx-stl \ gnu-libstdc + + \ libs \ armeabi directory.
Android on its own libstdc + + support is limited, it must be linked to a complete libstdc +
+. A the job.
Add file in Android.mk LOCAL_LDFLAGS = $ (LOCAL_PATH) / libs / libcurl.a \
$ (LOCAL_PATH) / libs / liblua.a \
`$ (LOCAL_PATH) / libs / libstdc + +. A`
And LOCAL_CPPFLAGS + =-lstdc + +-fexceptions can be compiled
There is a plan to allow C/C++ libraries in the next SDK version of Android (Codename Eclair?)To date, it's not possible through the Android Java SDK. However, you can grab the HUGE open source project, roll your own libraries, and then flash your own device...but anyone who wants to use your library will have to flash your custom build as well.
Short answer: You can't.
#Backslash17: Looking through the article and the following link with installation instructions, all the company got working is to launch a self compiled executable on the emulator, bypassing the android framework. Once you have the emulator you can telnet in and have a linux shell. Running a linux program there is trivial of course.
But that's not working for phones without jailbreak(aka root access) and not deliverable on the market.
Unless Google opens other opportunities or someone writes a custom compiler that compiles Language X into Dalvik bytecode (Dalvik is the VM that runs Android programs) you won't be able to write native code.