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