Skip to content

OpenTasker v0.2.96

Latest

Choose a tag to compare

@SysAdminDoc SysAdminDoc released this 12 Nov 20:03
· 198 commits to master since this release

This is a big one, and most of it is about Tasker. Imports bring over a lot more now, like Variable Clear, Stop Task, a task handing a value back, Get Sunrise/Sunset Times and plugin steps that wait for their plugin. Tasker's built-in variables such as %TIME and %BATT fill in, and conditions follow Tasker's own pattern and math rules. Outside of imports, deleting takes one tap with Undo, profiles can read Health Connect, and sun contexts can wait for twilight. It's also the first release with an F-Droid build attached, and it's signed with the same key as every release since v0.2.93, so it installs straight over them.

Added

  • Replace Text has three new options. First match only replaces just the first match. Store matches in array empties the array you name, say %found, and puts each match in %found1, %found2 and so on. Only find matches leaves the text alone, so the step just collects them. Tasker's Search Replace with Store Matches In Array, One Match Only or Replace Matches off now imports as this step, where those used to be placeholders or lose the array with a note. Like Tasker, a step that fails still empties the array, whether the pattern is bad or blank or there are too many matches. A list Split Text kept under the same name goes too, so Join Text and For Each read the matches and not the old list. A Search Replace still comes in as a placeholder that says why when any of its switches comes from a variable. Ignore Case and Multi-Line from a variable used to come in switched off. It's also a placeholder when its Replace With reads an element of the array it fills, like [%found1], because Tasker fills that in after storing this step's matches.
  • A Variable Clear action unsets a variable, so it reads as never set again. Turn on Pattern matching and it clears every variable whose name matches, like %item* for a whole array or %stdout/%stderr for a list, globals included unless Local variables only is on. The list a step like Split Text keeps under a cleared name goes too, so %parts(#) reads 0 after clearing %parts. Leave the name empty to clear every local variable, and turn on Clear all variables to clear every global too, saved ones included. The name is read as written, so %which clears %which itself and not the variable it names. In a task run by another one, only that task's own copy goes, and the task that ran it keeps its value. A global it clears stays gone after the run. Tasker's Variable Clear imports as this step now, where clearing a pattern or everything used to be a placeholder, and exports write it back. A Variable Clear with Local Variables Only and no pattern used to be a placeholder for a global like %Kept. Tasker clears it there, since that switch only counts with a pattern, and the import does the same now.
  • A task run by another one can hand a value back. Give Stop a value, and the Run Task step that ran it stores that value in the variable named in its new "Store the returned value in" field. Only the task that ran it directly gets the value, a secret stays secret, and a task that ends without a value leaves the variable as it was. Turn on "Clear it before the task runs" and the variable is emptied once the task is found, so a task that returns nothing leaves it unset instead. Only the asking task's own copy is cleared, so a task further up keeps its value of that name. When the name is an array element like %item1, changing %item afterward leaves the outer task's array alone too. That's Tasker's Reset Return Variable, and it imports and exports both ways. A name there that isn't a variable, or one that comes out empty, fails the step before the task runs. The preview hands the value back too, but not when the run would fail the task it ran. Tasker's Return and Perform Task's Return Value Variable now import this way instead of with a note, and exports write them back. Return's Local Variable Passthrough doesn't come over, and neither do Perform Task's Limit Passthrough To and Allow Overwrite Variables. The import notes each one.
  • Play Sound, Say and Beep can play on the Ringer or Notifications stream as well as Music and Alarm. They use the ringer or notification volume and go quiet when the phone is on vibrate or silent, and Do Not Disturb can silence them too. Tasker's Play Ringtone usually plays on Notification, and an import keeps it there now, along with Ringer, where both used to come over on Music with a note. Exports write them back.
  • A Stop Task step stops another task while it runs. Tasker's Stop with a task named comes over as this step, where it used to be a placeholder, and exports write it back as Stop. Naming the task it's in ends that run right there, like a plain Stop, and its other copies stop too. A task that isn't running is fine, the step just moves on. When the stopped task was running as another task's sub-task, that step fails and says what stopped it. A run of the same task that's still waiting for its turn isn't stopped and starts once the slot frees up. The preview warns when the task can't be found and ends where a run would, and a step that names no task stays out of a Tasker export, since Tasker would read it back as a plain Stop.
  • New Resume Sound, Play/Pause, Rewind and Fast Forward steps send those media keys to the app that's playing or played last. Tasker's Media Control imports its Play, Toggle Pause, Rewind and Fast Forward commands as these steps, and they export back out as Media Control.
  • Tasker's Notify Sound imports as a notification with its title and text. Its sound, icon, number, priority and repeat settings don't come over, and the import says so.
  • Tasker's Delete File imports as the delete file step, and the delete file step exports back out as Delete File. Like Read File and Write File, its path is looked up inside OpenTasker's own folder. Shredding and Use Root don't come over, and the import says so when they were set.
  • Tasker's Turn On imports as the wake step, which turns the screen on through Shizuku. Its Block Time doesn't come over, and the import says so. The wake step exports back out as Turn On with Tasker's default Block Time.
  • Tasker's Stay On imports as a settings write to Android's stay on while plugged in setting, keeping the same mix of AC, USB and wireless power Tasker picked. A global setting needs secure settings access, which you grant once from a computer, and import review calls it out like every other settings write.
  • Tasker's Reboot imports as the reboot step when it's set to Normal, and the reboot step exports back out as Reboot. Recovery, Bootloader and Shutdown stay placeholders that name the mode, since this step only restarts the phone. It runs through Shizuku, and import review calls it out before the profile can be turned on.
  • Tasker's Array Set imports as Variable Split, which has a new Values field. Given Values, it splits that text instead of the variable's own value and clears the old items first, the way Array Set does, and with no splitter it splits on spaces and new lines. A Variable Split with Values exports back out as Array Set.
  • Tasker's Auto Brightness and Display AutoRotate import as the settings write step, switching the same system settings Tasker does. Off and on come over. Toggle stays a placeholder, since that step writes the value it's given and can't flip what's there. A Set value taken from a variable stays a placeholder too. Both need Modify system settings, which you grant from Setup, and import review calls them out like every other settings write. Tasker's Display Brightness leaves Auto Brightness alone, but the brightness step here turns it off to set a level, so an imported Display Brightness now says that.
  • Tasker's Get Clipboard imports as the clipboard read step, filling %cl_text like Tasker does. The HTML text, URI, image URI, MIME types and extras it also fills don't come over, and the import says so. On Android 10 and newer this app can only read the clipboard while it's open and in front, so a step that runs in the background fails with that reason. The clipboard read step exports back out as Get Clipboard too, with a warning when it reads into a name other than %cl_text, since Tasker always fills that one.
  • Tasker's Sound Mode imports as the ringer step now, and the ringer step exports back out as Sound Mode with Ignore DND ticked. Every mode carries over as it is. With Ignore DND off, Tasker puts Do Not Disturb back the way it was after changing the mode, which this app doesn't do, so the import says Do Not Disturb may change along with it. A mode taken from a variable stays a placeholder, since Tasker's holds a number and this step wants the mode's name.
  • Tasker's Variable Subtract imports as a real step now. Like Variable Add, it rounds a value like 2.5 to a whole number first and counts from 0 when the variable isn't set, and one that subtracts another variable or wraps around stays a placeholder that says so.
  • A Text Length action counts the characters in some text and stores the number. Tasker's Test Variable, whose one type is Length, now imports as this step instead of a placeholder, and exports back out as Test Variable. As in Tasker, the count is taken after variables are filled in, so a %name that was never set counts as the 5 characters it's written with, and so does one a Variable Clear unset.
  • A Set Wallpaper action changes the home screen, the lock screen or both to an image you pick with Browse. Two new templates put it on the At sunrise and At sunset presets, so the wallpaper can switch between a day image and a night image. They work from the latitude and longitude you type in and don't need location access.
  • Sun contexts can wait for twilight. The presets add civil, nautical and astronomical dawn and dusk, and the new Sun elevation setting takes any angle in degrees, like -4 for the blue hour. The Inspector and profile cards name the twilight. Far enough north in summer the sun never gets that low, and the context just doesn't fire that day.
  • Profiles can react to Health Connect. State contexts read steps and exercise minutes since midnight, the latest heart rate and sleep from sessions that ended in the last 24 hours, with presets like 10,000 steps today. A night that a watch and a phone app both logged counts once, minus the time the watch saw you awake. OpenTasker checks them in the background every 15 minutes, or less often if you set it on the context, and it only reads. Setup has a Read Health Connect row, which says so plainly on a phone that can't have Health Connect. When Health Connect refuses a reading, or reads fail twice in a row, the context stays off, inverted or not, and the Inspector says why.
  • Locale and Tasker plugin actions and the Plugin context have a Set up in the plugin button. It opens the plugin's own settings screen, hands back what you saved last time, and fills in the config JSON and description for you. It finds settings screens that skip Android's default category too, like Termux:Tasker's, and says why when it can't open one. A value that's still a variable, like {"int":"%count"}, reaches that screen as text rather than emptying the whole form.
  • Tasker imports bring over eight more actions: Variable Add, Variable Clear, Variable Section, Variable Search Replace, Interrupt Mode, Return, Send Intent and In-Call Volume. Search Replace and Variable Add were among the most common placeholders in real exports. Anything one of them can't do here, like clearing one key of a JSON variable or sending an intent to a file:// URI, stays a placeholder that says why, and so does a Variable Add that wraps around. A Search Replace whose pattern anchors on $ comes in with a warning, unless Multi-Line or an inline (?m) already covers that $, since Tasker's $ also matches just before a final line break and OpenTasker's only matches at the very end, so a pattern for the last number in a command's output can come up empty. Going the other way, a Tasker export now writes every volume stream as Tasker's matching volume action, where only media volume used to make it across.
  • Tasker exports carry HTTP requests as Tasker's HTTP Request, the older HTTP Get and HTTP Post actions included. They used to be left out of the file. Headers, query and body go out redacted like every sensitive value in an export, so you fill them in again in Tasker. The export also says what Tasker can't hold, like a request that should only go over Wi-Fi, or a response variable other than Tasker's own %http_data.
  • Tasker's arrays work. Variable Split, Variable Join, Array Push, Array Pop, Array Clear and Array Process come over from Tasker imports as real steps, and they keep the items in %arr1, %arr2 and so on, the way Tasker does. Array Process has all 14 of Tasker's operations. Its number sorts go by the first number in each item, so b5, a3c and 1x come out as 1x, a3c, b5, and items with no number go last. Steps read them the Tasker way too: %arr(#) counts the items, %arr(<) is the last one, %arr(2:4) joins a range with commas and %arr(%i) reads the item at %i. A For loop over the array's name goes through its items. Variable Split was the most common placeholder left in real exports, and across the exports we test against the placeholders went from 989 to 799. An array named through another variable, like %%list, still comes in as a placeholder. If a Push or Pop takes its position from a variable that isn't set, the step stops with an error instead of using the first item without saying so (Preflight warns about it, and marks the step blocked when it's a global like %Pos that nothing in your tasks could set first), and %arr(%i) is empty while %i isn't set (so is %arr(%a:%b) while either end is unset). When a step pops or clears a global array like %Log, the removed items stay gone after the task ends. Exports write all six back as Tasker's own actions.
  • A Time context's start or end can be a global, like %Sunrise to %Sunset. That's how Tasker's own sunrise and sunset profiles work: one task saves the times in globals, and the Time context reads them. The window moves once the task that changes the global finishes, since that's when OpenTasker saves globals. A global can hold a time like 6.42 or 18:05, or seconds since 1970, of which only the hour and minute count. When it holds anything else the context stays off, same as Tasker. An inverted one stays off then too, since an unset %Sunrise doesn't make "not daytime" true. If the globals can't be read for a moment, the context keeps the times it read last and tries again shortly, waiting longer while the failures keep coming. Tasker imports and exports keep these windows, and the Inspector checks them against the globals' current values, shows the times it read and names any global that holds none. The editor and the Inspector flag a local like %sunrise and a bound that isn't a variable name at all (%1x), each with its own note. A simulation takes such a start as 6:00 and an end as 18:00, and says so.
  • Variable Convert comes over from Tasker imports as a real step, with all 32 of Tasker's conversions. That covers bytes to kilobytes, megabytes or gigabytes, seconds to a date and a date back to seconds, Celsius and Fahrenheit, inches, feet, pounds and miles, URL and Base64 encoding, binary and hex, MD5 and SHA-1, case changes, HTML to text and JSON encoding. They round the way Tasker's do, so 1572864 bytes is 1.5 megabytes. The result can replace the variable's value or go into another variable, and it stays hidden when the value it came from is a secret. A value the conversion can't read stops the step with an error. One thing differs on purpose: 12.30 am reads as half past midnight, where Tasker reads it as half past noon. A Convert of an array item like %list(2) stays a placeholder, and so does one whose conversion is picked by a variable. That leaves 2 of the 30 Variable Convert steps in the exports we test against as placeholders. Exports write it back as Tasker's own action.
  • A Beep action plays a tone at the pitch, length and loudness you set, on the music, alarm, ringer or notification stream. Tasker's Beep comes over from imports sounding the same. Tasker plays a quarter of the frequency it's given, so its 1852 arrives here as 463 Hz, and exports multiply it back. A Beep set to wait for Tasker's Do At Time comes in beeping right away, with a note saying so. One whose stream comes from a variable beeps on Music, and the import note names that variable. An export warns about a Beep pitch outside the 0 to 10000 Hz it can play.
  • Go To and Anchor actions. Go To jumps to a step number, which can come from a variable like %step, or to the first step with a given label, and the label wins when both are set. Anchor does nothing, so it's a place to hang a label. With a condition on it, a Go To back up the task makes a loop. Jumping out of a For or a Try ends it, and jumping back onto a For starts it over from its first item. A Go To that can't land (no step with that label, a number past the end, a variable that's empty, or a jump into the middle of a For or Try that isn't running) stops the task with an error saying which. Its Jump to choice can also send it to the top of the For Each it's in, which moves on to the next item the way Tasker's Top of Loop does, out of that loop, or to the End If of the If it's in. Those act on the innermost loop or If around the step and win over a number or label, and one with no loop or If around it stops the task. Preflight follows the jump and blocks the same ones, except that it stops following, with a note, when the target is a variable it has no value for yet. Tasker imports bring over every kind of Goto, along with Anchor and each step's label, so a labeled Goto still finds its spot. Exports write them back and fix the numbers for steps Tasker doesn't get, with a warning when a jump lands on one of those. An Anchor saved with the name it shows keeps that as its label, so a Go To to Anchor finds it. A step number or label that comes from a secret stays hidden in the error and in Preflight.
  • For Each can loop over a list of values instead of an array, written the way Tasker's For takes them: plain values like apple,pear, ranges like 1:10, 4:0 or 0:8:2, a variable like %fruit, a range with a variable end like 1:%arr(#), and array parts like %arr() or %arr(2:4). Variables are filled in and then the list is split on commas, so a variable holding a,b gives two items, while a whole %arr() keeps each of its items as they are (and gives nothing when there's no such array). The variable chips work here too, and they add their reference as one more item after a comma. The list is read once, when the loop starts. Tasker reads it again on every pass, which only matters when the loop changes what it reads. A named array wins over the values, and a range counting in steps of 0 or with a number over 15 digits stops the task with an error. A loop variable made from a secret stays hidden in the Run Log and in Preflight, which loops over the same items. The editor asks for an array or values when a For Each has neither. Tasker imports bring For over a range or a written-out list across as these values, where they used to need a whole array, so a task imported before this with a For like that needs importing again. Exports write the values back, with a chip's array or variable written the way Tasker does (%names(), %count), and warn about any other {{ }} part since Tasker's For won't fill it in.
  • A step can be turned off without deleting it. Its menu on the task screen has Turn off and Turn on, and a step that's off is dimmed with a line saying runs skip it. A run passes over it and the Run Log says why, Preflight shows it as skipped, and it keeps its number, so a Go To by number still lands where it did. Tasker imports bring a step switched off in Tasker over switched off, where it used to run. A switched-off Stop used to end the task early, and a switched-off step this app can't do kept the whole task from running and its profile from being turned on. An If, Else or End If that's off no longer opens or closes a block, so the steps inside it run every time, like in Tasker. Setup, lint and an imported profile's review leave out what only a step that's off would need, and it doesn't keep a Try from retrying. Run this action still runs a step that's off, since you asked for it. Exports mark those steps off for Tasker too.
  • Profile Status action. It turns a profile on or off by name, or flips it, and the name can come from a variable. A name matches exactly first and then ignoring case, and two profiles with the same name make it stop with an error instead of picking one. It won't turn on a profile the app itself wouldn't turn on from the profile list. That covers one still waiting for its review, one whose tasks call each other in a loop, one that would fight an active profile of the same priority over a setting, and one that changes system settings before OpenTasker is allowed to. An imported profile's review lists the action under device control. Tasker's Profile Status comes over as this action, where it used to be a placeholder, and exports write it back. A Set field held in a Tasker variable still comes over as a placeholder.
  • Tasker plugin steps come over from imports as plugin steps. That covers 176 steps from 25 plugins in the exports we test against, AutoInput, Kustom and Auto.js among them. Each one keeps its settings with their types, its description and how long Tasker waits for the plugin to finish. A setting OpenTasker can't send (a nested bundle, say, or a number that isn't finite, or one past the size limit) leaves the step a placeholder that names it. So does Tasker's Keyboard action, which isn't a plugin.
  • Plugin steps wait for the plugin to finish and get back what it sets, the way Tasker does. Termux:Tasker's %stdout and %stderr land in the task, and a plugin that reports a failure fails the step with its %errmsg and puts its code in %err. Plugins that refused to run without this, like iBeacon Tasker, work now. The timeout field is how long to wait, from 0 (send it and go on) up to 30 minutes, and a plugin that asks for a longer wait on its settings screen fills it in. A step left at 5 seconds that runs a longer Termux command now fails with a timeout instead of passing before the command finished, so give those a longer timeout.
  • Tasker's built-in variables fill in. The clock ones come out the way Tasker writes them, so %TIME is 09.05 and %DATE is 7-4-25 in the US, and %TIMES, %TIMEMS, %DAYW and %DAYM work too. The device ones are %BATT, %SCREEN, %BRIGHT, %DTOUT, %UPS, %SDK, %DEVID, %DEVMAN, %DEVMOD and %DEVPROD, plus each stream's volume level in %VOLA, %VOLC, %VOLD, %VOLM, %VOLN, %VOLR and %VOLS. With location permission, %LOC and %LOCN give the GPS and network providers' last fix as latitude,longitude. %PACTIVE, %PENABLED and %TRUN list the active profiles, the enabled ones and the running tasks the way Tasker does (,Home,Car,), and stay unset when the list is empty. %TRUN includes a task another task runs once it's allowed to start, and renaming a profile shows up in the lists right away. A profile held back by a higher priority one that you then edit leaves %PACTIVE until it matches again. A profile or task Tasker left unnamed gets a name on import, so it shows up in those lists where Tasker would skip it. Conditions, {{ TIME }} templates and the preview read them, and a Variable Split of %TIME on . gives the hour and the minute. Tasker won't let a task set one of these, but OpenTasker always has, so a value you set under one of their names still wins until you set it to nothing, and Preflight warns about the step that sets it. Built-ins this app doesn't fill in yet, like %LIGHT and %LOCSPD, stay as written, and a Tasker import names them for each task that reads one, unless a step in that task sets it first, the way HTTP Request sets %HTTPD. In the 48 exports we test against, 79 of 562 tasks read a built-in. Of those, 63 only read ones that fill in now, 9 get the import note, and the other 7 set the built-in they read themselves.
  • A Get Sunrise/Sunset Times action fills %ss_sunrise, %ss_sunset, %ss_solar_noon and the civil, nautical and astronomical dawn and dusk, each in seconds like %TIMES, plus %ss_sunlight_duration in minutes and %ss_day_or_night. Give it sun elevations, one per line or split by commas, and %ss_custom_morning and %ss_custom_evening list when the sun passes each one. The times are worked out the way Tasker 6.7.8 does it, down to the minute it rounds to. Leave the latitude or longitude blank and it uses the phone's location, which needs location access, and leave the time blank for today. A variable prefix other than ss renames every output. Tasker's Get Sunrise/Sunset Times imports as this action and exports back out, with a warning when the prefix isn't ss, since Tasker always fills %ss_. Day or night is the one value that can come out different. Tasker drops part of the day when it works that one out, so it can call noon in Sydney night, and this app doesn't.

