BlackBerry Java SDK Version: 7.0 - Guide de mise en route

 
BlackBerry Java SDK Version: 7.0 - Guide de mise en route
BlackBerry Java SDK
Version: 7.0
Guide de mise en route
BlackBerry Java SDK Version: 7.0 - Guide de mise en route
Publié le 2011-10-25
SWD-1641291-1025051221-002
Table des matières
1 Introduction......................................................................................................................................................     3
  Aide pour le développement Java....................................................................................................................                    3

2 Création d'une application réussie...................................................................................................................                  4
  Conception de votre application......................................................................................................................                  5

3 Outils de développement Java..........................................................................................................................                 8
  À propos de BlackBerry Java Plug-in pour Eclipse............................................................................................                           8
  Simulateurs.......................................................................................................................................................     9
  Clés de signature de code.................................................................................................................................             9

4 Création de votre première application...........................................................................................................                      10
  Créer l'application Hello BlackBerry.................................................................................................................                  10
  Exécution de votre application.........................................................................................................................                11
       Exécuter votre application dans un simulateur.........................................................................................                            11
       Exécuter votre application sur un smartphone.........................................................................................                             12
  Plus de didacticiels............................................................................................................................................       13

5 Présentation de Java SDK..................................................................................................................................             14
  API de cycle de vie des applications..................................................................................................................                 14
  API d'interface utilisateur.................................................................................................................................           16
  API d'intégration d'applications........................................................................................................................               19
  API PIM (gestion d'informations personnelles)................................................................................................                          22
  API de messagerie.............................................................................................................................................         23
  API de connexion réseau..................................................................................................................................              25
  Plate-forme CLDC et API d'utilitaires................................................................................................................                  26
  Caractéristiques des terminaux et BlackBerry Infrastructure...........................................................................                                 28
  API de stockage de données.............................................................................................................................                30
  API multimédia.................................................................................................................................................        32
  API de services géodépendants........................................................................................................................                  32
  API de sécurité..................................................................................................................................................      34
  Prise en charge des API Java standard..............................................................................................................                    37

6 Envoi de commentaires....................................................................................................................................              38

7 Glossaire...........................................................................................................................................................   39

8 Historique de révision du document................................................................................................................                     41
9 Informations juridiques....................................................................................................................................   42
Guide de mise en route                                                                                   Introduction

Introduction                                                                                                  1
Bienvenue dans l'univers du développement BlackBerry® Java®. Ce guide vous aide à vous lancer dans la création
d'applications mobiles pour smartphones BlackBerry. Dans ce guide, vous trouverez :
•     Des conseils pour mener à bien la création d'une application.
•     Une présentation des outils requis pour développer des applications Java BlackBerry.
•     Un didacticiel vous montrant comment créer une application simple.
•     Une présentation des composants des API de BlackBerry® Java® SDK.
Ce guide est conçu pour servir de passerelle vers les ressources de développement Java BlackBerry et fournit donc
des liens vers de plus amples informations, disponibles dans les guides de développement BlackBerry Java SDK et
le site BlackBerry Developer Zone.

Aide pour le développement Java
En cas de questions ou de problèmes, RIM fournit des ressources pour vous aider. Les ressources proposées sont
les suivantes.
Sites vous permettant de poser des questions gratuitement :
•     Forum d'assistance pour les développeurs Java
•     Application de suivi de problème pour les développeurs (pour signaler tout problème et consulter les rapports
      de débogage)
•     Développement BlackBerry sur Twitter
•     Communauté de développement BlackBerry sur Facebook
Sites permettant de poser des questions, soumis à tarification :
•     Prise en charge d'incident pour les développeurs
•     Programme d'alliance de BlackBerry
Votre question est peut-être déjà résolue. Voici un aperçu général rapide des ressources de développement de
Java :
•     Guides de développement Java
•     Exemples d'applications Java
•     Référence d'API Java
•     Ressources pour développeurs
•     BlackBerry.com > Zone Développeurs > Page de démarrage Java
•     Blog pour développeurs BlackBerry
•     Base de connaissances pour le développement Java

                                                                                                                   3
Guide de mise en route                                                                  Création d'une application réussie

Création d'une application réussie                                                                                 2
Research In Motion® fournit les solutions suivantes pour vous aider à bien vendre vos applications. Tous ces
services sont fournis gratuitement.
Advertising Service, Payment Service et Analytics Service sont des SDK distincts et par conséquent, ne dépendent
pas de la version de BlackBerry® Java® SDK. Ces services sont conçus pour une intégration facile.
Charger votre application sur App World
BlackBerry App World™ est le portail fourni aux développeurs par RIM pour vendre leurs applications. L'inscription
sur App World est gratuite, tout comme la vente de vos applications. App World est préchargé sur les nouveaux
smartphones BlackBerry. Plus de 90 % des 50 millions d'utilisateurs BlackBerry ont accès à BlackBerry App World.
App World est disponible dans plus de 70 pays et prend en charge 21 monnaies et 6 langues.
Pour plus d'informations, veuillez consulter :
•     Distribution de BlackBerry App World
•     BlackBerry App World storefront developer guides (Boutique BlackBerry App World - Guides développeur)

Placer des publicités dans votre application
Advertising Service comprend un SDK et un portail Web que vous pouvez utiliser pour intégrer des publicités à vos
applications. Le SDK est conçu pour vous permettre d'intégrer des publicités à vos applications sans écrire une
grande quantité de code. Le portail Web vous permet de modifier le contenu publicitaire après publication de
votre application (pour modifier vos réseaux publicitaires par exemple) et de suivre les statistiques à propos de
vos publicités.
Pour plus d'informations, veuillez consulter :
•     Advertising Service
•     Advertising Service developer guides and API reference (Advertising Service - Guides développeur et référence
      API)

Gagner de l'argent grâce à votre application
Payment Service est un SDK que vous pouvez utiliser pour récupérer de l'argent par le biais de vos applications.
Vos clients peuvent utiliser tout type de paiement associé à leur identifiant BlackBerry ID. Ces types de paiement
sont la facturation auprès de leur fournisseur de services sans fil, une carte de crédit ou PayPal®. Le serveur
Payment Service traite toutes les demandes d'achat.
Pour plus d'informations, veuillez consulter :
•     Payment Service
•     Payment Service developer guides and API reference (Payment Service - Guides développeur et référence API)

Recueillir des données à propos de l'utilisation de votre application

4
Guide de mise en route                                                                     Conception de votre application

Analytics Service comprend un SDK et un portail Web qui peuvent vous aider à comprendre l'utilisation de vos
applications. Par exemple, vous pouvez recueillir des données à propos de vos utilisateurs, telles que le modèle de
leur smartphone BlackBerry, sa version, leur pays d'origine et leur langue ; le nombre d'utilisateurs uniques, le
nombre total de sessions et la durée moyenne d'une session ; des données telles que le nombre d'affichages par
écran, celui de clics sur un bouton et celui d'erreurs de l'application. Analytics Service recueille les données, les
compile et génère des rapports et des statistiques sur un portail Web.
Pour plus d'informations, veuillez consulter :
•     Analytics Service
•     Analytics Service developer guides and API reference (Analytics Service - Guides développeur et référence API)

Conception de votre application
Cette section présente quelques-unes des étapes fondamentales de conception d'une application réussie, avec
des liens vers des informations plus détaillées.
Définissez votre marché
Pour commencer, vous devez connaître votre marché pour déterminer ce qu'attendent vos utilisateurs cible. Pour
les applications qui seront vendues sur BlackBerry App World™, vous devez connaître votre marché potentiel,
ainsi que la pénétration actuelle du marché. Pour les applications d'entreprise, déterminez les besoins et les
niveaux de compétence de vos utilisateurs cible.
Déterminez les versions prises en charge
Chaque smartphone BlackBerry® exécute une version de BlackBerry Device Software qui correspond à une version
de BlackBerry® Java® SDK. Les applications sont postcompatibles mais ne sont pas toujours rétrocompatibles. Par
exemple, les applications composées à l'aide de BlackBerry Java SDK 5.0 s'exécutent sur BlackBerry Device
Software 6.0, mais peuvent ne pas fonctionner avec BlackBerry Device Software 4.7.
Pour plus d'informations sur la conception d'applications pour plusieurs versions, reportez-vous aux documents
suivants :
•     Migrer votre application vers BlackBerry 7 (en anglais)
•     Développer des applications pour différentes versions de BlackBerry Device Software et différents modèles de
      smartphone BlackBerry (en anglais)
Pour plus d'informations à propos des caractéristiques des modèles et de leur mode d'utilisation, reportez-vous à
la section :
•     Choix d'un système d'exploitation de terminal cible
•     Modèles de smartphone BlackBerry
•     Référence API de BlackBerry Java SDK et Guide de développement de composants d'interface utilisateur
      BlackBerry Java SDK (pour la version correspondant au lancement de chaque composant d'API)

                                                                                                                        5
Guide de mise en route                                                                     Conception de votre application

Dans le plug-in BlackBerry Java Plug-in pour Eclipse, vous pouvez compiler votre projet d'application BlackBerry (et
tout projet connexe) pour plusieurs versions de BlackBerry Device Software. Lorsque vous distribuez votre
application, le plug-in crée un fichier master .alx dans le dossier Standard de votre projet d'application BlackBerry.
Lorsque vous distribuez votre application sur Internet, le plug-in crée les fichiers .jad et .cod de chaque version de
BlackBerry Device Software dans le dossier Web de votre projet d'application BlackBerry.
Pour plus d'informations à propos de la compilation de projets d'applications pour plusieurs versions, reportez-
vous aux guides de développement de BlackBerry Java Plug-in pour Eclipse.
Décidez des fonctionnalités BlackBerry à intégrer dans votre application
Toute application réussie exploite au maximum les possibilités du smartphone, notamment sur le marché grand
public. Par exemple, elle est intégrée à la mise en réseau social, aux calendriers, appareil photo, GPS ou à la
technologie Push. Certains smartphones BlackBerry intègrent un magnétomètre (une boussole à trois axes
détectant l'orientation), des accéléromètres (qui détectent le mouvement du smartphone dans l'espace 3D), des
capteurs NFC, et bien plus encore.
Pour obtenir des informations à propos des fonctionnalités BlackBerry et sur la façon de les mettre à profit dans
votre application, reportez-vous au document :
•     Applications BlackBerry Super App
•     BlackBerry Java SDK Super App Development Guide (BlackBerry Java SDK Super App - Guide de développement)
•     BlackBerry Java SDK Integration Development Guide (BlackBerry Java SDK - Guide de développement -
      Intégration)
Pour plus d'informations à propos de l'accéléromètre et du magnétomètre, reportez-vous au document
BlackBerry Java SDK UI and Navigation Development Guide (BlackBerry Java SDK - Guide de développement -
Interface utilisateur et navigation).
Pour plus d'informations à propos de la technologie NFC, reportez-vous au document BlackBerry Java SDK
Networking and Connectivity Development Guide (BlackBerry Java SDK - Guide de développement - Mise en
réseau et connectivité).
Pour plus d'informations sur les nouvelles fonctionnalités de BlackBerry Java SDK 7, consultez les documents
•     Migrer votre application vers BlackBerry 7 (en anglais)
•     BlackBerry Java SDK 7 - Nouveautés de cette version (en anglais)

Consultez les instructions de conception BlackBerry
Research In Motion® a dirigé un vaste programme de recherche pour développer des méthodes recommandées et
des conseils de conception à utiliser lors de la conception d'une interface utilisateur. Pour plus d’informations,
reportez-vous aux instructions relatives à l'interface utilisateur des smartphones BlackBerry.
Pour une référence rapide aux composants de l'interface utilisateur que vous pouvez créer, reportez-vous au
document BlackBerry Java SDK UI Components (Guide de référence rapide BlackBerry du composant d'interface
utilisateur de BlackBerry Java SDK).
Consultez les exemples d'application

6
Guide de mise en route                                                                   Conception de votre application

RIM fournit de nombreux exemples d'application à utiliser comme bases de départ. Ils sont installés avec le plug-in
BlackBerry Java Plug-in pour Eclipse.
Tous les exemples d'applications sont fournis avec des commentaires sur le code. Certains d'entre eux sont
également fournis avec un guide de l'utilisateur. Vous pouvez également obtenir des exemples d'applications Java.

                                                                                                                      7
Guide de mise en route                                                                        Outils de développement Java

Outils de développement Java                                                                                       3
Le plug-in BlackBerry® Java® Plug-in pour Eclipse® inclut BlackBerry Java SDK. Le plug-in permet également de
simplifier vos tâches de développement, grâce à des outils permettant de compiler votre code dans les fichiers
requis pour le déploiement BlackBerry, et intègre une fonctionnalité permettant de créer des applications pour
plusieurs versions de BlackBerry® Device Software.
Cette section décrit les outils de développement que vous pouvez utiliser pour le développement d'applications
pour smartphone BlackBerry®.

À propos de BlackBerry Java Plug-in pour Eclipse
Eclipse® est un outil de développement Open Source gratuit. Pour étendre Eclipse pour le développement
BlackBerry, RIM fournit gratuitement BlackBerry® Java® Plug-in pour Eclipse. Ce plug-in simplifie le
développement d'applications Java pour les smartphones BlackBerry en vous donnant accès aux outils Eclipse
standard, tels qu'une aide relative au code.
Le plug-in BlackBerry Java Plug-in pour Eclipse est l'outil de développement idéal pour les applications BlackBerry
Java. Toutefois, vous pouvez aussi utiliser Visual Studio ou NetBeans® comme environnement de développement.
Le plug-in inclut BlackBerry Java SDK, BlackBerry Smartphone Simulator et de nombreux exemples d'application.
Le plug-in inclut également les outils de développement suivants :
•     RAPC : vous pouvez utiliser ce compilateur d'invite de commande pour compiler des fichiers .java et .jar dans
      des fichiers .cod. Les applications pour smartphone sont au format .cod.
•     JavaLoader : cet outil vous permet d'ajouter ou de mettre à jour une application sur un smartphone à des fins
      de test et de consulter des informations à propos des fichiers d'application .cod.
•     BlackBerry Signature Tool : cet outil vous permet d'envoyer des requêtes de signature de code à BlackBerry®
      Signing Authority Tool.
•     Preverify Tool : cet outil vous permet de vérifier partiellement vos classes avant de charger votre application
      sur un smartphone.
•     JDWP : cet outil vous permet de déboguer des applications avec des environnements de développement intégré
      tiers.
Des versions de BlackBerry Java Plug-in pour Eclipse sont disponibles pour les systèmes d'exploitation Windows et
Macintosh.
Si vous avez déjà développé des applications BlackBerry Java avec BlackBerry JDE, vous pouvez importer vos
projets dans Eclipse à l'aide de BlackBerry Java Plug-in pour Eclipse. Depuis sa version 1.1 non comprise,
BlackBerry Java Plug-in pour Eclipse ne prend plus en charge les fichiers de projet (.jdp) ni les fichiers d'espace de
travail (.jdw) et n'est plus rétrocompatible avec BlackBerry JDE.
Installation de BlackBerry Java Plug-in et de l'IDE Eclipse
Pour installer l'IDE Eclipse ou BlackBerry Java Plug-in, vous devez avoir un compte sur le site BlackBerry Developer
Zone. L'inscription est gratuite.

8
Guide de mise en route                                                                                           Simulateurs

Vous pouvez télécharger l'IDE Eclipse et le plug-in. Si Eclipse est déjà installé, vous pouvez choisir d'installer l'IDE
Eclipse avec BlackBerry Java Plug-in dans un autre répertoire, ou bien écraser votre installation actuelle. Voici les
sites de téléchargement d'Eclipse avec le plug-in :
•     BlackBerry Java Plug-in pour Eclipse v1.3 (Windows)
•     BlackBerry Java Plug-in pour Eclipse v1.3 (Mac)
Si Eclipse Classic 3.6.x est déjà installé, vous pouvez installer le plug-in et le SDK sans réinstaller Eclipse. Pour ce
faire, dans Eclipse, cliquez sur Help (Aide) > Install New Software (Installer un nouveau logiciel) (vous devez
spécifier un emplacement de mise à jour BlackBerry pour ceci), ou bien sur Window (Fenêtre) > Preferences
(Préférences), développez l'élément Java et sélectionnez Installed JREs (JRE installés).
Une fois que vous avez installé le plug-in, vous pouvez mettre à jour la version de Java ou supprimer Java.
Vous trouverez les instructions complètes d'installation ici : Guides de développement de BlackBerry Java Plug-in
pour Eclipse (pour Windows et Mac).
Plus d'informations à propos d'Eclipse et du plug-in Java
•     Guides de développement de BlackBerry Java Plug-in pour Eclipse (pour Windows et Mac)
•     Site de mise jour de BlackBerry Java Plug-in pour Eclipse
•     Outils Java

Simulateurs
Lorsque vous installez le plug-in BlackBerry® Java® Plug-in pour Eclipse®, un simulateur est inclus dans le
téléchargement. Il est cependant recommandé de tester votre application sur plusieurs modèles de smartphone.
Vous pouvez télécharger gratuitement d'autres simulateurs BlackBerry.
Pour plus d'informations à propos des simulateurs et de leur téléchargement, reportez-vous aux sections
suivantes :
•     Simulateurs de smartphone BlackBerry (en anglais)
•     Guides de développement BlackBerry Smartphone Simulator (en anglais)

Clés de signature de code
Certaines API BlackBerry® nécessitent des clés de signature de code. Lorsque vous utilisez ces API, vous pouvez
tester votre application dans un simulateur, mais ne pourrez la déployer qu'après utilisation de la clé pour signer
l'application. Dans la référence d'API, les éléments nécessitant les clés de signature de code sont marqués d'un
verrou.
Les clés de signature de code BlackBerry sont gratuites. Pour vous inscrire aux clés de signature de code, rendez-
vous à l'adresse www.blackberry.com/SignedKeys. Vos clés vous seront envoyées par e-mail, avec les instructions
d'utilisation.
Pour plus d'informations à propos de l'utilisation des clés de signature de code, reportez-vous au document
BlackBerry Java SDK Security Development Guide (BlackBerry Java SDK - Guide de développement - Sécurité).

                                                                                                                           9
Guide de mise en route                                                                  Création de votre première application

Création de votre première application                                                                                 4
BlackBerry® Java® Plug-in pour Eclipse® 1.3 fournit des modèles à utiliser pour créer un projet d'application
BlackBerry de base. Vous pouvez personnaliser le code du modèle pour l'adapter à vos besoins ou créer une
application de toutes pièces à partir d'un modèle vide.
Pour commencer, nous allons créer une version de l'application « Hello World » à l'aide du modèle Hello
BlackBerry. Cette version de « Hello World » est une application avec interface utilisateur de base qui fournit des
composants d'interface utilisateur simples. L'application inclut un champ de texte modifiable qui permet à
l'utilisateur de smartphone de saisir du texte ; dans cet exemple, l'utilisateur peut taper son nom. L'application
inclut également un champ avec bouton. Lorsque l'utilisateur de smartphone tape son nom et clique sur le bouton
Say Hello to (Dire bonjour à), l'application affiche une boîte de dialogue indiquant Hello  (Bonjour
), comme sur la capture d'écran suivante.

