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