Raspberry Pi – Emission d’un flux vidéo pour une lecture sur Android

Raspberry Pi flux vidéo AndroidLe Raspberry Pi est un petit ordinateur vendu pour une trentaine d’euros et qui permet, grâce à son port GPIO de commander divers appareils et circuits électronique. Vous pouvez également y brancher un caméra, soit la caméra « officielle » nommée « Raspberry Pi Camera Board », soit une webcam USB.

Si comme moi, vous souhaitez diffuser l’image de la caméra branchée sur Raspberry Pi, ce tutoriel est fait pour vous.

 

Installation et configuration du paquet permettant de diffuser le flux vidéo

Tout d’abord, nous allons avoir besoin d’installer le paquet « subversion » pour pouvoir récupérer les sources utiles au fonctionnement du « streamer ».

Pour cela, exécutez les commandes suivantes :

sudo apt-get update
sudo apt-get install subversion

Installez ensuite libjpeg8-dev et imagemagick comme ceci :

sudo apt-get install libjpeg8-dev
sudo apt-get install imagemagick

Une fois cette action terminée, allez dans votre dossier personnel comme ceci

cd /home/pi

Il faut ensuite télécharger le streamer. Pour cela, nous allons utiliser « mjpg-streamer ».

Téléchargez-le en exécutant la commande suivante :

svn co https://svn.code.sf.net/p/mjpg-streamer/code/mjpg-streamer/ mjpg-streamer

Compiler le paquet avec les commandes suivantes :

cd mjpg-streamer
make

Une fois l’opération terminée, vous devriez pouvoir déclencher le streaming sur votre camera.
Si votre caméra est une webcam branchée en USB vous devriez pouvoir l’utiliser directement. Si la caméra est celle du Raspberry Pi (Raspberry Pi Camera Board), vous devriez avoir une erreur.

Pour en être sûr, exécutez la commande suivante :

./mjpg_streamer -i "./input_uvc.so" -o "./output_http.so -w ./www"

Si l’erreur « ERROR opening V4L interface: No such file or directory » apparait, cela signifie que la caméra n’a pas de drivers et ne peux pas être utilisée comme cela. Si jamais vous n’avez pas utilisé la caméra du Raspberry Pi mais une webcam USB, vous ne devriez pas voir apparaître cette erreur (sauf si votre webcam n’est pas compatible). Passer alors au dernier point de ce tutoriel

 

Installation du driver de la caméra « Raspberry Pi Camera Board »

Il faut tout d’abord installer UV4L, pour cela, nous allons commencer par la clé du dépôt. Exécutez alors la commande suivante :

wget http://www.linux-projects.org/listing/uv4l_repo/lrkey.asc && sudo apt-key add ./lrkey.asc

Ensuite, avec votre éditeur préféré, il va falloir aller modifier le fichier « /etc/apt/sources.list ». Dans l’exemple suivant, je vais utiliser « vi », mais « joe », « nano » ou un autre éditeur feront également l’affaire :

sudo vi /etc/apt/sources.list

Ajoutez alors dans à la fin de ce fichier la ligne suivante :

deb http://www.linux-projects.org/listing/uv4l_repo/raspbian/ wheezy main

Pour les utilisateur de « vi », quittee en appuyant sur « Esc » ou « Echap » sur votre clavier et en tapant « :wq! » puis validez en appuyant sur « Entrée »

Mettez à jour vos paquets grâce à la commande suivante :

sudo apt-get update

Puis installez le paquet uv4l et uv4l-raspicam :

sudo apt-get install uv4l uv4l-raspicam

Le drivers est maintenant installé, il manque cependant un nouveau paquet qui permettra de lancer automatiquement ce driver au démarrage du Raspberry Pi. Pour cela, exécutez la commande suivante :

sudo apt-get install uv4l-raspicam-extras

Il ne reste plus qu’à redémarer le service uv4l_raspicam grâce à la commande suivante :

