Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Un développeur parvient à faire fonctionner du code Swift sur Android
En attendant la sortie de Swift sous licence open source

Le , par Olivier Famien

50PARTAGES

4  0 
Depuis la sortie de Swift, le nouveau langage de développement d’Apple, nombreux sont ceux qui ont tourné le dos à Objective-C. Étant considéré comme le successeur de ce dernier, Swift a gravi les échelons dans les classements et fait l’objet d’apprentissage de la part de nombreux développeurs.

Aussi, pour ouvrir son langage à plus de contributeurs, Apple a annoncé à la dernière conférence WWDC 2015 que Swift allait passer au format open source d’ici la fin de l’année. Communiqué qui a renforcé l’attrait des développeurs vers ce langage considéré par Apple comme le prochain grand langage de programmation qui servira à créer des applications et faire la programmation système pendant les 20 années à venir.

En attendant la sortie de Swift sous licence open source, un développeur s’est lancé dans un exercice assez intéressant et est parvenu à faire tourner du code Swift sur Android. Pour y arriver, ce dernier a été aidé par les caractéristiques intrinsèques de Swift.

Il faut rappeler que Swift a été construit afin d’être compatible avec l’environnement de développement intégré (EDI) Xcode. Dans cet EDI, le compilateur utilisé est la machine virtuelle de bas niveau LLVM (Low Level Virtual Machine). Une des particularités de ce compilateur est qu’il permet de créer un générateur de code pour plusieurs types d’architectures et des optimiseurs de compilation indépendants de la plate-forme sur laquelle et de tout langage.

Ainsi donc, au lieu de générer du code ciblant une architecture spécifique, LLVM génère d’abord du code assembleur, puis convertit ce dernier afin qu’il soit utilisé sur l’architecture souhaitée. En profitant de cette caractéristique modulaire, le développeur est parvenu à réutiliser le code binaire généré avec Swift afin de l’utiliser sur Android. Pour ce faire, il est passé par les différentes étapes suivantes :

Code du fichier Hello World
Code : Sélectionner tout
1
2
// hello.swift
print("Hello, world!");
Instruction pour compiler le fichier Hello World
Code : Sélectionner tout
$ $SDK/usr/bin/swiftc -emit-object hello.swift
Contenu du fichier objet compilé hello.o
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ nm hello_swift.o
                 U __TFSSCfMSSFT21_builtinStringLiteralBp8byteSizeBw7isASCIIBi1__SS
                 U __TFSs27_allocateUninitializedArrayurFBwTGSaq__Bp_
                 U __TFSs5printFTGSaP__9separatorSS10terminatorSS_T_
                 U __TIFSs5printFTGSaP__9separatorSS10terminatorSS_T_A0_
                 U __TIFSs5printFTGSaP__9separatorSS10terminatorSS_T_A1_
0000000000000140 S __TMLP_
0000000000000100 S __TMaP_
                 U __TMdSS
                 U __TZvOSs7Process11_unsafeArgvGVSs20UnsafeMutablePointerGS0_VSs4Int8__
                 U __TZvOSs7Process5_argcVSs5Int32
                 U _globalinit_33_1BDF70FFC18749BAB495A73B459ED2F0_func6
                 U _globalinit_33_1BDF70FFC18749BAB495A73B459ED2F0_token6
0000000000000000 T _main
                 U _swift_getExistentialTypeMetadata
                 U _swift_once
Ensuite, il a fourni le code objet à l’éditeur de liens afin de générer l’exécutable.

Code : Sélectionner tout
1
2
3
4
5
6
$ ld -arch x86_64 -o hello hello.o
     -L$SDK/usr/lib/swift/macosx
     -lSystem -lswiftCore

$ DYLD_LIBRARY_PATH=$SDK/usr/lib/swift/macosx ./hello
Hello, world!
Il faut souligner que lorsque le compilateur Swift effectue la compilation, il génère dans un premier temps une représentation intermédiaire du code Swift, puis traduit cette représentation intermédiaire en code machine x86_64.

En continuant, le développeur a généré un fichier ARM qui est le format binaire utilisé sur Android. Voici le code utilisé pour générer le code binaire.

Code : Sélectionner tout
1
2
3
4
5
6
7
$SDK/usr/bin/swiftc
  -parse-as-library # We don't need a "main" function
  -target armv7-apple-ios9.0
  -emit-ir
  add.swift
  | grep -v "^!" # Filter-out iOS metadata
  > add.ll
