Android Programming: what changed

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

Old	New		Line
1	1		(Android only)
2	2
3	3		See also [[Custom Drawn Interface/Android]]
4	4
5	5		Knowing general Android programming can be very useful to help develop the Lazarus Android Interface.
6	6
7	7		## Platform Tips
8	8
9	9		## How to...
10	10
11	11		### Build the NDK OpenGL example
12	12
13	13		Just follow these steps:
14	14
15	15		Step 1 - Download and install the Android NDK, Android SDK and Ant. More information here: [[Android Interface/Using the Android SDK, Emulator and Phones\|Android_Interface/Using_the_Android_SDK%2C_Emulator_and_Phones]]
16	16
17	17		Step 2 - Install the pre-compiled FPC cross-compiler. Instructions here: [[Android Interface\|Android_Interface#Using_the_pre-compiled_compiler]]
18	18
19	19		Step 3 - Download the latest lazarus-ccr sourceforge code:
20	20
21	21		``` bash
22	22		svn co https://lazarus-ccr.svn.sourceforge.net/svnroot/lazarus-ccr lazarus-ccr
23	23		```
24	24
25	25		or if you think it is too big you can download just the folder lazarus-ccr/bindings/android-ndk
26	26
27	27		Step 4 - Building the Pascal Library
28	28
29	29		> Note: In the steps below, the directory /home/felipe/Programas or ~/Programas is used. Please adjust if your paths are different.
30	30
31	31		Open the project lazarus-ccr/bindings/android-ndk/examples/opengltest/opengltest.lpi
32	32
33	33		Go to Project-\>Project Options-\>Paths and where is written "Libraries -Fl" you should see a value like this:
34	34
35		-	~~```~~
	35	+	```text
36	36		/home/felipe/Programas/android-ndk-r5/platforms/android-9/arch-arm/usr/lib
37	37		```
38	38
39	39		Change it to the correct path in your system which points to the NDK and to the library folder for your minimal required Android API Level
40	40
41	41		Now build the project using Lazarus.
42	42
43	43		Step 5 - Configuring the build environment
44	44
45	45		Open the file opengltest/local.properties. Change this line to point to your SDK location:
46	46
47		-	~~```~~
	47	+	```text
48	48		sdk.dir=/home/felipe/Programas/android-sdk-linux
49	49		```
50	50
51	51		Step 6 - Buildings the APK
52	52
53	53		Open a terminal and type these commands:
54	54
55	55		``` bash
56	56		cd lazarus-ccr/bindings/ndk/examples/opengltest/android
57	57		ant debug
58	58		```
59	59
60	60		The APK file will be placed in opengltest/android/bin/
61	61
62	62		Step 7 - Install the APK
63	63
64	64		In this step, if you get error messages about permissions read: [[Android Interface/Using the Android SDK, Emulator and Phones\|Android_Interface/Using_the_Android_SDK%2C_Emulator_and_Phones#Recognition_of_devices_under_Linux]]
65	65
66	66		The command to install our APK in the phone is:
67	67
68	68		``` bash
69	69		cd opengltest/android
70	70		~/Programas/android-sdk-linux/platform-tools/adb install bin/OpenGLNDKTest-debug.apk
71	71		```
72	72
73	73		You should see something like:
74	74
75		-	~~```~~
	75	+	```text
76	76		2395 KB/s (107299 bytes in 0.043s)
77	77		pkg: /data/local/tmp/OpenGLNDKTest-debug.apk
78	78		Success
79	79		```
80	80
81	81		If you get an error message that it is already installed you can install with this command:
82	82
83	83		``` bash
84	84		~/Programas/android-sdk-linux/platform-tools/adb uninstall com.pascal.opengltest
85	85		```
86	86
87	87		And then you can run adb logcat to see what the log says while you start it in the phone via its newly added icon:
88	88
89	89		``` bash
90	90		~/Programas/android-sdk-linux/platform-tools/adb logcat
91	91		```
92	92
93	93		### Read the screen metrics
94	94
95	95		First fill a TDisplayMetrics with the correct info:
96	96
97	97		``` pascal
98	98		uses androidutil;
99	99
100	100		var
101	101		MyDisplayMetrics: TDisplayMetrics;
102	102		Str: string;
103	103		//
104	104		lHeight, lWidth: Integer;
105	105		xdpi, ydpi, lScreenSize: Single;
106	106		begin
107	107		// ..
108	108		// Objects
109	109
110	110		MyDisplayMetrics := TDisplayMetrics.Create;
111	111		Activity.getWindowManager().getDefaultDisplay().getMetrics(MyDisplayMetrics);
112	112		```
113	113
114	114		And then you can read it from the TDisplayMetrics:
115	115
116	116		``` pascal
117	117		lHeight := MyDisplayMetrics.heightPixels();
118	118		lWidth := MyDisplayMetrics.widthPixels();
119	119		xdpi := MyDisplayMetrics.xdpi();
120	120		ydpi := MyDisplayMetrics.ydpi();
121	121		lScreenSize := sqrt(sqr(lHeight / ydpi) + sqr(lWidth / xdpi));
122	122		ldensity := MyDisplayMetrics.density();
123	123		ldensityDpi := MyDisplayMetrics.densityDpi();
124	124		scaledDensity := MyDisplayMetrics.scaledDensity();
125	125		```
126	126
127	127		Note that lots of devices lie about the xdpi and ydpi, so don't trust the lScreenSize calculated above. Smartphones might report even 10 inches of screen size, while the correct is around 4.
128	128
129	129		## Details about Android devices
130	130
131	131		Since there are so many Android devices, it can be useful to keep track of some information about them. See also in the wikipedia Comparison of Android Devices [1](http://en.wikipedia.org/wiki/Comparison_of_Android_devices) and details about the processors in [2](https://wiki.mozilla.org/Mobile/Platforms/Android#System_Requirements).
132	132
133	133		### Smartphones
134	134
135	135		\| Manufacturer \| Model \| Android API Name (Build.Model) \| Processor \| Android version \| Multi-touch \| Comments \|
136	136		\|----\|----\|----\|----\|----\|----\|----\|
137	137		\| HTC \| Wildfire \| HTC Wildfire \| armv6 \| 2.1=\>2.2 \| Yes\\|\\|- \| \|
138	138		\| Sony Erricson \| Xperia X10 \| X10i \| armv7 \| 1.6=\>2.1 \| No\\|\\|- \| \|
139	139
140	140		### Tablets
141	141
142	142		\| Manufacturer \| Model \| Android API Name (Build.Model) \| Processor \| Android version \| Multi-touch \| Comments \|
143	143		\|----\|----\|----\|----\|----\|----\|----\|
144	144		\| Toshiba \| Folio 100 Tablet \| TOSHIBA_FOLIO_AND_A \| armv7 \| 2.2 \| Yes\\|\\|- \| \|
145	145
146	146		### List of devices ordered by processor compatibility (ARMv6 vs ARMv7)
147	147
148	148		<caption>List of ARMv7 devices</caption>
149	149		<tbody>
150	150
151	151		Fascinate, Vibrant, Epic 4G)</td>
152	152
153	153		</tbody>
154	154
155	155		\| \| \| \| \|
156	156		\|----\|----\|----\|----\|
157	157		\| Android SDK emulator \| Asus Garmin nuvifone A50 (T-Mobile Garminfone) \| Augen GENTouch 78 Tablet \| Coby Kyros Internet Tablet (MID7015) \|
158	158		\| Geeksphone One, Geeksphone Zero \| HTC Aria \| HTC ChaCha \| HTC Dream (T-Mobile G1, Android Dev Phone 1) \|
159	159		\| HTC Droid Eris \| HTC Espresso (T-Mobile myTouch 3G Slide) \| HTC Hero (T-Mobile G2 Touch) \| \\|HTC Legend \|
160	160		\| HTC Magic (T-Mobile myTouch 3G, T-Mobile G1 Touch) \| HTC Salsa \| HTC Tattoo \| HTC Wildfire \|
161	161		\| Huawei Ascend \| Huawei Ideos U8150-B (T-Mobile Comet) \| Huawei U8110 (T-Mobile Pulse Mini) \| \\|Huawei U8230 \|
162	162		\| LG Ally (Apex) (LG VS740) \| LG GW620 (Eve, InTouch Max, LinkMe) \| LG Optimus, Optimus M, Optimus T, Optimus S, Optimus V \| LG Vortex \|
163	163		\| LG P500 \| MAG iMiTO iM7 \| vMAG iMiTO iM7S \| Motorola Backflip \|
164	164		\| Motorola Citrus \| Motorola Cliq (MB200) \| Motorola Dext \| Motorola Devour \|
165	165		\| Motorola i1 \| Motorola Spice XT300 \| Motorola Quench XT5 XT502 \| Pandigital Novel \|
166	166		\| Samsung GT-S5570 Galaxy Mini \| Samsung i5500 Galaxy 5 (Corby) \| Samsung i5700 Galaxy Portal (Spica) \| Samsung i5800 Galaxy 3 \|
167	167		\| Samsung i7500 Galaxy \| Samsung Intercept \| Samsung M900 Moment \| Samsung S5830 Galaxy Ace \|
168	168		\| Samsung Transform \| Sanyo ZIO M6000 \| Sony Ericsson Xperia X8 \| Sony Ericsson Xperia X10 Mini \|
169	169		\| Sony Ericsson Xperia X10 Mini Pro \| Superpad 10.2" Tablet PC \| Viewsonic ViewPad 7 Tablet \| Velocity Micro T103 Cruz tablet \|
170	170		\| Vodafone 845 \| ZTE Blade \| \| \|
171	171
172	172		List of ARMv6 processors:'''
173	173
174	174		### Playing sounds and videos on the phones
175	175
176	176		Each phone comes with different codecs installed, which means that the native Media Player will be able to play different formats in different phones. Below is a table showing which formats play in the native Media Player of each phone:
177	177
178	178		\| Telephone \| Android \| webm - VP8 \| m4v - H.264 \| ogv - Theora \| mp4 - H.264 \| mov - H.264 \| avi - RLE \| mpg - MPEG-1 \| wmv - WM9 \| 3gp - MPEG-4 \|
179	179		\|----\|----\|----\|----\|----\|----\|----\|----\|----\|----\|----\|
180	180		\| Emulator \| 1.6 \| x \| x \| x \| x \| x \| x \| x \| x \| OK \|
181	181		\| Emulator \| 2.1 \| x \| x \| x \| x \| x \| x \| x \| x \| OK \|
182	182		\| Nexus One \| 2.2 \| x \| OK \| x \| OK \| x \| x \| x \| x \| OK \|
183	183		\| HTC Desire \| 1.6 \| x \| OK \| x \| OK \| x \| x \| x \| OK \| OK \|
184	184		\| Toshiba Folio 100 \| 2.2 \| x \| OK \| x \| OK \| x \| x \| x \| OK \| OK \|
185	185		\| Xperia X10 \| 2.1 \| x \| OK \| x \| x \| x \| x \| x \| OK \| OK \|
186	186		\| Xperia X8 \| 2.2 \| x \| OK \| x \| x \| x \| x \| x \| x \| OK \|
187	187		\| HTC Wildfire \| 2.1 \| x \| OK \| x \| x \| x \| x \| x \| x \| OK \|
188	188		\| HTC Desire HD \| 2.2 \| x \| OK \| x \| OK \| x \| x \| x \| x \| OK \|
189	189		\| Galaxy Tab \| 2.2 \| x \| OK \| x \| x \| x \| x \| x \| x \| OK \|
190	190		\| myPhone A210 \| 1.6 \| x \| OK \| x \| x \| x \| x \| x \| x \| OK \|
191	191		\| Motorola Milestone \| 2.1 \| x \| OK \| x \| x \| x \| x \| x \| OK \| ? \|
192	192		\| Milestone 2 \| 2.2 \| x \| OK \| x \| x \| x \| x \| x \| sound-only \| OK \|
193	193
194	194		## Android file system
195	195
196	196		Android recommends to use getApplicationContext().getFilesDir() to obtain the data directory for the application and this routine in my HTC Wildfire returns /data/data/\<package name\>
197	197
198	198		The native libraries of the application are placed in /data/data/\<package\>/lib
199	199
200	200		A good place where we have read and write access and we can create new files and even run files is /data/data/\<package name\>
201	201
202	202		## Creating a new Java Android application
203	203
204	204		This info can be useful for helping implement LCL-CustomDrawn-Android
205	205
206	206		Generic instructions here: <http://developer.android.com/guide/developing/other-ide.html>
207	207
208	208		### Showing/hiding the virtual keyboard
209	209
210	210		See here: <http://android-codes-examples.blogspot.com/2011/11/show-or-hide-soft-keyboard-on-opening.html>
211	211
212	212		To show it:
213	213
214	214		``` java
215	215		InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
216	216		imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
217	217		```
218	218
219	219		and for hiding the keyboard:
220	220
221	221		``` java
222	222		InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
223	223		imm.hideSoftInputFromWindow(singleedittext.getWindowToken(),0);
224	224		```
225	225
226	226		## Android JNI
227	227
228	228		Using JNI (Java Native Interface) you can call most Android SDK APIs and also other Java libraries.
229	229
230	230		### Table of Java types and Pascal JNI types
231	231
232	232		All of the Java types except interfaces can be represented in JNI without problems. For each Java type there is a corresponding VM Type Signature which is utilized in routines such as javaEnvRef^^.GetMethodID. There is also the JNI native type, which is the type declared in the unit lazarus/lcl/interfaces/customdrawn/android/jni.pas and should be the type utilized in JNI code written in Pascal. The Pascal equivalent is provided just for comparison, as one should use the types from jni.pas when writing JNI code.
233	233
234	234		\| Java type \| VM signature \| Type in jni.pas \| Pascal equivalent \| Description \|
235	235		\|----\|----\|----\|----\|----\|
236	236		\| boolean \| Z \| jboolean \| Boolean \| \|
237	237		\| byte \| B \| jbyte \| Byte \| \|
238	238		\| char \| C \| jchar \| Word \| \|
239	239		\| short \| S \| jshort \| Shortint \| \|
240	240		\| int \| I \| jint \| Integer \| \|
241	241		\| long \| J \| jlong \| Int64 \| \|
242	242		\| float \| F \| jfloat \| Single \| \|
243	243		\| double \| D \| jdouble \| Double \| \|
244	244		\| a class, ie: String or InputStream \| L\<full class name\> ie: Ljava/lang/String; \| jobject \| N/A \| \|
245	245		\| Array, ie: int\[\] \| \[\<type-name\> ie: \[I \| N/A \| \| \|
246	246		\| A method type \| (arg-types)ref-type \| JMethodID \| N/A \| \|
247	247		\| void \| V \| N/A \| procedure \| \|
248	248
249	249		### Example 1: Creating a Java object and calling a Java method
250	250
251	251		Let's say that you want to make Pascal JNI code equivalent to the following Java code:
252	252
253	253		``` java
254	254		HttpGet javaRequest = new HttpGet();
255	255		URI myURI = new URI("http://magnifier.sourceforge.net/");
256	256		javaRequest.setURI(myURI);
257	257		```
258	258
259	259		First you need to get all Class IDs involved in the process, then get all method IDs which we will use and then make the calls. If the call has parameters, then pass it in an array. The following Pascal native code is equivalent to that Java code above:
260	260
261	261		``` pascal
262	262		uses jni, customdrawnint;
263	263
264	264		var
265	265		javaClass_HttpGet, javaClass_URI: jclass;
266	266		javaMethod_HttpGet_new, javaMethod_HttpGet_setURI,
267	267		javaMethod_URI_new: jmethodid;
268	268		javaRequest, javaURI: jobject;
269	269		javaString: jstring;
270	270		lParams: array[0..2] of JValue;
271	271		lNativeString: PChar;
272	272		begin
273	273		DebugLn(':>LoadHTMLPageViaJNI');
274	274		// First call FindClass for all required classes
275	275		javaClass_HttpGet := javaEnvRef^^.FindClass(javaEnvRef,
276	276		'org/apache/http/client/methods/HttpGet');
277	277		javaClass_URI := javaEnvRef^^.FindClass(javaEnvRef,
278	278		'java/net/URI');
279	279
280	280		// Now all Method IDs
281	281		DebugLn(':LoadHTMLPageViaJNI 1');
282	282		javaMethod_HttpGet_new := javaEnvRef^^.GetMethodID(javaEnvRef, javaClass_HttpGet, '<init>', '()V');
283	283		javaMethod_HttpGet_setURI := javaEnvRef^^.GetMethodID(javaEnvRef, javaClass_HttpGet, 'setURI', '(Ljava/net/URI;)V');
284	284		javaMethod_URI_new := javaEnvRef^^.GetMethodID(javaEnvRef, javaClass_URI, '<init>', '(Ljava/lang/String;)V');
285	285
286	286		// Create a new instance for the HTTP request object
287	287		// HttpGet javaRequest = new HttpGet();
288	288		javaRequest := javaEnvRef^^.NewObject(javaEnvRef,
289	289		javaClass_HttpGet,
290	290		javaMethod_HttpGet_new);
291	291
292	292		DebugLn(':LoadHTMLPageViaJNI 4 javaRequest='+IntToHex(PtrInt(javaRequest), 8));
293	293		// Add a URI for the request object
294	294		// URI javaURI = new URI("http://magnifier.sourceforge.net/");
295	295		lParams[0].l := javaEnvRef^^.NewStringUTF(javaEnvRef, 'http://magnifier.sourceforge.net');
296	296		javaURI := javaEnvRef^^.NewObjectA(javaEnvRef,
297	297		javaClass_URI, javaMethod_URI_new, @lParams[0]);
298	298		javaEnvRef^^.DeleteLocalRef(javaEnvRef, lParams[0].l);
299	299		// javaRequest.setURI(javaURI);
300	300		lParams[0].l := javaURI;
301	301		javaEnvRef^^.CallVoidMethodA(javaEnvRef, javaRequest,
302	302		javaMethod_HttpGet_setURI, @lParams[0]);
303	303		```
304	304
305	305		### Example 2: Calling a static method
306	306
307	307		Let's say that you want to call the following static method located in the Bass class: <http://jerome.jouvie.free.fr/nativebass/javadoc/org/jouvieje/bass/Bass.html>
308	308
309	309		``` java
310	310		public static native int BASS_StreamCreateFile(String file, long offset, long length, int flags);
311	311		```
312	312
313	313		First you need to get all Class IDs involved in the process, then get the static method ID and then make the call with the parameter in the array:
314	314
315	315		``` pascal
316	316		uses jni, customdrawnint;
317	317
318	318		var
319	319		javaClass_Bass: jclass;
320	320		javaMethod_Bass_BASS_StreamCreateFile: jmethodid;
321	321		javaString: jstring;
322	322		lParams: array[0..3] of JValue;
323	323		lRetInt: jint;
324	324		begin
325	325		// First call FindClass for all required classes
326	326		javaClass_Bass := javaEnvRef^^.FindClass(javaEnvRef, 'org/jouvieje/bass/Bass');
327	327
328	328		// Now all Method IDs
329	329		javaMethod_Bass_BASS_StreamCreateFile := javaEnvRef^^.GetStaticMethodID(javaEnvRef, javaClass_Bass, 'BASS_StreamCreateFile', '(Ljava/lang/String;JJI)I');
330	330
331	331		// Make the call
332	332		lParams[0].l := javaEnvRef^^.NewStringUTF(javaEnvRef, '/path/to/file');
333	333		lParams[1].j := 0; // offset
334	334		lParams[2].j := 200; // length
335	335		lParams[3].i := 0; // flags
336	336		lRetInt := javaEnvRef^^.CallStaticIntMethodA(javaEnvRef, javaClass_Bass, javaMethod_Bass_BASS_StreamCreateFile, @lParams[0]);
337	337		javaEnvRef^^.DeleteLocalRef(javaEnvRef, lParams[0].l);
338	338		```
339	339
340	340		## References
341	341
342	342		- <http://developer.android.com/guide/developing/other-ide.html>
343	343		- [Tutorial "Lazarus and Android"](https://dl.dropboxusercontent.com/u/3753548/Lazarus%20and%20Android.pdf) (PDF file)
344	344
345	345		---
346	346		From the Free Pascal wiki, page "Android Programming", as it stood on 2019-12-16 after a change by Trev, 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