Ca faisait longtemps que j’en entendais parler, je l’ai utilisé, et je pense que je ne pourrai plus m’en passer! Définition Le “9-patch” permet de créer une image bitmap extensible, qui s’ajuste automatiquement au contenu de la vue. Il faut tout d’abord créer un fichier png qui sera la base du 9-patch. A l’aide d’une [...]
Android OS est un système Linux multi-utilisateurs dans lequel chaque application est un utilisateur différent.
Chaque processus a sa propre machine virtuelle pour que le code d’une application soit isolé des autres applications.
Il est bien sûr possible de contourner ces limitiations, mais la configuration par défaut est ainsi relativement sécurisée.
Les composants:
Il y a 4 types de composants qui sont des points d’entrée dans l’application. Pas forcemenent pour l’utilisateur, et certains dépendent les uns des autres, mais chacun existe comme une entité et joue un rôle spécifique.
L’Activity: représente un écran indépendant
Le Service: composant qui fonctionne en arrière plan pour faire des traitements longs. Il ne fournit pas d’IHM
Le Content Provider: il gère un ensemble de données partagées. Androi fournit par exemple un content provider qui partage les informations des contacts. Toute application qui en a le droit peut requeter ce content provider.
Le Broadcast Receiver: il répond à des annonces faites au travers du système (par exemple quand l’écran est éteind, quand la batterie est faible…). Il ne possède pas d’IHM, mais peut créer des notifications (barre de status).
Chaque application peut démarrer un composant d’une autre application. Une application peut prendre une photo sans avoir à ré-écrire le code de l’application de prise de photo.
Comme chaque application tourne dans un process différent qui ne permet pas l’accès aux autres applications, une application ne peut pas activer directement le composant d’une autre application. Mais le système android peut. Il faut donc envoyer un message au système qui spécifie l’intention de démarrer un composant particulier.
Activer les Composants:
3 des 4 composant (ativités, services, et broadcast receivers) sont activé par un message asynchrone appelé “intent”. Les intents lient les composants entre eux au runtime.
Les contents providers sont activés par un ContentResolver au travers des méthodes de l’objet ContentResolver lui-même.
J’ai appris beaucoup de choses sur GIMP récement pour faire les logos de mes applications (en même temps je partais de zéro…). Je voulais donc partager quelques ressources qui m’ont aidé à prendre en main ce logiciel de traitement d’image. Le tutoriel sur le site du zero m’a donné les bases.
Or quand j’ai voulu uploader le fichier .apk, le formulaire me renvoyait une erreure: “Une erreure inattendue s’est produite, veuillez réessayer plus tard.”
J’ai donc attendu un peu, le temps de déjeuner. Mais à l’heure où je devais faire la sieste je n’arrivais toujours pas à uploader mon apk. Je l’ai reconstruit, et re-reconstruit, j’ai essayé avec d’autre apk que j’avais déjà uploadé… Au comble de mon désespoir je cherche le formulaire de contact pour développeur en détresse sur la plateforme de google, et je tombe sur le forum où je vois que cette erreures revient régulièrement (“An unexpected error occurred. Please try again later.” ).
La solution est de se déconnecter/reconnecter de la plateforme.
Voilà au cas où ca vous arriverait Crédit photo: michael-reuter
Je voulais partager le bout de code sur lequel je me suis appuyé pour detecter le mouvement pour mes applications. Je ne l’ai pas inventé, mais j’ai du faire des petites corrections car certaines méthodes utilisées dans des exemples similaires étaient “deprecated”.
Voilà:
public class MyActivity extends Activity implements SensorEventListener{
private SensorManager sensorMgr;
private Sensor mAccelerometer;
private long lastUpdate = -1;
private float x, y, z;
private float last_x, last_y, last_z;
private static final int SHAKE_THRESHOLD = 350;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.myLayout);
startMotionDetection();
}
private void startMotionDetection() {
// start motion detection
sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);
mAccelerometer = sensorMgr.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
boolean accelSupported = sensorMgr.registerListener(this, mAccelerometer,
SensorManager.SENSOR_ACCELEROMETER);
if (!accelSupported) {
// on accelerometer on this device
sensorMgr.unregisterListener(this);
}
}
protected void onPause() {
if (sensorMgr != null) {
sensorMgr.unregisterListener(this);
sensorMgr = null;
}
super.onPause();
}
protected void onResume(){
sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);
sensorMgr.registerListener(this, mAccelerometer,
SensorManager.SENSOR_ACCELEROMETER);
super.onResume();
}
@Override
public void onAccuracyChanged(Sensor arg0, int arg1) {
// TODO Auto-generated method stub
}
@Override
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
long curTime = System.currentTimeMillis();
// only allow one update every 100ms.
if ((curTime - lastUpdate) > 100) {
long diffTime = (curTime - lastUpdate);
lastUpdate = curTime;
x = event.values[SensorManager.DATA_X];
y = event.values[SensorManager.DATA_Y];
z = event.values[SensorManager.DATA_Z];
float speed = Math.abs(x+y+z - last_x - last_y - last_z)
/ diffTime * 10000;
if (speed > SHAKE_THRESHOLD) {
// yes, this is a shake action! Do something about it!
//Put your code here
}
last_x = x;
last_y = y;
last_z = z;
}
}
}
}