À partir du code intermédiaire obtenu, le développeur a généré un fichier objet ARM ELF en s’appuyant sur le compilateur statique dans LLVM. Voici le code exécuté pour obtenir le fichier objet.

Code : Sélectionner tout
1
2
3
4
$NDK/toolchains/llvm-3.5/prebuilt/darwin-x86_64/bin/llc
  -mtriple=armv7-none-linux-androideabi
  -filetype=obj
  add.ll

Enfin, il a créé un package pour être utilisé dans une application Android. Pour cela, il a utilisé le framework Java JNI Bridge et écrit le code en C.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// jni-bridge.c

// Let's work around Swift symbol mangling
#define SWIFT_ADD _TF3add13addTwoNumbersFTVSs5UInt86secondS0__S0_

uint8_t SWIFT_ADD(uint8_t, uint8_t);

jstring jni_bridge(JNIEnv * env, jobject thiz ) {
  uint8_t a = 123;
  uint8_t b = 45;
  uint8_t c = SWIFT_ADD(a,b);

  char result[255];
  sprintf(result, "The result is %d", c);

  return (*env)->NewStringUTF(env, result);
}
Le tout a été regroupé dans une bibliothèque partagée et finalement le fichier objet a été compilé dans une application Android.

Code : Sélectionner tout
1
2
3
4
5
6
$NDK_GCC/bin/arm-linux-androideabi-ld
  add.o
  jni_bridge.o
  -shared # Build a shared library
  -lc # We'll need the libc
  -L$NDK/platforms/android-13/arch-arm/usr/lib
Ci-dessous le résultat final sur Android.


Il est bon de savoir que le code Swift utilisé sur Android ne requiert pas de bibliothèque Swift pour être exécuté, d’où la relative facilité dans sa mise en œuvre. Pour ceux qui souhaitent tirer profit de cette application, l’auteur du projet l’a mise à la disposition du public sur GitHub.

Télécharger la démo de l'application Hello World sur GitHub

Source : Page de présentation du projet

Et vous ?

Que pensez-vous de ce projet ?

Voir aussi

Forum langages de programmation

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de Voïvode
Membre émérite https://www.developpez.com
Le 20/10/2015 à 22:28
Intéressant mais inutile, selon l’avis même de l’auteur :
  • Le processus requiert l’usage du NDK, déconseillé par Google pour créer une application.
  • La bibliothèque principale SwiftCore n’existe pas sous Android.
3  0 
Avatar de Voïvode
Membre émérite https://www.developpez.com
Le 27/10/2015 à 16:06
Désolé d’avoir mis autant de temps à te répondre alors que tu t’es donné la peine de rédiger une réponse intéressante.

Après feuilletage des différentes versions du guide et furetage sur quelques blogs, je n’ai pas remarqué de grands changements dans la syntaxe de Swift. L’exemple que tu montres a tout simplement été réécrit par l’auteur.

En quelques points :
  • L’ancienne version de l’exemple avait une approche uniquement impérative, alors que la nouvelle version a une approche plus fonctionnelle. L’auteur a probablement fait ce choix pour mieux illustrer les possibilités de Swift et être plus en adéquation avec la philosophie du langage.
  • Il y a aussi surement eu un changement dans la bibliothèque de composant graphique UIKit dans iOS 9 qui permet d’utiliser cette approche fonctionnelle, mais cela ne concerne pas Swift à proprement parler.
  • var, let, ? et ! existent depuis le début.
  • La combinaison as? est la seule véritable nouveauté, introduite dans Swift 1.2 (avril 2015), mais ce nouvel élément de syntaxe ne casse rien d’ancien.
