src/policy_manager/zipc/dummy_stm.c

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