Changeset 77:9ebf545c4539 in mediastreamer2


Ignore:
Timestamp:
Oct 11, 2008 10:42:58 PM (5 years ago)
Author:
jehan <jehan@…>
Branch:
default
Message:

implement native api

git-svn-id: ​svn+ssh://svn.savannah.nongnu.org/linphone/trunk@80 3f6dc0c8-ddfe-455d-9043-3cd528dc4637

Location:
p2pproxy
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • p2pproxy/launcher/Debug/makefile

    r48 r77  
    3030        @echo 'Building target: $@' 
    3131        @echo 'Invoking: GCC C Linker' 
    32         gcc -L/usr/lib/jvm/java-6-openjdk/jre/lib/amd64 -L/usr/lib/jvm/java-6-openjdk/jre/lib/amd64/server -o"p2pproxy-launcher" $(OBJS) $(USER_OBJS) $(LIBS) 
     32        gcc -L/usr/lib/jvm/java-6-openjdk/jre/lib/amd64 -L/usr/lib/jvm/java-6-openjdk/jre/lib/i386 -L/usr/lib/jvm/java-6-openjdk/jre/lib/amd64/server -L/usr/lib/jvm/java-6-openjdk/jre/lib/i386/server -o"p2pproxy-launcher" $(OBJS) $(USER_OBJS) $(LIBS) 
    3333        @echo 'Finished building target: $@' 
    3434        @echo ' ' 

  • p2pproxy/launcher/src/launcher-tester.c

    r75 r77  
    1212int main(int argc, char **argv) { 
    1313        pthread_t th; 
    14         printf("starting p2pproxy tester"); 
     14        printf("starting p2pproxy tester \n"); 
    1515        pthread_create(&th,NULL,thread_starter,NULL); 
     16        sleep(3); 
    1617         
    17         sleep(1000); 
    18         /*p2pproxy_application_stop();*/ 
     18        if (p2pproxy_application_get_state() == P2PPROXY_CONNECTED) { 
     19                printf("CONNECTED \n"); 
     20        } else { 
     21                printf("NOT CONNECTED \n"); 
     22        }; 
     23 
     24 
     25        if (p2pproxy_accountmgt_createAccount("sip:titi@p2p.linphone.org") != P2PPROXY_NO_ERROR) { 
     26                printf("cannot create account \n");      
     27        } 
     28         
     29         
     30        if (p2pproxy_accountmgt_isValidAccount("sip:titi@p2p.linphone.org") != P2PPROXY_ACCOUNTMGT_USER_EXIST) { 
     31                printf("user not created \n");   
     32        } 
     33         
     34        char string_buffer[256]; 
     35        if (p2pproxy_resourcelocation_get_sip_proxyregistrar_uri(string_buffer,256) != P2PPROXY_NO_ERROR) { 
     36                printf("cannot get proxy\n");    
     37        } else { 
     38                printf("registrar is [%s]\n",string_buffer); 
     39        } 
     40        if (p2pproxy_accountmgt_deleteAccount("sip:titi@p2p.linphone.org") != P2PPROXY_NO_ERROR) { 
     41                printf("cannot delete account \n");      
     42        } 
     43         
     44        p2pproxy_application_stop(); 
    1945        pthread_join(th,NULL); 
    2046        return 0; 

  • p2pproxy/launcher/src/p2pproxy.c

    r75 r77  
    1313#endif 
    1414#define NUMBER_OF_OPTION 7 
    15 JNIEnv* p2pproxy_application_jnienv = 0; 
    1615JavaVM* p2pproxy_application_jvm = 0; 
    17 jclass  p2pproxy_proxy_main_class = 0; 
     16 
     17#define GET_JNI_ENV \ 
     18        jint lResut = 0 ;\ 
     19        JNIEnv* lJniEnv = 0;\ 
     20        jclass  lMainClass = 0;\ 
     21        lResut = (*p2pproxy_application_jvm)->AttachCurrentThread(p2pproxy_application_jvm,&lJniEnv,NULL);\ 
     22        if (lResut != 0) { \ 
     23                fprintf(stderr,"cannot attach VM\n");\ 
     24                return P2PPROXY_ERROR;\ 
     25        }\ 
     26        lMainClass = (*lJniEnv)->FindClass(lJniEnv, "org/linphone/p2pproxy/core/P2pProxyMain");\ 
     27        if (lMainClass == 0) { \ 
     28                fprintf(stderr,"cannot load class org/linphone/p2pproxy/core/P2pProxyMain\n");\ 
     29                return P2PPROXY_ERROR; \ 
     30        } \ 
     31 
    1832 
    1933int p2pproxy_application_start(int argc, char **argv) { 
    20  
     34        JNIEnv* lJniEnv = 0; 
     35        jclass  lMainClass = 0; 
     36         
    2137        JavaVMInitArgs args; 
    2238        JavaVMOption options[NUMBER_OF_OPTION]; 
    … …  
    2844        int optioncount=0; 
    2945 
    30         if (p2pproxy_application_jnienv != 0) { 
     46        if (p2pproxy_application_jvm != 0) { 
    3147                fprintf(stderr,"p2pproxy already started"); 
    3248                return P2PPROXY_ERROR_APPLICATION_ALREADY_STARTED; 
    … …  
    5369        args.nOptions = NUMBER_OF_OPTION; 
    5470        args.options = options; 
    55         args.ignoreUnrecognized = JNI_FALSE; 
     71        args.ignoreUnrecognized = JNI_FALSE;    int lResult; 
     72         
    5673 
    57         res = JNI_CreateJavaVM(&p2pproxy_application_jvm, (void **)&p2pproxy_application_jnienv, &args); 
     74        res = JNI_CreateJavaVM(&p2pproxy_application_jvm, (void **)&lJniEnv, &args); 
    5875        if (res < 0) { 
    5976                fprintf(stderr,"cannot start p2pproxy vm [%i]",res); 
    … …  
    6178        } 
    6279 
    63         p2pproxy_proxy_main_class = (*p2pproxy_application_jnienv)->FindClass(p2pproxy_application_jnienv, "org/linphone/p2pproxy/core/P2pProxyMain"); 
     80        lMainClass = (*lJniEnv)->FindClass(lJniEnv, "org/linphone/p2pproxy/core/P2pProxyMain"); 
    6481 
    65         if (p2pproxy_proxy_main_class == 0) { 
     82        if (lMainClass == 0) { 
    6683                fprintf(stderr,"cannot load class org/linphone/p2pproxy/core/P2pProxyMain\n"); 
    6784                return P2PPROXY_ERROR; 
    6885        } 
    69         mainMethod = (*p2pproxy_application_jnienv)->GetStaticMethodID(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, "main", "([Ljava/lang/String;)V"); 
     86        mainMethod = (*lJniEnv)->GetStaticMethodID(lJniEnv, lMainClass, "main", "([Ljava/lang/String;)V"); 
    7087 
    71         applicationArgsList = (*p2pproxy_application_jnienv)->NewObjectArray(p2pproxy_application_jnienv, argc, (*p2pproxy_application_jnienv)->FindClass(p2pproxy_application_jnienv, "java/lang/String"), NULL); 
     88        applicationArgsList = (*lJniEnv)->NewObjectArray(lJniEnv, argc, (*lJniEnv)->FindClass(lJniEnv, "java/lang/String"), NULL); 
    7289         
    7390        for (i=0;i<argc;i++) { 
    74                 applicationArg = (*p2pproxy_application_jnienv)->NewStringUTF(p2pproxy_application_jnienv, argv[i]); 
    75                 (*p2pproxy_application_jnienv)->SetObjectArrayElement(p2pproxy_application_jnienv, applicationArgsList, 0, applicationArg); 
     91                applicationArg = (*lJniEnv)->NewStringUTF(lJniEnv, argv[i]); 
     92                (*lJniEnv)->SetObjectArrayElement(lJniEnv, applicationArgsList, i, applicationArg); 
    7693 
    7794        } 
    7895 
    79         (*p2pproxy_application_jnienv)->CallStaticVoidMethod(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, mainMethod, applicationArgsList); 
     96        (*lJniEnv)->CallStaticVoidMethod(lJniEnv, lMainClass, mainMethod, applicationArgsList); 
    8097 
    8198        return P2PPROXY_NO_ERROR; 
    8299} 
     100        int lResult; 
    83101 
    84102 
    … …  
    90108int p2pproxy_accountmgt_createAccount(const char* user_name) { 
    91109        jmethodID createAccountMethod; 
    92         jstring applicationArg;  
    93          
    94         createAccountMethod = (*p2pproxy_application_jnienv)->GetStaticMethodID(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, "createAccount", "([java/lang/String;)I"); 
    95         applicationArg = (*p2pproxy_application_jnienv)->NewStringUTF(p2pproxy_application_jnienv, user_name); 
    96         return (*p2pproxy_application_jnienv)->CallStaticIntMethod(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, createAccountMethod, applicationArg); 
     110        jstring applicationArg; 
     111        GET_JNI_ENV 
     112        createAccountMethod = (*lJniEnv)->GetStaticMethodID(lJniEnv, lMainClass, "createAccount", "(Ljava/lang/String;)I"); 
     113        applicationArg = (*lJniEnv)->NewStringUTF(lJniEnv, user_name); 
     114        lResult = (*lJniEnv)->CallStaticIntMethod(lJniEnv, lMainClass, createAccountMethod, applicationArg); 
     115        (*p2pproxy_application_jvm)->DetachCurrentThread(p2pproxy_application_jvm); 
     116        return lResult; 
    97117} 
    98118 
    … …  
    100120        jmethodID isValidAccountMethod; 
    101121        jstring applicationArg;  
    102          
    103         isValidAccountMethod = (*p2pproxy_application_jnienv)->GetStaticMethodID(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, "isValidAccount", "([java/lang/String;)I"); 
    104         applicationArg = (*p2pproxy_application_jnienv)->NewStringUTF(p2pproxy_application_jnienv, user_name); 
    105         return (*p2pproxy_application_jnienv)->CallStaticIntMethod(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, isValidAccountMethod, applicationArg); 
     122        GET_JNI_ENV 
     123        isValidAccountMethod = (*lJniEnv)->GetStaticMethodID(lJniEnv, lMainClass, "isValidAccount", "(Ljava/lang/String;)I"); 
     124        applicationArg = (*lJniEnv)->NewStringUTF(lJniEnv, user_name); 
     125        lResult = (*lJniEnv)->CallStaticIntMethod(lJniEnv, lMainClass, isValidAccountMethod, applicationArg); 
     126        (*p2pproxy_application_jvm)->DetachCurrentThread(p2pproxy_application_jvm); 
     127        return lResult; 
    106128} 
    107129 
    … …  
    109131        jmethodID deleteAccountMethod; 
    110132        jstring applicationArg;  
    111          
    112         deleteAccountMethod = (*p2pproxy_application_jnienv)->GetStaticMethodID(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, "deleteAccount", "([java/lang/String;)I"); 
    113         applicationArg = (*p2pproxy_application_jnienv)->NewStringUTF(p2pproxy_application_jnienv, user_name); 
    114         return (*p2pproxy_application_jnienv)->CallStaticIntMethod(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, deleteAccountMethod, applicationArg); 
     133        GET_JNI_ENV 
     134        deleteAccountMethod = (*lJniEnv)->GetStaticMethodID(lJniEnv, lMainClass, "deleteAccount", "(Ljava/lang/String;)I"); 
     135        applicationArg = (*lJniEnv)->NewStringUTF(lJniEnv, user_name); 
     136        lResult = (*lJniEnv)->CallStaticIntMethod(lJniEnv, lMainClass, deleteAccountMethod, applicationArg); 
     137        (*p2pproxy_application_jvm)->DetachCurrentThread(p2pproxy_application_jvm); 
     138        return lResult; 
    115139} 
    116140 
    … …  
    120144        const jbyte* lString; 
    121145        jboolean  lIsCopy; 
     146        GET_JNI_ENV 
    122147         
    123         getSipProxyRegistrarUriMethod = (*p2pproxy_application_jnienv)->GetStaticMethodID(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, "getSipProxyRegistrarUriMethod", "()[java/lang/String;"); 
    124         lJStringResult = (*p2pproxy_application_jnienv)->CallStaticObjectMethod(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, getSipProxyRegistrarUriMethod); 
     148        getSipProxyRegistrarUriMethod = (*lJniEnv)->GetStaticMethodID(lJniEnv, lMainClass, "getSipProxyRegistrarUri", "()Ljava/lang/String;"); 
     149        lJStringResult = (*lJniEnv)->CallStaticObjectMethod(lJniEnv, lMainClass, getSipProxyRegistrarUriMethod); 
    125150        if (lJStringResult == 0) { 
    126151                return P2PPROXY_ERROR_RESOURCELOCATOR_SERVER_NOT_FOUND; 
    127152        } 
    128         lString =  (*p2pproxy_application_jnienv)->GetStringUTFChars(p2pproxy_application_jnienv, lJStringResult, &lIsCopy); 
     153        lString =  (*lJniEnv)->GetStringUTFChars(lJniEnv, lJStringResult, &lIsCopy); 
    129154        memcpy(aStringArray,lString,aSize); 
    130         (*p2pproxy_application_jnienv)->ReleaseStringUTFChars(p2pproxy_application_jnienv, lJStringResult, lString); 
     155        (*lJniEnv)->ReleaseStringUTFChars(lJniEnv, lJStringResult, lString); 
     156        (*p2pproxy_application_jvm)->DetachCurrentThread(p2pproxy_application_jvm); 
    131157        return P2PPROXY_NO_ERROR; 
    132158} 
    … …  
    134160int p2pproxy_application_get_state() { 
    135161        jmethodID stateMethod; 
     162        GET_JNI_ENV 
    136163         
    137         stateMethod = (*p2pproxy_application_jnienv)->GetStaticMethodID(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, "getState", "()I"); 
    138         return (*p2pproxy_application_jnienv)->CallStaticIntMethod(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, stateMethod); 
     164        stateMethod = (*lJniEnv)->GetStaticMethodID(lJniEnv, lMainClass, "getState", "()I"); 
     165        lResult = (*lJniEnv)->CallStaticIntMethod(lJniEnv, lMainClass, stateMethod); 
     166        (*p2pproxy_application_jvm)->DetachCurrentThread(p2pproxy_application_jvm); 
     167        return lResult; 
    139168         
    140169} 
    141170void p2pproxy_application_stop() { 
    142         jmethodID stopMethod; 
     171        jmethodID stopMethod = 0; 
     172        GET_JNI_ENV 
    143173         
    144         stopMethod = (*p2pproxy_application_jnienv)->GetStaticMethodID(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, "stop", "()V"); 
    145         (*p2pproxy_application_jnienv)->CallStaticVoidMethod(p2pproxy_application_jnienv, p2pproxy_proxy_main_class, stopMethod); 
     174        stopMethod = (*lJniEnv)->GetStaticMethodID(lJniEnv, lMainClass, "stop", "()V"); 
     175        (*lJniEnv)->CallStaticVoidMethod(lJniEnv, lMainClass, stopMethod); 
     176        (*p2pproxy_application_jvm)->DetachCurrentThread(p2pproxy_application_jvm); 
     177        (*p2pproxy_application_jvm)->DestroyJavaVM(p2pproxy_application_jvm); 
     178        p2pproxy_application_jvm = 0; 
    146179        return; 
    147180 

  • p2pproxy/src/org/linphone/p2pproxy/core/GenericService.java

    r0 r77  
    2020package org.linphone.p2pproxy.core; 
    2121 
     22import java.io.IOException; 
    2223import java.net.Socket; 
    2324import java.net.URI; 
    … …  
    5758   private final ExecutorService mPool; 
    5859   private final ServiceSocketHandlerFactory mServiceSocketHandlerFactory; 
     60   private boolean mExist = false; 
    5961   
    6062   public GenericService(Configurator lProperties,JxtaNetworkManager aJxtaNetworkManager,String aServiceName,ServiceSocketHandlerFactory aServiceSocketHandlerFactory) { 
    … …  
    123125   } 
    124126   public void stop(){ 
    125       throw new RuntimeException("Not implemented"); 
     127           try { 
     128                mJxtaServerSocket.close(); 
     129        } catch (IOException e) { 
     130                //nop 
     131        } 
     132           mExist = true; 
    126133   } 
    127134   public void run() { 
    128       while (true) { 
     135      while (mExist) { 
    129136         try { 
    130137            mLog.info("Waiting for connection on service ["+ADV_NAME+"]"); 

  • p2pproxy/src/org/linphone/p2pproxy/core/P2pProxyMain.java

    r74 r77  
    4343import org.linphone.p2pproxy.core.media.rtprelay.RtpRelayService; 
    4444import org.linphone.p2pproxy.core.sipproxy.SipProxyRegistrar; 
     45import org.linphone.p2pproxy.core.sipproxy.SipProxyRegistrarAdvertisement; 
    4546import org.zoolu.sip.provider.SipStack; 
    4647import org.linphone.p2pproxy.launcher.P2pProxylauncherConstants; 
    … …  
    380381private static void isReady() throws P2pProxyNotReadyException { 
    381382    try { 
    382       if (mJxtaNetworkManager!=null && mJxtaNetworkManager.isConnectedToRendezVous(0) == false) { 
    383          throw new P2pProxyNotReadyException("not connected to any rdv"); 
     383      if ((mJxtaNetworkManager!=null && mJxtaNetworkManager.isConnectedToRendezVous(0) == true)  
     384          ||  
     385          (mJxtaNetworkManager!=null && mJxtaNetworkManager.getPeerGroup().getRendezVousService().isRendezVous())) 
     386      { 
     387         //nop connected 
     388      } else { 
     389          throw new P2pProxyNotReadyException("not connected to any rdv"); 
    384390      } 
    385391   } catch (InterruptedException e) { 
    … …  
    425431   try { 
    426432      isReady(); 
    427       return mP2pProxyManagement.getSipProxyRegistrarUri(); 
    428    } catch (P2pProxyException e) { 
     433      SipProxyRegistrarAdvertisement lSipProxyRegistrarAdvertisement = (SipProxyRegistrarAdvertisement) (mJxtaNetworkManager.getAdvertisement(null, SipProxyRegistrarAdvertisement.NAME, true)); 
     434      return lSipProxyRegistrarAdvertisement.getAddress(); 
     435   } catch (Exception e) { 
    429436      return null; 
    430    }    
     437   }  
    431438} 
    432439public static int getState() { 

  • p2pproxy/src/org/linphone/p2pproxy/core/rdvautoconfig/PeerInfoProviderService.java

    r0 r77  
    6262   public final static String PEERINFO_MODULE_CLASS_ID="org.linphone.p2pproxy.PeerInfoProviderService.module-class.id"; 
    6363   public final static String PEERINFO_MODULE_SPEC_ID="org.linphone.p2pproxy.PeerInfoProviderService.module-spec.id"; 
     64   private boolean mExist = false;  
    6465    
    6566   public PeerInfoProviderService(Configurator lProperties,JxtaNetworkManager aJxtaNetworkManager) { 
    … …  
    119120      }         
    120121   } 
    121    public void stop(){ 
    122       throw new RuntimeException("Not implemented"); 
     122   public void stop() { 
     123           try { 
     124                   mJxtaServerSocket.close(); 
     125           } catch (IOException e) { 
     126                   //nop 
     127           } 
     128           mExist = true; 
     129           mLog.info("PeerInfoProviderService stopped"); 
    123130   } 
    124131 
    125132   public void run() { 
    126       while (true) { 
     133      while (mExist) { 
    127134         try { 
    128135            mLog.info("Waiting for connection on ["+ADV_NAME+"]"); 
    … …  
    156163         Object lInputObj; 
    157164         Object lOutputObj; 
    158          boolean lStop = false; 
    159          while (lStop == false) { 
     165         while (mExist == false) { 
    160166            lInputObj = lIn.readObject(); 
    161167            mLog.info("request message ["+lInputObj+"] received"); 
Note: See TracChangeset for help on using the changeset viewer.