@webos-tools/cli 3.1.1 → 3.1.3

package/files/templates/apollo-sdk-templates/js-service/helloworld_webos_service.js

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// helloworld_webos_service.js
+// is simple service, based on low-level luna-bus API
+
+// eslint-disable-next-line import/no-unresolved
+const pkgInfo = require('./package.json');
+const Service = require('webos-service');
+
+const service = new Service(pkgInfo.name); // Create service by service name on package.json
+const logHeader = "[" + pkgInfo.name + "]";
+let greeting = "Hello, World!";
+
+// a method that always returns the same value
+service.register("hello", function(message) {
+    console.log(logHeader, "SERVICE_METHOD_CALLED:/hello");
+    console.log("In hello callback");
+    const name = message.payload.name ? message.payload.name : "World";
+
+    message.respond({
+        returnValue: true,
+        Response: "Hello, " + name + "!"
+    });
+});
+
+// set some state in the service
+service.register("/config/setGreeting", function(message) {
+    console.log(logHeader, "SERVICE_METHOD_CALLED:/config/setGreeting");
+    console.log("In setGreeting callback");
+    if (message.payload.greeting) {
+        greeting = message.payload.greeting;
+    } else {
+        message.respond({
+            returnValue: false,
+            errorText: "argument 'greeting' is required",
+            errorCode: 1
+        });
+    }
+    message.respond({
+        returnValue: true,
+        greeting: greeting
+    });
+});
+
+// call another service
+service.register("time", function(message) {
+    console.log(logHeader, "SERVICE_METHOD_CALLED:/time");
+    console.log("time callback");
+    service.call("luna://com.webos.service.systemservice/clock/getTime", {}, function(m2) {
+        console.log(logHeader, "SERVICE_METHOD_CALLED:com.webos.service.systemservice/clock/getTime");
+        const response = "You appear to have your UTC set to: " + m2.payload.utc;
+        console.log(response);
+        message.respond({message: response});
+    });
+});
+
+// handle subscription requests
+const subscriptions = {};
+let interval;
+let x = 1;
+function createInterval() {
+    if (interval) {
+        return;
+    }
+    console.log(logHeader, "create_interval");
+    console.log("create new interval");
+    interval = setInterval(function() {
+        sendResponses();
+    }, 1000);
+}
+
+// send responses to each subscribed client
+function sendResponses() {
+    console.log(logHeader, "send_response");
+    console.log("Sending responses, subscription count=" + Object.keys(subscriptions).length);
+    for (const i in subscriptions) {
+        if (Object.prototype.hasOwnProperty.call(subscriptions, i)) {
+            const s = subscriptions[i];
+            s.respond({
+                returnValue: true,
+                event: "beat " + x
+            });
+        }
+    }
+    x++;
+}
+
+// listen for requests, and handle subscriptions via implicit event handlers in call
+// to register
+service.register("heartbeat", function(message) {
+    const uniqueToken = message.uniqueToken;
+    console.log(logHeader, "SERVICE_METHOD_CALLED:/heartbeat");
+    console.log("heartbeat callback, uniqueToken: " + uniqueToken + ", token: " + message.token);
+    message.respond({event: "beat"});
+    if (message.isSubscription) {
+        subscriptions[uniqueToken] = message;
+        if (!interval) {
+            createInterval();
+        }
+    }
+},
+function(message) {
+    const uniqueToken = message.uniqueToken;
+    console.log("Canceled " + uniqueToken);
+    delete subscriptions[uniqueToken];
+    const keys = Object.keys(subscriptions);
+    if (keys.length === 0) {
+        console.log("no more subscriptions, canceling interval");
+        clearInterval(interval);
+        interval = undefined;
+    }
+});
+
+// EventEmitter-based API for subscriptions
+// note that the previous examples are actually using this API as well, they're
+// just setting a "request" handler implicitly
+const heartbeat2 = service.register("heartbeat2");
+heartbeat2.on("request", function(message) {
+    console.log(logHeader, "SERVICE_METHOD_CALLED:/heartbeat2/request");
+    console.log("heartbeat callback");
+    message.respond({event: "beat"});
+    if (message.isSubscription) {
+        subscriptions[message.uniqueToken] = message;
+        if (!interval) {
+            createInterval();
+        }
+    }
+});
+heartbeat2.on("cancel", function(message) {
+    console.log(logHeader, "SERVICE_METHOD_CALLED:/heartbeat2/cancel");
+    console.log("Canceled " + message.uniqueToken);
+    delete subscriptions[message.uniqueToken];
+    const keys = Object.keys(subscriptions);
+    if (keys.length === 0) {
+        console.log("no more subscriptions, canceling interval");
+        clearInterval(interval);
+        interval = undefined;
+    }
+});
+
+service.register("ping", function(message) {
+    console.log(logHeader, "SERVICE_METHOD_CALLED:/ping");
+    console.log("Ping! setting up activity");
+    const methodName = "luna://" + pkgInfo.name + "/pong";
+    const activitySpec = {
+        "activity": {
+            "name": "My Activity", // this needs to be unique, per service
+            "description": "do something", // required
+            "background": true,    // can use foreground or background, or set individual properties (see Activity Specification below, for details)
+            "persist": true,       // this activity will be persistent across reboots
+            "explicit": true,      // this activity *must* be completed or cancelled explicitly, or it will be re-launched until it does
+            "callback": {          // what service to call when this activity starts
+                "method": methodName, // URI to service
+                "params": {        // parameters/arguments to pass to service
+                }
+            }
+        },
+        "start": true,             // start the activity immediately when its requirements (if any) are met
+        "replace": true,           // if an activity with the same name already exists, replace it
+        "subscribe": false         // if "subscribe" is false, the activity needs to be adopted immediately, or it gets canceled
+    };
+    service.call("luna://com.webos.service.activitymanager/create", activitySpec, function(reply) {
+        console.log(logHeader, "SERVICE_METHOD_CALLED:com.webos.service.activitymanager/create");
+        const activityId = reply.payload.activityId;
+        console.log("ActivityId = " + activityId);
+        message.respond({msg: "Created activity "+ activityId});
+    });
+});
+
+service.register("pong", function(message) {
+    console.log(logHeader, "SERVICE_METHOD_CALLED:/pong");
+    console.log("Pong!");
+    console.log(message.payload);
+    message.respond({message: "Pong"});
+});
+
+service.register("/do/re/me", function(message) {
+    console.log(logHeader, "SERVICE_METHOD_CALLED://do/re/me");
+    message.respond({verses:[
+        {doe: "a deer, a female deer"},
+        {ray: "a drop of golden sun"},
+        {me: "a name I call myself"}
+    ]});
+});

