FAQ LazarusConsultez toutes les FAQ

LAMW Manager est l'outil le plus commode pour installer et configurer le framework Lazarus Android Module Wizard (LAMW), qui permet de créer des applications pour Android dans l'environnement de développement Lazarus. Il prend en charge l'installation du SDK Android et de Java (OpenJDK), ce qui vous dispense de les installer vous-même.

Notez que ce sont les versions 2.0.12 de Lazarus et 3.2.2 du compilateur Free Pascal qui servent de support.

Sous Linux :

Téléchargez et décompactez ce fichier : https://github.com/DanielOliveiraSou...ive/master.zip.
Exécutez l'assistant :

./lamw_manager  --sdkmanager

./lamw_manager  --update-lamw

./lamw_manager  --reinstall

./lamw_manager  --reset

Pour créer une application Android, utilisez le menu Projet / Nouveau projet... puis sélectionnez le type de projet LAMW [GUI] Android Module.

Dans le dialogue qui apparaît, définissez au minimum les champs suivants (les autres sont facultatifs) :

• Path to workspace [your projects folder] : c'est l'emplacement de votre espace de travail, où sont stockés tous vos projets ;
  
• New Project Name [or Select] : c'est le nom de votre projet.

• NdkApi : c'est la version minimale du NDK (Android Native Development Kit), qui est l'interface de programmation orientée vers le matériel-cible ;
• Min. Device Api : c'est la version minimale du SDK (Software Development Kit), qui est une abstraction en bytecode Java indépendante du matériel ;
• Architecture/Instructions : c'est l'architecture-cible (processeur ARM 6, ARM 7, Intel x86, etc.) ;
• Android Theme : vous pouvez sélectionner un autre thème que celui par défaut, mais certains thèmes nécessitent d'installer des bibliothèques supplémentaires.

Si vous souhaitez que votre application puisse être distribuée sur un maximum d'appareils, vous pouvez définir une version minimale du SDK (Software Development Kit), soit au moment de la création du projet (premier lien ci-dessous), soit via le menu Projet / Options du projet... / [LAMW] Android Project Options.

Versions d'Android supportées par le SDK :

• Android 14 "Upside Down Cake" : version 34 ;
• Android 13 "Tiramisu" : version 33 ;
• Android 12 "Snow Cone" : version 31 ;
• Android 11 "Red Velvet Cake" : version 30 ;
• Android 10 "Q" : version 29 ;
• Android 9 "Pie" : version 28 ;
• Android 8 "Oreo" : version 26 ;
• Android 7 "Nougat" : version 24 ;
• Android 6 "Marshmallow" : version 23 ;
• Android 5 "Lollipop" : version 21 ;
• Android 4.4 "Kitkat" : version 19 ;
• Android 4.1 "Jellybean" : version 16.

Il est tout-à-fait possible d'exécuter une application sur un smartphone ou une tablette Android, directement depuis l'environnement de développement Lazarus.

Le prérequis est d'activer le mode développeur sur le téléphone dans les paramètres :

• cherchez l'option À propos du téléphone ;
• affichez les informations sur le logiciel ;
• pressez 7 fois sur le numéro de version.

• Rester activé ;
• Débogage USB ;
• Vérifier les applis via USB.

LAMW s'attend à trouver les éléments dessinables de l'interface de l'application dans les ressources, qui sont stockées dans le dossier res du répertoire du projet. Pour les éléments dessinables, il y a plusieurs sous-dossiers qui correspondent à différentes résolutions, de la plus basse à la plus élevée (à titre indicatif, la taille approximative des images est donnée par rapport à la plus faible résolution) :

• drawable-ldpi : (fichiers png) ;
• drawable-mdpi (fichiers png) - taille x 1,33 ;
• mipmap-mdpi (fichiers webp) - taille x 1,33 ;
• drawable-hdpi (fichiers png) - taille x 2 ;
• mipmap-hdpi (fichiers webp) - taille x 2 ;
• drawable-xhdpi (fichiers png) - taille x 2,66 ;
• mipmap-xhdpi (fichiers webp) - taille x 2,66 ;
• drawable-xxhdpi (fichiers png) - taille x 4 ;
• mipmap-xxhdpi (fichiers webp) - taille x 4 ;
• mipmap-xxxhdpi (fichiers webp) - taille x 5,33.

Si votre application est accompagnée de fichiers (texte, images, binaires...), vous pouvez les déposer dans le dossier assets de votre projet.

Allez dans le menu Outils / [LAMW] Android Module Wizard de Lazarus et sélectionnez Use/Import Image/Picture. Dans le dialogue qui apparaît, vous pouvez cocher plusieurs emplacements :

• assets, pour par exemple importer des images qui seront utilisées dans un jImageList ;
• plusieurs emplacements drawable-xxx, pour importer des images dans les ressources.

