Dentro de paquetes OTA

El sistema crea el binario del actualizador a partir de bootable/recovery/updater y lo utiliza en un paquete OTA.

El paquete en sí es un archivo .zip ( ota_update.zip , incremental_ota_update.zip ) que contiene el binario ejecutable META-INF/com/google/android/update-binary .

Updater contiene varias funciones integradas y un intérprete para un lenguaje de secuencias de comandos extensible ( edify ) que admite comandos para tareas típicas relacionadas con las actualizaciones. El actualizador busca en el archivo .zip del paquete un script en el archivo META-INF/com/google/android/updater-script .

Nota: El uso del script Edify y/o las funciones integradas no es una actividad común, pero puede resultar útil si necesita depurar el archivo de actualización.

Edificar la sintaxis

Un script de edición es una expresión única en la que todos los valores son cadenas. Las cadenas vacías son falsas en un contexto booleano y todas las demás cadenas son verdaderas . Edify admite los siguientes operadores (con los significados habituales):

(expr )
 expr + expr  # string concatenation, not integer addition
 expr == expr
 expr != expr
 expr && expr
 expr || expr
 ! expr
 if expr then expr endif
 if expr then expr else expr endif
 function_name(expr, expr,...)
 expr; expr

Cualquier cadena de caracteres az, AZ, 0-9, _, :, /, . que no es una palabra reservada se considera una cadena literal. (Las palabras reservadas son if else y endif. ) Las cadenas literales también pueden aparecer entre comillas dobles; Así es como se crean valores con espacios en blanco y otros caracteres que no están en el conjunto anterior. \n, \t, \", y \\ sirven como escapes dentro de cadenas entre comillas, al igual que \x ## .

El && y || los operadores están en cortocircuito; el lado derecho no se evalúa si el resultado lógico está determinado por el lado izquierdo. Los siguientes son equivalentes:

e1 && e2
if e1 then e2 endif

El ; el operador es un punto de secuencia; significa evaluar primero el lado izquierdo y luego el lado derecho. Su valor es el valor de la expresión del lado derecho. También puede aparecer un punto y coma después de una expresión, por lo que el efecto simula declaraciones de estilo C:

prepare();
do_other_thing("argument");
finish_up();

Funciones integradas

La mayor parte de la funcionalidad de actualización está contenida en las funciones disponibles para su ejecución mediante scripts. (Estrictamente hablando, estas son macros en lugar de funciones en el sentido de Lisp, ya que no necesitan evaluar todos sus argumentos). A menos que se indique lo contrario, las funciones devuelven verdadero en caso de éxito y falso en caso de error. Si desea que los errores anulen la ejecución del script, utilice las funciones abort() y/o assert() . El conjunto de funciones disponibles en el actualizador también se puede ampliar para proporcionar funcionalidades específicas del dispositivo .

abort([ msg ])
Anula la ejecución del script inmediatamente, con el mensaje opcional. Si el usuario ha activado la visualización de texto, aparece un mensaje en el registro de recuperación y en la pantalla.
assert( expr [, expr , ...])
Evalúa cada expr por turno. Si alguno es falso, cancela inmediatamente la ejecución con el mensaje "fallo de afirmación" y el texto fuente de la expresión fallida.
apply_patch( src_file , tgt_file , tgt_sha1 , tgt_size , patch1_sha1 , patch1_blob , [...])
Aplica un parche binario al src_file para producir el tgt_file . Si el destino deseado es el mismo que el origen, pase "-" para tgt_file . tgt_sha1 y tgt_size son el hash SHA1 final esperado y el tamaño del archivo de destino. Los argumentos restantes deben venir en pares: un hash SHA1 (una cadena hexadecimal de 40 caracteres) y un blob. El blob es el parche que se aplicará cuando el contenido actual del archivo fuente tenga el SHA1 dado.

