| Tasker |
| Home |
|
Direct Purchase |
|
Download |
|
TaskerNet |
|
Home Automation |
|
Usage Examples |
|
Pre-made Projects |
|
FAQs |
|
Guides |
|
Reviews |
| Wiki |
| Plugin List |
| Forum |
|
Forum/Support Legacy Forum |
| Userguide (5.0+) |
| Index: en es fr zh |
| 1 Page: en |
| More |
|
Join |
|
AutoApps |
|
Developers |
| History |
| Privacy Policy |
| Release Notes |
| Next Version |
|
Feature Requests |
|
Report Issues |
|
Patreon |
|
This document is a one-page compilation of the on-device userguide intended for printing out for use as a reference.
Tasker Userguide
|
| 1. | For %item apple,pear,banana |
Loop once for each of apple, pear and banana |
| 2. | Action One |
Example: Flash %item |
| 3. | Action Two |
... |
| 4. | End For |
Return to action 1 if we havn't done all the items yet |
Result: Action One and Action Two are performed three times. The first time, the variable %item is set to apple, the second time pear and the last time banana.
You can insert a Goto action in the loop with either Top of Loop (meaning continue, skip to the next item straight away) or End of Loop (meaning break, stop without doing any more items) specified.
In adition to simple text, the For action accepts any comma-separated combination of these Items:
- a numeric range e.g. 1:5 (= 1,2,3,4,5)
- a numeric range with a jump e.g. 8:2:-2 (= 8,6,4,2)
- a numeric range defined by variable values e.g. 2:%end:%skip, 1:%arr(#)
- a variable name (which is replaced) e.g. %fruit (= banana maybe)
- a variable array part e.g. %arr(1:2) (= %arr1, %arr2 = apple,banana maybe)
A common case is to use %arr(), which performs a loop for each element in the array %arr.
Warning: the Values parameter in the loop is reevaluated with each iteration of the loop, meaning that modifying array variables which appear there from within the loop can have unexpected effects. To workaround that, it can be best to use the following sequence:
Variables Set, %values, %arrayWhichWillChange()
Variable Split, %values
For, %value, %values()
...
For Loop
Goal: perform a set of actions for each of a set of elements in turn.
Use the Foreach Loop as described above, with the Items parameter being a range specification e.g. 4:0, 100, 0:8:2 (= 4,3,2,1,0,100,0,2,4,6,8).Until Loop
Goal: perform a Task X until some condition is met (at least once)
| 1. | Action One |
... |
| 2. | Action Two |
... |
| 3. | Goto 1 If %qtime < 20 |
Return to action 1 if runtime < 20 |
Result: Action One and Action Two are performed until %QTIME contains the value 20 or more i.e. until the task has been running for 20 seconds.
Note: %QTIME is a builtin local variable available in all tasks.
While Loop
Goal: perform a Task X while some condition is met.
| 1. | Stop If %fruit Not Matches Apple |
Stop task if it's not crunchy, otherwise go to next action |
| 2. | Action One |
... |
| 3. | Action Two |
... |
| 4. | Goto 1 |
Go back and see if we're still crunchy |
Result: Action One and Action Two are performed while %fruit contains the value Apple.
Counter Loop
Goal: perform a Task X a set number of times.
| 1. | Variable Set %count, 0 |
Initialize the counter |
| 2. | Action One Label: LoopStart |
... |
| 3. | Action Two |
... |
| 4. | Variable Add %count, 1 |
Add one to %count |
| 5. | Goto LoopStart If %count < 10 |
Return to action 2 if count < 10 |
Result: after initialization of %count to 0, the task loops around the actions
from 2-5 until
%count reaches 10, at which point the condition on the Goto fails
and the end of the task is reached.
Note that we used a Goto to a labelled action this time. In
all but the very simplest tasks it's better to use a label rather than a number. It's easier to work out what's happening and if you insert or delete actions before the loop starts, the Goto will still jump to the right place.
An alternative way to do this loop is to use a For action specified as 0:10.
If / Then / Else Condition
Goal: perform certain Tasks if conditions are met, otherwise perform a different task.
| 1. | If %fruit ~ Apple |
~ is short for 'matches' |
| 2. | Action One | ... |
| 3. | Action Two |
... |
| 4. | Else If %fruit ~ Pear |
an Else action with a condition |
| 5. | Action Three | ... |
| 6. | Else |
|
| 7. | Action Four |
... |
Result: actions One and Two are executed if %fruit matches Apple, Action Three is executed if %fruit matches Pear, otherwise Action Four is executed.
Notes:
- you can have as many
Else Ifs in a condition as you like - if your condition is in the middle of a more complicated task, you need to tell Tasker where the condition ends with an
End Ifaction
Subroutines
To call another task, use thePerform Task action. To use it as
a subroutine, you just need to ensure that the priority of the calling
task is less than the priority of the called task (more info:
scheduling).
The parent can optionally pass values to the child and receive a result back:
Parent Task
| 1. | Perform Task
Child, Priority, 10 %par1, 5, Result Value Variable, %result |
pass 5 to the child, expect a result in %result |
| 2. | Variable Flash Result: %result |
what did we get back ? |
Child Task
| 1. | Variable Set
%newval, %par1 + 1, Do Maths |
add one to the value that was passed |
| 1. | Return %newval | set %result in the parent to the value of %newval in the child |
Result: the parent flashes 6
Notes:
- changes made to %par1 and %par2 in the child task are not reflected by their changing in the parent task
- receiving a return value is optional for the parent, even if the child tries to give it one
- unlike
Returnstatements in most computer languages, Tasker's does not necessarily stop the child task, so if the child and parent have the same priority they can both run together and the child return several results over time.
Encryption
Note: encryption functions are not available to new customers or in Play Store versions of Tasker due to US export restrictions.
Tasker has the ability to encrypt and decrypt files. The relevant actions are in the Encryption action category.
Since decryption can be automated, you have the possibility to keep data files encrypted outside of certain times, locations, applications etc.
Warning: make backups of your files while setting up encryption until you understand how the system works and are sure the encryption/decryption process does not cause any corruption.
Tip: Tasker does not give progress reports while it's doing encryption, if you want to know when an long decryption operation is finished, just put a Vibrate action or similar after the Encrypt/Decrypt action.Keys
Tasker uses a system of named keys. All of the encryption actions can specify a key name so that you can use different keys with different files (if desired).If no key name is specified, default is used.
Once a passphrase for a key is entered, the ciphers it generated are stored in memory until explicitly deleted. The deletion might be specified after an Encrypt/ Decrypt File action, or explicitly with the Clear Key action.
Setting Up Encryption
General Preferences
First thing to do is check whether the encryption preferences for Encryption Iterations and Encryption Algorithm are as you wish. Once you start encryping things, it's time consuming to start again with new encryption preferences.
The preferences can be found at Menu / Prefs / Action.
Be sure to have a look at the help text for each item.
Initial Encryption
To start with, you probably want to encrypt some files which are in a particular directory, which you can then decrypt as they are needed.To do that, create a task called Encrypt or similar and add one or more Encrypt File or Encrypt Dir actions to it.
By default, the key is cleared once the file is encrypted, so click 'Leave Key' for all but the last action, otherwise you'll have to enter your passphrase for each file.
Next, create a Tasker shortcut on the home screen, using the Encrypt task. Tap the widget to encrypt your files. Notice how you are only asked for the passphrase for the first one, because it is stored until cleared.
The encrypted files will all receive an extension .tec and the original files are deleted.
Decryption
Once you have a set of encrypted files, you need to setup the contexts in which they will be decrypted.Create another task called Decrypt or similar, and add Decrypt actions to it to match the encrypt actions you setup previously.
Don't click Clear Key, otherwise you'll have to enter your passphrase for every file (and at the start of encryption).
Now you can use your Encrypt and Decrypt tasks whenever you like. For instance, you could create a profile with a Location Context and run your Decrypt task when entering the location (assign Decrypt as the Enter task) and your Encrypt task when leaving the location (assign Encrypt as the Exit task).
Important: when you use the Decrypt action, it recreates the original file from the encrypted copy, but does not delete the encrypted version.
When you re-encrypt the file, if it has not changed it is simply deleted since we already have an encrypted copy. If it has changed, it is re-encrypted.
The purpose of this method of operation is to:
- avoid the lengthy encryption process when unnecessary
- prevent accidental double-encryption (encrypting the same file twice)
Enter Key Action
It's not always convenient to enter the key at the point at which de- or encryption takes place. This action allows you to specify the passphrase for a key at a different point.If you don't wish to double-enter a key when encrypting, you can also use this action before an Encrypt action and not select Confirm.
Set Key Action
To allow full-automation of en/decryption, the passphrase for a key can also be set without user interaction. However, this is much less secure thamEnter Key because:
- the passphrase (as part of the action) is stored in clear text in device memory and could be read by the root user if the device OS is compromised
- although the passphrase is itself encrypted when a backup is made to SD, the parameters for that encryption can be recovered from the java code in the Tasker apk file
Security
Algorithm
Tasker uses symmetric encryption, meaning the same passphrase is used both to encrypt and decrypt the data.The default algorithm is "PBEWithMD5And128BitAES-CBC-OpenSSL". PBE stands for password-based encryption, see RFC 2898.
A salt is combined with the passphrase several hundreds of times using the MD5 algorithm to produce a key which is used for the 128-bit (default setting) AES algorithm.
The number of iterations and algorithm can be set in Menu / Prefs / Action.
Pass Phrases
The longer the passphrase, the more secure the data. Minimally 8 characters of mixed alphabetic, numeric and punctuation characters is recommended.Clearing Keys
While a key's ciphers are in memory, anyone can use the key for decryption or encryption if your device is lost or stolen, so it may be wise to setup a Clear Key action e.g. when the device is turned off (see Screen Off in the Event Context) or at a particular time (Time Context), depending on what you are using the encryption for.Manually Encrypting/Decrypting
You can use Tasker's file browser (action Browse Files) to encrypt/decrypt files directly, via a long-click on the file.
Gestures & Shaking
General
Gestures are physical movements of the phone in space, which you first record by creating a new Event of type Gesture (in the Misc category).When you later redo the gesture while using your device, Tasker will carry out the corresponding task(s) you have attached to its profile.
Like normal events, gestures are restricted by other contexts. For example, if you define a profile with a Gesture (Event) and Application context, the gesture will only be recognized while using that particular application.
Note: it might be a good idea to disable Tasker before setting up new gestures, as otherwise you are likely to trigger previously defined ones.
Recording A Gesture
Gesture Points
First off, it's important to know that Tasker only records the particular points (which we'll call inflection points) of a gesture that you tell it to. For example, recording a gesture involving tilting the phone to the left and back you would record three inflection points: the start, the tilted left position, and the end (which is the same as the start in this case).You can record as many points as you like, but in general it's best to record only the points where the phone is not moving.
Recognized Movements
Tasker will only recognize changes in the angle of the phone i.e. tilting to left or right, backwards or forwards, or rotating vertically. Imagine three poles going through the device in the three dimensions.Moving the phone backwards or forwards, up or down or side to side cannot be recognized.
Procedure
- create a new Gesture Event and give it a name (so you can differentiate between different gestures).
- put the phone in the position where you want the gesture to start and press-and-hold the Call, Camera, Menu, Search or Volume hardware buttons to record the point. The device will buzz.
- move to another (preferably not-moving) point on the path of your gesture, and press the button again (not a long press). The device will buzz.
- on the final inflection point, press-and-hold the button to mark the end of the gesture. The device will buzz again and the "Recorded." message should now flash up.
- Press Done, and add a Vibrate action so you can hear when your pattern matches when testing it.
Activation
Calibration
Before trying to match a pattern, you probably need to calibrate the hardware in your device. Go toMenu / Prefs / Monitor / Gestures. Press
the Calibrate button and tilt your phone around in all directions.
Tasker now has some idea what kind of values the accelerometer in your phone produces.
You only need to calibrate once.
Matching
Now exit Tasker and move your device through the points you previously defined when recording. You should hear the device vibrate when it reaches the final recorded point.If not, try playing with the values in the Gesture Settings screen. For instance, you could try raising the Match Radius (but be careful not to raise it too much or you'll get a lot of matches by mistake).
Power Usage
Tasker does its best to limit power usage of gesture monitoring.- monitoring for gestures only takes place when all the other contexts in a profile are already active (and so the gesture might have a chance of activating the profile). For example, if you combine an Application and Gesture (Event) context, gesture monitoring will only take place while using that particular application.
- Gesture monitoring is by default turned off when the display is off unless a power source is connected to the device,
unless specified otherwise in
Menu / Prefs / Monitor / Display Off Monitoring - updates from the accelerometer are at the minumum rate until the start of a gesture is detected.
Icons
Tasker can use four categories of icons:
Application,
Built-In,
Ipack,
User-Installed.
In some places it's also possible to use any image stored on local media as an icon.
Application Icons
These are taken from applications installed on the device.Minor note: if the icon of the application changes, an update of previously created widgets/shortcuts can be forced by creating a single widget with the new icon and then rebooting.
Built-In Icons
These come with Tasker and are kept in the device's memory.Ipack Icon Sets
Ipack is a free, open format for sharing of icon sets between Android applications. Ipack icon sets can be either installed from Play Store or from the Ipack website.When setting an icon, you will notice an item labelled Download More Icons. Clicking on it will use the appropriate source depending on which version of Tasker you have.
User-Installed Icons
You can also install your own icons directly into Tasker's icon directory
/sdcard/Tasker/.icn/. Make sure the icons are in a subdirectory.
The subdirectory should also only be one level deep (no subsubdirectories).
Icons must be in PNG format.
Example: a two-icon set called Christmas would have the two files in these locations:
/sdcard/Tasker/.icn/Christmas/santa.png
/sdcard/Tasker/.icn/Christmas/snowman.png
Intents
Intents are Android's main method for allowing apps to communicate with each other and share data. Intents are for advanced users. This document is not intended to explain how intents work, but how to use Tasker's intent facilities.
Sending Intents
You can find information about intents and details of several built-in Android intents on the Android SDK Reference Site.Tasker allows you to send arbitraty intents using the Send Intent action in the Misc category. This allows you to provoke behaviour in other apps, when you know the particular form of intent they are designed to respond to.
Send Intent Parameters
Note that any parameter specified except Extras will reduce the set of possible receivers of the intent.Action
What the sender would like the receiver to do with the data.
Example: android.intent.action.VIEW
Cat
Gives additional information about the action.Mime-Type
From the developer reference: "This is used to create intents that only specify a type and not data, for example to indicate the type of data to return."Can't be used together with a Data specification.
Data
The main data specification in the form of a URI.Can't be used together with a Mime-Type specification.
Extras
Any additional data to send with the intent.The extras must be in the form of a single colon-separated key and value.
If the value can be parsed as an integer, long (integer ending in L), floating point number, double (float ending in D) or boolean (true/false) it will be treated as one.
The value can also be forced to a simple type (long etc) or Uri via casting.
The name of a Java object created via the Java Function action which is of type Parcelable can also be used (e.g. a Bundle)
If none of the above apply, the value will be treated as a String.
Examples:
- have_flowers:true
(boolean) - this.is.an.integer.example:34
(int) - this.is.a.double.example:34D
(int) - address: (Uri) http://a.b
(Uri) - bunchofvalues:mybundle (where mybundle is the name of a Java object of type Bundle)
(Parcelable) - simple.string.example:hello there!
(String)
Package, Class
Allow specification of a particular package and/or class within the package to restrict the broadcast to.Target
The type of Android component which should receive the intent.Finding App Intents
Many intents that an app listens for are declared in its package manifest (called AndroidManifest.xml). You can view details of those intents using the aapt tool that comes with the Android SDK like this:
aapt dump xmltree example.apk AndroidManifest.xml
Look for Intent Filter elements.
It's not (easily) possible to determine which intents an app listens for dynamically (i.e. while the app is running).Receiving Intents
Tasker allows you to receive a large range of intents, sent by apps or the system, using the Intent Received event in the System category.
For each event you create, Tasker sets up a corresponding Intent Filter object.
Limitations
- Tasker can only receive intents which are sent to broadcast receiver components, not to activities or services.
- some intent senders require that a corresponding intent filter is specified statically (i.e. in an Android Manifest). Those intents cannot be received.
- intents which are broadcast with a specification of a particular package component to receive it cannot be received.
Send Intent Parameters
Action
If specified, the received intent must have also that action specified.Cat
Any categories specified in the received intent must also be specified in the Tasker event. Note that this is logically different to the situation for the Action parameter.Scheme
If any schemes are included in the filter, then an Intent's data must be either one of these schemes or a matching data type. If no schemes are included, then an Intent will match only if it includes no data.Mime Type
If a type is specified, then an Intent's data must be the same, or match the Scheme parameter. If no Mime Type is specified, then an Intent will only match if it specifies no Data.Priority
If the intent is part of an ordered broadcast, then the priority specified here will affect whether this event will receive the intent before or after other listeners.Stop Event
If the intent is part of an ordered broadcast, then specifying Stop Event will prevent it being passed to other listeners after this one.Accessing Intent Data
When an intent triggers an Intent Received event, the resulting task(s) which are executed have access to many details of the intent via local variables (where relevant and present):- %intent_data: the data
- %evtprm1: the action
- %evtprm2: the first category
- %evtprm3: the second category
- %evtprm4: the URI scheme
- %evtprm5: the MIME type
In addition, any extras attached to the intent can be accessed under their name, with the following modifications to make them valid variable names:
- all letters will be converted to lower-case, then
- names of length less than 3 will have var_ prefixed
- non-letter-or-digit characters will be converted to _, then
- names not starting with a letter will have a prefixed, then
- names not ending with a letter or digit will have a affixed
- if the result is the name of another extra, _dup will be affixed until that is no longer the case
For example, an extra with key %SOUND_ON will be available as %sound_on, and an extra with key package.SOUND_ON!, will be available via the local variable %package_sound_on_a
The following extra types are presented in Tasker as local arrays:
String [], Integer [], ArrayList.
Example: a string array extra `named 'fruits' with values 'pear' and 'apple' will result in the local variables %fruits1 (=pear) and %fruits2 (=apple).
Java Support
- Introduction
- The
Java FunctionAction- Using The Action
- Parameters
- Return Values
- Objects
- Creating An Object
- Object Naming, Local And Global
- Built-in Objects
- Assigning Values
- Other Actions Supporting Objects
- Other Topics
- Casting
- Constants
- Generic Classes
- Permissions
- Service Thread
- Static Fields
Introduction
Android has hundreds of thousands of functions which apps can use. It's not possible for Tasker to present all of those to the user, so Tasker allows the advanced user to directly call those Java functions and work with Java objects themselves.
It does not allow you to 'write Java code'... but the combination of Tasker's logic and flow control with direct access to the Android API is sufficient for most automation purposes.
This page assumes you have a basic familiarity with the Java concepts of objects and classes.
Developer information on the Android API is available from Google.
Example
Variable Set, %service, wifiJava Function, wiman = CONTEXT.getSystemService( %service )Java Function, %enabled = wiman.isWifiEnabled()Java Function, wiman.setEnabled( true ), If %enabled eq false
This example task turns wifi on if it is not already enabled.
Action 2 demonstrates that Tasker variables can be used in Java function calls.
wiman is a Java object resulting from the function call which is stored
by Tasker for use in subsequent actions. CONTEXT is also such a variable
but is built-in and always accessible to Java Function.
Action 3 demonstrates that results of Java Function can also
be assigned to Tasker variables. Since all Tasker variables are strings,
some conversion needs to take place depending on what type of object the
Java function returns. In this case it's a boolean, and so %enabled will be
true or false.
Action 4 demonstrates taking a decision based on the result of previous Java function call.
The Java Function Action
Using The Action
- enter an object or class (to access static functions)
into the first parameter.
The magnifying glass icon will show a class selector for classes known in the latest Android API. Some may be coloured red, as not all classes are available on all devices.
The coffee-cup icon allows quick selection of known Java objects
The question mark icon will attempt to link to the relevant Android reference page for the object or class.
- click the magnifying class next to the
Functionparameter to select a function to execute appropriate to the object or class from step 1.In most cases, Tasker will be able to guess which class an object is, and hence which functions are available, if not, see casting below.
Functions listed in red are private, meaning they can be used, but the author didn't intend them to be.
- if the function returns a value, you can enter a Java object name to assign it to, or a Tasker variable, see below.
- enter any parameters required for the function, see below. The type of object the function expects for the parameter is displayed above the text entry field. The magnifying glass will list any fields associated with the current entry in the text box, where possible.
Parameters
If you don't enter a value for a parameter, null will be used for
that parameter when the function is called.
If you enter the name of a variable array, Tasker will attempt to convert the array values into the type of object (an array or collection) which the function expects.
Other Tasker variables will be replaced in the usual way.
Here can also be entered Java objects, or their fields, either built-in or created by
previous calls to Java Function (e.g. wiman or arr[0].length)
Return Values
When a Java function returns a value, it can be placed in either a Tasker variable or a Java object (or ignored).
If it's placed into a Tasker variable, it's converted to a piece of text and the object itself is lost and can no longer be accessed. Note that if the Java object is an array or list, it will be assigned to multiple Tasker variables in the usual way e.g. %val1, %val2...
When the returned value is placed into a Java object, you can access the object at a later time in another Java Function and some other (see later) actions.
Note that return value classes are inferred from the function, so object names can refer to different classes at different times. It's not recommended to reuse names in this way however!
Objects
Creating An Object
New objects of most types can be created by filling in the class name,
hitting the function selector and selecting a function called new.
It's worth noting that many classes in the Android API have special static
functions for getting a new object of that class called e.g. getInstance
or similar.
Arrays (also multidimensional) can be created by adding [] to the
class name (or e.g. [][]).
Here's an example of creating a 3x5 string array:
Java Function, arr = new String[][]( 3 )For, %rowno, 0:2-
Java Function, arr[%rowno] = new String[]( 5 )
Creating an array is also possible natively via the newInstance function in the the class Array.
Array components can be accessed as in normal Java (arr[0][1])
wherever Java objects are supported.
Object Naming, Local and Global
Object names can consist of any any combination of upper or lower case letters and underscore and, unlike Tasker variable names, may start with underscore. The first letter may not be upper-case, as this is a convention used to distinguish objects from classes.Analogous to Tasker variables, Java objects are either local to the current task if their name is all lower case, or global (available to any other task) if there are any upper-case characters in the name. All-upper-case names represent final (fixed) global objects which cannot be modified.
There are three important things to remember about global Java objects:
- it's important to delete them once they are no longer needed, because they can take up a lot of memory.
- unlike global Tasker variables, they are lost when Tasker is killed e.g. because the device was restarted
- their names can only contain upper- or lower-case letters or underscore.
Built-in Objects
- Android Context (class
Context)
CONTEXT
Many funtions in Android require a context object. In tasks running directly as a result of a scene element event, this is the Activity object which is displaying the scene, otherwise it's Tasker's Application context. - Image Buffer (class
Bitmap)
IBUFFER The object manipulated by functions in Tasker's Image action category.
Assigning Values
When writing Java code, to make a name refer to the same object as another name, you would use something like:String a = "hello";String b = a;
Now both a and b refer to the same object.
To achieve that in Tasker, you use the special assignTo
function after selecting the object to assign.
Java Function, a, "hello", assign(ora = "hello".assign())Java Function, b, a, assign(orb = a.assign())
Other Actions Supporting Objects
If
A Java object can be directly referenced in a condition. Null-value objects are replaced with text representationnull.
Examples:
If, arr[0][0] eq 45If, arr[0].length > 3If, lightlevel Equals null
You cannot make function calls e.g. str.charAt( 5 )
For
The Value parameter in the For action can include Java object references as for If.
For, %value, arr
Will repeat once for each value in the array arr. This will also work for string lists and simple objects (boolean etc)
Other Topics
Casting
Casting in Tasker is used only to tell Tasker the type of a particular object. That can be useful so that e.g. Tasker can show functions which are appropriate to it.
In the example at the top of the page, the getSystemService
function returns an Object:
Java Function, wiman = CONTEXT.getSystemService( %service )
Since the object could be one of many kinds of managers, Tasker is
not able to list the WifiManager functions for easy selection
when creating the next Java Function action in the task.
You can tell Tasker the actual type by adding a cast in brackets before the name:
Java Function, (WifiManager) wiman = CONTEXT.getSystemService( %service )
Constants
Tasker support the usual naming conventions for Java constants.- L a long integer e.g.
300L - F a floating-point number e.g.
45.6D - D a double-length float e.g.
45.6D - double quotes indicate a string e.g.
"hello", though in many cases Tasker will infer that a string was intended anyway - single quotes indicate a character e.g.
'x'
Tasker will attempt to convert numbers without affixes to a Java type in
the following order: int, long, float, double.
Generic Classes
Tasker only supports fully the following generic classes:
- ArrayList<String>
- ArrayList<View>
- ArrayList<Bundle>
- ArrayList<Integer>
- ArrayList<Long>
- ArrayList<Double>
- ArrayList<Float>
Create them by selecting their class in the class selector, clicking the function selector and clicking new.
Generic classes mixed with arrays cannot be handled by Tasker, though you can pass such objects around from function to function.
Permissions
For some function calls, Android requires that the calling app have declared a permission otherwise the call will fail. This means that a Java Function call will fail if the permission is not one of the ones pre-declared by Tasker.
Unfortunately, Android does not allow permissions to be added dynamically, so if you wish to use a function requiring a permission that Tasker does not already have, the only option is to generate a child app to run the function (see App Creation). In the child configuration screen you can add any permissions which your Java Function call needs to the child app.
Service Thread
Java code is executed with a non-UI thread by a service.Some implications are:
- things which require an activity will not work e.g. showing a dialog
- sending intents will in some cases require the flag
Intent.FLAG_FROM_BACKGROUNDand possibly alsoIntent.FLAG_ACTIVITY_NEW_TASK
Static Fields
Static fields (e.g.ContentResolver.EXTRA_SIZE) are not currently supported
by Tasker.
A workaround is to use reflection to get (or set) the value:
res = CONTEXT.getContentResolver();cls = res.getClass();fld = cls.getField( EXTRA_SIZE );%val = fld.get( null );
JavaScript Support
- Introduction
- Local Variables
- Global Variables
- Arrays
- Settings
- Execution
- Working Off-Device
- Builtin Functions
alarmVol audioRecord audioRecordStop
btVoiceVol browseURL button
call callBlock callDivert callRevert callVol carMode clearKey composeEmail composeMMS composeSMS convert createDir createScene cropImage
decryptDir decryptFile deleteDir deleteFile destroyScene displayAutoBright displayAutoRotate displayTimeout dpad dtmfVol
elemBackColour elemBorder elemPosition elemText elemTextColour elemTextSize elemVisibility enableProfile encryptDir encryptFile endCall enterKey exit
filterImage flash flashLong flipImage
getLocation getVoice global goHome
haptics hideScene
listFiles loadApp loadImage local lock
mediaControl mediaVol micMute mobileData musicBack musicPlay musicSkip musicStop
nightMode notificationVol
performTask popup profileActive pulse
readFile reboot resizeImage ringerVol rotateImage
saveImage say scanCard sendIntent sendSMS setAirplaneMode setAirplaneRadios setAlarm setAutoSync setBT setBTID setClip setGlobal setKey setLocal settings setWallpaper setWifi shell showScene shutdown silentMode sl4a soundEffects speakerphone statusBar stayOn stopLocation systemLock systemVol
takeCall takePhoto taskRunning type
usbTether unzip
vibrate vibratePattern
wait wifiTether writeFile
zip - Function Notes
Introduction
Tasker supports running JavaScript code in tasks or WebView scene elements. Most Tasker actions can be accessed direct from the JavaScript. JSON and XMLHTTPRequest are also directly available from the JavaScript code.
JavaScript in Tasks
JavaScript can be embedded inline in tasks via the JavaScriptlet (direct specification of JavaScript to run) or JavaScript (load script from file) actions.
In both cases, the JavaScript executes in sequence with the other actions in the task and variables are transparently converted so pieces of JavaScript can be interwoven throughout the task.
Embedded in HTML
WebView elements allow specification of mixed HTML and JS for the element content.
<H1 onClick="setWifi( false )">ClickMeToTurnOffWifi</H1>
This allows a single WebView to present a complete user-interface.
Local Variables
In JavaScript(let) actions, local variables (all lower case, e.g. %myvar) are directly accessible in the JavaScript without
the % sign (e.g. myvar). If the script changes the value, the new value is transparently
used by subsequent actions in the task.
The values of new (all lower case) variables declared in JavaScript (with the var keyword) are also available to subsequent actions,
with the exception of those which are chain-declared e.g. var one = 'aval', two = 'bval';
In JavaScript embedded in HTML, the functions local and setLocal must be used to access variables local to the scene hosting the WebView.
Global Variables
Tasker global variables need to be accessed via global() and set via setGlobal(). Global arrays are not supported due to an Android limitation.Arrays
Local Tasker arrays are transparently available in Javascript(let)s and vice-versa. They are not available in WebViews.
Arrays which are not existing Tasker arrays must be declared in the JS as such i.e. in this case arr will not be visible to the remainder of the task:
var arr = getSomeArray();
Whereas in this case it will:
var arr = []; arr = getSomeArray();
Note that:
- JavaScript array indices start at 0, whereas Tasker array indices start at 1
- JavaScript uses
[]while Tasker uses()
So, for example, %arr(1) (Tasker) is equivalent to arr[0] (JavaScript).
Settings
Unlike normal Tasker actions, settings which are changed in JavaScript as part of a profile's enter task are not restored when the profile exits.Execution
Execution Instances
Only one script can execute at one time. Once a piece of JavaScript is executing, it cannot be interrupted by another piece.Working Off-Device
You might wish to develop long and/or complicated tasks off-device e.g. on a PC. There are two strategies for that:1. JavaScript action
For off-device testing, use Menu / More / Developer / Save JS Library Template to get dummy
definitions for the built in functions. Include that file when developing on your PC.
To test in your JavaScript code whether you're on-device or not, use
var onAndroid = ( global( 'sdk' ) > 0 );
By using the JavaScript action rather than JavaScriptlet you can easily
access a file synced from PC to a file on the Android device.
2. Using WebView
If you specify a website URL as the content for your WebView, then testing the code on the target device is a simple matter of pushing the new version to your webserver and reloading the WebView on the device (see action Element Web Control)
Builtin Function Execution
Calls to most Tasker builtin functions (see below) are executed as normal single-action tasks and thus may be blocked by other executing tasks.
They execute at the priority of the task that executed the JavaScript plus two.
JavaScript(let): Alert,Confirm,Prompt
Scripts using these functions require a 'user-interface' and may cause interference with the currently running app (though in most cases they will not).JavaScript(let): Auto Exit
By default, the JavaScript(let) action will end when the main execution
sequence is finished.
If you are using asynchronous code e.g. via setTimeout() or other callbacks, you should deselect Auto Exit. You are then responsible yourself for telling Tasker to continue the task by calling exit().
In any case, execution will stop when the timeout configured for the action is reached.
JavaScript(let): Libraries
You can specify as many libraries as you want in the Libraries parameter, separated by newlines.Several popular libraries are pre-selectable.
You may wish to download them manually to your local storage and change the http URL to a file URL so that Internet is not required to run your script.
Warning: library code will have access to local files, data providers etc. on the device
Important: if you are using your own libraries developed on Windows, you may need to convert CRLF style line endings to Unix style LF.
Builtin Functions
Tasker makes most of it's actions available via functions which can be called directly via name
in JavaScript(let) actions and WebView elements.
Exceptions:
- in WebView content where mode is set to URL, the functions must be prefixed by tk e.g.
tk.flash('Woo!') - when executing code via eval the functions must be prefixed by tk.
alarmVol / btVoiceVol / callVol / dtmfVol / mediaVol / notificationVol / systemVol / ringerVol
var ok = alarmVol( int level, bool display, bool sound )
Set the relevant system volume to level.
If display is true, the new level will be flashed up on-screen.
If sound is true, a tone will sound at the new level.
audioRecord
var ok = audioRecord( str destPath, str source, str codec, str format )
- destPath: where to put the recording. Note that a file extension is not necessary, it will correspond to the selected format.
- source: def, mic, call, callout or callin
- codec: amrn, amrw or aac
- format: mp4, 3gpp, amrn or amrw
The JavaScript does not wait for the audio recording to complete.
See also: audioRecordStop().
audioRecordStop
var ok = audioRecordStop()
Stop recording previously initiated by audioRecord().
browseURL
var ok = browseURL( str URL )
Open the default browser at the specifed URL.
button
var ok = button( str name )
Simulate a press of the named button.
name must be one of back, call, camera, endcall, menu, volup, voldown or search.
This function requires a rooted device.
call
var ok = call( str num, bool autoDial )
Make a phone call.
If autoDial is false, the phone app will be brought up with the number pre-inserted, if true the number will also be dialed.
callBlock
var ok = callBlock( str numMatch, bool showInfo )
Block outgoing calls matching numMatch.
If showInfo is set, Tasker will flash a message when a call is blocked.
callDivert
var ok = callDivert( str fromMatch, str to, bool showInfo )
Divert outgoing calls matching fromMatch to the number to.
If showInfo is set, Tasker will flash a message when a call is diverted.
callRevert
var ok = callRevert( str numMatch )
Stop blocking or diverting outgoing calls previously specified with callBlock or callDivert.
carMode
var ok = carMode( bool onFlag )
Turn on or off Android Car Mode.
clearKey
var ok = clearKey( str keyName )
Clear the passphrase for the specified keyName.
See Also: Encryption in the Userguide.
composeEmail
var ok = composeEmail( str to, str subject, str message )
Show an email composition dialog with any specified fields pre-filled.
The JavaScript does not wait for the email to be sent before continuing.
composeMMS
var ok = composeMMS( str to, str subject, str message, str attachmentPath )
Show an MMS composition dialog with any specified fields pre-filled.
The JavaScript does not wait for the MMS to be sent before continuing.
composeSMS
var ok = composeSMS( str to, str message )
Show an SMS composition dialog with any specified fields pre-filled.
The JavaScript does not wait for the SMS to be sent before continuing.
convert
var result = convert( str val, str conversionType )
Convert from one type of value to another.
conversionType must be one of the string constants: byteToKbyte, byteToMbyte, byteToGbyte, datetimeToSec, secToDatetime, secToDatetimeM, secToDatetimeL, htmlToText, celsToFahr, fahrToCels, inchToCent, metreToFeet, feetToMetre, kgToPound, poundToKg, kmToMile, mileToKm, urlDecode, urlEncode, binToDec, decToBin, hexToDec, decToHex, base64encode base64decode, toMd5, toSha1, toLowerCase, toUpperCase, toUpperCaseFirst.
See also: action Variable Convert.createDir
var ok = createDir( str dirPath, bool createParent, bool useRoot )
Create the named dirPath. If createParent is specified and any parent directory does not exist, it will also be created.
If useRoot is specified, the operation will be performed as the root user (where available).
createScene
var ok = createScene( str sceneName )
Create the named scene without displaying it.
cropImage
var ok = cropImage( int fromLeftPercent, int fromRightPercent, int fromTopPercent, int fromBottomPercent )
Crop an image in Tasker's image buffer previously loaded via loadImage.
decryptDir
var ok = decryptDir( str path, str key, bool removeKey )
As decryptFile(), but decrypts each file in the specified directory in turn.
decryptFile
var ok = decryptFile( str path, str key, bool removeKey )
Decrypt the specified file using the encryption parameters specified in Menu / Prefs / Action.
If removeKey is not set, the entered passphrase will be reapplied automatically to the next encryption/decryption operation with the specified keyName.
See Also: Encryption in the Userguide, Decrypt File action.
deleteDir
var ok = deleteDir( str dirPath, bool recurse, bool useRoot )
Delete the named dirPath. recurse must be specified if the directory is not empty.
If useRoot is specified, the operation will be performed as the root user (where available).
deleteFile
var ok = deleteFile( str filePath, int shredTimes, bool useRoot )
Delete the named filePath.
shredTimes has range 0-10.
If useRoot is specified, the operation will be performed as the root user (where available).
See also: action Delete File
destroyScene
var ok = destroyScene( str sceneName )
Hide the named scene if it's visible, then destroy it.
displayAutoBright
var ok = displayAutoBright( bool onFlag )
Whether the display brightness should automatically adjust to the ambient light or not.
displayAutoRotate
var ok = displayRotate( bool onFlag )
Whether the display orientation should change based on the physical orientation of the device.
displayTimeout
var ok = displayTimeout( int hours, int minutes, int seconds )
How long the period of no-activity should be before the display is turned off.
dpad
var ok = dpad( str direction, int noRepeats )
Simulate a movement or press of the hardware dpad (or trackball).
direction must be one of up, down, left, right or press.
This function requires a rooted device.
enableProfile
var ok = enableProfile( str name, boolean enable )
Enable or disable the named Tasker profile.
encryptDir
var ok = encryptDir( str path, str keyName, bool rememberKey, bool shredOriginal )
As encryptFile(), but encrypts each file in the specified directory in turn.
elemBackColour
var ok = elemBackColour( str scene, str element, str startColour, str endColour )
Set the background colour of the specified scene element.
See also: action Element Back Colour.
elemBorder
var ok = elemBorder( str scene, str element, int width, str colour )
Set the border colour and width of the specified scene element.
elemPosition
var ok = elemPosition( str scene, str element, str orientation, int x, int y, int animMS )
Move an element within it's scene.
orientation must be one of port or land. animMS indicates the duration of the corresponding animation in MS. A zero-value indicates no animation.
See also: action Element Position.
elemText
var ok = elemText( str scene, str element, str position, str text )
Set the text of the specified scene element.
pos must be one of repl (replace existing text completely), start (insert before existing text) or end (append after existing text).
See also: action Element Text.
elemTextColour
var ok = elemTextColour( str scene, str element, str colour )
Set the text colour of the specified scene element.
See also: action Element Text Colour.
elemTextSize
var ok = elemTextSize( str scene, str element, int size )
Set the text size of the specified scene element.
See also: action Element Text Size.
elemVisibility
var ok = elemVisibility( str scene, str element, boolean visible, int animationTimeMS )
Make the specified scene element visible or invisible.
See also: action Element Visibility.
endCall
var ok = endCall()
Terminate the current call (if there is one).
encryptFile
var ok = encryptFile( str path, str keyName, bool rememberKey, bool shredOriginal )
Encrypt the specified file using the encryption parameters specified in Menu / Prefs / Action.
If rememberKey is set, the entered passphrase will be reapplied automatically to the next encryption/decryption operation with the specified keyName.
If shredOriginal is specified, the original file will be overwritten several times with random bits if encryption is successful.
See Also: Encryption in the Userguide, Encrypt File action.
enterKey
var ok = enterKey( str title, str keyName, bool showOverKeyguard, bool confirm, str background, str layout, int timeoutSecs )
Show a dialog to enter the passphrase for the specified keyName. The JavaScript waits until the dialog has been dismissed or the timeout reached.
- confirm: if set, the passphrase must be entered twice to ensure it is correct.
- background: [optional] a file path or file URI to a background image.
- layout: the name of a user-created scene to use in place of the built-in scene.
See Also: Encryption in the Userguide
filterImage
bool ok = filterImage( str mode, int value )
Filter an image previously loaded into Tasker's image buffer via loadImage()
Possible values of mode are:
- bw: convert to black & white, using value as a threshold
- eblue: enhance blue values by value
- egreen: enhance green values by value
- ered: enhance red values by value
- grey: convert to greyscale, value is unused
- alpha: set pixel alpha (opposite of transparency) to value
value should be 1-254.
flipImage
bool ok = flipImage( bool horizontal )
Flip an image previously loaded into Tasker's image buffer via loadImage()
If horizontal is false, the image is flipped vertically.
exit
exit()
Stop execution of the JavaScript.
flash
flash( str message )
flashLong
flashLong( str message )
getLocation
var ok = getLocation( str source, bool keepTracking, int timeoutSecs )
Try to get a fix of the current device location.
source must be one of gps, net or any.
If keepTracking is set, the specified source(s) will be left tracking with the purpose of providing a much quicker fix next time the function is called.
Fix coordinates are stored in the global Tasker variables %LOC (GPS) and/or %LOCN (Net). The value can be retrieved with the global function. Several other parameters of the fix are also available, see Variables.
Example
var lastFix = global( 'LOC' );
if (
getLocation( 'gps' ) &&
( global( 'LOC' ) != lastFix )
) {
flash( "New fix: " + global( 'LOC' ) );
}
See also: action Get Location, function stopLocation.
getVoice
str result = getVoice( str prompt, str languageModel, int timeout )
Get voice input and convert to text.
result is 'undefined' if the voice acquisition failed, otherwise it's an array of possible matching texts.
prompt is a label for the dialog that is shown during voice acquisition.
languageMode gives the speech recognition engine a clue as to the context of the speech. It must be one of web for 'web search' or free for 'free-form'.
goHome
goHome( int screenNum )
Go to the Android home screen. screenNum is not supported by all home screens.
haptics
var ok = haptics( bool onFlag )
Enable/disable system setting Haptic Feedback.
hideScene
var ok = hideScene( str sceneName )
Hide the named scene if it's visible.
global
var value = global( str varName )
Retrieve the value of a Tasker global variable. Prefixing the name with % is optional.
Example:
flash( global( '%DogName' ) );
listFiles
str files = listFiles( str dirPath, bool hiddenToo )
List all files in the specified dirPath.
files is a newline-separated list of subfiles.
If no files or found or an error occurs, the returned value will be undef.
Example:
var files = listFiles( '/sdcard' ); var arr = files.split( '\n' ); flash( 'Found ' + arr.length + ' files' );
loadApp
var ok = loadApp( str name, str data, bool excludeFromRecents )
Start up the named app.
Name can be a package name or app label, it's tested first against known package names. Note: app label could be localized to another language if the script is used in an exported app.
Data is in URI format and app-specific.
When excludeFromRecents is true, the app will not appear in the home screen 'recent applications' list.
loadImage
var ok = loadImage( str uri )
Load an image into Tasker's internal image buffer.
The following uri formats are currently supported:
- file:// followed by a local file path
See also Load Image action.
lock
var ok = lock( str title, str code, bool allowCancel, bool rememberCode, bool fullScreen, str background, str layout )
Show a lock screen, preventing user interaction with the covered part of the screen. The JavaScript waits until the code has been entered or the lock cancelled (see below).
- code: the numeric code which must be entered for unlock
- allowCancel: show a button to remove the lockscreen, which causes a return to the Android home screen
- rememberCode: the code will be remembered and automatically entered when the lock screen is show in future, until the display next turns off
- background: [optional] a file path or file URI to a background image.
- layout: the name of a user-created scene to use in place of the built-in lock scene
local
var value = local( str varName )
Retrieve the value of a Tasker scene-local variable. The name should not be prefixed with %.
This function is only for use by JavaScript embedded in HTML and accessed via a WebView scene element.
mediaControl
var ok = mediaControl( str action )
Control media via simulation of hardware buttons.
Possible actions are next, pause, prev, toggle, stop or play.
micMute
var ok = micMute( bool shouldMute )
Mute or unmute the device's microphone (if present),
mobileData
var ok = mobileData( bool set )
Enable or disable the system Mobile Data setting.
See also: action Mobile Data
musicBack
var ok = musicBack( int seconds )
Skip back by seconds during playback of a music file previously started by musicPlay.
See also: musicSkip, musicStop
musicPlay
var ok = musicPlay( str path, int offsetSecs, bool loop, str stream )
Play a music file via Tasker's internal music player.
stream to which audio stream the music should be played
This function does not not wait for completion.
The last 3 arguments may be ommitted, in which case they default to 0, false and media respectively.
See also: musicStop, musicBack, musicSkip
musicSkip
var ok = musicSkip( int seconds )
Skip forwards by seconds during playback of a music file previously started by musicPlay.
See also: musicBack, musicStop
musicStop
var ok = musicStop()
Stop playback of a music file previously started by musicPlay.
See also: musicBack, musicSkip
nightMode
var ok = nightMode( bool onFlag )
Turn on or off Android Night Mode.
popup
var ok = popup( str title, str text, bool showOverKeyguard, str background, str layout, int timeoutSecs )
Show a popup dialog. The JavaScript waits until the popup has been dismissed or the timeout reached.
- background: [optional] a file path or file URI to a background image.
- layout: the name of a user-created scene to use in place of the built-in popup scene.
performTask
var ok = performTask( str taskName, int priority, str parameterOne, str parameterTwo )
Run the Tasker task taskName.
Note that the JavaScript does not wait for the task to complete.
profileActive
bool active = profileActive( str profileName )
Whether the named Tasker profile is currently active. Returns false if the profile name is unknown.
pulse
bool ok = pulse( bool onFlag )
Enable or disable the Android Notification Pulse system setting.
readFile
var contents = readFile( str path )
Read the contents of a text file.
reboot
var ok = reboot( str type )
Reboot the device.
type is one of normal, recovery or bootloader. It can be ommitted and defaults to normal.
Requires a rooted device.
See also: function shutdown
resizeImage
var ok = resizeImage( int width, int height )
Scale the current image in Tasker's image buffer to the specified dimensions.
rotateImage
var ok = rotateImage( str dir, int degrees )
Rotate the current image in Tasker's image buffer.
dir must be one of left or right. degrees must be one of 45, 90, 135 or 180.
saveImage
var ok = saveImage( str path, int qualityPercent, bool deleteFromMemoryAfter )
Save the current image in Tasker's image buffer to the specified file path.
Save Image action.
say
var ok = say( str text, str engine, str voice, str stream, int pitch, int speed )
Cause the device to say text out loud.
- engine: the speech engine e.g. com.svox.classic Defaults to the system default (specify undefined for that)
- voice: the voice to use (must be supported by engine). Defaults to the current system language (specify undefined for that)
- stream: to which audio stream the speech should be made
- pitch: 1-10
- speed: 1-10
The script waits for the speech to be finished.
sendIntent
var ok = sendIntent( str action, str targetComp, str package, str class, str category, str data, str mimeType, str[] extras );
Send an intent. Intents are Android's high-level application interaction system.
Any parameter may be specified as undefined.
- targetComp: the type of application component to target, one of receiver, activity or service. Defaults to receiver.
- package: the application package to limt the intent to
- class: the application class to limit the intent to
- category: one of none, alt, browsable, cardock, deskdock, home, info, launcher, preference, selectedalt, tab or test, defaults to none
- extras: extra data to pass, in the format key:value. May be undefined. Maximum length 2.
See also: action Send Intent.
sendSMS
var ok = sendSMS( str number, str text, boolean storeInMessagingApp );
Send an SMS.
See also: action Send SMS
setAirplaneMode
var ok = setAirplaneMode( bool setOn )
Enable or disable Airplane Mode.
Get the current value with:
var enabled = global( 'AIR' );
See also: function setAirplaneRadios
setAirplaneRadios
var ok = setAirplaneRadios( str disableRadios )
Specify the radios which will be disabled when the device enters Airplane Mode.
disableRadios is a comma-separated list with radio names from the following set: cell, nfc, wifi, wimax, bt.
Get the current value with:
var radios = global( 'AIRR' );
See also: function setAirplaneMode
setAlarm
var ok = setAlarm( int hour, int min, str message, bool confirmFlag )
Create an alarm in the default alarm clock app.
confirmFlag specifies whether the app should confirm that the alarm has been set.
message is optional.
Requires Android version 2.3+.
setAutoSync
var ok = setAutoSync( bool setOn )
Enable or disable the global auto-sync setting.
scanCard
var ok = scanCard( str path )
Force the system to scan the external storage card for new/deleted media.
If path is defined, only that will be scanned.
See also: action Scan Card
setBT
var ok = setBT( bool setOn )
Enable or disable the Bluetooth radio (if present).
Test BT state with:
if ( global( 'BLUE' ) == "on" ) { doSomething(); }
setBTID
var ok = setBTID( str toSet )
Set the bluetooth adapter ID (the name as seen by other devices).
setGlobal
setGlobal( str varName, str newValue )
Set the value of a Tasker global user variable. Prefixing varName with % is optional.
Arrays are not supported due to limitations of the Android JS interface.
setKey
var ok = setKey( str keyName, str passphrase )
Set the passphrase for the specified keyName.
See Also: Encryption in the Userguide.
setLocal
setLocal( str varName, str newValue )
Set the value of a Tasker scene-local user variable. Variable names should not be prefixed with %.
This function is only for use by JavaScript embedded in HTML and accessed via a WebView scene element.
setClip
var ok = setClip( str text, bool appendFlag )
Set the global system clipboard.
Test the value with:
var clip = global( 'CLIP' );
settings
var ok = settings( str screenName )
Show an Android System Settings screen.
screenName must be one of all, accessibility, addacount, airplanemode, apn, app, batteryinfo, appmanage bluetooth, date, deviceinfo, dictionary, display, inputmethod, internalstorage, locale, location, memorycard, networkoperator, powerusage, privacy, quicklaunch, security, mobiledata, search, sound, sync, wifi, wifiip or wireless.
setWallpaper
var ok = setWallpaper( str path )
Set the system home screen wallpaper.
setWifi
var ok = setWifi( bool setOn )
Enable or disable the Wifi radio (if present).
Test wifi state with:
if ( global( 'WIFI' ) == "on" ) { doSomething(); }
shell
var output = shell( str command, bool asRoot, int timoutSecs )
Run the shell command command.
asRoot will only have effect if the device is rooted.
output is 'undefined' if the shell command failed. It's maximum size is restricted to around 750K.
showScene
var ok = showScene( str name, str displayAs, int hoffset, int voffset, bool showExitIcon, bool waitForExit )
Show the named scene, creating it first if necessary.
- displayAs: options:
Overlay, OverBlocking, OverBlockFullDisplay, Dialog, DialogBlur, DialogDim, ActivityFullWindow, ActivityFullDisplay, ActivityFullDisplayNoTitle - hoffset, voffset: percentage vertical and horizontal offset for the scene -100% to 100% (not relevant for full screen/window display types)
- showExitIcon: display a small icon in the bottom right which destroys the scene when pressed
- waitForExit: whether to wait for the scene to exit before continuing the script
shutdown
var ok = shutdown()
Shutdown the device.
Requires a rooted device.
See also: reboot
silentMode
var ok = silentMode( str mode )
Set the system silent ('ringer') mode.
mode must be one of off, vibrate or on
sl4a
var ok = sl4a( str scriptName, boolean inTerminal )
Run a previously created SL4A script.
soundEffects
var ok = soundEffects( bool setTo )
Setting the system Sound Effects setting (sound from clicking on buttons etc.
speakerphone
var ok = speakerPhone( bool setFlag )
Enable or disable the speakerphone function.
statusBar
var ok = statusBar( bool expanded )
Expand or contract the system status bar.
stayOn
var ok = stayOn( str mode )
Specify whether the device should remain on when power is connected.
Possible modes are never, ac, usb, any.
stopLocation
var ok = stopLocation()
Stop tracking a location provider. This is only relevant when a getLocation function has been previously called with the keepTracking parameter set.
systemLock
var ok = systemLock()
Turn off the display and activate the keyguard.
Requires Tasker's Device Administrator to be enabled in Android settings.
taskRunning
bool running = taskRunning( str taskName )
Whether the named Tasker task is currently running. Returns false if the task name is unknown.
takeCall
bool ok = takeCall();
Auto-accept an incoming call (if there is one).
takePhoto
bool ok = takePhoto( int camera, str fileName, str resolution, bool insertGallery )
Take a photo with the builtin camera.
- camera: 0 = rear camera, 1 = front camera
- resolution: format WxH e.g. 640x840
- insertGallery: whether to insert the resulting picture in the Android Gallery application
See also: action Take Photo
type
var ok = type( str text, int repeatCount )
Simulate keyboard typing.
Requires a rooted device.
unzip
boolean ok = unzip( str zipPath, bool deleteZipAfter )
Unpack a Zip archive into the parent directory of the archive.
deleteZip causes the zip archive to be deleted after successful unpacking.
usbTether
usbTether( bool set )
Enable or disable USB tethering.
See also: action USB Tether
vibrate
vibrate( int durationMilliseconds )
Cause the device to vibrate for the specified time.
vibratePattern
vibratePattern( str pattern )
Cause the device to vibrate following the specified pattern, which consists of a sequence of off then on millisecond durations e.g.
500,1000,750,1000
wait for 500ms, vibrates 1000ms, wait for 750ms, then vibrate for 1000ms.
wait
wait( int durationMilliseconds )
Pause the script for the specified time.
Warning: may cause some preceeding functions not to complete in some situations. If in doubt, use JavaScript setTimeout() instead.
wifiTether
var ok = wifiTether( bool set )
Enable or disable Wifi tethering.
See also: action Wifi Tether
writeFile
var ok = writeFile( str path, str text, bool append )
Write text to file path.
If append is specified, the text will be attached to the end of the existing file contents (if there are any).
zip
boolean ok = zip( str path, int level, bool deleteOriginalAfter )
Zip a file or directory.
level is the desired compression level from 1-9, with 9 resulting in the smallest file and the longest compression time.
deleteOriginal causes path to be deleted if the zip operation is successful.
Notes
Audio Streams
Must be one of call, system, ringer, media, alarm or notificationColours
Colours are specified in AARRGGBB hexadecimal format, with solid white being FFFFFFFF.File Paths
File paths can be specified as either absolute (start with /) or relative (don't start with /).
Relative file paths are relative to the root of the internal storage media.
So, for example, pics/me.jpg might resolve
to /sdcard/pics/me.jpg.
Location Without Tears
This is an overview guide to choosing a method for fixing your location with Tasker. At the end are some advanced power-saving strategies.
Power / Accuracy Comparison
| Method | Power Usage | Acc | Network | Wifi | BT |
|---|---|---|---|---|---|
| State: Cell Near | * | * | |||
| State: BT Near | ** | ***** | Y | ||
| Location: Net | ** | ** | Y | ||
| Location: Net & Wifi | *** | */***** | Y | Y | |
| State: Wifi Near | **** | ***** | Y | ||
| Location: GPS | ***** | ***** | Y |
More stars mean higher power usage or higher accuracy (Acc).
Detail Comparison
State: Cell Near
Setup
Create a state context, select Phone then Cell Near. Click Update and walk around a bit to scan for cell towers nearby.About
Uses information about the cell towers the phone uses for telephony to record and match a location.
When the display is off, frequency of checks is controlled by Prefs / Monitor / Display Off All Checks.
If your profile keeps deactivating, go back to the Cell Near state and click the magnifying glass icon to check for cells you may have missed in your scan.
Plus / Minus
- (+) virtually no extra power on top of power needed for normal phone service
- (+) when the display is on, context updates as soon as the tower is visible
- (+) when the display is off, only one check period is needed to determine context exit
- (-) highly inaccurate
- (-) must be physically at the location in order to record it
Other Settings
Monitor / General Monitoring / Use New Cell API: if you're not seeing any cells at all when scanning on a modern device, try checking thisMonitor / Display Off Monitoring / Cell Workaround: if things aren't working when the display is offMonitor / Display Off Monitoring / Cell Wake Screen: second possible workaround when the display is off
State: BT Near
Setup
Create a State context, click BT Near (in the Net category), fill in the name or address of a bluetooth device near the location you want to identify.About
BT Near does regular bluetooth Scans and will activate when it recognizes a device you have configured is nearby. Note: you don't have to connect to the device, so it doesn't have to be a device you own.
Frequency of checks is controlled by Prefs / Monitor / BT Scan Seconds (screen on) and Prefs / Monitor / Display Off All Checks (screen off).
Check the BT Toggle box if you don't want bluetooth enabled all the time. It will then be toggled when Tasker needs to do a scan.
If your target device is a low-energy device, deselect Standard Devices to reduce energy usage. If you can pair with the target device, you can have a major reduction in power usage and scan times by not selecting Non-Paired Devices.
Plus / Minus
- (+) very good accuracy, reliability
- (+) modest power usage, especially for paired devices
- (+) works indoors too
- (-) need a known device nearby
Other Settings
Prefs / Monitor / Display Off Monitoring / Motion Detection: if available on your device, will need to be disabled if you wish to detect a nearby BT device that may move or turn off or on
Location: Net
Setup
Create a location context, and deselect GPS.About
Net location accuracy varies greatly. It's very important that you create a large radius around the spot you wish to detect.
Frequency of checks is controlled by Prefs / Monitor / Network Location Check (screen on)
and Prefs / Monitor / Display Off All Checks.
Plus / Minus
- (+) extremely low (extra) power (IF network is available anyway)
- (-) requires network and phone service
- (-) highly inaccurate and variable fixes
Location: Net & Wifi
Setup
Create a location context and deselect GPS. Make sure your device's Wifi is turned on when you want a more accurate location fix.About
Net location can be assisted by nearby access points when Wifi is turned on (Google has a map of APs for many areas).
Turn Wifi off when not needed to conserve power e.g. use a Time context to turn wifi off at night.
Plus / Minus
- (+) very good accuracy in built-up areas for relatively low power usage
- (-) must be physically at the location in order to record it
State: Wifi Near
Setup
Create a State context, click Wifi Near (in the Net category), fill in the SSID of an Access Point (AP) with the best signal near where you want to identify.About
Wifi Near does regular Wifi Scans and will activate when it recognizes an AP you have configured is nearby. Note: you don't have to connect to the AP. You could configure e.g. the neighbours AP if the signal is strong enough.
Frequency of checks is controlled by Prefs / Monitor / Wifi Scan Seconds (screen on) and Prefs / Monitor / Display Off All Checks (screen off).
Check the Wifi Toggle box if you don't want wifi on all the time. It will then be toggled when Tasker needs to do a scan. This isn't needed in
In Android 4.4+ if you select Scanning Always Available in Advanced Wifi Settings and will save power.
Plus / Minus
- (+) very good accuracy and reliability
- (+) less power than GPS
- (+) works indoors too
- (-) need an AP nearby
Other Settings
Prefs / Monitor / Display Off Monitoring / Motion Detection: if available on your device, will need to be disabled if you wish to detect an AP that may turn off and on.
Location: GPS
Setup
Create a location context, and deselect Net.About
Frequency of GPS checks is controlled by Prefs / Monitor / GPS Check (screen on)
and Prefs / Monitor / Display Off All Checks. Higher frequencies mean
more battery usage but that location changes will be noticed more quickly.
When indoors, GPS will try a long time to get a signal, using a lot of battery. Adjust
it at Prefs / Monitor / GPS Timeout. Make the
timeout as low as you can until you start losing effectiveness.
Plus / Minus
- (+) highly accurate in the open air
- (-) functions very poorly or not at all indoors. A bad side effect is that if you enter a building e.g. office while between the check times, it may never detect your new location until you leave.
- (-) extreme power usage
- (-) needs network to get a first fix
Other Settings
Prefs / Monitor / Display Off Monitoring / Motion Detection: if available on your device, will need to be disabled if you wish to detect changes of location on the order of a few meters.
Advanced Strategies
Motion Detection
Some devices have a low-power accelerometer that can be active while the rest of the device is sleeping.
For such devices, Tasker will not do location checks with the display off unless it detects that significant movement has taken place since the last check, resulting in lower power usage and faster response times when the device does eventually move.
Multiple Contexts
Tasker does not check high-power contexts until all lower-power contexts in the same profile are active. You can use this to reduce power consumption. For instance, if you use the Wifi Near state to detect coming home, you could add a Location: Net context to the same profile, so that wifi scanning will only take place when you are in the right neighbourhood.Location Control
Disable GPS/Net location when they're not needed by creating a separate profile with e.g. a Time context which disables GPS during the night.This works because Location contexts assume you are in the same location until there is a fix which says otherwise.