Toutes les applications possèdent une icône par défaut : c'est déjà le cas avec Lazarus, où par défaut c'est une patte de tigre, et c'est aussi le cas avec LAMW, où il s'agit soit d'un petit logo vert Android, soit d'un petit lémurien. Il est bien sûr possible de remplacer l'icône par défaut par l'icône de votre choix, mais attention : cela ne se fait pas du tout de la même façon que dans les applications classiques de Lazarus.

Tout d'abord, il faut savoir que votre icône devra obligatoirement porter le nom ic_launcher. Il existe deux type d'icônes, selon la résolution et la version d'Android visée :

• ic_launcher.png ;
• ic_launcher.webp et ic_launcher_round.webp (version ronde de l'icône).

• drawable-ldpi : ic_launcher.png 36*36 ;
• drawable-mdpi : ic_launcher.png 48*48 ;
• mipmap-mdpi : ic_launcher.webp et ic_launcher_round.webp 48*48 ;
• drawable-hdpi : ic_launcher.png 72*72 ;
• mipmap-hdpi : ic_launcher.webp et ic_launcher_round.webp 72*72 ;
• drawable-xhdpi : ic_launcher.png 96*96 ;
• mipmap-xhdpi : ic_launcher.webp et ic_launcher_round.webp 96*96 ;
• drawable-xxhdpi : ic_launcher.png 144*144;
• mipmap-xxhdpi : ic_launcher.webp et ic_launcher_round.webp 144*144 ;
• mipmap-xxxhdpi : ic_launcher.webp et ic_launcher_round.webp 192*192.

Plutôt que de simples images PNG ou WEBP, les versions récentes d'Android attendent une nouvelle génération d'icônes : les icônes adaptives. Il s'agit en réalité de fichiers XML permettant de composer l'icône de votre application à partir d'images contenues dans les ressources. Cela nécessite deux images :

• une image de fond, ic_launcher_background ;
• l'image principale, ic_launcher_foreground.

1
2
3
4
5
<?xml version="1.0" encoding="utf-8"?> 
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android"> 
    <background android:drawable="@mipmap/ic_launcher_background"/> 
    <foreground android:drawable="@mipmap/ic_launcher_foreground"/> 
</adaptive-icon>

Vous pouvez déterminer les dossiers par défaut du système sur lesquel tourne votre application à l'aide de la méthode GetEnvironmentDirectoryPath de la fenêtre principale, par exemple :

MyAppDirectory := Self.GetEnvironmentDirectoryPath(dirInternalAppStorage);

• le dossier où se trouve l'application : dirInternalAppStorage (dans l'exemple ci-dessus) ;
• les téléchargements : dirDownloads ;
• les documents : dirDocuments - uniquement pour les versions récentes d'Android ;
• la musique : dirMusic ;
• les images : dirPictures ;
• les vidéos : dirMovies ;
• le stockage secondaire : dirSdCard ;
• les bases de données : dirDatabase.

Il peut être opportun de désactiver temporairement la mise en veille de l'écran du smartphone ou de la tablette pendant l'exécution de l'application. Pour ce faire, il suffit d'ajouter cette ligne (par exemple, lors de l'initialisation de l'application, dans la méthode AndroidModule1JNIPrompt) :

Self.SetKeepScreenOn(True);

Depuis la palette Android Bridges Extra, déposez un composant jNotificationManager n'importe où sur la fiche de travail.

Voici un exemple de code permettant de générer une notification. Sont successivement définis :

• le texte de la notification - il est à noter qu'il n'y a pas de retour à la ligne possible ;
• l'espace de nommage de l'application tel qu'attendu par Android : "domaine.éditeur.nomapplication" (le domaine et l'éditeur sont définis, à la création de l'application, dans le champ Default Package Name du dialogue de création) ;
• la classe d'activité (ici c'est bien entendu une application) ;
• une valeur personnalisée permettant à l'application de réagir à la notification (voir le lien ci-dessous) ;
• le titre de la notification.

1
2
3
NotificationManager.Subject := 'Contenu de la notification'; 
NotificationManager.SetContentIntent('org.alcatiz.monapplication', 'App', 'Valeur personnalisée', 'Titre de la notification'); 
NotificationManager.Notify;

• l'icône et le nom de l'application ;
• le titre en gras ;
• le texte de la notification.

Pour permettre à une application ouverte par une notification d'éventuellement adopter un comportement particulier en fonction de la notification, il faut créer un gestionnaire répondant à l'événement OnActivityCreate de la fenêtre principale. Par exemple (voir la notification créée à la Q/R précédente - lien ci-dessous) :

1
2
3
4
5
6
7
8
9
procedure TfrmMain.frmMainActivityCreate(Sender : TObject; AIntentData : jObject); 
var 
  LExtraString : String; 
begin 
  LExtraString := IntentManager.GetExtraString(AIntentData, 'Valeur personnalisée');  
  if LExtraString <> '' 
     then 
       { . . . } 
end;