public class CompassView extends View {
    //~--- fields -------------------------------------------------------------
    //Rotation vers la droite en degree pour pointer le Nord 
    private float northOrientation=0;

    //~--- constructors -------------------------------------------------------
    public CompassView(Context context) {
        super(context);
    }

    // Constructeur utilisé pour instancier la vue depuis sa
    // déclaration dans un fichier XML
    public CompassView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    // idem au précédant
    public CompassView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }
    //~--- get methods --------------------------------------------------------

    // permet de récupérer l'orientation de la boussole
    public float getNorthOrientation() {
        return northOrientation;
    }

    //~--- set methods --------------------------------------------------------

    // permet de changer l'orientation de la boussole
    public void setNorthOrientation(float rotation) {
    	//on met à jour l'orientation uniquement si elle a changé
    	if (rotation != this.northOrientation)
    	{
    		this.northOrientation = rotation;
			//on demande à notre vue de se redessiner
			this.invalidate();
    	}
    }
}

//~--- methods ------------------------------------------------------------
// Permet de définir la taille de notre vue
// /!\ par défaut un cadre de 100x100 si non redéfini
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int measuredWidth  = measure(widthMeasureSpec);
    int measuredHeight = measure(heightMeasureSpec);

    // Notre vue sera un carré, on garde donc le minimum
    int d = Math.min(measuredWidth, measuredHeight);

    setMeasuredDimension(d, d);
}

// Déterminer la taille de notre vue
private int measure(int measureSpec) {
    int result   = 0;
    int specMode = MeasureSpec.getMode(measureSpec);
    int specSize = MeasureSpec.getSize(measureSpec);

    if (specMode == MeasureSpec.UNSPECIFIED) {
        // Le parent ne nous a pas donné d'indications,
		// on fixe donc une taille
        result = 150;
    } else {
        // On va prendre la taille de la vue parente
        result = specSize;
    }

    return result;
}

// Constructeur par défaut de la vue
public CompassView(Context context) {
    super(context);
    initView();//faire de même pour les 2 autres constructeurs
}

//~--- fields -------------------------------------------------------------
private Paint circlePaint;
private Paint northPaint;
private Paint southPaint;

private Path trianglePath;

//~--- methods ------------------------------------------------------------
private void initView() {
    Resources r = this.getResources();

    // Paint pour l'arrière plan de la boussole
    circlePaint = new Paint(Paint.ANTI_ALIAS_FLAG); // Lisser les formes
    circlePaint.setColor(r.getColor(R.color.compassCircle)); // Définir la couleur

    // Paint pour les 2 aiguilles, Nord et Sud
    northPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    northPaint.setColor(r.getColor(R.color.northPointer));
    southPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    southPaint.setColor(r.getColor(R.color.southPointer));

    // Path pour dessiner les aiguilles
    trianglePath = new Path();
}

<?xml version="1.0" encoding="utf-8"?>
<resources>
	<color name="northPointer">#FF0000</color>
	<color name="southPointer">#000000</color>
	<color name="compassCircle">#CCCCFF</color>
</resources>

// Appelée pour redessiner la vue
@Override
protected void onDraw(Canvas canvas) {
	//On détermine le point au centre de notre vue
    int centerX = getMeasuredWidth() / 2;
    int centerY = getMeasuredHeight() / 2;

    // On détermine le diamètre du cercle (arrière plan de la boussole)
    int radius = Math.min(centerX, centerY);

  	// On dessine un cercle avec le " pinceau " circlePaint
    canvas.drawCircle(centerX, centerY, radius, circlePaint);

    // On sauvegarde la position initiale du canevas
    canvas.save();

    // On tourne le canevas pour que le nord pointe vers le haut
    canvas.rotate(-northOrientation, centerX, centerY);

    // on créer une forme triangulaire qui part du centre du cercle et
    // pointe vers le haut
    trianglePath.reset();//RAZ du path (une seule instance)
    trianglePath.moveTo(centerX, 10);
    trianglePath.lineTo(centerX - 10, centerY);
    trianglePath.lineTo(centerX + 10, centerY);

    // On désigne l'aiguille Nord
    canvas.drawPath(trianglePath, northPaint);
    
    // On tourne notre vue de 180° pour désigner l'auguille Sud
    canvas.rotate(180, centerX, centerY);
    canvas.drawPath(trianglePath, southPaint);

    // On restaure la position initiale (inutile dans notre exemple, mais prévoyant)
    canvas.restore();
}

public class Boussole extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

<?xml version="1.0" encoding="utf-8"?>
<!-Pour utiliser notre vue, il suffit de mettre le nom complet du paquetage de notre classe CompassView-->
<com.bydavy.boussole.view.CompassView
	xmlns:android="http://schemas.android.com/apk/res/android"	
	android:id="@+id/compassView"	
	android:layout_width="fill_parent"
	android:layout_height="fill_parent"/>

public class Boussole extends Activity {
	
	//La vue de notre boussole
	private CompassView compassView;
	
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
	  //On récupère notre vue
        compassView = (CompassView)findViewById(R.id.compassView);
	  //Et on essaie de faire pointer notre aiguille du Nord au point à 45°
        compassView.setNorthOrientation(45);
    }
}