sudo service uv4l_raspicam restart

Vous pouvez maintenant relancer votre serveur de streaming grâce à la commande :

./mjpg_streamer -i "./input_uvc.so" -o "./output_http.so -w ./www"

Si cela ne fonctionne toujours pas (comme c’était le cas pour moi), vous pouvez exécuter la commande de mise à jour du Raspberry Pi:

sudo rpi-update

Puis terminer par un « reboot » pour redémarrer le Raspberry Pi.

Au redémarrage, vous devriez pouvoir utiliser votre Raspberry Pi avec la caméra :

cd /home/pi/mjpg_streamer
./mjpg_streamer -i "./input_uvc.so" -o "./output_http.so -w ./www"

 

Vous accéder maintenant à votre flux en lançant sur votre navigateur préféré sur la page suivante « http://IP_de_votre_Raspberry:8080 »

Egalement dans VLC en ouvrant un flux réseau à l’adresse suivante : « http:// IP_de_votre_Raspberry:8080/?action=stream »

Vous remarquerez que l’action exécutée en invite de commande sur le Raspberry Pi est bloquante. Pour quitter le streaming vidéo, il vous suffit simplement de faire « CTRL + C » sur votre clavier et le streaming est stoppé instantanément. Vous reprenez alors la main sur votre Raspberry Pi.

Pour les adaptes du Raspberry Pi, je ne saurais que vous conseiller le blog Framboise314

Android – Communication avec un Raspberry Pi

Un tutoriel sur la communication entre un terminal Android et un Raspberry Pi. Vous en rêviez, le voici !

Le but de ce tutoriel étant de diffuser un flux caméra depuis le Raspberry Pi et le visualiser sur le terminal Android. Vous pouvez accéder au tutoriel de diffusion du flux vidéo en cliquant ici

Dans un second temps, il y aura également le déclenchement d’actions (sur les broches GPIO) sur le Raspberry Pi depuis le terminal Android. – Publication à venir

Activer le débogage USB sur Android 4.2, 4.3 et 4.4

Je pense que vous avez pu constater que depuis la version 4.2 d’Android, et donc sur les version 4.2, 4.3 et 4.4 (respectivement appelées Jelly Bean et KitKat), le menu « Options pour les développeurs » a disparu du menu des paramètres. Mais ce n’est qu’un menu caché et où il faut effectuer différentes actions avant de le voir apparaitre. Voici la marche à suivre pour enfin retrouver le débogage USB :

  • Allez dans « Paramètres » puis « A propos du téléphone ».
  • Appuyez 7 fois (environ)  sur l’item « Numéro de build » (ou « Numéro de version ») jusqu’à ce que le message « Vous êtes maintenant développeur » apparaisse.
  • Quittez tout et retourner dans les « Paramètres ». Vous allez maintenant voir que l’item « Option pour les développeurs » est apparu.
  • Rendez-vous maintenant dans ce menu pour cocher la case « Débogage USB ».

Source : http://developer.android.com/tools/device.html

Communiquer avec un Webservice

Si comme moi, vous avez beaucoup cherché comment communiquer avec un Webservice depuis une applications Android, cet article est fait pour vous.

Tout d’abord, j’ai récupéré le paquet suivant :LibWebservice
Je l’ai ensuite dé-zippé à la racine du répertoire « src » du projet présent dans mon workspace. Si le projet était ouvert dans votre éditeur Android préféré, il faudra réactualiser ce dernier en appuyant sur la touche « F5 ». Vous devriez maintenant voir apparaitre les nouveaux fichiers dans l’arborescence de votre éditeur.

Il faut créer une classe avec son constructeur prenant comme paramètre l’URL du Webservice.

public class WebService {
    private String URL_globale = "";
    public WebService(String URL)
    {
        this.URL_globale = URL;
    }
}

J’ai ensuite créé une méthode me permettant de tester la connexion avec le WebService. Bien sûr, il faut que la fonction « testConnexion » soit présent dans le Webservice distant et dans notre cas, il faut que cette dernière retourne « OK » si la connexion est correcte.

