PC SOFT

FORUMS PROFESSIONNELS
WINDEVWEBDEV et WINDEV Mobile

Accueil → WINDEV Mobile 2024 → Import code Java dans projet Android
Import code Java dans projet Android
Débuté par Marc LAZZARINI, 23 oct. 2018 09:33 - 19 réponses
Membre enregistré
232 messages
Popularité : +23 (23 votes)
Posté le 23 octobre 2018 - 09:33
Salut à tous,

J'essaie désespérément d'importer du code Java dans mon projet WM Android, mais je n'y arrive pas. En fait j'ai besoin d'importer une classe complète avec ses imports et ses extends, et même ses override (je sais, je suis gourmand).

import android.app.Activity;
import android.app.ListActitity;
import android.view.KeyEvent;

public class MyActivity extends ListActivity  {
 
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        super.onKeyDown(keyCode, event);
if (keyCode == KeyEvent.KEYCODE_F1) { 
appelProcedureWL("AppuiTouche","KEYCODE_F1");
return true; 
}
    }
}


Mais j'ai l'impression qu'on ne peut créer du code Java que par procédure, et non par classe...
J'ai bien essayé de créer un .jar avec ma classe , mais comme il contient instruction appelProcedureWL qui se trouve dans le framework de Windev, le compilateur Javac la marque comme unchecked et plante la compilation....

