Interface InfiniteApiControllerInterface

The InfiniteApiControllerInterface interface is the core singleton of the 3djuump infinite javascript API.

It provides access to the following services :

• Font loading system.
• Logging System.
• Power saving management and 3djuump infinite internal clock.
• Browser detection.

The Font loading mechanism is available through getFontLoader.

The font loading mechanism may be done with the following :

/** 
 * Sample to illustrate the Loading of fonts.
 */
import { FontLoaderInterface, InfiniteFactory, FontLoaderInterfaceSignal, InfiniteEvent, FontLoadingStatus, FontInterface } from 'generated/documentation/appinfiniteapi';

// font loading is used wheen loading annotations

// what to do when fonts are loaded
let lFontLoaded : (pEvent : InfiniteEvent) => void;
// get the font loader, no need to create it, all the time available (singleton)
const lFontLoader : FontLoaderInterface = InfiniteFactory.GetInfiniteApiController().getFontLoader();
// register font Open Sans normal (no bold, no italic) by its url
const lFontRegistered : boolean = lFontLoader.registerFont('Open Sans', false, false, 'resources/fonts/OpenSans-Regular.otf');
console.assert(lFontRegistered, 'font should be registered');

// what to do when fonts is loaded ?
lFontLoader.addEventListener(FontLoaderInterfaceSignal.FontsLoaded, lFontLoaded)
// load explicitly font, if not, font will be loaded if required when loading annotations
const lLoadStatus : FontLoadingStatus = lFontLoader.loadFont('Open Sans', false, false);
console.assert(lLoadStatus === FontLoadingStatus.FLS_LoadingStarted, 'Font loading should be started');

// when fonts are loaded => what do we do ?
// perhaps some gui code ?
lFontLoaded = (_pEvent : InfiniteEvent) : void =>
{
    // get all registered fonts and their status
    const lFonts : Array<FontInterface> = [];
    lFontLoader.getRegisteredFonts(lFonts);
    let i : number;
    let lErrorCount : number = 0;
    for (i = 0; i < lFonts.length; ++i)
    {
        if (lFonts[i].error !== undefined)
        {
            ++lErrorCount;
        }
    }
    console.assert(lErrorCount === 0, 'There should be no font in error');
    // when font is loaded, we unload it, but perhaps we should make some gui code ? :)
    lFontLoader.unregisterFont('Open Sans', false, false);
}

The logging system is based on string messages with a criticality and a timestamp (date). The 3djuump infinite javascript API may log messages when key events occur.

You may :

• Discard messages that have a strictly lower criticality than the logger current log level (setLogLevel, getLogLevel, LogLevel).
• Customize the way logging is done on a specific criticality (setLogLevelBehavior, LogBehavior, InfiniteLogger).
• Add log messages (addLog).

/** 
 * Sample to illustrate the use of the logging system.
 */
import { InfiniteApiControllerInterface, InfiniteFactory, InfiniteLogger, LogLevel, LogBehavior } from 'generated/documentation/appinfiniteapi';

// a custom logger
class MyLogger implements InfiniteLogger
{
    // just output a fancy message, but you may use your own GUI
    addLog(pContent : string, pDate : Date, pLevel : LogLevel) : void
    {
        console.log('got log ' + pContent + ' at time ' + pDate + ' at level ' + pLevel);
    }
}

// the api controller interface (no need to create it, it is available !)
const lControllerInterface : InfiniteApiControllerInterface = InfiniteFactory.GetInfiniteApiController();
// create our custom logger
const lLogger : MyLogger = new MyLogger();
// no message less than information
lControllerInterface.setLogLevel(LogLevel.LL_Information);
// and we use our custom logger for the Information level
lControllerInterface.setLogLevelBehavior(LogLevel.LL_Information, LogBehavior.LB_LogToObject, lLogger);

// add some logs
lControllerInterface.addLog('this log should be discarded', LogLevel.LL_Debug);

lControllerInterface.addLog('this log should be displayed with my fancy logger', LogLevel.LL_Information);

The power saving system may be used to lower the CPU usage of the API when the browser is hidden. The 3djuump infinite javascript API features an internal clock that ticks every 16 milliseconds if the browser has the focus, and every 1 second when the browser has not the focus and power saving is enabled. When the internal clock ticks, the infinite objects are updated and calculated, and the [Tick](../enums/InfiniteApiControllerInterfaceSignal.html#Tick) signal is sent when all objects have been updated. Please note that the [DisplayDone](../enums/InfiniteEngineInterfaceSignal.html#DisplayDone) signal is sent by the [InfiniteEngineInterface](InfiniteEngineInterface.html) when the **rendering** is done (this is not at the same moment than [Tick](../enums/InfiniteApiControllerInterfaceSignal.html#Tick)). Power saving is enabled with [setPowerSavingEnabled](InfiniteApiControllerInterface.html#setPowerSavingEnabled).

The browser detection is based on bowser. At the start of the API, the running browser is detected and getBrowserName, getBrowserType, getBrowserVersion provide information about the current browser. The browser type is a BrowserType that helps identify the current browser.

NB : In case of Microsoft Edge, two versions exist, one is chromium based, the other not, and isEdgeChromium helps to disambiguate the two.

See

• InfiniteApiControllerInterfaceSignal
• FontLoaderInterface
• LogLevel
• LogBehavior
• InfiniteLogger
• BrowserType