Changed

  • Deleting a task, profile, scene or variable happens on the first tap now, with Undo in the message that pops up. There's no "Delete task?" dialog first. A task that a profile, another task or a scene still uses still opens the dialog that asks whether to point those at another task or clear them, and deleting a project still asks where its items should go.
  • Undo in that message just puts things back, and so does the Undo you get after removing a step, a context or a scene element, or turning a step off or on. The "Review what actually changed" dialog still comes up for Undo and Redo picked from the menu on a task, profile or scene.
  • A quick double tap on Delete in the scene list, a scene's elements, a profile's contexts, the variable list or "Settings to warn about", or on Revoke under "Locale execution grants", takes out one item now. Before, the second tap also took the row that slid up into its place.
  • If whatever used a task stops using it while the "point those at another task or clear them" dialog is open, the task still gets deleted. It used to close the dialog and leave the task there.
  • A Tasker step that stays a placeholder on purpose now says why in its import note. Scene steps say scenes aren't imported. Java steps say imported code doesn't run here. The others name what's missing, like the JavaScript engine or the camera. Run Shell points to saving the command as a script you approve and running it with Run Shizuku Script. Button and Back Button say there's no step that presses those keys, Wait Until says the wait step only waits a set time, and Ask Permissions points to Setup. Disable, Set Tasker Pref and Set Tasker Icon each say they change Tasker itself. Lots more now name what's missing too, like Popup, Menu, Call, Set Alarm and SQL Query. Get Location points to the location condition, and List Files says the list files step here puts file names in one variable rather than an array of paths. Simple Match/Regex and Parse/Format DateTime name the variables Tasker fills. Get Battery Info points to %BATT, and Turn Off points to the screen off and lock steps.
  • A variable with no value now stays as written, the way it does in Tasker. Battery %BATT used to come out as Battery and now reads Battery %BATT until something sets it, and a link with %C3%A9 in it keeps its escapes instead of losing them. Is Set and Isn't Set still ask whether there's a value, so they work as before. Comparisons change, though. %par1 ~ %* is true when a task was called without %par1, which is how Tasker tasks check for that, and a Perform Task that passes an unset %where hands on %where. %a != %b is now true while both are unset, and %x ~ * matches an unset %x. If one of your tasks counted on getting a blank, an Is Set check does that job. {{ }} templates still come out empty when there's no value. An Array Push or Pop position written as an unset variable still stops the step with the same message, and so does a Go To with nothing else to jump to (one that also has a step number goes to that step). The preview of a task that calls another now gives the called task its inputs, so a %par1 check there comes out the way it does in a run. Tasker's own variables this app doesn't fill in yet, like %LIGHT, show as written too. Across the 48 Tasker exports we test against, 176 of 562 tasks read a local variable that no earlier step in the task sets (plugins and profile events set some of those), 52 read %par1 or %par2, 71 read a Tasker variable or global that nothing in the export sets, and at least 90 conditions use Is Set or Isn't Set.
  • Matches and Doesn't Match conditions (~ and !~) follow Tasker's pattern rules. A / separates choices, so %SSID ~ home/work matches either one. A + stands for one or more characters, a ! at the very start turns the answer around (%app ~ !*chrome*), and a pattern with no capital letter ignores case, so %WIFI ~ on matches On too. Before this, * was the only special character and case always counted. A / meant as a real slash, like in a folder path, now splits the pattern in two, just as it does in Tasker, and an empty pattern matches nothing. Of the 173 Matches and Doesn't Match conditions that come over from the 48 exports we test against, 69 have an all-lowercase pattern and none uses / or +. Tasker's Matches Regex and Doesn't Match Regex now come over as their own ~R and !~R conditions, where they used to become a plain ~ with a note, and a ~ pattern that starts with ~R is a regex too, as in Tasker. A regex only has to match part of the value. One that uses lookahead or a backreference never matches here, and the import says so. All 16 regex conditions that come over from those exports run as they are, and exports write them back as Tasker's own.
  • Room moves to 2.8.5, WorkManager to 2.12.0, the Compose BOM to 2026.09.00, core-ktx to 1.19.1 and androidx.transition to 1.7.2. Macrobenchmark and the baseline-profile plugin drop the last pre-release in the graph for 1.5.0, JaCoCo moves to 0.8.16, and Bouncy Castle, which only the tests use, goes to 1.86. The APK no longer packages work-runtime-ktx, an empty artifact since WorkManager 2.9.0 moved its Kotlin extensions into work-runtime.
  • androidx.tracing moves from 1.3.0 to 2.0.5. Nothing here calls it directly, but WorkManager, Activity, core and Startup do, and every 1.3.0 call they make is still there in 2.0.5. It brings androidx.collection 1.6.0 along with it.
  • SQLCipher moves from 4.18.0 to 4.20.0, which puts the encrypted database on SQLite 3.54.1.
  • The Android Gradle Plugin moves from 9.3.2 to 9.5.1.
  • The Gradle wrapper moves from 9.7.1 to 9.9.1. That picks up Gradle's fixes for three high-severity advisories on the build machine, two where the daemon could deserialize untrusted data (GHSA-xwqc-3h47-hg64, GHSA-mvvg-497x-hmj8) and one where Gradle kept using a repository after its TLS handshake failed (GHSA-j5m7-59rp-24f5).
  • Releases are set up for F-Droid's reproducible builds (#29). Each one now attaches OpenTasker-v<version>-fdroid.apk, the F-Droid build signed with the same key as the regular APK. F-Droid can rebuild it from source, check that its copy matches byte for byte and ship our signed file, so moving between F-Droid, GitHub and Obtainium won't take an uninstall.
  • Release APKs no longer carry the Git commit they were built from or Google's encrypted dependency list. Native libraries go in exactly as their libraries ship them instead of being stripped by whatever NDK the build machine has, and the release baseline profile is now part of the source. Any one of these made a build from source come out different from ours.
  • The public keys that sign our dependencies now live in gradle/verification-keyring.keys. A fresh machine used to download them from public keyservers, which don't reliably have them (Error Prone's never came back), and the build stopped before compiling anything.

