orte/libjorte/JORTEDomainAppCreate.c

   1 /* JORTEDomainAppCreate.c */
   2
   3 /**
   4   * This code provides conversion between JAVA a C environments.
   5   * The C functions are calling here and results are send to JAVA
   6   * native functions. It uses the header pregenerated by JAVA
   7   * (by command 'javah -jni class_with_native_function')
   8   *
   9   * @author Lukas Pokorny (lukas_pokorny@centrum.cz)
  10   * @author CTU FEE Prague - Department of Control Engineering (dce.felk.cvut.cz)
  11   * @author Project ORTE - OCERA Real Time Ethernet (www.ocera.org)
  12   * @author dedication to Kj
  13   * @version 0.1
  14   *
  15   *
  16   * This program is free software; you can redistribute it and/or modify
  17   * it under the terms of the GNU General Public License as published by
  18   * the Free Software Foundation; either version 2 of the License, or
  19   * (at your option) any later version.
  20   *
  21   * This program is distributed in the hope that it will be useful,
  22   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  24   * GNU General Public License for more details.
  25   *
  26   */
  27
  28 #include <stdlib.h>
  29 // origin orte headers
  30 #include "orte.h"
  31 // pregenerated header
  32 #include "jorte/org_ocera_orte_DomainApp.h"
  33 // enable TEST_STAGE run level
  34 #include "jorte/4all.h"
  35 // new data types
  36 #include "jorte/jorte_typedefs_defines.h"
  37 #include "jorte/jorte_protos_api.h"
  38 #include <inttypes.h>
  39
  40 // /////////////////////////////////////////////////////////////////////
  41 //  public void onRegFail()
  42 // /////////////////////////////////////////////////////////////////////
  43 Boolean
  44 onRegFail(void *param)
  45 {
  46 // ///////////////////////////////// SPOLECNA CAST //
  47   JavaVM          *jvm = NULL;
  48   JNIEnv          *env = NULL; // local reference
  49   jclass           cls;
  50   jmethodID        mid;
  51   //
  52   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
  53   int flag_ok = 0;
  54
  55   #ifdef TEST_STAGE
  56       printf(":c: event func. 'onRegFail()' called.. \n");
  57   #endif
  58
  59   do
  60   {
  61 // ///////////////////////////////// SPOLECNA CAST //
  62     if(domain_events_cont->jvm == 0)
  63     {
  64      #ifdef TEST_STAGE
  65        printf(":!c: jvm = NULL! \n");
  66      #endif
  67      break;
  68     }
  69     jvm = domain_events_cont->jvm;
  70     // get env
  71     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
  72     if(env == 0)
  73     {
  74      #ifdef TEST_STAGE
  75        printf(":!c: env = NULL! \n");
  76      #endif
  77      break;
  78     }
  79     // find class
  80     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
  81     if(cls == 0)
  82     {
  83      #ifdef TEST_STAGE
  84        printf(":!c: cls = NULL! \n");
  85      #endif
  86      break;
  87     }
  88 // ///////////////////////////////// SPOLECNA CAST //
  89     // get method ID
  90     mid = (*env)->GetMethodID(env,
  91                               cls,
  92                               "onRegFail",
  93                               "()V");
  94     if(mid == 0)
  95     {
  96      #ifdef TEST_STAGE
  97        printf(":!c: mid = NULL! \n");
  98      #endif
  99      break;
 100     }
 101     // call method
 102     (*env)->CallVoidMethod(env,
 103                            domain_events_cont->obj_de,
 104                            mid);
 105     flag_ok = 1;
 106   } while(0);
 107   // while broken
 108   if(flag_ok)
 109   {
 110     if((*jvm)->DetachCurrentThread(jvm) != 0)
 111     {
 112       printf(":c!: DetachCurrentThread fault! \n");
 113       return  ORTE_FALSE;
 114     }
 115   }
 116
 117   return ORTE_TRUE;
 118 }
 119
 120
 121 // /////////////////////////////////////////////////////////////////////
 122 //  Event - public void onMgrNew()
 123 // /////////////////////////////////////////////////////////////////////
 124 Boolean
 125 onMgrNew(const struct ORTEAppInfo *appInfo, void *param)
 126 {
 127 // ///////////////////////////////// SPOLECNA CAST //
 128   JavaVM          *jvm = NULL;
 129   JNIEnv          *env = NULL; // local reference
 130   jclass           cls;
 131   jobject          obj_ainfo;
 132   jmethodID        mid;
 133   //
 134   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 135   int flag_ok = 0;
 136
 137   #ifdef TEST_STAGE
 138       printf(":c: event func. 'onMgrNew()' called.. \n");
 139   #endif
 140
 141   do
 142   {
 143 // ///////////////////////////////// SPOLECNA CAST //
 144     if(domain_events_cont->jvm == 0)
 145     {
 146      #ifdef TEST_STAGE
 147        printf(":!c: jvm = NULL! \n");
 148      #endif
 149      break;
 150     }
 151     jvm = domain_events_cont->jvm;
 152     // get env
 153     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 154     if(env == 0)
 155     {
 156      #ifdef TEST_STAGE
 157        printf(":!c: env = NULL! \n");
 158      #endif
 159      break;
 160     }
 161     // find class
 162     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 163     if(cls == 0)
 164     {
 165      #ifdef TEST_STAGE
 166        printf(":!c: cls = NULL! \n");
 167      #endif
 168      break;
 169     }
 170     // create AppInfo instance
 171     obj_ainfo = createAppInfo(env, appInfo);
 172     if(obj_ainfo == 0)
 173     {
 174      #ifdef TEST_STAGE
 175        printf(":!c: obj_ainfo = NULL! \n");
 176      #endif
 177      break;
 178     }
 179 // ///////////////////////////////// SPOLECNA CAST //
 180     // get method ID
 181     mid = (*env)->GetMethodID(env,
 182                               cls,
 183                               "onMgrNew",
 184                               "(Lorg/ocera/orte/types/AppInfo;)V");
 185     if(mid == 0)
 186     {
 187      #ifdef TEST_STAGE
 188        printf(":!c: mid = NULL! \n");
 189      #endif
 190      break;
 191     }
 192     // call method
 193     (*env)->CallVoidMethod(env,
 194                            domain_events_cont->obj_de,
 195                            mid,
 196                            obj_ainfo);
 197     flag_ok = 1;
 198   } while(0);
 199   // while broken
 200   if(flag_ok)
 201   {
 202     if((*jvm)->DetachCurrentThread(jvm) != 0)
 203     {
 204       printf(":c!: DetachCurrentThread fault! \n");
 205       return  ORTE_FALSE;
 206     }
 207   }
 208
 209   return ORTE_TRUE;
 210 }
 211
 212
 213 // /////////////////////////////////////////////////////////////////////
 214 //  Event - public void onMgrDelete()
 215 // /////////////////////////////////////////////////////////////////////
 216 Boolean
 217 onMgrDelete(const struct ORTEAppInfo *appInfo, void *param)
 218 {
 219 // ///////////////////////////////// SPOLECNA CAST //
 220   JavaVM          *jvm = NULL;
 221   JNIEnv          *env = NULL; // local reference
 222   jclass           cls;
 223   jobject          obj_ainfo;
 224   jmethodID        mid;
 225   //
 226   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 227   int flag_ok = 0;
 228
 229   #ifdef TEST_STAGE
 230       printf(":c: event func. 'onMgrDelete()' called.. \n");
 231   #endif
 232
 233   do
 234   {
 235 // ///////////////////////////////// SPOLECNA CAST //
 236     if(domain_events_cont->jvm == 0)
 237     {
 238      #ifdef TEST_STAGE
 239        printf(":!c: jvm = NULL! \n");
 240      #endif
 241      break;
 242     }
 243     jvm = domain_events_cont->jvm;
 244     // get env
 245     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 246     if(env == 0)
 247     {
 248      #ifdef TEST_STAGE
 249        printf(":!c: env = NULL! \n");
 250      #endif
 251      break;
 252     }
 253     // find class
 254     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 255     if(cls == 0)
 256     {
 257      #ifdef TEST_STAGE
 258        printf(":!c: cls = NULL! \n");
 259      #endif
 260      break;
 261     }
 262     // create AppInfo instance
 263     obj_ainfo = createAppInfo(env, appInfo);
 264     if(obj_ainfo == 0)
 265     {
 266      #ifdef TEST_STAGE
 267        printf(":!c: obj_ainfo = NULL! \n");
 268      #endif
 269      break;
 270     }
 271 // ///////////////////////////////// SPOLECNA CAST //
 272     // get method ID
 273     mid = (*env)->GetMethodID(env,
 274                               cls,
 275                               "onMgrDelete",
 276                               "(Lorg/ocera/orte/types/AppInfo;)V");
 277     if(mid == 0)
 278     {
 279      #ifdef TEST_STAGE
 280        printf(":!c: mid = NULL! \n");
 281      #endif
 282      break;
 283     }
 284     // call method
 285     (*env)->CallVoidMethod(env,
 286                            domain_events_cont->obj_de,
 287                            mid,
 288                            obj_ainfo);
 289     flag_ok = 1;
 290   } while(0);
 291   // while broken
 292   if(flag_ok)
 293   {
 294     if((*jvm)->DetachCurrentThread(jvm) != 0)
 295     {
 296       printf(":c!: DetachCurrentThread fault! \n");
 297       return  ORTE_FALSE;
 298     }
 299   }
 300
 301   return ORTE_TRUE;
 302 }
 303
 304
 305
 306 // /////////////////////////////////////////////////////////////////////
 307 //  Event - onAppRemoteNew
 308 // /////////////////////////////////////////////////////////////////////
 309 Boolean
 310 onAppRemoteNew(const struct ORTEAppInfo *appInfo, void *param)
 311 {
 312 // ///////////////////////////////// SPOLECNA CAST //
 313   JavaVM          *jvm = NULL;
 314   JNIEnv          *env = NULL; // local reference
 315   jclass           cls;
 316   jobject          obj_ainfo;
 317   jmethodID        mid;
 318   //
 319   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 320   int flag_ok = 0;
 321
 322   #ifdef TEST_STAGE
 323       printf(":c: event func. 'onAppRemoteNew()' called.. \n");
 324   #endif
 325
 326   do
 327   {
 328 // ///////////////////////////////// SPOLECNA CAST //
 329     if(domain_events_cont->jvm == 0)
 330     {
 331      #ifdef TEST_STAGE
 332        printf(":!c: jvm = NULL! \n");
 333      #endif
 334      break;
 335     }
 336     jvm = domain_events_cont->jvm;
 337     // get env
 338     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 339     if(env == 0)
 340     {
 341      #ifdef TEST_STAGE
 342        printf(":!c: env = NULL! \n");
 343      #endif
 344      break;
 345     }
 346     // find class
 347     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 348     if(cls == 0)
 349     {
 350      #ifdef TEST_STAGE
 351        printf(":!c: cls = NULL! \n");
 352      #endif
 353      break;
 354     }
 355     // create AppInfo instance
 356     obj_ainfo = createAppInfo(env, appInfo);
 357     if(obj_ainfo == 0)
 358     {
 359      #ifdef TEST_STAGE
 360        printf(":!c: obj_ainfo = NULL! \n");
 361      #endif
 362      break;
 363     }
 364 // ///////////////////////////////// SPOLECNA CAST //
 365
 366     // get method ID
 367     mid = (*env)->GetMethodID(env,
 368                               cls,
 369                               "onAppRemoteNew",
 370                               "(Lorg/ocera/orte/types/AppInfo;)V");
 371     if(mid == 0)
 372     {
 373      #ifdef TEST_STAGE
 374        printf(":!c: mid = NULL! \n");
 375      #endif
 376      break;
 377     }
 378     // call method
 379     (*env)->CallVoidMethod(env,
 380                            domain_events_cont->obj_de,
 381                            mid,
 382                            obj_ainfo);
 383     flag_ok = 1;
 384   } while(0);
 385   // while broken
 386   if(flag_ok)
 387   {
 388     if((*jvm)->DetachCurrentThread(jvm) != 0)
 389     {
 390       printf(":c!: DetachCurrentThread fault! \n");
 391       return  ORTE_FALSE;
 392     }
 393   }
 394
 395   return ORTE_TRUE;
 396 }
 397
 398
 399 // /////////////////////////////////////////////////////////////////////
 400 //  public void onAppDelete() { }
 401 // /////////////////////////////////////////////////////////////////////
 402 Boolean
 403 onAppDelete(const struct ORTEAppInfo *appInfo, void *param)
 404 {
 405 // ///////////////////////////////// SPOLECNA CAST //
 406   JavaVM          *jvm = NULL;
 407   JNIEnv          *env = NULL; // local reference
 408   jclass           cls;
 409   jobject          obj_ainfo;
 410   jmethodID        mid;
 411   //
 412   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 413   int flag_ok = 0;
 414
 415   #ifdef TEST_STAGE
 416       printf(":c: event func. 'onAppDelete()' called.. \n");
 417   #endif
 418
 419   do
 420   {
 421 // ///////////////////////////////// SPOLECNA CAST //
 422     if(domain_events_cont->jvm == 0)
 423     {
 424      #ifdef TEST_STAGE
 425        printf(":!c: jvm = NULL! \n");
 426      #endif
 427      break;
 428     }
 429     jvm = domain_events_cont->jvm;
 430     // get env
 431     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 432     if(env == 0)
 433     {
 434      #ifdef TEST_STAGE
 435        printf(":!c: env = NULL! \n");
 436      #endif
 437      break;
 438     }
 439     // find class
 440     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 441     if(cls == 0)
 442     {
 443      #ifdef TEST_STAGE
 444        printf(":!c: cls = NULL! \n");
 445      #endif
 446      break;
 447     }
 448     // create AppInfo instance
 449     obj_ainfo = createAppInfo(env, appInfo);
 450     if(obj_ainfo == 0)
 451     {
 452      #ifdef TEST_STAGE
 453        printf(":!c: obj_ainfo = NULL! \n");
 454      #endif
 455      break;
 456     }
 457 // ///////////////////////////////// SPOLECNA CAST //
 458     // get method ID
 459     mid = (*env)->GetMethodID(env,
 460                               cls,
 461                               "onAppDelete",
 462                               "(Lorg/ocera/orte/types/AppInfo;)V");
 463     if(mid == 0)
 464     {
 465      #ifdef TEST_STAGE
 466        printf(":!c: mid = NULL! \n");
 467      #endif
 468      break;
 469     }
 470     // call method
 471     (*env)->CallVoidMethod(env,
 472                            domain_events_cont->obj_de,
 473                            mid,
 474                            obj_ainfo);
 475     flag_ok = 1;
 476   } while(0);
 477   // while broken
 478   if(flag_ok)
 479   {
 480     if((*jvm)->DetachCurrentThread(jvm) != 0)
 481     {
 482       printf(":c!: DetachCurrentThread fault! \n");
 483       return  ORTE_FALSE;
 484     }
 485   }
 486
 487   return ORTE_TRUE;
 488 }
 489
 490
 491 // /////////////////////////////////////////////////////////////////////
 492 //  public void onPubRemoteNew()
 493 // /////////////////////////////////////////////////////////////////////
 494 Boolean
 495 onPubRemoteNew(const struct ORTEAppInfo *appInfo,
 496                const struct ORTEPubInfo *pubInfo,
 497                void *param)
 498 {
 499 // ///////////////////////////////// SPOLECNA CAST //
 500   JavaVM          *jvm = NULL;
 501   JNIEnv          *env = NULL; // local reference
 502   jclass           cls;
 503   jobject          obj_ainfo;
 504   jobject          obj_pinfo;
 505   jmethodID        mid;
 506   //
 507   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 508   int flag_ok = 0;
 509
 510   #ifdef TEST_STAGE
 511       printf(":c: event func. 'onPubRemoteNew()' called.. \n");
 512   #endif
 513
 514   do
 515   {
 516 // ///////////////////////////////// SPOLECNA CAST //
 517     if(domain_events_cont->jvm == 0)
 518     {
 519      #ifdef TEST_STAGE
 520        printf(":!c: jvm = NULL! \n");
 521      #endif
 522      break;
 523     }
 524     jvm = domain_events_cont->jvm;
 525     // get env
 526     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 527     if(env == 0)
 528     {
 529      #ifdef TEST_STAGE
 530        printf(":!c: env = NULL! \n");
 531      #endif
 532      break;
 533     }
 534     // find class
 535     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 536     if(cls == 0)
 537     {
 538      #ifdef TEST_STAGE
 539        printf(":!c: cls = NULL! \n");
 540      #endif
 541      break;
 542     }
 543     // create AppInfo instance
 544     obj_ainfo = createAppInfo(env, appInfo);
 545     if(obj_ainfo == 0)
 546     {
 547      #ifdef TEST_STAGE
 548        printf(":!c: obj_ainfo = NULL! \n");
 549      #endif
 550      break;
 551     }
 552     // create PubInfo instance
 553     obj_pinfo = createPubInfo(env, pubInfo);
 554     if(obj_pinfo == 0)
 555     {
 556      #ifdef TEST_STAGE
 557        printf(":!c: obj_pinfo = NULL! \n");
 558      #endif
 559      break;
 560     }
 561 // ///////////////////////////////// SPOLECNA CAST //
 562     // get method ID
 563     mid = (*env)->GetMethodID(env,
 564                               cls,
 565                               "onPubRemoteNew",
 566                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/PubInfo;)V");
 567     if(mid == 0)
 568     {
 569      #ifdef TEST_STAGE
 570        printf(":!c: mid = NULL! \n");
 571      #endif
 572      break;
 573     }
 574     // call method
 575     (*env)->CallVoidMethod(env,
 576                            domain_events_cont->obj_de,
 577                            mid,
 578                            obj_ainfo,
 579                            obj_pinfo);
 580     flag_ok = 1;
 581   } while(0);
 582   // while broken
 583   if(flag_ok)
 584   {
 585     if((*jvm)->DetachCurrentThread(jvm) != 0)
 586     {
 587       printf(":c!: DetachCurrentThread fault! \n");
 588       return  ORTE_FALSE;
 589     }
 590   }
 591
 592   return ORTE_TRUE;
 593 }
 594
 595
 596 // /////////////////////////////////////////////////////////////////////
 597 //public void onPubRemoteChanged()
 598 // /////////////////////////////////////////////////////////////////////
 599 Boolean
 600 onPubRemoteChanged(const struct ORTEAppInfo *appInfo,
 601                    const struct ORTEPubInfo *pubInfo,
 602                    void *param)
 603 {
 604 // ///////////////////////////////// SPOLECNA CAST //
 605   JavaVM          *jvm = NULL;
 606   JNIEnv          *env = NULL; // local reference
 607   jclass           cls;
 608   jobject          obj_ainfo;
 609   jobject          obj_pinfo;
 610   jmethodID        mid;
 611   //
 612   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 613   int flag_ok = 0;
 614
 615   #ifdef TEST_STAGE
 616       printf(":c: event func. 'onPubRemoteChanged()' called.. \n");
 617   #endif
 618
 619   do
 620   {
 621 // ///////////////////////////////// SPOLECNA CAST //
 622     if(domain_events_cont->jvm == 0)
 623     {
 624      #ifdef TEST_STAGE
 625        printf(":!c: jvm = NULL! \n");
 626      #endif
 627      break;
 628     }
 629     jvm = domain_events_cont->jvm;
 630     // get env
 631     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 632     if(env == 0)
 633     {
 634      #ifdef TEST_STAGE
 635        printf(":!c: env = NULL! \n");
 636      #endif
 637      break;
 638     }
 639     // find class
 640     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 641     if(cls == 0)
 642     {
 643      #ifdef TEST_STAGE
 644        printf(":!c: cls = NULL! \n");
 645      #endif
 646      break;
 647     }
 648     // create AppInfo instance
 649     obj_ainfo = createAppInfo(env, appInfo);
 650     if(obj_ainfo == 0)
 651     {
 652      #ifdef TEST_STAGE
 653        printf(":!c: obj_ainfo = NULL! \n");
 654      #endif
 655      break;
 656     }
 657     // create PubInfo instance
 658     obj_pinfo = createPubInfo(env, pubInfo);
 659     if(obj_pinfo == 0)
 660     {
 661      #ifdef TEST_STAGE
 662        printf(":!c: obj_pinfo = NULL! \n");
 663      #endif
 664      break;
 665     }
 666 // ///////////////////////////////// SPOLECNA CAST //
 667     // get method ID
 668     mid = (*env)->GetMethodID(env,
 669                               cls,
 670                               "onPubRemoteChanged",
 671                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/PubInfo;)V");
 672     if(mid == 0)
 673     {
 674      #ifdef TEST_STAGE
 675        printf(":!c: mid = NULL! \n");
 676      #endif
 677      break;
 678     }
 679     // call method
 680     (*env)->CallVoidMethod(env,
 681                            domain_events_cont->obj_de,
 682                            mid,
 683                            obj_ainfo,
 684                            obj_pinfo);
 685     flag_ok = 1;
 686   } while(0);
 687   // while broken
 688   if(flag_ok)
 689   {
 690     if((*jvm)->DetachCurrentThread(jvm) != 0)
 691     {
 692       printf(":c!: DetachCurrentThread fault! \n");
 693       return  ORTE_FALSE;
 694     }
 695   }
 696
 697   return ORTE_TRUE;
 698 }
 699
 700
 701
 702
 703 // /////////////////////////////////////////////////////////////////////
 704 //  public void onPubDelete()
 705 // /////////////////////////////////////////////////////////////////////
 706 Boolean
 707 onPubDelete(const struct ORTEAppInfo *appInfo,
 708             const struct ORTEPubInfo *pubInfo,
 709             void *param)
 710 {
 711 // ///////////////////////////////// SPOLECNA CAST //
 712   JavaVM          *jvm = NULL;
 713   JNIEnv          *env = NULL; // local reference
 714   jclass           cls;
 715   jobject          obj_ainfo;
 716   jobject          obj_pinfo;
 717   jmethodID        mid;
 718   //
 719   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 720   int flag_ok = 0;
 721
 722   #ifdef TEST_STAGE
 723       printf(":c: event func. 'onPubDelete()' called.. \n");
 724   #endif
 725
 726   do
 727   {
 728 // ///////////////////////////////// SPOLECNA CAST //
 729     if(domain_events_cont->jvm == 0)
 730     {
 731      #ifdef TEST_STAGE
 732        printf(":!c: jvm = NULL! \n");
 733      #endif
 734      break;
 735     }
 736     jvm = domain_events_cont->jvm;
 737     // get env
 738     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 739     if(env == 0)
 740     {
 741      #ifdef TEST_STAGE
 742        printf(":!c: env = NULL! \n");
 743      #endif
 744      break;
 745     }
 746     // find class
 747     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 748     if(cls == 0)
 749     {
 750      #ifdef TEST_STAGE
 751        printf(":!c: cls = NULL! \n");
 752      #endif
 753      break;
 754     }
 755     // create AppInfo instance
 756     obj_ainfo = createAppInfo(env, appInfo);
 757     if(obj_ainfo == 0)
 758     {
 759      #ifdef TEST_STAGE
 760        printf(":!c: obj_ainfo = NULL! \n");
 761      #endif
 762      break;
 763     }
 764     // create PubInfo instance
 765     obj_pinfo = createPubInfo(env, pubInfo);
 766     if(obj_pinfo == 0)
 767     {
 768      #ifdef TEST_STAGE
 769        printf(":!c: obj_pinfo = NULL! \n");
 770      #endif
 771      break;
 772     }
 773 // ///////////////////////////////// SPOLECNA CAST //
 774     // get method ID
 775     mid = (*env)->GetMethodID(env,
 776                               cls,
 777                               "onPubDelete",
 778                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/PubInfo;)V");
 779     if(mid == 0)
 780     {
 781      #ifdef TEST_STAGE
 782        printf(":!c: mid = NULL! \n");
 783      #endif
 784      break;
 785     }
 786     // call method
 787     (*env)->CallVoidMethod(env,
 788                            domain_events_cont->obj_de,
 789                            mid,
 790                            obj_ainfo,
 791                            obj_pinfo);
 792     flag_ok = 1;
 793   } while(0);
 794   // while broken
 795   if(flag_ok)
 796   {
 797     if((*jvm)->DetachCurrentThread(jvm) != 0)
 798     {
 799       printf(":c!: DetachCurrentThread fault! \n");
 800       return  ORTE_FALSE;
 801     }
 802   }
 803
 804   return ORTE_TRUE;
 805 }
 806
 807
 808 // /////////////////////////////////////////////////////////////////////
 809 //  Event - onSubRemoteNew
 810 // /////////////////////////////////////////////////////////////////////
 811 Boolean
 812 onSubRemoteNew(const struct ORTEAppInfo *appInfo,
 813                const struct ORTESubInfo *subInfo,
 814                void *param)
 815 {
 816 // ///////////////////////////////// SPOLECNA CAST //
 817   JavaVM          *jvm = NULL;
 818   JNIEnv          *env = NULL; // local reference
 819   jobject          obj_ainfo;
 820   jobject          obj_sinfo;
 821   jclass           cls;
 822   jmethodID        mid;
 823   //
 824   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 825   int flag_ok = 0;
 826
 827   #ifdef TEST_STAGE
 828       printf(":c: event func. 'onSubRemoteNew()' called.. \n");
 829   #endif
 830
 831   do
 832   {
 833 // ///////////////////////////////// SPOLECNA CAST //
 834     if(domain_events_cont->jvm == 0)
 835     {
 836      #ifdef TEST_STAGE
 837        printf(":!c: jvm = NULL! \n");
 838      #endif
 839      break;
 840     }
 841     jvm = domain_events_cont->jvm;
 842     // get env
 843     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 844     if(env == 0)
 845     {
 846      #ifdef TEST_STAGE
 847        printf(":!c: env = NULL! \n");
 848      #endif
 849      break;
 850     }
 851     // find class
 852     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 853     if(cls == 0)
 854     {
 855      #ifdef TEST_STAGE
 856        printf(":!c: cls = NULL! \n");
 857      #endif
 858      break;
 859     }
 860     // create AppInfo instance
 861     obj_ainfo = createAppInfo(env, appInfo);
 862     if(obj_ainfo == 0)
 863     {
 864      #ifdef TEST_STAGE
 865        printf(":!c: obj_ainfo = NULL! \n");
 866      #endif
 867      break;
 868     }
 869     // create SubInfo instance
 870     obj_sinfo = createSubInfo(env, subInfo);
 871     if(obj_sinfo == 0)
 872     {
 873      #ifdef TEST_STAGE
 874        printf(":!c: obj_sinfo = NULL! \n");
 875      #endif
 876      break;
 877     }
 878 // ///////////////////////////////// SPOLECNA CAST //
 879     // get method ID
 880     mid = (*env)->GetMethodID(env,
 881                               cls,
 882                               "onSubRemoteNew",
 883                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/SubInfo;)V");
 884     if(mid == 0)
 885     {
 886      #ifdef TEST_STAGE
 887        printf(":!c: mid = NULL! \n");
 888      #endif
 889      break;
 890     }
 891     // call method
 892     (*env)->CallVoidMethod(env,
 893                            domain_events_cont->obj_de,
 894                            mid,
 895                            obj_ainfo,
 896                            obj_sinfo);
 897     flag_ok = 1;
 898   } while(0);
 899   // while broken
 900   if(flag_ok)
 901   {
 902     if((*jvm)->DetachCurrentThread(jvm) != 0)
 903     {
 904       printf(":c!: DetachCurrentThread fault! \n");
 905       return  ORTE_FALSE;
 906     }
 907   }
 908
 909   return ORTE_TRUE;
 910 }
 911
 912
 913 // /////////////////////////////////////////////////////////////////////
 914 //  public void onSubRemoteChanged() { }
 915 // /////////////////////////////////////////////////////////////////////
 916 Boolean
 917 onSubRemoteChanged(const struct ORTEAppInfo *appInfo,
 918                    const struct ORTESubInfo *subInfo,
 919                    void *param)
 920 {
 921 // ///////////////////////////////// SPOLECNA CAST //
 922   JavaVM          *jvm = NULL;
 923   JNIEnv          *env = NULL; // local reference
 924   jclass           cls;
 925   jobject          obj_ainfo;
 926   jobject          obj_sinfo;
 927   jmethodID        mid;
 928   //
 929   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 930   int flag_ok = 0;
 931
 932   #ifdef TEST_STAGE
 933       printf(":c: event func. 'onSubRemoteChanged()' called.. \n");
 934   #endif
 935
 936   do
 937   {
 938 // ///////////////////////////////// SPOLECNA CAST //
 939     if(domain_events_cont->jvm == 0)
 940     {
 941      #ifdef TEST_STAGE
 942        printf(":!c: jvm = NULL! \n");
 943      #endif
 944      break;
 945     }
 946     jvm = domain_events_cont->jvm;
 947     // get env
 948     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 949     if(env == 0)
 950     {
 951      #ifdef TEST_STAGE
 952        printf(":!c: env = NULL! \n");
 953      #endif
 954      break;
 955     }
 956     // find class
 957     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 958     if(cls == 0)
 959     {
 960      #ifdef TEST_STAGE
 961        printf(":!c: cls = NULL! \n");
 962      #endif
 963      break;
 964     }
 965     // create AppInfo instance
 966     obj_ainfo = createAppInfo(env, appInfo);
 967     if(obj_ainfo == 0)
 968     {
 969      #ifdef TEST_STAGE
 970        printf(":!c: obj_ainfo = NULL! \n");
 971      #endif
 972      break;
 973     }
 974     // create SubInfo instance
 975     obj_sinfo = createSubInfo(env, subInfo);
 976     if(obj_sinfo == 0)
 977     {
 978      #ifdef TEST_STAGE
 979        printf(":!c: obj_sinfo = NULL! \n");
 980      #endif
 981      break;
 982     }
 983 // ///////////////////////////////// SPOLECNA CAST //
 984     // get method ID
 985     mid = (*env)->GetMethodID(env,
 986                               cls,
 987                               "onSubRemoteChanged",
 988                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/SubInfo;)V");
 989     if(mid == 0)
 990     {
 991      #ifdef TEST_STAGE
 992        printf(":!c: mid = NULL! \n");
 993      #endif
 994      break;
 995     }
 996     // call method
 997     (*env)->CallVoidMethod(env,
 998                            domain_events_cont->obj_de,
 999                            mid,
1000                            obj_ainfo,
1001                            obj_sinfo);
1002     flag_ok = 1;
1003   } while(0);
1004   // while broken
1005   if(flag_ok)
1006   {
1007     if((*jvm)->DetachCurrentThread(jvm) != 0)
1008     {
1009       printf(":c!: DetachCurrentThread fault! \n");
1010       return  ORTE_FALSE;
1011     }
1012   }
1013
1014   return ORTE_TRUE;
1015 }
1016
1017
1018 // /////////////////////////////////////////////////////////////////////
1019 //  public void onSubDelete() { }
1020 // /////////////////////////////////////////////////////////////////////
1021 Boolean
1022 onSubDelete(const struct ORTEAppInfo *appInfo,
1023             const struct ORTESubInfo *subInfo,
1024             void *param)
1025 {
1026 // ///////////////////////////////// SPOLECNA CAST //
1027   JavaVM          *jvm = NULL;
1028   JNIEnv          *env = NULL; // local reference
1029   jclass           cls;
1030   jobject          obj_ainfo;
1031   jobject          obj_sinfo;
1032   jmethodID        mid;
1033   //
1034   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
1035   int flag_ok = 0;
1036
1037   #ifdef TEST_STAGE
1038       printf(":c: event func. 'onSubDelete()' called.. \n");
1039   #endif
1040
1041   do
1042   {
1043 // ///////////////////////////////// SPOLECNA CAST //
1044     if(domain_events_cont->jvm == 0)
1045     {
1046      #ifdef TEST_STAGE
1047        printf(":!c: jvm = NULL! \n");
1048      #endif
1049      break;
1050     }
1051     jvm = domain_events_cont->jvm;
1052     // get env
1053     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
1054     if(env == 0)
1055     {
1056      #ifdef TEST_STAGE
1057        printf(":!c: env = NULL! \n");
1058      #endif
1059      break;
1060     }
1061     // find class
1062     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
1063     if(cls == 0)
1064     {
1065      #ifdef TEST_STAGE
1066        printf(":!c: cls = NULL! \n");
1067      #endif
1068      break;
1069     }
1070     // create AppInfo instance
1071     obj_ainfo = createAppInfo(env, appInfo);
1072     if(obj_ainfo == 0)
1073     {
1074      #ifdef TEST_STAGE
1075        printf(":!c: obj_ainfo = NULL! \n");
1076      #endif
1077      break;
1078     }
1079     // create SubInfo instance
1080     obj_sinfo = createSubInfo(env, subInfo);
1081     if(obj_sinfo == 0)
1082     {
1083      #ifdef TEST_STAGE
1084        printf(":!c: obj_sinfo = NULL! \n");
1085      #endif
1086      break;
1087     }
1088 // ///////////////////////////////// SPOLECNA CAST //
1089     // get method ID
1090     mid = (*env)->GetMethodID(env,
1091                               cls,
1092                               "onSubDelete",
1093                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/SubInfo;)V");
1094     if(mid == 0)
1095     {
1096      #ifdef TEST_STAGE
1097        printf(":!c: mid = NULL! \n");
1098      #endif
1099      break;
1100     }
1101     // call method
1102     (*env)->CallVoidMethod(env,
1103                            domain_events_cont->obj_de,
1104                            mid,
1105                            obj_ainfo,
1106                            obj_sinfo);
1107     flag_ok = 1;
1108   } while(0);
1109   // while broken
1110   if(flag_ok)
1111   {
1112     if((*jvm)->DetachCurrentThread(jvm) != 0)
1113     {
1114       printf(":c!: DetachCurrentThread fault! \n");
1115       return  ORTE_FALSE;
1116     }
1117   }
1118
1119   return ORTE_TRUE;
1120 }
1121
1122
1123 // /////////////////////////////////////////////////////////////////////
1124 // create default application domain
1125 // /////////////////////////////////////////////////////////////////////
1126 JNIEXPORT jlong JNICALL
1127 Java_org_ocera_orte_DomainApp_jORTEDomainDefaultAppCreate
1128 (JNIEnv *env, jclass class, jint jdomain, jboolean jsusp)
1129 {
1130   jlong     d;
1131
1132   #ifdef TEST_STAGE
1133     printf(":c: jsem pred ORTEDomainDefaultAppCreate() \n");
1134   #endif
1135   // call ORTE function
1136   d = (jlong) ORTEDomainAppCreate((int)jdomain,
1137                                  NULL,
1138                                  NULL,
1139                                  (Boolean) jsusp);
1140   if(!d) {
1141     printf(":!c: ORTEDomainDefaultAppCreate() FAILED.. \n");
1142     return 0;
1143   }
1144   #ifdef TEST_STAGE
1145     printf(":c: ORTEDomainDefautlAppCreate() ok.. + %#"PRIxPTR"\n", (intptr_t)d);
1146   #endif
1147   return (d);
1148 }
1149
1150 // //////////////////////////////////////////////////////////////////////
1151 // create user application domain
1152 // //////////////////////////////////////////////////////////////////////
1153 JNIEXPORT jlong JNICALL
1154 Java_org_ocera_orte_DomainApp_jORTEDomainAppCreate
1155 (JNIEnv *env, jclass cls,
1156  jint jdomain,
1157  jlong propHandle,
1158  jlong eventsHandle,
1159  jobject obj_de,
1160  jboolean jsusp)
1161 {
1162   // jni varibles
1163   JavaVM                 *jvm;
1164   jlong                   d;
1165   //
1166   ORTEDomainAppEvents    *dom_events;
1167   JORTEDomainEventsContext_t  *domain_events_cont;
1168
1169   #ifdef TEST_STAGE
1170     printf(":c: ORTEDomainAppCreate() called.. \n");
1171   #endif
1172   // memory alocation
1173   // don't forget free memory - free()!!
1174   domain_events_cont = (JORTEDomainEventsContext_t *) malloc(sizeof(JORTEDomainEventsContext_t));
1175   // get jvm
1176   jint b = (*env)->GetJavaVM(env,&jvm);
1177   if (b < 0)
1178   {
1179     printf(":!c: getJavaVM() failed! \n");
1180     return 0;
1181   }
1182   // create global references
1183   domain_events_cont->jvm = jvm;
1184   // domain events
1185   domain_events_cont->obj_de = (*env)->NewGlobalRef(env, obj_de);
1186   // get new events
1187   dom_events = (ORTEDomainAppEvents *) eventsHandle;
1188   ////////////////////////////////////////////////
1189   // set new events & their prarameters
1190   // onRegFail
1191   dom_events->onRegFail = (ORTEOnRegFail) onRegFail;
1192   dom_events->onRegFailParam = (void *) domain_events_cont;
1193   // onMgrNew
1194   dom_events->onMgrNew = (ORTEOnMgrNew) onMgrNew;
1195   dom_events->onMgrNewParam = (void *) domain_events_cont;
1196   // onMgrDelete
1197   dom_events->onMgrDelete = (ORTEOnMgrDelete) onMgrDelete;
1198   dom_events->onMgrDeleteParam = (void *) domain_events_cont;
1199   // onAppRemoteNew
1200   dom_events->onAppRemoteNew = (ORTEOnAppRemoteNew) onAppRemoteNew;
1201   dom_events->onAppRemoteNewParam = (void *) domain_events_cont;
1202   // onAppDelete
1203   dom_events->onAppDelete = (ORTEOnAppDelete) onAppDelete;
1204   dom_events->onAppDeleteParam = (void *) domain_events_cont;
1205   // onPubRemoteNew
1206   dom_events->onPubRemoteNew = (ORTEOnPubRemote) onPubRemoteNew;
1207   dom_events->onPubRemoteNewParam = (void *) domain_events_cont;
1208   // onPubRemoteChanged
1209   dom_events->onPubRemoteChanged = (ORTEOnPubRemote) onPubRemoteChanged;
1210   dom_events->onPubRemoteChangedParam = (void *) domain_events_cont;
1211   // onPubDelete
1212   dom_events->onPubDelete = (ORTEOnPubDelete) onPubDelete;
1213   dom_events->onPubDeleteParam = (void *) domain_events_cont;
1214   // onSubRemoteNew
1215   dom_events->onSubRemoteNew = (ORTEOnSubRemote) onSubRemoteNew;
1216   dom_events->onSubRemoteNewParam = (void *) domain_events_cont;
1217   // onSubRemoteChanged
1218   dom_events->onSubRemoteChanged = (ORTEOnSubRemote) onSubRemoteChanged;
1219   dom_events->onSubRemoteChangedParam = (void *) domain_events_cont;
1220   // onSubDelete
1221   dom_events->onSubDelete = (ORTEOnSubDelete) onSubDelete;
1222   dom_events->onSubDeleteParam = (void *) domain_events_cont;
1223   ////////////////////////////////////////////////
1224   // call ORTE function
1225   d = (jlong) ORTEDomainAppCreate((int)jdomain,
1226                                  (ORTEDomainProp *) propHandle,
1227                                  (ORTEDomainAppEvents *) eventsHandle,
1228                                  (Boolean) jsusp);
1229   if(!d) {
1230     printf(":!c: creating app domain failed! [NULL handle]  \n");
1231     return 0;
1232   }
1233   #ifdef TEST_STAGE
1234     printf(":c: ORTEDomainAppCreate() ok.. + %#"PRIxPTR"\n", (intptr_t)d);
1235   #endif
1236   return (d);
1237 }