Have an idea ??? Please ;(;(
Posté le 24 octobre 2018 - 10:48
Pourquoi vouloir faire un envoi touche ou appui touche sur Android ?
Si c'est un lecteur de code barre cela ne fonctionne pas comme cela sur Android.
Il faut regarder l'api fournie par le fabricant et l'adapter.
Donne nous plus d'informations, c'est curieux ?
Membre enregistré
232 messages
Popularité : +23 (23 votes)
Posté le 24 octobre 2018 - 17:39
Salut Popoy,

Merci, mais pour le lecteur de CB je me contente de Datawedge correctement paramétré.

Non là, j'ai besoin d'utiliser les touches physiques du terminal. En l'occurence le Skorpio X4 pour cette fois, mais c'est souvent du Zebra. Peut importe en fait.

Je voudrais associer une action dans l'application à l'appui d'une touche physique. F1, F2.. En occurrence, mais le principe sera le même pour n'importe quelle touche.
Et là, ce n'est pas l'api du constructeur qui entre en jeu, mais bel et bien l'évènement onKeyDown et son keyCode. Tout comme on avait sous Windows (CE ou autre).

Merci par avance pour ton aide.

Marc.
Membre enregistré
16 messages
Posté le 05 novembre 2018 - 21:39
Salut Marc,
Sans aller dans les détails de ce que tu veux faire, je te conseillerais d’accéder à ton code JAVA par l'import d'un .JAR au lieu d'essayer de le copier directement dans WinDev.En fonction des besoins, j'utilise les deux méthodes suivantes :
- Si c'est une action simple et directe : Une procédure JAVA 'à la WinDev', directement dans le projet
- Si c'est une action un peu plus complexe encapsulée dans une classe qui expose plusieurs méthodes ou un composant de plusieurs classes Java : Faire le code complet sous Eclipse par ex., générer un .Jar et dans le projet WinDev, accéder au code Java en passant par l'import du .Jar
Message modifié, 05 novembre 2018 - 21:43
Membre enregistré
232 messages
Popularité : +23 (23 votes)
Posté le 06 novembre 2018 - 09:25
Bonjour Carine,

C'est très gentil, je te remercie pour ta réponse. Mais le fait que je veuille appeler une procédure WinDev depuis le code Java m'empêche de passer par une librairie externe en .jar.


Entre temps j'ai trouvé comment brancher la gestion des évènements de type OnKeyDown, mais visiblement j'ai fait ce travail pour rien car en version 24 ce sera en natif…


Cordialement,
Marc.
Posté le 07 novembre 2018 - 10:46
@marc, félicitations.
peut tu mettre l'info pour ceux qui n'auront pas la 24.
merci d'avance.
Membre enregistré
232 messages
Popularité : +23 (23 votes)
Posté le 07 novembre 2018 - 15:02
J'avais pensé que ça n'intéressait personne d'autre que moi.
C'est curieux ?

popoy a écrit :
@marc, félicitations.
peut tu mettre l'info pour ceux qui n'auront pas la 24.
merci d'avance.


popoy a écrit :
Pourquoi vouloir faire un envoi touche ou appui touche sur Android ?
Si c'est un lecteur de code barre cela ne fonctionne pas comme cela sur Android.
Il faut regarder l'api fournie par le fabricant et l'adapter.
Donne nous plus d'informations, c'est curieux ?
Membre enregistré
232 messages
Popularité : +23 (23 votes)
Posté le 07 novembre 2018 - 15:21
Donc,

Primo, créer une procédure globale en Java capable d'intercepter les touches appuyées. Je l'ai appelée Android_HookClavier_OnKey(), le nom est libre. :
import android.view.View;
import android.view.KeyEvent;

PUBLIC static void Android_HookClavier_OnKey(string sNomChamp)
{
View v = getView(sNomChamp);
v.setOnKeyListener(new View.OnKeyListener()
{
@Override PUBLIC boolean onKey(View v, int keyCode, KeyEvent Event)
{
IF (Event.getAction() == KeyEvent.ACTION_DOWN)
{
boolean valRetour;
valRetour = appelProcedureWL_boolean("WL_HookClavier", keyCode);
RETURN valRetour;
}
RETURN False;
}
});
}


Cette procédure créé un Listener sur le champ dont le nom sera passé en paramètre.
Quand un appui touche est détecté sur ce champ, ça appelle automatiquement la procédure globale en WL que j'ai appelé WL_HookClavier en lui passant en paramètre le KEY_CODE de la touche appuyée.

Procedure WL_HookClavier(nKeyCode est un entier)
sCar est une chaîne UNICODE
SELON nKeyCode
CAS KEYCODE_F1, KEYCODE_F2
// Traitez ce que vous voulez si F1 ou F2 est appuyé (ici juste pour l'exemple)
RENVOYER Vrai // La touche est interceptée, pas de traitement par l'OS

AUTRE CAS
RENVOYER Faux // Touche non interceptée, on laisse l'OS gérer.

FIN


Après c'est à décliner comme vous le voulez, et à vous de vous débrouiller pour renvoyer le traitement vers la fenêtre ouverte, mais ça vous savez faire et puis c'est un autre sujet.

Ha oui au fait ! Pour me simplifier la compréhension du code, j'ai créé des constantes avec le nom et la valeur des KEY_CODE :
CONSTANT
KEYCODE_0 = 0x00000007
KEYCODE_1 = 0x00000008
KEYCODE_2 = 0x00000009
KEYCODE_3 = 0x0000000a
KEYCODE_4 = 0x0000000b
KEYCODE_F1 = 0x00000083
KEYCODE_F2 = 0x00000084
KEYCODE_F3 = 0x00000085
KEYCODE_NUMPAD_0 = 0x00000090
KEYCODE_NUMPAD_1 = 0x00000091
KEYCODE_NUMPAD_2 = 0x00000092
KEYCODE_NUMPAD_3 = 0x00000093
KEYCODE_NUMPAD_4 = 0x00000094
// etc.

La liste des KEY_CODE est ici : https://developer.android.com/reference/android/view/KeyEvent

Pour brancher la gestion des évènements, ça se passe dans le traitement Fin d'Initialisation de la fenêtre :
Android_HookClavier_OnKey(SAI_Scan..Nom)


Là je l'ai branché sur un champ de texte appelé SAI_Scan. Il faut le faire sur tous les champs sur lesquels vous voulez pouvoir détecter la touche appuyée.

Par contre je n'ai pas réussi à le gérer au niveau de l'Activity (la fenêtre), mais je sais que c'est faisable aussi.

Si ça peut aider, c'est cool.

Marc.
Membre enregistré
232 messages
Popularité : +23 (23 votes)
Posté le 07 novembre 2018 - 15:23
Et si quelqu'un a la variante pour l'utiliser au niveau de l'Activity je suis preneur.
Posté le 16 novembre 2018 - 10:50
Bonjour,

J'essaye d’implémenter le code pour intercepter les touches (F10,F11,...) sur un terminal Zebra Android 7.1.

Le code d'interception fonctionne parfaitement et me permet d’exécuter une procédure WD mais je rencontre un problème.
Lorsque cette procédure ouvre une nouvelle fenêtre (via Info()) l'application crash.
Le problème n’apparaît pas si je remplace la fonction Info() par un ToastAffiche().

Est-ce que quelqu’un à déjà rencontrer ce genre de problème ?

Merci d'avance
Membre enregistré
232 messages
Popularité : +23 (23 votes)
Posté le 16 novembre 2018 - 11:15
J'ai eu le même problème oui. Je l'ai contourné mais je ne sais plus comment. Je dois partir, mais je verrai si ce soir j'ai le temps de regarder et te répondre.
Posté le 21 novembre 2018 - 09:36
Bonjour Marc,

Je me permets de relancer le sujet, est-ce que vous avez pu regarder ?

Merci
Membre enregistré
232 messages
Popularité : +23 (23 votes)
Posté le 21 novembre 2018 - 11:22
Hello,

Non hélas, pas eu le temps, je n'arrête pas de courir. Par contre il m'est revenu que ce sont les instructions "appelProcedureWL" qui posent problème quand on ouvre une nouvelle fenêtre depuis la procédure lancée. J'avais dû me débrouiller pour ne pas tomber dans ce cas de figure, mais je pense qu'on devrait faire une remontée au ST.

Cordialement,

Marc.
Posté le 21 novembre 2018 - 16:33
Confirmation par le support téléphonique.

On ne peux pas intercepter les touches F1,F2 en version 23... par contre en 24 ça marchera... (évidemment :()

Je vais donc continuer à essayer de le gérer en natif.

Merci de votre aide
Membre enregistré
232 messages
Popularité : +23 (23 votes)
Posté le 21 novembre 2018 - 17:49
Ça on le savait, mais le problème à leur remonter c'est que ça plante quand on ouvre une fenêtre depuis une procédure appelée par appelProcedureWL. Ça ça n'a rien à voir avec l'interception d'une touche appuyée, c'est un bug d'ordre général.
Posté le 21 novembre 2018 - 18:09
A l’occasion je vais préparer un projet de test avec le code de reproduction pour le support.

On verra bien...
Membre enregistré
32 messages
Posté le 10 novembre 2021 - 15:33
Salut,
S'il te plaît je veut en savoir plus.

--
Merci de me soutenir.
Posté le 19 octobre 2022 - 17:32
Salutation depuis le futur, 2022, en version 25 / 27.
Le problème persiste toujours pour la détection des touches F1,F2.. des mobiles android (Zebra) et le crash à l'ouverture de fenêtre fille. Je suis partis du code de Marc LAZZARINI (merci à lui) et j'ai trouvé des alternatives.

Note : J'ai aussi une alternative pour l'ouverture de fenêtre fille faussement bloquante qui est compatible avec cette solution (nécessite une variable globale au projet et un retour de valeur via cette variable). Ce code n'est pas très beau, mais je n'ai pas réussis a faire mieux avec les limites de windev. La voici :
pg_OuvreAndroid(P_nomFenetre,P_param0="no_param",P_param1="no_param",P_param2="no_param",P_param3="no_param",P_param4="no_param",P_param5="no_param",P_param6="no_param",P_param7="no_param",P_param8="no_param",P_param9="no_param")
//Sous Android, on ne peut pas utiliser ni le paramètre "*" ni les indirections sur des variable local. De plus OuvreFenetreMobile ne peut recevoir un nombre de paramètre dynamique.
v_ValeurRenvoyé est un Variant = Null
GPv_ValeurRenvoyé = Null
GPv_ValeurRenvoyé[1] = Null
GPv_ValeurRenvoyé[2] = Null
GPv_ValeurRenvoyé[3] = Null
GPv_ValeurRenvoyé[4] = Null
GPv_ValeurRenvoyé[5] = Null

SI P_param0 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre)
SINON SI P_param1 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre,P_param0)
SINON SI P_param2 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre,P_param0,P_param1)
SINON SI P_param3 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre,P_param0,P_param1,P_param2)
SINON SI P_param4 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre,P_param0,P_param1,P_param2,P_param3)
SINON SI P_param5 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre,P_param0,P_param1,P_param2,P_param3,P_param4)
SINON SI P_param6 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre,P_param0,P_param1,P_param2,P_param3,P_param4,P_param5)
SINON SI P_param7 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre,P_param0,P_param1,P_param2,P_param3,P_param4,P_param5,P_param6)
SINON SI P_param8 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre,P_param0,P_param1,P_param2,P_param3,P_param4,P_param5,P_param6,P_param7)
SINON SI P_param9 = "no_param" ALORS
OuvreFenêtreMobile(P_nomFenetre,P_param0,P_param1,P_param2,P_param3,P_param4,P_param5,P_param6,P_param7,P_param8)
SINON
OuvreFenêtreMobile(P_nomFenetre,P_param0,P_param1,P_param2,P_param3,P_param4,P_param5,P_param6,P_param7,P_param8,P_param9)
FIN