Security

  • Other apps can't fake an NFC tap anymore. Tags now come in through an entry only Android's NFC service is allowed to open, and OpenTasker ignores a tag handed to it any other way. Before this, any installed app could fire your NFC profiles or finish an armed tag write without a tag. Turning the phone or reopening OpenTasker from Recents also no longer runs the last tag's profile a second time.
  • OpenTasker remembers the signing key of Termux and of each Locale plugin the first time it sends them anything, and stops sending to one that's been reinstalled under the same name with a different key. Before this, an app swapped in under Termux's package name would have received your approved script commands. Setup lists an app whose key changed with a Re-approve button for when you meant to switch builds, and Diagnostics lists every pinned app. Apps you already use get pinned on their next run, so nothing changes for one that stays the same, and a key rotated the official Android way keeps working.
  • A Locale plugin condition set to one of a profile's contexts stops answering when Undo, Redo or a backup restore puts a different context in that spot. It used to go on answering for whichever context landed there. Saving a profile already ended those conditions, all of them at once, and now it only ends the ones whose context moved, changed or went away, so adding a context at the end leaves the rest working.
  • Send Intent's extras can't be added to by a variable anymore. The field was filled in as one block of text and then split into lines, so a notification title holding a line break could add an extra you never wrote, like evil=bool:true. Each line you wrote now fills in on its own, and if a variable puts a line break into one, the step stops and says so. Preflight blocks that step too.
  • HTTP Request's headers and query get the same protection. A variable with a line break in it could add a header the step never had, like an Authorization line, or an extra query parameter. Now the step stops instead, in a run and in Preflight. The older HTTP Get and HTTP Post steps are covered as well, and so is Download, which sends its headers and query the same way.
  • A plugin step's settings can't be changed by a variable anymore. They were filled in as one block of JSON, so a variable holding a quote could break the settings or add one the step never had. Each value now fills in on its own, as plain text, so one that happens to start like a condition, (a) ? b : c, goes out as written. A value written without quotes, like {"count": %COUNT}, gets a number, true or false when the variable holds one, and plain text otherwise. Tasker's own entries, like the list of variables a plugin sets, never get filled in. A plugin that names the settings it wants filled in, through Tasker's VARIABLE_REPLACE_KEYS, only gets those, the way Tasker does it, and setting names stay as you wrote them. Preflight fills them in the same way. Settings that only turn into JSON once a variable fills in, like a whole set of settings kept in one variable, don't get filled in anymore, and Preflight says so. A plugin step whose settings nest thousands of levels deep now stops with a message instead of crashing.
  • JSON nested thousands of levels deep can't crash a task anymore. A template reading a JSON path, %json.path, Set Variable writing into one, Read Data, Home Assistant Webhook, UnifiedPush messages and the update check now count how deep it goes first and refuse it past a limit real data never gets near. Set Variable into a path of a variable like that fails and leaves the variable alone instead of replacing it. A MacroDroid or OpenTasker import with a value right after a closing bracket, like [0][0], is refused before it's read, since that shape got past the depth limit, and so is a MacroDroid import that tried to hide its depth behind //.
  • A Locale plugin's answer can't get OpenTasker to build one of its own classes anymore. The variables a plugin sends back and the settings it saves are read so only Android's own types can load. A variable OpenTasker can't read is named in the run log and the plugin's result stands. On Android 13 and newer the rest of its variables still come through, while older versions read them all at once and drop the whole set. A plugin setup that hands back a setting OpenTasker can't read is refused. Before, one value like that turned the plugin's OK into a failure with nothing returned, and a value nested deep enough could crash the app.
  • The same goes for the other places another app hands OpenTasker data, like a broadcast or push your profile listens for, a share, a Locale condition check or plugin query, a Locale host firing a task, the automation commands and Termux's script results. Their extras are read so only Android's own types can load, and a real sender never needs more than that. On Android 13 and newer only the extra that can't be read is lost. When that's the shared text or file itself, or a value inside a Locale plugin's settings, the share or query is ignored. Older versions read every extra at once, so there a broadcast still fires without its extras and the rest are ignored. A Termux result that can't be read now times out like one that never came, where before it could crash the app.
  • A Locale condition on a variable now answers only the comparison you set up. The saved settings live in the host app, and one that rewrote them could change the operator or the expected value and work out what the variable holds, one guess at a time.
  • Local database backups and crash logs stay out of device-to-device transfers. A backup is sealed with a key that never leaves the old phone, so the copy could never open, and a crash log is written before redaction.
  • Logs and exports hide more credentials. Only a bare password= or token: was caught, so api_key=, access_token:, client_secret= and the quoted fields of a JSON reply reached exported run logs in the clear.
  • A value can't change what a condition asks anymore. An If or a loop that compared %sms_body had the message pasted in before the condition was read, so a text reading true || could turn false into true, and one that named another variable could read it. Conditions are split into their parts first now and each side is filled in after that, and the run preview agrees with the real run on these. Two small changes come with it: %empty != word is true when the variable is empty, and a variable on its own works as a ternary's condition.