public boolean tester_la_connexion() throws IOException, XmlPullParserException
{
    final String SOAP_ACTION = "testConnexion";  //Nom de la fonction du Webservice
    final String METHOD_NAME = "testConnexion";  //Nom de la fonction du Webservice
    StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();

    StrictMode.setThreadPolicy(policy);
    // Création de la requête SOAP
    SoapObject request = new SoapObject (NAMESPACE, METHOD_NAME);
    //Ajout de propriété: addProperty(nom de variable, valeur) -> Le nom de la variable vient du Webservice
    request.addProperty("SecureKey", SECURE_KEY);   //Je passe une "secure key" qui permet d'identifier l'application (facultatif)

    //Mise dans l'enveloppe SOAP des données
    SoapSerializationEnvelope envelope = new SoapSerializationEnvelope (SoapEnvelope.VER11);
    //Préparation de la requête
    envelope.setOutputSoapObject (request);
    HttpTransportSE androidHttpTransport = new HttpTransportSE (URL_globale);

    androidHttpTransport.debug = false;
    //Envoi de la requête
    androidHttpTransport.call (SOAP_ACTION, envelope); //Envoi au Webservice

    Object soapResult =  envelope.getResponse(); //Récupération du résultat
    if(soapResult.toString().equals("OK"))
    {
       return true;
    }
    else
    {
       return false;
    }
 }

A vous d’adapter cette méthode en fonction de vos besoins et de vos fonctions.

Il ne vous reste plus qu’à instancier la classe « WebService » et vous servir de la fonction « tester_la_connexion »

Afficher des images venant de SQlite ou d’une URL dans une listView

Un problème rencontré lors de mes différents développements à été d’afficher des images provenant d’un champs Blob(SQlite) dans une zone image d’une listView.

Pour se faire, il faut tout d’abord créer une classe que j’appellerai ici « MyViewBinder », en voici donc le code :

import android.graphics.Bitmap;
import android.view.View;
import android.widget.ImageView;
import android.widget.SimpleAdapter.ViewBinder;

public class MyViewBinder implements ViewBinder
{
	public boolean setViewValue(View view, Object data,String textRepresentation)
        {
		if( (view instanceof ImageView) & (data instanceof Bitmap) )
                {
			ImageView iv = (ImageView) view;
			Bitmap bm = (Bitmap) data;
			iv.setImageBitmap(bm);
			return true;
		}
		return false;
	}

}

Il faut ensuite déclarer classiquement un HashMap mais de la façon suivante :

ArrayList<HashMap<String, Object>> listItem = new ArrayList<HashMap<String, Object>>(); //Déclaration de l'ArrayList qui recevra la liste de HashMap
HashMap<String, Object> map; //Déclaration du HashMap
map = new HashMap<String, Object>();

Vous pouvez ensuite y insérer l’image stocker dans un Bitmap de la façon suivante :
Le tout devra donc être dans un boucle pour remplir les différentes case de la listView

image = c.getBlob(3);  //Récupération du Blob
bmp  = BitmapFactory.decodeByteArray(image,0,image.length, null); //Conversion en Bitmap
map.put("img",bmp); //Mettre l'image dans le HashMap
listItem.add(map); //Mettre chaque HashMap dans l'ArrayList

Et enfin, l’affichage de tout cela

SimpleAdapter mSchedule = new SimpleAdapter (this.getBaseContext(), listItem,R.layout.affichageitem,
new String[] {"img", "ville", "type","prix","id"}, new int[] {R.id.img, R.id.ville, R.id.type,R.id.prix,R.id.id});
mSchedule.setViewBinder(new MyViewBinder());
listView.setAdapter(mSchedule);

Bien sûr, ce fonctionne marche également très bien pour les images provenant d’URLs externe.