TANTQUE FenEtat(P_nomFenetre) = Actif //DANS {Actif;AffichageSeulement;Grisé;HorsEcran;Invisible}
Multitâche(-50) // sert à temporiser sans bloquer
FIN
SI GPv_ValeurRenvoyé..Occurrence > 0
v_ValeurRenvoyé[1] = GPv_ValeurRenvoyé[1]
v_ValeurRenvoyé[2] = GPv_ValeurRenvoyé[2]
v_ValeurRenvoyé[3] = GPv_ValeurRenvoyé[3]
v_ValeurRenvoyé[4] = GPv_ValeurRenvoyé[4]
v_ValeurRenvoyé[5] = GPv_ValeurRenvoyé[5]
GPv_ValeurRenvoyé[1] = Null
GPv_ValeurRenvoyé[2] = Null
GPv_ValeurRenvoyé[3] = Null
GPv_ValeurRenvoyé[4] = Null
GPv_ValeurRenvoyé[5] = Null
GPv_ValeurRenvoyé = Null
RENVOYER (v_ValeurRenvoyé[1],v_ValeurRenvoyé[2],v_ValeurRenvoyé[3],v_ValeurRenvoyé[4],v_ValeurRenvoyé[5])
FIN
v_ValeurRenvoyé = GPv_ValeurRenvoyé
GPv_ValeurRenvoyé = Null
RENVOYER v_ValeurRenvoyé



