Changeset 507:02df594a66c2 in verona

Timestamp:

Jul 31, 2012 2:57:52 PM (11 months ago)

Author:

Nikita Kozlov <nikita@…>

Branch:

default

Message:

siwg scripts update

Files:

• phapi/phapi.c (modified) (2 diffs)
• phcpp/phapipp.cpp (modified) (3 diffs)
• phcpp/phapipp.h (modified) (4 diffs)
• swig/verona.i (modified) (14 diffs)

phapi/phapi.c

@@ -5895 +5895 @@
                         ph_update_nego_mflags(ca,ph_get_media_direction(new_sdp,"audio"),ph_get_media_direction(new_sdp,"video"));
         
+#ifndef ANDROID /* XXX: we will start the stream after we are sure that the ringback tone si finished */
                         if (ph_call_media_start(ca, je, mflags, ca->localresume))
                         {
                                 DBG_SIP_NEGO("SIP NEGO: ph_call_answered but without stream\n");
                         }
+#endif
                 }
         }
@@ -7535 +7537 @@
 void phSetDebugLevel(int level) {
         phDebugLevel = level;
+        osip_trace_enable_until_level(level);
 }
 

phcpp/phapipp.cpp

@@ -187 +187 @@
 }
 
+int phapi::callStartMedia(int cid, int streamFlags)
+{
+        return phCallStartMedia(cid, streamFlags);
+}
 
 int phapi::subscribe(int vlid, const char* to, int winfo, int use_proxy, int expire,
@@ -500 +504 @@
 void phapi::onSubscriptionProgress(int sid,  const phSubscriptionStateInfo_t *info)  { }
 void phapi::onFrameReady(int cid, phVideoFrameReceivedEvent_t *ev) { }
-void phapi::onPhLogCsl(const char *msg){ }
+void phapi::onPhLogCsl(int level, const char *msg){ }
 
 void phapi::onSoundFileStopped(void *userdata , unsigned int _id, void *arg){}
@@ -580 +584 @@
 }
 
