/* Page prose (es) */
"TakingOverTheStateMachine" = "# Tomar el control de la máquina de estados\n\nUna `Operation` se mueve por una pequeña **máquina de estados**: `ready` → `executing` → `finished`.\n\n* **ready**: dependencias satisfechas, esperando su turno.\n* **executing**: ejecutándose actualmente.\n* **finished**: hecho (haya completado o haya sido cancelada).\n\nPara una operación normal, Foundation impulsa estas transiciones por ti y cambia a **finished** en cuanto `main()` retorna. Para el trabajo basado en callbacks, necesitas mantener la operación en **executing** hasta que el callback se dispare, así que tienes que impulsar las transiciones por tu cuenta.\n\nFoundation vigila tres propiedades de solo lectura (`isReady`, `isExecuting`, `isFinished`) usando **KVO** (Key-Value Observing), el mecanismo de Objective-C donde un objeto anuncia \"esta propiedad está a punto de cambiar / acaba de cambiar\" para que los observadores puedan reaccionar. Una `OperationQueue` observa `isFinished`; así es como se entera de que una operación está hecha y puede iniciar la siguiente dependiente. Así que cuando cambias estos estados a mano, debes **disparar las notificaciones de KVO** (`willChangeValue(forKey:)` antes, `didChangeValue(forKey:)` después) o la cola nunca se entera.\n\nHay una pieza más. Sobrescribes `isAsynchronous` para que devuelva `true`. Esa es tu promesa a Foundation: *\"no supongas que estoy terminada cuando `start()` retorna; vigila `isFinished`, yo la cambiaré yo misma.\"* Aquí tienes una pequeña clase base reutilizable que hace exactamente eso:";
"TakingOverTheStateMachine-2" = "Lee `start()` con atención. Si la operación fue cancelada antes de empezar, vamos directo a **finished** sin ejecutar `main()`. Si no, pasamos a **executing** y llamamos a `main()`, pero *no* terminamos aquí. La operación permanece en **executing** hasta que alguien llama a `finish()`, que la mueve a **finished** y dispara la notificación de KVO que la cola está esperando.\n\nAhora la subida se vuelve correcta. Una subclase sobrescribe `main()`, inicia el trabajo asíncrono, y llama a `finish()` desde el callback:";
"TakingOverTheStateMachine-3" = "**Míralo en acción:** ahora el orden es `⬆️ Uploading...`, luego un segundo después `✅ ... reached the print server`, y *solo entonces* `🎉 completionBlock`. La operación permaneció en **executing** todo el segundo, exactamente como debe ser. Si esta subida tuviera una operación dependiente, ahora esperaría a la finalización real, no a la prematura.\n\n* callout(Pruébalo): Comenta las llamadas a `self.finish()` en el callback y ejecuta: la línea `🎉 completionBlock` nunca aparece, porque la operación nunca sale de **executing**.\n\n> **La única regla que no puedes romper:** una operación asíncrona debe *siempre* llegar a **finished**, en todos los caminos: éxito *y* cancelación. Por eso la rama de cancelación de arriba también llama a `finish()`. Olvídalo y la operación se queda atascada en **executing** para siempre, atascando la cola detrás de ella como un atasco de papel que nunca se despeja.\n\n[Anterior](@previous)  |  página 5 de 7  |  [Siguiente: completionBlock, brevemente](@next)";
