📱 UrbaFix

Qu'est-ce que UrbaFix ?

UrbaFix est une application mobile native Android permettant aux citoyens de signaler des incidents urbains (nids de poule, déchets, éclairage défectueux, etc.) à leur municipalité de manière simple et rapide.

Technologies Utilisées

Problème Résolu

Objectifs Stratégiques

1. Améliorer la réactivité municipale

   Réduire le délai moyen de prise en charge de 7 jours à 48h

2. Augmenter la participation citoyenne

   Objectif : 500 signalements/mois pour une ville de 30 000 habitants

3. Digitaliser la relation citoyen-mairie

   80% des signalements via app d'ici 2025

Accès Dashboard

1. Navigation vers https://urbafix.fr/dashboard/
2. Connexion JWT (email + mot de passe)
3. Affichage liste incidents avec filtres

Traitement Incident

Schéma d'Architecture

┌─────────────────────────────────────────────────┐
│           APPLICATION ANDROID                   │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │  UI      │  │ViewModel │  │Repository│      │
│  │ (Compose)│←→│  (MVVM)  │←→│ (Mediator)      │
│  └──────────┘  └──────────┘  └────┬─────┘      │
│                                    │            │
│               ┌────────────────────┼─────────┐  │
│               ▼                    ▼         │  │
│         ┌──────────┐        ┌──────────┐    │  │
│         │   Room   │        │ Retrofit │    │  │
│         │ Database │        │   API    │    │  │
│         └──────────┘        └─────┬────┘    │  │
│         (SQLite local)            │         │  │
└───────────────────────────────────┼─────────┘  │
                                    │ HTTPS      │
                                    ▼            │
                    ┌────────────────────────────┐│
                    │     BACKEND PHP            ││
                    │  ┌────────────────────┐    ││
                    │  │ Nginx + PHP-FPM    │    ││
                    │  │ - Endpoints REST   │    ││
                    │  │ - CryptoManager    │    ││
                    │  │ - Repositories     │    ││
                    │  └─────────┬──────────┘    ││
                    │            │               ││
                    │            ▼               ││
                    │  ┌────────────────────┐    ││
                    │  │   MySQL Database   │    ││
                    │  │ - incidents        │    ││
                    │  │ - citoyens (chiffré)   ││
                    │  │ - mairies          │    ││
                    │  │ - photos           │    ││
                    │  └────────────────────┘    ││
                    │                            ││
                    │  Docker Secret:            ││
                    │  /run/secrets/master_key   ││
                    └────────────────────────────┘│
                                                  │
                    

Flux de Données

1. Création incident (online) :

   UI → ViewModel → Repository → Retrofit → API → MySQL

2. Création incident (offline) :

   UI → ViewModel → Repository → Room → (WorkManager) → Retrofit → API

3. Lecture incidents :

   UI ← ViewModel ← Repository ← Room (source unique de vérité)

4. Synchronisation :

   WorkManager → Repository → (SELECT PENDING) → Retrofit → API → (UPDATE SYNCED)

Pattern MVVM

Structure des Packages

app/src/main/java/com/example/monquartierkotlin/
├── MainActivity.kt
├── UrbafixApplication.kt
│
├── data/
│   ├── local/
│   │   ├── AppDatabase.kt
│   │   ├── Converters.kt
│   │   ├── entities/
│   │   │   ├── IncidentEntity.kt
│   │   │   ├── PhotoEntity.kt
│   │   │   └── MairieEntity.kt
│   │   └── dao/
│   │       ├── IncidentDao.kt
│   │       └── PhotoDao.kt
│   │
│   ├── remote/
│   │   ├── UrbafixApi.kt
│   │   ├── RetrofitClient.kt
│   │   └── dto/
│   │       ├── IncidentDto.kt
│   │       └── DtoMappers.kt
│   │
│   └── repository/
│       └── IncidentRepository.kt
│
├── ui/
│   ├── screens/
│   │   ├── home/
│   │   │   ├── HomeScreen.kt
│   │   │   └── HomeViewModel.kt
│   │   ├── report/
│   │   │   ├── ReportScreen.kt
│   │   │   └── ReportViewModel.kt
│   │   └── ...
│   │
│   └── components/
│       ├── MapView.kt
│       └── IncidentCard.kt
│
├── workers/
│   └── SyncIncidentsWorker.kt
│
└── utils/
    ├── FingerprintManager.kt
    ├── DeviceIdManager.kt
    └── ImageCompressor.kt
                    