Fixed

  • Join Text with its array written as %parts joins that array now. The name used to be filled in first, so after Split Text it looked for an array named after the first part, and after a Variable Split one named after the split text, and joined nothing. If a task picked the array through another variable, with %which holding parts, write {{ which }} instead.
  • Variable Split and Array Clear drop a list Split Text kept under the same name. It used to hide the new elements, so after Split Text into %parts and a Variable Split of %parts, Join Text and For Each still saw the old parts.
  • A step set to carry on after an error, inside a Try with no Catch, no longer makes the End Try fail. The Try now stays open until its End Try, so the steps after it run. The same goes for a step like that inside a Catch, when the Try around it has no Catch of its own.
  • The task preview now fills in %FLOW_ERROR_CAUGHT like a run. It reads "true" once a Catch takes a failure and "false" after a failure nothing catches, so a step that checks it shows the right branch.
  • The task preview now follows Try and Catch the way a run does. It used to play the Catch steps even when nothing in the Try failed, and after a step that would fail it kept going through the rest of the Try instead of moving to Catch. A failure inside the Catch steps, or inside a Try that has no Catch, now shows up as one the task doesn't get past.
  • A task that got stopped just as it finished, by the stop button, an Abort existing run or a Stop Task step, could lose its Run Log entry and the globals it changed, and stay unfinished in the execution journal. A stop that comes too late now leaves the finished run alone, and it's logged like any other. A stop that reaches the task while it's still working through its steps ends it the same as before.
  • A Tasker export could write a Perform Task or Stop that names its task by number, like 12, and Tasker then looked for a task called 12. A step names its task by number once the task it calls is renamed, or once the task it called was deleted and its steps were pointed at another one. Exports now write that task's name. A number that doesn't match a task in the export stays as it is, and the export warns about it and names the task the step is in. A Tasker import also keeps a call to a task named with a number, like 5, on that task, where it could land on whichever task had that number as its id.
  • A plugin condition in a profile was asked without the description its setup saved, so a plugin that tells its conditions apart by that text, like primitive FTPd's server running check, never answered. It's sent now. A plugin that asks to be checked again is also asked as soon as any check already under way is done, where its profile used to wait for the next 30 second poll, and one that keeps asking is checked at most once a second. primitive FTPd names its settings screen under a different key in that request than most plugins use, and that key is read too, so its profile catches up right after the server starts or stops.
  • The clipboard read step came back empty instead of failing when OpenTasker was on screen but another window had the focus, like the other app in split screen or the pulled-down notification shade. Android only shares the clipboard with the focused app, so when it comes back empty and no OpenTasker screen has the focus, the step now fails and says so. It fails the same way while one of OpenTasker's own dialogs is open, since an empty clipboard and a hidden one look alike from there.
  • A Tasker Variable Add imported from now on rounds a value like 2.5 to a whole number before it adds, the way Tasker does. It used to add to the decimal as it was, so 2.5 plus 1 came out 3.5 here and 4 in Tasker. Tasks imported earlier keep adding to the decimal until they're imported again.
  • The round template function stopped a whole task when the value was the text "NaN". It leaves the value empty now, like the other number functions do, and so does a value too big to be a number, like Infinity, which used to come out as 9223372036854775807. The older %x(/round) form left the whole text it was in unfilled when the value was NaN, other variables included. It gives back NaN now, the way %x(+1) does.
  • A Tasker "If" or "Run only if" that used Is Even or Is Odd was dropped on import. Now those come in as is_even and is_odd, which also work in conditions you write yourself, and export writes them back out as Tasker's. As in Tasker, a value that's empty or isn't a number is neither, and 2.5 counts as odd. Tasker also works the value out as math first, so %ind+1 or an unset variable (which it reads as 0) still gets an answer there. Here the value has to be a plain number already, the same as the other number checks, so both of those are neither.
  • A Tasker "If" or "Run only if" with several conditions joined by And or Or came in as just its first condition. Now the conditions come in together, grouped the way Tasker reads them (Or2 and And2 bind tighter than Or and And), and exporting writes them back out with their joiners. Tasker stops reading a list at a missing joiner or condition number, and the import stops there too, with a note. A list that uses Xor, or a condition that can't be joined here without changing its meaning (one holding && or ||, a {{ }} template or a bracket it doesn't close), is dropped with a note, and that step runs without a condition until you give it one. Export also reads a comparison the way tasks run it, so %x ~ (a == b) keeps (a == b) as its pattern instead of being split at the ==.
  • An imported Tasker condition keeps its right side whole. A regex holding &&, like x&&y, comes in wrapped in a (?:...) group so it stays one regex, and so does one with spaces at its start or end, which keeps them. If that group takes it past 256 characters, the import says it never matches here. A Matches or regex check holding another comparison sign, like %html ~ *<b>*, used to be read as two comparisons and never held. Now everything after the match sign is its pattern, as in Tasker. A pattern or text this app would read as two conditions, like yes||no, or one holding a {{ }} template, is dropped with a note instead of coming in as a different check. A condition with nothing on its right comes in as the check Tasker settles it to, so Not Equals, Doesn't Match and Doesn't Match Regex always hold and the rest never do. Spaces at either end of a text comparison's right side are trimmed with a note, since Tasker compares them and this app doesn't.
  • Matches with a pattern that's just the word for on or off in the phone's language, like Ein in German or On in English, now also matches the value on or off, as it does in Tasker. Only the whole word as Tasker writes it counts, so ein or Ein/Aus don't.
  • An imported Tasker Wifi Connected context with a network name pattern, like home/work or !Office, now comes in as that pattern and matches the whole name the way Tasker does, instead of turning the profile off. A name with no capital, like home, matches any case, as in Tasker. A Notification event's title and text come in as Tasker patterns too, matched against the whole title or text, and both go back out to Tasker as the same text. The state editor's operator field takes ~ for a Wi-Fi name pattern, and the trigger simulator tries one with a name it matches. While Android is hiding the network's name, a name or pattern doesn't hold and neither does its Not, so !Office can't turn on while you might be on Office. A name with spaces at its start or end stays out with a note, since the whole name counts in Tasker. The check for two profiles fighting over a setting knows a pattern like +5 can match more than one network, so it still warns when the other profile is on one called 15. It also knows a network's name means connected, so profiles on connected and on Home get the warning, and profiles on disconnected and on Home don't. A name or title holding a variable, and a notification's subtext, messages, other text or category, still turn the profile off with a note.
  • A profile with an exit task and no enter task never ran at all. Now nothing runs when its contexts match, and the exit task runs once when they stop matching, the way Tasker treats one. The profile editor has a None choice for the enter task. Tasker profiles that only have an exit task come in from an import that way instead of being skipped, and go back out the same way. A one-shot profile like this is used up when its exit task runs. An event can't stop matching, so a profile with an event context and no enter task now gets a blocking warning instead of saving and never running.
  • Conditions in an export from an older Tasker, which numbered its comparisons differently, now import as the comparison they were. One of the 48 exports we test against comes from Tasker 4.3, and 62 of its conditions come over. Its less-than checks used to come in as Matches and its greater-than checks as Doesn't Match, its Matches and Doesn't Match as equals and not equals, its equals as a pattern match, and its regex checks didn't come in at all.
  • Saving a change to any profile, or starting the engine again while it was already running, ran the enter task of each profile that was already on a second time. That doesn't happen anymore. A profile you didn't edit carries on exactly as it was, and so does one where you only changed its name, tasks, priority, cooldown or run limits. If you changed when it matches (say its contexts or grace period), it stays on until its contexts have been read again, then turns off and runs its exit task if they no longer match, like a Time window moved away from now. Before, it stayed on with no exit task until it matched and stopped matching again. A context that can't be read yet, like a location still waiting for a fix, keeps it on for 3 minutes at most. An edit that makes it wait for an event turns it off right away and runs its exit task.
  • A step that set a variable to nothing, like a plugin returning an empty %stderr, showed that change as a raw Var: line in the run's summary instead of in the step's Variables set box. A template that came out empty did the same with a Template: line. Both stay with their step now.
  • A NOT group in a profile's context logic no longer turns the profile on when the context under it has no value yet. That covers a Time bound read from a %Sunrise that isn't set and a Health reading Android refused, along with a state the app hasn't read since the profile was turned on. Those count as unknown now, so NOT of them stays off, the way a single inverted context already did. A profile like that which was already on turns off while the value is missing and comes back on once it's read again. The profile inspector shows them as unknown, and Simulate says why the profile stays off.
  • Tasker or another Locale host checking whether one of your profile's contexts is satisfied heard "no" while that context had no value yet, or after its source stopped. A host condition that's inverted turned on from that. It hears "unknown" now, the answer the Locale condition API has for it, and a context that's really false still answers "no". Asking whether a whole profile is active works the same way. A new profile, or any profile right after the engine starts, answers "unknown" until its contexts have been read, then "no" if they leave it off. A profile waiting for an event answers "no" right away.
  • The profile inspector could show a profile as on while it was really off, or the other way around. A source that stopped or lost a permission counted as false there, while the profile itself keeps using the last value that source sent. And a plugin condition took another plugin's answer, or the same plugin's answer for a different setting, as its own. The inspector now works each context out the way profiles do, and says so when a stopped source's last value still counts or when the latest plugin answer was meant for something else.
  • A plugin step showed "Needs setup" forever, even with its plugin installed and set up, and tapping it did nothing. The pill now shows only while the plugin isn't installed, or when an update gives it two receivers of the same kind, since the step can't tell which one to send to.
  • Turning a profile on with OpenTasker's SET_PROFILE_ENABLED broadcast, from a Send Intent step for example, gets the same checks as turning it on in the app. It used to only stop an import still waiting for its review, so a profile whose tasks call each other in a loop could be switched on that way without the review the app asks for. The broadcast also changes only whether the profile is on. It used to save the whole profile as it read it, so an edit saved in the same moment could be lost, and a profile deleted in the same moment came back.
  • Tasker tasks with more than ten steps import in the right order. Tasker writes a task's steps sorted as text, so step 11 comes right after step 2 in the file, and the import kept that order. A long task came in scrambled, with step 11 running right after step 2. That hit 21 of the 48 real exports we test against.
  • A Tasker import says when a Say, Play Ringtone or Music Play step used a stream this app doesn't have, where it used to come over on Music without a word. The note names the variable when the stream came from one.
  • A sunset or twilight context fires once a night when dusk comes after midnight. Far west in a time zone in early summer, nautical dusk slides past 00:00, and it used to be read as that same morning. So the profile fired twice a few minutes apart and then ran every later night at the next night's minute. Each crossing now lands on the date it really happens, and a window or offset that runs past midnight keeps belonging to the night it started.
  • A step that names its variable like %Mode, the way Tasker imports do, sets Mode every time. Once Mode held a value, the next run wrote to a variable named after that value instead, so an imported counter or Set Variable stopped changing after its first run. Preflight shows the same variable a run would set. Send Intent's result variable takes %res the same way, where it used to stop the step with an invalid name. A result variable no run could keep, like a bare % or _res, stops the step and says so, where it used to send the broadcast with nowhere to put the answer.
  • Plugin settings now reach the plugin with their real types. Every value used to go out as text, so a plugin that reads a number or a switch (Termux:Tasker checks for a number version code) saw nothing and ignored the request. Plain JSON values are still sent as text, and a value like {"int":3} or {"boolean":true} goes out as that type.
  • Plugins made for Tasker, like Termux:Tasker, find their settings where they look for them. OpenTasker only sent them inside the plugin's settings bundle, but Termux:Tasker reads which script to run straight off the request, so it logged that the executable was empty and ran nothing. Tasker sends the settings both ways, and OpenTasker now does the same.
  • Tasker exports now write contexts the way Tasker itself does, so Tasker can open them. Day and App contexts use Tasker's own fields, and so do Power, Headset Plugged, Display State, Battery Level, Wifi Connected, Device Boot and Notification. Anything Tasker can't hold exactly is left out, and the export names it along with its settings. Tasker's Day has no Invert switch, so "not Monday" goes out as the other six days, and an inverted time window stays out. A profile that fires on either of two contexts gets a warning too, because a Tasker profile needs all of them. Tasker files that use those states and events now import too.
  • Tasker profiles keep their on/off switch both ways. A profile switched off in Tasker used to come in switched on, and an export never marked a profile off, so one you'd turned off here, or one that lost a context Tasker can't hold, came out running in Tasker. Exports now mark those profiles off the way Tasker does, and imports read that mark. A Tasker profile set to switch itself off after a few more runs comes in on, with a note that its run limit stayed behind.
  • A Tasker export leaves out a profile that would have no context left, like one that only runs outside a time window, and names it in the warnings. Tasker turned down the whole file over a profile like that ("no Profile found"). The profile count in the export message no longer includes it.
  • The Needs setup pill on a task's action goes away once the permission it waits on is granted, and it's checked again each time you come back to the app. It used to stay on every action of that kind, granted or not. Notification actions wait on the Notifications permission, Wi-Fi scan on location (all the time, since profiles scan in the background) and Nearby Wi-Fi, Bluetooth toggle on Android 12 on Bluetooth connect, and Write Setting on Write Settings or the secure settings grant depending on its table. An SMS trigger now asks Setup for Receive SMS rather than Send SMS. Volume actions on Android 17 and actions no grant can settle (scripts, a VPN app) keep their pill.
  • An OpenTasker bundle's Capability review says Ready for an action whose permission is already granted, the same way a task's actions do. It used to say Needs setup on Show Notification with notifications allowed.
  • The Run Log picks up a new run on its own while you're on the first page. It used to keep showing old entries until you tapped Refresh. Once you've scrolled further back the list stays put, so nothing moves under you.
  • The Run Log names a step you never gave a label after its action, like Show Notification, the way Tasks does. It used to title it with the action's id, notify.show.
  • Flow does the same, so an unlabeled step reads "Step 1: Set Brightness" instead of "Step 1: brightness.set", and TalkBack hears that name too.
  • Setup explains why a Bluetooth device nearby context asks for Bluetooth connect: a paired device that's already connected, like a car or headphones, often doesn't show up in a scan.
  • The Inspector and profile cards show a state check the way it reads, like "Bluetooth device nearby = Car", where they used to show "key=bt_near, operator==, value=Car".
  • An import that's over the size limit says it would add too many tasks, profiles, variables and scenes. It used to say "entities".
  • Import JSON opens the bundle's import review. It used to open "Review community share" first, with share fields like the slug and screenshots that mean nothing to someone importing a file. Anything the share check would block (an action that can't run here) still blocks the import.
  • When an imported file can't be opened, the reason stays on screen until you dismiss it or something else needs the spot, like the next message or a deleted task's Undo. If the Undo comes up before the reason ever showed, the reason follows it. A damaged or cut-off Tasker or MacroDroid file says so, and the catch-all message points to Diagnostics, where the details are logged.
  • Pasting something too long for the paste box now says the end was cut off and points to the file import, instead of sending the cut text on to fail as damaged.
  • A paste over about 16,000 characters shows as a character count with a Clear button instead of filling the paste box, since laying out a big export in the box could take more than a minute. Review import still reads all of it.
  • Preflight's missing setup line now reads the live grants, so it stops listing what Setup already shows as done.
  • Preflight names a variable that Persist Variable made global the way a run does, so mode becomes Mode there too. It used to become MODE, and a later step reading %Mode showed it empty. A global name that comes out blank stops the run, and Preflight no longer shows the variable as set there.
  • Tapping an action's Needs setup pill opens Setup on the access it's missing. Setup only lists access for enabled profiles, so a task you run by hand used to point at a row you couldn't find.
  • A state context set to charging stays on while the phone is plugged in but the battery isn't taking charge, like when a battery protection limit holds it at 85%. It used to switch off there, where Tasker's Power context stays on.
  • Play Sound opens a file with a # or ? in its name. The path used to stop there, so the sound never played.
  • On Android 17, Setup's Shizuku row explains that the original Shizuku may not start there, names the thedjchi fork that supports it, and says to turn wireless debugging back on after a reboot, since OpenTasker can't. The README says the same.
  • A failed NFC tag write says what to do next, like holding the tag still and trying again, or checking Diagnostics when the tag keeps refusing. It used to show the tag's raw exception, such as IOException. The widget's run messages, the Locale plugin's task and condition pickers, and the names OpenTasker gives share drafts and workspace exports can now be translated too, and they come in Chinese.
  • On Android 16 and later, Setup shows a Read NFC tags row when you have an NFC profile and Android isn't handing tags to OpenTasker. Its button opens the system page to allow it. Without that, scanning a tag did nothing and nothing said why. The Inspector and diagnostics report say so too.
  • A diagnostics report lists special access (exact alarms, display over other apps, modify system settings, usage access, installing apps and Do Not Disturb) the way Settings has it. It used to read the install-time flag, so exact alarms showed as denied while they worked and Do Not Disturb always showed as granted. A permission the phone doesn't know, from a newer Android or an app that isn't installed, now says it isn't defined instead of denied, and other apps' permissions keep their full names.
  • App triggers keep running when usage access was granted with adb shell pm grant. OpenTasker used to count only the Settings switch, so it paused app triggers and Setup listed usage access as missing while Android was serving the data.
  • The Locale condition picker no longer freezes for up to 30 seconds when it's opened right after a backup restore. If the database still isn't back by then, the condition and task pickers close instead of crashing.
  • After Split Text or Match Text, %parts(#) counts the parts again and %parts(2) or %parts(%i) reads one of them. Both actions also set %parts to the first part, and that made every one of those forms give the first part instead. A range like %parts(0:1) joins those parts with commas, and an index held in a variable with a stray space still reads its part. These arrays count from 0, unlike Tasker's, so %parts(1) is the second part (that's what lets Match Text's %var(1) be the first group). Writing the variable as %parts in the step's field now stores the same array as parts, where it used to keep it somewhere %parts(#) couldn't see. And once a Tasker Variable Split has made %parts1, %parts2 and so on, those win even after the split deletes %parts itself.
  • A task run with no parameters doesn't see its caller's %par1 and %par2 as its own %par array anymore. %par(#) there used to count the caller's parameters, and an Array Pop on %par would take them away from the caller.
  • A trigger simulation no longer calls its events pinned. It builds each one from the context itself, but its notice, its per-context results and its summary all said pinned.
  • Some sensor contexts show a value before anything has been measured: Activity starts at "stationary", Speed at 0, Tethering at off below Android 16, and Bluetooth Near with nobody nearby. A profile you edited while it was on could read that as real and turn off and back on, running its exit and enter tasks, and a profile you just turned on could run its enter task off it. Those first values no longer count until the sensor reports. Activity and Tethering settle within about 30 seconds and Speed with the first fix after the source starts, or about a minute after that when the phone isn't moving. With no fix at all, as with only GPS on and the phone indoors, Speed waits until one comes in. Bluetooth Near counts a device as away only after about 6 minutes of scanning, so a new "not near" profile takes that long to turn on. A Bluetooth scan that fails as it starts doesn't count toward those 6 minutes, and Speed doesn't read the silence from a location provider you just turned off as standing still. A sensor that starts over, as when Bluetooth comes back on or the location providers change, can't flip a profile with its stand-in either, so the profile keeps its state until the sensor reports again, for up to 3 minutes (8 with Bluetooth Near), going by time since the phone started so a clock change doesn't shorten it. After that the context counts as unknown, so a sensor that never reports again, like a Bluetooth scan that keeps failing, can't hold a profile on for good, and its stand-in can't turn one on either. The same wait now covers any new profile with an inverted context, so "not in Maps" waits until an app has been seen, and a Locale host asking about a context that hasn't been read hears unknown.
  • A backslash before a variable works the way it does in Tasker. \%name in any field is written as the text %name, \%%name puts a percent sign before the value (just the percent sign while it's unset), and \\%name puts one backslash before it. That last one holds in a regex or a JSON body too, as it does in Tasker, so to keep two backslashes right before a variable there, write three. The backslash used to stay in front of the filled-in value, so an imported Search Replace that wrote \%found1 stayed a placeholder, and one with \% in it came with a warning. In <, >, <=, >=, Is Even and Is Odd an unset or empty variable now counts as 0, as Tasker's math does, so %count < 5 is true before %count is set. An imported Variable Set with Do Maths on does the same. Those comparisons also read a number the way Tasker does: spaces don't count, 0x1F is hexadecimal, a trailing f or d is fine, and both sides are rounded to 10 decimal places, so 0.30000000000000004 is no longer more than 0.3. NaN and Infinity aren't numbers there, and neither is an exponent with a sign, like 1e+5. Every kind of space is dropped, a no-break space on a scraped value or a line separator in the middle included, as it is in Tasker on Android, while a zero width space still keeps a value from being a number.
  • An imported Tasker condition that uses the maths Equals or Not Equals now compares numbers, so 5.0 equals 5 and an unset variable counts as 0. It used to come in as a text compare. With no math equals here, it's written as a pair of checks, (%x <= 5 && %x >= 5) or (%x < 5 || %x > 5), and a Tasker export writes that pair back as the maths Equals or Not Equals, unless a side holds &&, || or a {{ }} template, which Tasker's math can't read. A Not Equals with nothing on its right side always holds, as it does in Tasker, while one with only spaces there never does, and neither does an Equals with a blank right side. A lone Equals or Not Equals guard with &&, ||, a {{ }} template or an unmatched bracket in a side can't be written as a pair, so it's dropped with a note.
  • An App context that watches several apps, which a Tasker import can bring in, can be opened and saved. The editor used to reject the comma-separated list as an invalid app.
  • A scene element that can't be drawn now says something like "Image unavailable" on the overlay. It used to show a raw [IMAGE] tag.
  • The scene image field no longer shows a repair error while it's still checking the picture.
  • The Locale condition editor now opens right under the variable you tap, keeps what you typed when you rotate, says why it can't save, and Clear really does clear the selection.
  • The widget, Quick Settings and Locale setup screens show a spinner while they load. They used to claim you had no tasks for a moment, and Setup's script count did the same.
  • The widget, Quick Settings and Locale setup screens wait for your saved theme before they draw, so they no longer flash the wrong one.
  • The Quick Settings tile setup screen makes room for the keyboard. With a long task list the whole screen used to slide up, taking the title off the top and leaving the field you were typing in partly under the keyboard, and Save tile stayed out of reach until you closed it.
  • Removing device admin from Setup now waits until Android has finished before updating the row, and tells you if it didn't work.
  • Screen readers now hear the right label on search clear buttons, the watched setting switches and the secret variable switch, and scene errors show a warning icon, so they no longer depend on color alone.
  • Watch a setting turns off at the 64 rule limit and says why. A 65th rule used to vanish as soon as you saved it.
  • Project name errors now say what's wrong (empty, too long or already taken) in place of a generic failure.
  • New scenes show the allowed width and height, and a size outside that range is flagged. It used to change when you saved, without a word.
  • The header counts on Variables and Scenes now match the selected project, like the list under them.
  • A stray tap outside the template, scene element, context logic or watched setting forms no longer throws away what you typed, and context logic survives rotating the phone.
  • A template that can't be installed keeps its form open with what you entered, and tapping Install twice no longer adds it twice.
  • Saving a profile that could set off its own trigger now tells you it was left off and why. It used to say the profile was saved and then switch it off without saying why.
  • The cooldown field says the limit is 3600 seconds and flags a bigger number while you type, not after you tap Save.
  • Tapping Save twice on a new task, profile or project no longer creates two of them.
  • Opening a variable or scene from search only happens once now. The editor used to pop back open whenever the list changed, and a scene hidden by the search box was never found.
  • Watched settings brought in by a bundle import now show up right away, and editing the list afterwards can't wipe them.
  • A Say action that gets interrupted now ends right away. It used to hold its task for up to 10 minutes.
  • A sub-task cut off by the step that started it now reports the limit that really ran out, not the budget of whatever it happened to be doing.
  • A scene showing an image from another app no longer freezes OpenTasker while that image loads.
  • Tasker XML export now tells you what it couldn't carry over, like secret variables it left out or a State comparison the format has no place for. Inverted contexts stay inverted in the file.
  • Tasker imports now read Day and App contexts the way Tasker really writes them and keep each context's Invert switch. A profile that loses a context it needs comes in turned off, with a warning, so it can't run more often than it did in Tasker.
  • Incoming call events no longer miss the next call after the last profile watching for them gets switched off mid-ring, and the known contact check now finds work profile contacts.
  • A Quick Settings tile whose task was deleted now shows that it needs a task and opens setup. Tapping it used to flip the tile and run nothing.
  • A home screen widget goes back to its task when you undo deleting that task. It used to stay stuck on the missing label until you set it up again.
  • Profiles that depend on the phone being locked now notice a delayed lock. With a lock timeout set, the phone kept counting as unlocked after the screen came back on at the lock screen.
  • An all-day calendar event keeps matching until your day ends. West of UTC its stored end passes hours before local midnight, so in New York it dropped out of the calendar query at about 7 or 8 in the evening and a Calendar profile ended early.
  • Scene buttons and Locale plugin fires start their tasks again. Both send a broadcast that only apps holding OpenTasker's automation permission may receive, and OpenTasker declared that permission without asking for it, so Android dropped the app's own broadcast.
  • Scene buttons, the home screen widget and the Quick Settings tile no longer write two errors to the system log every time they run a task. OpenTasker tried to hand back a result that only a Locale plugin host waits for, and Android complains when nobody asked for one.
  • A run started from outside OpenTasker isn't marked failed when its request arrives twice at the same moment. The second copy got past the duplicate check, was refused further down, and that refusal overwrote the status of the run that was still going.
  • Connect or Disconnect VPN no longer takes credit for a tunnel it can't vouch for. When a VPN was already up and you asked WireGuard or Tailscale to connect, the run log said that tunnel had come up. It now says a VPN was already connected and that it can't confirm it's the one you named. Disconnecting when nothing was up says there was nothing to bring down.
  • Run Termux Script, Run Shizuku Script, Lookup Contact and the Home Assistant webhook get the time they're allowed. The engine stopped the first three at 60 seconds and the webhook at 120, so a script with a two-minute limit, a contact picker left open for a minute or a webhook on its last retry was reported as a timeout the action itself never hit.
  • The local release gate no longer runs its device tests on every phone and emulator adb can see. It uses the one attached device, or the one you name with -Serial, and stops before building when there are several and none is named.
  • The local release gate finishes again. Since the release certificate check went in on September 30, the release staging step couldn't be saved to Gradle's configuration cache, so every gate run failed after all its checks had passed.
  • The local release gate sets its own Gradle memory. It compiles Kotlin, runs lint and drives the device tests in one Gradle process, and a smaller class-metadata limit in a user-level gradle.properties (which beats the project's) made it run out three tests in.
  • The device test for Lock Device turns the screen back on when it's done. Locking also puts the screen to sleep, and on a device without a PIN every screen test that ran after it started on a dark screen and failed.
  • The device test that compiles the app's regexes on Android's engine passes again, and the credential redaction patterns now have device tests of their own. The test's pattern list took the first line of a pattern split across several lines for the whole thing, so it failed on a fragment, and the redaction patterns, which are built from shared pieces, never reached it at all.
  • The app now ships Guava 33.7.2. Health Connect support had brought in Guava 32.0.0, which has a published advisory (GHSA-xxph-c9ww-hj94) about some of its collections allocating huge arrays when they read crafted serialized data.
  • The release gate's dependency check finds a jar that a library's module file serves from another version's folder, the way Guava's Android build points at its JVM jar. It used to report that jar's upstream evidence as missing and stop the gate.

Reports this release changed something for

#29 and #30, and discussion #28 (Set Wallpaper).

Install

Download OpenTasker-v0.2.96.apk below, or let Obtainium pick it up. Coming from v0.2.92 or earlier? That build used a different key, so export a backup from Setup, uninstall it, then install this one.

OpenTasker-v0.2.96-fdroid.apk is the F-Droid flavor, which skips the GitHub update check. It's signed with the same key and attached so F-Droid can confirm its own build matches. Take the plain one unless you want that flavor.

Verify

OpenTasker-v0.2.96.apk SHA-256: 1d8d797ca7fcbbcb8ca434a239289b61180ef52a9354ba7952c6b02bfbfca52c

OpenTasker-v0.2.96-fdroid.apk SHA-256: 9c627d98bea9284b5d967f04e5000c74dbe95158592010bc6b22443c8322fc95

Signed with the same certificate as every release since v0.2.93. AppVerifier reads it like this:

com.opentasker.app
DB:A1:AA:88:E3:7B:90:15:5F:CA:31:35:CA:3B:78:1D:E9:2C:22:51:07:E4:7C:98:06:E7:5B:F8:80:55:FD:D8