Android/es: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		(Android only)
2	2
3	3		# Android target
4	4
5	5		Support for the Android target is present starting from FPC 3.0.
6	6
7	7		CPUs soportadas:
8	8
9	9		- ARM (`CPU_TARGET=arm`)
10	10		- x86 (`CPU_TARGET=i386`)
11	11		- MIPS (`CPU_TARGET=mipsel`)
12	12		- [[FPC JVM\|JVM]] (not discussed on this page)
13	13
14	14		# Android NDK (Native Development Kit)
15	15
16	16		Para obtener las binutils de la plataforma cruzada de Android se necesita descargar e instalar el NDK (Native Development Kit) de Android. Esto permitirá compilar los programas en tu máquina actual teniendo como objetivo Android o dicho de otro modo generará archivos ejecutables bajo Android.
17	17
18	18		La descarga se puede realizar desde el siguiente enlace Android NDK:
19	19
20	20		<https://developer.android.com/ndk/downloads/index.html>
21	21
22	22		A continuación es necesario descomprimirlo a una carpeta.
23	23
24	24		# Descarga de FPC para Android
25	25
26	26		## Release version
27	27
28	28		If you develop for Android using a Windows machine you can download a setup package which contains cross-compilers for Android (ARM, i386, MIPS). After installation of the cross-compilers you can build binaries for Android without any additional steps.
29	29
30	30		For other host platforms you need to download the FPC sources archive and build a cross-compiler as described below.
31	31
32	32		Download the latest release cross-compilers and FPC sources here: <http://freepascal.org/download.var>
33	33
34	34		## Development version
35	35
36	36		The development (trunk) version of FPC may contain new features or bug fixes compared to the latest release version.
37	37
38	38		Check out the latest trunk sources of FPC using the following command:
39	39
40		-	~~<code>~~
41		-
42	40		svn co http://svn.freepascal.org/svn/fpc/trunk fpcsrc
43	41
44		-	~~</code>~~
45		-
46	42		Now you have the latest compiler sources in the `fpcsrc` sub-folder.
47	43
48	44		# Building cross compiler
49	45
50	46		You need to have a working installation of FPC 3.0 compiler in order to create the cross-compiler.
51	47
52	48		This tutorial describes how to build a cross-compiler for the `arm-android` target on Windows. But the tutorial can be applied to any system with small obvious modifications.
53	49
54	50		Use the similar approach to build a `i386-android` or `mipsel-android` cross-compiler.
55	51
56	52		Let's assume the following paths:
57	53
58	54		- Android NDK path: `C:\Program Files\Android SDK\android-ndk-r8d`
59	55		- FPC svn sources path: `C:\Develop\FPC\fpcsrc`
60	56		- The cross-compiler installation path: `C:\Develop\FPC\pp`
61	57
62	58		Add path to Android binutils to the PATH environment variable. In this tutorial the path is: `C:\Program Files\Android SDK\android-ndk-r8d\toolchains\arm-linux-androideabi-4.7\prebuilt\windows\bin`
63	59
64	60		Open the Command line prompt and `cd` to the root of FPC sources folder: `C:\Develop\FPC\fpcsrc`
65	61
66	62		Ejecuta el siguiente mandato:
67	63
68		-	~~<code>~~
69		-
70		-	~~`make clean crossall crossinstall OS_TARGET=android CPU_TARGET=arm INSTALL_PREFIX=C:\Develop\FPC\pp`</code>~~
	64	+	`make clean crossall crossinstall OS_TARGET=android CPU_TARGET=arm INSTALL_PREFIX=C:\Develop\FPC\pp`
71	65
72	66		After that you should have the cross-compiler and units installed in folder `C:\Develop\FPC\pp` By default all units are built with -O2 optimization switch. Also software FPU emulation is used for ARM CPU by default. If you need to specify different compiler options for building, use the `CROSSOPT` parameter. For example if you wish to build units with hardware FPU support and ARMv7a CPU use the following command:
73	67
74		-	~~<code>~~
75		-
76		-	~~`make clean crossall crossinstall OS_TARGET=android CPU_TARGET=arm CROSSOPT="-Cparmv7a -Cfvfpv3" INSTALL_PREFIX=C:\Develop\FPC\pp`</code>~~
	68	+	`make clean crossall crossinstall OS_TARGET=android CPU_TARGET=arm CROSSOPT="-Cparmv7a -Cfvfpv3" INSTALL_PREFIX=C:\Develop\FPC\pp`
