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