I’m stilll unclear as to the bigger picture on this of what you are switching out of Shortcuts to do (that you can’t already do in Shortcuts). I can see you are doing something with car tracking, but only in terms of data being passed back. To that end I’ll cover various options with the help of some Scriptable scripts and a Shortcuts shortcut.
The Scriptable Scripts
To follow along, copy and paste each of these scripts into a new script entry in Scriptable. The name is very important, and they could be named CarLog1, CarLog2 and CarLog3 respectively for the purposes of this example.
Scriptable Script: CarLog1
// Capture details
let alertInput = new Alert();
alertInput.title = "Enter car log details";
alertInput.message = "Please complete the details in each field below";
alertInput.addTextField("Enter trip description");
alertInput.addTextField("Enter the Initial Odometer Reading here");
alertInput.addTextField("Enter the Final Odometer Reading here");
alertInput.addAction("OK")
await alertInput.presentAlert();
// Populate JSON
let jsonCar = {};
jsonCar.date = new Date;
jsonCar.trip = alertInput.textFieldValue(0);
jsonCar.odometer = alertInput.textFieldValue(1);
jsonCar.final_odometer = alertInput.textFieldValue(2);
jsonCar.mileage = jsonCar.final_odometer - jsonCar.odometer;
console.log(jsonCar);
// Because we have had to switch to the Scriptable app from Shortcuts,
// we have to 'force' our way back with a URL (not x-callback-url as we
// are returning to shortcuts) call, and use the clipboard as a place to
// transfer the data
Pasteboard.copy(JSON.stringify(jsonCar));
Safari.open("shortcuts://");
Scriptable Script: CarLog2
// Populate JSON without human interaction
let jsonCar = {};
jsonCar.date = new Date;
jsonCar.trip = "Driving from A to B";
jsonCar.odometer = 111;
jsonCar.final_odometer = 333;
jsonCar.mileage = jsonCar.final_odometer - jsonCar.odometer;
console.log(jsonCar);
// We have no alerts in this script, so the script can pass back the results
// to Shortcuts directly. This could be used if you are picking up content from
// a calendar and car information API for example.
Script.setShortcutOutput(JSON.stringify(jsonCar));
Script.complete
Scriptable Script: CarLog3
// Capture details
let alertInput = new Alert();
alertInput.title = "Enter car log details";
alertInput.message = "Please complete the details in each field below";
alertInput.addTextField("Enter trip description");
alertInput.addTextField("Enter the Initial Odometer Reading here");
alertInput.addTextField("Enter the Final Odometer Reading here");
alertInput.addAction("OK")
await alertInput.presentAlert();
// Populate JSON
let jsonCar = {};
jsonCar.date = new Date;
jsonCar.trip = alertInput.textFieldValue(0);
jsonCar.odometer = alertInput.textFieldValue(1);
jsonCar.final_odometer = alertInput.textFieldValue(2);
jsonCar.mileage = jsonCar.final_odometer - jsonCar.odometer;
console.log(jsonCar);
// This time we have called Scriptable using an x-call-back-url.
// Scriptabe doesn't have x-callback-url support built in per se,
// but we can handle the x-callback operation in code.
// To do this, we will access the x-success parameter passed to the script
// and append the JSON weve built as a result. To do this, we need to first
// convert the JSON to a string, then encode it for transfer via URL, and then
// append it as a suitable x-callback parameter for Shortcuts to utlise.
let queryParams = URLScheme.allParameters();
let urlSuccess = queryParams["x-success"] + "?result=" + encodeURI(JSON.stringify(jsonCar));
Safari.open(urlSuccess);
There is actually a fourth script too, but that’s embedded inside of the shortcut.
The Shortcuts Shortcut
Now that the Scriptable scripts are in place, download the following shortcut and ensure that you have set the permissions for running third party shortcuts. As always with downloaded shortcuts (and code), please look through it before running to reassure yourself that it is safe to run.
When the shortcut is run, it will execute four different ways of calling a Scriptable script to retrieve a set of car log related data in a dictionary format. In each case, to show it is retrieving data from a dictionary being created by Scriptable, the shortcut will subsequently show the name of the trip and the mileage based on the construction of a dictionary containing the following root level elements.
-
date - the current date in a standard format (e.g.
2020-02-01T13:14:15.161Z), created by code.
-
trip - a description of the trip, entered manually or set by code.
-
odometer - an initial odometer reading, entered manually or set by code.
-
final_odometer - a final odometer reading, entered manually or set by code.
-
mileage - the miles recorded by taking the difference in the odometer readings, calculated by code.
Note the variation in some of manual or code determination. You’ll see these vary across the examples. I’ve had to go this route because at this point there was no way to narrow down how the data would be gathered. e.g. from manual entry, reading from a log file that has been generated, or direct access to a car information API.
Please note:
- These are examples for demonstration purposes I’ve foregone adding in any content validation, error handling, etc.
- These calls are not passing any data into Scriptable from Shortcuts, though this is possible.
Call 1: Shortcuts Scriptable Action - Scriptable Run in App
In the first call, the shortcut uses a standard Scriptable action to run a script in the Scriptable app. The action is set to execute the script in the Scriptable app. This is necessary because CarLog1 uses an interactive UI element (an Alert) to capture information from the user. Shortcuts can’t access Scriptable in this way internally, and so we have to switch into the Scriptable app to do it.
Once in Scriptable, the JSON is built and then copied to the clipboard. It isn’t my favourite way of passing data around as it overwrites the clipboard, but you can workaround this by capturing and restoring the clipboard in Shortcuts around calling the Scriptable script.
The Scriptable script finally just opens the Shortcuts app. Because of the wait to return action after the Scriptable action, this should just pick up where we left off when we get back to Shortcuts.
Shortcuts then displays the example result from the dictionary it picked up from the clipboard.
Call 2: Shortcuts Scriptable Action - Scriptable Not Run in App
If we are calling a Scriptable script that requires no data entry by the user, we can opt not to switch to the Scriptable app to run the script; though it should be noted there are other reasons, such as memory constraints for example, why you might opt to run a Scriptable script in app rather than in Shortcuts.
This time we will use the Shortcuts output option in Scriptable as we are not switching to the app. This means no clipboard overwriting. We simply set the output as a stringified version of the JSON, and set the script to complete.
We can then extract the dictionary from the output of the Scriptable script triggering action, and show the results as before.
Call 3: X-Callback-URL Action - Scriptable Run in App
The third option is to use x-callback-url, which is the one that the original question was around and where I suggested perhaps asking a more open ended question including details about what you actually wanted to do.
Scriptable does not natively support x-callback-url. It has a URL scheme, but that is not the same thing. x-callback-url requires a URL scheme to be in place, but a URL scheme does not necessitate the availability of an x-callback-url solution. But this is Scriptable. We can work around the lack of a inbuilt x-callback-url provision without too much effort.
We start by passing the Scriptable script run URL (available for example from script properties in Scriptable) to a Shortcuts action to open an x-callback-url. The Scriptable script is opened in app, so we can utilise the manual data entry once again if required (but it isn’t necessary), and at the end we can use some code to build our own x-callback-url.
When Shortcuts calls Scriptable, it generated an x-success parameter. We can query that from the script and append the JSON as an additional parameter; after converting it to a string and URL encoding it so that it can safely be included in a URL. Then we trigger the URL to open and we’re back in Shortcuts. We’re just carrying out the actions an app with built-in x-callback-url would in our own code.
Note that because we are doing x-callback-url, in this approach we don’t need to split the shortcut to have a pre-script-run shortcut and a post-script-run shortcut. Also by eliminating hard coding the shortcut to call back to, we have the potential for greater reusability of the Scriptable script.
Once back in shortcuts, the result from the x-callback-url can be extracted, converted to a dictionary and used to display the next result.
Call 4: Shortcuts Inline Scriptable Action - Scriptable Not Run in App
The final example uses the newest Scriptable action for Shortcuts and allows a script to be run inline. In this approach there is no fourth file in Scriptable. Instead the script is held within a field in the action, and is passed through to Scriptable behind the scenes to be run.
This is very similar to the second example and the exchange of the resulting JSON in both the script and the shortcut work in just the same way.
Summary
So there you have a handful of options. Not all are applicable in all cases and some are easier to implement and to follow than others, but hopefully you can follow along with each example.
Of course the fifth option that I eluded to at the start is to do everything purely in Shortcuts. I’m still left wondering what the driver is for needing to switch between the two. Reasons absolutely can and do exist, otherwise the actions wouldn’t exist, but as it stands, for the kind of thing being discussed, I currently just don’t see what it would be.
I hope that the above helps, and please do elaborate on the bigger picture. We may be able to advise further.