Et voici le complément concernant les touches F1, F2 ... non détéctées par windev :
1: La procédure à appeler à la fin d'initialisation de la fenêtre
Procedure pg_AjouteListener(F_MaFenetre <utile>,s_ListeRaccourci <utile>)
//Exemple d'usage: pg_AjoutListener(MaFenetre,BTN_Bouton1..NomComplet+";"+KEYCODE_F1+";"+BTN_Bouton2..NomComplet+";"+KEYCODE_F2+";"BTN_Bouton3..NomComplet+";"+KEYCODE_F1...)
//Avec BTN_Bouton3 sur un autre plan que BTN_Bouton1 ou BTN_Bouton3 non visible et actif en même temps que BTN_Bouton1
//Attention ! Le listener ne s'active pas si un DonneFocus est fait sur un champs inactif !

//On ajoute le listener sur tous les champs de la fenêtre en cours
<Compile SI Configuration="Nom_Config_Android">
i est un entier = 1
ResChamp est une chaîne
ResChamp = EnumèreChamp(F_MaFenetre, i)
TANTQUE ResChamp<>""
i++
Android_HookClavier_OnKey(ResChamp, s_ListeRaccourci)
ResChamp = EnumèreChamp(F_MaFenetre, i)
FIN
<FIN>


2: La procédure java (légèrement modifiée) pour créer les listener
import android.view.View;
import android.view.KeyEvent;

