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