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