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                 // Apps layer
 348                 g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoNone;
 349                 g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 350
 351                 // Homescreen layer
 352                 g_crr_state.layer[gStmLayerNoHomescreen].state = gStmLayoutNoHs;
 353                 g_crr_state.layer[gStmLayerNoHomescreen].is_changed = STM_TRUE;
 354                 break;
 355             case STM_CTG_NO_MAP:
 356                 switch (area_no) {
 357                 case STM_ARA_NO_FULL:
 358                     // Apps layer
 359                     switch (apps_state) {
 360                     case gStmLayoutNoMf:
 361                         // nop
 362                         break;
 363                     default:
 364                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoMf;
 365                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 366                         break;
 367                     }
 368                     break;
 369                 case STM_ARA_NO_NORMAL:
 370                     // Apps layer
 371                     switch (apps_state) {
 372                     case gStmLayoutNoM1:
 373                         // nop
 374                         break;
 375                     case gStmLayoutNoS1:
 376                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 377                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 378                         break;
 379                     default:
 380                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM1;
 381                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 382                     }
 383                     break;
 384                 case STM_ARA_NO_SPLIT_MAIN:
 385                     // Apps layer
 386                     switch (apps_state) {
 387                     case gStmLayoutNoS1:
 388                     case gStmLayoutNoS2:
 389                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 390                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 391                         break;
 392                     default:
 393                         // nop
 394                         break;
 395                     }
 396                     break;
 397                 }
 398                 break;
 399             case STM_CTG_NO_GENERAL:
 400                 switch (area_no) {
 401                 case STM_ARA_NO_NORMAL:
 402                     // Apps layer
 403                     switch (apps_state) {
 404                     case gStmLayoutNoMf:
 405                         // nop
 406                         break;
 407                     default:
 408                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoG;
 409                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 410                         break;
 411                     }
 412                     break;
 413                 default:
 414                     // nop
 415                     break;
 416                 }
 417                 break;
 418             case STM_CTG_NO_SPLITABLE:
 419                 switch (area_no) {
 420                 case STM_ARA_NO_NORMAL:
 421                     // Apps layer
 422                     switch (apps_state) {
 423                     case gStmLayoutNoM1:
 424                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 425                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 426                         break;
 427                     case gStmLayoutNoMf:
 428                     case gStmLayoutNoS1:
 429                         // nop
 430                         break;
 431                     default:
 432                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS1;
 433                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 434                         break;
 435                     }
 436                     break;
 437                 case STM_ARA_NO_SPLIT_MAIN:
 438                     // Apps layer
 439                     switch (apps_state) {
 440                     case gStmLayoutNoS1:
 441                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 442                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 443                         break;
 444                     case gStmLayoutNoS2:
 445                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 446                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 447                         break;
 448                     default:
 449                         // nop
 450                         break;
 451                     }
 452                     break;
 453                 case STM_ARA_NO_SPLIT_SUB:
 454                     // Apps layer
 455                     switch (apps_state) {
 456                     case gStmLayoutNoM1:
 457                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 458                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 459                         break;
 460                     case gStmLayoutNoM2:
 461                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
 462                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 463                         break;
 464                     case gStmLayoutNoS1:
 465                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 466                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 467                         break;
 468                     case gStmLayoutNoS2:
 469                         g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
 470                         g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
 471                         break;
 472                     default:
 473                         // nop
 474                         break;
 475                     }
 476                     break;
 477                 default:
 478                     // nop
 479                     break;
 480                 }
 481                 break;
 482             default:
 483                 // nop
 484                 break;
 485             }
 486             break;
 487         }
 488     case STM_EVT_NO_DEACTIVATE:
 489         switch (category_no) {
 490         default:
 491             // nop
 492             break;
 493         }
 494         break;
 495     default:
 496         // nop
 497         break;
 498     }
 499
 500
 501     // Set restriction layer
 502     if (STM_CTG_NO_RESTRICTION == category_no) {
 503         if (STM_EVT_NO_ACTIVATE == event_no) {
 504             if (gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state) {
 505                 switch (area_no) {
 506                 case STM_ARA_NO_RESTRICTION_NORMAL:
 507                     switch (restriction_state) {
 508                     case gStmLayoutNoNone:
 509                         if (g_crr_state.layer[gStmLayerNoApps].state == gStmLayoutNoS1) {
 510                             g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestriction;
 511                             g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 512                         }
 513                         break;
 514                     default:
 515                         // nop
 516                         break;
 517                     }
 518                     break;
 519                 case STM_ARA_NO_RESTRICTION_SPLIT_MAIN:
 520                     switch (restriction_state) {
 521                     case gStmLayoutNoNone:
 522                         g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitMain;
 523                         g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 524                         break;
 525                     default:
 526                         // nop
 527                         break;
 528                     }
 529                     break;
 530                 case STM_ARA_NO_RESTRICTION_SPLIT_SUB:
 531                     switch (restriction_state) {
 532                     case gStmLayoutNoNone:
 533                         if (g_crr_state.layer[gStmLayerNoApps].state == gStmLayoutNoM2) {
 534                             g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitSub;
 535                             g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 536                         }
 537                         break;
 538                     default:
 539                         // nop
 540                         break;
 541                     }
 542                     break;
 543                 default:
 544                     // nop
 545                     break;
 546                 }
 547             }
 548         }
 549         else if (STM_EVT_NO_DEACTIVATE == event_no) {
 550             switch (restriction_state) {
 551             case gStmLayoutNoRestriction:
 552             case gStmLayoutNoRestrictionSplitMain:
 553             case gStmLayoutNoRestrictionSplitSub:
 554                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 555                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 556                 break;
 557             default:
 558                 // nop
 559                 break;
 560             }
 561         }
 562     }
 563     else if (g_crr_state.layer[gStmLayerNoApps].is_changed) {
 564         if (gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state) {
 565             if (gStmLayoutNoM2 == g_crr_state.layer[gStmLayerNoApps].state) {
 566                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitSub;
 567                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 568             }
 569             else if (gStmLayoutNoS1 == g_crr_state.layer[gStmLayerNoApps].state) {
 570                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestriction;
 571                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 572             }
 573             else {
 574                 if (gStmLayoutNoNone != g_crr_state.layer[gStmLayerNoRestriction].state) {
 575                     g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 576                     g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 577                 }
 578             }
 579         }
 580         else {
 581             if (gStmLayoutNoNone != g_crr_state.layer[gStmLayerNoRestriction].state) {
 582                 g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
 583                 g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
 584             }
 585         }
 586     }
 587
 588     // Copy current state for return
 589     memcpy(state, &g_crr_state, sizeof(g_crr_state));
 590
 591     if ((STM_FALSE == g_map_is_activated)
 592         && (STM_TRUE == g_crr_state.layer[gStmLayerNoApps].is_changed)
 593         && ((gStmLayoutNoM1 == g_crr_state.layer[gStmLayerNoApps].state)
 594             || (gStmLayoutNoM2 == g_crr_state.layer[gStmLayerNoApps].state)
 595             || (gStmLayoutNoMf == g_crr_state.layer[gStmLayerNoApps].state))) {
 596         g_map_is_activated = STM_TRUE;
 597     }
 598
 599     return 0;
 600 }