#include <stdio.h>
|
#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 <sys/stat.h>
|
#include <sys/types.h>
|
#include <dirent.h>
|
|
#include <glib.h>
|
|
#include <pthread.h>
|
|
#include "json-c/json.h"
|
#include "dbserver.h"
|
#include "storage_manager.h"
|
#include "IPCProtocol.h"
|
|
struct ScanPath {
|
char *media_path;
|
char *thumb_path;
|
int type;
|
char *format;
|
int count;
|
int camid;
|
|
long medio_size;
|
long thumb_size;
|
pthread_t tid;
|
int run;
|
struct ScanPath *next;
|
};
|
|
struct StorageConfig {
|
int freesize;
|
char *mountpath;
|
int status;
|
struct ScanPath *scanpath;
|
};
|
|
struct StorageConfig storageconfig;
|
|
int create_dir(const char *sPathName)
|
{
|
char DirName[256];
|
int i;
|
strcpy(DirName, sPathName);
|
int len = strlen(DirName);
|
|
for (i = 1; i < len; i++) {
|
if (DirName[i] == '/') {
|
DirName[i] = 0;
|
if (access(DirName, R_OK) != 0) {
|
if(mkdir(DirName, 0755) == -1) {
|
printf("mkdir error\n");
|
return -1;
|
}
|
}
|
DirName[i] = '/';
|
}
|
}
|
if (access(DirName, R_OK) != 0) {
|
if(mkdir(DirName, 0755) == -1) {
|
printf("mkdir error\n");
|
return -1;
|
}
|
}
|
return 0;
|
}
|
|
void signal_update_disks_status(void *user_data)
|
{
|
printf("%s, %s\n", __func__, (char *)user_data);
|
}
|
|
void signal_update_media_path(void *user_data)
|
{
|
printf("%s, %s\n", __func__, (char *)user_data);
|
}
|
|
char *creatfilename(char *folder, char *format, int type, int count, int *needcount)
|
{
|
char *filename;
|
time_t nSeconds;
|
struct tm * pTM;
|
char *tmp = strstr(format, "%Y");
|
|
if (tmp) {
|
char name[128] = {0};
|
time(&nSeconds);
|
pTM = localtime(&nSeconds);
|
strftime(name, sizeof(name), format, pTM);
|
if (type == 0)//video mp4
|
filename = g_strdup_printf("%s/%s.mp4", folder, name);
|
else if (type == 1)//photo jpg
|
filename = g_strdup_printf("%s/%s.jpg", folder, name);
|
} else {
|
if (type == 0)//video mp4
|
filename = g_strdup_printf("%s/%s.mp4", folder, format);
|
else if (type == 1)//photo jpg
|
filename = g_strdup_printf("%s/%s.jpg", folder, format);
|
}
|
|
tmp = strstr(filename, "CCC");
|
if (tmp) {
|
int cnt = 0;
|
int mul = 1;
|
while (tmp[cnt] == 'C') {
|
cnt++;
|
mul *= 10;
|
}
|
for (int i = 0; i < cnt; i++) {
|
tmp[i] = (count % mul) * 10 / mul + '0';
|
mul /= 10;
|
}
|
*needcount = 1;
|
}
|
|
printf("filename = %s\n", filename);
|
return filename;
|
}
|
|
void creatfile(char *name, long size, int *run)
|
{
|
FILE *fp;
|
int buflen = 4 * 1024 * 1024;
|
unsigned char *buf = (unsigned char *)malloc(buflen);
|
fp = fopen(name, "wb+");
|
while (size > 0) {
|
if (size > buflen) {
|
fwrite(buf, 1, buflen, fp);
|
size -= buflen;
|
} else {
|
fwrite(buf, 1, size, fp);
|
break;
|
}
|
}
|
fclose(fp);
|
free(buf);
|
}
|
|
static void *creat_file_thread(void *arg)
|
{
|
struct ScanPath *scanpath = (struct ScanPath *)arg;
|
|
create_dir(scanpath->media_path);
|
if (scanpath->thumb_path && (!g_str_equal(scanpath->thumb_path, "")))
|
create_dir(scanpath->thumb_path);
|
while (scanpath->run) {
|
int needcount = 0;
|
printf("%s\n", __func__);
|
int type;
|
if (scanpath->type == TYPE_VIDEO)
|
type = 0;
|
else
|
type = 1;
|
|
char *filename = creatfilename(scanpath->media_path, scanpath->format, type, scanpath->count, &needcount);
|
creatfile(filename, scanpath->medio_size, &scanpath->run);
|
g_free(filename);
|
if (scanpath->thumb_path && (!g_str_equal(scanpath->thumb_path, ""))) {
|
filename = creatfilename(scanpath->thumb_path, scanpath->format, 1, scanpath->count, &needcount);
|
creatfile(filename, scanpath->thumb_size, &scanpath->run);
|
g_free(filename);
|
}
|
if (needcount)
|
scanpath->count++;
|
if (scanpath->type == 1)
|
sleep(10);
|
else
|
sleep(1);
|
}
|
err_event_monitor:
|
pthread_detach(pthread_self());
|
pthread_exit(NULL);
|
}
|
|
void creat_mediafile_test(void)
|
{
|
struct ScanPath *scanpath = storageconfig.scanpath;
|
|
if (storageconfig.status == 0)
|
return;
|
|
while (scanpath) {
|
if (scanpath->type == 0)
|
scanpath->medio_size = 200 * 1024 * 1024;
|
else
|
scanpath->medio_size = 4 * 1024 * 1024;
|
scanpath->thumb_size = 32 * 1024;
|
scanpath->run = 1;
|
pthread_create(&scanpath->tid, NULL, creat_file_thread, scanpath);
|
scanpath = scanpath->next;
|
}
|
}
|
|
void storage_manager_get_disks_status_test(void)
|
{
|
char *json_str = storage_manager_get_disks_status("");
|
printf("%s, %s\n", __func__, json_str);
|
if (json_str)
|
g_free(json_str);
|
}
|
|
void storage_manager_get_filelist_id_test(void)
|
{
|
char *json_str = storage_manager_get_filelist_id(2, 0, 0, "0,20");
|
printf("%s, %s\n", __func__, json_str);
|
if (json_str)
|
g_free(json_str);
|
}
|
|
void storage_manager_get_filelist_path_test(void)
|
{
|
int starttime = 1583975593;
|
int endtime = 1583982408;
|
char *json_str = storage_manager_get_filelist_path("/userdata/video1", &starttime, &endtime, 0, "0,20");
|
printf("%s, %s\n", __func__, json_str);
|
if (json_str)
|
g_free(json_str);
|
}
|
|
void storage_manager_get_media_path_test(void)
|
{
|
json_object *j_config;
|
json_object *j_array = NULL;
|
int videolen;
|
int videomaxsize;
|
char *mountpath;
|
char *json_str = storage_manager_get_media_path();
|
|
if (json_str == NULL)
|
return;
|
|
printf("%s, %s\n", __func__, json_str);
|
memset(&storageconfig, 0, sizeof(struct StorageConfig));
|
|
j_config = json_tokener_parse(json_str);
|
|
storageconfig.status = (int)json_object_get_int(json_object_object_get(j_config, "iStatus"));
|
storageconfig.freesize = (int)json_object_get_int(json_object_object_get(j_config, "iFreeSize"));
|
storageconfig.mountpath = g_strdup((char *)json_object_get_string(json_object_object_get(j_config, "sMountPath")));
|
|
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);
|
struct ScanPath *scanpath = (struct ScanPath *)calloc(1, sizeof(struct ScanPath));
|
if (storageconfig.scanpath == NULL) {
|
storageconfig.scanpath = scanpath;
|
} else {
|
struct ScanPath *tmp = storageconfig.scanpath;
|
while (tmp->next) {
|
tmp = tmp->next;
|
}
|
tmp->next = scanpath;
|
}
|
scanpath->media_path = g_strdup((char *)json_object_get_string(json_object_object_get(j_obj, "sMediaPath")));
|
scanpath->thumb_path = g_strdup((char *)json_object_get_string(json_object_object_get(j_obj, "sThumbPath")));
|
scanpath->format = g_strdup((char *)json_object_get_string(json_object_object_get(j_obj, "sFormat")));
|
scanpath->camid = (int)json_object_get_int(json_object_object_get(j_obj, "iCamId"));
|
scanpath->type = (int)json_object_get_int(json_object_object_get(j_obj, "iType"));
|
scanpath->count = (int)json_object_get_int(json_object_object_get(j_obj, "iCount"));
|
}
|
}
|
json_object_put(j_config);
|
|
if (json_str)
|
g_free(json_str);
|
}
|
|
void storage_manager_diskformat_test(void)
|
{
|
char *json_str = storage_manager_diskformat("/media/usb0", "fat32");
|
|
printf("%s json_str = %s\n", __func__, json_str);
|
if (json_str)
|
g_free(json_str);
|
|
for (int i = 0; i < 100; i++) {
|
json_str = storage_manager_get_disks_status("/media/usb0");
|
printf("%s, %s\n", __func__, json_str);
|
if (json_str)
|
g_free(json_str);
|
usleep(100000);
|
}
|
}
|
|
void storage_manager_test(void)
|
{
|
dbus_monitor_signal_registered(STORAGEMANAGER_INTERFACE, "UpdateDisksStatus", &signal_update_disks_status);
|
storage_manager_get_disks_status_test();
|
storage_manager_get_filelist_id_test();
|
storage_manager_get_filelist_path_test();
|
storage_manager_get_media_path_test();
|
//storage_manager_diskformat_test();
|
//creat_mediafile_test();
|
}
|
|
int main( int argc , char ** argv)
|
{
|
//IPCProtocol_init();
|
//int signal_id = dbus_monitor_signal_registered(STORAGEMANAGER_PATH, STORAGEMANAGER, STORAGEMANAGER_INTERFACE, SM_SIGNAL_UPDATEDISKSTATUS, &signal_update_disks_status);
|
storage_manager_test();
|
|
while (1){
|
sleep(1);
|
}
|
|
//dbus_monitor_signal_unregistered(signal_id);
|
|
return 0;
|
}
|
