#import <Foundation/Foundation.h>

@interface restRequest : NSObject <NSURLConnectionDelegate, NSURLConnectionDataDelegate> {
SEL callback; // Selecteur vers la fonction de retour
id delegate; // objet cible pour l'appel de la fonction de retour
int status; // code HTTP
bool done; // true si la requête est terminée

NSMutableString *method;
NSMutableString *url;
NSMutableString *payload;

NSMutableURLRequest *request;
NSURLConnection *connection;
NSMutableData *dta;
NSMutableString *result;
}

@property (nonatomic,retain) NSMutableData *dta;

@property (nonatomic,retain) NSMutableString *method;
@property (nonatomic,retain) NSMutableString *url;
@property (nonatomic,retain) NSMutableString *payload;

@property (nonatomic,retain) NSMutableURLRequest *request;
@property (nonatomic,retain) NSURLConnection *connection;

@property (nonatomic) SEL callback;
@property (nonatomic,assign) id delegate;

@property (nonatomic) int status;
@property (nonatomic) bool done;
@property (nonatomic,retain) NSMutableString *result;

-(id)initWithCallback:(SEL)cal andDelegate:(id)dl;
-(void)start;
-(void)cancel;
@end

#import "restRequest.h"

@implementation restRequest

@synthesize callback;
@synthesize delegate;

@synthesize url;
@synthesize method;
@synthesize payload;

@synthesize connection;
@synthesize request;
@synthesize dta;
@synthesize status;
@synthesize result;
@synthesize done;

