iotjs_ext_module_periph_common.c

00001 /* Copyright 2017-present Renesas Electronics Corporation and other contributors
00002  *
00003  * Licensed under the Apache License, Version 2.0 (the "License");
00004  * you may not use this file except in compliance with the License.
00005  * You may obtain a copy of the License at
00006  *
00007  *     http://www.apache.org/licenses/LICENSE-2.0
00008  *
00009  * Unless required by applicable law or agreed to in writing, software
00010  * distributed under the License is distributed on an "AS IS" BASIS
00011  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00012  * See the License for the specific language governing permissions and
00013  * limitations under the License.
00014  */
00015 #if defined(USE_POSIX_BRIDGE)
00016 #include "iotjs_def.h"
00017 
00018 #include "peripheral_io.h"
00019 #include "iotjs_ext_module_periph_common.h"
00020 #include "modules/iotjs_module_buffer.h"
00021 #include "iotjs_module_video.h"
00022 #include "iotjs_module_display.h"
00023 #include "iotjs_module_jpeg.h"
00024 #include "iotjs_module_aligned_buffer.h"
00025 
00026 const char* iotjs_ext_periph_error_str(uint8_t op) {
00027   switch (op) {
00028 #if ENABLE_MODULE_VIDEO
00029     case kVideoOpOpen:
00030       return "Open error, cannot open Video";
00031     case kVideoOpStart:
00032       return "Start error, cannot start Video";
00033     case kVideoOpStop:
00034       return "Stop error, cannot stop Video";
00035     case kVideoOpReadFrame:
00036       return "ReadFrame error, cannot readFrame Video";
00037     case kVideoOpClose:
00038       return "Close error, cannot close Video";
00039 #endif /* ENABLE_MODULE_VIDEO */
00040 #if ENABLE_MODULE_DISPLAY
00041     case kDisplayOpOpen:
00042       return "Open error, cannot open Display";
00043     case kDisplayOpStart:
00044       return "Start error, cannot start Display";
00045     case kDisplayOpStop:
00046       return "Stop error, cannot stop Display";
00047     case kDisplayOpUpdate:
00048       return "Update error, cannot update Display";
00049     case kDisplayOpClose:
00050       return "Close error, cannot close Display";
00051 #endif /* ENABLE_MODULE_VIDEO */
00052 #if ENABLE_MODULE_JPEG
00053     case kJpegOpEncode:
00054       return "Encode error, cannot encode Jpeg";
00055     case kJpegOpDecode:
00056       return "Decode error, cannot decode Jpeg";
00057 #endif /* ENABLE_MODULE_JPEG */
00058 #if ENABLE_MODULE_GRAPHICS
00059     case kGraphicsOpDrawImage:
00060       return "Draw error, cannot draw Image";
00061     case kGraphicsOpDrawLine:
00062       return "Draw error, cannot draw Line";
00063     case kGraphicsOpDrawRect:
00064       return "Draw error, cannot draw Rect";
00065     case kGraphicsOpDrawArc:
00066       return "Draw error, cannot draw Arc";
00067     case kGraphicsOpDrawCircle:
00068       return "Draw error, cannot draw Circle";
00069     case kGraphicsOpDrawEllipse:
00070       return "Draw error, cannot draw Ellipse";
00071     case kGraphicsOpDrawPolygon:
00072       return "Draw error, cannot draw Polygon";
00073     case kGraphicsOpDrawText:
00074       return "Draw error, cannot draw Text";
00075 #endif /* ENABLE_MODULE_GRAPHICS */
00076     default:
00077       return "Unknown error";
00078   }
00079 }
00080 
00081 static void after_worker(uv_work_t* work_req, int status) {
00082   iotjs_periph_reqwrap_t* reqwrap =
00083       (iotjs_periph_reqwrap_t*)iotjs_reqwrap_from_request((uv_req_t*)work_req);
00084 
00085   size_t jargc = 0;
00086   jerry_value_t jargs[2] = { 0 };
00087 
00088   if (status) {
00089     jargs[jargc++] = iotjs_jval_create_error_without_error_flag("System error");
00090   } else {
00091     if (!reqwrap->result) {
00092       jargs[jargc++] = iotjs_jval_create_error_without_error_flag(
00093           iotjs_ext_periph_error_str(reqwrap->op));
00094     } else {
00095       jargs[jargc++] = jerry_create_null();
00096       switch (reqwrap->op) {
00097         case kVideoOpStart:
00098         case kVideoOpStop:
00099         case kVideoOpReadFrame:
00100         case kVideoOpClose:
00101         case kDisplayOpStart:
00102         case kDisplayOpStop:
00103         case kDisplayOpUpdate:
00104         case kDisplayOpClose:
00105         case kGraphicsOpDrawImage:
00106         case kGraphicsOpDrawLine:
00107         case kGraphicsOpDrawRect:
00108         case kGraphicsOpDrawArc:
00109         case kGraphicsOpDrawCircle:
00110         case kGraphicsOpDrawEllipse:
00111         case kGraphicsOpDrawPolygon:
00112         case kGraphicsOpDrawText: {
00113           break;
00114         }
00115         case kVideoOpOpen: {
00116 #if ENABLE_MODULE_VIDEO
00117 //          iotjs_video_t* video = (iotjs_video_t*)reqwrap->data;
00118 //          jargs[jargc++] = video->jobject;
00119 #endif /* ENABLE_MODULE_VIDEO */
00120           break;
00121         }
00122         case kDisplayOpOpen: {
00123 #if ENABLE_MODULE_DISPLAY
00124 //          iotjs_display_t* display = (iotjs_display_t*)reqwrap->data;
00125 //          jargs[jargc++] = display->jobject;
00126 #endif /* ENABLE_MODULE_DISPLAY */
00127           break;
00128         }
00129         case kJpegOpEncode: {
00130 #if ENABLE_MODULE_JPEG
00131           iotjs_jpeg_t* jpeg = (iotjs_jpeg_t*)reqwrap->data;
00132           jerry_value_t jbuf = iotjs_aligned_buffer_wrap_create_buffer((size_t)jpeg->encode_data.dst.len, 32);
00133           if (jerry_value_is_error(jbuf)) {
00134             jerry_release_value(jargs[--jargc]);
00135           } else {
00136             iotjs_aligned_buffer_wrap_t* buf_wrap = iotjs_aligned_buffer_wrap_from_jbuffer(jbuf);
00137             iotjs_aligned_buffer_wrap_copy(buf_wrap, jpeg->encode_data.dst.buf, jpeg->encode_data.dst.len);
00138           }
00139           jargs[jargc++] = jbuf;
00140           IOTJS_RELEASE(jpeg->encode_data.dst.buf);
00141 #endif /* ENABLE_MODULE_JPEG */
00142           break;
00143         }
00144         case kJpegOpDecode: {
00145 #if ENABLE_MODULE_JPEG
00146           iotjs_jpeg_t* jpeg = (iotjs_jpeg_t*)reqwrap->data;
00147           jerry_value_t jbuf = iotjs_aligned_buffer_wrap_create_buffer((size_t)jpeg->decode_data.dst.len, 32);
00148           if (jerry_value_is_error(jbuf)) {
00149             jerry_release_value(jargs[--jargc]);
00150           } else {
00151             iotjs_aligned_buffer_wrap_t* buf_wrap = iotjs_aligned_buffer_wrap_from_jbuffer(jbuf);
00152             iotjs_aligned_buffer_wrap_copy(buf_wrap, jpeg->decode_data.dst.buf, jpeg->decode_data.dst.len);
00153           }
00154           jargs[jargc++] = jbuf;
00155           IOTJS_RELEASE(jpeg->decode_data.dst.buf);
00156 #endif /* ENABLE_MODULE_JPEG */
00157           break;
00158         }
00159         default: {
00160           IOTJS_ASSERT(!"Unreachable");
00161           break;
00162         }
00163       }
00164     }
00165   }
00166 
00167   jerry_value_t jcallback = iotjs_reqwrap_jcallback(&reqwrap->reqwrap);
00168   if (jerry_value_is_function(jcallback)) {
00169     iotjs_invoke_callback(jcallback, jerry_create_undefined(), jargs, jargc);
00170   }
00171 
00172   for (size_t i = 0; i < jargc; i++) {
00173     jerry_release_value(jargs[i]);
00174   }
00175 
00176   iotjs_reqwrap_destroy(&reqwrap->reqwrap);
00177   IOTJS_RELEASE(reqwrap);
00178 }
00179 
00180 static iotjs_periph_reqwrap_t* reqwrap_create(const jerry_value_t jcallback,
00181                                               void* data, uint8_t op) {
00182   iotjs_periph_reqwrap_t* reqwrap = IOTJS_ALLOC(iotjs_periph_reqwrap_t);
00183   iotjs_reqwrap_initialize((iotjs_reqwrap_t*)reqwrap, jcallback,
00184                            (uv_req_t*)&reqwrap->req);
00185   reqwrap->op = op;
00186   reqwrap->data = data;
00187   return (iotjs_periph_reqwrap_t*)reqwrap;
00188 }
00189 
00190 void iotjs_ext_periph_call_async(void* data, jerry_value_t jcallback, uint8_t op,
00191                              uv_work_cb worker) {
00192   uv_loop_t* loop = iotjs_environment_loop(iotjs_environment_get());
00193   iotjs_periph_reqwrap_t* req_wrap = reqwrap_create(jcallback, data, op);
00194   uv_queue_work(loop, &req_wrap->req, worker, after_worker);
00195 }
00196 #endif  // #if defined(USE_POSIX_BRIDGE)