Autox.js v7 Documentation

You can await an array containing a mix of promises, async functions, and synchronous values. bluebird-co will automatically resolve the elements within the array.

async function() {
    let res = await [asyncFunc1(), asyncFunc2(), somePromise, 42];
}

bluebird-co supports standard error handling patterns (top-level, nested, and deep errors) within async functions and generators.

Performance Note: bluebird-co is slightly slower at error handling compared to co because errors must pass through the Bluebird.coroutine circuitry rather than being thrown directly. However, this is typically negligible unless your application is throwing an extremely high volume of errors.

//Top level error
async function() {
    await undefined;
}

//nested error
async function() {
    await function*() {
        yield undefined;
    }
}

//deep error
async function() {
    let i = 0;

    await function*() {
        if(i++ > 2000) throw new Error();

        yield Promise.resolve(i);
    }
}

bluebird-co provides automatic traversal for ES6 iterables (like Set, Map, and TypedArray). It behaves similarly to Array.from but automatically resolves any asynchronous values encountered during traversal.

Note: While native for..of loops in modern environments can iterate through iterables, they do not automatically resolve asynchronous values; bluebird-co's approach handles this resolution for you.

let mySet = new Set( [Promise.resolve( 1 ), 2, [Promise.resolve( 3 ), 4], 5] );

async function() {
    let values = await mySet.values();

    console.log(values); //[1, 2, [3, 4], 5]
}

A thunk is a function that accepts a callback (usually done) and calls it with the result. bluebird-co allows you to await these thunks directly.

function get(value) {
    return function(done) {
        done(null, value); //single argument
    }
}

async function() {
    let value = await get(10);

    console.log(value); //10
}

In the Autox.js v7 second-generation API, UI construction has moved away from traditional XML and E4X. Instead, it uses a system where Vue 3 (specifically @vue/runtime-core) and htm are used as the template engine on the JavaScript side, which then renders to Jetpack Compose on the Android side.

Key architectural points:

• It is not a standard web Vue environment; you cannot use all Vue features or standard web UI frameworks.
• It uses a custom renderer that maps Vue Vnodes to Jetpack Compose components.
• The script thread is always separated from the UI thread, meaning you do not need to include 'ui'; at the top of your script as you did in the 1st generation API.
• You can launch multiple Activities by calling startActivity with different app instances.

bluebird-co can consume generator functions that yield promises. This allows for complex asynchronous control flows using generator syntax.

function* test(iterations){
    let i = 0;

    while(i++ < iterations) {
        yield Promise.resolve(i);
    }
}

async function() {
    await test(100);
}

bluebird-co allows you to await simple promises within an async function. It is optimized for performance when using Bluebird promises.

async function() {
    let res = await Promise.resolve(1);

    console.log(res); //1
}

You can await an object where the values are promises, async functions, or synchronous values. bluebird-co will resolve the object's values.

async function() {
    let res = await {
        a: asyncFunc1(),
        b: asyncFunc2(),
        c: somePromise,
        d: 42
    };
}

If you prefer using Android Studio to manage the deployment:

1. Run the template build command in the terminal:

   ./gradlew app:buildDebugTemplateApp

2. Click the Run button in Android Studio to deploy to your device.