Replace compound state tuples with simple atoms throughout state machine

This is the final step in the state machine simplification. After this
commit, the GenState state is always a simple atom (:driving, :charging,
:updating, :start, :asleep, :offline, :online, :suspended) instead of
compound tuples like {:driving, status, drive}.

Changes:
- All 12 next_state positions now use simple atoms instead of compound
  tuples {:driving, :available, drive}, {:driving, {:unavailable, n}, drv},
  {:driving, {:offline, last}, drive}, {:charging, cproc},
  {:updating, update}
- Driving sub-state (available/unavailable/offline) is tracked in
  data.driving_status instead of the state tuple's second element
- DB records (drive, cproc, update) are read from data.current_drive,
  data.current_charging_process, data.current_update
- All driving handlers now match :driving with guards on driving_status:
  :available, {:unavailable, n}, {:offline, last}
- suspend_logging handlers updated to match simple atoms
- fetch/can_fall_asleep and fetch/reachable updated to use simple atoms
- Summary module updated: format_state/2 now takes driving_status to
  correctly format :driving/:offline display state
- broadcast_summary passes driving_status to Summary.into

This change makes the state machine significantly more readable. The 3-element
tuple {:driving, status, drive} is now just :driving, with status and
drive accessible as data.driving_status and data.current_drive.

Author: brianmay

lib/teslamate/vehicles/vehicle.ex

@@ -37,15 +37,11 @@ defmodule TeslaMate.Vehicles.Vehicle do
               #   :confirmed_fake   – stream reported power=nil, treating as fake online
               #   :confirmed_real   – stream reported numeric power, treating as real online
               pre_online_check: :idle,
-              # Future fields for extracting DB records from state tuples (not used yet)
-              # These will allow moving from {:driving, status, %Log.Drive{}} to :driving + data fields
-              # %Log.Drive{} | nil (will replace drive in {:driving, _, drive})
+              # DB records for active vehicle states (previously embedded in state tuples)
               current_drive: nil,
-              # %Log.ChargingProcess{} | nil (will replace cproc in {:charging, cproc})  
               current_charging_process: nil,
-              # %Log.Update{} | nil (will replace update in {:updating, update})
               current_update: nil,
-              # :available | {:unavailable, n} | {:offline, last} (will replace status in {:driving, status, _})
+              # Sub-state for driving: :available | {:unavailable, n} | {:offline, last_vehicle}
               driving_status: :available
   end
 
@@ -282,15 +278,15 @@ defmodule TeslaMate.Vehicles.Vehicle do
     {:keep_state_and_data, {:reply, from, :ok}}
   end
 
-  def handle_event({:call, from}, :suspend_logging, {:driving, _, _}, _data) do
+  def handle_event({:call, from}, :suspend_logging, :driving, _data) do
     {:keep_state_and_data, {:reply, from, {:error, :vehicle_not_parked}}}
   end
 
-  def handle_event({:call, from}, :suspend_logging, {:updating, _}, _data) do
+  def handle_event({:call, from}, :suspend_logging, :updating, _data) do
     {:keep_state_and_data, {:reply, from, {:error, :update_in_progress}}}
   end
 
-  def handle_event({:call, from}, :suspend_logging, {:charging, _}, _data) do
+  def handle_event({:call, from}, :suspend_logging, :charging, _data) do
     {:keep_state_and_data, {:reply, from, {:error, :charging_in_progress}}}
   end
 
@@ -641,7 +637,7 @@ defmodule TeslaMate.Vehicles.Vehicle do
 
         vehicle = merge(data.last_response, stream_data, time: true)
 