Structure Backend

www/
├── index.php                    # Router principal
├── composer.json
│
├── src/
│   ├── Database.php             # Singleton PDO
│   │
│   ├── Crypto/
│   │   └── CryptoManager.php    # AES-256-GCM
│   │
│   ├── Utils/
│   │   ├── FingerprintValidator.php
│   │   └── AuditLogger.php
│   │
│   └── Repositories/
│       ├── IncidentRepository.php
│       └── CitoyenRepository.php
│
├── ── Endpoints API ──
├── check_mairie.php
├── signaler_mairie_avec_compte.php
├── get_incidents.php
├── update_citoyen.php
└── ...
                    

Pattern Repository

// src/Repositories/IncidentRepository.php

class IncidentRepository {

    private $db;

    public function __construct() {
        $this->db = Database::getInstance();
    }

    public function create($data): int {
        return $this->db->execute(
            "INSERT INTO incidents (...) VALUES (...)",
            [$data]
        );
    }

    public function findByCitoyen(int $citoyenId): array {
        return $this->db->query(
            "SELECT * FROM incidents WHERE citoyen_id = ?",
            [$citoyenId]
        );
    }
}

Schéma Complet

-- Table citoyens (données CHIFFRÉES)
CREATE TABLE citoyens (
    id INT AUTO_INCREMENT PRIMARY KEY,
    fingerprint VARCHAR(64) NOT NULL UNIQUE,
    salt VARCHAR(44) NOT NULL,

    -- Chiffrées AES-256-GCM (base64)
    nom TEXT NULL,
    prenom TEXT NULL,
    email TEXT NULL,

    code_postal VARCHAR(5) NOT NULL,
    created_at DATETIME NOT NULL
);

-- Table incidents
CREATE TABLE incidents (
    id INT AUTO_INCREMENT PRIMARY KEY,
    citoyen_id INT NULL,  -- NULL si citoyen supprimé
    mairie_id INT NOT NULL,
    type_id INT NOT NULL,

    description TEXT,
    latitude DECIMAL(10,8) NOT NULL,
    longitude DECIMAL(11,8) NOT NULL,
    code_insee VARCHAR(5),

    status ENUM('en_attente', 'en_cours', 'resolu', 'refuse'),
    created_at DATETIME NOT NULL,
    updated_at DATETIME,
    resolved_at DATETIME,

    FOREIGN KEY (citoyen_id) REFERENCES citoyens(id) ON DELETE SET NULL,  -- Préserve incidents
    FOREIGN KEY (mairie_id) REFERENCES mairies(id),
    FOREIGN KEY (type_id) REFERENCES types(id)
);

-- Index pour performances
CREATE INDEX idx_incidents_mairie_status
    ON incidents(mairie_id, status, created_at DESC);

CREATE INDEX idx_incidents_gps
    ON incidents(latitude, longitude);
                    

Codes d'Erreur HTTP

DTOs (Data Transfer Objects)

Les DTOs servent à transférer des données entre l'application Android et l'API backend.

IncidentDto (Android → API)

data class IncidentDto(
    @SerializedName("citoyen_fingerprint")
    val citoyenFingerprint: String,

    @SerializedName("type_id")
    val typeId: Int,

    @SerializedName("latitude")
    val latitude: Double,

    @SerializedName("longitude")
    val longitude: Double
)

Format des Dates

ISO 8601 utilisé partout : 2024-12-15T10:30:00Z

val timestamp = Instant.parse(
    "2024-12-15T10:30:00Z"
).toEpochMilli()

$datetime = new DateTime(
    '2024-12-15T10:30:00Z'
);

Enums et Constantes

SyncStatus (Android)

enum class SyncStatus {
    PENDING,   // En attente de sync
    SYNCING,   // En cours de synchronisation
    SYNCED,    // Synchronisé avec succès
    ERROR      // Erreur lors de la sync
}

IncidentStatus (Backend)

ENUM('en_attente', 'en_cours', 'resolu', 'refuse')

Device Fingerprinting

Principe : Chaque appareil Android génère un identifiant unique basé sur ses caractéristiques matérielles.

Résultat :

a7b3c9e4f1d2e8a6b5c4d3e2f1a0b9c8d7e6f5a4b3c2d1e0f9a8b7c6d5e4f3a2

