Share
De nombreux appareils Android sont équipés de caméras intégrées. Dans ce didacticiel, nous allons aborder la technique de base pour capturer une image à l'aide de l'appareil photo Android, puis la rogner à l'aide d'applications que l'utilisateur a déjà installées sur son appareil. En cours de route, je montrerai également comment rendre compte des utilisateurs dont les périphériques ne prennent en charge ni la capture d'image, ni les actions de recadrage..
Créez un nouveau projet Android dans Eclipse ou votre IDE choisi. Dans votre classe d'activité principale, ajoutez les instructions d'importation suivantes après la déclaration du package:
importer android.app.Activity; importer android.content.ActivityNotFoundException; importer android.content.Intent; importer android.graphics.Bitmap; importer android.net.Uri; importer android.os.Bundle; importer android.provider.MediaStore; importer android.view.View; importer android.view.View.OnClickListener; importer android.widget.Button; importer android.widget.ImageView; importer android.widget.Toast;
Celles-ci nous permettront d'effectuer la capture, le recadrage et l'affichage des images dans l'application. Ouvrez le fichier XML de chaînes de votre application, que vous devriez trouver dans le dossier "res / values". Ajoutez les chaînes suivantes:
Capturer une image à recadrer! Image Lancer la caméra
Nous allons utiliser ces chaînes dans l'interface utilisateur.
Nous allons concevoir la mise en page de l'application. Ouvrez votre fichier XML principal, qui devrait se trouver dans le dossier "res / layout". Utilisez une disposition linéaire comme suit, qu'Eclipse a peut-être déjà fournie:
Dans la présentation linéaire, ajoutez l'affichage de texte suivant:
Ici, nous affichons du texte informatif en utilisant une chaîne définie dans le fichier XML de chaînes. Après la vue texte, ajoutez un bouton comme suit:
La valeur de l’ID nous permettra d’identifier le bouton en Java afin de pouvoir répondre aux clics. Encore une fois, nous utilisons une chaîne que nous avons déjà définie en XML. Enfin, après le bouton, ajoutez une vue d'image:
Nous placerons l'image capturée par l'utilisateur avec la caméra de son périphérique dans cette vue en utilisant la valeur de l'identifiant pour l'identifier en Java. Nous utilisons l'une des chaînes comme description de contenu et comme ressource à dessiner en arrière-plan que nous allons créer par la suite. Si vous souhaitez que la vue d'image s'étire pour occuper l'espace disponible, modifiez les attributs width et height en "fill_parent" au lieu de "wrap_content" - rappelez-vous que cela peut donner à l'image affichée une mauvaise qualité..
Pour l’arrière-plan dessinable, créez un nouveau fichier XML dans chacun des dossiers dessinables de votre application, en le nommant "pic_border.xml" pour correspondre à la valeur utilisée dans la section de présentation Image.. Pour ce faire, le plus simple consiste à créer le fichier dans un dossier pouvant être dessiné, à y copier le code XML, à le sauvegarder, puis à le copier dans les autres dossiers pouvant être dessinés..
Utilisez le code XML suivant dans votre nouveau fichier extractible "pic_border":
L'utilisation d'une ressource d'arrière-plan pouvant être dessinée est entièrement facultative, n'hésitez donc pas à l'omettre. Voici à quoi l'application ressemblera lors de son lancement:
Dans la classe d'activité de votre application, étendez la ligne de déclaration de classe d'ouverture comme suit:
Classe publique ShootAndCropActivity (extension) Activity implémente OnClickListener
Modifiez le nom de la classe en fonction de vos besoins. Dans la méthode "onCreate" d'activité, ajoutez ce qui suit après le code existant, appelant la méthode superclass et définissant la présentation du contenu, qu'Eclipse aurait dû renseigner:
// récupère une référence à l'interface utilisateur Bouton Button captureBtn = (Button) findViewById (R.id.capture_btn); // gérer les clics sur les boutons captureBtn.setOnClickListener (this);
Ici, nous demandons simplement à la classe de gérer les clics de bouton. L'utilisateur appuiera sur le bouton pour lancer la caméra. Nous devons maintenant fournir une méthode "onClick". Ajoutez-le comme suit, après la méthode "onCreate":
espace public public onClick (View v) if (v.getId () == R.id.capture_btn)
Dans la déclaration "if", nous allons implémenter en utilisant la caméra.
En haut de votre déclaration de classe, avant la méthode "onCreate", ajoutez les variables d'instance suivantes:
// garde la trace de l'intention de capture de la caméra final int CAMERA_CAPTURE = 1; // image capturée uri private Uri picUri;
Nous utiliserons la première variable pour suivre l’interaction de l’utilisateur lorsqu’il accède à l’application de la caméra et inversement. La seconde variable stockera l'URI de l'image capturée. Dans l'instruction "if" de votre méthode "onClick", ajoutez le code suivant pour lancer l'objectif de la caméra, en l'incluant dans un bloc "try":
try // utilise l’intention standard de capture d’une image Intention captureIntent = new Intent (MediaStore.ACTION_IMAGE_CAPTURE); // nous allons gérer les données retournées dans onActivityResult startActivityForResult (captureIntent, CAMERA_CAPTURE);
Lorsque ce code est exécuté, l'application de la caméra de l'utilisateur démarre et il peut prendre une photo. Nous allons gérer l'utilisateur revenant de l'application caméra dans la méthode "onActivityResult". À partir de là, nous pourrons vérifier que l'utilisateur revient de cette intention en utilisant la variable "CAMERA_CAPTURE" que nous transmettons au démarrage de l'activité. Cependant, avant cela, nous devons gérer la situation dans laquelle le périphérique utilisateur ne prend pas en charge l'intention de capture d'image que nous avons tenté de lancer ici. Après le bloc "try", ajoutez un "catch" comme suit:
catch (ActivityNotFoundException anfe) // affiche un message d'erreur String errorMessage = "Whoops - votre appareil ne prend pas en charge la capture d'images!"; Toast Toast = Toast.makeText (this, errorMessage, Toast.LENGTH_SHORT); toast.show ();
Chaque fois que vous essayez de lancer une intention en dehors de votre propre application, vous voudrez peut-être prendre cette précaution. C'est particulièrement le cas avec l'action de recadrage que nous explorerons plus tard. Cependant, ce modèle de code est une bonne habitude à adopter en général, car les périphériques utilisateur varient considérablement. Lorsque l'utilisateur accepte la photo qu'il a capturée, il retourne à l'application..
Nous avons lancé l'application appareil photo en utilisant "startActivityForResult"; nous devons donc maintenant gérer le résultat. Ajoutez la méthode "onActivityResult" après la méthode "onClick" comme suit:
onActivityResult void protégé (int requestCode, int resultCode, données d'intention) if (resultCode == RESULT_OK)
Dans la déclaration "if", ajoutez-en une autre pour vérifier que nous revenons de l'application Camera, en utilisant la variable que nous avons transmise:
// l'utilisateur revient de la capture d'une image à l'aide de la caméra si (requestCode == CAMERA_CAPTURE)
Nous allons également revenir à la méthode "onActivityResult" après que l'utilisateur a rogné son image. Nous allons donc ajouter un "else if" plus tard. Dans cette instruction "if", ajoutez le code suivant pour récupérer l'URI de la photo capturée:
// récupère l'URI de l'image capturée picUri = data.getData ();
Nous devons maintenant passer cet URI à une application capable de le rogner. Pour ce faire, nous utiliserons une méthode d'assistance. Ajoutez donc l'appel de méthode suivant:
// effectue l'opération de recadrage performCrop ();
Ajoutez la méthode d'assistance que nous avons appelée après la méthode "onActivityResult":
void privé performCrop ()
Dans cette méthode, nous allons appeler une intention pour effectuer le recadrage. Nous allons donc ajouter les blocs "try" et "catch" au cas où le périphérique utilisateur ne prend pas en charge l'opération de recadrage:
try catch (ActivityNotFoundException anfe) // affiche un message d'erreur String errorMessage = "Whoops - votre appareil ne prend pas en charge l'action de rognage!"; Toast Toast = Toast.makeText (this, errorMessage, Toast.LENGTH_SHORT); toast.show ();
Nous utilisons la même technique que celle utilisée lors du lancement de l'objectif de la caméra. Si la machine utilisateur ne prend pas en charge l’intention de rognage, un message d’erreur s’affiche. Dans le bloc "try", lancez l’intention comme suit:
Accentsconagua
// appelez l'intention d'action de recadrage standard (le périphérique utilisateur peut ne pas la prendre en charge) Intention cropIntent = new Intent ("com.android.camera.action.CROP"); // indique le type d'image et Uri cropIntent.setDataAndType (picUri, "image / *"); // définir les propriétés de la culture cropIntent.putExtra ("crop", "true"); // indique un aspect du recadrage souhaité cropIntent.putExtra ("aspectX", 1); cropIntent.putExtra ("aspectY", 1); // indique les sorties X et Y cropIntent.putExtra ("outputX", 256); cropIntent.putExtra ("outputY", 256); // récupère les données sur return cropIntent.putExtra ("return-data", true); // démarre l'activité - nous gérons le retour à onActivityResult startActivityForResult (cropIntent, PIC_CROP); Ici, nous définissons diverses propriétés pour l’image recadrée, en demandant à l’application de récupérer les données de l’image obtenue une fois le recadrage terminé. Si vous souhaitez que les dimensions de l'image recadrée diffèrent, modifiez les lignes "outputX" et "outputY" en conséquence. Nous appelons l'intention en utilisant "startActivityForResult", nous allons donc récupérer le résultat dans "onActivityResult" à nouveau. Comme avec l'objectif de la caméra, nous transmettons une variable pour garder une trace de l'intention à partir de laquelle nous retournons. Ajoutez donc une déclaration de variable en haut de la classe, à côté des autres variables d'instance:
// garde la trace de l'intention de recadrage final int PIC_CROP = 2;
En plus du recadrage, l'utilisateur peut sélectionner une zone de l'image..
Enfin, nous pouvons récupérer l'image recadrée et l'afficher dans l'interface utilisateur de l'application. Dans votre méthode "onActivityResult", après l'instruction "if" dans laquelle vous recherchez le code de requête "CAMERA_CAPTURE", ajoutez une instruction "if else" recherchant le code "PIC_CROP", auquel cas nous revenons de l'opération de recadrage. :
// l'utilisateur revient de rogner l'image sinon if (requestCode == PIC_CROP)
Dans cette instruction, nous pouvons récupérer l'image recadrée renvoyée comme suit:
// récupère les données renvoyées Bundle extras = data.getExtras (); // récupère le bitmap recadré Bitmap thePic = extras.getParcelable ("data"); Nous avons maintenant l'image recadrée de l'utilisateur sous forme de bitmap. Présentons-le dans la vue d'image comme suit:
// récupère une référence à ImageView ImageView picView = (ImageView) findViewById (R.id.picture); // affiche l'image recadrée renvoyée picView.setImageBitmap (thePic);
Maintenant, l'image recadrée apparaîtra dans l'interface utilisateur de l'application dès que l'utilisateur reviendra du recadrage. Enregistrez et exécutez votre application sur un appareil réel pour la tester..
Dans ce didacticiel, nous avons exploré le processus de base de capture et de recadrage dans le SDK Android. Cependant, l’action de recadrage en particulier peut être un peu imprévisible sur les divers appareils utilisateurs en fonctionnement. De nombreuses applications différentes peuvent gérer l'opération de recadrage. Par conséquent, certains développeurs adoptent un algorithme plus complexe pour résoudre les choix de l'utilisateur, en présentant ces applications à l'utilisateur sous forme de liste d'options. Quelles que soient les applications fournies par l'environnement utilisateur, le processus de base de capture et de recadrage reste le même..