-void phapi::phLogCsl(const char *msg)
-{
-        if (uniqueobj)
-                uniqueobj->onPhLogCsl(msg);
+void phapi::phLogCsl(int level, const char *msg)
+{
+        if (uniqueobj)
+                uniqueobj->onPhLogCsl(level, msg);
 }
 

phcpp/phapipp.h

@@ -64 +64 @@
 
 
+#ifndef SWIGJAVA
+typedef std::pair<int, std::string> strresult;
+#else
+struct  strresult {
+        int first;
+        std::string  second;
+
+        strresult(int i, const std::string& s2) : first(i), second(s2) { }
+        strresult(int i) : first(i) { }
+};
+#endif
+
+typedef std::vector<std::string> strvector;
+typedef std::vector<std::pair<const char*, const char*> > cstrpairvec;
+
+struct  strresult2 {
+        int first;
+        std::string  second,third;
+
+        strresult2(int i, const std::string& s2, const std::string& s3) : first(i), second(s2), third(s3) { }
+        strresult2(int i) : first(i) { }
+};
+
+
+struct  strresult3 {
+        int first;
+        std::string  second,third,fourth;
+
+        strresult3(int i, const std::string& s2, const std::string& s3, const std::string& s4) :
+                first(i), second(s2), third(s3), fourth(s4) { }
+        strresult3(int i) : first(i) { }
+};
+
 namespace verona {
 
@@ -194 +227 @@
         virtual int mutePlayback(int cid, int val);
         virtual int muteCapture(int cid, int val);
+        virtual int callStartMedia(int cid, int streamFlags);
         
         virtual int setSoundFileGain(phStream* phstream,float gain);
@@ -238 +272 @@
 #endif
         virtual void onDtmfProgress(int cid, int dtmf);
-        virtual void onPhLogCsl(const char *msg);
+        virtual void onPhLogCsl(int level, const char *msg);
         virtual void onSoundFileStopped(void *userdata , unsigned int _id, void *arg);
         virtual void onQosEvent(int cid, const phQosInfo_t * info);
@@ -257 +291 @@
         static void  subscriptionProgress(int sid,  const phSubscriptionStateInfo_t *info);
         static void  frameReady(int cid, phVideoFrameReceivedEvent_t *ev);
-        static void  phLogCsl(const char *msg);
+        static void  phLogCsl(int level, const char *msg);
         static void  soundFileStopped(void *userdata , unsigned int _id, void *arg);
         static void  qosEvent(int cid, const phQosInfo_t * info);

swig/verona.i

@@ -16 +16 @@
 %module (directors=1) perl_verona
 #endif
+
+%include "typemaps.i"
 
 %{
@@ -60 +62 @@
 
 
+inline const char* as_cstr(const std::string& s) {
+        return s.c_str();
+}
+
+inline const char* as_cstr(const char* s) {
+        return s;
+}
 
 
@@ -89 +98 @@
  
 }
+struct barr {
+   const char *data;
+   int size;
+};
+
+jbyteArray make_bytearray(JNIEnv* env, const barr& d) 
+{
+    jbyteArray jb = env->NewByteArray(d.size);
+    env->SetByteArrayRegion(jb, 0, d.size, (const jbyte*)d.data);
+    return jb;
+}
+
 %}
 
@@ -94 +115 @@
 %include <std_string.i>
 using namespace std;
+%apply (char *STRING, int LENGTH) { (const char *bdata, int bsize) };
 
 %typemap(out) std::string* {
@@ -100 +122 @@
 
 }
+
+%typemap(out) barr  {
+   $result = make_bytearray(jenv, $1);  // out barr
+}
+
+%typemap(jni) barr "jbyteArray"
+%typemap(jtype) barr "byte[]"
+%typemap(jstype) barr "byte[]"
+%typemap(javaout) barr {
+    return $jnicall;
+  }
 
 %typemap(in) std::string 
@@ -177 +210 @@
 %typemap(newfree) std::string * "delete $1;";
 
+
+
 #endif
 
@@ -187 +222 @@
 %include "std_string.i"
 #endif
+
 %include "std_vector.i"
 %include "std_pair.i"
@@ -193 +229 @@
 
 #ifdef SWIGPYTHON
+//%template(cstrpairvec) std::vector<std::pair<const char*, const char*> >;
+
 %{
 PyObject*
@@ -215 +253 @@
   return result;      
 }
-%}
+
+
+template<class SEQ> bool make_str_seq(PyObject *input, SEQ& seq) 
+{
+   typedef typename SEQ::value_type value_type;
+
+   if (PySequence_Check(input)) {
+      int size = PySequence_Size(input);
+      for(int i = 0; i < size; i++) {
+          if (PyString_Check(PySequence_Fast_GET_ITEM(input, i))) {
+              seq.push_back(value_type(PyString_AsString(PySequence_Fast_GET_ITEM(input, i))));
+          } else {
+              PyErr_SetString(PyExc_TypeError,"not a string sequence");                             
+              return false;
+          }
+       }         
+   } else {
+     PyErr_SetString(PyExc_TypeError,"not a sequence");
+     return false;
+   }
+
+   return true; 
+}
+
+template<class SEQ> bool make_strpair_seq(PyObject *input, SEQ& seq)
+{
+  if (PySequence_Check(input)) {
+        int size = PySequence_Size(input);
+        for(int i = 0; i < size; i++) {
+                PyObject *o = PySequence_Fast_GET_ITEM(input, i);
+                if (PySequence_Check(o) && 2 == PySequence_Size(o)) {
+                   if (PyString_Check(PySequence_Fast_GET_ITEM(o, 0)) && PyString_Check(PySequence_Fast_GET_ITEM(o, 1))) {
+                         seq.push_back(std::make_pair<const char*, const char*>(PyString_AsString(PySequence_Fast_GET_ITEM(o, 0)), 
+                                PyString_AsString(PySequence_Fast_GET_ITEM(o, 1))));
+                         } else {
+                            PyErr_SetString(PyExc_TypeError,"not a string sequence");                       
+                            return false;
+                         }
+                         
+                   } else {
+                            PyErr_SetString(PyExc_TypeError,"item is not a 2 element sequence");
+                            return false;
+                   }
+                 
+                   
+        }
+  } else {
+     PyErr_SetString(PyExc_TypeError,"not a sequence");
+     return false;
+    
+  }
+  return true;
+}
+%}
+
+ 
+%typemap(in) strvector& ($*1_ltype tmpvec), vector<char*>& ($*1_ltype tmpvec),  vector<const char*>& ($*1_ltype tmpvec) {
+   // in strvector&
+   if (!make_str_seq($input, tmpvec))
+        return NULL;
+   $1 = &tmpvec;
+}
+
+%typemap(in) strvector, vector<char*>, vector<const char*> {
+   // in strvector
+   if (!make_str_seq($input, $1))
+        return NULL;
+}
+
+
+
 
 %typemap(out) std::map<char*, char*> {
@@ -240 +348 @@
 }
 
