@amazon-devices/kepler-system-info

{
    "dependencies": {
        "@amazon-devices/kepler-system-info": "~1.0.2",
        "@amazon-devices/keplerscript-turbomodule-api": "~1.2.5"
    }
}

npm install

import { SystemInfoModule, ISystemInfo } from '@amazon-devices/kepler-system-info';

// Get the main SystemInfo interface
let systemInfo: ISystemInfo;
try {
    systemInfo = SystemInfoModule.getSystemInfo();
    console.log('SystemInfo initialized successfully');
} catch (error) {
    console.error('Failed to initialize SystemInfo:', error);
    throw error;
}

import { MonotonicDuration, RawTimeValue } from '@amazon-devices/kepler-system-info';

async function getSystemUptime() {
    try {
        const uptime: MonotonicDuration = await systemInfo.getUptime();
        const timeValue: RawTimeValue = uptime.time;

        console.log('System Uptime:');
        console.log(`Seconds: ${timeValue.seconds}`);
        console.log(`Nanoseconds: ${timeValue.nanoseconds}`);

        // Convert to human-readable format
        const totalSeconds = timeValue.seconds;
        const hours = Math.floor(totalSeconds / 3600);
        const minutes = Math.floor((totalSeconds % 3600) / 60);
        const seconds = totalSeconds % 60;

        console.log(`Human readable: ${hours}h ${minutes}m ${seconds}s`);

        return uptime;
    } catch (error) {
        console.error('Failed to get system uptime:', error);
        throw error;
    }
}

function checkEmulatorStatus() {
    try {
        const isEmulator = systemInfo.isEmulator();
        console.log(`Running in emulator: ${isEmulator ? 'Yes' : 'No'}`);

        if (isEmulator) {
            console.log('Development/Testing environment detected');
        } else {
            console.log('Production environment detected');
        }

        return isEmulator;
    } catch (error) {
        console.error('Failed to check emulator status:', error);
        throw error;
    }
}

import { IOperatingSystemInfo } from '@amazon-devices/kepler-system-info';

function getOperatingSystemInfo() {
    try {
        const osInfo: IOperatingSystemInfo =
            systemInfo.getOperatingSystemInfo();

        // Get OS details
        const displayName = osInfo.getDisplayName();
        const codeName = osInfo.getCodeName();
        const version = osInfo.getVersion();

        console.log('Operating System Information:');
        console.log(`Display Name: ${displayName}`);
        console.log(`Code Name: ${codeName}`);
        console.log(`Version: ${version}`);

        return {
            displayName,
            codeName,
            version,
            osInfo,
        };
    } catch (error) {
        console.error('Failed to get OS information:', error);
        throw error;
    }
}

import {
    IBuildInfo,
    RealTimeInstant,
    RawTimeValue,
} from '@amazon-devices/kepler-system-info';

function getBuildInformation(osInfo: IOperatingSystemInfo) {
    try {
        const buildInfo: IBuildInfo = osInfo.getBuildInfo();

        // Basic build information
        const displayName = buildInfo.getDisplayName();
        const buildId = buildInfo.getId();
        const variant = buildInfo.getVariant();
        const fingerprint = buildInfo.getFingerprint();

        // Build timestamp
        const timestamp: RealTimeInstant = buildInfo.getTimestamp();
        const timeValue: RawTimeValue = timestamp.time;
        const buildDate = new Date(timeValue.seconds * 1000);

        // Build tags
        const tags: string[] = buildInfo.getTags();

        console.log('Build Information:');
        console.log(`Display Name: ${displayName}`);
        console.log(`Build ID: ${buildId}`);
        console.log(`Variant: ${variant}`);
        console.log(`Fingerprint: ${fingerprint}`);
        console.log(`Build Date: ${buildDate.toISOString()}`);
        console.log(`Tags: ${JSON.stringify(tags, null, 2)}`);

        return {
            displayName,
            buildId,
            variant,
            fingerprint,
            buildDate,
            tags,
            buildInfo,
        };
    } catch (error) {
        console.error('Failed to get build information:', error);
        throw error;
    }
}

import {
    SystemInfoModule,
    ISystemInfo,
    IOperatingSystemInfo,
    IBuildInfo,
    MonotonicDuration,
    RealTimeInstant,
    RawTimeValue,
} from '@amazon-devices/kepler-system-info';

class SystemInfoService {
    private systemInfo: ISystemInfo;

    constructor() {
        try {
            this.systemInfo = SystemInfoModule.getSystemInfo();
            console.log('SystemInfoService initialized');
        } catch (error) {
            console.error('Failed to initialize SystemInfoService:', error);
            throw error;
        }
    }

    async getCompleteSystemInfo() {
        try {
            // System-level information
            const uptime = await this.systemInfo.getUptime();
            const isEmulator = this.systemInfo.isEmulator();

            // Operating system information
            const osInfo = this.systemInfo.getOperatingSystemInfo();
            const osDisplayName = osInfo.getDisplayName();
            const osCodeName = osInfo.getCodeName();
            const osVersion = osInfo.getVersion();

            // Build information
            const buildInfo = osInfo.getBuildInfo();
            const buildDisplayName = buildInfo.getDisplayName();
            const buildId = buildInfo.getId();
            const buildVariant = buildInfo.getVariant();
            const buildFingerprint = buildInfo.getFingerprint();
            const buildTimestamp = buildInfo.getTimestamp();
            const buildTags = buildInfo.getTags();

            return {
                system: {
                    uptime: {
                        seconds: uptime.time.seconds,
                        nanoseconds: uptime.time.nanoseconds,
                        humanReadable: this.formatUptime(uptime.time.seconds),
                    },
                    isEmulator,
                },
                operatingSystem: {
                    displayName: osDisplayName,
                    codeName: osCodeName,
                    version: osVersion,
                },
                build: {
                    displayName: buildDisplayName,
                    id: buildId,
                    variant: buildVariant,
                    fingerprint: buildFingerprint,
                    timestamp: {
                        seconds: buildTimestamp.time.seconds,
                        nanoseconds: buildTimestamp.time.nanoseconds,
                        date: new Date(
                            buildTimestamp.time.seconds * 1000,
                        ).toISOString(),
                    },
                    tags: buildTags,
                },
            };
        } catch (error) {
            console.error('Failed to get complete system info:', error);
            throw error;
        }
    }

    private formatUptime(seconds: number): string {
        const hours = Math.floor(seconds / 3600);
        const minutes = Math.floor((seconds % 3600) / 60);
        const secs = seconds % 60;
        return `${hours}h ${minutes}m ${secs}s`;
    }
}

// Usage
async function main() {
    try {
        const service = new SystemInfoService();
        const systemInfo = await service.getCompleteSystemInfo();

        console.log('Complete System Information:');
        console.log(JSON.stringify(systemInfo, null, 2));
    } catch (error) {
        console.error('Application error:', error);
    }
}

main();

try {
    const systemInfo = SystemInfoModule.getSystemInfo();
    const uptime = await systemInfo.getUptime();
    // Process uptime...
} catch (error) {
    if (error instanceof Error) {
        console.error(`SystemInfo Error: ${error.message}`);
        console.error(`Stack trace: ${error.stack}`);
    } else {
        console.error('Unknown error occurred:', error);
    }

    // Handle error appropriately for your application
    throw error; // Re-throw if needed
}