Discussion :

[PetitBoutDeCode]

Bonjour,

J'ai récemment eu un retour concernant mon application mobile car un appareil n'est pas compatible, j'ai pu identifier le problème dans le catalogue d'appareils de Google Play Console :


Configuration actuelle du téléphone :


J'aimerais donc savoir si il y a un moyen de rendre compatible mon application avec plus d'appareils, du genre modifier le fichier Manifeste ou quelque chose dans le style

[ShaiLeTroll]

Je ne fais pas de FMX, mais cela semble évident dès que l'on fait une recherche

armeabi-v7a c'est du 32 bits
arm64-v8a c'est du 64 bits
Sur le net, on constate que la A10 malgré des CPU 64Bits semble fonctionner en mode 32bits forcé ... étrange, est-ce pour le lowcost ?
Exynos 7884B qui est le modèle d'instruction ARMv7 probablement ce qui est étrange pour un téléphone de 2019 mais c'est ce qui ressort sur le forum android même si il y a des infos contradictoire pour du ARMv8-A

Quand tu choisis la plateforme de compilation, vérifie que tes chemins 32bits de android-ndk les libs armeabi-v7a

[PetitBoutDeCode]

C'est bien ce que j'ai lu aussi, mais en parcourant les forums je suis tombé sur des solutions bizarres et qui n'était pas vraiment pour Delphi.

La solution était bien de changer un fichier dans le déploiement :



J'avais peur que ça ne soit pas comme Windows et que la version 64b ne serait pas compatible, mais finalement après quelques tests tout reste ok, et Google m'annonce que mon application est compatible avec 6500 appareils de plus

Oui ce qui m'a perturbé aussi c'est qu'en regardant la fiche produit de ce téléphone il disait qu'il est en 64b, décidément avoir des infos fiables sur internet est assez compliqué parfois ...

Un grand merci, sujet résolu !

[PetitBoutDeCode]

Autant pour moi,
J'ai réussi à faire accepter la version de l'application à google, mais sur l'appareil cible l'appli crash au démarrage... Je vais essayer de trouver un vieux téléphone en 32bits pour mes tests, il y a surement d'autres librairies que je dois prendre en compte je vais creuser

[ShaiLeTroll]

Faudrait surtout compiler en 32Bits et pas altérer la release 64Bits qui ne fonctionnera plus.

[PetitBoutDeCode]

Quand on compile en 32bits on obtient un fichier APK et Google veut un fichier .aab.

Mais effectivement, bidouiller comme je l'ai fait n'était pas la démarche à suivre, j'ai trouvé la réponse dans une discussion qui n'avait rien à voir

[pprem]

la plupart des smartphones ont des processeurs 64 bits, mais il existe encore quelques versions 32 bits d'Android installées dessus, du coup il est vraiment important d'activer le mode 32/64 quand on fait du déploiement 64 bits AAB pour que Google Play propose le programme aux deux types d'appareils

et idéalement il faut aussi tester la version 32 bits sur les notes, histoire d'être certains qu'il n'y a pas de couacs (même si 32/64 c'est "juste" une histoire de compilation dans la plupart des cas)

[PetitBoutDeCode]

Oui c'est ce que j'ai fini par comprendre à force de faire des tests, je trouve juste dommage que ça ne soit pas activé par défaut, je veux dire, pour les têtes en l'air comme moi, quand on y réfléchi être compatible avec le maximum d'appareils est souvent prioritaire pour obtenir un maximum d'utilisateurs.

En revanche j'ai un dernier point que je ne comprend pas, après promis j'arrête avec ce sujet, quand l'application démarre je fait un test pour vérifier si une nouvelle version d'application est disponible, si c'est le cas, je redirige vers le Play store pour mettre à jour, mais depuis que j'ai rendu ajouter l'option 32/64bits, il me demande systématiquement de mettre à jour, comme si '1.6.8' <> '1.6.8'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  if Donnees.Data.Query1.FindFirst then
    if Donnees.Data.Query1.FieldByName('version').AsString <> LVersion.Text then
{$IF DEFINED(ANDROID)}
      Reply := 0;
  TDialogService.MessageDialog('Nouvelle version disponible, la télécharger ?',
    TMsgDlgType.mtConfirmation, [TMsgDlgBtn.mbYes, TMsgDlgBtn.mbNo],
    TMsgDlgBtn.mbYes, 0,
    procedure(const AResult: TModalResult)
    begin
      Reply := AResult;
      if Reply = mrYes then
        tUrlOpen.Open
          ('https://play.google.com/store/apps/details?id=com.monApp&gl=FR');
    end);
{$ELSE}