-%typemap(in) const std::vector<std::pair<const char*, const char*> >& {
-
-  // we transform any Python sequence of items which are sequences where first 2 elements are string to a vector<pair<const char*, const char *>>
-  if (PySequence_Check($input)) {
-    std::vector<std::pair<const char*, const char*> > tmpvec;
-    $1 = &tmpvec;
-    
-        int size = PySequence_Size($input);
-        for(int i = 0; i < size; i++) {
-                PyObject *o = PySequence_GetItem($input, i);
-                if (PySequence_Check(o)) {
-                   if (PyString_Check(PySequence_GetItem(o, 0)) && PyString_Check(PySequence_GetItem(o, 1))) {
-                         $1->push_back(std::make_pair<const char*, const char*>(PyString_AsString(PySequence_GetItem(o, 0)), 
-                                PyString_AsString(PySequence_GetItem(o, 1))));
-                         } else {
-                            PyErr_SetString(PyExc_TypeError,"not a string sequence");                       
-                            return NULL;
-                         }
-                         
-                   } else {
-                            PyErr_SetString(PyExc_TypeError,"item is not a sequence");
-                            return NULL;
-                   }
-                 
-                   
-        }
-  } else {
-     PyErr_SetString(PyExc_TypeError,"not a sequence");
-     return NULL;
-    
-  }
+%typemap(typecheck, precedence=SWIG_TYPECHECK_STRING_ARRAY) cstrpairvec, cstrpairvec&, const cstrpairvec&, cstrpairvec*, const cstrpairvec* %{
+ $1 = PySequence_Check($input);
+%}
+
+%typemap(in) cstrpairvec& ($*1_ltype tmpvec) {
+   // in strpair vector&
+   if (!make_strpair_seq($input, tmpvec))
+        return NULL;
+   $1 = &tmpvec;
 }
 
@@ -300 +386 @@
 }
 
-#endif
+%{
+typedef PyObject SWIG_Object;
+ 
+template<class T> struct SwigObj {
+   SWIG_Object* obj(int v) { return PyLong_FromLong(v); }          
+ };
+
+template<> struct SwigObj<std::string> {
+  static SWIG_Object* obj(const std::string& s) { return PyString_FromStringAndSize(s.c_str(), s.length()); }   
+ };
+
+template<> struct SwigObj< std::pair<int, std::string> > {
+  static SWIG_Object* obj(const std::pair<int, std::string>& p) {
+    SWIG_Object *tuple;
+
+    tuple = Py_BuildValue("(is#)", p.first, p.second.c_str(), p.second.size() );
+    return tuple;
+  }
+ };
+ 
+template<> struct SwigObj< strresult2 > {
+  static SWIG_Object* obj(const strresult2& p) {
+    SWIG_Object *tuple;
+
+    tuple = Py_BuildValue("(is#s#)", p.first, p.second.c_str(), p.second.size(), p.third.c_str(), p.third.size() );
+    return tuple;
+  }
+ };
+ 
+
+
+template<> struct SwigObj< strresult3 > {
+  static SWIG_Object* obj(const strresult3& p) {
+    SWIG_Object *tuple;
+
+    tuple = Py_BuildValue("(is#s#s#)", p.first, p.second.c_str(), p.second.size(), p.third.c_str(), p.third.size(),
+      p.fourth.c_str(), p.fourth.size() );
+    return tuple;
+  }
+ };
+%}
+
+%typemap(out) strresult* {
+  $result = SwigObj<strresult>::obj(*$1);
+  delete $1;
+ }
+ 
+%typemap(out) strresult2* {
+  $result = SwigObj<strresult2>::obj(*$1);
+  delete $1;
+ }
+ 
+%typemap(out) strresult3* {
+  $result = SwigObj<strresult3>::obj(*$1);
+  delete $1;
+ }
+
+#endif
+ 
+#ifdef SWIGJAVA
+%{
+template<class SEQ> bool make_str_seq(_jobjectArray* input, SEQ& seq, JNIEnv *jenv) 
+{
+   typedef typename SEQ::value_type value_type;
+
+    int i = 0;
+    jint size = jenv->GetArrayLength((_jarray*)input);
+    /* make a copy of each string */
+    for (i = 0; i<size; i++) {
+        jstring j_string = (jstring)jenv->GetObjectArrayElement( input, i);
+        const char * c_string = jenv->GetStringUTFChars(j_string, 0);
+        seq.push_back(value_type(c_string));
+        jenv->ReleaseStringUTFChars(j_string, c_string);
+        jenv->DeleteLocalRef(j_string);
+    }
+  
+   return true; 
+}
+%}
+#endif
+
 
 
@@ -307 +473 @@
        %template(pStrMap) map<char*, char *>; 
        %template(pcStrPair) pair<const char*, const char*>;