El parche se realiza de una manera segura que garantiza que el archivo de destino tiene el hash y el tamaño SHA1 deseados o no se modifica: no quedará en un estado intermedio irrecuperable. Si el proceso se interrumpe durante la aplicación de parches, el archivo de destino puede estar en un estado intermedio; Existe una copia en la partición de caché, por lo que reiniciar la actualización puede actualizar el archivo correctamente.

Se admite una sintaxis especial para tratar el contenido de las particiones del dispositivo de tecnología de memoria (MTD) como archivos, lo que permite parchear particiones sin formato, como el arranque. Para leer una partición MTD, debe saber cuántos datos desea leer, ya que la partición no tiene una noción de fin de archivo. Puede utilizar la cadena "MTD: partición : tamaño_1 : sha1_1 : tamaño_2 : sha1_2 " como nombre de archivo para leer la partición dada. Debe especificar al menos un par (tamaño, sha-1) ; puede especificar más de uno si hay múltiples posibilidades para lo que espera leer.

apply_patch_check( filename , sha1 [, sha1 , ...])
Devuelve verdadero si el contenido del nombre de archivo o la copia temporal en la partición de caché (si está presente) tiene una suma de comprobación SHA1 igual a uno de los valores sha1 dados. Los valores sha1 se especifican como 40 dígitos hexadecimales. Esta función difiere de sha1_check(read_file( filename ), sha1 [, ...]) en que sabe verificar la copia de la partición de caché, por lo que apply_patch_check() tendrá éxito incluso si el archivo fue dañado por una apply_patch() update .
apply_patch_space( bytes )
Devuelve verdadero si hay al menos bytes de espacio disponible para aplicar parches binarios.
concat( expr [, expr , ...])
Evalúa cada expresión y las concatena. El operador + es azúcar sintáctico para esta función en el caso especial de dos argumentos (pero la forma de función puede tomar cualquier número de expresiones). Las expresiones deben ser cadenas; no puede concatenar blobs.
file_getprop( filename , key )
Lee el nombre de archivo dado, lo interpreta como un archivo de propiedades (por ejemplo, /system/build.prop ) y devuelve el valor de la clave dada o la cadena vacía si la clave no está presente.
format( fs_type , partition_type , location , fs_size , mount_point )
Reformatea una partición determinada. Tipos de partición admitidos:
  • fs_type="yaffs2" y partición_type="MTD". La ubicación debe ser el nombre de la partición MTD; Allí se construye un sistema de archivos yaffs2 vacío. Los argumentos restantes no se utilizan.
  • fs_type="ext4" y partición_type="EMMC". La ubicación debe ser el archivo del dispositivo para la partición. Allí se construye un sistema de archivos ext4 vacío. Si fs_size es cero, el sistema de archivos ocupa toda la partición. Si fs_size es un número positivo, el sistema de archivos toma los primeros fs_size bytes de la partición. Si fs_size es un número negativo, el sistema de archivos toma todo excepto el último |fs_size| bytes de la partición.
  • fs_type="f2fs" y partición_type="EMMC". La ubicación debe ser el archivo del dispositivo para la partición. fs_size debe ser un número no negativo. Si fs_size es cero, el sistema de archivos ocupa toda la partición. Si fs_size es un número positivo, el sistema de archivos toma los primeros fs_size bytes de la partición.
  • mount_point debería ser el futuro punto de montaje del sistema de archivos.