Sécurité HTTPS

• Certificat : Let's Encrypt (renouvellement auto)
• Protocoles : TLS 1.2, TLS 1.3 uniquement
• HSTS : Force HTTPS pendant 2 ans
• Headers : X-Frame-Options, X-Content-Type-Options, X-XSS-Protection

Flux Complet

Types d'Incidents

Détection Position GPS

Stratégie de fallback pour maximiser la précision :

1. FusedLocationProvider (Google Play Services) : Précision optimale
2. GPS Provider : Si Play Services indisponible
3. Network Provider : Si GPS désactivé
4. Position par défaut : Menton (43.7737, 7.4951)

Intégration OpenStreetMap

Bibliothèque : osmdroid 6.1.18

Avantages :

• ✅ Gratuit (pas d'API key)
• ✅ Données ouvertes (OpenStreetMap)
• ✅ Offline tiles possible
• ✅ Pas de limite de requêtes

Géocodage Inverse (Code INSEE)

API : geo.gouv.fr

Endpoint : GET /communes?lat=43.7737&lon=7.4951

Réponse :

{
  "nom": "Menton",
  "code": "06083",
  "codesPostaux": ["06500"]
}

Utilité : Identifier la commune précise (plusieurs communes peuvent partager un code postal).

📷 Compression d'Images

Objectif : Réduire la taille des photos pour optimiser upload et stockage.

Paramètres :

• Max Width : 1920px
• Max Height : 1080px
• JPEG Quality : 85%
• Format de sortie : Base64 (pour stockage Room)

Résultat typique : Photo 4MB → 400KB (-90%)

🎥 Support Vidéo (v1.5.0)

Caractéristiques Vidéo

• Durée maximale : 5 secondes (troncature automatique si dépassement)
• Taille maximale : 5 MB
• Format : MP4 (conversion automatique via MediaMuxer)
• Upload : Base64 (compatible infrastructure existante)

Traitement Vidéo (VideoCompressor.kt)

suspend fun getVideoInfo(context: Context, uri: Uri): VideoInfo
suspend fun compressVideo(context: Context, uri: Uri): File?
suspend fun trimVideoTo5Seconds(context: Context, uri: Uri): File?

Interface Utilisateur

• 4 boutons de capture : Photo, Galerie, Vidéo 5s, Galerie ▶
• Aperçu vidéos avec indicateurs visuels :
  • Bordure bleue (2dp) pour distinguer des photos
  • Icône ▶ centrée
  • Badge durée en bas à droite (ex: "3s")
• Compteur séparé : "2 photo(s) • 1 vidéo(s)"

⚠️ Avertissement RGPD Obligatoire

Base de Données

@Entity(tableName = "photos_incident")
data class PhotoEntity(
    val mediaType: MediaType = MediaType.PHOTO,  // PHOTO ou VIDEO
    val durationMs: Long? = null,                // Durée vidéo en ms
    val photoData: String? = null,               // Base64
    // ... autres champs
)

enum class MediaType { PHOTO, VIDEO }

🔌 API Backend - Upload Vidéos

Format JSON (nouveau en v1.5.0) :

// Structure DTO
data class VideoData(
    val video: String,        // "data:video/mp4;base64,..."
    val latitude: Double?,    // Coordonnées GPS
    val longitude: Double?
)

data class SubmitIncidentRequest(
    val mairieId: Long,
    val typeId: Long,
    val adresse: String,
    val latitude: Double,
    val longitude: Double,
    val description: String,
    val deviceId: String,
    val photos: List<String>?,      // Base64 avec prefix
    val videos: List<VideoData>?    // Objets avec GPS
)

Endpoint API :

• POST /api/submit_incident.php
• Content-Type: application/json
• Méthode Retrofit : submitIncidentJson(@Body request)

Traitement PHP (submit_incident.php:176-241) :

// Extraction tableau videos depuis JSON
foreach ($data['videos'] as $index => $videoData) {
    $videoBase64 = $videoData['video'];  // "data:video/mp4;base64,..."
    $videoLat = $videoData['latitude'];
    $videoLng = $videoData['longitude'];

    // Décodage et sauvegarde dans /uploads/videos/
    $filename = $incidentId . '_video_' . time() . '_' . $index . '.mp4';

    // Insertion dans table videos_incident
    INSERT INTO videos_incident (
        incident_id, type, filepath, filename,
        latitude, longitude, filesize, mime_type
    ) VALUES (...)
}

Table videos_incident (serveur MySQL) :

• Colonnes principales : id, incident_id, type, filename, filepath, description
• Métadonnées : duration (secondes), filesize (octets), mime_type
• GPS : latitude, longitude (DECIMAL 10,8 et 11,8)
• Sécurité : encrypted (TINYINT), created_at (TIMESTAMP)
• Contrainte : FK incident_id → incidents(id) ON DELETE CASCADE
• Index : incident_id, type, encrypted, GPS (lat+lng)

Stockage serveur :

• Répertoire : /uploads/videos/
• Format fichier : 123_video_1735917234_0.mp4
• Format vidéo : MP4 (H.264 + AAC)
• Durée max : 5 secondes
• Taille max : 5 MB

Stockage

Upload Multipart

// Kotlin - Préparation upload
val file = File(photoPath)
val requestBody = file.asRequestBody(
    "image/jpeg".toMediaTypeOrNull()
)
val part = MultipartBody.Part.createFormData(
    "photo1",
    file.name,
    requestBody
)

Architecture Offline-First

Principe : L'application fonctionne d'abord en mode local, puis synchronise quand le réseau est disponible.

SyncIncidentsWorker

Déclenchement :

• Périodicité : 15 minutes
• Contrainte : Réseau disponible (CONNECTED)
• Backoff : Exponentiel si échec

Logique :

1. SELECT incidents WHERE syncStatus = PENDING
2. Pour chaque incident :
   • UPDATE syncStatus = SYNCING
   • Appel API avec photos
   • Si succès : syncStatus = SYNCED + serverId
   • Si échec : syncStatus = ERROR
3. Retourner Result.success() ou Result.retry()

Architecture de Chiffrement Implémentée

Données Chiffrées (Table citoyens)

Implémentation Technique

Classe EncryptionManager (PHP)

class EncryptionManager {
    private const SECRET_PATH = '/run/secrets/app_encryption_key';
    private const CIPHER_METHOD = 'aes-256-gcm';
    private const IV_LENGTH = 12;  // 96 bits
    private const TAG_LENGTH = 16; // 128 bits

    public function encrypt(?string $plaintext): ?string {
        if ($plaintext === null || $plaintext === '') {
            return null;
        }

        // Générer IV unique
        $iv = random_bytes(self::IV_LENGTH);
        $tag = '';

        // Chiffrer avec AES-256-GCM
        $ciphertext = openssl_encrypt(
            $plaintext,
            self::CIPHER_METHOD,
            $this->key,
            OPENSSL_RAW_DATA,
            $iv,
            $tag
        );

        // Retourner: base64(IV || ciphertext || tag)
        return base64_encode($iv . $ciphertext . $tag);
    }
}

Hook beforeSave (update_profile.php)

$encryption = EncryptionManager::getInstance();

// Chiffrer avant sauvegarde
$nomChiffre = $encryption->encrypt($nom);
$prenomChiffre = $encryption->encrypt($prenom);
$emailChiffre = $encryption->encrypt($email);
$telephoneChiffre = $encryption->encrypt($telephone);

// UPDATE avec données chiffrées
$db->execute(
    "UPDATE citoyens SET nom = ?, prenom = ?, email = ?, telephone = ? WHERE id = ?",
    [$nomChiffre, $prenomChiffre, $emailChiffre, $telephoneChiffre, $id]
);

Hook afterLoad (get_profile.php)

$encryption = EncryptionManager::getInstance();

// Récupérer depuis BDD (chiffré)
$citoyen = $db->fetchOne("SELECT * FROM citoyens WHERE device_id = ?", [$deviceId]);

// Déchiffrer après lecture
$nomDechiffre = $encryption->decrypt($citoyen['nom']);
$prenomDechiffre = $encryption->decrypt($citoyen['prenom']);
$emailDechiffre = $encryption->decrypt($citoyen['email']);
$telephoneDechiffre = $encryption->decrypt($citoyen['telephone']);

Stockage de la Clé

Configuration docker-compose.yml

services:
  web:
    volumes:
      - ./:/var/www/html
      - ./secrets/app_encryption_key:/run/secrets/app_encryption_key:ro

Architecture Mobile vs Dashboard

Android App
    ↓ (données en clair)
SharedPreferences (local, source de vérité)
    ↓ (sync via update_profile.php)
API Backend (chiffrement AES-256-GCM)
    ↓ (stockage)
Base de données MySQL (données chiffrées en TEXT)
    ↓ (lecture via get_profile.php)
Dashboard Web (déchiffrement automatique)

Documentation Complète

Pour plus d'informations sur le déploiement, la sécurité et le dépannage :

• 📄 README_ENCRYPTION.md - Guide complet de déploiement
• 📄 DEPLOYMENT_SUCCESS.md - Rapport de déploiement production
• 📄 migration_encrypt_citoyens.sql - Script de migration SQL
• 📄 EncryptionManager.php - Classe de chiffrement (src/)

Anonymat par Défaut

Principe : L'utilisateur est anonyme jusqu'à ce qu'il décide de renseigner ses informations.

Avantages

• ✅ Barrière d'entrée minimale (pas de compte obligatoire)
• ✅ Conformité RGPD (minimisation des données)
• ✅ Contrôle utilisateur sur son identité
• ✅ Persistance entre réinstallations (fingerprint stable)

Principes RGPD Appliqués

Droits des Utilisateurs

Setup Environnement

Prérequis :

• Android Studio Hedgehog (2023.1.1+)
• JDK 17
• Android SDK 34
• Émulateur Android 8.0+ (API 26)

Installation :

git clone <repo_url> UrbafixKotlin
cd UrbafixKotlin
./gradlew build

Commandes Utiles

Bonnes Pratiques

• ✓ Toujours passer par ViewModel → Repository → DAO
• ✓ Utiliser viewModelScope pour coroutines
• ✓ Dispatchers.IO pour base de données/réseau
• ✓ StateFlow pour exposer l'état UI
• ✓ Pattern sealed class pour états (Loading, Success, Error)
• ✓ Sauvegarder en local d'abord (offline-first)

Setup Local

cd /home/franck/AndroidStudioProjects/UrbaFix/www
composer install
cp config/database.example.php config/database.php

# Créer base de données
mysql -u root -p < database/schema.sql

Créer un Endpoint

1. Créer fichier www/mon_endpoint.php
2. Inclure Database.php et utilitaires nécessaires
3. Valider paramètres d'entrée
4. Utiliser requêtes préparées (PDO)
5. Retourner JSON avec header Content-Type: application/json
6. Gérer codes HTTP appropriés (200, 400, 404, 500)

Déploiement Android (Google Play)

1. Build release :

   ./gradlew clean assembleRelease

2. Signer APK :

   jarsigner -keystore urbafix-release.keystore app-release.apk

3. Upload : Google Play Console → Production
4. Review : Attendre validation (1-3 jours)

Déploiement Backend (Production)

Architecture :

• VPS OVH (Debian 12)
• Nginx + PHP 8.1-FPM
• MySQL 8.0
• Let's Encrypt SSL

Déploiement :

ssh root@urbafix.fr
cd /var/www/urbafix
git pull origin main
composer install --no-dev
systemctl restart php8.1-fpm nginx

Docker (Recommandé)

# Générer master key
openssl rand -base64 32 | docker secret create urbafix_master_key -

# Démarrer stack
docker-compose up -d

# Vérifier logs
docker-compose logs -f php

Docker Hardened Images (DHI)

État : En Évaluation

Docker Hardened Images sont des images sécurisées rendues gratuites depuis le 17 décembre 2025.

Authentification :

# Se connecter avec PAT Docker Hub
docker login dhi.io -u username -p YOUR_PAT

Disponibilité pour UrbaFix :

• ✓ PHP 8.2 : Disponible mais CLI uniquement (pas FPM)
• ✗ MariaDB : Non disponible dans le catalogue
• ✗ MySQL : Erreurs lors du pull

Images actuelles (Production) :

# Dockerfile
FROM php:8.2-fpm

# docker-compose.yml
db:
  image: mariadb:10.11
phpmyadmin:
  image: phpmyadmin:latest

Critères pour adoption DHI :

1. Disponibilité de dhi.io/php:8.2-fpm
2. Support de MariaDB ou MySQL stable
3. Tests de compatibilité réussis

Alternative sécurisée immédiate : Utiliser les variantes Alpine des images officielles pour réduire la surface d'attaque.

Ressources :

• Catalogue DHI
• Documentation officielle
• GitHub Catalog