api-ref/html/test_8cpp_source.html

 /*
  * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
  *
  * 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.
  */

 #include <libsoundmanager/libsoundmanager.hpp>
 #include <iostream>
 #include <glib-2.0/glib.h>
 #include <fcntl.h>
 #include <string>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <thread>
 #include <exception>
 #include <vector>
 #include <sstream>

 using namespace std;

 static int io_event_callback(sd_event_source *src, int fd, uint32_t revents, void *closure);
 static vector<string> split(const string& str, char sep);
 LibSoundmanager* sm;
 static sd_event_source *evsrc;
 static GMainLoop *loop = NULL;
 static void call_test();

 static void usage()
 {
     cout << "verb "<< "key:arg" << endl;
     cout << "example: connect sourceID 100 sinkID 100" << endl;
     cout << "verb list:" << endl;
     // Todo output api list
     exit(0);
 }

 static void *event_loop_run(void *args)
 {
     call_test();
 }

 static int io_event_callback(sd_event_source *src, int fd, uint32_t revents, void *closure)
 {
     /* This is for Receiving Thread */
 }

 static void call_test()
 {
     string command;

     cout << "input verb and argments" << endl;

     /* read the buffer */
     for(;;){
         char line[1023];
         cin.getline(line, sizeof(line));
         command = line;
         if(command.empty()){
             continue;
         }

         vector<string> v_command = split(command, ' ');
         /*for(auto itr = v_command.begin(); itr != v_command.end(); ++itr)
         {
             cout << *itr <<endl;
         }*/
         size_t num = v_command.size();
         if(num % 2 == 0){
             cout << "If command contains args, please input <key,value> in argument part" << endl;
             continue;
         }
         /* create json object */
         struct json_object* j_obj = json_object_new_object();
         for(int i = 1;i < (v_command.size()) ;++i){
             struct json_object* val     = json_object_new_string(v_command[i+1].c_str());
             json_object_object_add(j_obj, v_command[i].c_str(), val);
             ++i;
         }
         /* call verb via libsoundmanager */
         sm->call(v_command[0], j_obj);
         /* free vector */
         vector<string>().swap(v_command);
         string().swap(command);
     }
 }

 static void onRep(struct json_object* reply_contents)
 {
     const char* str = json_object_to_json_string(reply_contents);
     cout << "[CB onRep]: " << str << endl;
     json_object_put(reply_contents);
 }

 static void onEv(const string& event, struct json_object* event_contents)
 {
     const char* str = json_object_to_json_string(event_contents);
     cout << "[CB onEvent]: event" << event.c_str() << "  contents:" << str << endl;
     json_object_put(event_contents);
 }

 static vector<string> split(const string& str, char sep)
 {
     vector<string> v;
     stringstream ss(str);
     string buffer;
     while( getline(ss, buffer, sep) ) {
         if(!buffer.empty())
             v.push_back(buffer);
     }
     return v;
 }

 int main(int argc, char **argv)
 {
     int ret;
     if(argc == 1)
     {
         printf("Please input port num in first argument, and token in second argument");
         usage();
         return 0;
     }
     if(argc == 2)
     {
         string av(argv[1]);
         if( (av == "-h") || (av == "--help"))
         {
             usage();
             return 0;
         }
     }

     string port_string(argv[1]);
     string token(argv[2]);
     char* endptr;
     long port = strtol(port_string.c_str(),&endptr,10);

     /* error check of range */
     if( (port > 20000) || (port < 0) )
     {
         printf("input under 20000(temporary number)");
         return 0;
     }
     if(*endptr != '\0')
     {
         printf("not number");
         return 0;
     }

     cout << "Call test for libsoundmanager" << endl;
     sm = new LibSoundmanager(port, token);
     sm->register_callback(&onEv, &onRep);
     pthread_t thread_id;
     ret = pthread_create(&thread_id, NULL, event_loop_run, NULL);

     sd_event *sloop;
     ret = sd_event_default(&sloop);

     if (ret < 0) {
         printf("failed to create event loop");
         return -1;
     }

     sd_event_add_io(sloop, &evsrc, 0, EPOLLIN, io_event_callback, NULL);
     for(;;)
         sd_event_run(sloop, 30000000);
     return 0;
 }
event
Definition: soundmanager.c:49

+std

+LibSoundmanager::call
int call(const std::string &verb, struct json_object *arg)
Definition: libsoundmanager.cpp:217

+LibSoundmanager::register_callback
void register_callback(void(*event_cb)(const std::string &event, struct json_object *event_contents), void(*reply_cb)(struct json_object *reply_contents))
Definition: libsoundmanager.cpp:119

+sm
LibSoundmanager * sm
Definition: test.cpp:33

+libsoundmanager.hpp

+main
int main(int argc, char **argv)
Definition: test.cpp:123

+LibSoundmanager
Definition: libsoundmanager.hpp:62

+