[ShaiLeTroll]

il n'y a pas un problème avec un espace qui traine ?


Sans parler de '1.6.8' <> '1.6.8'
La comparaison en chaine d'une version ne fonctionne pas vraiment exemple '1.6.10' est inférieur à '1.6.9' en chaine ce qui faux pour la comparaison de version, depuis longtemps j'ai écrit une fonction CompareVersion (attention elle est Win32/64 donc l'histoire des chaines en base 0, ça gère pas)

J'ai depuis réduit la fonction en

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
{* -----------------------------------------------------------------------------
la fonction CompareVersion compare deux versions selon un critère purement numérique
@param V1 Version à comparer
@param V2 Version à comparer
@return Comparaison V1 - V2, donc > 1 si V1 > V2, 0 si V1 = V2 et < -1 si V1 < V2
------------------------------------------------------------------------------ }
function CompareVersion(const V1, V2: string): Integer;
var
  AV1, AV2: System.Types.TStringDynArray;
  iav, iV1, iV2: Integer;
begin
  try
    // On considère que 1.0 = 1.0.0.0 par exemple
    Explode(V1, AV1, '.');
    Explode(V2, AV2, '.');
    if Length(AV1) > Length(AV2) then
      SetLength(AV2, Length(AV1))
    else
      if Length(AV2) > Length(AV1) then
        SetLength(AV1, Length(AV2));
 
    for iav := Low(AV1) to High(AV1) do
    begin
      if not TryStrToInt(AV1[iav], iV1) then Abort;
      if not TryStrToInt(AV2[iav], iV2) then Abort;
      Result := iV1 - iV2;
      if Result <> 0 then
        Exit;
    end;
    Result := 0;
  except
    Result := 0;
  end;
end;

Je n'ai rien pigé sur les chaines à base Zéro, un jour faudra que je me penche dessus pour savoir si on doit réécrire toutes les fonctions de manipulation de chaine

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
{* -----------------------------------------------------------------------------
la fonction Explode retourne un tableau de chaînes. Ce sont les sous-chaînes, extraites de S, en utilisant le séparateur Separator. cela peut servir pour lire du CSV
@param S Chaine à découper
@param A Tableau de Chaine qui recevra la découpe
@param Separators Caractères qui délimitent une chaine pour la découpe
@param ExcludeEmpty Si True, les Chaines vides ne sont pas insérés dans le Tableau
@param Quotes Caractères qui délimitent une chaine pour la découpe contenant des Separators, n'importe quel séparateur peut commencer et terminé une chaine, une quote doublée est considéré comme valeur un quote dans la chaine
@param KeepSeparators Si True, A contient les chaines et les séparateurs mais pas les Quotes, sinon (par défaut) A ne contient que les Chaines.
@param KeepTextAfterQuote Si True, le Texte entre une quote terminale d'un texte et un séparateur est conservée, la Quote comprise, sinon (par défaut) le Texte entre une quote terminale d'un texte et un séparateur est ignorées
@return Nombre de Séparateur Trouvé (peut-être différent du nombre de chaine dans A !)
------------------------------------------------------------------------------ }
function Explode(const S: string; out A: System.Types.TStringDynArray; const Separators: string; ExcludeEmpty: Boolean = False; const Quotes: string = ''; KeepSeparators: Boolean = False; KeepTextAfterQuote: Boolean = False): Integer;
var
  iLesSep: Integer;
  iLesQuote: Integer;
 
  function IsSeparator(C: Char): Integer;
  begin
    for Result := 1 to iLesSep do
      if C = Separators[Result] then
        Exit;
 
    Result := -1;
  end;
 
  function IsQuote(C: Char): Integer;
  begin
    for Result := 1 to iLesQuote do
      if C = Quotes[Result] then
        Exit;
 
    Result := -1;
  end;
 
var
  iStr: Integer;
  iQuote: Integer;
  iLenS: Integer;
  iLenSS: Integer;
  iLenA: Integer;
  iAdded: Integer;
  iBegin: Integer;
  Quoted: Boolean;
  DoubleQuoted: Boolean;
  AlreadyDQ: Boolean;
  QuoteConcat: string;
  iOffQuote: Integer;
  LastIsSep: Boolean;
  LastIsQ: Boolean;
  ContinueToNextSeparator: Boolean;
begin
  iLenS := Length(S);
  iLesSep := Length(Separators);
 
  if (iLenS = 0) or (iLesSep = 0) then
  begin
    SetLength(A, 1);
    Result := 0;
    A[Result] := '';
    Exit;
  end;
 
  iLesQuote := Length(Quotes);
  for iQuote := 1 to iLesQuote do
    if IsSeparator(Quotes[iQuote]) > 0 then
      raise EExplodeParserError.CreateFmt(ERR_DELIM_CANT_BE_SEPARATOR_FMT, [Quotes[iQuote]]);
 
  // Cette technique de double balayage était optimale sous D4 à D7 où les réallocations étaient très couteuses en temps.
  // Avec l'intégration de FastMM depuis 2007, cela n'est plus utile et dans certains cas ralenti le traitement.
  // Dans cette variante, cela contrôle aussi le nombre de délimiteurs, cela dépasse le simple but d'optimisation,
  // il est nécessaire de conserver cette première analyse des délimiteurs et séparateurs.
  Result := 0;
  iQuote := 0;
  for iStr := 1 to Length(S) do
  begin
    if IsSeparator(S[iStr]) > 0 then
      Inc(Result)
    else
      if IsQuote(S[iStr]) > 0 then
        Inc(iQuote);
  end;
 
  if Odd(iQuote) then
    raise EExplodeParserError.CreateFmt(ERR_BAD_DELIM_COUNT_FMT, [iQuote]);
 
  LastIsSep := IsSeparator(S[iLenS]) > 0;
  LastIsQ := IsQuote(S[iLenS]) > 0;
 
  if KeepSeparators then
    iLenA := Result * 2 + 1
  else
    iLenA := Result + 1;
  SetLength(A, iLenA);
  iLenSS := 0;
  iAdded := 0;
  Quoted := False;
  iOffQuote := 0;
  QuoteConcat := '';
  AlreadyDQ := False;
  iBegin := 1;
  if IsSeparator(S[1]) > 0 then
  begin
    if KeepSeparators then
    begin
      iBegin := 2;
      A[iAdded] := S[1];
      Inc(iAdded);
    end;
  end;
 
  ContinueToNextSeparator := False;
  for iStr := iBegin to iLenS do
  begin
    if ContinueToNextSeparator and (IsSeparator(S[iStr]) <= 0) then
      Continue;
    ContinueToNextSeparator := False;
 
    if not Quoted and (IsSeparator(S[iStr]) > 0) then
    begin
      if ExcludeEmpty and (iLenSS = 0) then
      begin
        if KeepSeparators then
        begin
          A[iAdded] := S[iStr];
          Inc(iAdded);
        end;
        iBegin := iStr + 1;
      end else
      begin
        if AlreadyDQ then
          A[iAdded] := QuoteConcat
        else
          A[iAdded] := Copy(S, iBegin, iLenSS);
 
        AlreadyDQ := False;
        Inc(iAdded);
 
        if KeepSeparators and (iBegin > 0) then
        begin
          A[iAdded] := S[iStr];
          Inc(iAdded);
        end else
          begin
          if LastIsSep and KeepSeparators and (iStr = iLenS) then
          begin
            A[iAdded] := S[iStr];
            Inc(iAdded);
          end;
        end;
        iBegin := iStr + 1;
        iLenSS := 0;
      end;
    end else
    begin
      if IsQuote(S[iStr]) > 0 then
      begin
        if Quoted then
        begin
          Quoted := False;
          if iStr < iLenS then
          begin
            DoubleQuoted := IsQuote(S[iStr+1]) > 0;
            if not KeepTextAfterQuote and not DoubleQuoted and (IsSeparator(S[iStr+1]) <= 0) then
            begin
              ContinueToNextSeparator := True;
              iQuote := iStr;
            end;
            if AlreadyDQ then
              QuoteConcat := QuoteConcat + Copy(S, iBegin, iLenSS) + IfThen(DoubleQuoted, S[iStr+1], '')
            else
              QuoteConcat := Copy(S, iBegin, iLenSS) + IfThen(DoubleQuoted, S[iStr+1], '');
            AlreadyDQ := AlreadyDQ or DoubleQuoted;
          end;
        end else
        begin
          Quoted := True;
          iBegin := iStr + 1;
          iLenSS := 0;
        end;
      end else
      begin
        if Quoted and (IsSeparator(S[iStr]) > 0) then
          Inc(iOffQuote);
        Inc(iLenSS);
      end;
    end;
  end;
 
  if iBegin <= iLenS then
  begin
    if ContinueToNextSeparator then
      A[iAdded] := Copy(S, iBegin, iQuote - iBegin)
    else
      if LastIsQ then
        A[iAdded] := Copy(S, iBegin, iLenS - iBegin)
      else
        A[iAdded] := Copy(S, iBegin, MaxInt);
    Inc(iAdded);
 
    if LastIsSep and KeepSeparators then
    begin
      A[iAdded] := S[iLenS];
      Inc(iAdded);
    end;
  end;
 
  if LastIsSep and not ExcludeEmpty then
    Inc(iAdded);
 
  if iAdded < iLenA then
    A := Copy(A, 0, iAdded);
 
  Result := Result - iOffQuote;
end;

[SergioMaster]

Cela dépend peut-être du SGBD, j'ai eu des surprises avec SQLite et les strings

je suggère

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 if not sametext(Donnees.Data.Query1.FieldByName('version').AsString.trim,LVersion.text.trim) then 
..

mais je ne testerai pas sur un Lversion.Text qui doit être initialisé quelque-part et peut-être plus tard

[PetitBoutDeCode]

J'ai déjà lu cette discussion quand j'ai instauré ce système de version, le truc c'est que je trouve que ça alourdi pas mal le code que j'essaie de garder le plus clair et le plus simple possible.
Du coup j'ai préféré utiliser la comparaison de chaine de caractère, étant donné que dans le Play store je ne peux que publier des versions supérieurs, si celle que je trouve est différente, c'est qu'il y en a une plus récente.

Je récupère le numéro de version comme ça (la méthode Windows est la uniquement parce que je voulais faire une fonction qui englobe les trois OS) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
function GetAppVersion: String;
{$IF Defined(IOS) }
Var
  NSB: NSBundle;
  NSDic: NSDictionary;
  NS: NSString;
Begin
  Try
    NSB := TNSBundle.Wrap(TNSBundle.OCClass.MainBundle) ;
    NSDic := NSB.InfoDictionary;
    NS := TNSString.Wrap(NSDic.ValueForKey(NSStr('CFBundleVersion'))) ;
    Result := Format('%s', [NS.UTF8String]);
    NS.release;
    NSB.release;
 
    NS := Nil;
    NSB := Nil;
  Except
    On E: Exception Do
      Data.envoi_mail_erreur('App version IOS', E.Message);
  End;
End;
{$ENDIF}
{$IFDEF ANDROID}
 
Var
  PackageManager: JPackageManager;
  PackageInfo: JPackageInfo;
Begin
  PackageManager := SharedActivityContext.getPackageManager;
  PackageInfo := PackageManager.getPackageInfo
    (SharedActivityContext.getPackageName, 0);
  Result := JStringToString(PackageInfo.versionName);
End;
{$ENDIF}
{$IF defined(MSWINDOWS)}
 
Var
  a, b, c: Cardinal;
begin
 
  GetProductVersion(Application.ExeName, a, b, c);
  Result := IntToStr(a) + '.' + IntToStr(b) + '.' + IntToStr(c);
end;
{$ENDIF}

Quand j'initialise mon module de données je met la version dans une variable globale (GB_APP_VERSION := Trim(GetAppVersion()); )

Puis je l'attribue a mon label quand je crée ma page (LVersion.Text := GB_APP_VERSION; )

C'est du MySQL et j'ai vérifié il n'y a aucun espace .

Si je lance en Debug sur ma tablette, je n'ai pas le message, le message apparait uniquement depuis l'application sur le store, et j'ai ce bug uniquement depuis que j'ai ajouté la compilation en 32bits pour la compatibilité...

C'est possible que les chaines de caractères soient traitées différemment en compilant en 32bits et que le fieldbyname('version').AsString ne soit pas lu comme un label.Text ?

[ShaiLeTroll]

Je ne sais pas sur Android mais sur Windows, le numéro de version inclu dans l'Exe peut-être différent selon 32/64 et selon Debug/Release dans les différentes configurations.
Vérifie ton DPROJ qu'il ne contient pas des valeurs parasites <VerInfo_***>

[pprem]

merci d'utiliser mes bouts de codes, content que ça serve un peu

concernant la version, il y a le numéro "humain" qu'on gère comme on veut et le numéro de bundle demandé par les magasins d'application.

assure toi que ce numéro (un nombre unique) soit bien incrémenté avec chaque package car des fois ce n'est pas le cas selon ce qu'on bidouille, et du coup le store refuse le fichier AAB avec un message pas clair du tout "vous ne pouvez pas déployer cette release car elle ne permet à aucun utilisateur d'effectuer une mise à jour vers les app bundles ajoutés" ou un autre tout aussi nébuleux

[PetitBoutDeCode]

merci d'utiliser mes bouts de codes, content que ça serve un peu

Je n'aime pas trop utiliser du code tout fait, mais c'est vraiment pratique d'avoir réuni les méthodes que l'on trouve à droite à gauche pour chaque OS, c'est un peu ce que j'ai fait pour ma méthode GetAppVersion, elle vient de 3 forums réunis

J'ai abandonné hier soir à force de regarder ce bout de code je ne le comprenais même plus, et la nuit m'a porté conseil!

Comme a mon habitude j'ai cherché compliqué alors que la réponse était toute bête...............

En fait quand j'ai pris Le {$IF DEFINED (ANDROID)} pour un Begin!

Du coup que la version soit différente ou non, ça n'affecte que l'initialisation de la variable Reply......

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  if Donnees.Data.Query1.FindFirst then
    if Donnees.Data.Query1.FieldByName('version').AsString <> LVersion.Text then
{$IF DEFINED(ANDROID)}
    BEGIN
    Reply := 0;
    TDialogService.MessageDialog('Nouvelle version disponible, la télécharger ?',
    TMsgDlgType.mtConfirmation, [TMsgDlgBtn.mbYes, TMsgDlgBtn.mbNo],
    TMsgDlgBtn.mbYes, 0,
    procedure(const AResult: TModalResult)
    begin
      Reply := AResult;
      if Reply = mrYes then
        tUrlOpen.Open
          ('https://play.google.com/store/apps/details?id=com.monApp&gl=FR');
    end);
   END;
{$ELSE}

Désolé de vous avoir fait perdre votre temps pour une erreur d'inattention

[pprem]

Je n'ai rien pigé sur les chaines à base Zéro, un jour faudra que je me penche dessus pour savoir si on doit réécrire toutes les fonctions de manipulation de chaine

En fait c'est assez simple (ou pas tant que ça)...

Avant la 10.4 Sydney, sous Windows (et si je ne me goure pas Mac+Linux), les chaînes sont des 1-based. Sur iOS+Android c'est du 0-based. C'était "transparent" si on n'assume nulle part en dur le numéro du premier caractère genre machaine[1] sur mobile était une mauvaise idée...

Depuis la 10.4 Sydney :
- les fonctions historiques (StrUtils & co) gèrent des chaînes en partant du principe que le premier caractère est le numéro 1
- les helpers gèrent les chaînes en considérant que le 1er caractère est le numéro 0

Physiquement les string restent des string. On peut mélanger "anciennes" fonctions de manipulation de chaînes et les helpers mais il est fortement recommandé de ne pas jouer avec le feu et en rester à une utilisation et surtout pas faire un mélange en utilisant les mêmes variables dessus. Perso j'ai choisi les helpers, plus pratiques et surtout plus évolutifs.

Si on veut retrouver le comportement "aléatoire" d'avant la 10.4 Sydney, il faut activer $ZEROBASEDSTRINGS dans les unités dans lesquelles on veut du 0-based sur mobiles aussi dans les anciennes procédures et fonctions.