Créer l'application Hello BlackBerry
Avant de commencer : Dans le plug-in BlackBerry® Java® Plug-in pour Eclipse®, assurez-vous d'activer la
perspective de développement d'application BlackBerry. Cliquez sur Window (Fenêtre) > Open Perspective
(Ouvrir la perspective) > Other (Autre), puis choisissez BlackBerry Application Development (Développement
d'application BlackBerry).

1.    À partir du menu BlackBerry, cliquez sur New (Nouveau) > BlackBerry Project (Projet BlackBerry).
2.    Dans le champ Project name (Nom du projet), saisissez HelloBlackBerry.
3.    Dans la boîte de dialogue Nouveau projet BlackBerry, sélectionnez Create new project in workspace (Créer un
      projet dans un espace de travail).
4.    Sous JRE, sélectionnez Use a project specific JRE (Utiliser un JRE spécifique au projet) puis choisissez BlackBerry
      JRE 7.0.0 dans la liste déroulante.
5.    Cliquez sur Next. (Suivant).
6.    Cliquez sur Next. (Suivant).
7.    Sélectionnez le modèle Hello BlackBerry.

10
Guide de mise en route                                                                        Exécution de votre application

8.    Cliquez sur Finish. (Terminer).
Dans la liste de projets sur le volet de l'explorateur de progiciels, le projet HelloBlackBerry apparaît. Vous pouvez
développer le projet et voir que le dossier src/mypackage contient deux fichiers source Java® :
• HelloBlackBerry.java : contient le code source de la section principale de l'application.
• HelloBlackBerryScreen.java : contient le code source de création de l'écran.

Exécution de votre application
Vous pouvez exécuter et tester votre application à l'aide de BlackBerry® Smartphone Simulator ou d'un
smartphone BlackBerry.
Le plug-in BlackBerry® Java® Plug-in pour Eclipse® inclut des simulateurs pour différents modèles de smartphones
BlackBerry. Les simulateurs exécutent le même code Java® que les smartphones. Par conséquent, un simulateur
fournit un environnement précis permettant de tester la façon dont votre application se comporte sur un terminal
BlackBerry.

Exécuter votre application dans un simulateur
Dans les étapes suivantes, nous utilisons l'application Hello BlackBerry créée plus tôt pour montrer comment
exécuter une application.
1.    Dans le volet Package Explorer (Explorateur de progiciels), sélectionnez le projet que vous voulez exécuter. Pour
      cet exemple, sélectionnez le projet HelloBlackBerry.
2.    Pour exécuter l'application dans un simulateur, effectuez l'une des actions suivantes :
      • Cliquez avec le bouton droit sur le projet, puis sélectionnez Run As (Exécuter en tant que) > BlackBerry
         Simulator (Simulateur BlackBerry).
      • Si vous avez activé la perspective de développement d'applications BlackBerry, depuis la barre d'outils
         BlackBerry, cliquez sur le bouton Run on BlackBerry Simulator (Exécuter dans BlackBerry Simulator).
      BlackBerry® Java® Plug-in pour Eclipse® produit et compile le projet, puis lance BlackBerry Smartphone
      Simulator.
3.    Sur l'écran d'accueil du simulateur, cliquez sur l'icône de l'application. Dans cet exemple, cliquez sur l'icône
      Hello BlackBerry.

                                                                                                                         11
Guide de mise en route                                                                        Exécution de votre application

      L'application HelloBlackBerry s'ouvre et affiche un écran avec un champ textuel modifiable et un bouton.
4.    Pour tester l'application Hello BlackBerry, tapez votre nom dans le champ Enter Name (Entrer le nom), puis
      cliquez sur le bouton Say Hello to (Dire bonjour à).
      Une boîte de dialogue s'affiche avec le texte Hello  (votre nom) et un bouton OK. Cliquez sur OK.
5.    Pour fermer l'application, sur le simulateur, appuyez sur la touche Menu, puis sélectionnez Close (Fermer).
6.    Pour fermer le simulateur, cliquez sur File (Fichier) > Exit. (Quitter).

Exécuter votre application sur un smartphone
Avant de commencer : Si votre application utilise des API Research In Motion® protégées, vous devez d'abord
obtenir des clés de signature de code auprès de RIM. Pour plus d'informations à propos de la signature du code et
de l'enregistrement auprès de RIM pour utiliser des API protégées, rendez-vous à l'adresse www.blackberry.com/
SignedKeys.

1.    Connectez le smartphone BlackBerry® à votre ordinateur avec un câble USB.
2.    Dans le volet Package Explorer Eclipse®, cliquez avec le bouton droit sur le projet à charger sur le terminal.
3.    Cliquez sur BlackBerry > Load Project(s) on Device (Charger le projet sur le terminal).
      Le plug-in BlackBerry® Java® Plug-in pour Eclipse® produit et compile le projet. Si le smartphone est protégé par
      un mot de passe, vous êtes invité à le saisir. L'application est chargée sur le terminal.
4.    Sur l'écran d'accueil du smartphone, cliquez sur l'icône de l'application pour exécuter cette dernière.

12
Guide de mise en route                                             Plus de didacticiels

Plus de didacticiels
Voici quelques-uns des didacticiels les plus avancés :
•     Didacticiel : Création d'un bouton personnalisé
•     Didacticiels dans les forums d'assistance développeur Java

                                                                                    13
Guide de mise en route                                                                           Présentation de Java SDK

Présentation de Java SDK                                                                                          5
Le smartphone BlackBerry est créé de toute pièce en tant que terminal Java, avec toutes les applications et API
intégrées écrites en Java. BlackBerry Java SDK inclut des API Java® ME ainsi que des API BlackBerry spécifiques. Les
API BlackBerry fournissent l'accès à des fonctionnalités d'interface utilisateur avancées, une intégration en
profondeur avec les applications existantes, la possibilité de créer des bases de données avec SQLite® et d'utiliser
des fonctions cryptographiques pour protéger votre contenu, une fonctionnalité d'intégration de fonctions
géodépendantes (par exemple, les cartes et la géolocalisation), et bien plus encore.
BlackBerry® Java® SDK est divisé en douze catégories. Chaque catégorie se compose d'API qui fournissent un type
distinct de fonctionnalité, comme la création de l'interface utilisateur, la mise en réseau, le stockage de données
et la sécurité. De nombreuses catégories incluent à la fois des API Java ME et des API BlackBerry spécifiques.
Les douze catégories constituant BlackBerry Java SDK sont décrites dans les sections suivantes.

API de cycle de vie des applications
Le cycle de vie d'une application fait référence aux états et transitions par lesquels peut passer une application
entre son démarrage et sa fermeture. Le cycle de vie d'une application BlackBerry® est simple : démarrage,
exécution, fermeture. En cours d'exécution, la plupart des applications reçoivent et traitent des événements et
mettent à jour leur interface utilisateur en conséquence.
Toutes les applications ont une classe d'application dérivée des classes Application ou UiApplication. Si vous
souhaitez créer une application avec interface utilisateur, votre application doit étendre UiApplication. Sinon,
votre application doit étendre Application.
Démarrage
Une application BlackBerry peut être démarrée de différentes façons :
•     L'utilisateur clique sur une icône sur l'écran d'accueil.
•     Le système démarre automatiquement l'application lorsque le smartphone démarre.
•     Une autre application démarre l'application.
•     Le système démarre l'application à une heure programmée.

En cours d'exécution
Indépendamment de la manière dont une application est démarrée, le gestionnaire d'applications démarre le
processus dans lequel l'application s'exécute. La classe ApplicationManager permet aux applications d'interagir
avec le gestionnaire d'applications pour exécuter des tâches, y compris :
•     exécuter une application immédiatement ou à une heure donnée ;
•     interagir avec des processus, comme récupérer les ID des applications au premier plan ;
•     envoyer des événements globaux au système.
Le gestionnaire d'applications démarre une application en obtenant un nouveau processus et en exécutant un
thread dans ce processus pour appeler l'un des points d'entrée de l'application. Pour de nombreuses applications,
la méthode main() de sa classe d'application est le seul point d'entrée appelé. Toutefois, vous pouvez configurer

14
Guide de mise en route                                                                     API de cycle de vie des applications

plusieurs points d'entrée pour une même application. Plusieurs points d'entrée permettent aux utilisateurs de
démarrer l'application de différentes façons. Par exemple, si votre application permet aux utilisateurs de créer un
document, il est possible que vous souhaitiez fournir aux utilisateurs deux icônes permettant de démarrer
l'application. Les utilisateurs peuvent alors cliquer sur une icône pour ouvrir l'application dans leur écran d'accueil
et sur l'autre icône pour ouvrir l'application dans l'écran requis pour créer un document.
Les descripteurs d'application sont des ensembles de données à propos d'une application. Une application seule
peut être associée à plusieurs descripteurs d'application. Une application avec plusieurs points d'entrée dispose
d'un descripteur d'application correspondant à chacun de ces points d'entrée. Vous pouvez utiliser la classe
ApplicationDescriptor conjointement aux descripteurs d'application.
L'environnement d'exploitation BlackBerry est multi-thread. Il vous permet d'exécuter plusieurs applications
simultanément. Il prend en charge des événements de diffusion pour plusieurs applications et threads en cours
d'exécution en arrière-plan.
Le thread d'événement est le seul thread qui peut traiter des événements et mettre à jour l'interface utilisateur de
l'application. Par conséquent, vous ne devez pas l'utiliser pour exécuter des instructions qui pourraient échouer ou
être longues. Si, par exemple, vous devez établir une connexion réseau, vous devez exécuter et utiliser un autre
thread.
Il peut vous arriver de vouloir mettre à jour l'interface utilisateur depuis un thread de type autre que
d'événement. Vous disposez pour cela de deux méthodes.
•     Vous pouvez utiliser des threads d'arrière-plan pour accéder à l'interface utilisateur en activant un verrouillage
      d'événement pour une courte durée. Cette option est utile si vous avez besoin d'exécuter une mise à jour de
      l'interface utilisateur rapide ou urgente. Dans ce cas, vous devez procéder rapidement à la mise à jour de
      l'interface utilisateur requise et déverrouiller. Sinon, votre application ne répondra plus et pourrait être fermée
      par le système. Obtenez le verrouillage en appelant Application.getEventLock() sur le thread d'arrière-plan, puis
      synchronisez cet objet pour sérialiser l'accès à l'interface utilisateur.
•     Vous pouvez ajouter un objet exécutable à la file d'attente d'événements. Cette option est préférable si
      l'éventualité d'un retard avant l'exécution de la tâche est acceptable. Vous injectez un événement sous forme
      d'un objet déployant Runnable. L'événement est traité par le thread d'événement lorsqu'il est reçu de la file
      d'attente des messages. Le thread d'événement traite l'événement en appelant sa méthode run(). Pour injecter
      des événements exécutables dans la file d'attente des messages de votre application, utilisez la méthode
      invokeAndWait() ou invokeLater().
Dans les deux cas, vous ne devez pas exécuter de tâche susceptible d'être longue ou de se bloquer. Si vous utilisez
des appels de la bibliothèque dans votre tâche, assurez-vous de les comprendre correctement et de ne les utiliser
que s'ils sont rapides et ne risquent pas de se bloquer.
Fermeture
Pour fermer une application, vous pouvez appeler System.exit(), qui génère la fermeture de BlackBerry JVM
pour mettre fin à tous les processus d'appel et, par conséquent, à tous les threads associés. Vous pouvez
également arrêter une application en ôtant le dernier objet Screen de la pile d'affichage, ce qui pousse la méthode
close() à appeler System.exit().

                                                                                                                            15
Guide de mise en route                                                                            API d'interface utilisateur

Il s'agit d'une bonne méthode de désenregistrement manuel de tout écouteur que vous avez enregistré avant
d'arrêter votre application.
Du fait que vous démarrez généralement le thread d'envoi d'événement en appelant
Application.enterEventDispatcher(), qui ne s'arrête pas, votre application doit offrir une méthode d'arrêt. Les
applications interagissant avec l'utilisateur peuvent proposer un gestionnaire pour un élément de menu Close et
les applications sans interaction avec l'utilisateur peuvent s'arrêter par le traitement d'un événement système sur
lequel repose leur exécution.
Plus d'informations à propos du cycle de vie d'une application
•     Cycle de vie de l'interface utilisateur (en anglais)

API d'interface utilisateur
L'API d'interface utilisateur vous permet de créer des interfaces utilisateur pour les écrans BlackBerry®.
Les applications avec interface utilisateur mettent en œuvre net.rim.device.api.ui.UiApplication, qui est une sous-
classe de net.rim.device.api.system.Application. Un objet UIApplication maintient une pile d'objets Screen.
Lorsqu'il transfère des objets Screen sur la pile, il les place au-dessus de tout autre objet Screen déjà sur la pile.
Lorsque l'application ôte un objet Screen de la pile, elle réorganise les objets Screen sous-jacents comme
nécessaire. Seul l'écran au-dessus de la pile reçoit des événements d'entrée.
Les trois principaux éléments d'interface utilisateur sont Field (champ), Manager (gestionnaire) et Screen (écran).
Champs
Un objet Field représente une zone rectangulaire contenue par un gestionnaire. Chaque commande, telle qu'un
bouton, correspond à une instance d'un champ. Vous ne pouvez pas instancier l'objet Field directement, mais
vous pouvez utiliser les champs préconçus et créer des champs personnalisés. Chaque champ génère la
commande et traite l'entrée utilisateur. Voici quelques-uns des champs préconçus les plus utilisés :
•     ButtonField : fournit un bouton simple.
•     LabelField : fournit une étiquette textuelle.
•     TextField : fournit une étiquette textuelle.
•     DateField : permet d'enregistrer une date et de l'afficher dans différents formats dans un champ (par exemple,
      17/11/2011).
•     MapField : permet d'afficher une carte dans un champ.
•     BrowserField : permet d'afficher du contenu Web dans un champ.
Vous pouvez créer des champs personnalisés en étendant la classe Field.
Responsables
Un objet Manager, également appelé gestionnaire de disposition, traite la disposition et le défilement des
champs. Un objet Manager contient des champs. Il y a plusieurs sous-classes d'objets Manager, traitant des types
spécifiques de disposition de champs.

16
Guide de mise en route                                                                             API d'interface utilisateur

Plusieurs gestionnaires pratiques sont définis dans le progiciel net.rim.device.api.ui.container. Les gestionnaires
suivants sont les plus fréquemment utilisés :
•     VerticalFieldManager : ordonne les champs dans une seule colonne verticale.
•     HorizontalFieldManager : ordonne les champs dans une seule ligne horizontale.
•     FlowFieldManager : ordonne les champs horizontalement, puis verticalement.
Vous déclarez un gestionnaire de disposition au premier niveau de votre écran puis y ajoutez des champs. Les
gestionnaires de disposition étant des sous-classes de l'objet Field, ils peuvent être intégrés dans d'autres
gestionnaires de disposition. Vous pouvez également définir votre propre gestionnaire de disposition.
Écrans
Un objet Screen (écran) est le conteneur de niveau le plus élevé pour les éléments d'interface utilisateur
représentant ce que vous voulez afficher. Les écrans peuvent contenir des champs (tels que des champs textuels),
des gestionnaires de disposition, boutons radio et listes déroulantes.
L'API d'interface utilisateur propose deux types principaux d'objets Screen :
•     FullScreen, sous-classé par MainScreen et PhoneScreen
•     PopupScreen, sous-classé par Dialog, Status, LocationPicker et AbstractLocationPicker
Vous pouvez afficher des informations complémentaires pour votre application dans un écran contextuel sans
interrompre l'exécution de l'application. Par conséquent, vous n'avez pas besoin de quitter l'écran pour y revenir
par la suite. Par ailleurs, vous pouvez hiérarchiser les objets PopupScreen transférés au sommet de la pile
d'affichage en appelant pushGlobalScreen(Screen, int, int).
Menus
Les smartphones BlackBerry organisent les commandes sous forme de menus contextuels accessible à l'aide de la
touche Menu. Les éléments de menu sont des instances de MenuItem. Vous pouvez personnaliser le menu ouvert
pour votre application. Vous pouvez :
•     ajouter ou supprimer des éléments de menu selon l'état d'écran ou de l'application lorsque le menu s'ouvre ;
•     indiquer l'ordre des éléments de menu ;
•     indiquer l'ordre des éléments de menu et l'élément de menu sélectionné par défaut.

Écouteurs
L'API d'interface utilisateur contient un modèle d'écouteur d'événement générique qui vous permet de déployer
des écouteurs pour de nombreux types d'événements, par exemple la modification d'un champ ou lorsque
l'utilisateur appuie sur une touche, clique sur le pavé tactile ou la trackball ou encore touche l'écran tactile. Vous
pouvez définir un écouteur pour un objet Field en appelant setChangeListener() de la classe Field.
Modèle de conception Modèle-Vue-Contrôleur

                                                                                                                           17
Guide de mise en route                                                                          API d'interface utilisateur

Certains composants standard de l'API d'interface utilisateur, y compris les indicateurs d'activité et de progression
du progiciel net.rim.device.api.ui.component.progressindicator ainsi que les listes et tableaux du progiciel
net.rim.device.api.ui.component.table, utilisent le modèle de conception Modèle-Vue-Contrôleur (MVC) comme
modèle de conception.
Avant d'utiliser ces composants, vous devez connaître le modèle de conception MVC. De nombreux documents
papier et ressources en ligne sont disponibles pour en savoir plus sur le modèle MVC.
Écrans modaux
Les objets Screen sont transférés sur la pile d'affichage par les méthodes pushScreen() et pushModalScreen() de la
classe UiApplication. L'objet pushModalScreen() se bloquant jusqu'à disparition de l'objet Screen de la pile
d'affichage (où pushScreen() répond immédiatement), l'ordre des opérations est crucial lorsque vous utilisez
des écrans modaux. N'appelez pas pushModalScreen() avant de démarrer le thread d'envoi d'événement pour
ne pas lancer d'exception RuntimeException. D'autres méthodes, telles que Dialog.inform() et Dialog.alert(),
utilisent également pushModalScreen().
Graphismes
Plusieurs options vous permettent de créer des graphiques sur un smartphone BlackBerry.
•     Vous pouvez ajouter des composants d'interface utilisateur prédéfinis, tels que du texte, des contrôles de
      données et des images aux objets Screen.
•     Vous pouvez faire des tracés personnalisés simples sur un écran en ignorant la méthode paint() de la classe
      qui représente l'écran et à l'aide des méthodes fournies par l'objet Graphics pour tracer sur l'écran.
•     Vous pouvez dessiner des graphiques 2D avec les API SVG : org.w3c.dom, org.w3c.dom.events et
      org.w3c.dom.svg.
•     Vous pouvez dessiner des images 2D plus sophistiquées avec les API d'utilitaires graphiques OpenGL ES et
      OpenVG.
•     Vous pouvez créer des images 3D avec l'API OpenGL ES.

Plus d'informations à propos de l'interface utilisateur
•     Création d'un bouton personnalisé (en anglais)
•     BlackBerry Java SDK UI and Navigation Development Guide (BlackBerry Java SDK - Guide de développement -
      Interface utilisateur et navigation)
•     BlackBerry Java SDK Graphics and Animation Development Guide (BlackBerry Java SDK - Guide de
      développement - Graphiques et animation)
•     BlackBerry Smartphones UI Guidelines (Guides sur l'interface utilisateur des smartphones BlackBerry)
•     BlackBerry Java SDK UI Component Development Guide (BlackBerry Java SDK - Guide de développement -
      Composants de l'interface utilisateur)

18
Guide de mise en route                                                                       API d'intégration d'applications

API d'intégration d'applications
Les API d'intégration d'applications contiennent des progiciels que vous pouvez utiliser pour intégrer vos
applications aux applications de base, telles que l'application Contacts, l'application Téléphone et l'application
Multimédia.
API d'appel
Vous pouvez utiliser l'API d'appel pour appeler des applications de base et, éventuellement, pour transmettre des
données. Pour utiliser cette API, appelez invokeApplication et transmettez le type d'application et tout argument
pertinent. Vous pouvez utiliser l'API d'appel pour appeler les applications de base suivantes :
•     contacts
•     calculatrice
•     calendrier
•     appareil photo
•     BlackBerry Maps
•     mémos
•     messages
•     téléphone
•     recherche
•     tâches
L'API d' appel contient des champs APP_TYPE qui énumèrent les applications.
Pour chaque application de base pouvant être appelée avec l'API d'appel, il existe une sous-classe correspondante
de la classe ApplicationArguments. Par exemple, pour appeler l'application Téléphone, appelez invokeApplication
et transmettez le type d'application Téléphone, ainsi qu'un argument PhoneArguments. Pour appeler une
application sans argument, transmettez null et non un objet ApplicationArguments.
API de gestionnaire de contenu
Vous pouvez utiliser l'API de gestionnaire de contenu (CHAPI) pour appeler des applications principales et des
applications tierces. JSR 211 définit CHAPI comme une API Java® ME facultative. Pour plus d'informations à propos
de CHAPI, consultez la présentation du progiciel javax.microedition.content.
Pour utiliser CHAPI afin d'appeler des applications, indiquez une URL, un type de contenu ou un ID de contenu
avec l'un des constructeurs de la classe javax.microedition.content.Invocation. Lorsque vous utilisez CHAPI avec
des ID de contenu fournis par RIM pour appeler des gestionnaires de contenu RIM®, CHAPI peut constituer une
bonne méthode de définition des paramètres d'appel pour les applications de base, y compris l'application
Multimédia. Vous pouvez également utiliser CHAPI pour appeler des applications tierces enregistrées en tant que
gestionnaires de contenu.
BlackBerry Browser
Vous pouvez appeler BlackBerry Browser et ouvrir une page Web avec les méthodes de la classe Browser et de la
classe BrowserSession.

                                                                                                                          19
Guide de mise en route                                                                    API d'intégration d'applications

Pour plus d'informations à propos de l'appel d'un navigateur, y compris la méthode d'appel d'un navigateur
différent du navigateur par défaut, consultez l'article de la base de connaissances Invoke the browser (Appeler le
navigateur).
Vous pouvez également intégrer du contenu Web dans votre application avec la classe BrowserField.
Gestionnaire d'applications
Vous pouvez démarrer une application de base avec la classe ApplicationManager, en indiquant le module de code
de l'application. Utilisez cette technique uniquement si l'application ne peut pas être appelée avec l'une des
techniques évoquées précédemment. Vous ne pouvez pas transmettre d'argument d'application à une application
de base avec cette technique. Vous pouvez utiliser ApplicationManager pour appeler les applications de base
suivantes :

 Application        Nom du module
 horloge            net_rim_bb_clock
 sons               net_rim_bb_profiles_app
 BlackBerry         net_rim_bb+_qm_peer
 Messenger
 options            net_rim_bb_options_app

Remarque: Les noms de module des applications de base sont susceptibles d'être modifiés. Appeler les modules
directement peut avoir des effets secondaires indésirables.
Activation des applications de base pour appeler votre application
Vous pouvez ajouter des éléments de menu à une application de base avec le progiciel menuitem. Par exemple,
vous pouvez ajouter un élément de menu appelé Voir les commandes à l'application Contacts. Lorsque l'utilisateur
clique sur Voir les commandes, votre application s'ouvre et affiche la liste des commandes de ce contact.
La classe ApplicationMenuItemRepository fournit les constantes déterminant l'application de base dans laquelle
votre élément de menu apparaît. Par exemple, la constante MENUITEM_MESSAGE_LIST indique que l'élément de
menu doit apparaître dans l'application Messages. La constante MENUITEM_SYSTEM indique que votre élément de
menu s'affiche dans la plupart des applications de base.
Les applications qui utilisent le champ ActiveAutoTextEditField ou ActiveRichTextField (par exemple, les
applications Calendrier et Messages) peuvent reconnaître des modèles de chaîne et fournir des éléments
spécifiques pour ces modèles de chaîne dans le menu sur le smartphone. Par exemple, si un message contient un
numéro de téléphone, ce numéro est mis en surbrillance. Si l'utilisateur de smartphone sélectionne le numéro et
appuie sur la touche Menu, l'élément de menu spécial Appeler ce numéro s'affiche.
Vous pouvez définir vos propres modèles de chaîne et associer ces modèles à des éléments de menu
personnalisés. Les éléments de menu personnalisés s'affichent lorsqu'un utilisateur sélectionne une chaîne
correspondante dans un champ ActiveAutoTextEditField ou ActiveRichTextField et ouvre le menu. Les
éléments de menu personnalisés peuvent exécuter tout type d'action, par exemple démarrer votre application.

20
Vous pouvez aussi lire
DIAPOSITIVES SUIVANTES ... Annuler