Sigue las prácticas recomendadas para el bloqueo de activación
Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
El uso de un bloqueo de activación puede afectar el rendimiento del dispositivo. Si necesitas usar un bloqueo de activación, es importante que lo hagas correctamente. En este documento, se describen algunas prácticas recomendadas que pueden ayudarte a evitar los errores comunes relacionados con los bloqueos de activación.
Asigna un nombre adecuado al bloqueo de activación
Te recomendamos que incluyas el nombre de tu paquete, clase o método en la etiqueta de bloqueo de activación. De esta manera, si se produce un error, será más fácil encontrar la ubicación en el código fuente donde se creó el bloqueo de activación. Estas son otras sugerencias:
No incluyas información de identificación personal (PII) en el nombre, como una dirección de correo electrónico. Si el dispositivo detecta PII en la etiqueta de bloqueo de activación, registra _UNKNOWN en lugar de la etiqueta que especificaste.
No obtengas el nombre de la clase o del método de forma programática, por ejemplo, llamando a getName(). Si intentas obtener el nombre de forma programática, es posible que herramientas como Proguard lo ofusquen. En su lugar, usa una cadena hard-coded.
No agregues un contador ni identificadores únicos a las etiquetas de bloqueo de activación. El código que crea un bloqueo de activación debe usar la misma etiqueta cada vez que se ejecuta.
Esta práctica permite que el sistema agregue el uso del bloqueo de activación de cada método.
Asegúrate de que tu app esté visible en primer plano
Mientras un bloqueo de activación está activo, el dispositivo usa energía. El usuario del dispositivo debe saber que esto está sucediendo. Por este motivo, si usas un bloqueo de activación, debes mostrarle al usuario alguna notificación.
En la práctica, esto significa que debes obtener y mantener el bloqueo de activación en un servicio en primer plano. Los servicios en primer plano deben mostrar una notificación.
Si un servicio en primer plano no es la opción adecuada para tu app, probablemente tampoco deberías usar un bloqueo de activación. Consulta la documentación de Cómo elegir la API adecuada para mantener el dispositivo activo para conocer otras formas de realizar tareas mientras tu app no está en primer plano.
Mantén la lógica simple
Asegúrate de que la lógica para adquirir y liberar los bloqueos de activación sea lo más simple posible. Cuando la lógica del bloqueo de activación se vincula a máquinas de estado complejo, tiempos de espera, grupos de ejecutores o eventos de devolución de llamada, cualquier error en dicha lógica, por pequeño que sea, puede hacer que el bloqueo de activación se mantenga más de lo esperado. Estos errores son difíciles de diagnosticar y depurar.
Verifica que el bloqueo de activación siempre se libere
Si usas un bloqueo de activación, debes asegurarte de que se libere correctamente cada bloqueo de activación que adquieras. No siempre es tan fácil como parece. Por ejemplo, el siguiente código tiene un problema:
Kotlin
@Throws(MyException::class)fundoSomethingAndRelease(){wakeLock.apply{acquire()doTheWork()// can potentially throw MyExceptionrelease()// does not run if an exception is thrown}}
Java
voiddoSomethingAndRelease()throwsMyException{wakeLock.acquire();doTheWork();// can potentially throw MyExceptionwakeLock.release();// does not run if an exception is thrown}
El problema aquí es que el método doTheWork() puede generar la excepción MyException. Si es así, el método doSomethingAndRelease() propaga la excepción hacia afuera y nunca llega a la llamada release(). El resultado es que el bloqueo de activación se adquiere, pero no se libera, lo cual es muy malo.
En el código corregido, doSomethingAndRelease() se asegura de liberar el bloqueo de activación incluso si se arroja una excepción:
El contenido y las muestras de código que aparecen en esta página están sujetas a las licencias que se describen en la Licencia de Contenido. Java y OpenJDK son marcas registradas de Oracle o sus afiliados.
Última actualización: 2025-08-27 (UTC)
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Falta la información que necesito","missingTheInformationINeed","thumb-down"],["Muy complicado o demasiados pasos","tooComplicatedTooManySteps","thumb-down"],["Desactualizado","outOfDate","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Problema con las muestras o los códigos","samplesCodeIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-08-27 (UTC)"],[],[],null,["Using a wake lock can impair device performance. If you need to use a wake\nlock, it's important to do it properly. This document covers some best practices\nthat can help you avoid common wake lock pitfalls.\n| **Note:** Creating and holding wake locks can have a dramatic impact on the device's battery life. You shouldn't use wake locks if there are any suitable alternatives. For other options, see the [Keep the device awake](/develop/background-work/background-tasks/awake) documentation. If you do need to use a wake lock, make sure to hold it for as short a time as possible.\n\nName the wake lock properly\n\nWe recommend including your package, class, or method name in the wakelock\ntag. That way, if an error occurs, it's easier to find the location in your\nsource code where the wake lock was created. Here are some additional tips:\n\n- Leave out any personally identifying information (PII) in the name, such as an email address. If the device detects PII in the wake lock tag, it logs `_UNKNOWN` instead of the tag you specified.\n- Don't get the class or method name programmatically, for example by calling `getName()`. If you try to get the name programmatically, it might get obfuscated by tools like Proguard. Instead use a hard-coded string.\n- Don't add a counter or unique identifiers to wake lock tags. The code that creates a wake lock should use the same tag every time it runs. This practice enables the system to aggregate each method's wake lock usage.\n\nMake sure your app is visible in the foreground\n\nWhile a wake lock is active, the device is using power. The device's user\nshould be aware that this is going on. For this reason, if you're using a\nwake lock, you should display some notification to the user.\nIn practice, this means you should get and hold the wakelock in a\n[foreground service](/develop/background-work/services/fgs). Foreground services are required to display\na notification.\n\nIf a foreground service isn't the right choice for your app,\nyou probably shouldn't be using a wake lock, either. See the\n[Choose the right API to keep the device awake](/develop/background-work/background-tasks/awake)\ndocumentation for other ways to do work while your app isn't in the foreground.\n\nKeep the logic simple\n\nMake sure the logic for acquiring and releasing wake locks is as simple as\npossible. When your wake lock logic is tied to complex state machines, timeouts,\nexecutor pools, or callback events, any subtle bug in that logic can cause the\nwake lock to be held longer than expected. These bugs are difficult to diagnose\nand debug.\n\nCheck that the wake lock is always released\n\nIf you use a wake lock, you must make sure that every wake lock you acquire\nis properly released. This isn't always as easy as it sounds. For example,\nthe following code has a problem: \n\nKotlin \n\n @Throws(MyException::class)\n fun doSomethingAndRelease() {\n wakeLock.apply {\n acquire()\n doTheWork() // can potentially throw MyException\n release() // does not run if an exception is thrown\n }\n }\n\nJava \n\n void doSomethingAndRelease() throws MyException {\n wakeLock.acquire();\n doTheWork(); // can potentially throw MyException\n wakeLock.release(); // does not run if an exception is thrown\n }\n\nThe problem here is that the method `doTheWork()` can throw the exception\n`MyException`. If it does, the `doSomethingAndRelease()` method propagates\nthe exception outward, and it never reaches the `release()` call. The result\nis that the wake lock is acquired but not released, which is very bad.\n\nIn the corrected code, `doSomethingAndRelease()` makes sure to release the\nwake lock even if an exception is thrown: \n\nKotlin \n\n @Throws(MyException::class)\n fun doSomethingAndRelease() {\n wakeLock.apply {\n try {\n acquire()\n doTheWork()\n } finally {\n release()\n }\n }\n }\n\nJava \n\n void doSomethingAndRelease() throws MyException {\n try {\n wakeLock.acquire();\n doTheWork();\n } finally {\n wakeLock.release();\n }\n }"]]