2  0 
Avatar de Martin Lestas
Membre éprouvé https://www.developpez.com
Le 21/10/2015 à 22:40
Stylé, mais c'est sûr sa ne sert à rien !
1  0 
Avatar de frayien
Futur Membre du Club https://www.developpez.com
Le 26/11/2015 à 19:51
C'est vrai que le format change beaucoup trop, en ce moment j'essaye d’apprendre le swift mais c'est difficile car quand je cherche une solution a un problème je tombe sur 24 syntaxes différentes... Non pour moi le swift a été sorti AVANT d'être terminé ^^ désolé mais je ne trouve pas normal que quand je fait :
var a: String[4]
le compilateur me dit : "Fixed-length arrays are not yet supported" ... Que ce soit pas possible en swift pourquoi pas mais pas encore supporté non quoi ...
1  0 
Avatar de Voïvode
Membre émérite https://www.developpez.com
Le 21/10/2015 à 13:42
Ce n’est pas moi qui le dit, c’est dans la conclusion de l’auteur.
Citation Envoyé par Romain Goyet
That was fun, but is of course useless:

  • Generally speaking, the NDK makes sense only for a small percentage of apps, so in the general case Google advises against trying to write a whole Android app using the NDK.
  • And of course since we're missing the SwiftCore library this is restricted to a small subset of Swift.

0  0 
Avatar de Mishulyna
Traductrice https://www.developpez.com
Le 23/10/2015 à 23:36
Le problème de Swift c'est que la syntaxe change toutes les six mois, sans aucune préoccupation pour la rétrocompatibilité. J'étais en train de faire la traduction des mises à jour de certains tutoriels Swift, des relecteurs techniques les ont relus, des relecteurs orthographiques les ont corrigés et PAN ! Certainement, encore des "?" remplacés par des "!" ou vice-versa.

Si cela restera ainsi "pendant les 20 années à venir", je plains les développeurs Swift ! Afficher "Hello World!" sur un écran ce n'est pas vraiment la plus poussée des applications.
0  0 
Avatar de Voïvode
Membre émérite https://www.developpez.com
Le 24/10/2015 à 2:00
@Mishulyna
Un exemple en tête ? Je suis curieux de savoir.

Swift m’intéresse, mais un avis éclairé m’intéresse tout autant.
0  0 
Avatar de Mishulyna
Traductrice https://www.developpez.com
Le 24/10/2015 à 12:12
Il me serait impossible de donner un avis "éclairé", car je ne développe pas en Swift. Je peux juste donner deux exemples de code tirés d'un tutoriel, "avant" et "après" une de ces modifications du langage.

2014 :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
func tableView(tableView: UITableView!, didSelectRowAtIndexPath indexPath: NSIndexPath!) {
    // Obtenir les données pour la ligne sélectionnée
    var rowData: NSDictionary = self.tableData[indexPath.row] as NSDictionary
    
    var name: String = rowData["trackName"] as String
    var formattedPrice: String = rowData["formattedPrice"] as String

    var alert: UIAlertView = UIAlertView()
    alert.title = name
    alert.message = formattedPrice
    alert.addButtonWithTitle("Ok")
    alert.show()
}
2015 :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
    // Obtenir les données pour la ligne sélectionnée
    if let rowData = self.tableData[indexPath.row] as? NSDictionary,

        // Obtenir le nom du morceau pour cette ligne
        name = rowData["trackName"] as? String,
        
        // Obtenir le prix de l'item iTunes pour cette ligne
        formattedPrice = rowData["formattedPrice"] as? String {
            let alert = UIAlertController(title: name, message: formattedPrice, preferredStyle: .Alert)
            alert.addAction(UIAlertAction(title: "Ok", style: .Default, handler: nil))
            self.presentViewController(alert, animated: true, completion: nil)
    }
}
Sans y connaître grand-chose, je vois que des points d'exclamations ont disparu et des points interrogation ont été ajoutes. Des mots clé "var" ont disparu, des "let" sont apparus. Et il paraît que des nouveaux changements se sont produits récemment.

Je ne dis pas que Swift n'est pas un langage intéressant et puissant, mais j'ai l'impression qu'on le modifie trop souvent, "pour refléter les changements de Xcode x.x". J'ignore s'il existe beaucoup de langages qui changent suite aux modifications apportées à l'IDE.
0  0 
Avatar de VLDG
Membre éclairé https://www.developpez.com
Le 28/10/2015 à 22:27
Il y a très longtemps que Remobjects utilise Swift sous dotent ou sur la plate-forme android
http://www.elementscompiler.com/elements/
0  0 
Avatar de ddoumeche
Membre extrêmement actif https://www.developpez.com
Le 29/10/2015 à 16:53
Effectivement la syntaxe de Swift fait un peur à voir.
J'imagine que c'est néanmoins un progrès par rapport à Objective-C ?
0  1