-       %template(pcStrVec) vector<pair<const char*, const char *> >;
+       %template(pcStrPairVec) std::vector<std::pair<const char*, const char*> >;
+#ifndef SWIGJAVA
+       %template(strresult) pair<int, std::string>;
+#endif
 }
 #endif
@@ -315 +484 @@
      ph_hdr_val *item(int i) { return i < self->count ? self->elems+i : 0; }
 }; 
+
+#ifdef SWIGJAVA
+
+%template(strvector) std::vector<std::string>;
+
+%typemap(jni) strvector& "jobjectArray"
+%typemap(jtype) strvector& "String[]"
+%typemap(jstype) strvector& "String[]"
+%typemap(javain) strvector& "$javainput"
+%typemap(directorin, descriptor="[Ljava/lang/String;", noblock=1) strvector&, vector<char*>, vector<const char*> %{
+
+        
+       {
+         jobject nullstr =  jenv->NewStringUTF("");
+         $input = (jobjectArray)jenv->NewObjectArray($1.size(),
+                jenv->FindClass("java/lang/String"),
+                nullstr);
+         jenv->DeleteLocalRef(nullstr);
+        }
+
+        TmpJOBJ tvec_$1name(jenv, (jobject) $input);
+
+        for(int i = 0; i < $1.size(); i++) {
+            jobject je = jenv->NewStringUTF(::as_cstr($1[i]));
+            jenv->SetObjectArrayElement($input, i, je);
+            jenv->DeleteLocalRef(je);
+        } 
+        
+
+%}
+
+%typemap(javadirectorin) strvector& "$jniinput"
+%typemap(javadirectorin) int* "$jniinput"
+%typemap(javadirectorout) int* "$jniinput"
+%typemap(directorin, descriptor="[I", noblock = 1) int* %{
+        {
+                jintArray result;
+                result = jenv->NewIntArray(1);
+                // move from the temp structure to the java structure
+                jenv->SetIntArrayRegion(result, 0, 1, $1);
+        $input = result;
+        }
+
+        TmpJOBJ tvec_$1name(jenv, (jobject) $input);
+
+%}
+
+
+
+%typemap(in) strvector& ($*1_ltype tmpvec), vector<char*>& ($*1_ltype tmpvec), vector<const char*>& ($*1_ltype tmpvec) {
+   make_str_seq($input, tmpvec, jenv);
+   $1 = &tmpvec;
+}
+
+%typemap(in) strvector, vector<char*>, vector<const char*> %{
+   make_str_seq($input, $1, jenv);
+%}
+#endif
+
+ 
+ 
 #if 0
 enum ph_subs_type 
@@ -527 +757 @@
 
 %feature("director") phapi;
-
+%apply int *OUTPUT {int *isreceipt};
 %include "phapi.h"
 %include "phapipp.h"
+
+#ifdef SWIGJAVA
+struct barr;
+
+%extend strresult {
+        
+        barr jsecond() { 
+          barr ba = { self->second.c_str(), self->second.size()  };  
+          return ba;
+        }
+}
+#endif
+