getprop( key )
Devuelve el valor de la clave de propiedad del sistema (o la cadena vacía, si no está definida). Los valores de las propiedades del sistema definidos por la partición de recuperación no son necesariamente los mismos que los del sistema principal. Esta función devuelve el valor en recuperación.
greater_than_int( a , b )
Devuelve verdadero si y sólo si (iff) a (interpretado como un número entero) es mayor que b (interpretado como un número entero).
ifelse( cond , e1 [, e2 ])
Evalúa cond , y si es verdadero evalúa y devuelve el valor de e1 , en caso contrario evalúa y devuelve e2 (si está presente). La construcción "if... else... then... endif" es simplemente azúcar sintáctico para esta función.
is_mounted( mount_point )
Devuelve verdadero si hay un sistema de archivos montado en mount_point .
is_substring( needle , haystack )
Devuelve verdadero si la aguja es una subcadena de pajar .
less_than_int( a , b )
Devuelve verdadero si a (interpretado como un número entero) es menor que b (interpretado como un número entero).
mount( fs_type , partition_type , name , mount_point )
Monta un sistema de archivos de fs_type en mount_point . tipo_partición debe ser uno de:
  • MTD . Nombre es el nombre de una partición MTD (por ejemplo, sistema, datos de usuario; consulte /proc/mtd en el dispositivo para obtener una lista completa).
  • EMMC.

La recuperación no monta ningún sistema de archivos de forma predeterminada (excepto la tarjeta SD si el usuario está realizando una instalación manual de un paquete desde la tarjeta SD); su script debe montar cualquier partición que necesite modificar.

package_extract_dir( package_dir , dest_dir )
Extrae todos los archivos del paquete debajo de package_dir y los escribe en el árbol correspondiente debajo de dest_dir . Todos los archivos existentes se sobrescriben.
package_extract_file( package_file [, dest_file ])
Extrae un único archivo_paquete del paquete de actualización y lo escribe en dest_file , sobrescribiendo los archivos existentes si es necesario. Sin el argumento dest_file , devuelve el contenido del archivo del paquete como un blob binario.
read_file( filename )
Lee el nombre del archivo y devuelve su contenido como un blob binario.
run_program( path [, arg , ...])
Ejecuta el binario en la ruta , pasando arg s. Devuelve el estado de salida del programa.
set_progress( frac )
Establece la posición del medidor de progreso dentro del fragmento definido por la llamada show_progress() más reciente. frac debe estar en el rango [0.0, 1.0]. El medidor de progreso nunca retrocede; los intentos de lograrlo son ignorados.
sha1_check( blob [, sha1 ])
El argumento blob es un blob del tipo devuelto por read_file() o la forma de un argumento de package_extract_file() . Sin argumentos sha1 , esta función devuelve el hash SHA1 del blob (como una cadena hexadecimal de 40 dígitos). Con uno o más argumentos sha1 , esta función devuelve el hash SHA1 si es igual a uno de los argumentos, o la cadena vacía si no es igual a ninguno de ellos.
show_progress( frac , secs )
Avanza el medidor de progreso sobre la siguiente fracción de su longitud durante los segundos segundos (debe ser un número entero). secs puede ser 0, en cuyo caso el medidor no avanza automáticamente sino mediante el uso de la función set_progress() definida anteriormente.
sleep( secs )
Duerme durante segundos (debe ser un número entero).
stdout( expr [, expr , ...])
Evalúa cada expresión y vuelca su valor a la salida estándar. Útil para depurar.
tune2fs( device [, arg , …])
Ajusta los argumentos de los parámetros ajustables en el dispositivo .
ui_print([ text , ...])
Concatena todos los argumentos de texto e imprime el resultado en la interfaz de usuario (donde será visible si el usuario ha activado la visualización de texto).
unmount( mount_point )
Desmonta el sistema de archivos montado en mount_point .
wipe_block_device( block_dev , len )
Limpia los len bytes del dispositivo de bloque dado block_dev .
wipe_cache()
Hace que la partición de caché se borre al final de una instalación exitosa.
write_raw_image( filename_or_blob , partition )
Escribe la imagen en filename_or_blob en la partición MTD. filename_or_blob puede ser una cadena que nombre un archivo local o un argumento con valor de blob que contenga los datos que se van a escribir. Para copiar un archivo del paquete OTA a una partición, use: write_raw_image(package_extract_file("zip_filename"), "partition_name");

Nota: Antes de Android 4.1, solo se aceptaban nombres de archivos, por lo que para lograr esto, primero era necesario descomprimir los datos en un archivo local temporal.