-(id)initWithCallback:(SEL)cal andDelegate:(id)dl {

    self = [super init];
    if(self) {
        callback = cal; // Selecteur vers la fonction de retour
        delegate = [dl retain]; // objet cible de la fonction de retour
        status = -1; // code de retour HTTP
        done = FALSE; // indique si la requête est terminée

        dta = [[NSMutableData alloc] init]; // buffer
        url = [[NSMutableString alloc] init]; // url appelée
        method = [[NSMutableString alloc] initWithString:@"GET"]; // méthode HTTP : GET / POST / PUT, ...
        payload = [[NSMutableString alloc] init]; // contenu de la requete (Body)

        result = [[NSMutableString alloc] init]; // résultat de la requête
    }

    return self;

}
-(void)dealloc {

    [self cancel];

    done = TRUE;

    delegate = nil;
    callback = nil;

    [dta release];
    [url release];
    [method release];
    [payload release];
    [result release];

    if(request){
        [request release];
        request = nil;
    }

    [super dealloc];
}
-(void)start {

    status = 0;

    [dta setLength:0];

        [result setString:@""];
        NSString *full = [NSString stringWithFormat:@"http://%@/%@",@"http://www.url-de-base.com/",url];
        NSURL *myurl = [NSURL URLWithString:full];

        if(request){
            [request release];
            request = nil;
        }

        request = [[NSMutableURLRequest alloc] initWithURL:myurl];
        [request setHTTPMethod:method];
        if([payload length] > 0) [request setHTTPBody:[payload dataUsingEncoding:NSUTF8StringEncoding]];
        //[request setValue:@"application/xml" forHTTPHeaderField:@"Content-Type"]; // spécifie le format du contenu de la requête
        [request setTimeoutInterval:10];

        connection = [NSURLConnection connectionWithRequest:request delegate:self];
      [connection start];

}
-(void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data {
    [dta appendData:data];
}
-(void)connection:(NSURLConnection *)sconnection didFailWithError:(NSError *)error {
    NSLog(@"Error restRequest %@",[error localizedDescription]);
    [dta setLength:0];

    status = -2;

    if(delegate && [delegate respondsToSelector:callback]) [delegate performSelector:callback withObject:self];

    connection = nil;
    delegate = nil;
    callback = nil;

    done = TRUE;
}
-(void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response {
    if([response respondsToSelector:@selector(statusCode)]){
        status = [(NSURLResponseInternal *)response statusCode];
    }
}
-(void)connectionDidFinishLoading:(NSURLConnection *)sconnection {

    NSMutableString *res = [[NSMutableString alloc] initWithData:dta encoding:NSUTF8StringEncoding];
    [result setString:res];

    if(delegate && [delegate respondsToSelector:callback]){
        [delegate performSelector:callback withObject:self];
        [delegate release];
    }

    connection = nil;
    delegate = nil;
    callback = nil;
    done = TRUE;

    [res release];
}
-(void)cancel {
    if(connection){
        [connection cancel];
        connection = nil;
    }

    if(request){
        [request release];
        request = nil;
    }

    delegate = nil;
    callback = nil;
    done = TRUE;
}

@end

-(void)start_request {

    restRequest *rest = [[restRequest alloc] initWithCallback:@selector(register_response:) andDelegate:self];

    [[(restRequest *)rest url] setString:@"appel/fonction.php"];
    [[(restRequest *)rest method] setString:@"PUT"];
    [[(restRequest *)rest payload] setString:@"contenu xml, json, ..."];

    [(restRequest *)rest start];

}
-(void)register_response:(restRequest *)res {

    if (res.status == 204) {
        // success
        NSString *resultat = res.result;
    }
    else if(res.status == 404){
        // document introuvable ...
    }
    else if(res.status == 500){
        // erreur interne
    }
    else if(res.status == -2){
        // impossible d'établir la connection, probablement un problème de réseau
    }

}

Fonctionnement d’une application mobile : les différentes possibilités

avril 5th, 2011    Posted in Développement

Une petite longue note explicative sur les différents modes de fonctionnement des applications mobiles telles que nous les concevons.

Les applications connectées

Ce type d’appli se comporte globalement comme votre navigateur Internet. A chaque opération ou accès de données, les informations sont lues sur Internet

Nos apps repose en général sur ces éléments :

- L’application en elle même, codée en Objective C sur iPhone, JAVA pour Android et Blackberry
- Un Serveur Web type Apache/PHP
- Un serveur de base de données (pour nous MySQL)

La lecture des données se fait de manière suivante :

Une fois lancée, l’application se connecte au serveur web et vient télécharger un fichier, en général au format XML (RSS ou WebServices).
Ce flux est généré en temps réel par un script écrit en PHP, qui interprète la demande (et les paramètres GET et POST) et interroge la base de données en fonction.

Reste à l’appli à interpréter ces données (libxml2 fait le travail) et de le placer dans l’interface !

En utilisant cette technique, les différentes versions de vos applis (iPhone, Android, …)
viennent toutes se connecter à la même source de données, et simplifient la maintenance et les mises à jours.

Il est aussi possible de connecter la base de données existante de votre site web, les données sur votre iPhone ou sur un navigateur classique sont donc toujours identiques.

Avantages :

- Une synchronisation parfaite entre toutes vos supports pour votre service.
- Possibilité de donner des infos en temps réels
- Facilité de mise à jour du contenu (couplé avec un BackOffice par exemple)
- Application légère et rapide à télécharger sur le Store
- Le serveur peut effectuer certains traitements lourds un peu délicat à réaliser sur un téléphone qui tourne sur batterie et avec une puissance de calcul limitée (traitement d’image ou de vidéo par exemple)
- Toutes les possibilités du téléphone sont exploitables (GPS, Push …)

Inconvénients :

- La connexion Internet est indispensable
- Pour peu que l’on fasse transiter beaucoup de données (grande photos, vidéo) la couverture en 3G est obligatoire (15 Min de vidéo au fin fond du Berry, oubliez tout de suite)
- Plein de petits chargements qui peuvent être gênants à la longue.

Ce type d’application est parfait pour des services connectés à un site web, pour l’utilisation de réseau sociaux, ou généralement quand les informations doivent être obtenus rapidement.

Exemples : Dépanne Moi, Astuces FB, b2pweb …

Les applications embarquées

Pour ce type d’application, toutes les fonctions, données média sont embarquées dans le téléphone ou la tablette.
Un seul élément dans ce cas de figure : le téléphone avec son logiciel embarqué.

Le téléphone lit tous les fichiers qu’il lui faut directement dans la mémoire de stockage du téléphone, ou dans une base de données embarquées (SQLite3 est très efficace dans ce cas de figure)
sur le même modèle qu’un ordinateur qui ouvre un fichier.

Avantages :

- L’appli est toujours disponible, que l’on soit en plein Paris ou au beau milieu de la pampa.
- L’accès aux données est très rapide, d’autant plus que les téléphones disposent d’une mémoire de type SSD, avec des débit de lecture assez élevés.
- Les fonctions radio du téléphone ne sont pas sollicitées, la batterie perd donc la charge moins vite.
- Lors du téléchargement de l’appli, tout son contenu est immédiatement disponible.

Inconvénients :

- La moindre correction orthographique demande une mise à jour de l’appli. Quand on sait que cela peut prendre plusieurs jours avec Apple, mieux vaut bien tout valider à chaque étape
- L’application peut vite devenir extrêmement lourde. Au delà de 20 Mo (pour l’iPhone en tout cas), une connexion Wifi est exigée par Apple.
- Pas de réactivité du contenu
- L’utilisation de Google Maps, du GPS, des notifications devient plus problématique

En résumé ce type d’appli est adapté pour des utilitaires avec une fonction bien précise, pas vraiment voués à évoluer dans le temps par leur contenu.

Exemples : Tecknodent, Planet Solaire

Les applications synchronisables

Il s’agit d’une version hybride des deux autres modèles. Elles reposent à la fois :

- Sur un serveur web/php alimenté par une base SQL
- le système de stockage Interne du téléphone
- L’application en elle même

L’application en utilisation simple vient lire les données sur son disque de stockage, ou sa base de données interne, mais dispose d’une fonction qui permet de synchroniser son contenu.

En détail cela fonctionne de cette manière :

- L’appli vérifie sa connectivité
- Une requête avec la date de dernière mise à jour est envoyée vers le serveur
- Le serveur répond par une liste de données à récupérer (URL de fichiers média, requêtes SQL pour synchro avec la base SQLite, …). Toute cette liste est envoyée via un flux XML
- L’application va alors télécharger toutes les infos de manière séquentielles (via HTTP ou FTP), ou exécuter les requêtes SQL. Il est aussi possible, pour des petits fichiers, de les stocker en base de données sous forme de BLOB binaires.
- Une fois toute la séquence terminée, on recharge l’interface.

Avantages :

- Un bon compromis entre la disponibilité et la flexibilité du contenu
- La radio du téléphone n’est sollicité que lors des mises à jour
- Application légère à télécharger
- Seules les nouvelles informations sont téléchargées (ou celles mises à jours évidemment), les autres sont stockées dans le téléphone

Inconvénients :

- Les données peuvent ne plus être valables si l’on oublie de faire la mise à jour
- Lors du premier lancement, cela implique de télécharger tout le contenu. Même en Wifi, cela peut prendre du temps dans certain cas.

Exemple : CNRI, iAstreinte, Concorde Hotels & Resorts

Ce type d’appli se prêtent bien aux applications métier, ou à usage professionnel, quand la fiabilité est importante, tout en gardant la possibilité d’échanger des informations rapidement.

Il est évidemment possible d’utiliser un mélange de ces techniques en fonctions des services proposés par l’application, ou de passer en mode « dégradé » si la connexion Internet n’est pas disponible.

Des questions sur la faisabilité technique de votre projet d’appli ? Contactez nous au 01.75.43.03.82 pour en discuter