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