Dans le monde des applications mobiles, l’exactitude de l’heure est cruciale pour diverses fonctionnalités, allant de la planification à la sécurité. Cependant, les utilisateurs peuvent modifier l’heure de l’appareil, rendant nécessaire une source d’information plus précise que l’heure locale du système. C’est pourquoi nous avons lancé l’API **TrustedTime** qui exploite l’infrastructure de Google pour fournir un horodatage fiable, indépendant des paramètres d’heure locaux potentiellement manipulés de l’appareil.
**Fonctionnement de TrustedTime**
La nouvelle API s’appuie sur l’infrastructure sécurisée de Google pour fournir une source d’heure fiable à votre application. **TrustedTime** synchronise périodiquement son horloge avec les **serveurs de Google**, qui ont accès à une source d’heure extrêmement précise, évitant ainsi de devoir effectuer une requête serveur à chaque fois que vous souhaitez connaître l’heure actuelle du réseau. De plus, nous avons intégré un modèle unique qui calcule la dérive de l’horloge de l’appareil. Cela vous indiquera quand l’heure peut être inexacte entre les synchronisations avec le réseau.
**Importance d’une source d’heure précise**
De nombreuses applications dépendent de l’horloge de l’appareil pour diverses fonctionnalités. Cependant, les utilisateurs peuvent modifier les paramètres d’heure de leur appareil, intentionnellement ou non, modifiant ainsi l’heure obtenue par votre application. Cela peut entraîner des problèmes tels que :
* **Incohérence des données :** Les applications qui reposent sur l’ordre chronologique des événements sont vulnérables à la corruption des données si les utilisateurs manipulent l’heure de l’appareil. **TrustedTime** atténue ce risque en fournissant une source horaire fiable.
* **Failles de sécurité :** Les mesures de sécurité basées sur le temps, telles que les mots de passe à usage unique ou les contrôles d’accès temporisés, nécessitent une source d’heure non altérée pour être efficaces.
* **Planification peu fiable :** Les applications qui dépendent d’une planification précise, comme les applications de calendrier ou de rappel, peuvent mal fonctionner si l’horloge de l’appareil (c’est-à-dire l’horodatage Unix) est incorrecte.
* **Heure inexacte :** L’horloge interne de l’appareil peut dériver en raison de divers facteurs, tels que la température, le mode économie d’énergie, le niveau de la batterie, etc. Cela peut entraîner des problèmes dans les applications qui nécessitent plus de précision. L’API **TrustedTime** fournit également l’erreur estimée avec les horodatages, afin que vous puissiez vous assurer que les opérations sensibles au temps de votre application sont effectuées correctement.
* **Absence de cohérence entre les appareils :** Une heure incohérente entre les appareils peut entraîner des problèmes dans les scénarios multi-appareils, tels que les jeux ou les applications collaboratives. L’API **TrustedTime** garantit que tous les appareils ont une vue cohérente de l’heure, améliorant ainsi l’expérience utilisateur.
* **Consommation inutile de puissance et de données :** **TrustedTime** est conçu pour être plus efficace que d’appeler un serveur NTP chaque fois qu’une application a besoin de l’heure actuelle. Il évite les frais généraux liés aux requêtes réseau répétées en synchronisant périodiquement son horloge avec les serveurs de temps. Cette heure synchronisée est ensuite utilisée comme point de référence, et l’API **TrustedTime** calcule l’heure actuelle en fonction de l’horloge interne de l’appareil. Cette approche réduit l’utilisation du réseau et améliore les performances des applications qui nécessitent des vérifications fréquentes de l’heure.
**Cas d’utilisation de TrustedTime**
L’API **TrustedTime** ouvre un large éventail de possibilités pour améliorer la fiabilité et la sécurité de vos applications, avec des cas d’utilisation dans des domaines tels que :
* **Applications financières :** Assurer l’exactitude des horodatages des transactions même lorsque l’appareil est hors ligne, évitant ainsi les fraudes et les litiges.
* **Jeux :** Mettre en œuvre le fair-play en empêchant les utilisateurs de manipuler l’horloge du jeu pour obtenir un avantage injuste.
* **Offres à durée limitée :** Garantir que les promotions et les offres expirent à l’heure correcte, quels que soient les paramètres de l’appareil de l’utilisateur.
* **Commerce électronique :** Suivre avec précision le traitement des commandes et les délais de livraison.
* **Licence de contenu :** Appliquer des restrictions temporelles au contenu numérique, comme les locations ou les abonnements.
* **Appareils IoT :** Synchroniser les horloges sur plusieurs appareils pour une consignation et un contrôle des données cohérents.
* **Applications de productivité :** Enregistrer avec précision l’heure de toute modification apportée aux documents cloud hors ligne.
**Prise en main de l’API TrustedTime**
L’API **TrustedTime** est basée sur les services Google Play, ce qui rend l’intégration transparente pour la plupart des développeurs Android.
La manière la plus simple de l’intégrer consiste à initialiser **TrustedTimeClient** au début du cycle de vie de votre application, par exemple dans la méthode **onCreate()** de votre classe Application. L’exemple suivant utilise **l’injection de dépendances** avec Hilt pour rendre le client de temps disponible pour les composants de l’application.
### **(Facultatif) Configuration de l’injection de dépendances**
« `kotlin
// TrustedTimeClientAccessor.kt
import com.google.android.gms.tasks.Task
import com.google.android.gms.time.TrustedTimeClient
interface TrustedTimeClientAccessor {
fun createClient(): Task
}
// TrustedTimeModule.kt
@Module
@InstallIn(SingletonComponent::class)
class TrustedTimeModule {
@Provides
fun provideTrustedTimeClientAccessor(
@ApplicationContext context: Context
): TrustedTimeClientAccessor {
return object : TrustedTimeClientAccessor {
override fun createClient(): Task
return TrustedTime.createClient(context)
}
}
}
}
« `
### **Initialisation au début du cycle de vie de votre application**
« `kotlin
// TrustedTimeDemoApplication.kt
@HiltAndroidApp
class TrustedTimeDemoApplication : Application() {
@Inject
lateinit var trustedTimeClientAccessor: TrustedTimeClientAccessor
var trustedTimeClient: TrustedTimeClient? = null
private set
override fun onCreate() {
super.onCreate()
trustedTimeClientAccessor.createClient().addOnCompleteListener { task ->
if (task.isSuccessful) {
// Cachez le client
trustedTimeClient = task.result
} else {
// Gérez l’erreur, peut-être réessayer plus tard
val exception = task.exception
}
}
// Pour utiliser la coroutine Kotlin, vous pouvez utiliser la méthode await(),
// consultez https://developers.google.com/android/guides/tasks#kotlin_coroutine pour plus d’informations.
}
}
REMARQUE : Si vous n’utilisez pas l**’injection de dépendances** dans votre application. Vous pouvez simplement appeler
`TrustedTime.createClient(context)` au lieu d’**utiliser** un TrustedTimeClientAccessor.
« `
### **Utilisation de TrustedTimeClient partout dans votre application**
« `kotlin
// Récupérez TrustedTimeClient depuis votre classe d’application
val myApp = applicationContext as TrustedTimeDemoApplication
// Dans cet exemple, System.currentTimeMillis() est utilisé comme solution de secours si le
// client est null (c’est-à-dire que la tâche de création du client a échoué) ou lorsqu’il n’y a pas de signal
// temporel disponible. Vous ne voudrez peut-être pas faire cela si l’utilisation de l’horloge système est
// inadaptée à votre cas d’utilisation.
val currentTimeMillis =
myApp.trustedTimeClient?.computeCurrentUnixEpochMillis()
?: System.currentTimeMillis()
// trustedTimeClient.computeCurrentInstant() peut être utilisé si Instant est
// préférable à long pour les horodatages d’époque Unix et que vous pouvez utiliser les API.
« `
### **Utilisation dans des composants éphémères comme Activity**
« `kotlin
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
@Inject
lateinit var trustedTimeAccessor: TrustedTimeAccessor
private var trustedTimeClient: TrustedTimeClient? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
…
trustedTimeAccessor.createClient().addOnCompleteListener { task ->
if (task.isSuccessful) {
// Cachez le client
trustedTimeClient = task.result
} else {
// Gérez l’erreur, peut-être
Source : Article original