77	69
78	70		Now create a new `fpc.cfg` file in folder `C:\Develop\FPC\pp\bin\i386-win32` and paste into it the following text:
79	71
80		-	~~<code>~~
81		-
82	72		-FuC:\Develop\FPC\pp\units\$FPCTARGET*
83	73
84	74		#ifdef android
85	75		#ifdef cpuarm
86	76		-FlC:\Program Files\Android SDK\android-ndk-r8d\platforms\android-14\arch-arm\usr\lib
87	77		#endif
88	78		#ifdef cpu386
89	79		-FlC:\Program Files\Android SDK\android-ndk-r8d\platforms\android-14\arch-x86\usr\lib
90	80		#endif
91	81		#endif
92	82
93		-	~~</code>~~
94		-
95	83		# Compiling programs
96	84
97		-	~~Now, when the cross-compiler is ready, you can compile programs for the Android target: <code>~~
	85	+	Now, when the cross-compiler is ready, you can compile programs for the Android target:
98	86
99	87		`C:\Develop\FPC\pp\bin\i386-win32\ppcrossarm -Tandroid testprog.pas`
100	88
101		-	~~</code>~~
102		-
103	89		# Notas
104	90
105	91		- El compilador NO define `LINUX` durante la compilación! It defines `UNIX` and `ANDROID` though.\
106	92		(Background: Android is not completely Linux compatible, e.g. a few syscalls and default library functions e.g. in pthreads, ... are missing, and it generally behaves different in a few ways. This makes the amount of defines manageable by avoiding `if defined(linux) and not defined(android)`. Actualmente el listado de cosas que son diferentes está solamente aumentando).
107	93
108	94		- Shared libraries do not have `argc/argv` available (i.e. establecer a 0 o nil) debido a Android.
109	95
110	96		- La selección de paquetes compilados viene mayoritariamente dada por que librerias vienen incorporadas por defecto con Android, i.e. no muchas.
111	97
112	98		- \[trunk\] La unit System contiene algunas funciones útiles específicas de Android [funciones útiles específicas de Android](http://svn.freepascal.org/cgi-bin/viewvc.cgi/trunk/rtl/android/sysandroidh.inc?view=markup).
113	99
114	100		- \[trunk\] El compilador y la RTL realizan procesamiento especial para librerias compartidas JNI. El compilador trata una librería como del tipo JNI solamente si dicha librería exporta la función `JNI_OnLoad`. POr tanto, si estás creando una librería compartida JNI, entonces siempre exporta `JNI_OnLoad`, incluso si está vacía.
115	101
116	102		- \[trunk\] Para librerias compartidas tipo JNI las salidas estandar y de error se redireccionan al log de sistema de Android. Por tanto se puede utilizar `writeln()` para escribir en el log del sistema.
117	103
118	104		# Known issues
119	105
120		-	- Shared libraries compiled with FPC 3.0 does not work on Android 6.0+ and executables does not run on Android 5.0+. Starting from Android 6.0 (Marshmallow), it is required to build PIC compatible shared libraries. Starting from Android 5.0 (Lollipop), it is required to build PIC compatible executables (PIE).<span style="color:green">**\
121		-	~~PIC support for the Android target is present starting from FPC 3.0.2.**</span>\~~
	106	+	- Shared libraries compiled with FPC 3.0 does not work on Android 6.0+ and executables does not run on Android 5.0+. Starting from Android 6.0 (Marshmallow), it is required to build PIC compatible shared libraries. Starting from Android 5.0 (Lollipop), it is required to build PIC compatible executables (PIE).**\
	107	+	PIC support for the Android target is present starting from FPC 3.0.2.**\
122	108		NOTE: By default FPC 3.0.2+ builds PIC enabled shared libraries and executables for the Android target. PIC shared libraries work on any Android version (tested even on Android 1.5). But PIC executables can run only on Android 4.1+. To run executables on older versions of Android you need to disable PIC by passing the `-Cg-` switch to the compiler.
123	109		- If you use the cwstring unit in a JNI shared library, your Java application will hang when loading the library on Android 4.0 or earlier. This also applies to any unit which dynamically loads shared libraries during initialization. See more information below.\
124		-	~~<span style="color:green">This issue is fixed in FPC 3.1.1 (development version).</span>~~
	110	+	This issue is fixed in FPC 3.1.1 (development version).
125	111		- The clocale unit is not implemented in FPC 3.0.\
126		-	~~<span style="color:green">It is implemented in FPC 3.1.1 (development version).</span>~~
	112	+	It is implemented in FPC 3.1.1 (development version).
127	113		- The netdb unit is unusable in FPC 3.0 due to missing configuration of DNS servers.\
128		-	~~<span style="color:green">This issue is fixed in FPC 3.1.1 (development version).</span>~~
	114	+	This issue is fixed in FPC 3.1.1 (development version).
129	115		- The `Now` function always returns a GMT time in FPC 3.0.\
130		-	~~<span style="color:green">This issue is fixed in FPC 3.1.1 (development version).</span>~~
	116	+	This issue is fixed in FPC 3.1.1 (development version).
131	117		- The following functions return unusable paths in FPC 3.0: `GetTempDir, GetAppConfigDir, GetAppConfigFile, GetUserDir`.\
132		-	~~<span style="color:green">This issue is fixed in FPC 3.1.1 (development version).</span>~~
	118	+	This issue is fixed in FPC 3.1.1 (development version).
133	119
134	120		## Freeze during shared library initialization on Android prior 4.1
135	121
136	122		If your shared library contains a unit which performs dynamic loading of other shared libraries using `LoadLibaray()` or `dlopen()`, your library may fail to load on Android 4.0 or earlier. The library loading will freeze in such case. One of the units, which can trigger the issue is cwstring.
137	123
138	124		Due to a bug in Android versions prior to 4.1, the `dlopen()` API function does not support recursive calls. When a shared library is being loaded by JVM, using `dlopen()`, the library initialization is executed, including initialization code of all units in the library. If a unit initialization code calls `dlopen()` - it simply hangs, since the initial `dlopen()` is not finished yet and recursion is not allowed.
139	125
140		-	<span style="color:green">This issue is fixed in FPC 3.1.1 (development version).</span>: To workaround this issue the compiler uses the following trick: If a library exports `JNI_OnLoad()`, then no unit initialization is performed during library load. The initialization is called when JVM has loaded the library and then calls `JNI_OnLoad()`.
	126	+	This issue is fixed in FPC 3.1.1 (development version).: To workaround this issue the compiler uses the following trick: If a library exports `JNI_OnLoad()`, then no unit initialization is performed during library load. The initialization is called when JVM has loaded the library and then calls `JNI_OnLoad()`.
141	127
142	128		Therefore, if you are creating a JNI shared library, always export `JNI_OnLoad`, even if it is empty.
143	129
144	130		Also you can trigger this bug if you have a JNI shared library, which use other shared library, created using FPC. The loading of this second library may hang. To workaround this, you need to export an empty `JNI_OnLoad()` function in the second library. Then you need to call `JNI_OnLoad()` from the initialization of the first library.
145	131
146	132		# See also
147	133
148	134		- [[Android tutorial]]
149	135		- You can use the [[pas2jni]] utility to easily create JNI shared libraries from your existing code and use it in Android native Java applications.
150	136
151	137		# External Links
152	138
153	139		- [Tutorial "Lazarus and Android"](http://sourceforge.net/projects/laztoapk/files/Lazarus%20and%20Android.pdf/download) (PDF file)
154	140
155	141		---
156	142		From the Free Pascal wiki, page "Android/es", as it stood on 2017-03-02 after a change by FTurtle, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history