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* gStmRunningNo2Name[] = {
 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 const char* gStmCarElementName[] = {
 153     "trans_gear",
 154     "parking_brake",
 155     "accel_pedal",
 156     "running",
 157     "lamp",
 158     "lightstatus_brake",
 159     "restriction_mode",
 160 };
 161
 162 const char** gStmCarStateNameList[] = {
 163     gStmTransGearStateNo2Name,
 164     gStmParkingBrakeStateNo2Name,
 165     gStmAccelPedalStateNo2Name,
 166     gStmRunningNo2Name,
 167     gStmLampStateNo2Name,
 168     gStmLightstatusBrakeStateNo2Name,
 169     gStmRestrictionModeStateNo2Name,
 170 };
 171
 172 stm_state_t g_crr_state;
 173 stm_state_t g_prv_state;
 174 int g_prv_restriction_state_car_stop = 0;
 175 int g_prv_apps_state_car_stop = 0;
 176 int g_map_is_activated = STM_FALSE;
 177
 178 void stmInitialize() {
 179     // Initialize previous state
 180     memset(&g_prv_state, 0, sizeof(g_prv_state));
 181
 182     g_prv_state.layer[gStmLayerNoOnScreen].state    = gStmLayoutNoNone;
 183     g_prv_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 184     g_prv_state.layer[gStmLayerNoApps].state        = gStmLayoutNoNone;
 185     g_prv_state.layer[gStmLayerNoHomescreen].state  = gStmLayoutNoNone;
 186     g_prv_state.car_element[gStmCarElementNoTransGear].state        = gStmTransGearStateNoN;
 187     g_prv_state.car_element[gStmCarElementNoLightstatusBrake].state = gStmLightstatusBrakeStateNoOn;
 188     g_prv_state.car_element[gStmCarElementNoAccelPedal].state       = gStmAccelPedalStateNoOff;
 189     g_prv_state.car_element[gStmCarElementNoRunning].state          = gStmRunningNoStop;
 190     g_prv_state.car_element[gStmCarElementNoLamp].state             = gStmLampStateNoOff;
 191     g_prv_state.car_element[gStmCarElementNoParkingBrake].state     = gStmParkingBrakeStateNoOn;
 192     g_prv_state.car_element[gStmCarElementNoRestrictionMode].state  = gStmRestrictionModeStateNoOff;
 193
 194     // Initialize current state
 195     g_crr_state = g_prv_state;
 196 }
 197
 198 int stmTransitionState(int event, stm_state_t* state) {
 199     int event_no, category_no, area_no;
 200     int restriction_state, apps_state;
 201     int trans_gear_state, parking_brake_state, lightstatus_brake_state, accel_pedal_state, car_state, lamp_state, restriction_mode_state;
 202
 203     event_no    = event & STM_MSK_EVT_NO;
 204     category_no = event & STM_MSK_CTG_NO;
 205     area_no     = event & STM_MSK_ARA_NO;
 206
 207     // Backup previous state
 208     g_prv_state = g_crr_state;
 209
 210     // Get previous state
 211     restriction_state = g_prv_state.layer[gStmLayerNoRestriction].state;
 212     apps_state        = g_prv_state.layer[gStmLayerNoApps].state;
 213     trans_gear_state        = g_prv_state.car_element[gStmCarElementNoTransGear].state;
 214     parking_brake_state     = g_prv_state.car_element[gStmCarElementNoParkingBrake].state;
 215     accel_pedal_state       = g_prv_state.car_element[gStmCarElementNoAccelPedal].state;
 216     car_state               = g_prv_state.car_element[gStmCarElementNoRunning].state;
 217     lamp_state              = g_prv_state.car_element[gStmCarElementNoLamp].state;
 218     lightstatus_brake_state = g_prv_state.car_element[gStmCarElementNoLightstatusBrake].state;
 219     restriction_mode_state  = g_prv_state.car_element[gStmCarElementNoRestrictionMode].state;
 220
 221     // Clear flags
 222     g_crr_state.layer[gStmLayerNoOnScreen].is_changed    = STM_FALSE;
 223     g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_FALSE;
 224     g_crr_state.layer[gStmLayerNoApps].is_changed        = STM_FALSE;
 225     g_crr_state.layer[gStmLayerNoHomescreen].is_changed  = STM_FALSE;
 226     g_crr_state.car_element[gStmCarElementNoTransGear].is_changed        = STM_FALSE;
 227     g_crr_state.car_element[gStmCarElementNoParkingBrake].is_changed     = STM_FALSE;
 228     g_crr_state.car_element[gStmCarElementNoLightstatusBrake].is_changed = STM_FALSE;
 229     g_crr_state.car_element[gStmCarElementNoAccelPedal].is_changed       = STM_FALSE;
 230     g_crr_state.car_element[gStmCarElementNoRunning].is_changed          = STM_FALSE;
 231     g_crr_state.car_element[gStmCarElementNoLamp].is_changed             = STM_FALSE;
 232     g_crr_state.car_element[gStmCarElementNoRestrictionMode].is_changed  = STM_FALSE;
 233
 234
 235     // Set car state
 236     switch (event_no) {
 237     case STM_EVT_NO_TRANS_GEAR_N:
 238         if (gStmTransGearStateNoN != trans_gear_state) {
 239             g_crr_state.car_element[gStmCarElementNoTransGear].state = gStmTransGearStateNoN;
 240             g_crr_state.car_element[gStmCarElementNoTransGear].is_changed = STM_TRUE;
 241         }
 242         break;
 243     case STM_EVT_NO_TRANS_GEAR_NOT_N:
 244         if (gStmTransGearStateNoNotN != trans_gear_state) {
 245             g_crr_state.car_element[gStmCarElementNoTransGear].state = gStmTransGearStateNoNotN;
 246             g_crr_state.car_element[gStmCarElementNoTransGear].is_changed = STM_TRUE;
 247         }
 248         break;
 249     case STM_EVT_NO_PARKING_BRAKE_OFF:
 250         if (gStmParkingBrakeStateNoOff != parking_brake_state) {
 251             g_crr_state.car_element[gStmCarElementNoParkingBrake].state = gStmParkingBrakeStateNoOff;
 252             g_crr_state.car_element[gStmCarElementNoParkingBrake].is_changed = STM_TRUE;
 253         }
 254         break;
 255     case STM_EVT_NO_PARKING_BRAKE_ON:
 256         if (gStmParkingBrakeStateNoOn != parking_brake_state) {
 257             g_crr_state.car_element[gStmCarElementNoParkingBrake].state = gStmParkingBrakeStateNoOn;
 258             g_crr_state.car_element[gStmCarElementNoParkingBrake].is_changed = STM_TRUE;
 259         }
 260         break;
 261     case STM_EVT_NO_ACCEL_PEDAL_OFF:
 262         if (gStmAccelPedalStateNoOff != accel_pedal_state) {
 263             g_crr_state.car_element[gStmCarElementNoAccelPedal].state = gStmAccelPedalStateNoOff;
 264             g_crr_state.car_element[gStmCarElementNoAccelPedal].is_changed = STM_TRUE;
 265         }
 266         break;
 267     case STM_EVT_NO_ACCEL_PEDAL_ON:
 268         if (gStmAccelPedalStateNoOn != accel_pedal_state) {
 269             g_crr_state.car_element[gStmCarElementNoAccelPedal].state = gStmAccelPedalStateNoOn;
 270             g_crr_state.car_element[gStmCarElementNoAccelPedal].is_changed = STM_TRUE;
 271         }
 272         break;
 273     case STM_EVT_NO_LAMP_OFF:
 274         if (gStmLampStateNoOff != lamp_state) {
 275             g_crr_state.car_element[gStmCarElementNoLamp].state = gStmLampStateNoOff;
 276             g_crr_state.car_element[gStmCarElementNoLamp].is_changed = STM_TRUE;
 277         }
 278         break;
 279     case STM_EVT_NO_LAMP_ON:
 280         if (gStmLampStateNoOn != lamp_state) {
 281             g_crr_state.car_element[gStmCarElementNoLamp].state = gStmLampStateNoOn;
 282             g_crr_state.car_element[gStmCarElementNoLamp].is_changed = STM_TRUE;
 283         }
 284         break;
 285     case STM_EVT_NO_LIGHTSTATUS_BRAKE_OFF:
 286         if (gStmLightstatusBrakeStateNoOff != lightstatus_brake_state) {
 287             g_crr_state.car_element[gStmCarElementNoLightstatusBrake].state = gStmLightstatusBrakeStateNoOff;
 288             g_crr_state.car_element[gStmCarElementNoLightstatusBrake].is_changed = STM_TRUE;
 289         }
 290         break;
 291     case STM_EVT_NO_LIGHTSTATUS_BRAKE_ON:
 292         if (gStmLightstatusBrakeStateNoOn != lightstatus_brake_state) {
 293             g_crr_state.car_element[gStmCarElementNoLightstatusBrake].state = gStmLightstatusBrakeStateNoOn;
 294             g_crr_state.car_element[gStmCarElementNoLightstatusBrake].is_changed = STM_TRUE;
 295         }
 296         break;
 297     default:
 298         // nop
 299         break;
 300     }
 301
 302 #if 1 // FOR ALS
 303     if (g_crr_state.car_element[gStmCarElementNoLightstatusBrake].is_changed
 304         || g_crr_state.car_element[gStmCarElementNoAccelPedal].is_changed) {
 305         if ((gStmLightstatusBrakeStateNoOff == g_crr_state.car_element[gStmCarElementNoLightstatusBrake].state)
 306             && (gStmAccelPedalStateNoOn == g_crr_state.car_element[gStmCarElementNoAccelPedal].state)){
 307 #else
 308     if (g_crr_state.car_element[gStmCarElementNoParkingBrake].is_changed
 309         || g_crr_state.car_element[gStmCarElementNoTransGear].is_changed) {
 310         if ((gStmParkingBrakeStateNoOff == g_crr_state.car_element[gStmCarElementNoParkingBrake].state)
 311             && (gStmTransGearStateNoNotN == g_crr_state.car_element[gStmCarElementNoTransGear].state)){
 312 #endif
 313             if (gStmRunningNoRun != car_state) {
 314                 // Car state is changed stop -> run
 315                 g_crr_state.car_element[gStmCarElementNoRunning].state = gStmRunningNoRun;
 316                 g_crr_state.car_element[gStmCarElementNoRunning].is_changed = STM_TRUE;
 317             }
 318         }
 319         else {
 320             if (gStmRunningNoStop != car_state) {
 321                 // Car state is changed run -> stop
 322                 g_crr_state.car_element[gStmCarElementNoRunning].state = gStmRunningNoStop;
 323                 g_crr_state.car_element[gStmCarElementNoRunning].is_changed = STM_TRUE;
 324             }
 325         }
 326     }
 327
 328     // Set restriction mode
 329     if ((STM_EVT_NO_RESTRICTION_MODE_ON == event_no)
 330       && (gStmRestrictionModeStateNoOn != restriction_mode_state)) {
 331         HMI_DEBUG("wm:pm:stm", "Restriction mode OFF -> ON");
 332
 333         // Restriction mode is changed OFF -> ON
 334         g_crr_state.car_element[gStmCarElementNoRestrictionMode].state = gStmRestrictionModeStateNoOn;
 335         g_crr_state.car_element[gStmCarElementNoRestrictionMode].is_changed = STM_TRUE;
 336
 337         // Update restriction layer
 338         g_prv_restriction_state_car_stop = restriction_state;
 339         g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 340         g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 341
 342         // Update apps layer
 343         g_prv_apps_state_car_stop = apps_state;
 344         if ((STM_TRUE == g_map_is_activated)
 345             && (gStmLayoutNoSystem != apps_state)) {
 346             g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM1;
 347             g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 348         }
 349     }
 350     else if ((STM_EVT_NO_RESTRICTION_MODE_OFF == event_no)
 351       && (gStmRestrictionModeStateNoOff != restriction_mode_state)) {
 352         HMI_DEBUG("wm:pm:stm", "Restriction mode ON -> OFF");
 353
 354         // Restriction mode is changed ON -> OFF
 355         g_crr_state.car_element[gStmCarElementNoRestrictionMode].state = gStmRestrictionModeStateNoOff;
 356         g_crr_state.car_element[gStmCarElementNoRestrictionMode].is_changed = STM_TRUE;
 357
 358         // Update restriction layer
 359         g_crr_state.layer[gStmLayerNoRestriction].state = g_prv_restriction_state_car_stop;
 360         g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 361
 362         // Update apps layer
 363         if (STM_TRUE == g_map_is_activated) {
 364             g_crr_state.layer[gStmLayerNoApps].state = g_prv_apps_state_car_stop;
 365             g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 366         }
 367     }
 368
 369     // Set apps/homescreen layer
 370     switch (event_no) {
 371     case STM_EVT_NO_ACTIVATE:
 372         if (gStmRestrictionModeStateNoOff == restriction_mode_state) {
 373             switch (category_no) {
 374             case STM_CTG_NO_HOMESCREEN:
 375                 // Homescreen layer
 376                 g_crr_state.layer[gStmLayerNoHomescreen].state = gStmLayoutNoHs;
 377                 g_crr_state.layer[gStmLayerNoHomescreen].is_changed = STM_TRUE;
 378
 379                 // Apps layer
 380                 if (gStmLayoutNoNone != apps_state) {
 381                     g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoNone;
 382                     g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 383                 }
 384                 break;
 385             case STM_CTG_NO_MAP:
 386                 switch (area_no) {
 387                 case STM_ARA_NO_FULL:
 388                     // Apps layer
 389                     switch (apps_state) {
 390                     case gStmLayoutNoMf:
 391                         // nop
 392                         break;
 393                     default:
 394                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoMf;
 395                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 396                         break;
 397                     }
 398                     break;
 399                 case STM_ARA_NO_NORMAL:
 400                     // Apps layer
 401                     switch (apps_state) {
 402                     case gStmLayoutNoM1:
 403                         // nop
 404                         break;
 405                     case gStmLayoutNoS1:
 406                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 407                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 408                         break;
 409                     default:
 410                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM1;
 411                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 412                     }
 413                     break;
 414                 case STM_ARA_NO_SPLIT_MAIN:
 415                     // Apps layer
 416                     switch (apps_state) {
 417                     case gStmLayoutNoS1:
 418                     case gStmLayoutNoS2:
 419                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 420                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 421                         break;
 422                     default:
 423                         // nop
 424                         break;
 425                     }
 426                     break;
 427                 }
 428                 break;
 429             case STM_CTG_NO_GENERAL:
 430                 switch (area_no) {
 431                 case STM_ARA_NO_NORMAL:
 432                     // Apps layer
 433                     switch (apps_state) {
 434                     case gStmLayoutNoMf:
 435                         // nop
 436                         break;
 437                     default:
 438                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoG;
 439                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 440                         break;
 441                     }
 442                     break;
 443                 default:
 444                     // nop
 445                     break;
 446                 }
 447                 break;
 448             case STM_CTG_NO_SYSTEM:
 449                 switch (area_no) {
 450                 case STM_ARA_NO_NORMAL:
 451                     // Apps layer
 452                     switch (apps_state) {
 453                     case gStmLayoutNoMf:
 454                         // nop
 455                         break;
 456                     default:
 457                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoSystem;
 458                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 459                         break;
 460                     }
 461                     break;
 462                 default:
 463                     // nop
 464                     break;
 465                 }
 466                 break;
 467             case STM_CTG_NO_SPLITABLE:
 468                 switch (area_no) {
 469                 case STM_ARA_NO_NORMAL:
 470                     // Apps layer
 471                     switch (apps_state) {
 472                     case gStmLayoutNoM1:
 473                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 474                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 475                         break;
 476                     case gStmLayoutNoMf:
 477                     case gStmLayoutNoS1:
 478                         // nop
 479                         break;
 480                     default:
 481                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS1;
 482                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 483                         break;
 484                     }
 485                     break;
 486                 case STM_ARA_NO_SPLIT_MAIN:
 487                     // Apps layer
 488                     switch (apps_state) {
 489                     case gStmLayoutNoS1:
 490                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 491                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 492                         break;
 493                     case gStmLayoutNoS2:
 494                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 495                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 496                         break;
 497                     default:
 498                         // nop
 499                         break;
 500                     }
 501                     break;
 502                 case STM_ARA_NO_SPLIT_SUB:
 503                     // Apps layer
 504                     switch (apps_state) {
 505                     case gStmLayoutNoM1:
 506                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 507                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 508                         break;
 509                     case gStmLayoutNoM2:
 510                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 511                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 512                         break;
 513                     case gStmLayoutNoS1:
 514                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 515                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 516                         break;
 517                     case gStmLayoutNoS2:
 518                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 519                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 520                         break;
 521                     default:
 522                         // nop
 523                         break;
 524                     }
 525                     break;
 526                 default:
 527                     // nop
 528                     break;
 529                 }
 530                 break;
 531             default:
 532                 // nop
 533                 break;
 534             }
 535             break;
 536         }
 537         else {  // (gStmRestrictionModeStateNoOn == restriction_mode_state)
 538             switch (category_no) {
 539             case STM_CTG_NO_MAP:
 540                 switch (area_no) {
 541                 case STM_ARA_NO_FULL:
 542                 case STM_ARA_NO_NORMAL:
 543                 case STM_ARA_NO_SPLIT_MAIN:
 544                     // Apps layer
 545                     switch (apps_state) {
 546                     case gStmLayoutNoM1:
 547                         // nop
 548                         break;
 549                     default:
 550                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM1;
 551                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 552                     }
 553                     break;
 554                 }
 555                 break;
 556             case STM_CTG_NO_SYSTEM:
 557                 switch (area_no) {
 558                 case STM_ARA_NO_NORMAL:
 559                     // Apps layer
 560                     switch (apps_state) {
 561                     case gStmLayoutNoMf:
 562                         // nop
 563                         break;
 564                     default:
 565                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoSystem;
 566                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 567                         break;
 568                     }
 569                     break;
 570                 default:
 571                     // nop
 572                     break;
 573                 }
 574                 break;
 575             }
 576         }
 577     case STM_EVT_NO_DEACTIVATE:
 578         switch (category_no) {
 579         default:
 580             // nop
 581             break;
 582         }
 583         break;
 584     default:
 585         // nop
 586         break;
 587     }
 588
 589
 590     // Set restriction layer
 591     if (STM_CTG_NO_RESTRICTION == category_no) {
 592         if (STM_EVT_NO_ACTIVATE == event_no) {
 593             if (gStmLightstatusBrakeStateNoOff == g_crr_state.car_element[gStmCarElementNoLightstatusBrake].state) {
 594                 switch (area_no) {
 595                 case STM_ARA_NO_RESTRICTION_NORMAL:
 596                     switch (restriction_state) {
 597                     case gStmLayoutNoNone:
 598                         if (g_crr_state.layer[gStmLayerNoApps].state == gStmLayoutNoS1) {
 599                             g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestriction;
 600                             g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 601                         }
 602                         break;
 603                     default:
 604                         // nop
 605                         break;
 606                     }
 607                     break;
 608                 case STM_ARA_NO_RESTRICTION_SPLIT_MAIN:
 609                     switch (restriction_state) {
 610                     case gStmLayoutNoNone:
 611                         g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitMain;
 612                         g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 613                         break;
 614                     default:
 615                         // nop
 616                         break;
 617                     }
 618                     break;
 619                 case STM_ARA_NO_RESTRICTION_SPLIT_SUB:
 620                     switch (restriction_state) {
 621                     case gStmLayoutNoNone:
 622                         if (g_crr_state.layer[gStmLayerNoApps].state == gStmLayoutNoM2) {
 623                             g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitSub;
 624                             g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 625                         }
 626                         break;
 627                     default:
 628                         // nop
 629                         break;
 630                     }
 631                     break;
 632                 default:
 633                     // nop
 634                     break;
 635                 }
 636             }
 637         }
 638         else if (STM_EVT_NO_DEACTIVATE == event_no) {
 639             switch (restriction_state) {
 640             case gStmLayoutNoRestriction:
 641             case gStmLayoutNoRestrictionSplitMain:
 642             case gStmLayoutNoRestrictionSplitSub:
 643                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 644                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 645                 break;
 646             default:
 647                 // nop
 648                 break;
 649             }
 650         }
 651     }
 652     else if (g_crr_state.layer[gStmLayerNoApps].is_changed) {
 653         if (gStmLightstatusBrakeStateNoOff == g_crr_state.car_element[gStmCarElementNoLightstatusBrake].state) {
 654             if (gStmLayoutNoM2 == g_crr_state.layer[gStmLayerNoApps].state) {
 655                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitSub;
 656                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 657             }
 658             else if (gStmLayoutNoS1 == g_crr_state.layer[gStmLayerNoApps].state) {
 659                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestriction;
 660                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 661             }
 662             else {
 663                 if (gStmLayoutNoNone != g_crr_state.layer[gStmLayerNoRestriction].state) {
 664                     g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 665                     g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 666                 }
 667             }
 668         }
 669         else {
 670             if (gStmLayoutNoNone != g_crr_state.layer[gStmLayerNoRestriction].state) {
 671                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 672                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 673             }
 674         }
 675     }
 676
 677     // Copy current state for return
 678     memcpy(state, &g_crr_state, sizeof(g_crr_state));
 679
 680     if ((STM_FALSE == g_map_is_activated)
 681         && (STM_TRUE == g_crr_state.layer[gStmLayerNoApps].is_changed)
 682         && ((gStmLayoutNoM1 == g_crr_state.layer[gStmLayerNoApps].state)
 683             || (gStmLayoutNoM2 == g_crr_state.layer[gStmLayerNoApps].state)
 684             || (gStmLayoutNoMf == g_crr_state.layer[gStmLayerNoApps].state))) {
 685         g_map_is_activated = STM_TRUE;
 686     }
 687
 688     return 0;
 689 }
 690
 691 void stmUndoState() {
 692     g_crr_state = g_prv_state;
 693 }