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