src/policy_manager/zipc/dummy_stm.c

   1 #include <string.h>
   2 #include "dummy_stm.h"
   3 #include "hmi-debug.h"
   4
   5 const char* gStmEventName[] = {
   6     "none",
   7     "activate",
   8     "deactivate",
   9     "trans_gear_neutral",
  10     "trans_gear_not_neutral",
  11     "parking_brake_off",
  12     "parking_brake_on",
  13     "accel_pedal_off",
  14     "accel_pedal_on",
  15     "timer_expired",
  16     "lamp_off",
  17     "lamp_on",
  18     "lightstatus_brake_off",
  19     "lightstatus_brake_on",
  20     "restriction_mode_off",
  21     "restriction_mode_on",
  22 };
  23
  24 const int gStmEventNo[] = {
  25     STM_EVT_NO_NONE,
  26     STM_EVT_NO_ACTIVATE,
  27     STM_EVT_NO_DEACTIVATE,
  28     STM_EVT_NO_TRANS_GEAR_N,
  29     STM_EVT_NO_TRANS_GEAR_NOT_N,
  30     STM_EVT_NO_PARKING_BRAKE_OFF,
  31     STM_EVT_NO_PARKING_BRAKE_ON,
  32     STM_EVT_NO_ACCEL_PEDAL_OFF,
  33     STM_EVT_NO_ACCEL_PEDAL_ON,
  34     STM_EVT_NO_TIMER_EXPIRED,
  35     STM_EVT_NO_LAMP_OFF,
  36     STM_EVT_NO_LAMP_ON,
  37     STM_EVT_NO_LIGHTSTATUS_BRAKE_OFF,
  38     STM_EVT_NO_LIGHTSTATUS_BRAKE_ON,
  39     STM_EVT_NO_RESTRICTION_MODE_OFF,
  40     STM_EVT_NO_RESTRICTION_MODE_ON,
  41 };
  42
  43 const char* gStmCategoryName[] = {
  44     "none",
  45     "homescreen",
  46     "map",
  47     "general",
  48     "splitable",
  49     "popup",
  50     "system_alert",
  51     "restriction",
  52     "system",
  53 };
  54
  55 const int gStmCategoryNo[] = {
  56     STM_CTG_NO_NONE,
  57     STM_CTG_NO_HOMESCREEN,
  58     STM_CTG_NO_MAP,
  59     STM_CTG_NO_GENERAL,
  60     STM_CTG_NO_SPLITABLE,
  61     STM_CTG_NO_POPUP,
  62     STM_CTG_NO_SYSTEM_ALERT,
  63     STM_CTG_NO_RESTRICTION,
  64     STM_CTG_NO_SYSTEM,
  65 };
  66
  67 const char* gStmAreaName[] = {
  68     "none",
  69     "fullscreen",
  70     "normal",
  71     "split.main",
  72     "split.sub",
  73     "onscreen",
  74     "restriction.normal",
  75     "restriction.split.main",
  76     "restriction.split.sub",
  77 };
  78
  79 const int gStmAreaNo[] = {
  80     STM_ARA_NO_NONE,
  81     STM_ARA_NO_FULL,
  82     STM_ARA_NO_NORMAL,
  83     STM_ARA_NO_SPLIT_MAIN,
  84     STM_ARA_NO_SPLIT_SUB,
  85     STM_ARA_NO_ON_SCREEN,
  86     STM_ARA_NO_RESTRICTION_NORMAL,
  87     STM_ARA_NO_RESTRICTION_SPLIT_MAIN,
  88     STM_ARA_NO_RESTRICTION_SPLIT_SUB,
  89 };
  90
  91 // String for state
  92 const char* gStmTransGearStateNo2Name[] = {
  93     "trans_gear_neutral",
  94     "trans_gear_not_neutral"
  95 };
  96
  97 const char* gStmParkingBrakeStateNo2Name[] = {
  98     "parking_brake_off",
  99     "parking_brake_on"
 100 };
 101
 102 const char* gStmAccelPedalStateNo2Name[] = {
 103     "accel_pedal_off",
 104     "accel_pedal_on"
 105 };
 106
 107 const char* gStmCarStateNo2Name[] = {
 108     "car_stop",
 109     "car_run"
 110 };
 111
 112 const char* gStmLampStateNo2Name[] = {
 113     "lamp_off",
 114     "lamp_on"
 115 };
 116
 117 const char* gStmLightstatusBrakeStateNo2Name[] = {
 118     "lightstatus_brake_off",
 119     "lightstatus_brake_on"
 120 };
 121
 122 const char* gStmRestrictionModeStateNo2Name[] = {
 123     "restriction_mode_off",
 124     "restriction_mode_on"
 125 };
 126
 127 const char* gStmLayoutNo2Name[] = {
 128     "none",
 129     "pu",
 130     "sa",
 131     "m1",
 132     "m2",
 133     "mf",
 134     "s1",
 135     "s2",
 136     "g",
 137     "hs",
 138     "restriction",
 139     "restriction.split.main",
 140     "restriction.split.sub",
 141     "system",
 142 };
 143
 144 const char* gStmLayerName[] = {
 145     "none",
 146     "homescreen",
 147     "apps",
 148     "restriction",
 149     "on_screen",
 150 };
 151
 152 stm_state_t g_crr_state;
 153 stm_state_t g_prv_state;
 154 int g_prv_restriction_state_car_stop = 0;
 155 int g_prv_apps_state_car_stop = 0;
 156 int g_map_is_activated = STM_FALSE;
 157
 158 void stmInitialize() {
 159     // Initialize previous state
 160     memset(&g_prv_state, 0, sizeof(g_prv_state));
 161
 162     g_prv_state.layer[gStmLayerNoOnScreen].state   = gStmLayoutNoNone;
 163     g_prv_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 164     g_prv_state.layer[gStmLayerNoApps].state        = gStmLayoutNoNone;
 165     g_prv_state.layer[gStmLayerNoHomescreen].state  = gStmLayoutNoNone;
 166     g_prv_state.trans_gear.state        = gStmTransGearStateNoN;
 167     g_prv_state.lightstatus_brake.state = gStmLightstatusBrakeStateNoOn;
 168     g_prv_state.accel_pedal.state       = gStmAccelPedalStateNoOff;
 169     g_prv_state.car.state               = gStmCarStateNoStop;
 170     g_prv_state.lamp.state              = gStmLampStateNoOff;
 171     g_prv_state.parking_brake.state     = gStmParkingBrakeStateNoOn;
 172     g_prv_state.restriction_mode.state  = gStmRestrictionModeStateNoOff;
 173
 174     // Initialize current state
 175     g_crr_state = g_prv_state;
 176 }
 177
 178 int stmTransitionState(int event, stm_state_t* state) {
 179     int event_no, category_no, area_no;
 180     int restriction_state, apps_state;
 181     int trans_gear_state, parking_brake_state, lightstatus_brake_state, accel_pedal_state, car_state, lamp_state, restriction_mode_state;
 182
 183     event_no    = event & STM_MSK_EVT_NO;
 184     category_no = event & STM_MSK_CTG_NO;
 185     area_no     = event & STM_MSK_ARA_NO;
 186
 187     // Backup previous state
 188     g_prv_state = g_crr_state;
 189
 190     // Get previous state
 191     restriction_state = g_prv_state.layer[gStmLayerNoRestriction].state;
 192     apps_state        = g_prv_state.layer[gStmLayerNoApps].state;
 193     trans_gear_state        = g_prv_state.trans_gear.state;
 194     parking_brake_state     = g_prv_state.parking_brake.state;
 195     accel_pedal_state       = g_prv_state.accel_pedal.state;
 196     car_state               = g_prv_state.car.state;
 197     lamp_state              = g_prv_state.lamp.state;
 198     lightstatus_brake_state = g_prv_state.lightstatus_brake.state;
 199     restriction_mode_state  = g_prv_state.restriction_mode.state;
 200
 201     // Clear flags
 202     g_crr_state.layer[gStmLayerNoOnScreen].is_changed   = STM_FALSE;
 203     g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_FALSE;
 204     g_crr_state.layer[gStmLayerNoApps].is_changed        = STM_FALSE;
 205     g_crr_state.layer[gStmLayerNoHomescreen].is_changed  = STM_FALSE;
 206     g_crr_state.trans_gear.is_changed        = STM_FALSE;
 207     g_crr_state.parking_brake.is_changed     = STM_FALSE;
 208     g_crr_state.lightstatus_brake.is_changed = STM_FALSE;
 209     g_crr_state.accel_pedal.is_changed       = STM_FALSE;
 210     g_crr_state.car.is_changed               = STM_FALSE;
 211     g_crr_state.lamp.is_changed              = STM_FALSE;
 212     g_crr_state.restriction_mode.is_changed  = STM_FALSE;
 213
 214
 215     // Set car state
 216     switch (event_no) {
 217     case STM_EVT_NO_TRANS_GEAR_N:
 218         if (gStmTransGearStateNoN != trans_gear_state) {
 219             g_crr_state.trans_gear.state = gStmTransGearStateNoN;
 220             g_crr_state.trans_gear.is_changed = STM_TRUE;
 221         }
 222         break;
 223     case STM_EVT_NO_TRANS_GEAR_NOT_N:
 224         if (gStmTransGearStateNoNotN != trans_gear_state) {
 225             g_crr_state.trans_gear.state = gStmTransGearStateNoNotN;
 226             g_crr_state.trans_gear.is_changed = STM_TRUE;
 227         }
 228         break;
 229     case STM_EVT_NO_PARKING_BRAKE_OFF:
 230         if (gStmParkingBrakeStateNoOff != parking_brake_state) {
 231             g_crr_state.parking_brake.state = gStmParkingBrakeStateNoOff;
 232             g_crr_state.parking_brake.is_changed = STM_TRUE;
 233         }
 234         break;
 235     case STM_EVT_NO_PARKING_BRAKE_ON:
 236         if (gStmParkingBrakeStateNoOn != parking_brake_state) {
 237             g_crr_state.parking_brake.state = gStmParkingBrakeStateNoOn;
 238             g_crr_state.parking_brake.is_changed = STM_TRUE;
 239         }
 240         break;
 241     case STM_EVT_NO_ACCEL_PEDAL_OFF:
 242         if (gStmAccelPedalStateNoOff != accel_pedal_state) {
 243             g_crr_state.accel_pedal.state = gStmAccelPedalStateNoOff;
 244             g_crr_state.accel_pedal.is_changed = STM_TRUE;
 245         }
 246         break;
 247     case STM_EVT_NO_ACCEL_PEDAL_ON:
 248         if (gStmAccelPedalStateNoOn != accel_pedal_state) {
 249             g_crr_state.accel_pedal.state = gStmAccelPedalStateNoOn;
 250             g_crr_state.accel_pedal.is_changed = STM_TRUE;
 251         }
 252         break;
 253     case STM_EVT_NO_LAMP_OFF:
 254         if (gStmLampStateNoOff != lamp_state) {
 255             g_crr_state.lamp.state = gStmLampStateNoOff;
 256             g_crr_state.lamp.is_changed = STM_TRUE;
 257         }
 258         break;
 259     case STM_EVT_NO_LAMP_ON:
 260         if (gStmLampStateNoOn != lamp_state) {
 261             g_crr_state.lamp.state = gStmLampStateNoOn;
 262             g_crr_state.lamp.is_changed = STM_TRUE;
 263         }
 264         break;
 265     case STM_EVT_NO_LIGHTSTATUS_BRAKE_OFF:
 266         if (gStmLightstatusBrakeStateNoOff != lightstatus_brake_state) {
 267             g_crr_state.lightstatus_brake.state = gStmLightstatusBrakeStateNoOff;
 268             g_crr_state.lightstatus_brake.is_changed = STM_TRUE;
 269         }
 270         break;
 271     case STM_EVT_NO_LIGHTSTATUS_BRAKE_ON:
 272         if (gStmLightstatusBrakeStateNoOn != lightstatus_brake_state) {
 273             g_crr_state.lightstatus_brake.state = gStmLightstatusBrakeStateNoOn;
 274             g_crr_state.lightstatus_brake.is_changed = STM_TRUE;
 275         }
 276         break;
 277     default:
 278         // nop
 279         break;
 280     }
 281
 282 #if 1 // FOR ALS
 283     if (g_crr_state.lightstatus_brake.is_changed
 284         || g_crr_state.accel_pedal.is_changed) {
 285         if ((gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state)
 286             && (gStmAccelPedalStateNoOn == g_crr_state.accel_pedal.state)){
 287 #else
 288     if (g_crr_state.parking_brake.is_changed
 289         || g_crr_state.trans_gear.is_changed) {
 290         if ((gStmParkingBrakeStateNoOff == g_crr_state.parking_brake.state)
 291             && (gStmTransGearStateNoNotN == g_crr_state.trans_gear.state)){
 292 #endif
 293             if (gStmCarStateNoRun != car_state) {
 294                 // Car state is changed stop -> run
 295                 g_crr_state.car.state = gStmCarStateNoRun;
 296                 g_crr_state.car.is_changed = STM_TRUE;
 297             }
 298         }
 299         else {
 300             if (gStmCarStateNoStop != car_state) {
 301                 // Car state is changed run -> stop
 302                 g_crr_state.car.state = gStmCarStateNoStop;
 303                 g_crr_state.car.is_changed = STM_TRUE;
 304             }
 305         }
 306     }
 307
 308     // Set restriction mode
 309     if ((STM_EVT_NO_RESTRICTION_MODE_ON == event_no)
 310       && (gStmRestrictionModeStateNoOn != restriction_mode_state)) {
 311         HMI_DEBUG("wm:pm:stm", "Restriction mode OFF -> ON");
 312
 313         // Restriction mode is changed OFF -> ON
 314         g_crr_state.restriction_mode.state = gStmRestrictionModeStateNoOn;
 315         g_crr_state.restriction_mode.is_changed = STM_TRUE;
 316
 317         // Update restriction layer
 318         g_prv_restriction_state_car_stop = restriction_state;
 319         g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 320         g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 321
 322         // Update apps layer
 323         g_prv_apps_state_car_stop = apps_state;
 324         if ((STM_TRUE == g_map_is_activated)
 325             && (gStmLayoutNoSystem != apps_state)) {
 326             g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM1;
 327             g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 328         }
 329     }
 330     else if ((STM_EVT_NO_RESTRICTION_MODE_OFF == event_no)
 331       && (gStmRestrictionModeStateNoOff != restriction_mode_state)) {
 332         HMI_DEBUG("wm:pm:stm", "Restriction mode ON -> OFF");
 333
 334         // Restriction mode is changed ON -> OFF
 335         g_crr_state.restriction_mode.state = gStmRestrictionModeStateNoOff;
 336         g_crr_state.restriction_mode.is_changed = STM_TRUE;
 337
 338         // Update restriction layer
 339         g_crr_state.layer[gStmLayerNoRestriction].state = g_prv_restriction_state_car_stop;
 340         g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 341
 342         // Update apps layer
 343         if (STM_TRUE == g_map_is_activated) {
 344             g_crr_state.layer[gStmLayerNoApps].state = g_prv_apps_state_car_stop;
 345             g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 346         }
 347     }
 348
 349     // Set apps/homescreen layer
 350     switch (event_no) {
 351     case STM_EVT_NO_ACTIVATE:
 352         if (gStmRestrictionModeStateNoOff == restriction_mode_state) {
 353             switch (category_no) {
 354             case STM_CTG_NO_HOMESCREEN:
 355                 // Homescreen layer
 356                 g_crr_state.layer[gStmLayerNoHomescreen].state = gStmLayoutNoHs;
 357                 g_crr_state.layer[gStmLayerNoHomescreen].is_changed = STM_TRUE;
 358
 359                 // Apps layer
 360                 if (gStmLayoutNoNone != apps_state) {
 361                     g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoNone;
 362                     g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 363                 }
 364                 break;
 365             case STM_CTG_NO_MAP:
 366                 switch (area_no) {
 367                 case STM_ARA_NO_FULL:
 368                     // Apps layer
 369                     switch (apps_state) {
 370                     case gStmLayoutNoMf:
 371                         // nop
 372                         break;
 373                     default:
 374                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoMf;
 375                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 376                         break;
 377                     }
 378                     break;
 379                 case STM_ARA_NO_NORMAL:
 380                     // Apps layer
 381                     switch (apps_state) {
 382                     case gStmLayoutNoM1:
 383                         // nop
 384                         break;
 385                     case gStmLayoutNoS1:
 386                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 387                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 388                         break;
 389                     default:
 390                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM1;
 391                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 392                     }
 393                     break;
 394                 case STM_ARA_NO_SPLIT_MAIN:
 395                     // Apps layer
 396                     switch (apps_state) {
 397                     case gStmLayoutNoS1:
 398                     case gStmLayoutNoS2:
 399                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 400                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 401                         break;
 402                     default:
 403                         // nop
 404                         break;
 405                     }
 406                     break;
 407                 }
 408                 break;
 409             case STM_CTG_NO_GENERAL:
 410                 switch (area_no) {
 411                 case STM_ARA_NO_NORMAL:
 412                     // Apps layer
 413                     switch (apps_state) {
 414                     case gStmLayoutNoMf:
 415                         // nop
 416                         break;
 417                     default:
 418                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoG;
 419                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 420                         break;
 421                     }
 422                     break;
 423                 default:
 424                     // nop
 425                     break;
 426                 }
 427                 break;
 428             case STM_CTG_NO_SYSTEM:
 429                 switch (area_no) {
 430                 case STM_ARA_NO_NORMAL:
 431                     // Apps layer
 432                     switch (apps_state) {
 433                     case gStmLayoutNoMf:
 434                         // nop
 435                         break;
 436                     default:
 437                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoSystem;
 438                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 439                         break;
 440                     }
 441                     break;
 442                 default:
 443                     // nop
 444                     break;
 445                 }
 446                 break;
 447             case STM_CTG_NO_SPLITABLE:
 448                 switch (area_no) {
 449                 case STM_ARA_NO_NORMAL:
 450                     // Apps layer
 451                     switch (apps_state) {
 452                     case gStmLayoutNoM1:
 453                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 454                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 455                         break;
 456                     case gStmLayoutNoMf:
 457                     case gStmLayoutNoS1:
 458                         // nop
 459                         break;
 460                     default:
 461                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS1;
 462                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 463                         break;
 464                     }
 465                     break;
 466                 case STM_ARA_NO_SPLIT_MAIN:
 467                     // Apps layer
 468                     switch (apps_state) {
 469                     case gStmLayoutNoS1:
 470                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 471                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 472                         break;
 473                     case gStmLayoutNoS2:
 474                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 475                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 476                         break;
 477                     default:
 478                         // nop
 479                         break;
 480                     }
 481                     break;
 482                 case STM_ARA_NO_SPLIT_SUB:
 483                     // Apps layer
 484                     switch (apps_state) {
 485                     case gStmLayoutNoM1:
 486                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 487                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 488                         break;
 489                     case gStmLayoutNoM2:
 490                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 491                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 492                         break;
 493                     case gStmLayoutNoS1:
 494                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 495                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 496                         break;
 497                     case gStmLayoutNoS2:
 498                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 499                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 500                         break;
 501                     default:
 502                         // nop
 503                         break;
 504                     }
 505                     break;
 506                 default:
 507                     // nop
 508                     break;
 509                 }
 510                 break;
 511             default:
 512                 // nop
 513                 break;
 514             }
 515             break;
 516         }
 517         else {  // (gStmRestrictionModeStateNoOn == restriction_mode_state)
 518             switch (category_no) {
 519             case STM_CTG_NO_MAP:
 520                 switch (area_no) {
 521                 case STM_ARA_NO_FULL:
 522                 case STM_ARA_NO_NORMAL:
 523                 case STM_ARA_NO_SPLIT_MAIN:
 524                     // Apps layer
 525                     switch (apps_state) {
 526                     case gStmLayoutNoM1:
 527                         // nop
 528                         break;
 529                     default:
 530                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM1;
 531                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 532                     }
 533                     break;
 534                 }
 535                 break;
 536             case STM_CTG_NO_SYSTEM:
 537                 switch (area_no) {
 538                 case STM_ARA_NO_NORMAL:
 539                     // Apps layer
 540                     switch (apps_state) {
 541                     case gStmLayoutNoMf:
 542                         // nop
 543                         break;
 544                     default:
 545                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoSystem;
 546                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 547                         break;
 548                     }
 549                     break;
 550                 default:
 551                     // nop
 552                     break;
 553                 }
 554                 break;
 555             }
 556         }
 557     case STM_EVT_NO_DEACTIVATE:
 558         switch (category_no) {
 559         default:
 560             // nop
 561             break;
 562         }
 563         break;
 564     default:
 565         // nop
 566         break;
 567     }
 568
 569
 570     // Set restriction layer
 571     if (STM_CTG_NO_RESTRICTION == category_no) {
 572         if (STM_EVT_NO_ACTIVATE == event_no) {
 573             if (gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state) {
 574                 switch (area_no) {
 575                 case STM_ARA_NO_RESTRICTION_NORMAL:
 576                     switch (restriction_state) {
 577                     case gStmLayoutNoNone:
 578                         if (g_crr_state.layer[gStmLayerNoApps].state == gStmLayoutNoS1) {
 579                             g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestriction;
 580                             g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 581                         }
 582                         break;
 583                     default:
 584                         // nop
 585                         break;
 586                     }
 587                     break;
 588                 case STM_ARA_NO_RESTRICTION_SPLIT_MAIN:
 589                     switch (restriction_state) {
 590                     case gStmLayoutNoNone:
 591                         g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitMain;
 592                         g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 593                         break;
 594                     default:
 595                         // nop
 596                         break;
 597                     }
 598                     break;
 599                 case STM_ARA_NO_RESTRICTION_SPLIT_SUB:
 600                     switch (restriction_state) {
 601                     case gStmLayoutNoNone:
 602                         if (g_crr_state.layer[gStmLayerNoApps].state == gStmLayoutNoM2) {
 603                             g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitSub;
 604                             g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 605                         }
 606                         break;
 607                     default:
 608                         // nop
 609                         break;
 610                     }
 611                     break;
 612                 default:
 613                     // nop
 614                     break;
 615                 }
 616             }
 617         }
 618         else if (STM_EVT_NO_DEACTIVATE == event_no) {
 619             switch (restriction_state) {
 620             case gStmLayoutNoRestriction:
 621             case gStmLayoutNoRestrictionSplitMain:
 622             case gStmLayoutNoRestrictionSplitSub:
 623                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 624                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 625                 break;
 626             default:
 627                 // nop
 628                 break;
 629             }
 630         }
 631     }
 632     else if (g_crr_state.layer[gStmLayerNoApps].is_changed) {
 633         if (gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state) {
 634             if (gStmLayoutNoM2 == g_crr_state.layer[gStmLayerNoApps].state) {
 635                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitSub;
 636                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 637             }
 638             else if (gStmLayoutNoS1 == g_crr_state.layer[gStmLayerNoApps].state) {
 639                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestriction;
 640                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 641             }
 642             else {
 643                 if (gStmLayoutNoNone != g_crr_state.layer[gStmLayerNoRestriction].state) {
 644                     g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 645                     g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 646                 }
 647             }
 648         }
 649         else {
 650             if (gStmLayoutNoNone != g_crr_state.layer[gStmLayerNoRestriction].state) {
 651                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 652                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 653             }
 654         }
 655     }
 656
 657     // Copy current state for return
 658     memcpy(state, &g_crr_state, sizeof(g_crr_state));
 659
 660     if ((STM_FALSE == g_map_is_activated)
 661         && (STM_TRUE == g_crr_state.layer[gStmLayerNoApps].is_changed)
 662         && ((gStmLayoutNoM1 == g_crr_state.layer[gStmLayerNoApps].state)
 663             || (gStmLayoutNoM2 == g_crr_state.layer[gStmLayerNoApps].state)
 664             || (gStmLayoutNoMf == g_crr_state.layer[gStmLayerNoApps].state))) {
 665         g_map_is_activated = STM_TRUE;
 666     }
 667
 668     return 0;
 669 }
 670
 671 void stmUndoState() {
 672     g_crr_state = g_prv_state;
 673 }