Custom Drawn Interface/Android: what changed

Revision 4 to 5. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		(Android only)
2	2
3	3		> Warning: THIS INFORMATION IS DATED AND NEEDS UPDATING
4	4
5	5		Go back to [[Custom Drawn Interface]]
6	6
7	7		## Architecture
8	8
9	9		LCL-CustomDrawn-Android utilizes a minimal Java application which communicates with our Pascal library and sends all events to it and also obeys commands from it. The communication is done via JNI as supported by Google. The controls are not native, instead they are all drawing using TRawImage+TLazIntfImage+TLazCanvas and events and the painting are clipped using LazRegions. The drawing itself is done in Pascal using jnigraphics to draw on a Bitmap Java object which is then drawn by the minimal Java activity on a SurfaceView.
10	10
11	11		Our previous and short-lived attempt to write an LCL Interface for Android (LCL-Android) utilized a non-standard method of using native executables which communicated with a Java machine via Pipes. This method was abandoned because it was considered unsupported by Google. It is considered obsolete and people should use LCL-CustomDrawn-Android instead. This older interface was documented in [[Android Interface]].
12	12
13	13		## Roadmap
14	14
15	15		Part 1, until March 2012:
16	16
17	17		1. Build the set of [[Lazarus Custom Drawn Controls]]
18	18		2. Initial bindings for the Android APIs
19	19		3. Create an application to automatically generate the bindings
20	20		4. Start the new widgetset
21	21		5. Implement support for JNI
22	22		6. Merge the Lazarus Custom Drawn Controls into the LCL and use them to implement all basic controls
23	23		7. Add text support for Android
24	24		8. Implement basic window client area scrolling
25	25		9. Add mobile emulator for desktop platforms
26	26		10. Improve the mobile scrolling
27	27		11. Add text support in X11
28	28		12. Add DPI awareness and adaptation in the LCL
29	29		13. Add non-native text support via pasfreetype
30	30
31	31		Part 2: April, May, June 2012:
32	32
33	33		1. TButton improve the Android visual
34	34		2. TBitBtn
35	35		3. TRadioButton finish the native look
36	36		4. Calendar dialog -\> Problematic as the LCL has no calendar dialog, it just opens a normal form and puts a calendar on it, so we need a TCDCalendar widget
37	37		5. MaskEdit
38	38		6. Improve TComboBox
39	39		7. TMemo
40	40		8. TListView as a list with columns
41	41		9. TMainMenu
42	42		10. Database with sqlite
43	43		11. Barcode reading
44	44		12. Windows add-on installer
45	45
46	46		## Using the Android SDK, Emulator and Phones
47	47
48	48		[[Custom Drawn Interface/Using the Android SDK, Emulator and Phones]]
49	49
50	50		## Android Programming
51	51
52	52		See [[Android Programming]], also includes caracteristics of the various phones relevant for programming.
53	53
54	54		## Configuring the Free Pascal Compiler for Android
55	55
56	56		\| NOTE: \|
57	57		\|----\|
58	58		\| The cross-compiler instructions below are probably obsolete, since support for the [[Android\|Android target]] is present in the trunk (development) version 2.7.1 of FPC. Here are up to date instructions: [[Android\|building a cross-compiler for Android target]]. \|
59	59
60	60		### Use the ready Virtual Box Image with FPC and Lazarus
61	61
62	62		The fastest way to configure Free Pascal and Lazarus for Android development is simply using a pre-configured virtual machine image which already includes Mageia Linux 1, KDE, Lazarus 0.9.31, Subversion, Free Pascal for both x86-linux and arm-linux (targetting Android), the Android SDK, the Android NDK, Java, Ant, Gtk2 and all it's development packages, the GNU debugger (GDB), subversion and everything else necessary for building Android applications with Lazarus.
63	63
64	64		The download like for the virtual machine image is: <https://sourceforge.net/projects/p-tools/files/Lazarus_for_Android_VM_Image/snapshot_30_dez_2011/> (warning: the VirtualBox image was created using the Mac OS X default Zip utility and not all zip applications can handle it. The Mac OS X default zip application can, and [PeaZip](https://peazip.github.io/) too and [WinRAR](http://win-rar.com/download.html) too. Both 7-Zip and the Windows 7 default unzipper fail.
65	65
66	66		The virtual machine image is composed by two files: “Android Devel VM.vbox” and “Android Devel VM.hdd”. Both need to be located in the same folder and also note that the source forge download is a zipped file, so it needs to be unzipped. After unzipping the VM image has 5,2GB. To use this virtual machine one should install Virtual Box and then use it to open the .vbox file. Then one can already use this Linux virtual machine to build Android applications. The process of building an application involves first opening Lazarus and building the application in Lazarus, for example the example project available on ~/Programas/lazarus/example/androidlcl/ and then going into the Linux terminal, navigating to ~/Programas/lazarus/example/androidlcl/android and issuing the command “ant debug” which will generate the APK file in ~/Programas/ lazarus/example/androidlcl/android/bin/LCLExample-debug.apk. There are two users in the virtual machine: “root” and “pascaldev” and both of them use the password “root”.
67	67
68	68		Note that the virtual machine contains the Lazarus source code from when it was created, but one can also use svn update to get the latest code. Note that this involves some risks, however, as the trunk version might ocasionally contain problems.
69	69
70	70		### Building the compiler yourself in Windows
71	71
72	72		Step 1 - Install the Android SDK and NDK
73	73
74	74		Download from Google and install both the SDK and the NDK for Windows.
75	75
76	76		Check your path to the binutils installed by the NDK. For example, for NDK r7 installed in C:\Programas\android-ndk-r7\\ the path is C:\Programas\android-ndk-r7\toolchains\arm-linux-androideabi-4.4.3\prebuilt\windows\bin
77	77
78	78		Also check your path to the libraries installed by the NDK. For example, for NDK r7 installed in C:\Programas\android-ndk-r7\\ the path is C:\Programas\android-ndk-r7\platforms\android-8\arch-arm\usr
79	79
80	80		Step 2 - Download FPC 2.5.1 from January 19th
81	81
82	82		Create a folder to store the FPC trunk source code and checkout revision 16790
83	83
84	84		Or if you want support for database and many other nice fixes use the branch fpc4android from here:
85	85
86	86		svn co <https://p-tools.svn.sourceforge.net/svnroot/p-tools/fpc4android> fpc4android
87	87
88	88		Step 3 - Install FPC 2.4.4
89	89
90	90		An easy way to obtain a good FPC 2.4.4 is installing Lazarus 0.9.30.2. For example, let's say you install this Lazarus version in C:\Programas\lazarusfpc244
91	91
92	92		Step 4 - Create the build script and built it
93	93
94	94		Create the output directory, for example: C:\Programas\fpcandroid\output
95	95
96	96		Next create a file called build.bat in the fpc root folder, in our example C:\Programas\fpcandroid and copy to it:
97	97
98	98		SET PATH=C:\Programas\lazarusfpc244\fpc\2.4.4\bin\i386-win32\
99	99		make crossinstall CPU_TARGET=arm OS_TARGET=linux CROSSBINDIR=C:\Programas\android-ndk-r7\toolchains\arm-linux-androideabi-4.4.3\prebuilt\windows\bin OPT=-dFPC_ARMEL BINUTILSPREFIX=arm-linux-androideabi- INSTALL_PREFIX=C:\Programas\fpcandroid\output
100	100		pause
101	101
102	102		Next run this batch script and you should have FPC installed into C:\Programas\fpcandroid\output
103	103
104	104		Step 5 - Copy some cross-binutils into the bin dir
105	105
106	106		You now should have a FPC binary in C:\Programas\fpcandroid\output\bin\i386-win32
107	107
108	108		Now get these 3 files:
109	109
110	110		C:\Programas\android-ndk-r7\toolchains\arm-linux-androideabi-4.4.3\prebuilt\windows\bin\arm-linux-androideabi-as.exe C:\Programas\android-ndk-r7\toolchains\arm-linux-androideabi-4.4.3\prebuilt\windows\bin\arm-linux-androideabi-ld.exe C:\Programas\android-ndk-r7\toolchains\arm-linux-androideabi-4.4.3\prebuilt\windows\bin\arm-linux-androideabi-strip.exe
111	111
112	112		And copy and then rename to have:
113	113
114	114		C:\Programas\fpcandroid\output\bin\i386-win32\arm-linux-as.exe C:\Programas\fpcandroid\output\bin\i386-win32\arm-linux-ld.exe C:\Programas\fpcandroid\output\bin\i386-win32\arm-linux-strip.exe
115	115
116	116		Step 6 - Merge this into a Lazarus FPC setup
117	117
118	118		Let's say you have the following Lazarus C:\Programas\lazarus31 with the following fpc installed inside it: C:\Programas\lazarus31\fpc\2.6.1\bin\i386-win32 and C:\Programas\lazarus31\fpc\2.6.1\units\\
119	119
120	120		Now create a directory C:\Programas\lazarus31\fpc\2.5.1\units\arm-linux and copy C:\Programas\fpcandroid\output\units\arm-linux there
121	121
122	122		Copy all .exe files from C:\Programas\fpcandroid\output\bin\i386-win32\\ into C:\Programas\lazarus31\fpc\2.6.1\bin\i386-win32
123	123
124	124		(! copy the exe-files to FPC 2.6.1 !)
125	125
126	126		Now you can already build the example project androidlcltest.lpi using the Windows-Release build mode
127	127
128	128		### Using the pre-compiled compiler in Windows
129	129
130	130		Step 1 - Download and unzip the pre-compiled compiler
131	131
132	132		The download is available here: <https://sourceforge.net/projects/p-tools/files/Free%20Pascal%20for%20ARM/Windows/>
133	133
134	134		Step 2 - Merge it into the FPC installation
135	135
136	136		Let's say you have the following Lazarus C:\Programas\lazarus31 with the following fpc installed inside it: C:\Programas\lazarus31\fpc\2.6.1\bin\i386-win32 and C:\Programas\lazarus31\fpc\2.6.1\units\\
137	137
138	138		Now create a directory C:\Programas\lazarus31\fpc\2.5.1\units\arm-linx and copy fpc4android_2_5_1_26_mar_2012\units\arm-linux there
139	139
140	140		Copy all .exe files from fpc4android_2_5_1_26_mar_2012\bin\i386-win32\\ into C:\Programas\lazarus31\fpc\2.6.1\bin\i386-win32 (the version here should be of the installed Windows compiler, not the version of the cross-compiler, so might be 2.6.0 or 2.7.1 or something else)
141	141
142	142		Step 3 - Install the Java JDK and the Android SDK and NDK
143	143
144	144		If you haven't done so already, then install the Java JDK and the Android SDK and NDK. I recommend the JDK 6 (JDK 7 doesnt work!), latest SDK and the NDK version 7. The Windows NDK 7b has a serious bug: [1](https://groups.google.com/group/android-ndk/browse_thread/thread/d8c88bd58ad6df87/5396d1223f0c65b1?hl=pl&lnk=gst&q=Felipe+Monteiro+de+Carvalho#5396d1223f0c65b1) Some people also report that 7c works fine, and I tested that 8c works fine.
145	145
146	146		- Java JDK (!WARNING! Download JDK version 6! Version 7 does not work!!!): <http://www.oracle.com/technetwork/java/javase/downloads/index.html>
147	147		- Android SDK Download (!WARNING! Instead of clicking in the first download link that you see, go to "Use an existing IDE"!): <http://developer.android.com/sdk/index.html> !WARNING! The SDKs r21 and superior removed the nice apkbuilder.bat script which is utilized in our build system in Windows. If you want to use our Windows build scripts, download the SDK r20 from this link: <http://dl.google.com/android/installer_r20-windows.exe>
148	148		- Android NDK version 7 download link: <http://dl.google.com/android/ndk/android-ndk-r7-windows.zip>
149	149
150	150		Now you can already build the example project androidlcltest.lpi using the Windows-Release build mode and these instructions: [[Custom Drawn Interface/Android\|Custom Drawn Interface/Android#Compiling_the_example_LCL_Android_Application]]
151	151
152	152		### Building the compiler yourself in Linux
153	153
154	154		See [[Setup Cross Compile For ARM]] and make sure to use the option OPT="-dFPC_ARMEL" for building the compiler.
155	155
156	156		### Using the pre-compiled compiler in Linux
157	157
158	158		A pre-compiled compiler is provided for convenience for users. The following steps were tested in Mandriva Linux 2010.0 and 2010.1:
159	159
160	160		Required Environment
161	161
162	162		- The latest stable FPC installed in the system via the RPM / DEB / TAR package
163	163
164	164		Step 1 - Install the cross-binutils
165	165
166	166		For Mandriva Linux the RPM package containing arm-linux-as, arm-linux-ld, etc, which are the cross-binutils can be found here: <http://rpm.pbone.net/index.php3/stat/4/idpl/14252825/dir/mandriva_2010/com/cross-arm-binutils-2.20.51.0.4-2mnb2.i586.rpm.html>
167	167
168	168		Just download the RPM package and install it using:
169	169
170		-	~~`rpm -ivh cross-arm-binutils-2.20.51.0.4-2mnb2.i586.rpm `~~
	170	+	```text
	171	+	rpm -ivh cross-arm-binutils-2.20.51.0.4-2mnb2.i586.rpm
	172	+	```
171	173
172	174		In Mandriva Linux 2010.0 the dependencies won't match, as the package is for 2010.1, but one can simply ignore this problem and it works fine using --nodeps:
173	175
174		-	~~`rpm -ivh --nodeps cross-arm-binutils-2.20.51.0.4-2mnb2.i586.rpm `~~
	176	+	```text
	177	+	rpm -ivh --nodeps cross-arm-binutils-2.20.51.0.4-2mnb2.i586.rpm
	178	+	```
175	179
176	180		For other distributions use the corresponding package, or else read the instructions for building the cross-binutils yourself at [[Setup Cross Compile For ARM]]
177	181
178	182		Step 2 - Configure the cross-binutils
179	183
180	184		The assembler needs a parameter to tell it which ARM ABI to use. A choice which works good is EABI-5, which is compatible with all Android devices available as of Jan 2011. To set this, we will rename the original assembler and substitute it with a shell script which passes the desired parameter. These commands will do it:
181	185
182		-	~~`su`\~~
183		-	~~`mv /usr/bin/arm-linux-as /usr/bin/arm-linux-as_org`\~~
184		-	~~`gedit /usr/bin/arm-linux-as`~~
	186	+	```text
	187	+	su
	188	+	mv /usr/bin/arm-linux-as /usr/bin/arm-linux-as_org
	189	+	gedit /usr/bin/arm-linux-as
	190	+	```
185	191
186	192		Now paste into the editor this code:
187	193
188		-	~~`#!/bin/sh`\~~
189		-	~~`/usr/bin/arm-linux-as_org -meabi=5 $@`~~
	194	+	```text
	195	+	#!/bin/sh
	196	+	/usr/bin/arm-linux-as_org -meabi=5 $@
	197	+	```
190	198
191	199		And don't forget to then make it executable:
192	200
193		-	~~`chmod 755 /usr/bin/arm-linux-as`~~
	201	+	```text
	202	+	chmod 755 /usr/bin/arm-linux-as
	203	+	```
194	204
195	205		Step 3 - Install the Free Pascal Cross-Compiler
196	206
197	207		At this point the pre-compiled FPC can be download from here: <http://sourceforge.net/projects/p-tools/files/Free%20Pascal%20for%20ARM/>
198	208
199	209		Then use these commands to install the pre-compiled Free Pascal cross-compiler into /usr:
200	210
201		-	~~`[felipe@localhost Programas]$ ls -l`\~~
202		-	~~`total 20664`\~~
203		-	~~`-rw-rw-r-- 1 felipe felipe 17098552 2010-10-25 08:17 fpc-2.5.1.arm-linux.tar.gz`\~~
204		-	~~`[felipe@localhost Programas]$ su`\~~
205		-	~~`Password: `\~~
206		-	~~`[root@localhost Programas]# cp fpc-2.5.1.arm-linux.tar.gz /usr/`\~~
207		-	~~`[root@localhost Programas]# cd /usr/`\~~
208		-	~~`[root@localhost usr]# tar -xvf fpc-2.5.1.arm-linux.tar.gz `\~~
209		-	~~`[root@localhost usr]# ln -s /usr/lib/fpc/2.5.1/ppcrossarm /usr/bin/ppcrossarm`~~
	211	+	```text
	212	+	[felipe@localhost Programas]$ ls -l
	213	+	total 20664
	214	+	-rw-rw-r-- 1 felipe felipe 17098552 2010-10-25 08:17 fpc-2.5.1.arm-linux.tar.gz
	215	+	[felipe@localhost Programas]$ su
	216	+	Password:
	217	+	[root@localhost Programas]# cp fpc-2.5.1.arm-linux.tar.gz /usr/
	218	+	[root@localhost Programas]# cd /usr/
	219	+	[root@localhost usr]# tar -xvf fpc-2.5.1.arm-linux.tar.gz
	220	+	[root@localhost usr]# ln -s /usr/lib/fpc/2.5.1/ppcrossarm /usr/bin/ppcrossarm
	221	+	```
210	222
211	223		Step 4 - Verify if your Cross-Compiler works
212	224
213	225		If you made no errors in the previous steps, it should work, so try to call it like this:
214	226
215		-	~~`[felipe@localhost Programas]$ /usr/bin/ppcrossarm`~~
	227	+	```text
	228	+	[felipe@localhost Programas]$ /usr/bin/ppcrossarm
	229	+	```
216	230
217	231		If this command works and fpc shows its options, then you configured the cross-compiler correctly, if not, then try to find out if your symbolic link points to a correct location with this command:
218	232
219	233		\[felipe@localhost Programas\]\$ ls -ls /usr/bin/ppc*
220	234
221	235		Now we are ready to compile Android applications using the Lazarus IDE! Configuring the fpc.cfg file isn't necessary, the old compiler will automatically find the new compiler and it's object files.
222	236
223	237		## Install the Java JDK and the Android SDK and NDK
224	238
225	239		If you haven't done so already, then install the Java JDK and the Android SDK and NDK. I recommend the JDK 6 (JDK 7 doesnt work!), latest SDK and the NDK version 7. The Windows NDK 7b has a serious bug: [2](https://groups.google.com/group/android-ndk/browse_thread/thread/d8c88bd58ad6df87/5396d1223f0c65b1?hl=pl&lnk=gst&q=Felipe+Monteiro+de+Carvalho#5396d1223f0c65b1) Some people also report that 7c works fine, and I tested that 8c works fine.
226	240
227	241		- Java JDK (Choose version 6!): <http://www.oracle.com/technetwork/java/javase/downloads/index.html>
228	242		- Android SDK Download (Choose Use an existing IDE!): <http://developer.android.com/sdk/index.html>
229	243		- Android NDK version 7 download link: <http://dl.google.com/android/ndk/android-ndk-r7-windows.zip>
230	244
231	245		Now you can already build the example project androidlcltest.lpi using the Windows-Release build mode and these instructions: [[Custom Drawn Interface/Android\|Custom Drawn Interface/Android#Compiling_the_example_LCL_Android_Application]]
232	246
233	247		## Compiling the example LCL Android Application
234	248
235	249		Step 1 - Download the source code
236	250
237	251		The source code of the example is located inside the Lazarus sources in lazarus/examples/androidlcl/androidlcltest.lpi
238	252
239	253		Step 2 - Make sure you have the Java JDK and the Android SDK and NDK installed
240	254
241	255		Read here: [[Custom Drawn Interface/Android\|Custom_Drawn_Interface/Android#Install_the_Java_JDK_and_the_Android_SDK_and_NDK]]
242	256
243	257		Step 3 - Build the project using the Lazarus IDE
244	258
245	259		Configuring Lazarus itself to use the new compiler should not normally be necessary because fpc should be able to find the symlink created, but if you have trouble in this part you can try to hard code the compiler path to use the new crosscompiler. To hardcode the compiler path in cause of trouble go to the menu "Tools-\>Options" and change the "Compiler Path" to "/usr/bin/ppcrossarm"
246	260
247	261		But it is necessary to configure the LPI file to build the example. Open the Project Options dialog of the androidlcltest.lpi project and go to the section Paths and change the libraries path to reflect the correct paths of where your Android NDK was installed and where your jnigraphics.so, libc.so, etc, libraries are located for your target Android API level. For LCL-CustomDrawn-Android API level 8 is the best choice, because it supports Android 2.2+ like the LCL. The image below shows where to configure this:
248	262
249	263		![](/wiki-images/b/b0/Configure_androidlcl_libraries.jpg)
250	264
251	265		The actual lazarus release contains a error, they create a .so.so - file instead of a .so - file. So you have to change this manually in lazarus.
252	266
253	267		Step 4 - Build the APK
254	268
255	269		If you are using Windows, use these instructions to build the APK: [[Custom Drawn Interface/Android\|Custom Drawn Interface/Android#Step_4_-_Creating_the_APK_package_in_Windows]]
256	270
257	271		If you are using Linux follow these instructions instead: Before going to the command line to build the APK open the file lazarus/examples/androidlcl/android/local.properties and change it to reflect your Android SDK path. The file says you should not modify it, but ignore that and modify it anyway. Here is how the file looks like:
258	272
259	273		# This file is automatically generated by Android Tools.
260	274		# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
261	275		#
262	276		# This file must NOT be checked in Version Control Systems,
263	277		# as it contains information specific to your local configuration.
264	278
265	279		# location of the SDK. This is only used by Ant
266	280		# For customization when using a Version Control System, please read the
267	281		# header note.
268	282		sdk.dir=/home/felipe/Programas/android-sdk-linux
269	283
270	284		After configuring that one, go to the command line and issue these commands:
271	285
272		-	~~` cd lazarus/examples/androidlcl/android`\~~
273		-	~~` ant debug`~~
	286	+	```text
	287	+	cd lazarus/examples/androidlcl/android
	288	+	ant debug
	289	+	```
274	290
275	291		The APK will be located in lazarus/examples/androidlcl/android/bin
276	292
277	293		Step 5 - Install the APK in your phone and run it
278	294
279	295		You can install via ADB or by copying the file to the sdcard. You should see this:
280	296
281	297		![](/wiki-images/4/4c/Lcl_android_30_mar.png)
282	298
283	299		## How to create an LCL Android Application
284	300
285	301		To create a new LCL-CustomDrawn-Android application simply copy all of the file structure and build and java files from the example project called "androidlcl". This example can be obtained from the Lazarus source tree in lazarus/examples/androidlcl
286	302
287	303		Then you will need to modify the build files to change them to your new project name and your new Java package name.
288	304
289	305		### Step 1 - Creating the LPI
290	306
291	307		You need a separate LPI at the moment for the Android version of the application but all the rest of the code can be shared. Create it using the template for a "Library" and then adapt the code from the example located in the lazarus source code in lazarus/examples/androidlcl
292	308
293	309		You need to adapt the exported JNI method names to your Android Package Name.
294	310
295	311		### Step 2 - Building the library
296	312
297	313		First of all, build the Pascal executable without debug information. This debug information is not so useful in Android and makes the executable much bigger. Open the menu Project-\>Project Options and set the build mode, widgetset, architecture and operating system targets, as shown in these screenshots:
298	314
299	315		![](/wiki-images/6/64/Android_project_options_1.png)
300	316
301	317		![](/wiki-images/f/f7/Android_project_options_2.png)
302	318
303	319		![](/wiki-images/9/9f/Android_project_options_3.png)
304	320
305	321		### Step 3 - Create the Android project structure
306	322
307	323		Besides the LCL project building, such as configuring a proper LPI and having a library main project file, one also needs to add all of the android project structure. Simply copy from the example project in lazarus/examples/androidlcl and adapt it to the new project. Things to change are the path to the SDK, the package name. The package name needs to be updated in the build files, in the directory structure android/src/packagename, in the activity java source code and also in the main library pascal source in the exports section.
308	324
309	325		### Step 4 - Creating the APK package
310	326
311	327		#### Step 4 - Creating the APK package in Linux
312	328
313	329		To create the APK package in Linux simply go to the directory "android" inside the project folder and issue the command "ant debug". The package will be in android/bin/MyProject.apk
314	330
315		-	~~`cd myproject/android ant debug`~~
	331	+	```text
	332	+	cd myproject/android
	333	+	ant debug
	334	+	```
316	335
317	336		Ant and all dependencies must be installed using the package management of your linux distribution.
318	337
319	338		#### Step 4 - Creating the APK package in Windows
320	339
321	340		Pre-requisites:
322	341
323	342		- Java JDK installed: <http://www.oracle.com/technetwork/java/javase/downloads/index.html>
324	343		- Android SDK Installed
325	344
326	345		Instructions:
327	346
328	347		In Windows we provide a APK build system which uses only the tools provided in the Android SDK and therefore does not require ANT.
329	348
330	349		First it is necessary to create a debug key to use. To do this use this script:
331	350
332		-	~~`lazarus/examples/androidlcl/android/generate_debug_key.bat`~~
	351	+	```text
	352	+	lazarus/examples/androidlcl/android/generate_debug_key.bat
	353	+	```
333	354
334	355		which can be copied from the example application to your own project folder.
335	356
336	357		it contains following:
337	358
338		-	~~`REM Adjust these paths to yours`\~~
339		-	~~`SET PATH=C:\Programme\Android\android-sdk\tools;C:\Programme\Android\android-sdk\platform-tools\;C:\Programme\Java\jdk1.6.0_38\bin`\~~
340		-	~~`SET APP_NAME=androidlcltest`\~~
341		-	~~`SET ANDROID_HOME=C:\Programme\Android\android-sdk`\~~
342		-	~~`SET APK_SDK_PLATFORM=C:\Programme\Android\android-sdk\platforms\android-9`\~~
343		-	~~`SET APK_PROJECT_PATH=C:\Programme\lazarus\examples\androidlcl\android`\~~
	359	+	``` pascal
	360	+	REM Adjust these paths to yours
	361	+	SET PATH=C:\Programme\Android\android-sdk\tools;C:\Programme\Android\android-sdk\platform-tools\;C:\Programme\Java\jdk1.6.0_38\bin
	362	+	SET APP_NAME=androidlcltest
	363	+	SET ANDROID_HOME=C:\Programme\Android\android-sdk
	364	+	SET APK_SDK_PLATFORM=C:\Programme\Android\android-sdk\platforms\android-9
	365	+	SET APK_PROJECT_PATH=C:\Programme\lazarus\examples\androidlcl\android
344	366
345		-	~~`mkdir bin`\~~
	367	+	mkdir bin
346	368
347		-	~~`keytool --help`\~~
	369	+	keytool --help
348	370
349		-	~~`keytool -genkey -v -keystore bin\LCLDebugKey.keystore -alias LCLDebugKey -keyalg RSA -validity 10000`\~~
	371	+	keytool -genkey -v -keystore bin\LCLDebugKey.keystore -alias LCLDebugKey -keyalg RSA -validity 10000
350	372
351		-	~~`REM call and pause together allow us to see the results in the end`\~~
352		-	~~`pause`\~~
	373	+	REM call and pause together allow us to see the results in the end
	374	+	pause
	375	+	```
353	376
354	377		You have to fix everything after SET to your own paths. Don't forget adjusting the android version from APK_SDK_PLATFORM!
355	378
356	379		After generating the key, use the other script:
357	380
358		-	~~`lazarus/examples/androidlcl/android/build_debug_apk.bat`~~
	381	+	```text
	382	+	lazarus/examples/androidlcl/android/build_debug_apk.bat
	383	+	```
359	384
360	385		To build the APK file. Also remember to edit this batch file to reflect your paths.
361	386
362	387		This script contains the following:
363	388
364		-	~~`REM Adjust these paths to yours`\~~
365		-	~~`SET PATH=C:\Programme\Android\android-sdk\tools;C:\Programme\Android\android-sdk\platform-tools\;C:\Programme\Java\jdk1.6.0_38\bin`\~~
366		-	~~`SET APP_NAME=androidlcltest`\~~
367		-	~~`SET ANDROID_HOME=C:\Programme\Android\android-sdk`\~~
368		-	~~`SET APK_SDK_PLATFORM=C:\Programme\Android\android-sdk\platforms\android-9`\~~
369		-	~~`SET APK_PROJECT_PATH=C:\lazarus\examples\androidlcl\android `\~~
	389	+	```text
	390	+	REM Adjust these paths to yours
	391	+	SET PATH=C:\Programme\Android\android-sdk\tools;C:\Programme\Android\android-sdk\platform-tools\;C:\Programme\Java\jdk1.6.0_38\bin
	392	+	SET APP_NAME=androidlcltest
	393	+	SET ANDROID_HOME=C:\Programme\Android\android-sdk
	394	+	SET APK_SDK_PLATFORM=C:\Programme\Android\android-sdk\platforms\android-9
	395	+	SET APK_PROJECT_PATH=C:\lazarus\examples\androidlcl\android
370	396
371		-	~~`REM Create necessary directory Structure`\~~
372		-	~~`mkdir bin`\~~
373		-	~~`mkdir bin\classes`\~~
374		-	~~`mkdir gen`\~~
375		-	~~`mkdir gen\com`\~~
376		-	~~`mkdir gen\com\pascal`\~~
377		-	~~`mkdir gen\com\pascal\lcltest`\~~
378		-	~~`mkdir raw`\~~
379		-	~~`mkdir raw\lib`\~~
380		-	~~`mkdir raw\lib\armeabi`\~~
	397	+	REM Create necessary directory Structure
	398	+	mkdir bin
	399	+	mkdir bin\classes
	400	+	mkdir gen
	401	+	mkdir gen\com
	402	+	mkdir gen\com\pascal
	403	+	mkdir gen\com\pascal\lcltest
	404	+	mkdir raw
	405	+	mkdir raw\lib
	406	+	mkdir raw\lib\armeabi
381	407
382		-	~~`REM Cleanup`\~~
383		-	~~`del bin\%APP_NAME%.ap_`\~~
384		-	~~`del bin\%APP_NAME%.apk`\~~
385		-	~~`del raw\lib\armeabi*.so`\~~
	408	+	REM Cleanup
	409	+	del bin\%APP_NAME%.ap_
	410	+	del bin\%APP_NAME%.apk
	411	+	del raw\lib\armeabi*.so
386	412
387		-	~~`REM More directory preparation`\~~
388		-	~~`copy libs\armeabi*.so raw\lib\armeabi\ `\~~
	413	+	REM More directory preparation
	414	+	copy libs\armeabi*.so raw\lib\armeabi\
389	415
390		-	~~`REM Resource compilation`\~~
391		-	~~`call aapt p -v -f -M AndroidManifest.xml -F bin\%APP_NAME%.ap_ -I %APK_SDK_PLATFORM%\android.jar -S res -m -J gen raw`\~~
	416	+	REM Resource compilation
	417	+	call aapt p -v -f -M AndroidManifest.xml -F bin\%APP_NAME%.ap_ -I %APK_SDK_PLATFORM%\android.jar -S res -m -J gen raw
392	418
393		-	~~`REM Java compiler`\~~
394		-	~~`call javac -verbose -classpath %APK_SDK_PLATFORM%\android.jar -d bin\classes src\com\pascal\lcltest\LCLActivity.java`\~~
	419	+	REM Java compiler
	420	+	call javac -verbose -classpath %APK_SDK_PLATFORM%\android.jar -d bin\classes src\com\pascal\lcltest\LCLActivity.java
395	421
396		-	~~`REM DX to convert the java bytecode to dalvik bytecode`\~~
397		-	~~`call dx --dex --verbose --output=%APK_PROJECT_PATH%\bin\classes.dex %APK_PROJECT_PATH%\bin\classes `\~~
	422	+	REM DX to convert the java bytecode to dalvik bytecode
	423	+	call dx --dex --verbose --output=%APK_PROJECT_PATH%\bin\classes.dex %APK_PROJECT_PATH%\bin\classes
398	424
399		-	~~`REM It seams that dx calls echo off`\~~
400		-	~~`@echo on`\~~
401		-	~~`REM Now build the unsigned APK`\~~
402		-	~~`del %APK_PROJECT_PATH%\bin\%APP_NAME%-unsigned.apk`\~~
403		-	~~`call apkbuilder %APK_PROJECT_PATH%\bin\%APP_NAME%-unsigned.apk -v -u -z %APK_PROJECT_PATH%\bin\%APP_NAME%.ap_ -f %APK_PROJECT_PATH%\bin\classes.dex`\~~
	425	+	REM It seams that dx calls echo off
	426	+	@echo on
	427	+	REM Now build the unsigned APK
	428	+	del %APK_PROJECT_PATH%\bin\%APP_NAME%-unsigned.apk
	429	+	call apkbuilder %APK_PROJECT_PATH%\bin\%APP_NAME%-unsigned.apk -v -u -z %APK_PROJECT_PATH%\bin\%APP_NAME%.ap_ -f %APK_PROJECT_PATH%\bin\classes.dex
404	430
405		-	~~`REM Generating on the fly a debug key`\~~
406		-	~~`rem keytool -genkey -v -keystore bin\LCLDebugKey.keystore -alias LCLDebugKey -keyalg RSA -validity 10000 -dname NAME -storepass senhas -keypass senhas`\~~
	431	+	REM Generating on the fly a debug key
	432	+	rem keytool -genkey -v -keystore bin\LCLDebugKey.keystore -alias LCLDebugKey -keyalg RSA -validity 10000 -dname NAME -storepass senhas -keypass senhas
407	433
408		-	~~`REM Signing the APK with a debug key`\~~
409		-	~~`del bin\%APP_NAME%-unaligned.apk`~~
	434	+	REM Signing the APK with a debug key
	435	+	del bin\%APP_NAME%-unaligned.apk
	436	+	```
410	437
411		-	~~`REM Change keypass and storepass pw here\| and here\|`\~~
412		-	~~`jarsigner -verbose -keystore bin\LCLDebugKey.keystore -keypass senhas -storepass senhas -signedjar bin\%APP_NAME%-unaligned.apk bin\%APP_NAME%-unsigned.apk LCLDebugKey`\~~
	438	+	``` pascal
	439	+	REM Change keypass and storepass pw here\| and here\|
	440	+	jarsigner -verbose -keystore bin\LCLDebugKey.keystore -keypass senhas -storepass senhas -signedjar bin\%APP_NAME%-unaligned.apk bin\%APP_NAME%-unsigned.apk LCLDebugKey
413	441
414		-	~~`REM Align the final APK package`\~~
415		-	~~`zipalign -v 4 bin\%APP_NAME%-unaligned.apk bin\%APP_NAME%.apk `\~~
	442	+	REM Align the final APK package
	443	+	zipalign -v 4 bin\%APP_NAME%-unaligned.apk bin\%APP_NAME%.apk
416	444
417		-	~~`REM call and pause together allow us to see the results in the end`\~~
418		-	~~`pause`~~
	445	+	REM call and pause together allow us to see the results in the end
	446	+	pause
	447	+	```
419	448
420	449		Don't forget changing the set-variables in the top AND change the pw (see above where).
421	450
422	451		### Building an LCL Android application with debug info
423	452
424	453		It is useful to add another Android build mode which has debug info. Use all of the same options as shown above, except for the debug information:
425	454
426	455		![](/wiki-images/1/11/Android_project_options_4.png)
427	456
428	457		## Oh no! My LCL Android application doesn't work
429	458
430	459		There are various reasons why the app may not work. The most important thing to do when an app doesn't work is to open the logcat and see what the log says. This can be done by running this command line command:
431	460
432	461		``` bash
433	462		./adb logcat
434	463		```
435	464
436	465		And then test one of the hypotheses in the next subsections.
437	466
438	467		### The Pascal executable was compiled for a wrong architecture, operating system and/or widgetset
439	468
440	469		This is the leading cause of executables not running. Always verify that you compiled the program to the "android" widgetset, "linux" operating system and "arm" architecture. This is done by going into the menu Project-\>Project Options. Then set these in the dialog all options as explained in this section:
441	470
442	471		[[How to build an LCL Android application]]
443	472
444	473		To check if you library is arm-linux or not, execute the following commands:
445	474
446	475		``` bash
447	476		cd libs/armeabi
448	477		ls -l
449	478		file liblclapp.so
450	479		ldd liblclapp.so
451	480		```
452	481
453	482		If it mentions anything like 80386 or gtk, then your program was compiled for linux-x86 and gtk2, not for Android like it should.
454	483
455	484		### My Pascal application crashed. How to get a stacktrace?
456	485
457	486		If a Pascal application crashes you should use the command "adb logcat" to obtain the stack
458	487
459	488		Read also this thread in the Google NDK group about converting addresses to lines: <http://groups.google.com/group/android-ndk/msg/2ed2286e85f4ccdd>?
460	489
461	490		### The indispensable build options
462	491
463	492		- -Xd This build option is indispensable when cross-compiling from x86-linux to Android or else FPC will try to link the application against for example /usr/lib/libc.so instead of the libc.so in the NDK, even if you specify a -Fl library path
464	493		- -CpARMV6 This build option is indispensable because code generated for older ARM versions is unsupported by Android and might crash in some devices. See <http://groups.google.com/group/android-ndk/browse_thread/thread/ba542483f062a828>
465	494		- -dAndroid in the package LCLBase.lpk
466	495		- -Parm -Tlinux for the process and target operating system
467	496		- -Fl should contain the path to the NDK directory with the target link shared object, such as libc.so, liblog.so, libjni.so, etc
468	497
469	498		### Wrong package name
470	499
471	500		If you change the package name of the project, then you need to adapt the main project file to inform the widgetset of the change. In the example project this is done in the main project file, androidlcltest.lpr in this part:
472	501
473	502		CDWidgetset.ActivityClassName := 'com/pascal/lcltest/LCLActivity';
474	503
475	504		If your new package name is com.pascal.myapp, then you should change the command above to this:
476	505
477	506		CDWidgetset.ActivityClassName := 'com/pascal/myapp/LCLActivity';
478	507
479	508		## Free Pascal Bugs on Android Support
480	509
481	510		The following summarizes the state of Android Support in Free Pascal:
482	511
483	512		- The pre-compiled snapshot for x86-linux -\> Android is known to work very well and it was built on 19th January 2011: <https://sourceforge.net/projects/p-tools/files/Free%20Pascal%20for%20ARM/>
484	513		- On February this revision <http://svn.freepascal.org/cgi-bin/viewvc.cgi?view=rev&revision=16981> introduced this bug: <http://mantis.freepascal.org/view.php?id=18833>
485	514		- In the end of 2011 this revision <http://svn.freepascal.org/cgi-bin/viewvc.cgi?view=rev&revision=19036> broke linking Android projects
486	515
487	516		We are in contact with FPC developers to fix the situation as can be seen in: <http://mantis.freepascal.org/view.php?id=20726>
488	517
489	518		### FPC4Android Branches
490	519
491	520		Because of FPC bugs related to Android support I have rolled my own branches.
492	521
493	522		#### FPC4Android 2.5.1
494	523
495	524		FPC4Android 2.5.1 has the following fixes applied to it:
496	525
497	526		<http://bugs.freepascal.org/view.php?id=21208> <http://bugs.freepascal.org/view.php?id=21341> <http://bugs.freepascal.org/view.php?id=19559>
498	527
499	528		And I have created a pre-compiled x86-linux -\> android-arm cross-compiler and hosted it here (it is the -v2 cross-compiler);
500	529
501	530		<https://sourceforge.net/projects/p-tools/files/Free%20Pascal%20for%20ARM/>
502	531
503	532		To download the source execute:
504	533
505		-	~~`svn co `[`https://p-tools.svn.sourceforge.net/svnroot/p-tools/fpc4android`](https://p-tools.svn.sourceforge.net/svnroot/p-tools/fpc4android)` fpc4android`~~
	534	+	```text
	535	+	svn co https://p-tools.svn.sourceforge.net/svnroot/p-tools/fpc4android fpc4android
	536	+	```
506	537
507	538		#### FPC4Android 2.6.1
508	539
509	540		This branch is not finished, it lacks patches to fix Android support, patches are welcome. SVN link:
510	541
511		-	~~`svn co `[`https://p-tools.svn.sourceforge.net/svnroot/p-tools/fpc4android_2_6`](https://p-tools.svn.sourceforge.net/svnroot/p-tools/fpc4android_2_6)` fpc4android_2_6`~~
	542	+	```text
	543	+	svn co https://p-tools.svn.sourceforge.net/svnroot/p-tools/fpc4android_2_6 fpc4android_2_6
	544	+	```
512	545
513	546		## Android SDK and NDK bugs
514	547
515	548		### Android NDK for Windows broken linker
516	549
517	550		The linker in android-ndk-r7b (path C:\Programas\android-ndk-r7\toolchains\arm-linux-androideabi-4.4.3\prebuilt\windows\bin\arm-linux-androideabi-ld.exe) crashes for no reason while linking LCL apps =( The linker from android-ndk-r7 and r5 work correctly.
518	551
519	552		See <http://groups.google.com/group/android-ndk/browse_thread/thread/d8c88bd58ad6df87>
520	553
521	554		### Error while calling DX: Trouble processing: bad class file magic (cafebabe)
522	555
523	556		If while using the build script you get the following errors:
524	557
525	558		D:\djsystem\djpalm\android>call dx --dex --verbose --output=D:\djsystem\djpalm\a
526	559		ndroid\bin\classes.dex D:\djsystem\djpalm\android\bin\classes
527	560		processing D:\djsystem\djpalm\android\bin\classes\.\com\pascal\djpalm\LCLActivit
528	561		y$1.class...
529	562
530	563		trouble processing:
531	564		bad class file magic (cafebabe) or version (0033.0000)
532	565		...while parsing com/pascal/djpalm/LCLActivity$1.class
533	566		...while processing com/pascal/djpalm/LCLActivity$1.class
534	567		processing D:\djsystem\djpalm\android\bin\classes\.\com\pascal\djpalm\LCLActivit
535	568		y$2.class...
536	569
537	570		trouble processing:
538	571		bad class file magic (cafebabe) or version (0033.0000)
539	572		...while parsing com/pascal/djpalm/LCLActivity$2.class
540	573		...while processing com/pascal/djpalm/LCLActivity$2.class
541	574		processing D:\djsystem\djpalm\android\bin\classes\.\com\pascal\djpalm\LCLActivit
542	575		y$3.class...
543	576
544	577		This probably means that you are using JDK 7. Unfortunatelly the current Android SDK r20 is not compatible with JDK 7, only with JDK 5 and 6. Please install JDK 6 and use that instead. See:
545	578
546	579		- <http://stackoverflow.com/questions/8538891/bad-class-file-magic-when-using-dx-bat>
547	580		- <http://www.oracle.com/technetwork/java/javase/downloads/jdk6-downloads-1637591.html>
548	581
549	582		## Development Notes
550	583
551	584		### The mysterious JNI Crash (SIGILL - illegal instruction)
552	585
553	586		See the thread: <http://groups.google.com/group/android-ndk/browse_thread/thread/ba542483f062a828>
554	587
555	588		The problem was that vm^^.GetEnv would crash in HTC Wildfire, Alcatel and in the emulator with SIGILL but not in Xperia Mini, HTC Desire HD, Motorola Atrix and other smartphones.
556	589
557	590		The answer was that one needs to specify -CpARMV6 when building because older instructions might fail in some devices. Also try restarting the emulator or running on a different device.
558	591
559	592		### NDK Libraries available in Android 2.2 (API level 8)
560	593
561	594		LCL-CustomDrawn targets Android 2.2+ and in this API level the following libraries are supported by the NDK:
562	595
563	596		1. libc.so
564	597		2. libdl.so (linker)
565	598		3. OpenGL ES 1
566	599		4. OpenGL ES 2
567	600		5. libjnigraphics.so
568	601		6. liblog.so
569	602		7. libm.so
570	603		8. libz.so
571	604		9. libthread_db.so
572	605		10. libstdc++.so
573	606
574	607		LCL-CustomDrawn-Android uses libjnigraphics.so and liblog.so at the moment.
575	608
576	609		### Native text drawing
577	610
578	611		Native text drawing is a bit convoluted in Android and the documentation is quite bad too. Some gotchas already found:
579	612
580	613		- It draws text starting on a Y coordinate which represents the baseline, which is the bottom of strings like "abc", but not the bottom of strings like "qg". See <http://code.google.com/p/android/issues/detail?id=393>
581	614		- There is no documentation about what the size in Paint.setTextSize represents. Some people say it is pixels, but to me it looks something else because it seams to differ across devices.
582	615
583	616		But there are also good things about it:
584	617
585	618		- It can draw on a transparent bitmap and use alpha transparency to implement anti-aliasing and subpixel rendering. The text gets quite beaultiful.
586	619		- It can draw on the ARGB 32-bits non-premultiplied format which is a pretty good one
587	620
588	621		### Flood of garbage collector messages when the caret is visible
589	622
590	623		Something like this:
591	624
592	625		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 188 objects / 6664 bytes in 94ms
593	626		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 170 objects / 6160 bytes in 78ms
594	627		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 162 objects / 5904 bytes in 82ms
595	628		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 162 objects / 5856 bytes in 78ms
596	629		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 162 objects / 5872 bytes in 80ms
597	630		D/dalvikvm( 2825): GC_EXPLICIT freed 371 objects / 18480 bytes in 91ms
598	631		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 162 objects / 5896 bytes in 78ms
599	632		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 162 objects / 5896 bytes in 78ms
600	633		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 162 objects / 5896 bytes in 81ms
601	634		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 162 objects / 5920 bytes in 78ms
602	635		D/dalvikvm( 6364): GC_EXTERNAL_ALLOC freed 162 objects / 5920 bytes in 83ms
603	636
604	637		In my investigation this happens probably because the TCDEdit will request a full control invalidate on each timer tick, which currently will main a full form invalidate, so the GC needs to collect the bitmaps and other paint objects when painting that often.
605	638
606	639		### Why the caret of a TEdit keeps blinking after clicking on the form
607	640
608	641		When clicking on the form the LCL focus will refuse to move from the Edit to the Form because this behavior seems to be hard coded in the LCL, although maybe we might change this for Android. So even while we set focus into the form, the LCL refuses to do that and keeps its focus in the Edit, thus we have a focus mismatch. This might eventually be fixed in the future.
609	642
610	643		### Android ComboBox
611	644
612	645		For adding Android combobox support a new method was added to LCLIntf along with a global variable to store the callback of this dialog:
613	646
614	647		``` pascal
615	648		var
616	649		OnShowSelectItemDialogResult: TOnShowSelectItemDialogResult;
617	650
618	651		function ShowSelectItemDialog(const AItems: TStrings): Boolean; override;
619	652		```
620	653
621	654		This method will run a native item selection dialog, if the platform has one, or result false without doing anything otherwise.
622	655
623	656		![](/wiki-images/8/82/Android_combobox.png)
624	657
625	658		### Using the Native ListView Dialog
626	659
627	660		To allow the user to select items from a list more easily we offer a routine which launch dialog with the native ListView.
628	661
629	662		``` pascal
630	663		{$ifdef LCLCustomDrawn}
631	664		uses customdrawnint, lclintf;
632	665		{$endif}
633	666
634	667		procedure TForm2.Button3Click(Sender: TObject);
635	668		begin
636	669		{$ifdef LCLCustomDrawn}
637	670		LCLIntf.OnListViewDialogResult := @MyOnListViewDialogResult;
638	671		CDWidgetSet.ShowListViewDialog('Dialog Title',
639	672		['Title1', 'Title2', 'Title3', 'Title4', 'Title5', 'Title6'],
640	673		['Descr1', 'Descr2', 'Descr3', 'Descr4', 'Descr5', 'Descr6']);
641	674		{$endif}
642	675		end;
643	676
644	677		procedure TForm2.MyOnListViewDialogResult(ASelectedItem: Integer);
645	678		begin
646	679		DebugLn(Format('[MyOnListViewDialogResult] ASelectedItem=%d', [ASelectedItem]));
647	680		end;
648	681		```
649	682
650	683		LCLIntf.OnListViewDialogResult will be called with the selected item, with a zero-based index, or -1 if the dialog was cancelled by the user. One way to cancel the dialog is when the user pressed the back button.
651	684
652	685		Note that there are 2 more parameters in the end of this routine with default values, which allow choosing the color for the odd and the other for the even rows. The color is an integer of 32-bits in the ARGB format, don't use TColor here!
653	686
654	687		``` pascal
655	688		procedure TCDWidgetSet.ShowListViewDialog(ATitle: string; ATitles,
656	689		ADescriptions: array of string;
657	690		AColorOddRow: jint = $ff292C29; AColorEvenRow: jint = $ff424542);
658	691		```
659	692
660	693		![](/wiki-images/2/2c/Android_ListView.png)
661	694
662	695		### LazDeviceAPIs
663	696
664	697		See: [[LazDeviceAPIs]]
665	698
666	699		---
667	700		From the Free Pascal wiki, page "Custom Drawn Interface/Android", as it stood on 2021-01-08 after a change by Giorgio Tani, 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).
668	701		Category: Android
669	702		Category: Custom Drawn

Back to history