src/policy_manager/zipc/dummy_stm.c

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