PUBLIC static void Android_HookClavier_OnKey(string sNomChamp,final string sChampKeyCode)
{
View v = getView(sNomChamp);
v.setOnKeyListener(new View.OnKeyListener()
{
@Override PUBLIC boolean onKey(View v, int keyCode, KeyEvent Event)
{
IF (Event.getAction() == KeyEvent.ACTION_DOWN) {
boolean valRetour;
valRetour = appelProcedureWL_boolean("WL_HookClavier", keyCode, sChampKeyCode);
RETURN valRetour;
}
RETURN False;
}
});
}


3: Le traitement avec vérification d'accessibilité de la cible

Procedure WL_HookClavier(n_KeyCode est un entier <utile>, s_ChampKeyCode est une chaîne <utile>)
//Procédure appelée par le listener
//n_KeyCode = la touche pressée
//s_ChampKeyCode = la liste des champs et leur touche associée
<Compile SI Configuration="Nom_Config_Android">

ta_ChampParKey est un tableau associatif (*,*,wlEntier) de chaîne
s_ChampEC est une chaîne
i est un entier = 0
POUR TOUTE chaîne s_ChampOuKeyCode de s_ChampKeyCode SEPAREE PAR ";"
i++
SI Modulo(i,2) = 1 ALORS
s_ChampEC = s_ChampOuKeyCode
//Si le bouton associé n'est pas dans le plan en cours, est invisible ou non actif alors on ne le prend pas en compte
// (cela permet également d'avoir plusieurs fois le même raccourcis pour une fenêtre sur différents champs)
SI (PAS ChampExiste(s_ChampEC)) _OU_ PAS ({s_ChampEC,indChamp}..Plan = 0 _OU_ Contient({s_ChampEC,indChamp}..Plan,{ExtraitChaîne(s_ChampEC,1,"."),indFenêtre}..Plan))...
_OU_ ({s_ChampEC,indChamp}..Etat <> Actif) _OU_ ({s_ChampEC,indChamp}..Visible = Faux) ALORS s_ChampEC = ""
SINON
SI s_ChampEC = "" ALORS CONTINUER
ta_ChampParKey[Val(s_ChampOuKeyCode)] = s_ChampEC
FIN
FIN
// Touche non interceptée, on laisse l'OS gérer.
SI ta_ChampParKey[n_KeyCode] = "" ALORS RENVOYER Faux

//Touche interceptée, on execute le traitement clic sur le champs associé
//(on l'execute dans un thread car l'appel de appelProcedureWL_boolean ne peut pas être bloquant, cela evite un crash lorsque le bouton ouvre une fenêtre)
TâcheParallèleExécute(pg_TraitementClic,(ta_ChampParKey[n_KeyCode]))
RENVOYER Vrai
<FIN>


4: La procédure d'appel avec un petit jeu de thread pour passer outre quelques problèmes de windev
Procedure pg_TraitementClic(s_Nomchamp)
//Le listener appelle cette fonction depuis un thread secondaire afin qu'il ne soit pas bloqué
//Le thread secondaire rapelle alors cette fonction depuis le thread principal (une le code du listener terminé) afin de pouvoir modifier l'UI
SI ThreadCourant() = "" ALORS
ExécuteTraitement({s_Nomchamp,indChamp},trtClic)
SINON
Multitâche(10)
ExécuteThreadPrincipal(pg_TraitementClic,s_Nomchamp)
FIN


Fly away..
Posté le 28 octobre 2022 - 13:00
Bonjour,

J'ai une petite question cette méthode : Android_HookClavier_OnKey est bien créée dans windev mobile, pas dans le .jar ?

Si je copie/colle cette méthode dans windev mobile 27, j'ai un avertissement : "type du paramètre non valide".
Et Gradle n'accepte pas la syntaxe :

error: <identifier> expected
PUBLIC static void Android_HookClavier_OnKey(string sNomChamp,final string sChampKeyCode)
^
error: <identifier> expected
@Override PUBLIC boolean onKey(View v, int keyCode, KeyEvent Event)
^
error: ';' expected
IF (Event.getAction() == KeyEvent.ACTION_DOWN) {
^


Merci
Membre enregistré
794 messages
Popularité : +40 (42 votes)
Posté le 28 octobre 2022 - 15:55
Bonjour, les commandes du code Java sont toujours en minuscules et sans symboles de ponctuation. C'est une erreur dans le code collé.

Rubén