Aggiornamento over-the-air per dispositivi non A/B con partizioni dinamiche

Android 10 supporta le partizioni dinamiche, un sistema di partizione dello spazio utente che può creare, ridimensionare ed eliminare le partizioni durante gli aggiornamenti over-the-air (OTA).

In questa pagina viene descritto come i client OTA ridimensionano le partizioni dinamiche durante un aggiornamento dispositivi non A/B.

Per i dispositivi non A/B, viene applicato l'aggiornamento OTA per le partizioni dinamiche utilizzando updater all'interno del pacchetto di aggiornamento.

Aggiornare i dispositivi di lancio

Questa sezione si applica ai dispositivi non A/B che vengono lanciati con il supporto delle partizioni dinamiche. Questi dispositivi eseguono l'upgrade da Android 10 a release successive.

Generare pacchetti di aggiornamento

I pacchetti di aggiornamento OTA sono generati Script ota_from_target_files, situato in build/make/tools/releasetools. Per impostazione predefinita, lo script genera un pacchetto che aggiorna i system e vendor partizioni. Se sono presenti altre partizioni dinamiche, come product, product_services o odm, i relativi aggiornamenti devono essere generati nel codice specifico del dispositivo.

Per generare aggiornamenti, nel modulo Python esteso implementa FullOTA_GetBlockDifferences() e IncrementalOTA_GetBlockDifferences(). Queste due funzioni restituiscono un elenco di oggetti BlockDifference, ciascuno che descrive la patch di aggiornamento da applicare a una partizione. Le partizioni restituite da queste due funzioni non devono essere modificate manualmente o verificate altrove, ad esempio in *_InstallBegin() o *_InstallEnd().

Esempio di generazione di aggiornamenti: 

# device/yoyodyne/tardis/releasetools.py

import os
from common import BlockDifference, EmptyImage, GetUserImage

# The joined list of user image partitions of source and target builds.
# - Items should be added to the list if new dynamic partitions are added.
# - Items should not be removed from the list even if dynamic partitions are
#   deleted. When generating an incremental OTA package, this script needs to
#   know that an image is present in source build but not in target build.
USERIMAGE_PARTITIONS = [
    "product",
    "odm",
]

def GetUserImages(input_tmp, input_zip):
  return {partition: GetUserImage(partition, input_tmp, input_zip)
          for partition in USERIMAGE_PARTITIONS
          if os.path.exists(os.path.join(input_tmp,
                                         "IMAGES", partition + ".img"))}

def FullOTA_GetBlockDifferences(info):
  images = GetUserImages(info.input_tmp, info.input_zip)
  return [BlockDifference(partition, image)
          for partition, image in images.items()]

def IncrementalOTA_GetBlockDifferences(info):
  source_images = GetUserImages(info.source_tmp, info.source_zip)
  target_images = GetUserImages(info.target_tmp, info.target_zip)

  # Use EmptyImage() as a placeholder for partitions that will be deleted.
  for partition in source_images:
    target_images.setdefault(partition, EmptyImage())

  # Use source_images.get() because new partitions are not in source_images.
  return [BlockDifference(partition, target_image, source_images.get(partition))
          for partition, target_image in target_images.items()]

Aggiorna flusso

Dietro le quinte, vengono aggiunte all'edify le seguenti funzioni script:

  • unmap_partition(name)
    • Se la partizione è mappata, annulla la mappatura, altrimenti non fare nulla.
    • Restituisce la stringa t in caso di esito positivo o una stringa vuota in caso di esito negativo.
  • map_partition(name)
    • Mappa la partizione se non è già mappata.
    • Restituire il percorso assoluto del dispositivo a blocchi mappato una volta completata l'operazione. o una stringa vuota in caso di errore.
  • update_dynamic_partitions(op_list)
    • Applica l'elenco di operazioni specificato ai metadati della partizione dinamica. l'annullamento della mappatura delle partizioni, se necessario.
    • Restituisce t in caso di esito positivo o una stringa vuota in caso di esito negativo.

L'argomento op_list per update_dynamic_partitions rimanda a un file nel di aggiornamento del pacchetto. Ogni riga del file specifica un'operazione. Se presente operazione non riuscita, update_dynamic_partitions subito restituisce una stringa vuota. Le operazioni sono:

  • resize partition-name size
    • Annulla la mappatura della partizione, quindi ridimensionala in size.
  • remove partition_name
    • Annulla la mappatura della partizione, quindi rimuovila.
  • add partition-name group-name
    • Aggiungi una nuova partizione al gruppo specificato.
    • Interrompi se il gruppo non esiste o se la partizione esiste già.
  • move partition-name group-name
    • Sposta la partizione nel gruppo specificato.
    • Interrompi se il gruppo non esiste o la partizione non esiste.
  • add_group group-name maximum-size
    • Aggiungi un gruppo con il nome specificato e la dimensione massima.
    • Interrompi se il gruppo esiste già.
    • Un valore maximum_size pari a 0 indica che non sono presenti limiti di dimensioni. sulle partizioni del gruppo. Sono necessari test aggiuntivi per verificare che le partizioni del gruppo non superino lo spazio disponibile sul dispositivo.
  • resize_group group-name maximum-size
    • Ridimensiona il gruppo alla dimensione massima specificata.
    • Interrompi se il gruppo non esiste.
    • Un valore maximum_size pari a 0 indica che non esistono limiti di dimensione per le partizioni nel gruppo. Sono necessari test aggiuntivi per assicura che le partizioni del gruppo non superino di spazio disponibile sul dispositivo.
  • remove_group group-name
    • Rimuovere un gruppo.
    • Interrompi se nel gruppo sono presenti partizioni.
  • remove_all_groups
    • Annulla la mappatura di tutte le partizioni dal mapping dei dispositivi.
    • Rimuovi tutte le partizioni e i gruppi.

OTA incrementale

Gli aggiornamenti OTA incrementali utilizzano la seguente logica:

  1. Riduci le partizioni/elimina le partizioni/rimuovi le partizioni dal gruppo (in modo che ci sia spazio sufficiente per ridurre i gruppi)
  2. Riduci i gruppi (in modo che ci sia spazio sufficiente per espanderli)
  3. Fai crescere i gruppi (in modo da avere spazio sufficiente per crescere/aggiungere) partizioni)
  4. Far crescere le partizioni/aggiungere partizioni/spostare partizioni in un nuovo gruppo

In dettaglio, update-script viene generato con questa logica: 

for each shrinking partition:
    block_image_update(map_partition(name), …)

update_dynamic_partitions(op_list)

for each growing / adding partition:
    block_image_update(map_partition(name), …)

Il file op_list per Il valore update_dynamic_partitions viene generato con questo logica: 

for each deleting partition:
    remove
for each partition that changes groups:
    move to "default"
for each shrinking partition:
    resize
for each shrinking / removing group:
    resize_group / remove_group
for each growing / adding group:
    resize_group / add_group
for each adding partition:
    add
for each growing / adding partition:
    resize
for each partition that changes groups:
    move to target group

OTA completa

Gli aggiornamenti OTA completi utilizzano la seguente logica:

  1. Elimina tutti i gruppi e le partizioni esistenti
  2. Aggiungi gruppi
  3. Aggiungere partizioni

In dettaglio, update-script viene generato con questa logica: 

update_dynamic_partitions(op_list)

for each adding partition:
    block_image_update(map_partition(name), …)

Il file op_list per update_dynamic_partitions viene generato con questa logica: 

remove_all_groups
for each adding group:
    add_group
for each adding partition:
    add
for each adding partition:
    resize