/*
|
* Copyright (C) 2019 Rockchip Electronics Co., Ltd.
|
* author: Zhihua Wang, hogan.wang@rock-chips.com
|
*
|
* This software is available to you under a choice of one of two
|
* licenses. You may choose to be licensed under the terms of the GNU
|
* General Public License (GPL), available from the file
|
* COPYING in the main directory of this source tree, or the
|
* OpenIB.org BSD license below:
|
*
|
* Redistribution and use in source and binary forms, with or
|
* without modification, are permitted provided that the following
|
* conditions are met:
|
*
|
* - Redistributions of source code must retain the above
|
* copyright notice, this list of conditions and the following
|
* disclaimer.
|
*
|
* - Redistributions in binary form must reproduce the above
|
* copyright notice, this list of conditions and the following
|
* disclaimer in the documentation and/or other materials
|
* provided with the distribution.
|
*
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
* SOFTWARE.
|
*/
|
|
#include "db_monitor.h"
|
#include "video_common.h"
|
#include <stdio.h>
|
|
#ifdef USE_WEB_SERVER
|
#include <stdlib.h>
|
#include <string.h>
|
#include <errno.h>
|
#include <stdbool.h>
|
#include <sys/types.h>
|
#include <unistd.h>
|
#include <ctype.h>
|
#include <inttypes.h>
|
#include <pthread.h>
|
#include <assert.h>
|
|
#include <json-c/json.h>
|
#include <glib.h>
|
|
#include <IPCProtocol.h>
|
#include <dbserver.h>
|
#include <storage_manager.h>
|
#include <dbus_signal.h>
|
|
#include "rockface_control.h"
|
#include "display.h"
|
|
#define DBSERVER "rockchip.dbserver"
|
#define DBSERVER_PATH "/"
|
#define DBSERVER_EVENT_INTERFACE DBSERVER ".event"
|
|
#include <list>
|
|
struct json_data {
|
int id;
|
char *path;
|
bool add;
|
};
|
|
static std::list<int> g_fail_id;
|
static std::list<struct json_data*> g_json;
|
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
static pthread_t g_th;
|
static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
|
static pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
|
static bool g_flag;
|
|
extern int g_face_width;
|
extern int g_face_height;
|
|
static void db_monitor_wait(void)
|
{
|
pthread_mutex_lock(&g_mutex);
|
if (g_flag)
|
pthread_cond_wait(&g_cond, &g_mutex);
|
g_flag = true;
|
pthread_mutex_unlock(&g_mutex);
|
}
|
|
static void db_monitor_signal(void)
|
{
|
pthread_mutex_lock(&g_mutex);
|
g_flag = false;
|
pthread_cond_signal(&g_cond);
|
pthread_mutex_unlock(&g_mutex);
|
}
|
|
static void db_monitor_check(void);
|
static void *db_monitor_thread(void *arg)
|
{
|
int ret;
|
int id = -1;
|
struct json_data *data = NULL;
|
|
while (!is_command_success("pidof dbserver")) {
|
printf("check dbserver failed!\n");
|
sleep(1);
|
}
|
while (!is_command_success("pidof netserver")) {
|
printf("check netserver failed!\n");
|
sleep(1);
|
}
|
while (!is_command_success("pidof storage_manager")) {
|
printf("check storage_manager failed!\n");
|
sleep(1);
|
}
|
db_monitor_check();
|
|
while (1) {
|
id = -1;
|
if (data) {
|
if (data->path)
|
free(data->path);
|
free(data);
|
data = NULL;
|
}
|
pthread_mutex_lock(&g_lock);
|
if (g_json.empty() && g_fail_id.empty()) {
|
pthread_mutex_unlock(&g_lock);
|
db_monitor_wait();
|
} else if (!g_json.empty()){
|
data = g_json.front();
|
g_json.pop_front();
|
pthread_mutex_unlock(&g_lock);
|
} else if (!g_fail_id.empty()) {
|
id = g_fail_id.front();
|
g_fail_id.pop_front();
|
pthread_mutex_unlock(&g_lock);
|
}
|
if (id != -1) {
|
dbserver_face_load_complete(id, -1);
|
printf("%s: Update fail: %d\n", __func__, id);
|
continue;
|
}
|
if (!data)
|
continue;
|
|
if (data->add) {
|
ret = rockface_control_add_web(data->id, data->path);
|
if (ret == -1 )
|
dbserver_face_load_complete(data->id, -1);
|
else if (ret == 2)
|
dbserver_face_load_complete(data->id, 2);
|
else
|
dbserver_face_load_complete(data->id, 1);
|
printf("Update: id = %d, path = %s\n", data->id, data->path);
|
} else {
|
rockface_control_delete(data->id, data->path, false, true);
|
printf("Delete: id = %d\n", data->id);
|
}
|
|
usleep(10000);
|
}
|
pthread_exit(NULL);
|
}
|
|
static void get_face_config(json_object *j_obj)
|
{
|
if (!j_obj)
|
return;
|
g_face_config.en = true;
|
g_face_config.volume = json_object_get_int(json_object_object_get(j_obj, "iPromptVolume"));
|
const char *live_det = json_object_get_string(json_object_object_get(j_obj, "sLiveDetect"));
|
if (live_det) {
|
if (!strncmp(live_det, "open", strlen("open")))
|
g_face_config.live_det_en = 1;
|
else
|
g_face_config.live_det_en = 0;
|
}
|
g_face_config.live_det_th = json_object_get_int(json_object_object_get(j_obj, "iLiveDetectThreshold"));
|
g_face_config.face_det_th = json_object_get_int(json_object_object_get(j_obj, "iFaceDetectionThreshold"));
|
g_face_config.face_rec_th = json_object_get_int(json_object_object_get(j_obj, "iFaceRecognitionThreshold"));
|
g_face_config.face_mask_th = 50; // TODO
|
g_face_config.min_pixel = json_object_get_int(json_object_object_get(j_obj, "iFaceMinPixel"));
|
g_face_config.corner_x = json_object_get_int(json_object_object_get(j_obj, "iLeftCornerX"));
|
g_face_config.corner_y = json_object_get_int(json_object_object_get(j_obj, "iLeftCornerY"));
|
g_face_config.det_width = json_object_get_int(json_object_object_get(j_obj, "iDetectWidth"));
|
g_face_config.det_height = json_object_get_int(json_object_object_get(j_obj, "iDetectHeight"));
|
g_face_config.nor_width = json_object_get_int(json_object_object_get(j_obj, "iNormalizedWidth"));
|
g_face_config.nor_height = json_object_get_int(json_object_object_get(j_obj, "iNormalizedHeight"));
|
printf("face_config: en %d\n", g_face_config.en);
|
printf(" volume %d\n", g_face_config.volume);
|
printf(" live_det_en %d\n", g_face_config.live_det_en);
|
printf(" live_det_th %d\n", g_face_config.live_det_th);
|
printf(" face_det_th %d\n", g_face_config.face_det_th);
|
printf(" face_rec_th %d\n", g_face_config.face_rec_th);
|
printf(" min_pixel %d\n", g_face_config.min_pixel);
|
printf(" corner_x %d\n", g_face_config.corner_x);
|
printf(" corner_y %d\n", g_face_config.corner_y);
|
printf(" det_width %d\n", g_face_config.det_width);
|
printf(" det_height %d\n", g_face_config.det_height);
|
printf(" nor_width %d\n", g_face_config.nor_width);
|
printf(" nor_height %d\n", g_face_config.nor_height);
|
if (get_face_config_region_cb) {
|
int x, y, w, h;
|
int width, height;
|
display_get_resolution(&width, &height);
|
if (!width || !height) {
|
width = g_face_width;
|
height = g_face_height;
|
}
|
x = g_face_config.corner_x * width / g_face_config.nor_width;
|
y = g_face_config.corner_y * height / g_face_config.nor_height;
|
w = g_face_config.det_width * width / g_face_config.nor_width;
|
h = g_face_config.det_height * height / g_face_config.nor_height;
|
get_face_config_region_cb(x, y, w, h);
|
}
|
}
|
|
void db_monitor_run(void *json_str)
|
{
|
if (!json_str) {
|
printf("%s error!\n", __func__);
|
return;
|
}
|
json_object *j_cfg = json_tokener_parse((const char*)json_str);
|
json_object *j_table = json_object_object_get(j_cfg, "table");
|
|
const char *table = json_object_get_string(j_table);
|
if (strstr(table, "FaceConfig")) {
|
json_object *j_data = json_object_object_get(j_cfg, "data");
|
get_face_config(j_data);
|
json_object_put(j_cfg);
|
return;
|
} else if (!strstr(table, "FaceList")) {
|
json_object_put(j_cfg);
|
return;
|
}
|
|
json_object *j_key = json_object_object_get(j_cfg, "key");
|
json_object *j_id = json_object_object_get(j_key, "id");
|
json_object *j_data = json_object_object_get(j_cfg, "data");
|
json_object *j_cmd = json_object_object_get(j_cfg, "cmd");
|
|
int id = json_object_get_int(j_id);
|
const char *cmd = json_object_get_string(j_cmd);
|
|
if (cmd && strstr(cmd, "Update")) {
|
json_object *j_note = json_object_object_get(j_data, "sNote");
|
const char *note = json_object_get_string(j_note);
|
if (note && !strstr(note, "undone")) {
|
json_object *j_path = json_object_object_get(j_data, "sPicturePath");
|
const char *path = json_object_get_string(j_path);
|
if (path) {
|
struct json_data *data = (struct json_data*)calloc(sizeof(struct json_data), 1);
|
if (data) {
|
data->add = true;
|
data->id = id;
|
data->path = strdup(path);
|
if (data->path) {
|
pthread_mutex_lock(&g_lock);
|
g_json.push_back(data);
|
pthread_mutex_unlock(&g_lock);
|
} else {
|
free(data);
|
pthread_mutex_lock(&g_lock);
|
g_fail_id.push_back(id);
|
pthread_mutex_unlock(&g_lock);
|
}
|
} else {
|
pthread_mutex_lock(&g_lock);
|
g_fail_id.push_back(id);
|
pthread_mutex_unlock(&g_lock);
|
}
|
db_monitor_signal();
|
}
|
}
|
}
|
if (cmd && strstr(cmd, "Delete")) {
|
struct json_data *data = (struct json_data*)calloc(sizeof(struct json_data), 1);
|
if (data) {
|
data->id = id;
|
data->add = false;
|
json_object *j_path = json_object_object_get(j_key, "sPicturePath");
|
const char *path = json_object_get_string(j_path);
|
if (!j_id && !j_path) {
|
printf("Delete all!\n");
|
rockface_control_delete_all();
|
free(data);
|
} else if (path) {
|
data->path = strdup(path);
|
if (data->path) {
|
pthread_mutex_lock(&g_lock);
|
g_json.push_back(data);
|
pthread_mutex_unlock(&g_lock);
|
db_monitor_signal();
|
} else {
|
printf("strdup %d path fail!\n", id);
|
free(data);
|
}
|
} else {
|
printf("get %d path fail!\n", id);
|
free(data);
|
}
|
} else {
|
printf("%s: Delete fail: %d\n", __func__, id);
|
}
|
}
|
|
json_object_put(j_cfg);
|
}
|
|
void db_monitor_storage_init(void)
|
{
|
char *json_str = NULL;
|
printf("%s\n", __func__);
|
do {
|
json_str = dbserver_get_storage_media_folder();
|
if (json_str)
|
break;
|
usleep(1000000);
|
} while (1);
|
|
json_object *j_config = json_tokener_parse(json_str);
|
json_object *j_data = json_object_object_get(j_config, "jData");
|
if (j_data) {
|
int num = json_object_array_length(j_data);
|
for (int i = 0; i < num; i++) {
|
json_object *j_obj = json_object_array_get_idx(j_data, i);
|
int camid = (int)json_object_get_int(json_object_object_get(j_obj, "iCamId"));
|
int type = (int)json_object_get_int(json_object_object_get(j_obj, "iType"));
|
switch (type) {
|
case TYPE_VIDEO:
|
dbserver_update_storage_media_folder_duty(camid, type, 0, -1);
|
break;
|
case TYPE_PHOTO:
|
dbserver_update_storage_media_folder_duty(camid, type, 0, -1);
|
break;
|
case TYPE_BLACK_LIST:
|
dbserver_update_storage_media_folder_duty(camid, type, 10, -1);
|
break;
|
case TYPE_SNAPSHOT:
|
dbserver_update_storage_media_folder_duty(camid, type, 40, -1);
|
break;
|
case TYPE_WHITE_LIST:
|
dbserver_update_storage_media_folder_duty(camid, type, 50, -1);
|
break;
|
default:
|
printf("%s: type error\n", __func__);
|
break;
|
}
|
}
|
}
|
|
json_object_put(j_config);
|
g_free(json_str);
|
}
|
|
static void db_monitor_get_media_path(int type, char *path, size_t size)
|
{
|
char *json_str = NULL;
|
int status;
|
json_object *j_config;
|
|
printf("%s: type = %d\n", __func__, type);
|
do {
|
json_str = storage_manager_get_media_path();
|
if (json_str) {
|
j_config = json_tokener_parse(json_str);
|
json_object *j_status = json_object_object_get(j_config, "iStatus");
|
status = json_object_get_int(j_status);
|
} else {
|
usleep(1000000);
|
continue;
|
}
|
if (status)
|
break;
|
json_object_put(j_config);
|
g_free(json_str);
|
usleep(1000000);
|
} while (1);
|
|
json_object *j_array = json_object_object_get(j_config, "sScanPath");
|
if (j_array) {
|
int num = json_object_array_length(j_array);
|
for (int i = 0; i < num; i++) {
|
json_object *j_obj = json_object_array_get_idx(j_array, i);
|
int t = (int)json_object_get_int(json_object_object_get(j_obj, "iType"));
|
if (t == type) {
|
const char *p = json_object_get_string(json_object_object_get(j_obj, "sMediaPath"));
|
strncpy(path, p, size - 1);
|
break;
|
}
|
}
|
}
|
|
json_object_put(j_config);
|
g_free(json_str);
|
}
|
|
void db_monitor_init()
|
{
|
if (pthread_create(&g_th, NULL, db_monitor_thread, NULL)) {
|
printf("%s create thread failed!\n", __func__);
|
return;
|
}
|
}
|
|
static void db_monitor_check(void)
|
{
|
char *json_str = NULL;
|
json_object *j_config;
|
|
db_monitor_storage_init();
|
|
db_monitor_get_media_path(TYPE_SNAPSHOT, g_snapshot, sizeof(g_snapshot));
|
db_monitor_get_media_path(TYPE_BLACK_LIST, g_black_list, sizeof(g_black_list));
|
db_monitor_get_media_path(TYPE_WHITE_LIST, g_white_list, sizeof(g_white_list));
|
if (check_path_dir(g_snapshot))
|
printf("check %s error\n", g_snapshot);
|
if (check_path_dir(g_white_list))
|
printf("check %s error\n", g_white_list);
|
if (check_path_dir(g_black_list))
|
printf("check %s error\n", g_black_list);
|
|
json_str = dbserver_event_get("FaceConfig");
|
if (json_str) {
|
j_config = json_tokener_parse(json_str);
|
int ret = json_object_get_int(json_object_object_get(j_config, "iReturn"));
|
if (ret == 0) {
|
json_object *j_data = json_object_object_get(j_config, "jData");
|
json_object *j_obj = json_object_array_get_idx(j_data, 0);
|
get_face_config(j_obj);
|
}
|
json_object_put(j_config);
|
free(json_str);
|
}
|
|
dbus_monitor_signal_registered(DBSERVER_EVENT_INTERFACE, "DataChanged", &db_monitor_run);
|
}
|
|
void db_monitor_face_list_add(int id, char *path, char *name, char *type)
|
{
|
dbserver_face_list_add(id, path, name, type);
|
dbserver_face_load_complete(id, 1);
|
}
|
|
void db_monitor_face_list_delete(int id)
|
{
|
dbserver_face_list_delete(id);
|
}
|
|
void db_monitor_snapshot_record_set(char *path)
|
{
|
dbserver_snapshot_record_set(path);
|
}
|
|
void db_monitor_control_record_set(int face_id, char *path, char *status, char *similarity)
|
{
|
dbserver_control_record_set(face_id, path, status, similarity);
|
}
|
|
|
void db_monitor_get_user_info(struct user_info *info, int i)
|
{
|
char *json_str = NULL;
|
|
json_str = dbserver_event_get_by_id(TABLE_FACE_LIST, i);
|
if (json_str) {
|
json_object *j_cfg = json_tokener_parse((const char*)json_str);
|
json_object *j_data = json_object_object_get(j_cfg, "jData");
|
json_object *j_obj = json_object_array_get_idx(j_data, 0);
|
#define COPY_INT(x) info->x = json_object_get_int(json_object_object_get(j_obj, #x))
|
#define COPY_STRING(x) \
|
do { \
|
if (json_object_get_string(json_object_object_get(j_obj, #x))) \
|
strncpy(info->x, json_object_get_string(json_object_object_get(j_obj, #x)), sizeof(info->x) - 1); \
|
} while (0)
|
COPY_INT(id);
|
COPY_STRING(sPicturePath);
|
COPY_STRING(sRegistrationTime);
|
COPY_INT(iAge);
|
COPY_STRING(sListType);
|
COPY_STRING(sType);
|
COPY_STRING(sName);
|
COPY_STRING(sGender);
|
COPY_STRING(sNation);
|
COPY_STRING(sCertificateType);
|
COPY_STRING(sCertificateNumber);
|
COPY_STRING(sBirthday);
|
COPY_STRING(sTelephoneNumber);
|
COPY_STRING(sHometown);
|
COPY_INT(iAccessCardNumber);
|
json_object_put(j_cfg);
|
free(json_str);
|
} else {
|
printf("%s %d failed\n", __func__, i);
|
}
|
}
|
#else
|
void db_monitor_init()
|
{
|
snprintf(g_snapshot, sizeof(g_snapshot), "/userdata/snapshot");
|
snprintf(g_black_list, sizeof(g_black_list), "/userdata/black_list");
|
snprintf(g_white_list, sizeof(g_white_list), "/userdata/white_list");
|
if (check_path_dir(g_snapshot))
|
printf("check %s error\n", g_snapshot);
|
if (check_path_dir(g_white_list))
|
printf("check %s error\n", g_white_list);
|
if (check_path_dir(g_black_list))
|
printf("check %s error\n", g_black_list);
|
}
|
void db_monitor_face_list_add(int id, char *path, char *name, char *type) {}
|
void db_monitor_face_list_delete(int id) {}
|
void db_monitor_snapshot_record_set(char *path) {}
|
void db_monitor_control_record_set(int face_id, char *path, char *status, char *similarity) {}
|
void db_monitor_get_user_info(struct user_info *info, int id) {}
|
#endif
|