package/files/templates/apollo-sdk-templates/native-service/CMakeLists.txt

@@ -0,0 +1,72 @@
+# Copyright (c) 2020-2024 LG Electronics, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 2.8.7)
+project(nativeService C)
+
+# set link directory
+#link_directories(${CMAKE_SOURCE_DIR}/pkg_$ENV{ARCH}/lib)
+
+# ---
+# add include files
+include_directories(${CMAKE_SOURCE_DIR})
+include_directories(${CMAKE_SOURCE_DIR}/src)
+include_directories(${CMAKE_SOURCE_DIR}/include)
+
+# ---
+# find required packages
+include(FindPkgConfig)
+
+pkg_check_modules(GTHREAD2 REQUIRED gthread-2.0)
+include_directories(${GTHREAD2_INCLUDE_DIRS})
+
+pkg_check_modules(PBNJSON REQUIRED pbnjson_c)
+include_directories(${PBNJSON_INCLUDE_DIRS})
+
+# -- check for glib 2.0
+pkg_check_modules(GLIB2 REQUIRED glib-2.0)
+include_directories(${GLIB2_INCLUDE_DIRS})
+
+pkg_check_modules(LS2 REQUIRED luna-service2)
+include_directories(${LS2_INCLUDE_DIRS})
+
+pkg_check_modules(PMLOG REQUIRED PmLogLib)
+include_directories(${PMLOG_INCLUDE_DIRS})
+
+# ---
+# create executable file
+set(BIN_NAME echo_service)
+
+set(SRC_LIST
+    ${CMAKE_SOURCE_DIR}/src/main.c
+)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/pkg_$ENV{OECORE_TARGET_ARCH}/")
+add_executable(${BIN_NAME} ${SRC_LIST})
+
+# ignore shared library
+set(CMAKE_EXE_LINKER_FLAGS "-Wl,--allow-shlib-undefined")
+set_target_properties(${BIN_NAME} PROPERTIES LINKER_LANGUAGE C)
+
+target_link_libraries (${BIN_NAME}
+    ${GTHREAD2_LDFLAGS}
+    ${PBNJSON_LDFLAGS}
+    ${LS2_LDFLAGS}
+    ${GLIB2_LDFLAGS}
+    ${PMLOG_LDFLAGS}
+)
+
+file(COPY ${CMAKE_SOURCE_DIR}/services.json DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")

package/files/templates/apollo-sdk-templates/native-service/services.json

@@ -0,0 +1,11 @@
+{
+    "id": "com.domain.app.service",
+    "description": "Native echo service",
+    "engine": "native",
+    "executable": "echo_service",
+    "services": [ {
+      "name": "com.domain.app.service",
+      "description": "Native echo service"
+    }]
+  }
+  

package/files/templates/apollo-sdk-templates/native-service/src/main.c

@@ -0,0 +1,144 @@
+// Copyright (c) 2020-2024 LG Electronics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+#include <stdio.h>
+#include <glib-object.h>
+#include <luna-service2/lunaservice.h>
+#include <pbnjson.h>
+
+// This service name
+#define SERVICE_NAME "SERVICE_ID"
+#define BUF_SIZE 64
+
+// Main loop for aliving background service
+GMainLoop *gmainLoop;
+
+LSHandle  *sh = NULL;
+LSMessage *message;
+
+// Declare of each method
+// All method format must be : bool function(LSHandle*, LSMessage*, void*)
+bool echo(LSHandle *sh, LSMessage *message, void *data);
+
+LSMethod sampleMethods[] = {
+    {"echo", echo},   // luna://SERVICE_ID/echo
+};
+
+
+/*
+ * Define luna://SERVICE_ID/echo
+ *  - A method that always returns the same value
+ *
+ * +----------------------------+            +--------------------------------+
+ * |   APP_ID          |            | SERVICE_ID        |
+ * |   Foreground Application   |            |        Background Service      |
+ * +----------------------------+            +--------------------------------+
+ *   |                                                                        |
+ *   |                                                                        |
+ *   | 1. Request to luna://SERVICE_ID/echo                      |
+ *   |    with parameters { input: "Hello, World!" }                          |
+ *   |                                                                        |
+ *   | ---------------------------------------------------------------------> |
+ *   |                                                                        |
+ *   |                                                                        |
+ *   |            2. Response to APP_ID                              |
+ *   |               with result '{ "echoMessage" : "Hello, World!" }'        |
+ *   |                                                                        |
+ *   | <--------------------------------------------------------------------- |
+ *   |                                                                        |
+ *  \|/                                                                      \|/
+ *   '                                                                        '
+ */
+bool echo(LSHandle *sh, LSMessage *message, void *data)
+{
+    LSError lserror;
+    JSchemaInfo schemaInfo;
+    jvalue_ref parsed = {0}, value = {0};
+    jvalue_ref jobj = {0}, jreturnValue = {0};
+    const char *input = NULL;
+    char buf[BUF_SIZE] = {0, };
+
+    LSErrorInit(&lserror);
+
+    // Initialize schema
+    jschema_info_init (&schemaInfo, jschema_all(), NULL, NULL);
+
+    // get message from LS2 and parsing to make object
+    parsed = jdom_parse(j_cstr_to_buffer(LSMessageGetPayload(message)), DOMOPT_NOOPT, &schemaInfo);
+
+    if (jis_null(parsed)) {
+        j_release(&parsed);
+        return true;
+    }
+
+    // Get value from payload.input
+    value = jobject_get(parsed, j_cstr_to_buffer("input"));
+
+    // JSON Object to string without schema validation check
+    input = jvalue_tostring_simple(value);
+
+    /**
+     * JSON create test
+     */
+    jobj = jobject_create();
+    if (jis_null(jobj)) {
+        j_release(&jobj);
+        return true;
+    }
+
+    jreturnValue = jboolean_create(TRUE);
+    jobject_set(jobj, j_cstr_to_buffer("returnValue"), jreturnValue);
+    jobject_set(jobj, j_cstr_to_buffer("echoMessage"), value);
+
+    LSMessageReply(sh, message, jvalue_tostring_simple(jobj), &lserror);
+
+    j_release(&parsed);
+    return true;
+}
+
+// Register background service and initialize
+int main(int argc, char* argv[])
+{
+    LSError lserror;
+    LSHandle  *handle = NULL;
+    bool bRetVal = FALSE;
+
+    LSErrorInit(&lserror);
+
+    // create a GMainLoop
+    gmainLoop = g_main_loop_new(NULL, FALSE);
+
+    bRetVal = LSRegister(SERVICE_NAME, &handle, &lserror);
+    if (FALSE== bRetVal) {
+        LSErrorFree( &lserror );
+        return 0;
+    }
+    sh = LSMessageGetConnection(message);
+
+    LSRegisterCategory(handle,"/",sampleMethods, NULL, NULL, &lserror);
+
+    LSGmainAttach(handle, gmainLoop, &lserror);
+
+    // run to check continuously for new events from each of the event sources
+    g_main_loop_run(gmainLoop);
+    // Decreases the reference count on a GMainLoop object by one
+    g_main_loop_unref(gmainLoop);
+
+    return 0;
+}

package/files/templates/apollo-sdk-templates/serviceinfo/package.json

@@ -0,0 +1,11 @@
+{
+    "name": "com.domain.app.service",
+    "version": "1.0.0",
+    "description": "Helloworld service",
+    "main": "helloworld_webos_service.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "",
+    "license": "BSD"
+}

package/files/templates/apollo-sdk-templates/serviceinfo/services.json

@@ -0,0 +1,8 @@
+{
+    "id": "com.domain.app.service",
+    "description": "HelloWorld Service",
+    "services": [ {
+        "name": "com.domain.app.service",
+        "description": "HelloWorld Service"
+    } ]
+}

package/lib/base/novacom.js

@@ -975,7 +975,7 @@ const async = require('async'),
                 chStream.on('close', function() {
                     log.silly("novacom#Session()#run()", "event close (cmd:" + cmd + ")");
                     if (err === undefined) {
-                       setImmediate(next);
+                        setImmediate(next);
                     }
                 });