orte/libjorte/JORTEDomainEvents.c

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