//Notre listener sur le capteur de la boussole numérique
private final SensorEventListener sensorListener = new SensorEventListener()         {
	@Override
	public void onSensorChanged(SensorEvent event) {
		compassView.setNorthOrientation(event.values[SensorManager.DATA_X]);
	}

	@Override
	public void onAccuracyChanged(Sensor sensor, int accuracy) {
	}
};

//Le gestionnaire des capteurs
private SensorManager sensorManager;
//Notre capteur de la boussole numérique
private Sensor sensor;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    compassView = (CompassView)findViewById(R.id.compassView);
 	//Récupération du gestionnaire de capteurs
    sensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
	//Demander au gestionnaire de capteur de nous retourner les capteurs de type boussole
    List<Sensor> sensors =sensorManager.getSensorList(Sensor.TYPE_ORIENTATION);
	//s'il y a plusieurs capteurs de ce type on garde uniquement le premier
    if (sensors.size() > 0) {
    	sensor = sensors.get(0);
    }
}

@Override
protected void onResume(){
	super.onResume();
	//Lier les évènements de la boussole numérique au listener
	sensorManager.registerListener(sensorListener, sensor, SensorManager.SENSOR_DELAY_NORMAL);
}

@Override
protected void onStop(){
	super.onStop();
	//Retirer le lien entre le listener et les évènements de la boussole numérique
	sensorManager.unregisterListener(sensorListener);
}

//Délais entre chaque image
private final int DELAY = 20;
//Durée de l'animation
private final int DURATION = 1000;

private float startNorthOrientation;
private float endNorthOrientation;

//Heure de début de l'animation (ms)
private long startTime;

// permet de changer l'orientation de la boussole
public void setNorthOrientation(float rotation) {

    // on met à jour l'orientation uniquement si elle a changé
    if (rotation != this.northOrientation) {
        //Arrêter l'ancienne animation
        removeCallbacks(animationTask);
    	//Position courante
        this.startNorthOrientation = this.northOrientation;
        //Position désirée
        this.endNorthOrientation   = rotation;
        //Nouvelle animation
        startTime = SystemClock.uptimeMillis();
        postDelayed(animationTask, DELAY);
    }
}

private Runnable animationTask = new Runnable() {
    public void run() {
        long curTime   = SystemClock.uptimeMillis();
        long totalTime = curTime - startTime;

        if (totalTime > DURATION) {
            // Fin de l'animation
            northOrientation = endNorthOrientation;
            removeCallbacks(animationTask);
        } else {
            //Changer la position de l'aiguille
            //Rappeler cette tâche dans DELAY ms pour dessiner la suite
            postDelayed(this, DELAY);
        }

        // Quoi qu'il arrive, on demande à notre vue de se redessiner
        invalidate();
    }
};

perCent = ((float) totalTime) / DURATION;

northOrientation = (float) (startNorthOrientation + perCent * (endNorthOrientation - startNorthOrientation));

if (totalTime > DURATION) {
    ?
} else {
    float perCent = ((float) totalTime) / DURATION;
    //On s'assure qu'on ne dépassera pas 1.
    perCent          = Math.min(perCent, 1);
    //On determine la nouvelle position de l'aiguille
    northOrientation = (float) (startNorthOrientation + perCent * (endNorthOrientation - startNorthOrientation));
    postDelayed(this, DELAY);
}
// Quoi qu'il arrive, on demande à notre vue de se redessiner
invalidate();

if (totalTime > DURATION) {
    ?
} else {
    float perCent = ((float) totalTime) / DURATION;

    // Animation plus réaliste de l'aiguille
    perCent          = (float) Math.sin(perCent * 1.5);
    perCent          = Math.min(perCent, 1);
    northOrientation = (float) (startNorthOrientation + perCent * (endNorthOrientation - startNorthOrientation));
    postDelayed(this, DELAY);
}
// Quoi qu'il arrive, on demande à notre vue de se redessiner
invalidate();

// permet de changer l'orientation de la boussole
public void setNorthOrientation(float rotation) {

    // on met à jour l'orientation uniquement si elle a changé
    if (rotation != this.northOrientation) {
        //Arrêter l'ancienne animation
        removeCallbacks(animationTask);
        
    	//Position courante
        this.startNorthOrientation = this.northOrientation;
        //Position désirée
        this.endNorthOrientation   = rotation;

        //Détermination du sens de rotation de l'aiguille
        if ( ((startNorthOrientation + 180) % 360) > endNorthOrientation)
        {
        	//Rotation vers la gauche
        	if ( (startNorthOrientation - endNorthOrientation) > 180 )
        	{
        		endNorthOrientation+=360;
        	}
        } else {
        	//Rotation vers la droite
        	if ( (endNorthOrientation - startNorthOrientation) > 180 )
        	{
        		startNorthOrientation+=360;
        	}
        }
        
        //Nouvelle animation
        startTime = SystemClock.uptimeMillis();
        postDelayed(animationTask, DELAY);
    }
}

private Runnable animationTask = new Runnable() {
    public void run() {
        ?
        if (totalTime > DURATION) {
            northOrientation = endNorthOrientation % 360;
            removeCallbacks(animationTask);
        } else {
            ?
        }
        ?
    }
};