Source : http://www.developpez.net/forums/d1032626/java/general-java/java-mobiles/android/prendre-image-url-afficher-utilisant-listview/

Tester la connexion internet

Vous n’avez jamais eu besoin de tester si votre application peux accéder à internet ou non ?
Eh bien rien de plus simple. Tout d’accord créez une classe classique, j’ai nommé la mienne « ConnexionInternet » dans l’exemple ci-dessous. Voici le code réalisant le test :


import android.app.Activity;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.NetworkInfo.State;

public class ConnexionInternet
{
    public static boolean isConnectedInternet(Activity activity)
    {
        ConnectivityManager connectivityManager = (ConnectivityManager)activity.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
        if (networkInfo != null)
        {
            State networkState = networkInfo.getState();
            if (networkState.compareTo(State.CONNECTED) == 0)
            {
                return true;
            }
            else return false;
        }
        else return false;
    }
}

Et enfin, le code pour l’utilisation de la fonction

if(ConnexionInternet.isConnectedInternet(MainActivity.this))
{
    //Je suis connecté à internet
}
else
{
    //Je ne suis pas connecté à internet
}

Définir une animation entre le passage d’une vue à une autre

Pour permettre le changement de l’animation par défaut pour le passage d’une vue à une autre, il faut tout d’abord importer le dossier « anim » présent dans les exemples du SDKd’Android dans le répertoire « res » d’Eclipse (voir image ci-dessous).

On peut alors faire la chose suivant pour définir la transition qui sera utilisée :


package com.AJ.FastAndQuikly;
import android.app.Activity;
import android.os.Bundle;

public class DisplayVue extends Activity
{
    public void onCreate(Bundle savedInstanceState) //A la creation de la vue
    {
        super.onCreate(savedInstanceState);
        overridePendingTransition(R.anim.wave_scale, R.anim.wave_scale);  //Animation
        setContentView(R.layout.jeu); //Afficher la vue portant le nom "jeu"
    }
}

On a donc rajouter l’animation, il est est alors possible de changer celle de l’exemple pour une autre ou de rajouter une animation en ajoutant un fichier XML dans le dossier « anim ».

Source : http://www.41post.com/3368/programming/android-changing-the-animation-between-activities

Faire un bouton qui change de vue

Le changement de vue sous Android est assez complexe pour un débutant comme moi, il faut tout d’abord créer une classe qui aura pour but d’afficher la seconde vue, en voici le code (Fichiers « DisplayVue.java ») :


package com.AJ.FastAndQuikly;
import android.app.Activity;
import android.os.Bundle;

public class DisplayVue extends Activity
{
    public void onCreate(Bundle savedInstanceState) //A la   creation de la vue
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.jeu); //Afficher la vue portant le nom "jeu"
    }
}

Il faut ensuite activer un listener sur le bouton souhaité comme suivant (fichier « FastandQuiklyActivity.java » qui est le fichier principal) :

package com.AJ.FastAndQuikly;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class FastandQuiklyActivity extends Activity
{
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);  //Définition de la vue principale
        Button ButtonConnexion = (Button) findViewById(R.id.button1);   //Appel du "button1"
        ButtonConnexion.setOnClickListener(new View.OnClickListener()      //Creation du listener sur ce bouton
        {
            public void onClick(View actuelView)    //au clic sur le bouton
            {
                Intent intent = new Intent(FastandQuiklyActivity.this, DisplayVue.class);  //Lancer l'activité DisplayVue
                startActivity(intent);    //Afficher la vue
            }
        });
    }
}

Attention : ne pas oublier de declarer l’activity « DisplayVue » dans le fichier AndroidManifest.xml

Modifier la couleur de fond

Après avoir pas mal chercher, voici la marche à suivre pour changer la couleur de fond de votre application.

Il faut ajouter dans le fichier main du dossier layout (ou autre selon les résolutions paramétrées) dans la balise <LinearLayout>

 android:background="#0000ff" 

#0000ff correspondant à la couleur désirée, ici un bleu.