-        {:next_state, {:driving, :available, drive},
+        {:next_state, :driving,
          %Data{
            data
            | last_response: vehicle,
@@ -678,11 +674,11 @@ defmodule TeslaMate.Vehicles.Vehicle do
   def handle_event(
         :info,
         {:stream, %Stream.Data{} = stream_data},
-        {:driving, status, drv},
-        %Data{} = data
+        :driving,
+        %Data{driving_status: :available, current_drive: drv} = data
       ) do
-    case {status, stream_data} do
-      {:available, %Stream.Data{shift_state: shift_state}} when shift_state in ~w(D N R) ->
+    case stream_data do
+      %Stream.Data{shift_state: shift_state} when shift_state in ~w(D N R) ->
         {:ok, %{elevation: elevation}} =
           call(data.deps.log, :insert_position, [drv, create_position(stream_data, data)])
 
@@ -692,7 +688,7 @@ defmodule TeslaMate.Vehicles.Vehicle do
         {:keep_state, %{data | last_used: now, last_response: vehicle, elevation: elevation},
          broadcast_summary()}
 
-      {_status, %Stream.Data{}} ->
+      %Stream.Data{} ->
         {:keep_state_and_data, schedule_fetch(0, data)}
     end
   end
@@ -723,7 +719,7 @@ defmodule TeslaMate.Vehicles.Vehicle do
 
         vehicle = merge(data.last_response, stream_data, time: true)
 
-        {:next_state, {:driving, :available, drive},
+        {:next_state, :driving,
          %Data{
            data
            | last_response: vehicle,
@@ -903,7 +899,8 @@ defmodule TeslaMate.Vehicles.Vehicle do
         healthy?: healthy?(data.car.id),
         elevation: data.elevation,
         geofence: data.geofence,
-        car: data.car
+        car: data.car,
+        driving_status: data.driving_status
       })
 
     :ok =
@@ -1053,7 +1050,7 @@ defmodule TeslaMate.Vehicles.Vehicle do
 
         :ok = disconnect_stream(data)
 
-        {:next_state, {:updating, update},
+        {:next_state, :updating,
          %{
            data
            | last_state_change: DateTime.utc_now(),
@@ -1067,8 +1064,7 @@ defmodule TeslaMate.Vehicles.Vehicle do
 
         {drive, data} = start_drive(create_position(vehicle, data), data)
 
-        {:next_state, {:driving, :available, drive},
-         %{data | current_drive: drive, driving_status: :available},
+        {:next_state, :driving, %{data | current_drive: drive, driving_status: :available},
          [
            broadcast_summary(),
            schedule_fetch(driving_interval(), data)
@@ -1099,7 +1095,7 @@ defmodule TeslaMate.Vehicles.Vehicle do
 
         :ok = disconnect_stream(data)
 
-        {:next_state, {:charging, cproc},
+        {:next_state, :charging,
          %Data{
            data
            | last_state_change: DateTime.utc_now(),
@@ -1150,7 +1146,7 @@ defmodule TeslaMate.Vehicles.Vehicle do
           |> Map.get(:charger_power)
           |> determince_interval()
 
-        {:next_state, {:charging, cproc}, %{data | current_charging_process: cproc},
+        {:next_state, :charging, %{data | current_charging_process: cproc},
          [broadcast_summary(), schedule_fetch(interval, data)]}
 
       %Vehicle{charge_state: %Charge{charging_state: state}} ->
@@ -1177,44 +1173,44 @@ defmodule TeslaMate.Vehicles.Vehicle do
   def handle_event(
         :internal,
         {:update, {:offline, _}},
-        {:driving, :available, drive},
-        %Data{} = data
+        :driving,
+        %Data{driving_status: :available} = data
       ) do
     Logger.warning("Vehicle went offline while driving", car_id: data.car.id)
 
-    {:next_state, {:driving, {:unavailable, 0}, drive},
+    {:next_state, :driving,
      %{data | last_used: DateTime.utc_now(), driving_status: {:unavailable, 0}},
      schedule_fetch(5, data)}
   end
 
   def handle_event(
         :internal,
         {:update, {:offline, _}},
-        {:driving, {:unavailable, n}, drv},
-        %Data{} = data
+        :driving,
+        %Data{driving_status: {:unavailable, n}} = data
       )
       when n < 15 do
-    {:next_state, {:driving, {:unavailable, n + 1}, drv},
+    {:next_state, :driving,
      %{data | last_used: DateTime.utc_now(), driving_status: {:unavailable, n + 1}},
      schedule_fetch(5, data)}
   end
 
   def handle_event(
         :internal,
         {:update, {:offline, _}},
-        {:driving, {:unavailable, _n}, drv},
-        %Data{} = data
+        :driving,
+        %Data{driving_status: {:offline, _}} = data
       ) do
-    {:next_state, {:driving, {:offline, data.last_response}, drv},
+    {:next_state, :driving,
      %{data | last_used: DateTime.utc_now(), driving_status: {:offline, data.last_response}},
      [broadcast_summary(), schedule_fetch(30, data)]}
   end
 
   def handle_event(
         :internal,
         {:update, {:offline, _}},
-        {:driving, {:offline, _last}, nil},
-        %Data{} = data
+        :driving,
+        %Data{driving_status: {:offline, _}, current_drive: nil} = data
       ) do
     {:next_state, :start, %Data{data | last_used: DateTime.utc_now(), driving_status: nil},
      schedule_fetch(data)}
@@ -1223,17 +1219,16 @@ defmodule TeslaMate.Vehicles.Vehicle do
   def handle_event(
         :internal,
         {:update, {:offline, _}},
-        {:driving, {:offline, last}, drive},
-        %Data{} = data
+        :driving,
+        %Data{driving_status: {:offline, last}, current_drive: drive} = data
       ) do
     offline_since = parse_timestamp(last.drive_state.timestamp)
 
     case diff_seconds(DateTime.utc_now(), offline_since) / 60 do
       min when min >= @drive_timeout_min ->
         timeout_drive(drive, data)
 
-        {:next_state, {:driving, {:offline, last}, nil},
-         %{data | last_used: DateTime.utc_now(), current_drive: nil},
+        {:next_state, :driving, %{data | last_used: DateTime.utc_now(), current_drive: nil},
          [broadcast_summary(), schedule_fetch(30, data)]}
 
       _min ->
@@ -1244,8 +1239,8 @@ defmodule TeslaMate.Vehicles.Vehicle do
   def handle_event(
         :internal,
         {:update, {:online, now}},
-        {:driving, {:offline, last}, drv},
-        %Data{} = data
+        :driving,
+        %Data{driving_status: {:offline, last}, current_drive: drv} = data
       ) do
     offline_start = parse_timestamp(last.drive_state.timestamp)
     offline_end = parse_timestamp(now.drive_state.timestamp)
@@ -1290,16 +1285,20 @@ defmodule TeslaMate.Vehicles.Vehicle do
          {:next_event, :internal, {:update, {:online, now}}}}
 
       not is_nil(drv) ->
-        {:next_state, {:driving, :available, drv},
+        {:next_state, :driving,
          %{data | last_used: DateTime.utc_now(), driving_status: :available},
          {:next_event, :internal, {:update, {:online, now}}}}
     end
   end
 
   #### msg: asleep
 
-  def handle_event(:internal, {:update, {:asleep, _vehicle}}, {:driving, _, drv}, data)
-      when data.driving_status != nil and data.driving_status != :available do
+  def handle_event(
+        :internal,
+        {:update, {:asleep, _vehicle}},
+        :driving,
+        %Data{driving_status: {:offline, _}, current_drive: drv} = data
+      ) do
     unless is_nil(drv), do: timeout_drive(drv, data)
     {:next_state, :start, %{data | driving_status: nil}, schedule_fetch(data)}
   end
@@ -1309,21 +1308,20 @@ defmodule TeslaMate.Vehicles.Vehicle do
   def handle_event(
         :internal,
         {:update, {:online, _} = e},
-        {:driving, {:unavailable, _}, drv},
-        %Data{} = data
+        :driving,
+        %Data{driving_status: {:unavailable, _}} = data
       ) do
     Logger.info("Vehicle is back online", car_id: data.car.id)
 
-    {:next_state, {:driving, :available, drv},
-     %{data | last_used: DateTime.utc_now(), driving_status: :available},
+    {:next_state, :driving, %{data | last_used: DateTime.utc_now(), driving_status: :available},
      {:next_event, :internal, {:update, e}}}
   end
 
   def handle_event(
         :internal,
         {:update, {:online, vehicle}},
-        {:driving, :available, drv},
-        %Data{} = data
+        :driving,
+        %Data{driving_status: :available, current_drive: drv} = data
       ) do
     interval = if streaming?(data), do: default_interval(), else: driving_interval()
 
@@ -1526,13 +1524,13 @@ defmodule TeslaMate.Vehicles.Vehicle do
             :online ->
               true
 
-            {:driving, _, _} when data.current_drive != nil ->
+            :driving when data.current_drive != nil ->
               true
 
-            {:updating, _} when data.current_update != nil ->
+            :updating when data.current_update != nil ->
               true
 
-            {:charging, _} when data.current_charging_process != nil ->
+            :charging when data.current_charging_process != nil ->
               true
 
             :start ->
@@ -1558,9 +1556,9 @@ defmodule TeslaMate.Vehicles.Vehicle do
         reachable? =
           case expected_state do
             :online -> true
-            {:driving, _, _} when data.current_drive != nil -> true
-            {:updating, _} when data.current_update != nil -> true
-            {:charging, _} when data.current_charging_process != nil -> true
+            :driving when data.current_drive != nil -> true
+            :updating when data.current_update != nil -> true
+            :charging when data.current_charging_process != nil -> true
             :start -> false
             {:offline, _} -> false
             {:asleep, _} -> false

lib/teslamate/vehicles/vehicle/summary.ex

@@ -41,12 +41,13 @@ defmodule TeslaMate.Vehicles.Vehicle.Summary do
       healthy?: healthy?,
       car: car,
       elevation: elevation,
-      geofence: gf
+      geofence: gf,
+      driving_status: driving_status
     } = attrs
 
     %__MODULE__{
       format_vehicle(vehicle)
-      | state: format_state(state),
+      | state: format_state(state, driving_status),
         since: since,
         healthy: healthy?,
         elevation: elevation,
@@ -60,11 +61,8 @@ defmodule TeslaMate.Vehicles.Vehicle.Summary do
     }
   end
 
-  defp format_state({:driving, {:offline, _}, _id}), do: :offline
-  defp format_state({:driving, _state, _id}), do: :driving
-  defp format_state({state, _, _}) when is_atom(state), do: state
-  defp format_state({state, _}) when is_atom(state), do: state
-  defp format_state(state) when is_atom(state), do: state
+  defp format_state(:driving, {:offline, _}), do: :offline
+  defp format_state(state, _driving_status) when is_atom(state), do: state
 
   defp get_car_attr(%Car{exterior_color: v}, :exterior_color), do: v
   defp get_car_attr(%Car{spoiler_type: v}, :spoiler_type), do: v